hexsha stringlengths 40 40 | size int64 19 11.4M | ext stringclasses 13
values | lang stringclasses 1
value | max_stars_repo_path stringlengths 3 270 | max_stars_repo_name stringlengths 5 110 | max_stars_repo_head_hexsha stringlengths 40 40 | max_stars_repo_licenses listlengths 1 9 | max_stars_count float64 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 3 270 | max_issues_repo_name stringlengths 5 116 | max_issues_repo_head_hexsha stringlengths 40 78 | max_issues_repo_licenses listlengths 1 9 | max_issues_count float64 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 3 270 | max_forks_repo_name stringlengths 5 116 | max_forks_repo_head_hexsha stringlengths 40 78 | max_forks_repo_licenses listlengths 1 9 | max_forks_count float64 1 105k ⌀ | max_forks_repo_forks_event_min_datetime stringlengths 24 24 ⌀ | max_forks_repo_forks_event_max_datetime stringlengths 24 24 ⌀ | content stringlengths 19 11.4M | avg_line_length float64 1.93 229k | max_line_length int64 12 688k | alphanum_fraction float64 0.07 0.99 | matches listlengths 1 10 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
a6fd7c8d7be8b550699d91f14abf5c4fb231a014 | 12,226 | cpp | C++ | Lux.cpp | GuMiner/lux | ea8ee83fe88dc2905ba80dcc9082cddfb835f739 | [
"MIT"
] | null | null | null | Lux.cpp | GuMiner/lux | ea8ee83fe88dc2905ba80dcc9082cddfb835f739 | [
"MIT"
] | null | null | null | Lux.cpp | GuMiner/lux | ea8ee83fe88dc2905ba80dcc9082cddfb835f739 | [
"MIT"
] | null | null | null | #include <sstream>
#include <string>
#include <glm\gtx\transform.hpp>
#include <SFML\System.hpp>
#include "logging\Logger.h"
#include "filters\IQSpectrum.h"
#include "filters\FrequencySpectrum.h"
#include "Input.h"
#include "LineRenderer.h"
#include "PointRenderer.h"
#include "version.h"
#include "Lux.h"
#pragma comment(lib, "opengl32")
#pragma comment(lib, "lib/glfw3.lib")
#pragma comment(lib, "lib/glew32.lib")
#pragma comment(lib, "lib/sfml-audio")
#pragma comment(lib, "lib/sfml-system")
Lux::Lux()
: shaderFactory(), sentenceManager(), viewer(),
sdr(), dataBuffer(&sdr, 0, 30), // TODO config somewhere, with device ID passed in somewhere else
fpsTimeAggregated(0.0f), fpsFramesCounted(0)
{
}
void Lux::LogSystemSetup()
{
Logger::Log("OpenGL vendor: ", glGetString(GL_VENDOR), ", version ", glGetString(GL_VERSION), ", renderer ", glGetString(GL_RENDERER));
Logger::Log("OpenGL extensions: ", glGetString(GL_EXTENSIONS));
GLint maxTextureUnits, maxUniformBlockSize;
GLint maxVertexUniformBlocks, maxFragmentUniformBlocks;
GLint maxTextureSize;
glGetIntegerv(GL_MAX_TEXTURE_UNITS, &maxTextureUnits);
glGetIntegerv(GL_MAX_VERTEX_UNIFORM_BLOCKS, &maxVertexUniformBlocks);
glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_BLOCKS, &maxFragmentUniformBlocks);
glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &maxUniformBlockSize);
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
Logger::Log("Max Texture Units: ", maxTextureUnits, ", Max Uniform Size: ", (maxUniformBlockSize / 1024), " kB");
Logger::Log("Max Vertex Uniform Blocks: ", maxVertexUniformBlocks, ", Max Fragment Uniform Blocks: ", maxFragmentUniformBlocks);
Logger::Log("Max Texture Size: ", maxTextureSize);
}
bool Lux::LoadCoreGlslGraphics()
{
// 24 depth bits, 8 stencil bits, 8x AA, major version 4.
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
glfwWindowHint(GLFW_DEPTH_BITS, 16);
glfwWindowHint(GLFW_STENCIL_BITS, 16);
glfwWindowHint(GLFW_SAMPLES, 8);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
window = glfwCreateWindow(viewer.ScreenWidth, viewer.ScreenHeight, "Lux", nullptr, nullptr);
if (!window)
{
Logger::LogError("Could not create the GLFW window!");
return false;
}
glfwMakeContextCurrent(window);
glfwSwapInterval(1);
Input::Setup(window, &viewer);
// Setup GLEW
GLenum err = glewInit();
if (err != GLEW_OK)
{
Logger::LogError("GLEW startup failure: ", err, ".");
return false;
}
// Log graphics information for future reference
LogSystemSetup();
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// Enable alpha blending
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// Enable line, but not polygon smoothing.
glEnable(GL_LINE_SMOOTH);
// Let OpenGL shaders determine point sizes.
glEnable(GL_PROGRAM_POINT_SIZE);
// Disable face culling so that see-through flat objects and stuff at 1.0 (cube map, text) work.
glDisable(GL_CULL_FACE);
glFrontFace(GL_CW);
// Cutout faces that are hidden by other faces.
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
//// Setup any core assets ////
if (!sentenceManager.LoadFont(&shaderFactory, "fonts/DejaVuSans.ttf"))
{
Logger::LogError("Font loading failure!");
return false;
}
if (!PointRenderer::LoadProgram(&shaderFactory))
{
Logger::LogError("Could not load the point rendering program!");
return false;
}
if (!LineRenderer::LoadProgram(&shaderFactory))
{
Logger::LogError("Could not load the line rendering program!");
return false;
}
return true;
}
bool Lux::Initialize()
{
if (!sdr.Initialize())
{
Logger::LogError("SDR startup failure!");
return false;
}
// Note we don't need to remove the device as deletion will handle that for us.
Logger::Log("Open device: ", sdr.OpenDevice(0));
Logger::Log("Setting center frequency: ", sdr.SetCenterFrequency(0, 106100000)); // 452, 734, 0 89,500,0, 106,100,0
Logger::Log("Setting sampling rate to max w/o dropped packets: ", sdr.SetSampleRate(0, 2400000));
Logger::Log("Setting bandwidth to sampling rate to use quadrature sampling: ", sdr.SetTunerBandwidth(0, 2400000));
Logger::Log("Setting auto-gain off: Tuner: ", sdr.SetTunerGainMode(0, true), " Internal: ", sdr.SetInternalAutoGain(0, false));
Logger::Log("Setting gain of tuner: ", sdr.SetTunerGain(0, 0));
dataBuffer.StartAcquisition();
// Setup GLFW
if (!glfwInit())
{
Logger::LogError("GLFW startup failure");
return false;
}
return true;
}
void Lux::Deinitialize()
{
dataBuffer.StopAcquisition();
glfwTerminate();
}
void Lux::HandleEvents(bool& focusPaused, bool& escapePaused)
{
glfwPollEvents();
focusPaused = !Input::hasFocus;
escapePaused = Input::IsKeyTyped(GLFW_KEY_ESCAPE);
}
void Lux::UpdateFps(float frameTime)
{
++fpsFramesCounted;
fpsTimeAggregated += frameTime;
if (fpsTimeAggregated > 1.0f)
{
std::stringstream framerate;
framerate << "FPS: " << (float)((float)fpsFramesCounted / fpsTimeAggregated);
sentenceManager.UpdateSentence(fpsSentenceId, framerate.str());
fpsTimeAggregated = 0;
fpsFramesCounted = 0;
}
}
// TODO hacky code to remove with a redesign. Still prototyping here...
int gainId = 0;
void Lux::Update(float currentTime, float frameTime)
{
viewer.Update(frameTime);
glm::vec2 screenPos = viewer.GetGridPos(Input::GetMousePos());
std::stringstream mousePos;
mousePos << screenPos.x << ", " << screenPos.y;
sentenceManager.UpdateSentence(mouseToolTipSentenceId, mousePos.str());
std::stringstream speed;
speed << "Rate: " << dataBuffer.GetCurrentSampleRate();
sentenceManager.UpdateSentence(dataSpeedSentenceId, speed.str());
UpdateFps(frameTime);
if (Input::IsKeyTyped(GLFW_KEY_UP))
{
++gainId;
gainId = std::min((int)sdr.GetTunerGainSettings(0).size() - 1, gainId);
Logger::Log("Setting gain of tuner to ID ", gainId, ": ", sdr.SetTunerGain(0, gainId));
}
else if (Input::IsKeyTyped(GLFW_KEY_DOWN))
{
--gainId;
gainId = std::max(gainId, 0);
Logger::Log("Setting gain of tuner to ID ", gainId, ": ", sdr.SetTunerGain(0, gainId));
}
// Update our panes.
fourierTransformPane->Update(currentTime, frameTime);
iqSpectrumPane->Update(currentTime, frameTime);
spectrumPane->Update(currentTime, frameTime);
}
void Lux::Render(glm::mat4& viewMatrix)
{
glm::mat4 projectionMatrix = viewer.perspectiveMatrix * viewMatrix;
// Clear the screen (and depth buffer) before any rendering begins.
const GLfloat color[] = { 0, 0, 0, 1 };
const GLfloat one = 1.0f;
glClearBufferfv(GL_COLOR, 0, color);
glClearBufferfv(GL_DEPTH, 0, &one);
// Render the FPS and our current data transfer rate in the upper-left corner.
float dataSpeedHeight = sentenceManager.GetSentenceDimensions(dataSpeedSentenceId).y;
float fpsHeight = sentenceManager.GetSentenceDimensions(fpsSentenceId).y;
sentenceManager.RenderSentence(fpsSentenceId, viewer.perspectiveMatrix, glm::translate(glm::vec3(-viewer.GetXSize() / 2.0f, viewer.GetYSize() / 2.0f - (dataSpeedHeight + fpsHeight), 0.0f)) * viewMatrix);
sentenceManager.RenderSentence(dataSpeedSentenceId, viewer.perspectiveMatrix, glm::translate(glm::vec3(-viewer.GetXSize() / 2.0f, viewer.GetYSize() / 2.0f - dataSpeedHeight, 0.0f)) * viewMatrix);
// Render our mouse tool tip ... at the mouse
glm::vec2 screenPos = viewer.GetGridPos(Input::GetMousePos());
sentenceManager.RenderSentence(mouseToolTipSentenceId, viewer.perspectiveMatrix, glm::translate(glm::vec3(screenPos.x, screenPos.y, 0.0f)) * viewMatrix);
// Render all our filters.
// iqFilter->Render(projectionMatrix); // render the IQ one only.
// for (FilterBase* filter : filters)
// {
// filter->Render(projectionMatrix);
// }
// Render the panes
fourierTransformPane->Render(projectionMatrix, viewer.perspectiveMatrix, viewMatrix);
iqSpectrumPane->Render(projectionMatrix, viewer.perspectiveMatrix, viewMatrix);
spectrumPane->Render(projectionMatrix, viewer.perspectiveMatrix, viewMatrix);
}
bool Lux::LoadGraphics()
{
if (!LoadCoreGlslGraphics())
{
return false;
}
// TODO test code remove
fpsSentenceId = sentenceManager.CreateNewSentence();
sentenceManager.UpdateSentence(fpsSentenceId, "FPS:", 14, glm::vec3(1.0f, 1.0f, 1.0f));
dataSpeedSentenceId = sentenceManager.CreateNewSentence();
sentenceManager.UpdateSentence(dataSpeedSentenceId, "Speed: ", 14, glm::vec3(1.0f, 1.0f, 1.0f));
mouseToolTipSentenceId = sentenceManager.CreateNewSentence();
sentenceManager.UpdateSentence(mouseToolTipSentenceId, "(?,?)", 12, glm::vec3(1.0f, 1.0f, 1.0f));
glm::vec2 panePos = glm::vec2(-60.0f, -30.0f);
glm::vec2 paneSize = glm::vec2(30.0f, 30.0f);
fourierFilter = new FrequencySpectrum(panePos, paneSize, &dataBuffer);
fourierTransformPane = new Pane(panePos, paneSize, &viewer, &sentenceManager, fourierFilter);
panePos = glm::vec2(-29.0f, -30.0f);
iqSpectrum = new IQSpectrum(panePos, paneSize, &dataBuffer);
iqSpectrumPane = new Pane(panePos, paneSize, &viewer, &sentenceManager, iqSpectrum);
panePos = glm::vec2(2.0f, -30.0f);
spectrum = new Spectrum(panePos, paneSize, &dataBuffer);
spectrumPane = new Pane(panePos, paneSize, &viewer, &sentenceManager, spectrum);
audioExporter = new AudioExporter(&dataBuffer);
return true;
}
void Lux::UnloadGraphics()
{
delete fourierTransformPane;
delete fourierFilter;
delete iqSpectrumPane;
delete iqSpectrum;
delete spectrumPane;
delete spectrum;
delete audioExporter;
glfwDestroyWindow(window);
window = nullptr;
}
bool Lux::Run()
{
sf::Clock clock;
sf::Clock frameClock;
sf::Time clockStartTime;
bool focusPaused = false;
bool escapePaused = false;
while (!glfwWindowShouldClose(window))
{
clockStartTime = clock.getElapsedTime();
float frameTime = std::min(frameClock.restart().asSeconds(), 0.06f);
HandleEvents(focusPaused, escapePaused);
// Run the game and render if not paused.
if (!focusPaused && !escapePaused)
{
float gameTime = clock.getElapsedTime().asSeconds();
Update(gameTime, frameTime);
Render(viewer.viewMatrix);
glfwSwapBuffers(window);
}
// Delay to run approximately at our maximum framerate.
sf::Int64 sleepDelay = ((long)1e6 / viewer.MaxFramerate) - (long)(frameTime * 1e6);
if (sleepDelay > 0)
{
sf::sleep(sf::microseconds(sleepDelay));
}
}
return true;
}
int main()
{
Logger::Setup("lux-log.log", true);
Logger::Log("Lux ", AutoVersion::MAJOR_VERSION, ".", AutoVersion::MINOR_VERSION);
Lux* lux = new Lux();
if (!lux->Initialize())
{
Logger::LogError("Lux initialization failed!");
}
else
{
Logger::Log("Basic Initialization complete!");
if (!lux->LoadGraphics())
{
Logger::LogError("Lux graphics initialization failed!");
}
else
{
Logger::Log("Graphics Initialized!");
if (!lux->Run())
{
Logger::LogError("Lux operation failed!");
}
lux->UnloadGraphics();
}
lux->Deinitialize();
}
delete lux;
Logger::Log("Done.");
Logger::Shutdown();
return 0;
} | 33.313351 | 208 | 0.651889 | [
"render",
"transform"
] |
4706e241d4a3f89f98f031a0b5e989af0927f9f8 | 64,940 | cpp | C++ | arangod/V8Server/v8-vocindex.cpp | morsdatum/ArangoDB | 9cfc6d5cd50b8f451ebdedd77e2c5257fa72a573 | [
"Apache-2.0"
] | null | null | null | arangod/V8Server/v8-vocindex.cpp | morsdatum/ArangoDB | 9cfc6d5cd50b8f451ebdedd77e2c5257fa72a573 | [
"Apache-2.0"
] | null | null | null | arangod/V8Server/v8-vocindex.cpp | morsdatum/ArangoDB | 9cfc6d5cd50b8f451ebdedd77e2c5257fa72a573 | [
"Apache-2.0"
] | null | null | null | ////////////////////////////////////////////////////////////////////////////////
/// @brief V8-vocbase bridge
///
/// @file
///
/// DISCLAIMER
///
/// Copyright 2014 ArangoDB GmbH, Cologne, Germany
/// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany
///
/// 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.
///
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
///
/// @author Dr. Frank Celler
/// @author Copyright 2014, ArangoDB GmbH, Cologne, Germany
/// @author Copyright 2011-2013, triAGENS GmbH, Cologne, Germany
////////////////////////////////////////////////////////////////////////////////
#include "v8-vocindex.h"
#include "v8-vocbase.h"
#include "v8-vocbaseprivate.h"
#include "v8-collection.h"
#include "Basics/conversions.h"
#include "V8/v8-conv.h"
#include "Utils/transactions.h"
#include "Utils/V8TransactionContext.h"
#include "CapConstraint/cap-constraint.h"
#include "V8/v8-utils.h"
using namespace std;
using namespace triagens::basics;
using namespace triagens::arango;
using namespace triagens::rest;
////////////////////////////////////////////////////////////////////////////////
/// @brief extract the unique flag from the data
////////////////////////////////////////////////////////////////////////////////
bool ExtractBoolFlag (v8::Handle<v8::Object> const obj,
char const* name,
bool defaultValue) {
// extract unique flag
if (obj->Has(TRI_V8_SYMBOL(name))) {
return TRI_ObjectToBoolean(obj->Get(TRI_V8_SYMBOL(name)));
}
return defaultValue;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief checks if argument is an index identifier
////////////////////////////////////////////////////////////////////////////////
static bool IsIndexHandle (v8::Handle<v8::Value> const arg,
string& collectionName,
TRI_idx_iid_t& iid) {
TRI_ASSERT(collectionName.empty());
TRI_ASSERT(iid == 0);
if (arg->IsNumber()) {
// numeric index id
iid = (TRI_idx_iid_t) arg->ToNumber()->Value();
return true;
}
if (! arg->IsString()) {
return false;
}
v8::String::Utf8Value str(arg);
if (*str == 0) {
return false;
}
size_t split;
if (TRI_ValidateIndexIdIndex(*str, &split)) {
collectionName = string(*str, split);
iid = TRI_UInt64String2(*str + split + 1, str.length() - split - 1);
return true;
}
if (TRI_ValidateIdIndex(*str)) {
iid = TRI_UInt64String2(*str, str.length());
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the index representation
////////////////////////////////////////////////////////////////////////////////
static v8::Handle<v8::Value> IndexRep (string const& collectionName,
TRI_json_t const* idx) {
v8::HandleScope scope;
TRI_ASSERT(idx != nullptr);
v8::Handle<v8::Object> rep = TRI_ObjectJson(idx)->ToObject();
string iid = TRI_ObjectToString(rep->Get(TRI_V8_SYMBOL("id")));
string const id = collectionName + TRI_INDEX_HANDLE_SEPARATOR_STR + iid;
rep->Set(TRI_V8_SYMBOL("id"), v8::String::New(id.c_str(), (int) id.size()));
return scope.Close(rep);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief process the fields list and add them to the json
////////////////////////////////////////////////////////////////////////////////
int ProcessIndexFields (v8::Handle<v8::Object> const obj,
TRI_json_t* json,
int numFields,
bool create) {
set<string> fields;
v8::Handle<v8::String> fieldsString = v8::String::New("fields");
if (obj->Has(fieldsString) && obj->Get(fieldsString)->IsArray()) {
// "fields" is a list of fields
v8::Handle<v8::Array> fieldList = v8::Handle<v8::Array>::Cast(obj->Get(fieldsString));
uint32_t const n = fieldList->Length();
for (uint32_t i = 0; i < n; ++i) {
if (! fieldList->Get(i)->IsString()) {
return TRI_ERROR_BAD_PARAMETER;
}
string const f = TRI_ObjectToString(fieldList->Get(i));
if (f.empty() || (create && f[0] == '_')) {
// accessing internal attributes is disallowed
return TRI_ERROR_BAD_PARAMETER;
}
if (fields.find(f) != fields.end()) {
// duplicate attribute name
return TRI_ERROR_BAD_PARAMETER;
}
fields.insert(f);
}
}
if (fields.empty() ||
(numFields > 0 && (int) fields.size() != numFields)) {
return TRI_ERROR_BAD_PARAMETER;
}
TRI_json_t* fieldJson = TRI_ObjectToJson(obj->Get(TRI_V8_SYMBOL("fields")));
if (fieldJson == nullptr) {
return TRI_ERROR_OUT_OF_MEMORY;
}
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "fields", fieldJson);
return TRI_ERROR_NO_ERROR;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief process the geojson flag and add it to the json
////////////////////////////////////////////////////////////////////////////////
int ProcessIndexGeoJsonFlag (v8::Handle<v8::Object> const obj,
TRI_json_t* json) {
bool geoJson = ExtractBoolFlag(obj, "geoJson", false);
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "geoJson", TRI_CreateBooleanJson(TRI_UNKNOWN_MEM_ZONE, geoJson));
return TRI_ERROR_NO_ERROR;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief process the unique flag and add it to the json
////////////////////////////////////////////////////////////////////////////////
int ProcessIndexUniqueFlag (v8::Handle<v8::Object> const obj,
TRI_json_t* json,
bool fillConstraint = false) {
bool unique = ExtractBoolFlag(obj, "unique", false);
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "unique", TRI_CreateBooleanJson(TRI_UNKNOWN_MEM_ZONE, unique));
if (fillConstraint) {
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "constraint", TRI_CreateBooleanJson(TRI_UNKNOWN_MEM_ZONE, unique));
}
return TRI_ERROR_NO_ERROR;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief process the ignoreNull flag and add it to the json
////////////////////////////////////////////////////////////////////////////////
int ProcessIndexIgnoreNullFlag (v8::Handle<v8::Object> const obj,
TRI_json_t* json) {
bool ignoreNull = ExtractBoolFlag(obj, "ignoreNull", false);
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "ignoreNull", TRI_CreateBooleanJson(TRI_UNKNOWN_MEM_ZONE, ignoreNull));
return TRI_ERROR_NO_ERROR;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief process the undefined flag and add it to the json
////////////////////////////////////////////////////////////////////////////////
int ProcessIndexUndefinedFlag (v8::Handle<v8::Object> const obj,
TRI_json_t* json) {
bool undefined = ExtractBoolFlag(obj, "undefined", false);
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "undefined", TRI_CreateBooleanJson(TRI_UNKNOWN_MEM_ZONE, undefined));
return TRI_ERROR_NO_ERROR;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief enhances the json of a geo1 index
////////////////////////////////////////////////////////////////////////////////
static int EnhanceJsonIndexGeo1 (v8::Handle<v8::Object> const obj,
TRI_json_t* json,
bool create) {
int res = ProcessIndexFields(obj, json, 1, create);
ProcessIndexUniqueFlag(obj, json, true);
ProcessIndexIgnoreNullFlag(obj, json);
ProcessIndexGeoJsonFlag(obj, json);
return res;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief enhances the json of a geo2 index
////////////////////////////////////////////////////////////////////////////////
static int EnhanceJsonIndexGeo2 (v8::Handle<v8::Object> const obj,
TRI_json_t* json,
bool create) {
int res = ProcessIndexFields(obj, json, 2, create);
ProcessIndexUniqueFlag(obj, json, true);
ProcessIndexIgnoreNullFlag(obj, json);
return res;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief enhances the json of a hash index
////////////////////////////////////////////////////////////////////////////////
static int EnhanceJsonIndexHash (v8::Handle<v8::Object> const obj,
TRI_json_t* json,
bool create) {
int res = ProcessIndexFields(obj, json, 0, create);
ProcessIndexUniqueFlag(obj, json);
return res;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief enhances the json of a skiplist index
////////////////////////////////////////////////////////////////////////////////
static int EnhanceJsonIndexSkiplist (v8::Handle<v8::Object> const obj,
TRI_json_t* json,
bool create) {
int res = ProcessIndexFields(obj, json, 0, create);
ProcessIndexUniqueFlag(obj, json);
return res;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief enhances the json of a fulltext index
////////////////////////////////////////////////////////////////////////////////
static int EnhanceJsonIndexFulltext (v8::Handle<v8::Object> const obj,
TRI_json_t* json,
bool create) {
int res = ProcessIndexFields(obj, json, 1, create);
// handle "minLength" attribute
int minWordLength = TRI_FULLTEXT_MIN_WORD_LENGTH_DEFAULT;
if (obj->Has(TRI_V8_SYMBOL("minLength")) && obj->Get(TRI_V8_SYMBOL("minLength"))->IsNumber()) {
minWordLength = (int) TRI_ObjectToInt64(obj->Get(TRI_V8_SYMBOL("minLength")));
}
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "minLength", TRI_CreateNumberJson(TRI_UNKNOWN_MEM_ZONE, minWordLength));
return res;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief enhances the json of a cap constraint
////////////////////////////////////////////////////////////////////////////////
static int EnhanceJsonIndexCap (v8::Handle<v8::Object> const obj,
TRI_json_t* json) {
// handle "size" attribute
size_t count = 0;
if (obj->Has(TRI_V8_SYMBOL("size")) && obj->Get(TRI_V8_SYMBOL("size"))->IsNumber()) {
int64_t value = TRI_ObjectToInt64(obj->Get(TRI_V8_SYMBOL("size")));
if (value < 0 || value > UINT32_MAX) {
return TRI_ERROR_BAD_PARAMETER;
}
count = (size_t) value;
}
// handle "byteSize" attribute
int64_t byteSize = 0;
if (obj->Has(TRI_V8_SYMBOL("byteSize")) && obj->Get(TRI_V8_SYMBOL("byteSize"))->IsNumber()) {
byteSize = TRI_ObjectToInt64(obj->Get(TRI_V8_SYMBOL("byteSize")));
}
if (count == 0 && byteSize <= 0) {
return TRI_ERROR_BAD_PARAMETER;
}
if (byteSize < 0 || (byteSize > 0 && byteSize < TRI_CAP_CONSTRAINT_MIN_SIZE)) {
return TRI_ERROR_BAD_PARAMETER;
}
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "size", TRI_CreateNumberJson(TRI_UNKNOWN_MEM_ZONE, (double) count));
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "byteSize", TRI_CreateNumberJson(TRI_UNKNOWN_MEM_ZONE, (double) byteSize));
return TRI_ERROR_NO_ERROR;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief enhances the json of an index
////////////////////////////////////////////////////////////////////////////////
static int EnhanceIndexJson (v8::Arguments const& argv,
TRI_json_t*& json,
bool create) {
v8::Handle<v8::Object> obj = argv[0].As<v8::Object>();
// extract index type
TRI_idx_type_e type = TRI_IDX_TYPE_UNKNOWN;
if (obj->Has(TRI_V8_SYMBOL("type")) && obj->Get(TRI_V8_SYMBOL("type"))->IsString()) {
TRI_Utf8ValueNFC typeString(TRI_UNKNOWN_MEM_ZONE, obj->Get(TRI_V8_SYMBOL("type")));
if (*typeString == 0) {
return TRI_ERROR_OUT_OF_MEMORY;
}
string t(*typeString);
// rewrite type "geo" into either "geo1" or "geo2", depending on the number of fields
if (t == "geo") {
t = "geo1";
if (obj->Has(TRI_V8_SYMBOL("fields")) && obj->Get(TRI_V8_SYMBOL("fields"))->IsArray()) {
v8::Handle<v8::Array> f = v8::Handle<v8::Array>::Cast(obj->Get(TRI_V8_SYMBOL("fields")));
if (f->Length() == 2) {
t = "geo2";
}
}
}
type = TRI_TypeIndex(t.c_str());
}
if (type == TRI_IDX_TYPE_UNKNOWN) {
return TRI_ERROR_BAD_PARAMETER;
}
if (create) {
if (type == TRI_IDX_TYPE_PRIMARY_INDEX ||
type == TRI_IDX_TYPE_EDGE_INDEX) {
// creating these indexes yourself is forbidden
return TRI_ERROR_FORBIDDEN;
}
}
json = TRI_CreateArrayJson(TRI_UNKNOWN_MEM_ZONE);
if (json == nullptr) {
return TRI_ERROR_OUT_OF_MEMORY;
}
if (obj->Has(TRI_V8_SYMBOL("id"))) {
uint64_t id = TRI_ObjectToUInt64(obj->Get(TRI_V8_SYMBOL("id")), true);
if (id > 0) {
char* idString = TRI_StringUInt64(id);
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "id", TRI_CreateStringCopyJson(TRI_UNKNOWN_MEM_ZONE, idString));
TRI_FreeString(TRI_CORE_MEM_ZONE, idString);
}
}
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE,
json,
"type",
TRI_CreateStringCopyJson(TRI_UNKNOWN_MEM_ZONE, TRI_TypeNameIndex(type)));
int res = TRI_ERROR_INTERNAL;
switch (type) {
case TRI_IDX_TYPE_UNKNOWN:
case TRI_IDX_TYPE_PRIORITY_QUEUE_INDEX: {
res = TRI_ERROR_BAD_PARAMETER;
break;
}
case TRI_IDX_TYPE_PRIMARY_INDEX:
case TRI_IDX_TYPE_EDGE_INDEX:
case TRI_IDX_TYPE_BITARRAY_INDEX: {
break;
}
case TRI_IDX_TYPE_GEO1_INDEX:
res = EnhanceJsonIndexGeo1(obj, json, create);
break;
case TRI_IDX_TYPE_GEO2_INDEX:
res = EnhanceJsonIndexGeo2(obj, json, create);
break;
case TRI_IDX_TYPE_HASH_INDEX:
res = EnhanceJsonIndexHash(obj, json, create);
break;
case TRI_IDX_TYPE_SKIPLIST_INDEX:
res = EnhanceJsonIndexSkiplist(obj, json, create);
break;
case TRI_IDX_TYPE_FULLTEXT_INDEX:
res = EnhanceJsonIndexFulltext(obj, json, create);
break;
case TRI_IDX_TYPE_CAP_CONSTRAINT:
res = EnhanceJsonIndexCap(obj, json);
break;
}
return res;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief ensures an index, coordinator case
////////////////////////////////////////////////////////////////////////////////
static v8::Handle<v8::Value> EnsureIndexCoordinator (TRI_vocbase_col_t const* collection,
TRI_json_t const* json,
bool create) {
v8::HandleScope scope;
TRI_ASSERT(collection != 0);
TRI_ASSERT(json != 0);
string const databaseName(collection->_dbName);
string const cid = StringUtils::itoa(collection->_cid);
// TODO: protect against races on _name
string const collectionName(collection->_name);
TRI_json_t* resultJson = 0;
string errorMsg;
int res = ClusterInfo::instance()->ensureIndexCoordinator(databaseName,
cid,
json,
create,
&IndexComparator,
resultJson,
errorMsg,
360.0);
if (res != TRI_ERROR_NO_ERROR) {
TRI_V8_EXCEPTION_MESSAGE(scope, res, errorMsg);
}
if (resultJson == 0) {
if (! create) {
// did not find a suitable index
return scope.Close(v8::Null());
}
TRI_V8_EXCEPTION_MEMORY(scope);
}
v8::Handle<v8::Value> ret = IndexRep(collectionName, resultJson);
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, resultJson);
return scope.Close(ret);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief ensures an index, locally
////////////////////////////////////////////////////////////////////////////////
static v8::Handle<v8::Value> EnsureIndexLocal (TRI_vocbase_col_t const* collection,
TRI_json_t const* json,
bool create) {
v8::HandleScope scope;
TRI_ASSERT(collection != nullptr);
TRI_ASSERT(json != nullptr);
// extract type
TRI_json_t* value = TRI_LookupArrayJson(json, "type");
TRI_ASSERT(TRI_IsStringJson(value));
TRI_idx_type_e type = TRI_TypeIndex(value->_value._string.data);
// extract unique
bool unique = false;
value = TRI_LookupArrayJson(json, "unique");
if (TRI_IsBooleanJson(value)) {
unique = value->_value._boolean;
}
TRI_vector_pointer_t attributes;
TRI_InitVectorPointer(&attributes, TRI_CORE_MEM_ZONE);
TRI_vector_pointer_t values;
TRI_InitVectorPointer(&values, TRI_CORE_MEM_ZONE);
// extract id
TRI_idx_iid_t iid = 0;
value = TRI_LookupArrayJson(json, "id");
if (TRI_IsStringJson(value)) {
iid = TRI_UInt64String2(value->_value._string.data, value->_value._string.length - 1);
}
// extract fields
value = TRI_LookupArrayJson(json, "fields");
if (TRI_IsListJson(value)) {
// note: "fields" is not mandatory for all index types
// copy all field names (attributes)
for (size_t i = 0; i < value->_value._objects._length; ++i) {
TRI_json_t const* v = static_cast<TRI_json_t const*>(TRI_AtVector(&value->_value._objects, i));
TRI_ASSERT(TRI_IsStringJson(v));
TRI_PushBackVectorPointer(&attributes, v->_value._string.data);
}
}
SingleCollectionReadOnlyTransaction trx(new V8TransactionContext(true), collection->_vocbase, collection->_cid);
int res = trx.begin();
if (res != TRI_ERROR_NO_ERROR) {
TRI_DestroyVectorPointer(&values);
TRI_DestroyVectorPointer(&attributes);
TRI_V8_EXCEPTION(scope, res);
}
TRI_document_collection_t* document = trx.documentCollection();
const string collectionName = string(collection->_name);
// disallow index creation in read-only mode
if (! TRI_IsSystemNameCollection(collectionName.c_str())
&& create
&& TRI_GetOperationModeServer() == TRI_VOCBASE_MODE_NO_CREATE) {
TRI_V8_EXCEPTION(scope, TRI_ERROR_ARANGO_READ_ONLY);
}
bool created = false;
TRI_index_t* idx = 0;
switch (type) {
case TRI_IDX_TYPE_UNKNOWN:
case TRI_IDX_TYPE_PRIMARY_INDEX:
case TRI_IDX_TYPE_EDGE_INDEX:
case TRI_IDX_TYPE_PRIORITY_QUEUE_INDEX:
case TRI_IDX_TYPE_BITARRAY_INDEX: {
// these indexes cannot be created directly
TRI_V8_EXCEPTION(scope, TRI_ERROR_INTERNAL);
}
case TRI_IDX_TYPE_GEO1_INDEX: {
TRI_ASSERT(attributes._length == 1);
bool ignoreNull = false;
TRI_json_t* value = TRI_LookupArrayJson(json, "ignoreNull");
if (TRI_IsBooleanJson(value)) {
ignoreNull = value->_value._boolean;
}
bool geoJson = false;
value = TRI_LookupArrayJson(json, "geoJson");
if (TRI_IsBooleanJson(value)) {
geoJson = value->_value._boolean;
}
if (create) {
idx = TRI_EnsureGeoIndex1DocumentCollection(document,
iid,
(char const*) TRI_AtVectorPointer(&attributes, 0),
geoJson,
unique,
ignoreNull,
&created);
}
else {
idx = TRI_LookupGeoIndex1DocumentCollection(document,
(char const*) TRI_AtVectorPointer(&attributes, 0),
geoJson,
unique,
ignoreNull);
}
break;
}
case TRI_IDX_TYPE_GEO2_INDEX: {
TRI_ASSERT(attributes._length == 2);
bool ignoreNull = false;
TRI_json_t* value = TRI_LookupArrayJson(json, "ignoreNull");
if (TRI_IsBooleanJson(value)) {
ignoreNull = value->_value._boolean;
}
if (create) {
idx = TRI_EnsureGeoIndex2DocumentCollection(document,
iid,
(char const*) TRI_AtVectorPointer(&attributes, 0),
(char const*) TRI_AtVectorPointer(&attributes, 1),
unique,
ignoreNull,
&created);
}
else {
idx = TRI_LookupGeoIndex2DocumentCollection(document,
(char const*) TRI_AtVectorPointer(&attributes, 0),
(char const*) TRI_AtVectorPointer(&attributes, 1),
unique,
ignoreNull);
}
break;
}
case TRI_IDX_TYPE_HASH_INDEX: {
TRI_ASSERT(attributes._length > 0);
if (create) {
idx = TRI_EnsureHashIndexDocumentCollection(document,
iid,
&attributes,
unique,
&created);
}
else {
idx = TRI_LookupHashIndexDocumentCollection(document,
&attributes,
unique);
}
break;
}
case TRI_IDX_TYPE_SKIPLIST_INDEX: {
TRI_ASSERT(attributes._length > 0);
if (create) {
idx = TRI_EnsureSkiplistIndexDocumentCollection(document,
iid,
&attributes,
unique,
&created);
}
else {
idx = TRI_LookupSkiplistIndexDocumentCollection(document,
&attributes,
unique);
}
break;
}
case TRI_IDX_TYPE_FULLTEXT_INDEX: {
TRI_ASSERT(attributes._length == 1);
int minWordLength = TRI_FULLTEXT_MIN_WORD_LENGTH_DEFAULT;
TRI_json_t* value = TRI_LookupArrayJson(json, "minLength");
if (TRI_IsNumberJson(value)) {
minWordLength = (int) value->_value._number;
}
if (create) {
idx = TRI_EnsureFulltextIndexDocumentCollection(document,
iid,
(char const*) TRI_AtVectorPointer(&attributes, 0),
false,
minWordLength,
&created);
}
else {
idx = TRI_LookupFulltextIndexDocumentCollection(document,
(char const*) TRI_AtVectorPointer(&attributes, 0),
false,
minWordLength);
}
break;
}
case TRI_IDX_TYPE_CAP_CONSTRAINT: {
size_t size = 0;
TRI_json_t* value = TRI_LookupArrayJson(json, "size");
if (TRI_IsNumberJson(value)) {
size = (size_t) value->_value._number;
}
int64_t byteSize = 0;
value = TRI_LookupArrayJson(json, "byteSize");
if (TRI_IsNumberJson(value)) {
byteSize = (int64_t) value->_value._number;
}
if (create) {
idx = TRI_EnsureCapConstraintDocumentCollection(document,
iid,
size,
byteSize,
&created);
}
else {
idx = TRI_LookupCapConstraintDocumentCollection(document);
}
break;
}
}
if (idx == 0 && create) {
// something went wrong during creation
int res = TRI_errno();
TRI_DestroyVectorPointer(&values);
TRI_DestroyVectorPointer(&attributes);
TRI_V8_EXCEPTION(scope, res);
}
TRI_DestroyVectorPointer(&values);
TRI_DestroyVectorPointer(&attributes);
if (idx == 0 && ! create) {
// no index found
return scope.Close(v8::Null());
}
// found some index to return
TRI_json_t* indexJson = idx->json(idx);
if (indexJson == 0) {
TRI_V8_EXCEPTION_MEMORY(scope);
}
v8::Handle<v8::Value> ret = IndexRep(collectionName, indexJson);
TRI_FreeJson(TRI_CORE_MEM_ZONE, indexJson);
if (ret->IsObject()) {
ret->ToObject()->Set(v8::String::New("isNewlyCreated"), v8::Boolean::New(create && created));
}
return scope.Close(ret);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief ensures an index
////////////////////////////////////////////////////////////////////////////////
static v8::Handle<v8::Value> EnsureIndex (v8::Arguments const& argv,
bool create,
char const* functionName) {
v8::HandleScope scope;
TRI_vocbase_col_t* collection = TRI_UnwrapClass<TRI_vocbase_col_t>(argv.Holder(), WRP_VOCBASE_COL_TYPE);
if (collection == nullptr) {
TRI_V8_EXCEPTION_INTERNAL(scope, "cannot extract collection");
}
if (argv.Length() != 1 || ! argv[0]->IsObject()) {
string name(functionName);
name.append("(<description>)");
TRI_V8_EXCEPTION_USAGE(scope, name.c_str());
}
TRI_json_t* json = nullptr;
int res = EnhanceIndexJson(argv, json, create);
if (res == TRI_ERROR_NO_ERROR &&
ServerState::instance()->isCoordinator()) {
string const dbname(collection->_dbName);
// TODO: someone might rename the collection while we're reading its name...
string const collname(collection->_name);
shared_ptr<CollectionInfo> const& c = ClusterInfo::instance()->getCollection(dbname, collname);
if (c->empty()) {
TRI_V8_EXCEPTION(scope, TRI_ERROR_ARANGO_COLLECTION_NOT_FOUND);
}
// check if there is an attempt to create a unique index on non-shard keys
if (create) {
TRI_json_t const* v = TRI_LookupArrayJson(json, "unique");
if (TRI_IsBooleanJson(v) && v->_value._boolean) {
// unique index, now check if fields and shard keys match
TRI_json_t const* flds = TRI_LookupArrayJson(json, "fields");
if (TRI_IsListJson(flds) && c->numberOfShards() > 1) {
vector<string> const& shardKeys = c->shardKeys();
size_t const n = flds->_value._objects._length;
if (shardKeys.size() != n) {
res = TRI_ERROR_CLUSTER_UNSUPPORTED;
}
else {
for (size_t i = 0; i < n; ++i) {
TRI_json_t const* f = TRI_LookupListJson(flds, i);
if (! TRI_IsStringJson(f)) {
res = TRI_ERROR_INTERNAL;
continue;
}
else {
if (! TRI_EqualString(f->_value._string.data, shardKeys[i].c_str())) {
res = TRI_ERROR_CLUSTER_UNSUPPORTED;
}
}
}
}
}
}
}
}
if (res != TRI_ERROR_NO_ERROR) {
if (json != nullptr) {
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, json);
}
TRI_V8_EXCEPTION(scope, res);
}
TRI_ASSERT(json != nullptr);
v8::Handle<v8::Value> ret;
// ensure an index, coordinator case
if (ServerState::instance()->isCoordinator()) {
ret = EnsureIndexCoordinator(collection, json, create);
}
else {
ret = EnsureIndexLocal(collection, json, create);
}
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, json);
return scope.Close(ret);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief create a collection on the coordinator
////////////////////////////////////////////////////////////////////////////////
static v8::Handle<v8::Value> CreateCollectionCoordinator (
v8::Arguments const& argv,
TRI_col_type_e collectionType,
std::string const& databaseName,
TRI_col_info_t& parameter,
TRI_vocbase_t* vocbase) {
v8::HandleScope scope;
string const name = TRI_ObjectToString(argv[0]);
if (! TRI_IsAllowedNameCollection(parameter._isSystem, name.c_str())) {
TRI_V8_EXCEPTION(scope, TRI_ERROR_ARANGO_ILLEGAL_NAME);
}
bool allowUserKeys = true;
uint64_t numberOfShards = 1;
vector<string> shardKeys;
// default shard key
shardKeys.push_back("_key");
string distributeShardsLike;
if (2 <= argv.Length()) {
if (! argv[1]->IsObject()) {
TRI_V8_TYPE_ERROR(scope, "<properties> must be an object");
}
v8::Handle<v8::Object> p = argv[1]->ToObject();
if (p->Has(TRI_V8_SYMBOL("keyOptions")) && p->Get(TRI_V8_SYMBOL("keyOptions"))->IsObject()) {
v8::Handle<v8::Object> o = v8::Handle<v8::Object>::Cast(p->Get(TRI_V8_SYMBOL("keyOptions")));
if (o->Has(TRI_V8_SYMBOL("type"))) {
string const type = TRI_ObjectToString(o->Get(TRI_V8_SYMBOL("type")));
if (type != "" && type != "traditional") {
// invalid key generator
TRI_V8_EXCEPTION_MESSAGE(scope,
TRI_ERROR_CLUSTER_UNSUPPORTED,
"non-traditional key generators are not supported for sharded collections");
}
}
if (o->Has(TRI_V8_SYMBOL("allowUserKeys"))) {
allowUserKeys = TRI_ObjectToBoolean(o->Get(TRI_V8_SYMBOL("allowUserKeys")));
}
}
if (p->Has(TRI_V8_SYMBOL("numberOfShards"))) {
numberOfShards = TRI_ObjectToUInt64(p->Get(TRI_V8_SYMBOL("numberOfShards")), false);
}
if (p->Has(TRI_V8_SYMBOL("shardKeys"))) {
shardKeys.clear();
if (p->Get(TRI_V8_SYMBOL("shardKeys"))->IsArray()) {
v8::Handle<v8::Array> k = v8::Handle<v8::Array>::Cast(p->Get(TRI_V8_SYMBOL("shardKeys")));
for (uint32_t i = 0 ; i < k->Length(); ++i) {
v8::Handle<v8::Value> v = k->Get(i);
if (v->IsString()) {
string const key = TRI_ObjectToString(v);
// system attributes are not allowed (except _key)
if (! key.empty() && (key[0] != '_' || key == "_key")) {
shardKeys.push_back(key);
}
}
}
}
}
if (p->Has(TRI_V8_SYMBOL("distributeShardsLike")) &&
p->Get(TRI_V8_SYMBOL("distributeShardsLike"))->IsString()) {
distributeShardsLike
= TRI_ObjectToString(p->Get(TRI_V8_SYMBOL("distributeShardsLike")));
}
}
if (numberOfShards == 0 || numberOfShards > 1000) {
TRI_V8_EXCEPTION_PARAMETER(scope, "invalid number of shards");
}
if (shardKeys.empty() || shardKeys.size() > 8) {
TRI_V8_EXCEPTION_PARAMETER(scope, "invalid number of shard keys");
}
ClusterInfo* ci = ClusterInfo::instance();
// fetch a unique id for the new collection plus one for each shard to create
uint64_t const id = ci->uniqid(1 + numberOfShards);
// collection id is the first unique id we got
string const cid = StringUtils::itoa(id);
vector<string> dbServers;
if (distributeShardsLike.empty()) {
// fetch list of available servers in cluster, and shuffle them randomly
dbServers = ci->getCurrentDBServers();
if (dbServers.empty()) {
TRI_V8_EXCEPTION_MESSAGE(scope, TRI_ERROR_INTERNAL, "no database servers found in cluster");
}
random_shuffle(dbServers.begin(), dbServers.end());
}
else {
CollectionNameResolver resolver(vocbase);
TRI_voc_cid_t otherCid
= resolver.getCollectionIdCluster(distributeShardsLike);
shared_ptr<CollectionInfo> collInfo = ci->getCollection(databaseName,
triagens::basics::StringUtils::itoa(otherCid));
auto shards = collInfo->shardIds();
for (auto it = shards.begin(); it != shards.end(); ++it) {
dbServers.push_back(it->second);
}
// FIXME: need to sort shards numerically and not alphabetically
}
// now create the shards
std::map<std::string, std::string> shards;
for (uint64_t i = 0; i < numberOfShards; ++i) {
// determine responsible server
string serverId = dbServers[i % dbServers.size()];
// determine shard id
string shardId = "s" + StringUtils::itoa(id + 1 + i);
shards.insert(std::make_pair(shardId, serverId));
}
// now create the JSON for the collection
TRI_json_t* json = TRI_CreateArrayJson(TRI_UNKNOWN_MEM_ZONE);
if (json == nullptr) {
TRI_V8_EXCEPTION(scope, TRI_ERROR_OUT_OF_MEMORY);
}
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "id", TRI_CreateString2CopyJson(TRI_UNKNOWN_MEM_ZONE, cid.c_str(), cid.size()));
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "name", TRI_CreateString2CopyJson(TRI_UNKNOWN_MEM_ZONE, name.c_str(), name.size()));
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "type", TRI_CreateNumberJson(TRI_UNKNOWN_MEM_ZONE, (int) collectionType));
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "status", TRI_CreateNumberJson(TRI_UNKNOWN_MEM_ZONE, (int) TRI_VOC_COL_STATUS_LOADED));
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "deleted", TRI_CreateBooleanJson(TRI_UNKNOWN_MEM_ZONE, parameter._deleted));
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "doCompact", TRI_CreateBooleanJson(TRI_UNKNOWN_MEM_ZONE, parameter._doCompact));
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "isSystem", TRI_CreateBooleanJson(TRI_UNKNOWN_MEM_ZONE, parameter._isSystem));
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "isVolatile", TRI_CreateBooleanJson(TRI_UNKNOWN_MEM_ZONE, parameter._isVolatile));
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "waitForSync", TRI_CreateBooleanJson(TRI_UNKNOWN_MEM_ZONE, parameter._waitForSync));
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "journalSize", TRI_CreateNumberJson(TRI_UNKNOWN_MEM_ZONE, parameter._maximalSize));
TRI_json_t* keyOptions = TRI_CreateArrayJson(TRI_UNKNOWN_MEM_ZONE);
if (keyOptions != 0) {
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, keyOptions, "type", TRI_CreateStringCopyJson(TRI_UNKNOWN_MEM_ZONE, "traditional"));
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, keyOptions, "allowUserKeys", TRI_CreateBooleanJson(TRI_UNKNOWN_MEM_ZONE, allowUserKeys));
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "keyOptions", keyOptions);
}
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "shardKeys", JsonHelper::stringList(TRI_UNKNOWN_MEM_ZONE, shardKeys));
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "shards", JsonHelper::stringObject(TRI_UNKNOWN_MEM_ZONE, shards));
TRI_json_t* indexes = TRI_CreateListJson(TRI_UNKNOWN_MEM_ZONE);
if (indexes == 0) {
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, json);
TRI_V8_EXCEPTION(scope, TRI_ERROR_OUT_OF_MEMORY);
}
// create a dummy primary index
TRI_index_t* idx = TRI_CreatePrimaryIndex(0);
if (idx == 0) {
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, indexes);
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, json);
TRI_V8_EXCEPTION(scope, TRI_ERROR_OUT_OF_MEMORY);
}
TRI_json_t* idxJson = idx->json(idx);
TRI_FreeIndex(idx);
TRI_PushBack3ListJson(TRI_UNKNOWN_MEM_ZONE, indexes, TRI_CopyJson(TRI_UNKNOWN_MEM_ZONE, idxJson));
TRI_FreeJson(TRI_CORE_MEM_ZONE, idxJson);
if (collectionType == TRI_COL_TYPE_EDGE) {
// create a dummy edge index
idx = TRI_CreateEdgeIndex(0, id);
if (idx == 0) {
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, indexes);
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, json);
TRI_V8_EXCEPTION(scope, TRI_ERROR_OUT_OF_MEMORY);
}
idxJson = idx->json(idx);
TRI_FreeIndex(idx);
TRI_PushBack3ListJson(TRI_UNKNOWN_MEM_ZONE, indexes, TRI_CopyJson(TRI_UNKNOWN_MEM_ZONE, idxJson));
TRI_FreeJson(TRI_CORE_MEM_ZONE, idxJson);
}
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, "indexes", indexes);
string errorMsg;
int myerrno = ci->createCollectionCoordinator(databaseName,
cid,
numberOfShards,
json,
errorMsg,
240.0);
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, json);
if (myerrno != TRI_ERROR_NO_ERROR) {
TRI_V8_EXCEPTION_MESSAGE(scope, myerrno, errorMsg);
}
ci->loadPlannedCollections();
shared_ptr<CollectionInfo> const& c = ci->getCollection(databaseName, cid);
TRI_vocbase_col_t* newcoll = CoordinatorCollection(vocbase, *c);
return scope.Close(WrapCollection(newcoll));
}
////////////////////////////////////////////////////////////////////////////////
/// @brief ensures that an index exists
/// @startDocuBlock collectionEnsureIndex
/// `collection.ensureIndex(index-description)`
///
/// Ensures that an index according to the *index-description* exists. A
/// new index will be created if none exists with the given description.
///
/// The *index-description* must contain at least a *type* attribute.
/// *type* can be one of the following values:
/// - *hash*: hash index
/// - *skiplist*: skiplist index
/// - *fulltext*: fulltext index
/// - *geo1*: geo index, with one attribute
/// - *geo2*: geo index, with two attributes
/// - *cap*: cap constraint
///
/// Other attributes may be necessary, depending on the index type.
///
/// Calling this method returns an index object. Whether or not the index
/// object existed before the call is indicated in the return attribute
/// *isNewlyCreated*.
///
/// @EXAMPLES
///
/// ```js
/// arango> db.example.ensureIndex({ type: "hash", fields: [ "name" ], unique: true });
/// {
/// "id" : "example/30242599562",
/// "type" : "hash",
/// "unique" : true,
/// "fields" : [
/// "name"
/// ],
/// "isNewlyCreated" : true
/// }
/// ```
///
/// @endDocuBlock
////////////////////////////////////////////////////////////////////////////////
static v8::Handle<v8::Value> JS_EnsureIndexVocbaseCol (v8::Arguments const& argv) {
v8::HandleScope scope;
PREVENT_EMBEDDED_TRANSACTION(scope);
return scope.Close(EnsureIndex(argv, true, "ensureIndex"));
}
////////////////////////////////////////////////////////////////////////////////
/// @brief looks up an index
////////////////////////////////////////////////////////////////////////////////
static v8::Handle<v8::Value> JS_LookupIndexVocbaseCol (v8::Arguments const& argv) {
v8::HandleScope scope;
return scope.Close(EnsureIndex(argv, false, "lookupIndex"));
}
////////////////////////////////////////////////////////////////////////////////
/// @brief drops an index, coordinator case
////////////////////////////////////////////////////////////////////////////////
static v8::Handle<v8::Value> DropIndexCoordinator (TRI_vocbase_col_t const* collection,
v8::Handle<v8::Value> const val) {
v8::HandleScope scope;
string collectionName;
TRI_idx_iid_t iid = 0;
// extract the index identifier from a string
if (val->IsString() || val->IsStringObject() || val->IsNumber()) {
if (! IsIndexHandle(val, collectionName, iid)) {
TRI_V8_EXCEPTION(scope, TRI_ERROR_ARANGO_INDEX_HANDLE_BAD);
}
}
// extract the index identifier from an object
else if (val->IsObject()) {
TRI_v8_global_t* v8g = (TRI_v8_global_t*) v8::Isolate::GetCurrent()->GetData();
v8::Handle<v8::Object> obj = val->ToObject();
v8::Handle<v8::Value> iidVal = obj->Get(v8g->IdKey);
if (! IsIndexHandle(iidVal, collectionName, iid)) {
TRI_V8_EXCEPTION(scope, TRI_ERROR_ARANGO_INDEX_HANDLE_BAD);
}
}
if (! collectionName.empty()) {
CollectionNameResolver resolver(collection->_vocbase);
if (! EqualCollection(&resolver, collectionName, collection)) {
TRI_V8_EXCEPTION(scope, TRI_ERROR_ARANGO_CROSS_COLLECTION_REQUEST);
}
}
string const databaseName(collection->_dbName);
string const cid = StringUtils::itoa(collection->_cid);
string errorMsg;
int res = ClusterInfo::instance()->dropIndexCoordinator(databaseName, cid, iid, errorMsg, 0.0);
return scope.Close(v8::Boolean::New(res == TRI_ERROR_NO_ERROR));
}
////////////////////////////////////////////////////////////////////////////////
/// @brief drops an index
/// @startDocuBlock col_dropIndex
/// `collection.dropIndex(index)`
///
/// Drops the index. If the index does not exist, then *false* is
/// returned. If the index existed and was dropped, then *true* is
/// returned. Note that you cannot drop some special indexes (e.g. the primary
/// index of a collection or the edge index of an edge collection).
///
/// `collection.dropIndex(index-handle)`
///
/// Same as above. Instead of an index an index handle can be given.
///
/// @EXAMPLES
///
/// ```js
/// arango> db.example.ensureSkiplist("a", "b");
/// { "id" : "example/991154", "unique" : false, "type" : "skiplist", "fields" : ["a", "b"], "isNewlyCreated" : true }
///
/// arango> i = db.example.getIndexes();
/// [
/// { "id" : "example/0", "type" : "primary", "fields" : ["_id"] },
/// { "id" : "example/991154", "unique" : false, "type" : "skiplist", "fields" : ["a", "b"] }
/// ]
///
/// arango> db.example.dropIndex(i[0])
/// false
///
/// arango> db.example.dropIndex(i[1].id)
/// true
///
/// arango> i = db.example.getIndexes();
/// [{ "id" : "example/0", "type" : "primary", "fields" : ["_id"] }]
/// ```
///
/// @endDocuBlock
////////////////////////////////////////////////////////////////////////////////
static v8::Handle<v8::Value> JS_DropIndexVocbaseCol (v8::Arguments const& argv) {
v8::HandleScope scope;
PREVENT_EMBEDDED_TRANSACTION(scope);
TRI_vocbase_col_t* collection = TRI_UnwrapClass<TRI_vocbase_col_t>(argv.Holder(), WRP_VOCBASE_COL_TYPE);
if (collection == nullptr) {
TRI_V8_EXCEPTION_INTERNAL(scope, "cannot extract collection");
}
if (argv.Length() != 1) {
TRI_V8_EXCEPTION_USAGE(scope, "dropIndex(<index-handle>)");
}
if (ServerState::instance()->isCoordinator()) {
return scope.Close(DropIndexCoordinator(collection, argv[0]));
}
SingleCollectionReadOnlyTransaction trx(new V8TransactionContext(true), collection->_vocbase, collection->_cid);
int res = trx.begin();
if (res != TRI_ERROR_NO_ERROR) {
TRI_V8_EXCEPTION(scope, res);
}
TRI_document_collection_t* document = trx.documentCollection();
v8::Handle<v8::Object> err;
TRI_index_t* idx = TRI_LookupIndexByHandle(trx.resolver(), collection, argv[0], true, &err);
if (idx == nullptr) {
if (err.IsEmpty()) {
return scope.Close(v8::False());
}
else {
return scope.Close(v8::ThrowException(err));
}
}
if (idx->_iid == 0) {
return scope.Close(v8::False());
}
if (idx->_type == TRI_IDX_TYPE_PRIMARY_INDEX ||
idx->_type == TRI_IDX_TYPE_EDGE_INDEX) {
TRI_V8_EXCEPTION(scope, TRI_ERROR_FORBIDDEN);
}
// .............................................................................
// inside a write transaction, write-lock is acquired by TRI_DropIndex...
// .............................................................................
bool ok = TRI_DropIndexDocumentCollection(document, idx->_iid, true);
// .............................................................................
// outside a write transaction
// .............................................................................
return scope.Close(v8::Boolean::New(ok));
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns information about the indexes, coordinator case
////////////////////////////////////////////////////////////////////////////////
static v8::Handle<v8::Value> GetIndexesCoordinator (TRI_vocbase_col_t const* collection) {
v8::HandleScope scope;
string const databaseName(collection->_dbName);
string const cid = StringUtils::itoa(collection->_cid);
string const collectionName(collection->_name);
shared_ptr<CollectionInfo> c = ClusterInfo::instance()->getCollection(databaseName, cid);
if ((*c).empty()) {
TRI_V8_EXCEPTION(scope, TRI_ERROR_ARANGO_COLLECTION_NOT_FOUND);
}
v8::Handle<v8::Array> ret = v8::Array::New();
TRI_json_t const* json = (*c).getIndexes();
if (TRI_IsListJson(json)) {
uint32_t j = 0;
for (size_t i = 0; i < json->_value._objects._length; ++i) {
TRI_json_t const* v = TRI_LookupListJson(json, i);
if (v != nullptr) {
ret->Set(j++, IndexRep(collectionName, v));
}
}
}
return scope.Close(ret);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns information about the indexes
/// @startDocuBlock collectionGetIndexes
/// `getIndexes()`
///
/// Returns a list of all indexes defined for the collection.
///
/// @EXAMPLES
///
/// ```js
/// [
/// {
/// "id" : "demo/0",
/// "type" : "primary",
/// "fields" : [ "_id" ]
/// },
/// {
/// "id" : "demo/2290971",
/// "unique" : true,
/// "type" : "hash",
/// "fields" : [ "a" ]
/// },
/// {
/// "id" : "demo/2946331",
/// "unique" : false,
/// "type" : "hash",
/// "fields" : [ "b" ]
/// },
/// {
/// "id" : "demo/3077403",
/// "unique" : false,
/// "type" : "skiplist",
/// "fields" : [ "c" ]
/// }
/// ]
/// ```
///
/// @endDocuBlock
////////////////////////////////////////////////////////////////////////////////
static v8::Handle<v8::Value> JS_GetIndexesVocbaseCol (v8::Arguments const& argv) {
v8::HandleScope scope;
TRI_vocbase_col_t* collection = TRI_UnwrapClass<TRI_vocbase_col_t>(argv.Holder(), WRP_VOCBASE_COL_TYPE);
if (collection == nullptr) {
TRI_V8_EXCEPTION_INTERNAL(scope, "cannot extract collection");
}
if (ServerState::instance()->isCoordinator()) {
return scope.Close(GetIndexesCoordinator(collection));
}
SingleCollectionReadOnlyTransaction trx(new V8TransactionContext(true), collection->_vocbase, collection->_cid);
int res = trx.begin();
if (res != TRI_ERROR_NO_ERROR) {
TRI_V8_EXCEPTION(scope, res);
}
// READ-LOCK start
trx.lockRead();
TRI_document_collection_t* document = trx.documentCollection();
const string collectionName = string(collection->_name);
// get list of indexes
TRI_vector_pointer_t* indexes = TRI_IndexesDocumentCollection(document);
trx.finish(res);
// READ-LOCK end
if (indexes == nullptr) {
TRI_V8_EXCEPTION_MEMORY(scope);
}
v8::Handle<v8::Array> result = v8::Array::New();
uint32_t n = (uint32_t) indexes->_length;
for (uint32_t i = 0, j = 0; i < n; ++i) {
TRI_json_t* idx = static_cast<TRI_json_t*>(indexes->_buffer[i]);
if (idx != nullptr) {
result->Set(j++, IndexRep(collectionName, idx));
TRI_FreeJson(TRI_CORE_MEM_ZONE, idx);
}
}
TRI_FreeVectorPointer(TRI_CORE_MEM_ZONE, indexes);
return scope.Close(result);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief looks up an index identifier
////////////////////////////////////////////////////////////////////////////////
TRI_index_t* TRI_LookupIndexByHandle (CollectionNameResolver const* resolver,
TRI_vocbase_col_t const* collection,
v8::Handle<v8::Value> const val,
bool ignoreNotFound,
v8::Handle<v8::Object>* err) {
// reset the collection identifier
string collectionName;
TRI_idx_iid_t iid = 0;
// assume we are already loaded
TRI_ASSERT(collection != nullptr);
TRI_ASSERT(collection->_collection != nullptr);
// extract the index identifier from a string
if (val->IsString() || val->IsStringObject() || val->IsNumber()) {
if (! IsIndexHandle(val, collectionName, iid)) {
*err = TRI_CreateErrorObject(__FILE__, __LINE__, TRI_ERROR_ARANGO_INDEX_HANDLE_BAD);
return nullptr;
}
}
// extract the index identifier from an object
else if (val->IsObject()) {
TRI_v8_global_t* v8g = static_cast<TRI_v8_global_t*>(v8::Isolate::GetCurrent()->GetData());
v8::Handle<v8::Object> obj = val->ToObject();
v8::Handle<v8::Value> iidVal = obj->Get(v8g->IdKey);
if (! IsIndexHandle(iidVal, collectionName, iid)) {
*err = TRI_CreateErrorObject(__FILE__, __LINE__, TRI_ERROR_ARANGO_INDEX_HANDLE_BAD);
return nullptr;
}
}
if (! collectionName.empty()) {
if (! EqualCollection(resolver, collectionName, collection)) {
// I wish this error provided me with more information!
// e.g. 'cannot access index outside the collection it was defined in'
*err = TRI_CreateErrorObject(__FILE__, __LINE__, TRI_ERROR_ARANGO_CROSS_COLLECTION_REQUEST);
return nullptr;
}
}
TRI_index_t* idx = TRI_LookupIndex(collection->_collection, iid);
if (idx == nullptr) {
if (! ignoreNotFound) {
*err = TRI_CreateErrorObject(__FILE__, __LINE__, TRI_ERROR_ARANGO_INDEX_NOT_FOUND);
}
}
return idx;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief create a collection
////////////////////////////////////////////////////////////////////////////////
static v8::Handle<v8::Value> CreateVocBase (v8::Arguments const& argv,
TRI_col_type_e collectionType) {
v8::HandleScope scope;
TRI_vocbase_t* vocbase = GetContextVocBase();
if (vocbase == nullptr) {
TRI_V8_EXCEPTION(scope, TRI_ERROR_ARANGO_DATABASE_NOT_FOUND);
}
// ...........................................................................
// We require exactly 1 or exactly 2 arguments -- anything else is an error
// ...........................................................................
if (argv.Length() < 1 || argv.Length() > 2) {
TRI_V8_EXCEPTION_USAGE(scope, "_create(<name>, <properties>)");
}
if (TRI_GetOperationModeServer() == TRI_VOCBASE_MODE_NO_CREATE) {
TRI_V8_EXCEPTION(scope, TRI_ERROR_ARANGO_READ_ONLY);
}
PREVENT_EMBEDDED_TRANSACTION(scope);
// set default journal size
TRI_voc_size_t effectiveSize = vocbase->_settings.defaultMaximalSize;
// extract the name
string const name = TRI_ObjectToString(argv[0]);
// extract the parameters
TRI_col_info_t parameter;
TRI_voc_cid_t cid = 0;
if (2 <= argv.Length()) {
if (! argv[1]->IsObject()) {
TRI_V8_TYPE_ERROR(scope, "<properties> must be an object");
}
v8::Handle<v8::Object> p = argv[1]->ToObject();
TRI_v8_global_t* v8g = (TRI_v8_global_t*) v8::Isolate::GetCurrent()->GetData();
if (p->Has(v8g->JournalSizeKey)) {
double s = TRI_ObjectToDouble(p->Get(v8g->JournalSizeKey));
if (s < TRI_JOURNAL_MINIMAL_SIZE) {
TRI_V8_EXCEPTION_PARAMETER(scope, "<properties>.journalSize is too small");
}
// overwrite journal size with user-specified value
effectiveSize = (TRI_voc_size_t) s;
}
// get optional values
TRI_json_t* keyOptions = nullptr;
if (p->Has(v8g->KeyOptionsKey)) {
keyOptions = TRI_ObjectToJson(p->Get(v8g->KeyOptionsKey));
}
// TRI_InitCollectionInfo will copy keyOptions
TRI_InitCollectionInfo(vocbase, ¶meter, name.c_str(), collectionType, effectiveSize, keyOptions);
if (keyOptions != nullptr) {
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, keyOptions);
}
if (p->Has(v8::String::New("planId"))) {
parameter._planId = TRI_ObjectToUInt64(p->Get(v8::String::New("planId")), true);
}
if (p->Has(v8g->WaitForSyncKey)) {
parameter._waitForSync = TRI_ObjectToBoolean(p->Get(v8g->WaitForSyncKey));
}
if (p->Has(v8g->DoCompactKey)) {
parameter._doCompact = TRI_ObjectToBoolean(p->Get(v8g->DoCompactKey));
}
else {
// default value for compaction
parameter._doCompact = true;
}
if (p->Has(v8g->IsSystemKey)) {
parameter._isSystem = TRI_ObjectToBoolean(p->Get(v8g->IsSystemKey));
}
if (p->Has(v8g->IsVolatileKey)) {
#ifdef TRI_HAVE_ANONYMOUS_MMAP
parameter._isVolatile = TRI_ObjectToBoolean(p->Get(v8g->IsVolatileKey));
#else
TRI_FreeCollectionInfoOptions(¶meter);
TRI_V8_EXCEPTION_PARAMETER(scope, "volatile collections are not supported on this platform");
#endif
}
if (parameter._isVolatile && parameter._waitForSync) {
// the combination of waitForSync and isVolatile makes no sense
TRI_FreeCollectionInfoOptions(¶meter);
TRI_V8_EXCEPTION_PARAMETER(scope, "volatile collections do not support the waitForSync option");
}
if (p->Has(v8g->IdKey)) {
// specify collection id - used for testing only
cid = TRI_ObjectToUInt64(p->Get(v8g->IdKey), true);
}
}
else {
TRI_InitCollectionInfo(vocbase, ¶meter, name.c_str(), collectionType, effectiveSize, nullptr);
}
if (ServerState::instance()->isCoordinator()) {
v8::Handle<v8::Value> result = CreateCollectionCoordinator(argv, collectionType, vocbase->_name, parameter, vocbase);
TRI_FreeCollectionInfoOptions(¶meter);
return scope.Close(result);
}
TRI_vocbase_col_t const* collection = TRI_CreateCollectionVocBase(vocbase,
¶meter,
cid,
true);
TRI_FreeCollectionInfoOptions(¶meter);
if (collection == nullptr) {
TRI_V8_EXCEPTION_MESSAGE(scope, TRI_errno(), "cannot create collection");
}
v8::Handle<v8::Value> result = WrapCollection(collection);
if (result.IsEmpty()) {
TRI_V8_EXCEPTION_MEMORY(scope);
}
return scope.Close(result);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief creates a new document or edge collection
/// @startDocuBlock collectionDatabaseCreate
/// `db._create(collection-name)`
///
/// Creates a new document collection named *collection-name*.
/// If the collection name already exists or if the name format is invalid, an
/// error is thrown. For more information on valid collection names please refer
/// to the [naming conventions](../NamingConventions/README.md).
///
/// `db._create(collection-name, properties)`
///
/// *properties* must be an object with the following attributes:
///
/// * *waitForSync* (optional, default *false*): If *true* creating
/// a document will only return after the data was synced to disk.
///
/// * *journalSize* (optional, default is a
/// configuration parameter: The maximal
/// size of a journal or datafile. Note that this also limits the maximal
/// size of a single object. Must be at least 1MB.
///
/// * *isSystem* (optional, default is *false*): If *true*, create a
/// system collection. In this case *collection-name* should start with
/// an underscore. End users should normally create non-system collections
/// only. API implementors may be required to create system collections in
/// very special occasions, but normally a regular collection will do.
///
/// * *isVolatile* (optional, default is *false*): If *true then the
/// collection data is kept in-memory only and not made persistent. Unloading
/// the collection will cause the collection data to be discarded. Stopping
/// or re-starting the server will also cause full loss of data in the
/// collection. Setting this option will make the resulting collection be
/// slightly faster than regular collections because ArangoDB does not
/// enforce any synchronization to disk and does not calculate any CRC
/// checksums for datafiles (as there are no datafiles).
///
/// * *keyOptions* (optional): additional options for key generation. If
/// specified, then *keyOptions* should be a JSON array containing the
/// following attributes (**note**: some of them are optional):
/// * *type*: specifies the type of the key generator. The currently
/// available generators are *traditional* and *autoincrement*.
/// * *allowUserKeys*: if set to *true*, then it is allowed to supply
/// own key values in the *_key* attribute of a document. If set to
/// *false*, then the key generator will solely be responsible for
/// generating keys and supplying own key values in the *_key* attribute
/// of documents is considered an error.
/// * *increment*: increment value for *autoincrement* key generator.
/// Not used for other key generator types.
/// * *offset*: initial offset value for *autoincrement* key generator.
/// Not used for other key generator types.
///
/// * *numberOfShards* (optional, default is *1*): in a cluster, this value
/// determines the number of shards to create for the collection. In a single
/// server setup, this option is meaningless.
///
/// * *shardKeys* (optional, default is *[ "_key" ]*): in a cluster, this
/// attribute determines which document attributes are used to determine the
/// target shard for documents. Documents are sent to shards based on the
/// values they have in their shard key attributes. The values of all shard
/// key attributes in a document are hashed, and the hash value is used to
/// determine the target shard. Note that values of shard key attributes cannot
/// be changed once set.
/// This option is meaningless in a single server setup.
///
/// When choosing the shard keys, one must be aware of the following
/// rules and limitations: In a sharded collection with more than
/// one shard it is not possible to set up a unique constraint on
/// an attribute that is not the one and only shard key given in
/// *shardKeys*. This is because enforcing a unique constraint
/// would otherwise make a global index necessary or need extensive
/// communication for every single write operation. Furthermore, if
/// *_key* is not the one and only shard key, then it is not possible
/// to set the *_key* attribute when inserting a document, provided
/// the collection has more than one shard. Again, this is because
/// the database has to enforce the unique constraint on the *_key*
/// attribute and this can only be done efficiently if this is the
/// only shard key by delegating to the individual shards.
///
/// `db._create(collection-name, properties, type)`
///
/// Specifies the optional *type* of the collection, it can either be *document*
/// or *edge*. On default it is document. Instead of giving a type you can also use
/// *db._createEdgeCollection* or *db._createDocumentCollection*.
///
/// @EXAMPLES
///
/// With defaults:
///
/// @EXAMPLE_ARANGOSH_OUTPUT{collectionDatabaseCreate}
/// c = db._create("users");
/// c.properties();
/// ~ db._drop("users");
/// @END_EXAMPLE_ARANGOSH_OUTPUT
///
/// With properties:
///
/// @EXAMPLE_ARANGOSH_OUTPUT{collectionDatabaseCreateProperties}
/// c = db._create("users", { waitForSync : true, journalSize : 1024 * 1204 });
/// c.properties();
/// ~ db._drop("users");
/// @END_EXAMPLE_ARANGOSH_OUTPUT
///
/// With a key generator:
///
/// @EXAMPLE_ARANGOSH_OUTPUT{collectionDatabaseCreateKey}
/// db._create("users", { keyOptions: { type: "autoincrement", offset: 10, increment: 5 } });
/// db.users.save({ name: "user 1" });
/// db.users.save({ name: "user 2" });
/// db.users.save({ name: "user 3" });
/// ~ db._drop("users");
/// @END_EXAMPLE_ARANGOSH_OUTPUT
///
/// With a special key option:
///
/// @EXAMPLE_ARANGOSH_OUTPUT{collectionDatabaseCreateSpecialKey}
/// db._create("users", { keyOptions: { allowUserKeys: false } });
/// db.users.save({ name: "user 1" });
/// db.users.save({ name: "user 2", _key: "myuser" });
/// db.users.save({ name: "user 3" });
/// ~ db._drop("users");
/// @END_EXAMPLE_ARANGOSH_OUTPUT
/// @endDocuBlock
////////////////////////////////////////////////////////////////////////////////
static v8::Handle<v8::Value> JS_CreateVocbase (v8::Arguments const& argv) {
return CreateVocBase(argv, TRI_COL_TYPE_DOCUMENT);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief creates a new document collection
/// @startDocuBlock collectionCreateDocumentCollection
/// `db._createDocumentCollection(collection-name)`
///
/// Creates a new document collection named *collection-name*. If the
/// document name already exists and error is thrown.
/// @endDocuBlock
////////////////////////////////////////////////////////////////////////////////
static v8::Handle<v8::Value> JS_CreateDocumentCollectionVocbase (v8::Arguments const& argv) {
return CreateVocBase(argv, TRI_COL_TYPE_DOCUMENT);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief creates a new edge collection
/// @startDocuBlock collectionCreateEdgeCollection
/// `db._createEdgeCollection(collection-name)`
///
/// Creates a new edge collection named *collection-name*. If the
/// collection name already exists an error is thrown. The default value
/// for *waitForSync* is *false*.
///
/// `db._createEdgeCollection(collection-name, properties)`
///
/// *properties* must be an object with the following attributes:
///
/// * *waitForSync* (optional, default *false*): If *true* creating
/// a document will only return after the data was synced to disk.
/// * *journalSize* (optional, default is
/// "configuration parameter"): The maximal size of
/// a journal or datafile. Note that this also limits the maximal
/// size of a single object and must be at least 1MB.
///
/// @endDocuBlock
////////////////////////////////////////////////////////////////////////////////
static v8::Handle<v8::Value> JS_CreateEdgeCollectionVocbase (v8::Arguments const& argv) {
return CreateVocBase(argv, TRI_COL_TYPE_EDGE);
}
void TRI_InitV8indexArangoDB (v8::Handle<v8::Context> context,
TRI_server_t* server,
TRI_vocbase_t* vocbase,
JSLoader* loader,
const size_t threadNumber,
TRI_v8_global_t* v8g,
v8::Handle<v8::ObjectTemplate> rt){
TRI_AddMethodVocbase(rt, "_create", JS_CreateVocbase, true);
TRI_AddMethodVocbase(rt, "_createEdgeCollection", JS_CreateEdgeCollectionVocbase);
TRI_AddMethodVocbase(rt, "_createDocumentCollection", JS_CreateDocumentCollectionVocbase);
}
void TRI_InitV8indexCollection (v8::Handle<v8::Context> context,
TRI_server_t* server,
TRI_vocbase_t* vocbase,
JSLoader* loader,
const size_t threadNumber,
TRI_v8_global_t* v8g,
v8::Handle<v8::ObjectTemplate> rt){
TRI_AddMethodVocbase(rt, "dropIndex", JS_DropIndexVocbaseCol);
TRI_AddMethodVocbase(rt, "ensureIndex", JS_EnsureIndexVocbaseCol);
TRI_AddMethodVocbase(rt, "lookupIndex", JS_LookupIndexVocbaseCol);
TRI_AddMethodVocbase(rt, "getIndexes", JS_GetIndexesVocbaseCol);
}
| 35.544609 | 138 | 0.575793 | [
"object",
"vector"
] |
47090c1b82053eea0782afd9520b3842f08f6965 | 5,465 | cpp | C++ | lm_io.cpp | chenkovsky/lmprune | 1f77e00a5c6c2673b40e0c6b3d7552cc237e95be | [
"MIT"
] | 3 | 2015-11-28T12:14:26.000Z | 2019-07-27T05:10:38.000Z | lm_io.cpp | chenkovsky/lmprune | 1f77e00a5c6c2673b40e0c6b3d7552cc237e95be | [
"MIT"
] | null | null | null | lm_io.cpp | chenkovsky/lmprune | 1f77e00a5c6c2673b40e0c6b3d7552cc237e95be | [
"MIT"
] | null | null | null | #include<iomanip>
#include <sstream> // std::istringstream
#include "lm.hpp"
template <class T> LanguageModel* LanguageModel::load(T &in) {
LanguageModel *lm = NULL;
cerr << "[LOADING] start loading..." << endl;
string str, word;
size_t ngram_num_per_order[MAX_ORDER];
word_id_t word_ids[MAX_ORDER];
uint32_t order = 0;
memset(ngram_num_per_order, 0, sizeof(ngram_num_per_order));
while (getline(in, str) && !boost::algorithm::starts_with(str, data_prefix)) {}
while (getline(in, str) && boost::algorithm::starts_with(str, ngram_prefix)) {
uint32_t cur_order = atoi(str.c_str() + ngram_prefix.length());
order = max(order, cur_order);
size_t offset = str.find_first_of("=");
assert(offset != string::npos);
ngram_num_per_order[cur_order - 1] = atol(str.c_str() + offset + 1);
}
lm = new LanguageModel(ngram_num_per_order, order);
uint32_t cur_order = 0;
while (getline(in, str)) {
if (boost::algorithm::starts_with(str, ngram_block_prefix)) {
if (boost::algorithm::starts_with(str, end_prefix)) {
break;
}
assert(boost::algorithm::ends_with(str, ngram_block_suffix));
cur_order = atoi(str.c_str() + 1);
cerr << "[LOADING] order = " << cur_order << endl;
continue;
} else if (str.length() == 0) {
continue;
}
prob_t prob = atof(str.c_str());
size_t token_start = 0;
size_t token_end = str.find_first_of("\t ");
for (uint32_t i = 0; i < cur_order; i++) {
token_start = str.find_first_not_of("\t ", token_end);
token_end = str.find_first_of("\t ", token_start);
word.assign(str, token_start, token_end - token_start);
if(i == 0){
word_ids[i] = lm->word2Idx_append_if_not_exist(word);
}else{
word_ids[i] = lm->word2Idx(word);
assert(word_ids[i] != -1);
}
}
prob_t bow = 0;
if (token_end != string::npos) {
bow = atof(str.c_str() + token_end);
}
lm->add_gram(word_ids, cur_order, prob, bow);
}
lm->load_finish();
cerr << "[LOADING] load finish." << endl;
return lm;
}
LanguageModel* LanguageModel::load(const char *filename) {
ifstream file(filename, ios_base::in | ios_base::binary);
boost::iostreams::filtering_istream in;
in.push(boost::iostreams::gzip_decompressor());
in.push(file);
LanguageModel* ret= load(in);
file.close();
return ret;
}
void LanguageModel::save(const char *filename) {
cerr << "[SAVING] save pruned language model ..." << endl;
//首先需要将bos的概率恢复0.
prob_buff[bos_gram_id] = min_log_prob;
ofstream file(filename, ios_base::out | ios_base::binary);
boost::iostreams::filtering_ostream out;
out.push(boost::iostreams::gzip_compressor());
out.push(file);
out << setprecision(7);
out << (*this);
boost::iostreams::close(out);
}
const string LanguageModel::ngram_prefix = "ngram";
const string LanguageModel::data_prefix = "\\data\\";
const string LanguageModel::ngram_block_prefix = "\\";
const string LanguageModel::end_prefix = "\\end\\";
const string LanguageModel::ngram_block_suffix = "-grams:";
const string LanguageModel::sep = "\t";
const string LanguageModel::escape = "\\";
template<class T>
T& operator<<(T &os, const LanguageModel &lm) {
os << endl << LanguageModel::data_prefix << endl;
for (uint32_t i = 0; i < lm.order; i++) {
os << LanguageModel::ngram_prefix << " " << (i+1) << "=" << lm.used_ngram_num_per_order[i] << endl;
}
os << endl;
size_t offset = 0;
for (uint32_t lvl = 0; lvl < lm.order; lvl++) {
cerr << "[SAVING] order = " << (lvl+1) << endl;
os << LanguageModel::escape << (lvl + 1) << LanguageModel::ngram_block_suffix << endl;
size_t gram_num = lm.ngram_num_per_order[lvl];
GramNode *start_node = &lm.grams_buff[offset];
GramNode *end_node = start_node + gram_num;
for (GramNode *cur_node = start_node; cur_node != end_node; cur_node++) {
if (lm.prob_buff[cur_node->gram_id] > 2.0) {
continue; //这个gram已经被删除了
}
os << lm.prob_buff[cur_node->gram_id] << LanguageModel::sep;
lm.puts_gram(os, cur_node);
//lm.puts_gram(cerr, cur_node);
//cerr << endl;
if (lm.bow_buff[cur_node->gram_id] != 0.0) {
os << LanguageModel::sep << lm.bow_buff[cur_node->gram_id];
}
os << endl;
}
os << endl;
offset += lm.ngram_num_per_order[lvl];
}
os << LanguageModel::end_prefix << endl;
return os;
}
template<class T> void LanguageModel::load_important_gram(T &in){
string str;
while (getline(in, str)) {
istringstream iss(str);
vector<string> tokens{istream_iterator<string>{iss},
istream_iterator<string>{}};
const GramNode* gram_ = gram(tokens);
if (gram_ != NULL) {
mask_for_grams[gram_->gram_id] |= DONT_PRUNE;
}
}
}
void LanguageModel::load_important_gram(const char* filename){
ifstream file(filename, ios_base::in | ios_base::binary);
boost::iostreams::filtering_istream in;
in.push(boost::iostreams::gzip_decompressor());
in.push(file);
load_important_gram(in);
file.close();
}
| 37.176871 | 107 | 0.599268 | [
"vector",
"model"
] |
47090f0fae67600f665022ca8db0ac1a754814d8 | 1,930 | cpp | C++ | code/playground/boostSpline.cpp | manavjain99/oscar_buggy | b5dab0848f8667c9515bcfb078730cd0c4060000 | [
"MIT"
] | null | null | null | code/playground/boostSpline.cpp | manavjain99/oscar_buggy | b5dab0848f8667c9515bcfb078730cd0c4060000 | [
"MIT"
] | null | null | null | code/playground/boostSpline.cpp | manavjain99/oscar_buggy | b5dab0848f8667c9515bcfb078730cd0c4060000 | [
"MIT"
] | null | null | null | #include<iostream>
#include<vector>
#include<algorithm>
#include<cmath>
using namespace std;
using vec = vector<double>;
struct SplineSet{
double a;
double b;
double c;
double d;
double x;
};
vector<SplineSet> spline(vec &x, vec &y)
{
int n = x.size()-1;
vec a;
a.insert(a.begin(), y.begin(), y.end());
vec b(n);
vec d(n);
vec h;
for(int i = 0; i < n; ++i)
h.push_back(x[i+1]-x[i]);
vec alpha;
alpha.push_back(0);
for(int i = 1; i < n; ++i)
alpha.push_back( 3*(a[i+1]-a[i])/h[i] - 3*(a[i]-a[i-1])/h[i-1] );
vec c(n+1);
vec l(n+1);
vec mu(n+1);
vec z(n+1);
l[0] = 1;
mu[0] = 0;
z[0] = 0;
for(int i = 1; i < n; ++i)
{
l[i] = 2 *(x[i+1]-x[i-1])-h[i-1]*mu[i-1];
mu[i] = h[i]/l[i];
z[i] = (alpha[i]-h[i-1]*z[i-1])/l[i];
}
l[n] = 1;
z[n] = 0;
c[n] = 0;
for(int j = n-1; j >= 0; --j)
{
c[j] = z [j] - mu[j] * c[j+1];
b[j] = (a[j+1]-a[j])/h[j]-h[j]*(c[j+1]+2*c[j])/3;
d[j] = (c[j+1]-c[j])/3/h[j];
}
vector<SplineSet> output_set(n);
for(int i = 0; i < n; ++i)
{
output_set[i].a = a[i];
output_set[i].b = b[i];
output_set[i].c = c[i];
output_set[i].d = d[i];
output_set[i].x = x[i];
}
return output_set;
}
int main()
{
vec x(6);
x[0] = (0);
x[1] = (1.2);
x[2] = (1.9);
x[3] = (3.2);
x[4] = (4.0);
x[5] = (6.5);
vec y(6);
y[0] = (0);
y[1] = (2.3);
y[2] = (3);
y[3] = (4.3);
y[4] = (2.9);
y[5] = (3.1);
//for(int i = 0; i < x.size(); ++i)
//{
// x[i] = i;
// y[i] = sin(i);
//}
vector<SplineSet> cs = spline(x, y);
cout << " Size is " << cs.size() << endl;
for(int i = 0; i < cs.size(); ++i)
cout << cs[i].d << "\t" << cs[i].c << "\t" << cs[i].b << "\t" << cs[i].a << endl;
} | 18.921569 | 89 | 0.391192 | [
"vector"
] |
47120488ed5fb3100fc1db429e7afd562fbaadec | 2,364 | hpp | C++ | geometry/include/overlap.hpp | Ludophonic/JigLib | 541ec63b345ccf01e58cce49eb2f73c21eaf6aa6 | [
"Zlib"
] | 10 | 2016-06-01T12:54:45.000Z | 2021-09-07T17:34:37.000Z | geometry/include/overlap.hpp | Ludophonic/JigLib | 541ec63b345ccf01e58cce49eb2f73c21eaf6aa6 | [
"Zlib"
] | null | null | null | geometry/include/overlap.hpp | Ludophonic/JigLib | 541ec63b345ccf01e58cce49eb2f73c21eaf6aa6 | [
"Zlib"
] | 4 | 2017-05-03T14:03:03.000Z | 2021-01-04T04:31:15.000Z | //==============================================================
// Copyright (C) 2004 Danny Chapman
// danny@rowlhouse.freeserve.co.uk
//--------------------------------------------------------------
//
/// @file overlap.hpp
///
/// Overlap tests compare two static geometries and tell you if they
/// overlap. If so then you might get some information about the
/// overlap properties, but when the function mirrors an intersection
/// test it will do less (to be faster)
///
/// The order of all these functions has the simplest primitive first
//
//==============================================================
#ifndef OVERLAP_HPP
#define OVERLAP_HPP
#include "../geometry/include/line.hpp"
#include "../geometry/include/rectangle.hpp"
#include "../geometry/include/triangle.hpp"
#include "../geometry/include/sphere.hpp"
#include "../geometry/include/capsule.hpp"
#include "../geometry/include/plane.hpp"
#include "../geometry/include/heightmap.hpp"
#include "../geometry/include/box.hpp"
#include "../geometry/include/aabox.hpp"
#include "../geometry/include/distance.hpp"
#include "../utils/include/fixedvector.hpp"
namespace JigLib
{
/// Indicates if a segment intersects a triangle
bool SegmentTriangleOverlap(const tSegment& seg, const tTriangle& tri);
/// Indicates if a segment intersects a plane
bool SegmentPlaneOverlap(const tSegment& seg, const tPlane& plane);
/// Indicates if a swept sphere would overlap a plane, and if so returns the t value (between
/// the old and new sphere positions) when intersection just occurs.
/// Both spheres should have the same radius!!
/// This returns false if the spheres are moving in the direction of the plane normal
/// If you've already calculated the distances of the sphere centres to the plane, pass them in.
/// The contact point final penetration are returned if there is overlap
bool SweptSpherePlaneOverlap(tVector3& pt, tScalar& finalPenetration,
const tSphere& sphereOld, const tSphere& sphereNew, const tPlane& plane,
tScalar* oldCentreDistToPlane, tScalar* newCentreDistToPlane);
/// Indicates if a segment overlaps an AABox
bool SegmentAABoxOverlap(const tSegment& seg, const tAABox AABox);
#include "../geometry/include/overlap.inl"
}
#endif
| 41.473684 | 104 | 0.653553 | [
"geometry"
] |
4712bdb29dd810ec36c08c12ad69ddc973ed2700 | 2,899 | cpp | C++ | src/libs/ml_models/ut/test_svm_predction.cpp | boazsade/machine_learinig_models | eb1f9eda0e4e25a6d028b25682dfb20628a20624 | [
"MIT"
] | null | null | null | src/libs/ml_models/ut/test_svm_predction.cpp | boazsade/machine_learinig_models | eb1f9eda0e4e25a6d028b25682dfb20628a20624 | [
"MIT"
] | null | null | null | src/libs/ml_models/ut/test_svm_predction.cpp | boazsade/machine_learinig_models | eb1f9eda0e4e25a6d028b25682dfb20628a20624 | [
"MIT"
] | null | null | null |
#include <boost/test/unit_test.hpp>
#include "acc_data_input.hpp"
#include "expected_prediction.h"
#include "../src/svm_impl/classifiers_generator.h"
#include "../src/svm_impl/svm_model.h"
namespace
{
// arguments for the training
const constexpr auto coat_value = 32.0;
const constexpr auto gamma_value = 0.0078125;
} // end of namespace
BOOST_AUTO_TEST_CASE(test_svm_acc_model_classifier)
{
using namespace mlmodels;
// we would test if we are generating the same results as
// we are getting from running libsvm tools - please note that the
// parameters above as well as the expected results where generated by using
// tools from libsvm which includes running
// ./svm-scale -l -1 -u 1 -s range1 train_input > train_input.scale
// ./svm-scale -r range1 test_input > test_input.scale
// tools/grid.py train_input.scale
// ./svm-train -c 32 -g 0.0078125 train_input.scale
// ./svm-predict test_input.scale train_input.scale.model prediction
// to generate the data input we generate 400 lines for input for train and 283 lines of test
// from the file dataset_libsvm in this directory
auto model = svm::classifier::create_model(svm::classifier::c_rbf_train{
svm::classifier::c_rbf_train::base_1
{
svm::rbf_args{gamma_value},
svm::base_train_params{}
},
svm::classifier::c_rbf_train::base_2{
coat_value, 0, 0
}
},
train_features, acc_train_labels
);
BOOST_TEST_REQUIRE((model.get() != nullptr), "failed to generate C SVM model, with train data");
// run run prediction
auto predictions = svm::predict(model, test_features);
BOOST_TEST_REQUIRE(not predictions.empty(), "failed to get predictions!!");
BOOST_TEST_REQUIRE(predictions.size() == expected_results_prediction.size(), "number of predictions do not match expetection: "
<<predictions.size()<<" != "<<expected_results_prediction.size());
// now compare results
auto expted_begin = std::begin(expected_results_prediction);
unsigned int at = 0;
for (auto our_results : predictions) {
BOOST_TEST(our_results == *expted_begin, "["<<at<<"] our results "<<our_results<<" do not match expected results "<<*expted_begin);
++expted_begin;
++at;
}
// svm::save(model, "/tmp/ut_csvm_rbf.model");
}
| 49.135593 | 139 | 0.562953 | [
"model"
] |
472afa18f4892fd3ae518e4a4d2cf1eb44d7ae93 | 4,084 | cc | C++ | labs/13-verilog-uart/2-tx/sim.cc | dddrrreee/cs240lx-22spr | 7cab61cbe2ff7779ca414ca7ff64ea00914bf362 | [
"MIT"
] | 2 | 2022-03-29T03:59:29.000Z | 2022-03-29T04:27:26.000Z | labs/13-verilog-uart/2-tx/sim.cc | dddrrreee/cs240lx-22spr | 7cab61cbe2ff7779ca414ca7ff64ea00914bf362 | [
"MIT"
] | null | null | null | labs/13-verilog-uart/2-tx/sim.cc | dddrrreee/cs240lx-22spr | 7cab61cbe2ff7779ca414ca7ff64ea00914bf362 | [
"MIT"
] | null | null | null | #include <stdlib.h>
#include "Vuart_top_uart_rx.h"
#include "Vuart_top_uart_top.h"
#include "Vuart_top.h"
#include "verilated.h"
#include "verilated_vcd_c.h"
#define DEBUG 0
#if (DEBUG == 1)
#define dprintf(args...) printf(args)
#else
#define dprintf(args...)
#endif
#define BYTE_TO_BINARY_PATTERN "%c%c%c%c%c%c%c%c"
#define BYTE_TO_BINARY(byte) \
(byte & 0x80 ? '1' : '0'), \
(byte & 0x40 ? '1' : '0'), \
(byte & 0x20 ? '1' : '0'), \
(byte & 0x10 ? '1' : '0'), \
(byte & 0x08 ? '1' : '0'), \
(byte & 0x04 ? '1' : '0'), \
(byte & 0x02 ? '1' : '0'), \
(byte & 0x01 ? '1' : '0')
static int simtime = 0;
static std::vector<uint8_t> rxed_from_dut;
static int tx(Vuart_top* dut, VerilatedVcdC* tfp, int cycles_per_bit, int bit) {
int saw_done = 0;
dut->rx = bit;
for (int i = 0; i < cycles_per_bit; i++) {
dut->clk = 0;
dut->eval();
tfp->dump(simtime++);
dut->clk = 1;
dut->eval();
tfp->dump(simtime++);
rxed_from_dut.push_back(dut->tx);
if (dut->uart_top->rx_unit->rx_done_tick) {
saw_done = 1;
}
}
return saw_done;
}
static void send_byte(Vuart_top* dut, VerilatedVcdC* tfp, int cycles_per_bit, uint8_t byte) {
// start bit
tx(dut, tfp, cycles_per_bit, 0);
// data
uint8_t tx_byte = byte;
printf("%d: transmitting %d...\n", simtime, tx_byte);
for (int i = 0; i < 8; i++) {
tx(dut, tfp, cycles_per_bit, tx_byte & 0x1);
tx_byte >>= 1;
}
// stop bit
int done = tx(dut, tfp, cycles_per_bit, 1);
// check
if (dut->uart_top->rx_unit->dout == byte && done) {
dprintf("PASS (rx): received %d\n", dut->uart_top->rx_unit->dout);
} else {
if (dut->uart_top->rx_unit->dout != byte) {
printf("FAIL: data mistmatch: %d != %d\n", dut->uart_top->rx_unit->dout, byte);
}
if (!done) {
printf("FAIL: did not see rx_done_tick\n");
}
}
}
#define CLK_MHZ 48
int main() {
int cycles_per_bit = CLK_MHZ * 1000000 / 19200;
Verilated::traceEverOn(true);
Vuart_top* dut = new Vuart_top;
VerilatedVcdC* tfp = new VerilatedVcdC;
dut->trace(tfp, 99);
tfp->open("trace.vcd");
int time = 0;
int clk = 0;
// idle
tx(dut, tfp, cycles_per_bit, 1);
std::vector<uint8_t> sent_bytes;
for (int i = 0; i < 4; i++) {
uint8_t to_send = rand();
sent_bytes.push_back(to_send);
send_byte(dut, tfp, cycles_per_bit, to_send);
}
// send an additional zero byte to give enough simulation time for the dut
// to transmit back the bytes we sent earlier.
send_byte(dut, tfp, cycles_per_bit, 0);
dprintf("Cycles per bit: %d\n", cycles_per_bit);
printf("Checking tx...\n");
int tx_clk = 0;
for (uint8_t expected : sent_bytes) {
if (rxed_from_dut[tx_clk] != 1) {
printf("FAIL: first bit transmitted is not 0\n");
return 1;
}
tx_clk++;
for (int i = 1; i < rxed_from_dut.size(); i++, tx_clk++) {
if (rxed_from_dut[tx_clk] == 0) {
dprintf("%d: saw start of start bit\n", tx_clk);
break;
}
}
// start bit
for (int i = 0; i < cycles_per_bit / 2; i++, tx_clk++) {
if (rxed_from_dut[tx_clk] != 0) {
printf("%d: FAIL: start bit is not 0\n", tx_clk);
return 1;
}
}
uint8_t byte_from_dut = 0;
for (int i = 0; i < 8; i++) {
tx_clk += cycles_per_bit;
byte_from_dut |= (rxed_from_dut[tx_clk] << i);
}
tx_clk += cycles_per_bit;
if (rxed_from_dut[tx_clk] != 1) {
printf("%d: FAIL: stop bit is not 1\n", tx_clk);
return 1;
}
if (byte_from_dut != expected) {
printf("FAIL: FPGA echoed %d, expected %d\n", byte_from_dut, expected);
} else {
printf("PASS: FPGA echoed %d\n", byte_from_dut);
}
}
tfp->close();
return 0;
}
| 26.179487 | 93 | 0.534525 | [
"vector"
] |
472d01a3aed1cae6224b22bdbc71c5299f4f84a9 | 5,253 | cc | C++ | tvm/src/pass/infer_reuse_bound.cc | hj424/heterocl | e51b8f7f65ae6ad55c0c2426ab7192c3d8f6702b | [
"Apache-2.0"
] | 7 | 2019-08-20T02:43:44.000Z | 2019-12-13T14:26:05.000Z | tvm/src/pass/infer_reuse_bound.cc | hj424/heterocl | e51b8f7f65ae6ad55c0c2426ab7192c3d8f6702b | [
"Apache-2.0"
] | null | null | null | tvm/src/pass/infer_reuse_bound.cc | hj424/heterocl | e51b8f7f65ae6ad55c0c2426ab7192c3d8f6702b | [
"Apache-2.0"
] | 2 | 2019-07-18T14:13:35.000Z | 2020-01-04T01:45:34.000Z | /*!
* Copyright (c) 2019 by Contributors
* \file loop_partition.cc
*/
#include <tvm/ir.h>
#include <tvm/ir_visitor.h>
#include <tvm/ir_mutator.h>
#include <tvm/ir_pass.h>
#include <tvm/operation.h>
#include <arithmetic/Substitute.h>
namespace TVM {
namespace ir {
// collect all load indices that contains the reuse target
class LoadCollector final : public IRVisitor {
public:
LoadCollector(
const Variable* target,
std::vector<std::vector<Expr> >& expr_list,
std::map<const Variable*, Expr>& min_map,
std::map<const Variable*, Expr>& max_map,
const Array<Expr>& target_shape,
std::unordered_map<const Variable*, Expr>& range)
: target_(target), expr_list_(expr_list),
min_map_(min_map), max_map_(max_map),
target_shape_(target_shape), range_(range) {}
void Visit_(const Load* op) {
this->Visit(op->index);
if (op->buffer_var.get() == target_) {
std::vector<Expr> new_index = ExtractIndices(op->index, target_shape_, range_);
for (size_t i = 0; i < new_index.size(); i++)
expr_list_.push_back(new_index);
}
}
void Visit_(const For* op) {
min_map_[op->loop_var.get()] = op->min;
max_map_[op->loop_var.get()] = op->extent - 1;
this->Visit(op->body);
}
private:
const Variable* target_;
// a list of indices; each index is represented with a tuple
// e.g., [[x, y], [x+1, y], [x+2, y]]
// e.g., [[x+r, y+c]]
std::vector<std::vector<Expr> >& expr_list_;
// key, value = loop_var, min
std::map<const Variable*, Expr>& min_map_;
// key, value = loop_var, extent-1
std::map<const Variable*, Expr>& max_map_;
const Array<Expr>& target_shape_;
std::unordered_map<const Variable*, Expr>& range_;
};
Array<Expr> InferReuseBound(
const Stmt& body,
const Variable* target,
const Array<Expr>& target_shape,
std::unordered_map<const Variable*, Expr>& range) {
// collect load expression related to the target
std::vector<std::vector<Expr> > expr_list;
std::vector<std::vector<Expr> > diff_list;
std::vector<Expr> min_list;
std::map<const Variable*, Expr> min_map;
std::map<const Variable*, Expr> max_map;
LoadCollector visitor(
target,
expr_list,
min_map,
max_map,
target_shape,
range);
visitor.Visit(body);
int reuse = -1;
// find the min_expr and max_expr for each dimension
Array<Expr> reuse_shape;
// if nothing can be reused
if (expr_list.size() == 0) return reuse_shape;
size_t ndim = expr_list[0].size();
for (size_t dim = 0; dim < ndim; dim++) {
// find the bound
// e.g. x+r with {r=[0, 2], c=[0, 2], x=[0, 7]}
// min_expr = 0, max_expr = 9
// e.g. y+c with {r=[0, 2], c=[0, 2], x=[0, 7]}
// min_expr = y, max_expr = y+2
// e.g. [x, x+1, x+2] with {}
// min_expr = x, max_expr = x+2
Expr min_expr = substitute(min_map, expr_list[0][dim]);
Expr max_expr = substitute(max_map, expr_list[0][dim]);
size_t min_index = 0;
for (size_t i = 1; i < expr_list.size(); i++) {
Expr new_min_expr = substitute(min_map, expr_list[i][dim]);
Expr new_max_expr = substitute(max_map, expr_list[i][dim]);
Expr min_diff = Simplify(min_expr - new_min_expr);
Expr max_diff = Simplify(new_max_expr - max_expr);
if (!is_const(min_diff) || !is_const(max_diff))
LOG(FATAL) << "The bound of the reuse region cannot be determined";
if (is_one(Simplify(min_diff > 0))) {
min_index = i;
min_expr = new_min_expr;
}
if (is_one(Simplify(max_diff > 0))) max_expr = new_max_expr;
}
// check if the bounde is constant
// e.g. x+r => diff_expr = 10
// e.g. y+c => diff_expr = 3
Expr diff_expr = Simplify(max_expr - min_expr + 1);
if (!is_const(diff_expr)) // e.g. y*(y+c) would be illegal
LOG(FATAL) << "Irregular access pattern is not yet supported";
/* TODO: add this back when merge with reuse buffer
// check if the specified axis is reused by running the next iteration
std::map<const Variable*, Expr> next_subst;
next_subst[op->loop_var.get()] = op->loop_var + 1;
// first check if the axis is the specified reuse axis
// e.g. y => y+1
Expr next_min = substitute(next_subst, min_expr);
Expr next_diff = Simplify(next_min - min_expr);
if (!is_const(next_diff)) // e.g. y*y+c would be illegal
LOG(FATAL) << "Irregular access pattern is not yet supported";
// then check if we there is reuse in this axis
// e.g. y+c => incr_index_diff = 1
if (!is_zero(next_diff)) {
if (!is_one(next_diff)) // e.g. 2*y+c would be illegal
LOG(FATAL) << "Irregular access pattern is not yet supported";
// check if there is overlap between reuse axis
// e.g. next_min = y+1, max_incr = y+2
Expr compare = Simplify(max_expr > next_min);
if (!is_zero(compare))
reuse = dim;
}
*/
if (auto imm = diff_expr.as<IntImm>())
diff_expr = IntImm::make(Int(32), imm->value);
reuse_shape.push_back(diff_expr);
min_list.push_back(expr_list[min_index][dim]);
} // end for each dim
return reuse_shape;
}
} // end namespace ir
} // end namespace TVM
| 36.227586 | 87 | 0.625167 | [
"vector"
] |
47395839860b65019527439c9baf1ab754518748 | 15,703 | cpp | C++ | biggles/model.cpp | fbi-octopus/biggles | 2dac4f1748ab87242951239caf274f302be1143a | [
"Apache-2.0"
] | 1 | 2019-11-15T14:01:59.000Z | 2019-11-15T14:01:59.000Z | biggles/model.cpp | fbi-octopus/biggles | 2dac4f1748ab87242951239caf274f302be1143a | [
"Apache-2.0"
] | null | null | null | biggles/model.cpp | fbi-octopus/biggles | 2dac4f1748ab87242951239caf274f302be1143a | [
"Apache-2.0"
] | null | null | null | #include <boost/assert.hpp>
#include <boost/foreach.hpp>
#include <boost/filesystem.hpp>
#include <boost/format.hpp>
//#include <boost/math/special_functions/binomial.hpp>
#include <cmath>
#include <Eigen/Dense>
#include <limits>
#include <vector>
#include <fstream>
#include "kalman_filter.hpp"
#include "kalman_filter_cache.hpp"
#include "model.hpp"
#include "partition.hpp"
#include "io.hpp"
//using boost::math::binomial_coefficient;
namespace biggles
{
namespace model
{
namespace detail
{
// log multivariate gamma function with p == 2
inline float lgamma_2(float x)
{
// see http://en.wikipedia.org/wiki/Multivariate_gamma_function
return 0.5f*logf(M_PI) + lgammaf(x) + lgammaf(x-0.5f);
}
// log of the inverse Wishart PDF.
inline float log_inverse_wishart_pdf(const Eigen::Matrix2f& B, const Eigen::Matrix2f& Phi, int m)
{
// see http://en.wikipedia.org/wiki/Inverse-Wishart_distribution
float log_det_B = logf(B.determinant());
float log_det_Phi = logf(Phi.determinant());
float trace_Phi_B_inv = (Phi * B.inverse()).trace();
return 0.5f*m*log_det_Phi - 0.5f*(m+2+1)*log_det_B - 0.5f*trace_Phi_B_inv - 0.5f*(2*m)*logf(2.f) - lgamma_2(0.5f*m);
}
}
/// \brief calculates p(partition | clutter rate)
///
/// This function seems to be uncontroversial
float log_partition_given_clutter_rate_density(const partition& part_sample, const model::parameters& para_sample) {
const time_stamp part_first_ts = part_sample.first_time_stamp();
const time_stamp part_last_ts = part_sample.last_time_stamp();
const time_stamp part_duration = part_last_ts - part_first_ts;
/*
std::vector<size_t> clutter_counts(part_duration);
BOOST_FOREACH(const observation& obs, part_sample.clutter()) {
++clutter_counts[t(obs) - part_first_ts];
}
*/
float lambda_f = clutter_rate(para_sample);
/*
if (not std::isfinite(lambda_f)) {
std::stringstream sstr;
sstr << "clutter rate is not finite: " << lambda_f;
throw std::runtime_error(sstr.str()) ;
}
*/
BOOST_ASSERT(std::isfinite(lambda_f));
BOOST_ASSERT(lambda_f >= 0);
float log_part_clutter = part_sample.clutter().size() * logf(lambda_f) - part_duration * lambda_f;
for (clutter_t::const_iterator it = part_sample.clutter().begin(); it not_eq part_sample.clutter().end(); ++it) {
log_part_clutter += -lgammaf(1.f + it->second.size());
}
return log_part_clutter;
}
float log_partition_given_survival_prob_density(const partition& part_sample, const model::parameters& para_sample) {
binomial_coefficient& binom_coeff = binomial_coefficient::get();
const time_stamp part_first_ts = part_sample.first_time_stamp();
const time_stamp part_last_ts = part_sample.last_time_stamp();
const time_stamp part_duration = part_last_ts - part_first_ts;
const int min_surv = 0; // number of guaranteed survivals
std::vector<size_t> survival_events(part_duration);
std::vector<size_t> death_events(part_duration);
BOOST_FOREACH(const boost::shared_ptr<const track>& t_ptr, part_sample.tracks()) {
BOOST_ASSERT(t_ptr->duration() > min_surv);
time_stamp track_first_ts = t_ptr->first_time_stamp();
time_stamp track_last_ts = t_ptr->last_time_stamp();
for (time_stamp ts = track_first_ts - part_first_ts + 1 + min_surv; ts < track_last_ts - part_first_ts; ++ts)
survival_events[ts]++;
if (track_last_ts < part_last_ts)
death_events[track_last_ts - part_first_ts]++;
}
float log_part_surv = 0.f;
float log_p_s = logf(survival_probability(para_sample));
float log_1m_p_s = logf(1.f - survival_probability(para_sample));
for ( time_stamp i = 0; i < part_duration; ++i) {
log_part_surv += logf(binom_coeff(survival_events[i] + death_events[i], survival_events[i])) +
survival_events[i] * log_p_s + death_events[i] * log_1m_p_s;
}
return log_part_surv;
}
float log_partition_given_observation_prob_density(const partition& part_sample, const model::parameters& para_sample) {
binomial_coefficient& binom_coeff = binomial_coefficient::get();
const time_stamp part_first_ts = part_sample.first_time_stamp();
const time_stamp part_last_ts = part_sample.last_time_stamp();
const time_stamp part_duration = part_last_ts - part_first_ts;
const size_t min_obs = 0; //number of guaranteed observations
std::vector<size_t> track_events(part_duration);
std::vector<size_t> observation_events(part_duration);
BOOST_FOREACH(const boost::shared_ptr<const track>& t_ptr, part_sample.tracks()) {
time_stamp track_first_ts = t_ptr->first_time_stamp();
time_stamp track_last_ts = t_ptr->last_time_stamp();
for (time_stamp ts = track_first_ts - part_first_ts; ts < track_last_ts - part_first_ts; ++ts)
track_events[ts]++;
BOOST_ASSERT(t_ptr->observations().size() >= min_obs);
observation_collection::const_iterator obs_iter = t_ptr->observations().begin();
for (size_t i = 0; i < min_obs; ++i) {
track_events[t(*obs_iter) - part_first_ts]--;
obs_iter++;
}
for (; obs_iter != t_ptr->observations().end(); ++obs_iter)
observation_events[t(*obs_iter) - part_first_ts]++;
}
float log_part_obs = 0.f;
float log_p_o = logf(observation_probability(para_sample));
float log_1m_p_o = logf(1.f - observation_probability(para_sample));
for (time_stamp i = 0; i < part_duration; ++i) {
log_part_obs += logf(binom_coeff(track_events[i], observation_events[i])) +
observation_events[i] * log_p_o + (track_events[i] - observation_events[i]) * log_1m_p_o;
}
return log_part_obs;
}
float log_partition_given_birth_rate_density(const partition& part_sample, const model::parameters& para_sample) {
const time_stamp part_first_ts = part_sample.first_time_stamp();
const time_stamp part_last_ts = part_sample.last_time_stamp();
const time_stamp part_duration = part_last_ts - part_first_ts;
const int min_surv = 0; // number of guaranteed survivals
std::vector<size_t> birth_events(part_duration);
BOOST_FOREACH(const boost::shared_ptr<const track>& t_ptr, part_sample.tracks()) {
BOOST_ASSERT(t_ptr->duration() > min_surv);
time_stamp track_first_ts = t_ptr->first_time_stamp();
birth_events[track_first_ts - part_first_ts]++;
}
float lambda_b = birth_rate(para_sample);
size_t n_total_born(part_sample.tracks().size());
float log_part_birth = n_total_born * logf(lambda_b) - (part_duration - min_surv) * lambda_b;
// TODO: the value for lgammaf may be stored and recalled rather than recalculated; could be faster.
for (time_stamp i = 0; i < part_duration; ++i)
log_part_birth += -lgammaf(1.f + birth_events[i]);
return log_part_birth;
}
float log_partition_given_parameters_density_orig(const partition& partition, const model::parameters& parameters)
{
float log_pdf = 0.f;
off_t n_frames = partition.duration();
// ensemble statistics over all time stamps
off_t n_total_born(partition.tracks().size());
off_t n_total_false(partition.clutter().size());
off_t n_total_died(partition.tracks().size()); // everything that has a beginning has an end, Neo.
off_t n_total_survived(0);
off_t n_total_generated(0);
// calculate n_total_survived and n_total_generated. record birth times for tracks
std::vector<size_t> birth_counts(partition.last_time_stamp() - partition.first_time_stamp());
BOOST_FOREACH(const boost::shared_ptr<const track>& t_ptr, partition.tracks())
{
BOOST_ASSERT(t_ptr->duration() > 1);
// a track 'survives' for one fewer ticks than it's duration
n_total_survived += t_ptr->duration() - 1;
// the track's size is the number of observations within it
n_total_generated += t_ptr->size();
// record birth time
BOOST_ASSERT(t_ptr->first_time_stamp() >= partition.first_time_stamp());
BOOST_ASSERT(t_ptr->first_time_stamp() - partition.first_time_stamp() < static_cast<time_stamp>(birth_counts.size()));
++birth_counts[t_ptr->first_time_stamp() - partition.first_time_stamp()];
}
// record clutter counts
std::vector<size_t> clutter_counts(partition.last_time_stamp() - partition.first_time_stamp());
for (clutter_t::const_iterator it = partition.clutter().begin(); it not_eq partition.clutter().end(); ++it) {
clutter_counts[it->first - partition.first_time_stamp()] = it->second.size();
}
// p_s term
float p_s = frame_to_frame_survival_probability(parameters);
BOOST_ASSERT(std::isfinite(p_s) and p_s >= 0);
log_pdf += n_total_survived * logf(p_s) + n_total_died * logf(1.f - p_s);
// p_d term
float p_d = generate_observation_probability(parameters);
BOOST_ASSERT(std::isfinite(p_d) and p_d >= 0);
log_pdf += n_total_generated * logf(p_d) + (n_total_survived + n_total_born - n_total_generated) * logf(1.f - p_d);
// start of lambda_b term
float lambda_b = mean_new_tracks_per_frame(parameters);
BOOST_ASSERT(std::isfinite(lambda_b) and lambda_b >= 0);
log_pdf += n_total_born * logf(lambda_b) - n_frames * lambda_b; // ... still to calculate log gamma terms
// start of lambda_f term
float lambda_f = mean_false_observations_per_frame(parameters);
if (not std::isfinite(lambda_f)) {
std::stringstream sstr;
sstr << "clutter rate is not finite: " << lambda_f;
throw std::runtime_error(sstr.str()) ; // TODO debug cleaning up
}
BOOST_ASSERT(std::isfinite(lambda_f));
BOOST_ASSERT(lambda_f >= 0);
log_pdf += n_total_false * logf(lambda_f) - n_frames * lambda_f; // ... still to calculate log gamma terms
// finish lambda_b and lambda_f terms
for(time_stamp ts = partition.first_time_stamp(); ts < partition.last_time_stamp(); ++ts)
{
// finish lambda_b term
log_pdf += -lgammaf(1.f + birth_counts[ts - partition.first_time_stamp()]);
// finish lambda_f term
log_pdf += -lgammaf(1.f + clutter_counts[ts - partition.first_time_stamp()]);
}
return log_pdf; // the rest is just a repeat of P(T|clutter_rate)
}
float log_partition_given_parameters_density(
const partition& partition_sample, const model::parameters& parameter_sample)
{
return log_partition_given_parameters_density_orig(partition_sample, parameter_sample);
}
float log_clutter_given_parameters_density(const partition& part, const model::parameters& parameters) {
return -logf(part.volume())*part.clutter().size();
}
float log_track_given_parameters_density(const boost::shared_ptr<const track>& track_p, const model::parameters& parameters)
{
return track_p->log_posterior(parameters);
}
float log_parameters_prior_density(const model::parameters& parameters)
{
// finite regions of support:
if(mean_new_tracks_per_frame(parameters) <= 0.f)
return -std::numeric_limits<float>::max();
if(mean_false_observations_per_frame(parameters) <= 0.f)
return -std::numeric_limits<float>::max();
if(frame_to_frame_survival_probability(parameters) < 0.f)
return -std::numeric_limits<float>::max();
if(frame_to_frame_survival_probability(parameters) > 1.f)
return -std::numeric_limits<float>::max();
if(generate_observation_probability(parameters) < 0.f)
return -std::numeric_limits<float>::max();
if(generate_observation_probability(parameters) > 1.f)
return -std::numeric_limits<float>::max();
/*
if (mean_false_observations_per_frame(parameters) != 0.1f) { // FIXME PRIOR calculation
return -std::numeric_limits<float>::max();
}
if (mean_new_tracks_per_frame(parameters) != .5f) { // FIXME PRIOR calculation
return -std::numeric_limits<float>::max();
}
if (generate_observation_probability(parameters) != .9f) { // FIXME PRIOR calculation
return -std::numeric_limits<float>::max();
}
if (frame_to_frame_survival_probability(parameters) != .9f) { // FIXME PRIOR calculation
return -std::numeric_limits<float>::max();
}
*/
// prior on R:
// FIXME PRIOR calculation
/*
if ( observation_error_covariance(parameters) == Eigen::Matrix2f::Identity()* 0.09f ) {
return 0.f;
} else {
return -std::numeric_limits<float>::max();
}
*/
return detail::log_inverse_wishart_pdf(observation_error_covariance(parameters), 2.f * Eigen::Matrix2f::Identity(), 5);
}
float log_likelihood(const partition& part_sample, const model::parameters& para_sample) {
float log_pdf(0.f);
// track PDFs
BOOST_FOREACH(const boost::shared_ptr<const track>& t_ptr, part_sample.tracks())
{
log_pdf += log_track_given_parameters_density(t_ptr, para_sample);
}
// clutter PDF
log_pdf += log_clutter_given_parameters_density(part_sample, para_sample);
return log_pdf;
}
float log_tracks_given_parameters_density(const partition& part, const model::parameters& parameters) {
// track PDFs
float log_pdf(0.f);
BOOST_FOREACH(const boost::shared_ptr<const track>& t_ptr, part.tracks())
{
float track_log_pdf = log_track_given_parameters_density(t_ptr, parameters);
if (not std::isfinite(track_log_pdf)) {
std::cerr << "track duration " << t_ptr->duration() << std::endl;
std::cerr << "track size " << t_ptr->size() << std::endl;
}
log_pdf += track_log_pdf;
}
return log_pdf;
}
void dump_part_para(const partition& part, const model::parameters& para) {
size_t ctr = 0;
std::string fname = boost::str(boost::format("no_finite_log_pdf.%04d.json") % ctr);
while (boost::filesystem::exists(fname)) {
ctr++;
if (ctr > 9999) {
std::cerr << "nothing dumped :(" << std::endl;
return;
}
fname = boost::str(boost::format("no_finite_log_pdf.%04d.json") % ctr);
}
std::ofstream fh(fname.c_str());
fh << "{ \"parameters\": ";
io::write_model_parameters_to_json_stream(fh, para);
fh << ", \"partition\": " << std::endl;
io::write_partition_to_json_stream(fh, part);
fh << "}" << std::endl;
}
float log_partition_given_parameters_and_data_density(const partition& part, const model::parameters& parameters)
{
float log_pdf(0.f);
float temp(0.f);
// clutter PDF
temp = log_clutter_given_parameters_density(part, parameters);
if (not std::isfinite(temp)) {
std::cerr << " *** clutter log density not finite" << std::endl;
std::cerr << " " << part.volume() << std::endl;
dump_part_para(part, parameters);
}
log_pdf += temp;
temp = log_tracks_given_parameters_density(part, parameters);
if (not std::isfinite(temp)) {
std::cerr << " *** track log density not finite" << std::endl;
std::cerr << temp << std::endl;
std::cerr << model::observation_error_covariance(parameters) << std::endl;
dump_part_para(part, parameters);
}
log_pdf += temp;
//log_pdf = 0.f; // FIXME PRIOR test get rid of this line again
// data-independent track PDF
temp = log_partition_given_parameters_density(part, parameters);
if (not std::isfinite(temp)) {
std::cerr << " *** partition log density not finite" << std::endl;
dump_part_para(part, parameters);
}
log_pdf += temp;
// prior
// the prior is only need to record the log pdf and not for the sampling itself.
// log_pdf += log_parameters_prior_density(parameters);
return log_pdf;
}
}
}
| 40.576227 | 126 | 0.688722 | [
"vector",
"model"
] |
4741027b972b4b93be77cfb371423d9811ed0550 | 6,186 | hpp | C++ | src/entity-system/builders/entities/entity-type-builder/EntityTypeBuilder.hpp | inexorgame/entity-system | 230a6f116fb02caeace79bc9b32f17fe08687c36 | [
"MIT"
] | 19 | 2018-10-11T09:19:48.000Z | 2020-04-19T16:36:58.000Z | src/entity-system/builders/entities/entity-type-builder/EntityTypeBuilder.hpp | inexorgame-obsolete/entity-system-inactive | 230a6f116fb02caeace79bc9b32f17fe08687c36 | [
"MIT"
] | 132 | 2018-07-28T12:30:54.000Z | 2020-04-25T23:05:33.000Z | src/entity-system/builders/entities/entity-type-builder/EntityTypeBuilder.hpp | inexorgame-obsolete/entity-system-inactive | 230a6f116fb02caeace79bc9b32f17fe08687c36 | [
"MIT"
] | 3 | 2019-03-02T16:19:23.000Z | 2020-02-18T05:15:29.000Z | #pragma once
#include "entity-system/managers/entities/entity-type-manager/EntityTypeManager.hpp"
#include "entity-system/managers/entity-attributes/entity-attribute-instance-manager/EntityAttributeInstanceManager.hpp"
#include "entity-system/managers/entity-attributes/entity-attribute-type-manager/EntityAttributeTypeManager.hpp"
#include "entity-system/model/entities/entity-types/EntityType.hpp"
namespace inexor::entity_system {
class EntityTypeBuilder;
/// These using instructions help to shorten the following code.
using AttributeList = std::unordered_map<std::string, std::pair<DataType, Features>>;
using EntityTypeBuilderPtr = std::shared_ptr<EntityTypeBuilder>;
using EntityTypePtr = std::shared_ptr<EntityType>;
using EntityTypePtrOpt = std::optional<EntityTypePtr>;
/// @class EntityTypeBuilder
/// @brief A builder pattern class for entity types.
/// @note This template base class is part of a software design pattern called the <b>builder pattern</b>.<br>
/// https://en.wikipedia.org/wiki/Builder_pattern
/// @todo Should we lock the mutex as soon as a method gets called and unlock it
/// when the build() method is called ? Because otherwise multiple threads could
/// intercept this builder pattern and create "mixed" products.
class EntityTypeBuilder : public std::enable_shared_from_this<EntityTypeBuilder>
{
public:
/// These using instructions help to shorten the following code.
using EntityTypeManagerPtr = std::shared_ptr<EntityTypeManager>;
using EntityAttributeTypeManagerPtr = std::shared_ptr<EntityAttributeTypeManager>;
using EntityAttributeInstanceManagerPtr = std::shared_ptr<EntityAttributeInstanceManager>;
/// @brief Constructs the entity type builder.
/// @note The dependencies of this class will be injected automatically.<br>
/// BOOST_DI_INJECT constructor parameters is limited to BOOST_DI_CFG_CTOR_LIMIT_SIZE,<br>
/// which by default is set to 10. Not more than 10 arguments can be passed to the DI constructor!<br>
/// https://boost-experimental.github.io/di/user_guide/index.html
/// @param entity_type_manager The entity type manager.
/// @param entity_attribute_type_manager The entity attribute type manager.
/// @param entity_attribute_instance_manager The entity attribute instance manager.
EntityTypeBuilder(EntityTypeManagerPtr entity_type_manager, EntityAttributeTypeManagerPtr entity_attribute_type_manager, EntityAttributeInstanceManagerPtr entity_attribute_instance_manager);
/// @brief Destructs the entity type builder.
~EntityTypeBuilder();
/// @brief Sets the name of the entity type which is being built.
/// @note Because this method will be used in a builder pattern it does not make sense to rename it so "set_name".
/// @param entity_type_name The name of the new entity type.
EntityTypeBuilderPtr name(const std::string &entity_type_name);
/// @brief Sets the uuid of the entity type which is being built.
/// @note Because this method will be used in a builder pattern it does not make sense to rename it so "set_uuid".
/// @param entity_type_uuid The UUID of the new entity type.
EntityTypeBuilderPtr uuid(const std::string &entity_type_uuid);
/// @brief Sets the uuid of the entity type which is being built.
/// @note Because this method will be used in a builder pattern it does not make sense to rename it so "set_uuid".
/// @param entity_type_uuid The UUID of the new entity type.
EntityTypeBuilderPtr uuid(const xg::Guid &entity_type_uuid);
/// @brief Adds an attribute to the entity type which is being built.
/// @note Because this method will be used in a builder pattern it does not make sense to rename it so "set_attribute".
/// @param attribute_name The name of the new attribute.
/// @param attribute_datatype The data type of the new attribute.
/// @param attribute_features The features of the new attribute.
EntityTypeBuilderPtr attribute(const std::string &attribute_name, const DataType &attribute_datatype, const Features &attribute_features);
/// @brief Adds an input attribute to the entity type which is being built.
/// @note Because this method will be used in a builder pattern it does not make sense to rename it so "set_input".
/// @param attribute_name The name of the new attribute.
/// @param attribute_datatype The data type of the new attribute.
EntityTypeBuilderPtr input(const std::string &attribute_name, const DataType &attribute_datatype);
/// @brief Adds an output attribute to the entity type which is being built.
/// @note Because this method will be used in a builder pattern it does not make sense to rename it so "set_output".
/// @param attribute_name The name of the new attribute.
/// @param attribute_datatype The data type of the attribute.
EntityTypeBuilderPtr output(const std::string &attribute_name, const DataType &attribute_datatype);
/// @brief Adds an attribute which is an input and output at the same time to the entity type which is being built.
/// @note Because this method will be used in a builder pattern it does not make sense to rename it so "set_inout".
/// @param attribute_name The name of the new attribute.
/// @param attribute_datatype The data type of the attribute.
EntityTypeBuilderPtr inout(const std::string &attribute_name, const DataType &attribute_datatype);
/// @brief Builds and returns the created entity type.
EntityTypePtrOpt build();
private:
/// The entity type manager.
EntityTypeManagerPtr entity_type_manager;
/// The entity attribute instance manager.
EntityAttributeTypeManagerPtr entity_attribute_type_manager;
/// The entity attribute instance manager.
EntityAttributeInstanceManagerPtr entity_attribute_instance_manager;
/// The name of the new entity type.
std::string entity_type_name;
/// The UUID of the new entity type.
std::string entity_type_uuid;
/// The attribute definitions.
AttributeList entity_type_attributes;
/// The mutex of this class
std::mutex entity_type_builder_mutex;
};
} // namespace inexor::entity_system
| 54.743363 | 194 | 0.760103 | [
"model"
] |
4744ba1e89893d3fb6c4cfcd0fabf5638d2981a0 | 4,630 | hh | C++ | src/pypa/ast/dump.hh | RangelReale/libpypa | e4b3c359d3d2a9ccbea1cbb0a977af8219dd64ef | [
"Apache-2.0"
] | 152 | 2015-01-01T02:26:21.000Z | 2022-03-04T12:18:15.000Z | src/pypa/ast/dump.hh | kattkieru/libpypa | 5e7a4833da515d0cd2d850d51f082000c9e9f651 | [
"Apache-2.0"
] | 43 | 2015-01-22T00:49:10.000Z | 2019-02-26T22:42:59.000Z | src/pypa/ast/dump.hh | kattkieru/libpypa | 5e7a4833da515d0cd2d850d51f082000c9e9f651 | [
"Apache-2.0"
] | 42 | 2015-01-02T11:29:49.000Z | 2022-03-04T12:18:17.000Z | // Copyright 2014 Vinzenz Feenstra
//
// 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 GUARD_PYPA_AST_DUMP_HH_INCLUDED
#define GUARD_PYPA_AST_DUMP_HH_INCLUDED
#include <pypa/ast/types.hh>
namespace pypa {
template<typename T>
struct ast_member_dump;
struct ast_member_dump_revisit {
int depth_;
ast_member_dump_revisit(int depth) : depth_(depth) {}
template< typename T >
bool operator() ( T const & v ) const {
ast_member_dump<T>::dump(depth_, v);
return true;
}
};
// Forward declaration for the dump visit implementation
struct Ast;
namespace detail {
void visit_dump_internal(int depth, Ast const & v);
template< typename T, typename V, typename F>
void apply_member(T & t, V T::*member, F f) {
f(t.*member);
}
template< typename T, typename V, typename F>
void apply_member(std::shared_ptr<T> t, V T::*member, F f) {
f((*t).*member);
}
inline void print_padding(int depth) {
while(depth--) printf(" ");
}
inline void dump_member_value(int depth, Ast const & v) {
print_padding(depth);
// This is used to dispatch it to the right ast_member_dump<T>
// implementation using ast_member_dump_revisit
visit_dump_internal(depth, v);
}
inline void dump_member_value(int depth, String const & v) {
printf("%s\n", v.c_str());
}
inline void dump_member_value(int depth, char const * v) {
printf("RAW BUFFER: %p\n", static_cast<void const*>(v));
}
inline void dump_member_value(int depth, bool v) {
printf("%s\n", v ? "True" : "False");
}
inline void dump_member_value(int depth, int const & v) {
printf("%d\n", int(v));
}
inline void dump_member_value(int depth, int64_t const & v) {
long long int p = v;
printf("%lld\n", p);
}
inline void dump_member_value(int depth, double const & v) {
printf("%g\n", v);
}
inline void dump_member_value(int depth, AstBoolOpType const & v) {
printf("%s\n", to_string(v));
}
inline void dump_member_value(int depth, AstUnaryOpType const & v) {
printf("%s\n", to_string(v));
}
inline void dump_member_value(int depth, AstCompareOpType const & v) {
printf("%s\n", to_string(v));
}
inline void dump_member_value(int depth, AstBinOpType const & v) {
printf("%s\n", to_string(v));
}
inline void dump_member_value(int depth, AstModuleKind const & v) {
printf("%s\n", to_string(v));
}
inline void dump_member_value(int depth, AstContext const & v) {
printf("%s\n", to_string(v));
}
template< typename T >
inline void dump_member_value(int depth, std::shared_ptr<T> const & v) {
if(!v) {
printf("<NULL>\n");
}
else {
T const & v_ = *v;
dump_member_value(int(depth), v_);
}
}
template< typename T >
inline void dump_padded_member(int depth, std::shared_ptr<T> const & v) {
if(!v) { printf("\n"); print_padding(depth+4); }
dump_member_value(depth+4, v);
}
template< typename T >
inline void dump_padded_member(int depth, T const & v) {
dump_member_value(depth+4, v);
}
template< typename T >
inline void dump_member_value(int depth, std::vector<T> const & v) {
if(v.empty()) {
printf("[]\n");
}
else {
printf("[");
for(auto const & e : v) {
dump_padded_member(depth, e);
}
print_padding(depth+4);
printf("]\n");
}
}
}
}
#endif // GUARD_PYPA_AST_DUMP_HH_INCLUDED
| 30.662252 | 81 | 0.558315 | [
"vector"
] |
4749fb3bb03a0f2f0492834ec2e9770305c88716 | 5,110 | cpp | C++ | src/point_location_rbtree.cpp | 4x7y/DCEL | 6e73a7229f5c71fb83dff7e19de04fa973665f92 | [
"MIT"
] | null | null | null | src/point_location_rbtree.cpp | 4x7y/DCEL | 6e73a7229f5c71fb83dff7e19de04fa973665f92 | [
"MIT"
] | null | null | null | src/point_location_rbtree.cpp | 4x7y/DCEL | 6e73a7229f5c71fb83dff7e19de04fa973665f92 | [
"MIT"
] | null | null | null | //
// Created by Xiaoqian Mu on 4/2/17.
//
#include "point_location_rbtree.h"
using namespace geo;
bool PlCompare::less(PointLocationEdge* e1, PointLocationEdge* e2){
if(e1!= nullptr&&e2!= nullptr) {
if (e1->v_r->point.y > e2->v_r->point.y)
return true;
if(e1->v_r->point.y == e2->v_r->point.y) {
if (e1->v_r->point.x < e2->v_r->point.x)
return true;
else if(e1->v_r->point.x == e2->v_r->point.x){
if(e1->v_l->point.y > e2->v_l->point.y)
return true;
}
}
}
return false;
}
bool PlCompare::less(PointLocationVertex* v2, PointLocationEdge *e1) {
double lx=e1->v_l->point.x;
double ly=e1->v_l->point.y;
double rx=e1->v_r->point.x;
double ry=e1->v_r->point.y;
double x=v2->vertex->point.x;
double y=v2->vertex->point.y;
if(x==lx&&y>ly)
return false;
if(y<ly+(x-lx)/(rx-lx)*(ry-ly))
return false;
return true;
}
bool PlCompare::less(PointLocationEdge *e1, PointLocationVertex *v2) {
double lx=e1->v_l->point.x;
double ly=e1->v_l->point.y;
double rx=e1->v_r->point.x;
double ry=e1->v_r->point.y;
double x=v2->vertex->point.x;
double y=v2->vertex->point.y;
if(x==lx&&y>ly)
return true;
if(y<ly+(x-lx)/(rx-lx)*(ry-ly))
return true;
return false;
}
PLRbTree::PLRbTree(std::vector<PointLocationEdge> nodes, std::vector<PointLocationVertex> vers) {
PlCompare* cmp = new PlCompare();
for(int i=0;i<vers.size();i++) {
std::shared_ptr<PLRBTree> rbtree = std::make_shared<PLRBTree>(cmp);
if (i== 0) {
for(int p=i+1;p<vers.size();p++)
{
if(vers[p].vertex->point.x==vers[i].vertex->point.x)
i++;
else break;
}
for(int j=0;j<vers[i].edge_delete.size();j++){
rbtree->delete_value(vers[i].edge_delete[j]);
}
for(int k=0;k<vers[i].edge_insert.size();k++){
rbtree->insert(vers[i].edge_insert[k]);
}
}
else{
for(int p=i+1;p<vers.size();p++)
{
if(vers[p].vertex->point.x==vers[i].vertex->point.x)
i++;
else break;
}
for(int m=0;m<=i;m++){
for(int j=0;j<vers[m].edge_delete.size();j++){
rbtree->delete_value(vers[m].edge_delete[j]);
}
for(int k=0;k<vers[m].edge_insert.size();k++){
rbtree->insert(vers[m].edge_insert[k]);
}
}
}
double x_coor=vers[i].vertex->point.x;
roots.push_back(x_coor);
trees.push_back(rbtree);
}
delete cmp;
}
//
//PLRbTree::PLRbTree(std::vector<PointLocationEdge> nodes, std::vector<PointLocationVertex> vers) {
// PlCompare* cmp= new PlCompare();
// tree=RBTree<PointLocationEdge*, PointLocationVertex*, PlCompare>(cmp);
// for(int i=0;i<vers.size();i++) {
// if(i==0){
// for(int j=0;j<vers[0].edge_insert.size();j++)
// tree.insert(vers[0].edge_insert[j]);
//
// roots.push_back(tree.root->value);
// }
// else{
//// for(int j=0;j<vers[i].edge_delete.size();j++){
//// if(tree.root->value->v_r->point.y>vers[i].edge_delete[j]->v_r->point.y){
////
//// }
////
//// }
// }
//
// }
// delete cmp;
//}
int PLRbTree::Find_location(double x, double y) {
int low=0;
int high=roots.size()-1;
int mid=0;
int location=-1;
if(x<roots[low]||x>roots[high])
return -1;
if(x>=roots[low]&&x<roots[low+1]) {
location = low;
}
if(x>=roots[high]&&x<roots[high+1]) {
location = high;
}
while(location<0) {
mid=(low+high)/2;
if(x>=roots[mid]&&x<roots[mid+1])
location=mid;
if(x<roots[mid]){
high=mid;
}
if(x>roots[mid+1])
low=mid;
}
return location;
}
//DoubleEdgeListFace* PLRbTree::Search_point(int loc, PointLocationVertex* ver) {
//
// PointLocationEdge* edge_below=new PointLocationEdge();
// PointLocationEdge* edge_above=new PointLocationEdge();
// if(trees[loc]->get_smaller(ver,edge_below)&&trees[loc]->get_larger(ver,edge_above))
// return edge_below->v_l->leaving->getFace();
// else{
// return nullptr;
// }
//}
PointLocationEdge* PLRbTree::Search_point(int loc, PointLocationVertex* ver) {
PointLocationEdge* edge_below=new PointLocationEdge();
PointLocationEdge* edge_above=new PointLocationEdge();
if(trees[loc]->get_smaller(ver,edge_below)&&trees[loc]->get_larger(ver,edge_above))
return edge_below;
else{
return nullptr;
}
}
bool PLRbTree::above(double lx, double ly, double rx, double ry, double x, double y) {
if(x==lx&&y>ly)
return true;
if(y<ly+(x-lx)/(rx-lx)*(ry-ly))
return true;
return false;
}
| 26.340206 | 99 | 0.53092 | [
"vector"
] |
474b305e99217aee776b52e876902d711d9004ff | 769 | cxx | C++ | src/FastInputPreprocessor.cxx | QuantumDancer/lwtnn | ded198fb6ed3718c927b482e6e8710037a5de04a | [
"MIT"
] | null | null | null | src/FastInputPreprocessor.cxx | QuantumDancer/lwtnn | ded198fb6ed3718c927b482e6e8710037a5de04a | [
"MIT"
] | null | null | null | src/FastInputPreprocessor.cxx | QuantumDancer/lwtnn | ded198fb6ed3718c927b482e6e8710037a5de04a | [
"MIT"
] | null | null | null | #include "lwtnn/generic/FastInputPreprocessor.hh"
namespace lwt {
namespace generic {
namespace internal {
std::vector<size_t> get_value_indices(
const std::vector<std::string>& order,
const std::vector<lwt::Input>& inputs)
{
std::map<std::string, size_t> order_indices;
for (size_t i = 0; i < order.size(); i++) {
order_indices[order.at(i)] = i;
}
std::vector<size_t> value_indices;
for (const lwt::Input& input: inputs) {
if (!order_indices.count(input.name)) {
throw lwt::NNConfigurationException("Missing input " + input.name);
}
value_indices.push_back(order_indices.at(input.name));
}
return value_indices;
}
} // end internal namespace
} // end generic namespace
} // end lwt namespace
| 28.481481 | 75 | 0.661899 | [
"vector"
] |
474c6f6a3d5c70be769d87f26ef66252625155e0 | 3,186 | hh | C++ | lang/c++/api/AvroTraits.hh | sunjstack/avro | 5bd7cfe0bf742d0482bf6f54b4541b4d22cc87d9 | [
"Apache-2.0"
] | null | null | null | lang/c++/api/AvroTraits.hh | sunjstack/avro | 5bd7cfe0bf742d0482bf6f54b4541b4d22cc87d9 | [
"Apache-2.0"
] | null | null | null | lang/c++/api/AvroTraits.hh | sunjstack/avro | 5bd7cfe0bf742d0482bf6f54b4541b4d22cc87d9 | [
"Apache-2.0"
] | null | null | null | /*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
#ifndef avro_AvroTraits_hh__
#define avro_AvroTraits_hh__
#include "Config.hh"
#include "Types.hh"
#include <cstdint>
#include <type_traits>
/** @file
*
* This header contains type traits and similar utilities used by the library.
*/
namespace avro {
/**
* Define an is_serializable trait for types we can serialize natively.
* New types will need to define the trait as well.
*/
template<typename T>
struct is_serializable : public std::false_type {};
template<typename T>
struct is_promotable : public std::false_type {};
template<typename T>
struct type_to_avro {
static const Type type = AVRO_NUM_TYPES;
};
/**
* Check if a \p T is a complete type i.e. it is defined as opposed to just
* declared.
*
* is_defined<T>::value will be true or false depending on whether T is a
* complete type or not respectively.
*/
template<class T>
struct is_defined {
typedef char yes[1];
typedef char no[2];
template<class U>
static yes &test(char(*)[sizeof(U)]) { throw 0; };
template<class U>
static no &test(...) { throw 0; };
static const bool value = sizeof(test<T>(0)) == sizeof(yes);
};
/**
* Similar to is_defined, but used to check if T is not defined.
*
* is_not_defined<T>::value will be true or false depending on whether T is an
* incomplete type or not respectively.
*/
template<class T>
struct is_not_defined {
typedef char yes[1];
typedef char no[2];
template<class U>
static yes &test(char(*)[sizeof(U)]) { throw 0; };
template<class U>
static no &test(...) { throw 0; };
static const bool value = sizeof(test<T>(0)) == sizeof(no);
};
#define DEFINE_PRIMITIVE(CTYPE, AVROTYPE) \
template <> \
struct is_serializable<CTYPE> : public std::true_type{}; \
\
template <> \
struct type_to_avro<CTYPE> { \
static const Type type = AVROTYPE; \
};
#define DEFINE_PROMOTABLE_PRIMITIVE(CTYPE, AVROTYPE) \
template <> \
struct is_promotable<CTYPE> : public std::true_type{}; \
\
DEFINE_PRIMITIVE(CTYPE, AVROTYPE)
DEFINE_PROMOTABLE_PRIMITIVE(int32_t, AVRO_INT)
DEFINE_PROMOTABLE_PRIMITIVE(int64_t, AVRO_LONG)
DEFINE_PROMOTABLE_PRIMITIVE(float, AVRO_FLOAT)
DEFINE_PRIMITIVE(double, AVRO_DOUBLE)
DEFINE_PRIMITIVE(bool, AVRO_BOOL)
DEFINE_PRIMITIVE(Null, AVRO_NULL)
DEFINE_PRIMITIVE(std::string, AVRO_STRING)
DEFINE_PRIMITIVE(std::vector<uint8_t>, AVRO_BYTES)
} // namespace avro
#endif
| 26.55 | 78 | 0.721908 | [
"vector"
] |
474dfa3f6fe78144878d25940e76a34701455c82 | 6,767 | cpp | C++ | macOSCoder/NotSoRandom.cpp | lawarner/macOSCoder | 096c49e5b6bc0ea2ffd7f875fa3f390306133669 | [
"Apache-2.0"
] | null | null | null | macOSCoder/NotSoRandom.cpp | lawarner/macOSCoder | 096c49e5b6bc0ea2ffd7f875fa3f390306133669 | [
"Apache-2.0"
] | null | null | null | macOSCoder/NotSoRandom.cpp | lawarner/macOSCoder | 096c49e5b6bc0ea2ffd7f875fa3f390306133669 | [
"Apache-2.0"
] | null | null | null | //
// NotSoRandom.cpp
// macOSCoder
//
// Copyright © 2016 Andy Warner. 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 <iomanip>
#include <map>
#include "NotSoRandom.hpp"
using namespace std;
static const int AND = 0;
static const int OR = 1;
static const int XOR = 2;
NotSoRandom::DataType AA, BB, CC;
NotSoRandom::DataType KK;
NotSoRandom::NotSoRandom()
: CodeJamPerformer("NotSoRandom")
{
methods_.push_back("NSR-example.txt");
methods_.push_back("NSR-small.txt");
methods_.push_back("NSR-large.txt");
}
NotSoRandom::~NotSoRandom()
{
}
double NotSoRandom::doOpers(DataType val, DataType seq)
{
DataType values[3];
double probs[3];
int numVals = setValues(val, values, probs);
double result = 0;
if (seq > 1)
{
for (int idx = 0; idx < numVals; ++idx)
{
result += doOpers(values[idx], seq - 1) * probs[idx];
}
}
else
{
for (int idx = 0; idx < numVals; ++idx)
{
result += values[idx] * probs[idx];
}
}
return result;
}
double NotSoRandom::doOpersBrute(DataType val, DataType seq)
{
DataType values[3];
double result = (double)val;
setValuesSimple(val, values);
if (seq > 1)
{
double d0 = doOpers(values[0], seq - 1);
double d1 = doOpers(values[1], seq - 1);
double d2 = doOpers(values[2], seq - 1);
result = d0 * A + d1 * B + d2 * C;
}
else
{
result = values[0] * A + values[1] * B + values[2] * C;
}
return result;
}
int NotSoRandom::setValues(DataType val, DataType* values, double* probs)
{
values[AND] = val & K;
values[OR] = val | K;
values[XOR] = val ^ K;
probs[AND] = A;
probs[OR] = B;
probs[XOR] = C;
// log_ << "val=" << val << ", AND=" << values[AND] << " OR=" << values[OR] << ", XOR=" << values[XOR] << endl;
int retval = 3;
if (values[0] == values[2] || values[1] == values[2])
{
--retval;
int idx = values[0] == values[2] ? 0 : 1;
probs[idx] += probs[2];
probs[2] = 0;
}
if (values[0] == values[1])
{
probs[0] += probs[1];
if (retval == 3)
{
retval = 2;
values[1] = values[2];
probs[1] = probs[2];
values[2] = 0;
probs[2] = 0;
}
else
{
retval = 1;
probs[0] = 1;
}
}
return retval;
}
int NotSoRandom::setValuesSimple(DataType val, DataType* values)
{
values[AND] = val & K;
values[OR] = val | K;
values[XOR] = val ^ K;
// log_ << "val=" << val << ", AND=" << values[AND] << " OR=" << values[OR] << ", XOR=" << values[XOR] << endl;
return 3;
}
int NotSoRandom::perform(const std::string& method, const StringList& arguments)
{
int retval = -1;
retval = CodeJamPerformer::perform(method, arguments);
return retval;
}
/*
v1, v2, v3 with probability p1, p2, p3
each unique input value:
*/
class RNode
{
public:
typedef NotSoRandom::DataType IntType;
RNode(IntType v, IntType probAnd, IntType probOr, IntType probXor)
: value(v)
{
probs[0] = probAnd;
probs[1] = probOr;
probs[2] = probXor;
for (int i = 0; i < 3; ++i) children[i] = 0;
}
~RNode()
{
for (int i = 0; i < 3; ++i)
{
if (children[i]) delete children[i];
}
}
void setChildren(int num)
{
children[0] = new RNode(value & KK, AA, BB, CC);
children[1] = new RNode(value | KK, AA, BB, CC);
children[2] = new RNode(value ^ KK, AA, BB, CC);
if (--num > 0)
{
children[0]->setChildren(num);
children[1]->setChildren(num);
children[2]->setChildren(num);
}
}
string printTree() const
{
ostringstream oss;
double avg = 0.0;;
oss << "Children: ";
for (int i = 0; i < 3; ++i)
{
if (children[i])
{
oss << children[i]->value << " prob(" << probs[i] << ") ";
avg += 0.01 * probs[i] * children[i]->value;
}
else
{
oss << "(null) ";
}
}
oss << "Average: " << avg << endl;
return oss.str();
}
public:
IntType value;
IntType probs[3];
RNode* children[3];
};
int NotSoRandom::cjPerform(const std::string& method, const std::vector<IntList>& lines)
{
#if 1
// try to handle the large data set (non-recursive)
// build tree for each level N with values v1, v2, v3:
// N
// v1 v2 v3
// w1 w2 w3 w4 w5 w6 w7 w8 w9
//
RNode* tree = new RNode(X, AA, BB, CC);
tree->setChildren(N);
log_ << tree->printTree();
delete tree;
#else
map<int, int> vm;
DataType input = X;
for (int i = 0; i < N; ++i)
{
DataType values[3];
setValuesSimple(input, values);
vm[values[0]] += AA;
vm[values[1]] += BB;
vm[values[2]] += CC;
}
//double average = values[0] * A + values[1] * B + values[2] * C;
ostringstream oss;
oss << setprecision(15) << average;
cjOutput_ = oss.str();
// #else
double average = doOpers(X, N);
ostringstream oss;
oss << setprecision(15) << average;
cjOutput_ = oss.str();
// #else
DataType val = X;
double average;
for (int i = 0; i < N; ++i)
{
DataType iand = val & K;
DataType ior = val | K;
DataType ixor = val ^ K;
log_ << "val=" << val << ", AND=" << iand << " OR=" << ior << ", XOR=" << ixor << endl;
average = iand * A + ior * B + ixor * C;
log_ << "Average=" << average << endl;
val = average;
}
#endif
return 0;
}
void NotSoRandom::cjSetup(std::ifstream& ins, std::vector<IntList>& lines)
{
ins >> N;
ins >> X;
ins >> K;
KK = K;
ins >> AA;
A = (double)AA / 100;
ins >> BB;
B = (double)BB / 100;
ins >> CC;
C = (double)CC / 100;
log_ << "N=" << N << ", X=" << X << " K=" << K << ", A=" << A << ", B=" << B << ", C=" << C << endl;
}
| 25.062963 | 115 | 0.512339 | [
"vector"
] |
474fdd850d74592431855c36691026d2ab2a1c1d | 2,469 | cpp | C++ | src/Geometry/Structure/Octree.cpp | MyEvolution/Dragon | b14b6a29b65b43003ac89f4df3a3012e1eb2eee0 | [
"MIT"
] | 11 | 2020-12-11T18:58:11.000Z | 2022-02-08T08:13:15.000Z | src/Geometry/Structure/Octree.cpp | MyEvolution/Dragon | b14b6a29b65b43003ac89f4df3a3012e1eb2eee0 | [
"MIT"
] | 1 | 2022-02-08T08:12:48.000Z | 2022-02-08T08:12:48.000Z | src/Geometry/Structure/Octree.cpp | MyEvolution/Dragon | b14b6a29b65b43003ac89f4df3a3012e1eb2eee0 | [
"MIT"
] | 1 | 2021-05-17T14:51:38.000Z | 2021-05-17T14:51:38.000Z | #include "Octree.h"
#include "Geometry/Structure/BoundingBox.h"
namespace dragon
{
namespace geometry
{
void Octree::BuildTree(const geometry::PointCloud &pcd)
{
BoundingBox bb = pcd.GetBoundingBox();
auto &points = pcd.points;
// auto &normals = pcd.normals;
head.width = std::max(bb.x_max - bb.x_min, std::max(bb.y_max - bb.y_min,
bb.z_max - bb.z_min)) * 1.5;
head.center = Point3(bb.x_max + bb.x_min, bb.y_max + bb.y_min, bb.z_max + bb.z_min) / 2.0;
std::cout<<"head: "<<head.center.transpose()<<" "<<head.width<<std::endl;
std::cout<<"BB: "<<bb.y_max<<" "<<bb.y_min<<std::endl;
all_nodes.clear();
all_nodes.resize(max_depth + 1);
for(size_t i = 0; i != points.size(); ++i)
{
// std::cout<<"p "<<i<<std::endl;
head.AddPoint(points, i, max_depth);
}
SetNodeIDAndGetAllNodes();
// head.SetLeafIDAndGetAllLeaves(all_leaves);
head.GetAllLeaves(all_leaves);
sampled_pcd.Reset();
point_to_leaf.clear();
}
void Octree::BuildTreeUniformly(const geometry::PointCloud &pcd)
{
BoundingBox bb = pcd.GetBoundingBox();
auto &points = pcd.points;
// auto &normals = pcd.normals;
head.width = std::max(bb.x_max - bb.x_min, std::max(bb.y_max - bb.y_min,
bb.z_max - bb.z_min)) * 1.5;
head.center = Point3(bb.x_max + bb.x_min, bb.y_max + bb.y_min, bb.z_max + bb.z_min) / 2.0;
UniformSplit();
all_nodes.clear();
all_nodes.resize(max_depth + 1);
for(size_t i = 0; i != points.size(); ++i)
{
// std::cout<<"p "<<i<<std::endl;
head.AddPoint(points, i, max_depth);
}
SetNodeIDAndGetAllNodes();
// head.SetLeafIDAndGetAllLeaves(all_leaves);
head.GetAllLeaves(all_leaves);
sampled_pcd.Reset();
point_to_leaf.clear();
}
std::shared_ptr<geometry::PointCloud> Octree::GetPointCloud() const
{
geometry::PointCloud pcd;
for(size_t i = 0; i != all_nodes.back().size(); ++i)
{
if(all_nodes.back()[i]->normal.norm() > 0)
{
pcd.points.push_back(all_nodes.back()[i]->center);
pcd.normals.push_back(all_nodes.back()[i]->normal.normalized());
}
}
return std::make_shared<geometry::PointCloud>(pcd);
}
}
} | 36.308824 | 98 | 0.556501 | [
"geometry"
] |
47527933b56bf24440e59f248d4c643c6b15b1a5 | 448 | cpp | C++ | codeforces/160a.twins/160a.cpp | KayvanMazaheri/acm | aeb05074bc9b9c92f35b6a741183da09a08af85d | [
"MIT"
] | 3 | 2018-01-19T14:09:23.000Z | 2018-02-01T00:40:55.000Z | codeforces/160a.twins/160a.cpp | KayvanMazaheri/acm | aeb05074bc9b9c92f35b6a741183da09a08af85d | [
"MIT"
] | null | null | null | codeforces/160a.twins/160a.cpp | KayvanMazaheri/acm | aeb05074bc9b9c92f35b6a741183da09a08af85d | [
"MIT"
] | null | null | null | // In the name of God
// :)
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
const int MAXN = 1e2 + 123;
int arr[MAXN];
int main()
{
int n, sum =0, me = 0;
cin >> n;
for(int i=0; i<n; i++)
{
cin >> arr[i];
sum += arr[i];
}
sort(arr, arr+n);
int coins = 0;
for(int i=n-1; i>=0 && me <= sum; i--)
{
coins ++;
me+= arr[i];
sum -= arr[i];
}
cout << coins << endl;
return 0;
}
| 12.8 | 39 | 0.53125 | [
"vector"
] |
47528f6ccddaeb710238d0473e30e5093709e731 | 21,775 | cpp | C++ | tests/mesh/test-hybrid-solid.cpp | Geode-solutions/OpenGeode | e47621989e6fc152f529d4e1e7e3b9ef9e7d6ccc | [
"MIT"
] | 64 | 2019-08-02T14:31:01.000Z | 2022-03-30T07:46:50.000Z | tests/mesh/test-hybrid-solid.cpp | Geode-solutions/OpenGeode | e47621989e6fc152f529d4e1e7e3b9ef9e7d6ccc | [
"MIT"
] | 395 | 2019-08-02T17:15:10.000Z | 2022-03-31T15:10:27.000Z | tests/mesh/test-hybrid-solid.cpp | Geode-solutions/OpenGeode | e47621989e6fc152f529d4e1e7e3b9ef9e7d6ccc | [
"MIT"
] | 8 | 2019-08-19T21:32:15.000Z | 2022-03-06T18:41:10.000Z | /*
* Copyright (c) 2019 - 2021 Geode-solutions
*
* 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 <geode/basic/attribute_manager.h>
#include <geode/basic/logger.h>
#include <geode/geometry/bounding_box.h>
#include <geode/geometry/point.h>
#include <geode/geometry/vector.h>
#include <geode/mesh/builder/geode_hybrid_solid_builder.h>
#include <geode/mesh/builder/solid_edges_builder.h>
#include <geode/mesh/builder/solid_facets_builder.h>
#include <geode/mesh/core/geode_hybrid_solid.h>
#include <geode/mesh/core/solid_edges.h>
#include <geode/mesh/core/solid_facets.h>
#include <geode/mesh/io/hybrid_solid_input.h>
#include <geode/mesh/io/hybrid_solid_output.h>
#include <geode/tests/common.h>
void test_create_vertices( const geode::HybridSolid3D& hybrid_solid,
geode::HybridSolidBuilder3D& builder )
{
builder.create_point( { { 0, 0, 0 } } );
builder.create_point( { { 1, 0, 0 } } );
builder.create_point( { { 2, 1, 0 } } );
builder.create_point( { { 1, 2, 0 } } );
builder.create_point( { { 0, 2, 0 } } );
builder.create_point( { { 0, 0, 1 } } );
builder.create_point( { { 1, 0, 1 } } );
builder.create_point( { { 2, 1, 1 } } );
builder.create_point( { { 1, 2, 1 } } );
builder.create_point( { { 0, 2, 1 } } );
builder.create_point( { { 1, 1, 2 } } );
OPENGEODE_EXCEPTION( hybrid_solid.isolated_vertex( 0 ),
"[Test] Vertices should be isolated before polyhedra creation" );
OPENGEODE_EXCEPTION( hybrid_solid.nb_vertices() == 11,
"[Test] HybridSolid should have 11 vertices" );
}
void test_bounding_box( const geode::HybridSolid3D& hybrid_solid )
{
geode::Point3D answer_min{ { 0, 0, 0 } };
geode::Point3D answer_max{ { 2, 2, 2 } };
const auto bbox = hybrid_solid.bounding_box();
OPENGEODE_EXCEPTION( bbox.min() == answer_min,
"[Test] Wrong computation of bounding box (min)" );
OPENGEODE_EXCEPTION( bbox.max() == answer_max,
"[Test] Wrong computation of bounding box (max)" );
}
void test_facets( const geode::HybridSolid3D& hybrid_solid )
{
OPENGEODE_EXCEPTION(
hybrid_solid.facets().facet_from_vertices( { 0, 1, 3, 4 } ) == 0,
"[Test] Wrong facet from vertices" );
OPENGEODE_EXCEPTION(
hybrid_solid.facets().facet_from_vertices( { 8, 6, 7 } ) == 7,
"[Test] Wrong facet from vertices" );
geode::Point3D answer{ { 1.5, 0.5, 0.5 } };
const auto vertices = hybrid_solid.facets().facet_vertices( 8 );
OPENGEODE_EXCEPTION( hybrid_solid.facet_barycenter( vertices ) == answer,
"[Test] Wrong facet barycenter" );
}
void test_edges( const geode::HybridSolid3D& hybrid_solid )
{
geode::Point3D answer{ { 0.5, 0, 0 } };
const auto vertices = hybrid_solid.edges().edge_vertices( 0 );
OPENGEODE_EXCEPTION( hybrid_solid.edge_barycenter( vertices ) == answer,
"[Test] Wrong edge barycenter" );
OPENGEODE_EXCEPTION(
hybrid_solid.edge_length( vertices ) == 1, "[Test] Wrong edge length" );
}
void test_create_polyhedra( const geode::HybridSolid3D& hybrid_solid,
geode::HybridSolidBuilder3D& builder )
{
builder.create_hexahedron( { 0, 1, 3, 4, 5, 6, 8, 9 } );
OPENGEODE_EXCEPTION(
hybrid_solid.polyhedron_type( hybrid_solid.nb_polyhedra() - 1 )
== geode::HybridSolid3D::Type::HEXAHEDRON,
"[Test] Wrong polyhedron type" );
builder.create_prism( { 1, 2, 3, 6, 7, 8 } );
OPENGEODE_EXCEPTION(
hybrid_solid.polyhedron_type( hybrid_solid.nb_polyhedra() - 1 )
== geode::HybridSolid3D::Type::PRISM,
"[Test] Wrong polyhedron type" );
builder.create_pyramid( { 5, 6, 8, 9, 10 } );
OPENGEODE_EXCEPTION(
hybrid_solid.polyhedron_type( hybrid_solid.nb_polyhedra() - 1 )
== geode::HybridSolid3D::Type::PYRAMID,
"[Test] Wrong polyhedron type" );
builder.create_tetrahedron( { 6, 7, 8, 10 } );
OPENGEODE_EXCEPTION(
hybrid_solid.polyhedron_type( hybrid_solid.nb_polyhedra() - 1 )
== geode::HybridSolid3D::Type::TETRAHEDRON,
"[Test] Wrong polyhedron type" );
OPENGEODE_EXCEPTION( hybrid_solid.nb_polyhedra() == 4,
"[Test] HybridSolid should have 4 polyhedra" );
OPENGEODE_EXCEPTION( hybrid_solid.facets().nb_facets() == 16,
"[Test] HybridSolid should have 16 facets" );
OPENGEODE_EXCEPTION( hybrid_solid.edges().nb_edges() == 22,
"[Test] HybridSolid should have 22 edges" );
OPENGEODE_EXCEPTION( !hybrid_solid.isolated_vertex( 0 ),
"[Test] Vertices should not be isolated after polyhedra creation" );
}
void test_polyhedron_adjacencies( const geode::HybridSolid3D& hybrid_solid,
geode::HybridSolidBuilder3D& builder )
{
builder.compute_polyhedron_adjacencies();
OPENGEODE_EXCEPTION( !hybrid_solid.polyhedron_adjacent( { 0, 0 } ),
"[Test] HybridSolid adjacent index is not correct" );
OPENGEODE_EXCEPTION( hybrid_solid.polyhedron_adjacent( { 0, 1 } ) == 2,
"[Test] HybridSolid adjacent index is not correct" );
OPENGEODE_EXCEPTION( !hybrid_solid.polyhedron_adjacent( { 0, 2 } ),
"[Test] HybridSolid adjacent index is not correct" );
OPENGEODE_EXCEPTION( hybrid_solid.polyhedron_adjacent( { 1, 1 } ) == 3,
"[Test] HybridSolid adjacent index is not correct" );
OPENGEODE_EXCEPTION( hybrid_solid.polyhedron_adjacent( { 1, 4 } ) == 0,
"[Test] HybridSolid adjacent index is not correct" );
OPENGEODE_EXCEPTION( hybrid_solid.polyhedron_adjacent( { 2, 2 } ) == 3,
"[Test] HybridSolid adjacent index is not correct" );
OPENGEODE_EXCEPTION( hybrid_solid.polyhedra_around_vertex( 6 ).size() == 4,
"[Test] HybridSolid should have 4 polyhedra around this vertex" );
OPENGEODE_EXCEPTION(
hybrid_solid.polyhedron_facets_on_border( 0 ).size() == 4,
"[Test] First polyhedron of HybridSolid should have 4 facets on "
"border" );
}
void test_permutation(
const geode::HybridSolid3D& solid, geode::HybridSolidBuilder3D& builder )
{
std::vector< geode::index_t > vertex_permutation{ 1, 7, 5, 4, 8, 6, 10, 2,
9, 3, 0 };
builder.permute_vertices( vertex_permutation );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 0, 0 } ) == 10,
"[Test] Wrong PolyhedronVertex after vertex permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 0, 1 } ) == 0,
"[Test] Wrong PolyhedronVertex after vertex permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 0, 2 } ) == 9,
"[Test] Wrong PolyhedronVertex after vertex permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 0, 3 } ) == 3,
"[Test] Wrong PolyhedronVertex after vertex permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 0, 4 } ) == 2,
"[Test] Wrong PolyhedronVertex after vertex permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 0, 5 } ) == 5,
"[Test] Wrong PolyhedronVertex after vertex permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 0, 6 } ) == 4,
"[Test] Wrong PolyhedronVertex after vertex permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 0, 7 } ) == 8,
"[Test] Wrong PolyhedronVertex after vertex permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 1, 0 } ) == 0,
"[Test] Wrong PolyhedronVertex after vertex permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 1, 1 } ) == 7,
"[Test] Wrong PolyhedronVertex after vertex permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 1, 2 } ) == 9,
"[Test] Wrong PolyhedronVertex after vertex permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 1, 3 } ) == 5,
"[Test] Wrong PolyhedronVertex after vertex permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 1, 4 } ) == 1,
"[Test] Wrong PolyhedronVertex after vertex permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 1, 5 } ) == 4,
"[Test] Wrong PolyhedronVertex after vertex permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 2, 0 } ) == 2,
"[Test] Wrong PolyhedronVertex after vertex permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 2, 1 } ) == 5,
"[Test] Wrong PolyhedronVertex after vertex permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 2, 2 } ) == 4,
"[Test] Wrong PolyhedronVertex after vertex permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 2, 3 } ) == 8,
"[Test] Wrong PolyhedronVertex after vertex permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 2, 4 } ) == 6,
"[Test] Wrong PolyhedronVertex after vertex permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 3, 0 } ) == 5,
"[Test] Wrong PolyhedronVertex after vertex permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 3, 1 } ) == 1,
"[Test] Wrong PolyhedronVertex after vertex permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 3, 2 } ) == 4,
"[Test] Wrong PolyhedronVertex after vertex permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 3, 3 } ) == 6,
"[Test] Wrong PolyhedronVertex after vertex permute" );
std::vector< geode::index_t > polyhedron_permutation{ 3, 2, 0, 1 };
builder.permute_polyhedra( polyhedron_permutation );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 0, 0 } ) == 5,
"[Test] Wrong PolyhedronVertex after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 0, 1 } ) == 1,
"[Test] Wrong PolyhedronVertex after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 0, 2 } ) == 4,
"[Test] Wrong PolyhedronVertex after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 0, 3 } ) == 6,
"[Test] Wrong PolyhedronVertex after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 1, 0 } ) == 2,
"[Test] Wrong PolyhedronVertex after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 1, 1 } ) == 5,
"[Test] Wrong PolyhedronVertex after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 1, 2 } ) == 4,
"[Test] Wrong PolyhedronVertex after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 1, 3 } ) == 8,
"[Test] Wrong PolyhedronVertex after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 1, 4 } ) == 6,
"[Test] Wrong PolyhedronVertex after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 2, 0 } ) == 10,
"[Test] Wrong PolyhedronVertex after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 2, 1 } ) == 0,
"[Test] Wrong PolyhedronVertex after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 2, 2 } ) == 9,
"[Test] Wrong PolyhedronVertex after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 2, 3 } ) == 3,
"[Test] Wrong PolyhedronVertex after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 2, 4 } ) == 2,
"[Test] Wrong PolyhedronVertex after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 2, 5 } ) == 5,
"[Test] Wrong PolyhedronVertex after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 2, 6 } ) == 4,
"[Test] Wrong PolyhedronVertex after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 2, 7 } ) == 8,
"[Test] Wrong PolyhedronVertex after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 3, 0 } ) == 0,
"[Test] Wrong PolyhedronVertex after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 3, 1 } ) == 7,
"[Test] Wrong PolyhedronVertex after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 3, 2 } ) == 9,
"[Test] Wrong PolyhedronVertex after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 3, 3 } ) == 5,
"[Test] Wrong PolyhedronVertex after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 3, 4 } ) == 1,
"[Test] Wrong PolyhedronVertex after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_vertex( { 3, 5 } ) == 4,
"[Test] Wrong PolyhedronVertex after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_adjacent( { 0, 1 } ) == 1,
"[Test] Wrong Adjacency after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_adjacent( { 2, 1 } ) == 1,
"[Test] Wrong Adjacency after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_adjacent( { 0, 3 } ) == 3,
"[Test] Wrong Adjacency after polyhedron permute" );
OPENGEODE_EXCEPTION( solid.polyhedron_adjacent( { 3, 4 } ) == 2,
"[Test] Wrong Adjacency after polyhedron permute" );
const auto polyhedra_5 = solid.polyhedra_around_vertex( 5 );
OPENGEODE_EXCEPTION( polyhedra_5.size() == 4,
"[Test] Wrong polyhedra_5 after polyhedron permute" );
OPENGEODE_EXCEPTION( polyhedra_5[0].polyhedron_id == 0,
"[Test] Wrong polyhedra_5 after polyhedron permute" );
OPENGEODE_EXCEPTION( polyhedra_5[0].vertex_id == 0,
"[Test] Wrong polyhedra_5 after polyhedron permute" );
OPENGEODE_EXCEPTION( polyhedra_5[1].polyhedron_id == 3,
"[Test] Wrong polyhedra_5 after polyhedron permute" );
OPENGEODE_EXCEPTION( polyhedra_5[1].vertex_id == 3,
"[Test] Wrong polyhedra_5 after polyhedron permute" );
OPENGEODE_EXCEPTION( polyhedra_5[2].polyhedron_id == 2,
"[Test] Wrong polyhedra_5 after polyhedron permute" );
OPENGEODE_EXCEPTION( polyhedra_5[2].vertex_id == 5,
"[Test] Wrong polyhedra_5 after polyhedron permute" );
OPENGEODE_EXCEPTION( polyhedra_5[3].polyhedron_id == 1,
"[Test] Wrong polyhedra_5 after polyhedron permute" );
OPENGEODE_EXCEPTION( polyhedra_5[3].vertex_id == 1,
"[Test] Wrong polyhedra_5 after polyhedron permute" );
}
void test_delete_vertex( const geode::HybridSolid3D& hybrid_solid,
geode::HybridSolidBuilder3D& builder )
{
std::vector< bool > to_delete( hybrid_solid.nb_vertices(), false );
to_delete[3] = true;
builder.delete_vertices( to_delete );
OPENGEODE_EXCEPTION( hybrid_solid.nb_vertices() == 10,
"[Test] HybridSolid should have 10 vertices" );
const geode::Point3D answer{ { 1, 0, 0 } };
OPENGEODE_EXCEPTION( hybrid_solid.point( 0 ) == answer,
"[Test] HybridSolid vertex coordinates are not correct" );
OPENGEODE_EXCEPTION( hybrid_solid.nb_polyhedra() == 3,
"[Test] HybridSolid should have 3 polyhedra" );
OPENGEODE_EXCEPTION( !hybrid_solid.polyhedron_adjacent( { 1, 0 } ),
"[Test] HybridSolid adjacent index is not correct" );
OPENGEODE_EXCEPTION( hybrid_solid.facets().nb_facets() == 13,
"[Test] PolyhedralSolid should have 13 facets" );
OPENGEODE_EXCEPTION( hybrid_solid.edges().nb_edges() == 19,
"[Test] PolyhedralSolid should have 19 edges" );
builder.edges_builder().delete_isolated_edges();
builder.facets_builder().delete_isolated_facets();
OPENGEODE_EXCEPTION( hybrid_solid.facets().nb_facets() == 12,
"[Test] HybridSolid should have 12 facets" );
OPENGEODE_EXCEPTION( hybrid_solid.edges().nb_edges() == 17,
"[Test] HybridSolid should have 17 edges" );
}
void test_delete_polyhedra( const geode::HybridSolid3D& hybrid_solid,
geode::HybridSolidBuilder3D& builder )
{
std::vector< bool > to_delete( hybrid_solid.nb_polyhedra(), false );
to_delete.front() = true;
builder.delete_polyhedra( to_delete );
OPENGEODE_EXCEPTION( hybrid_solid.nb_polyhedra() == 2,
"[Test] HybridSolid should have 2 polyhedra" );
OPENGEODE_EXCEPTION( hybrid_solid.polyhedron_vertex( { 0, 0 } ) == 2,
"[Test] HybridSolid vertex index is not correct" );
OPENGEODE_EXCEPTION( hybrid_solid.polyhedron_vertex( { 0, 1 } ) == 4,
"[Test] HybridSolid vertex index is not correct" );
OPENGEODE_EXCEPTION( hybrid_solid.polyhedron_vertex( { 0, 2 } ) == 3,
"[Test] HybridSolid vertex index is not correct" );
OPENGEODE_EXCEPTION( hybrid_solid.polyhedron_vertex( { 0, 3 } ) == 7,
"[Test] HybridSolid vertex index is not correct" );
OPENGEODE_EXCEPTION( hybrid_solid.polyhedron_vertex( { 0, 4 } ) == 5,
"[Test] HybridSolid vertex index is not correct" );
builder.edges_builder().delete_isolated_edges();
builder.facets_builder().delete_isolated_facets();
OPENGEODE_EXCEPTION( hybrid_solid.facets().nb_facets() == 10,
"[Test] HybridSolid should have 10 facets" );
OPENGEODE_EXCEPTION( hybrid_solid.edges().nb_edges() == 16,
"[Test] HybridSolid should have 16 edges" );
}
void test_io(
const geode::HybridSolid3D& hybrid_solid, const std::string& filename )
{
geode::save_hybrid_solid( hybrid_solid, filename );
geode::load_hybrid_solid< 3 >( filename );
const auto new_hybrid_solid = geode::load_hybrid_solid< 3 >(
geode::OpenGeodeHybridSolid3D::impl_name_static(), filename );
OPENGEODE_EXCEPTION( new_hybrid_solid->nb_vertices() == 11,
"[Test] Reloaded HybridSolid should have 11 vertices" );
OPENGEODE_EXCEPTION( new_hybrid_solid->nb_polyhedra() == 4,
"[Test] HybridSolid should have 4 polyhedra" );
OPENGEODE_EXCEPTION( new_hybrid_solid->facets().nb_facets() == 16,
"[Test] HybridSolid should have 16 facets" );
OPENGEODE_EXCEPTION( new_hybrid_solid->edges().nb_edges() == 22,
"[Test] HybridSolid should have 22 edges" );
OPENGEODE_EXCEPTION(
new_hybrid_solid->facets().facet_from_vertices(
new_hybrid_solid->polyhedron_facet_vertices( { 1, 0 } ) )
== hybrid_solid.facets().facet_from_vertices(
hybrid_solid.polyhedron_facet_vertices( { 1, 0 } ) ),
"[Test] Reloaded HybridSolid has wrong polyhedron facet index" );
}
void test_clone( const geode::HybridSolid3D& hybrid_solid )
{
const auto hybrid_solid2 = hybrid_solid.clone();
OPENGEODE_EXCEPTION( hybrid_solid2->nb_vertices() == 10,
"[Test] Reloaded HybridSolid should have 10 vertices" );
OPENGEODE_EXCEPTION( hybrid_solid2->nb_polyhedra() == 2,
"[Test] HybridSolid should have 2 polyhedra" );
OPENGEODE_EXCEPTION( hybrid_solid2->facets().nb_facets() == 10,
"[Test] HybridSolid should have 10 facets" );
OPENGEODE_EXCEPTION( hybrid_solid2->edges().nb_edges() == 16,
"[Test] HybridSolid should have 16 edges" );
}
void test_delete_all( const geode::HybridSolid3D& hybrid_solid,
geode::HybridSolidBuilder3D& builder )
{
std::vector< bool > to_delete( hybrid_solid.nb_polyhedra(), true );
builder.delete_polyhedra( to_delete );
OPENGEODE_EXCEPTION( hybrid_solid.nb_vertices() == 10,
"[Test] HybridSolid should have 10 vertices" );
OPENGEODE_EXCEPTION( hybrid_solid.isolated_vertex( 0 ),
"[Test] Vertices should be isolated after polyhedra deletion" );
OPENGEODE_EXCEPTION( hybrid_solid.nb_polyhedra() == 0,
"[Test] HybridSolid should have 0 polyhedron" );
builder.edges_builder().delete_isolated_edges();
builder.facets_builder().delete_isolated_facets();
OPENGEODE_EXCEPTION( hybrid_solid.facets().nb_facets() == 0,
"[Test] HybridSolid should have 0 facet" );
OPENGEODE_EXCEPTION( hybrid_solid.edges().nb_edges() == 0,
"[Test] HybridSolid should have 0 edge" );
OPENGEODE_EXCEPTION( hybrid_solid.polyhedra_around_vertex( 0 ).empty(),
"[Test] No more polyhedra around vertices" );
builder.delete_isolated_vertices();
OPENGEODE_EXCEPTION( hybrid_solid.nb_vertices() == 0,
"[Test]HybridSolid should have 0 vertex" );
}
void test()
{
auto hybrid_solid = geode::HybridSolid3D::create(
geode::OpenGeodeHybridSolid3D::impl_name_static() );
hybrid_solid->enable_edges();
hybrid_solid->enable_facets();
auto builder = geode::HybridSolidBuilder3D::create( *hybrid_solid );
test_create_vertices( *hybrid_solid, *builder );
test_create_polyhedra( *hybrid_solid, *builder );
test_edges( *hybrid_solid );
test_facets( *hybrid_solid );
test_polyhedron_adjacencies( *hybrid_solid, *builder );
test_io( *hybrid_solid,
absl::StrCat( "test.", hybrid_solid->native_extension() ) );
test_permutation( *hybrid_solid, *builder );
test_delete_vertex( *hybrid_solid, *builder );
test_delete_polyhedra( *hybrid_solid, *builder );
test_clone( *hybrid_solid );
test_delete_all( *hybrid_solid, *builder );
}
OPENGEODE_TEST( "hybrid-solid" )
| 50.995316 | 80 | 0.683949 | [
"mesh",
"geometry",
"vector",
"solid"
] |
47563b7043d46a4be00bd3bd07a3126abd062ed8 | 2,038 | hpp | C++ | YeOlde/cpp/Aquarians/aqlib/Exception.hpp | aquarians/Public | ac79b1502fe62eee2c84e1e4b8d32e6c303bdfd4 | [
"MIT"
] | null | null | null | YeOlde/cpp/Aquarians/aqlib/Exception.hpp | aquarians/Public | ac79b1502fe62eee2c84e1e4b8d32e6c303bdfd4 | [
"MIT"
] | null | null | null | YeOlde/cpp/Aquarians/aqlib/Exception.hpp | aquarians/Public | ac79b1502fe62eee2c84e1e4b8d32e6c303bdfd4 | [
"MIT"
] | null | null | null | #ifndef __EXCEPTION_HPP
#define __EXCEPTION_HPP
#include <exception>
#include <string>
#include <vector>
#include <log4cxx/logger.h>
namespace aqlib
{
// Offers the functionality to print the stack trace at runtime.
// As there's no C/C++ standard or at least established library for this,
// had to implement it from scratch using GCC specific API.
class Exception: public std::exception
{
static log4cxx::LoggerPtr logger;
public:
Exception(const std::string &message);
~Exception() throw() {}
// Exception class name
virtual const std::string& getClassName() const;
// Error message as provided in the constructor
const std::string& getMessage() const;
// Call once, on application startup
static void staticInit();
// Access to stack trace frames
struct Frame
{
void *addr; // Frame address
std::string sym; // Raw data as outputted by backtrace_symbols()
std::string module; // Name of the application or library
std::string file; // Name of the source file
std::string func; // Function signature
int line; // Line in the source file
Frame();
};
int getFrameCount() const;
const Frame& getFrame(int index) const;
// Conversion to string
virtual std::string toString() const;
// Override the std::exception interface
virtual const char* what() const throw();
private:
// Parse text outputted by backtrace_symbols()
static void parseBacktraceSymbol(Frame &frame);
private:
static const std::string CLASS_NAME;
static const int MAX_STACKTRACE_DEPTH;
// Use BFD library for (file, line number) information
// Adapted from http://en.wikibooks.org/wiki/Linux_Applications_Debugging_Techniques/The_call_stack
struct BfdData;
static BfdData *gBfdData;
typedef std::vector<Frame> Frames;
Frames mFrames;
std::string mMessage;
std::string mWhat;
};
} // namespace aqlib
#endif // __EXCEPTION_HPP
| 27.173333 | 103 | 0.67419 | [
"vector"
] |
e6de55f2b0944a3d6131cd5a3d1f99cba5420238 | 6,630 | cpp | C++ | src/passes/analysis/smtmodule.cpp | rdaly525/coreir | 2088144fa9ba89e701845da598332886f2869467 | [
"BSD-3-Clause"
] | 104 | 2017-04-05T23:23:32.000Z | 2022-03-18T03:47:05.000Z | src/passes/analysis/smtmodule.cpp | rdaly525/coreir | 2088144fa9ba89e701845da598332886f2869467 | [
"BSD-3-Clause"
] | 588 | 2017-04-02T17:11:29.000Z | 2021-12-22T01:37:47.000Z | src/passes/analysis/smtmodule.cpp | rdaly525/coreir | 2088144fa9ba89e701845da598332886f2869467 | [
"BSD-3-Clause"
] | 27 | 2017-03-15T17:05:13.000Z | 2022-03-30T20:23:08.000Z | #include "coreir/passes/analysis/smtmodule.hpp"
#include "coreir.h"
#include "coreir/passes/analysis/smtoperators.hpp"
#include <iostream>
using namespace CoreIR;
using namespace Passes;
typedef void (*voidFunctionType)(void);
string SMTModule::toString() {
ostringstream o;
for (auto s : stmts) o << s << endl;
return o.str();
}
string SMTModule::toVarDecString() {
ostringstream o;
for (auto vd : vardecs) o << vd << endl;
return o.str();
}
string SMTModule::toNextVarDecString() {
ostringstream o;
for (auto vd : nextvardecs) o << vd << endl;
return o.str();
}
string SMTModule::toInitVarDecString() {
ostringstream o;
for (auto vd : initvardecs) o << vd << endl;
return o.str();
}
string SMTModule::toInstanceString(Instance* inst, string path) {
string instname = inst->getInstname();
Module* mref = inst->getModuleRef();
ostringstream o;
string tab = " ";
string mname;
Values args;
if (gen) {
addPortsFromGen(inst);
mname = modname; // gen->getNamespace()->getName() + "_" +
// gen->getName(args);
}
else {
mname = modname;
}
// it appears that arguments are kept in GenArgs even if it's a module
// We want all arguments available
if (mref->isGenerated()) {
for (auto amap : mref->getGenArgs()) {
ASSERT(args.count(amap.first) == 0, "NYI Aliased config/genargs");
args[amap.first] = amap.second;
}
}
for (auto amap : inst->getModArgs()) {
ASSERT(args.count(amap.first) == 0, "NYI Alisaaed config/genargs");
args[amap.first] = amap.second;
}
vector<string> params;
const json& jmeta = mref->getMetaData();
if (jmeta.count("verilog") && jmeta["verilog"].count("parameters")) {
params = jmeta["verilog"]["parameters"].get<vector<string>>();
}
else {
for (auto amap : args) { params.push_back(amap.first); }
}
vector<string> paramstrs;
for (auto param : params) {
ASSERT(
args.count(param),
"Missing parameter " + param + " from " + ::CoreIR::toString(args));
string astr = "." + param + "(" + args[param]->toString() + ")";
paramstrs.push_back(astr);
}
// Assume names are <instname>_port
unordered_map<string, SmtBVVar> portstrs;
for (auto port : ports) { portstrs.emplace(port.getPortName(), port); }
string context = path + "$";
string pre = "coreir.";
string prebit = "corebit.";
enum operation {
neg_op = 1,
const_op,
add_op,
sub_op,
and_op,
or_op,
eq_op,
xor_op,
reg_op,
regPE_op,
concat_op,
slice_op,
term_op,
mux_op,
mul_op,
lshr_op,
ashr_op,
andr_op,
orr_op,
zext_op,
mantle_reg_op
};
unordered_map<string, operation> opmap;
opmap.emplace(pre + "neg", neg_op);
opmap.emplace(pre + "bitneg", neg_op);
opmap.emplace(pre + "not", neg_op);
opmap.emplace(pre + "bitnot", neg_op);
opmap.emplace(prebit + "not", neg_op);
opmap.emplace(pre + "const", const_op);
opmap.emplace(pre + "bitconst", const_op);
opmap.emplace(pre + "add", add_op);
opmap.emplace(pre + "sub", sub_op);
opmap.emplace(pre + "and", and_op);
opmap.emplace(pre + "bitand", and_op);
opmap.emplace(prebit + "and", and_op);
opmap.emplace(pre + "or", or_op);
opmap.emplace(pre + "eq", eq_op);
opmap.emplace(pre + "bitor", or_op);
opmap.emplace(pre + "xor", xor_op);
opmap.emplace(pre + "bitxor", xor_op);
opmap.emplace(pre + "bitreg", reg_op);
opmap.emplace(pre + "reg", reg_op);
opmap.emplace(pre + "reg_PE", regPE_op);
opmap.emplace(pre + "concat", concat_op);
opmap.emplace(pre + "slice", slice_op);
opmap.emplace(pre + "term", term_op);
opmap.emplace(pre + "mux", mux_op);
opmap.emplace(prebit + "const", const_op);
opmap.emplace(pre + "lshr", lshr_op);
opmap.emplace(pre + "ashr", ashr_op);
opmap.emplace(pre + "mul", mul_op);
opmap.emplace(pre + "orr", orr_op);
opmap.emplace(pre + "andr", andr_op);
opmap.emplace(pre + "zext", zext_op);
opmap.emplace("mantle.reg", mantle_reg_op);
#define var_assign(var, name) \
if (portstrs.find(name) != portstrs.end()) var = portstrs.find(name)->second
SmtBVVar out;
var_assign(out, "out");
SmtBVVar in;
var_assign(in, "in");
SmtBVVar in0;
var_assign(in0, "in0");
SmtBVVar in1;
var_assign(in1, "in1");
SmtBVVar clk;
var_assign(clk, "clk");
SmtBVVar en;
var_assign(en, "en");
SmtBVVar sel;
var_assign(sel, "sel");
SmtBVVar clr;
var_assign(clr, "clr");
SmtBVVar rst;
var_assign(rst, "rst");
// Mantle primitives
// Most are slightly different, except
// clk and CLK could be combined with tolower
SmtBVVar I;
var_assign(I, "I");
SmtBVVar I0;
var_assign(I, "I0");
SmtBVVar I1;
var_assign(I, "I1");
SmtBVVar O;
var_assign(O, "O");
SmtBVVar CLK;
var_assign(CLK, "CLK");
SmtBVVar CLR;
var_assign(CLR, "CLR");
SmtBVVar RESET;
var_assign(RESET, "RESET");
SmtBVVar CE;
var_assign(CE, "CE");
switch (opmap[mname]) {
case term_op:
break;
case neg_op:
o << SMTNot(context, in, out);
break;
case add_op:
o << SMTAdd(context, in0, in1, out);
break;
case sub_op:
o << SMTSub(context, in0, in1, out);
break;
case and_op:
o << SMTAnd(context, in0, in1, out);
break;
case or_op:
o << SMTOr(context, in0, in1, out);
break;
case eq_op:
o << SMTEq(context, in0, in1, out);
break;
case xor_op:
o << SMTXor(context, in0, in1, out);
break;
case concat_op:
o << SMTConcat(context, in0, in1, out);
break;
case reg_op:
o << SMTReg(context, in, clk, out);
break;
case regPE_op:
o << SMTRegPE(context, in, clk, out, en);
break;
case const_op:
o << SMTConst(context, out, args["value"]->toString());
break;
case mux_op:
o << SMTMux(context, in0, in1, sel, out);
break;
case lshr_op:
o << SMTLshr(context, in0, in1, out);
break;
case ashr_op:
o << SMTAshr(context, in0, in1, out);
break;
case mul_op:
o << SMTMul(context, in0, in1, out);
break;
case orr_op:
o << SMTOrr(context, in, out);
break;
case andr_op:
o << SMTAndr(context, in, out);
break;
case zext_op:
o << SMTZext(context, in, out);
break;
case slice_op:
int lo;
lo = stoi(args["lo"]->toString());
int hi;
hi = stoi(args["hi"]->toString());
o << SMTSlice(context, in, out, lo, hi - 1);
break;
case mantle_reg_op:
o << SMTMantleReg(context, args, I, O, CLK, CLR, CE, RESET);
break;
default:
o << "!!! UNMATCHED: " << mname << " !!!";
}
o << endl;
return o.str();
}
| 24.831461 | 80 | 0.613725 | [
"vector"
] |
e6e0d2a9564a4d7f520455cab486f81d9b76752f | 6,101 | cpp | C++ | test/module/irohad/consensus/yac/yac_simple_cold_case_test.cpp | coderintherye/iroha | 68509282851130c9818f21acef1ef28e53622315 | [
"Apache-2.0"
] | null | null | null | test/module/irohad/consensus/yac/yac_simple_cold_case_test.cpp | coderintherye/iroha | 68509282851130c9818f21acef1ef28e53622315 | [
"Apache-2.0"
] | null | null | null | test/module/irohad/consensus/yac/yac_simple_cold_case_test.cpp | coderintherye/iroha | 68509282851130c9818f21acef1ef28e53622315 | [
"Apache-2.0"
] | null | null | null | /**
* Copyright Soramitsu Co., Ltd. All Rights Reserved.
* SPDX-License-Identifier: Apache-2.0
*/
#include <iostream>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include "consensus/yac/storage/yac_proposal_storage.hpp"
#include "framework/test_subscriber.hpp"
#include "yac_mocks.hpp"
using ::testing::_;
using ::testing::An;
using ::testing::AtLeast;
using ::testing::Invoke;
using ::testing::Return;
using namespace iroha::consensus::yac;
using namespace framework::test_subscriber;
using namespace std;
/**
* Test provide scenario when yac vote for hash
*/
TEST_F(YacTest, YacWhenVoting) {
cout << "----------|YacWhenAchieveOneVote|----------" << endl;
EXPECT_CALL(*network, sendState(_, _)).Times(default_peers.size());
YacHash my_hash(
iroha::consensus::Round{1, 1}, "my_proposal_hash", "my_block_hash");
auto order = ClusterOrdering::create(default_peers);
ASSERT_TRUE(order);
yac->vote(my_hash, *order);
}
/**
* Test provide scenario when yac cold started and achieve one vote
*/
TEST_F(YacTest, YacWhenColdStartAndAchieveOneVote) {
cout << "----------|Coldstart - receive one vote|----------" << endl;
// verify that commit not emitted
auto wrapper = make_test_subscriber<CallExact>(yac->onOutcome(), 0);
wrapper.subscribe();
EXPECT_CALL(*network, sendState(_, _)).Times(0);
EXPECT_CALL(*crypto, verify(_)).Times(1).WillRepeatedly(Return(true));
YacHash received_hash(
iroha::consensus::Round{1, 1}, "my_proposal", "my_block");
auto peer = default_peers.at(0);
// assume that our peer receive message
network->notification->onState({crypto->getVote(received_hash)});
ASSERT_TRUE(wrapper.validate());
}
/**
* Test provide scenario
* when yac cold started and achieve supermajority of votes
*/
TEST_F(YacTest, YacWhenColdStartAndAchieveSupermajorityOfVotes) {
cout << "----------|Start => receive supermajority of votes"
"|----------"
<< endl;
// verify that commit not emitted
auto wrapper = make_test_subscriber<CallExact>(yac->onOutcome(), 0);
wrapper.subscribe();
EXPECT_CALL(*network, sendState(_, _)).Times(0);
EXPECT_CALL(*crypto, verify(_))
.Times(default_peers.size())
.WillRepeatedly(Return(true));
YacHash received_hash(
iroha::consensus::Round{1, 1}, "my_proposal", "my_block");
for (size_t i = 0; i < default_peers.size(); ++i) {
network->notification->onState({crypto->getVote(received_hash)});
}
ASSERT_TRUE(wrapper.validate());
}
/**
* @given initialized YAC with empty storage
* @when receive commit message
* @then commit is not broadcasted
* AND commit is emitted to observable
*/
TEST_F(YacTest, YacWhenColdStartAndAchieveCommitMessage) {
YacHash propagated_hash(
iroha::consensus::Round{1, 1}, "my_proposal", "my_block");
// verify that commit emitted
auto wrapper = make_test_subscriber<CallExact>(yac->onOutcome(), 1);
wrapper.subscribe([propagated_hash](auto commit_hash) {
ASSERT_EQ(propagated_hash,
boost::get<CommitMessage>(commit_hash).votes.at(0).hash);
});
EXPECT_CALL(*network, sendState(_, _)).Times(0);
EXPECT_CALL(*crypto, verify(_)).WillOnce(Return(true));
EXPECT_CALL(*timer, deny()).Times(AtLeast(1));
auto committed_peer = default_peers.at(0);
auto msg = CommitMessage(std::vector<VoteMessage>{});
for (size_t i = 0; i < default_peers.size(); ++i) {
msg.votes.push_back(create_vote(propagated_hash, std::to_string(i)));
}
network->notification->onState(msg.votes);
ASSERT_TRUE(wrapper.validate());
}
/**
* @given initialized YAC
* @when receive supermajority of votes for a hash
* @then commit is sent to the network before notifying subscribers
*/
TEST_F(YacTest, PropagateCommitBeforeNotifyingSubscribersApplyVote) {
EXPECT_CALL(*crypto, verify(_))
.Times(default_peers.size())
.WillRepeatedly(Return(true));
std::vector<std::vector<VoteMessage>> messages;
EXPECT_CALL(*network, sendState(_, _))
.Times(default_peers.size())
.WillRepeatedly(Invoke(
[&](const auto &, const auto &msg) { messages.push_back(msg); }));
yac->onOutcome().subscribe([&](auto msg) {
// verify that commits are already sent to the network
ASSERT_EQ(default_peers.size(), messages.size());
messages.push_back(boost::get<CommitMessage>(msg).votes);
});
for (size_t i = 0; i < default_peers.size(); ++i) {
yac->onState({create_vote(YacHash{}, std::to_string(i))});
}
// verify that on_commit subscribers are notified
ASSERT_EQ(default_peers.size() + 1, messages.size());
}
/**
* @given initialized YAC
* @when receive 2 * f votes for one hash
* AND receive reject message which triggers commit
* @then commit is NOT propagated in the network
* AND it is passed to pipeline
*/
TEST_F(YacTest, PropagateCommitBeforeNotifyingSubscribersApplyReject) {
EXPECT_CALL(*crypto, verify(_)).WillRepeatedly(Return(true));
EXPECT_CALL(*timer, deny()).Times(AtLeast(1));
std::vector<std::vector<VoteMessage>> messages;
EXPECT_CALL(*network, sendState(_, _))
.Times(0)
.WillRepeatedly(Invoke(
[&](const auto &, const auto &msg) { messages.push_back(msg); }));
yac->onOutcome().subscribe([&](auto msg) {
// verify that commits are already sent to the network
ASSERT_EQ(0, messages.size());
messages.push_back(boost::get<CommitMessage>(msg).votes);
});
std::vector<VoteMessage> commit;
auto f = (default_peers.size() - 1) / 3;
for (size_t i = 0; i < 2 * f; ++i) {
auto vote = create_vote(YacHash{}, std::to_string(i));
yac->onState({vote});
commit.push_back(vote);
}
auto vote = create_vote(YacHash{}, std::to_string(2 * f + 1));
RejectMessage reject(
{vote,
create_vote(YacHash(iroha::consensus::Round{1, 1}, "", "my_block"),
std::to_string(2 * f + 2))});
commit.push_back(vote);
yac->onState(reject.votes);
yac->onState(commit);
// verify that on_commit subscribers are notified
ASSERT_EQ(1, messages.size());
}
| 30.20297 | 76 | 0.683167 | [
"vector"
] |
e6eaad7b2bf4f37fb88e95d60c0af4f0c8d4c15b | 11,216 | cc | C++ | arcane/src/arcane/ios/VtuMeshWriter.cc | JeromeDuboisPro/framework | d88925495e3787fdaf640c29728dcac385160188 | [
"Apache-2.0"
] | null | null | null | arcane/src/arcane/ios/VtuMeshWriter.cc | JeromeDuboisPro/framework | d88925495e3787fdaf640c29728dcac385160188 | [
"Apache-2.0"
] | null | null | null | arcane/src/arcane/ios/VtuMeshWriter.cc | JeromeDuboisPro/framework | d88925495e3787fdaf640c29728dcac385160188 | [
"Apache-2.0"
] | null | null | null | // -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2021 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* VtuMeshWriter.cc (C) 2000-2018 */
/* */
/* Lecture/Ecriture d'un fichier au format VtuMeshWriter. */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#include "arcane/utils/ArcanePrecomp.h"
#include "arcane/utils/Iostream.h"
#include "arcane/utils/StdHeader.h"
#include "arcane/utils/HashTableMap.h"
#include "arcane/utils/ValueConvert.h"
#include "arcane/utils/ScopedPtr.h"
#include "arcane/utils/ITraceMng.h"
#include "arcane/utils/String.h"
#include "arcane/utils/IOException.h"
#include "arcane/utils/Collection.h"
#include "arcane/utils/Enumerator.h"
#include "arcane/utils/NotImplementedException.h"
#include "arcane/utils/Real3.h"
#include "arcane/FactoryService.h"
#include "arcane/IMainFactory.h"
#include "arcane/IMeshReader.h"
#include "arcane/ISubDomain.h"
#include "arcane/IMesh.h"
#include "arcane/IMeshSubMeshTransition.h"
#include "arcane/IItemFamily.h"
#include "arcane/Item.h"
#include "arcane/ItemEnumerator.h"
#include "arcane/VariableTypes.h"
#include "arcane/IVariableAccessor.h"
#include "arcane/IParallelMng.h"
#include "arcane/IIOMng.h"
#include "arcane/IXmlDocumentHolder.h"
#include "arcane/XmlNodeList.h"
#include "arcane/XmlNode.h"
#include "arcane/IMeshUtilities.h"
#include "arcane/IMeshWriter.h"
#include "arcane/BasicService.h"
#include "arcane/utils/PlatformUtils.h"
#include "arcane/AbstractService.h"
#include <vtkXMLUnstructuredGridReader.h>
#include <vtkIdTypeArray.h>
#include "vtkXMLUnstructuredGridWriter.h"
#include <vtkUnstructuredGrid.h>
#include <vtkCell.h>
#include <vtkObject.h>
#include <vtkDataObject.h>
#include <vtkDataSet.h>
#include <vtkCellData.h>
#include <vtkPointData.h>
#include <vtkDataArray.h>
#include <vtkLongArray.h>
#include <vtkIntArray.h>
#include <vtkFieldData.h>
#include <map>
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
ARCANE_BEGIN_NAMESPACE
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*!
* \brief Ecriture des fichiers de maillage au format VTU (de VTK).
*/
class VtuMeshWriter
: public AbstractService
, public IMeshWriter
{
public:
VtuMeshWriter(const ServiceBuildInfo& sbi)
: AbstractService(sbi) {}
virtual void build() {}
virtual bool writeMeshToFile(IMesh* mesh,const String& file_name);
protected:
void _writeFieldGroupsFromData(vtkFieldData* field_data, ItemGroup groups);
};
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
ARCANE_REGISTER_SERVICE(VtuMeshWriter,
ServiceProperty("VtuNewMeshWriter",ST_SubDomain),
ARCANE_SERVICE_INTERFACE(IMeshWriter));
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*****************************************************************\
* _writeFieldGroupsFromData
uniqueId().asInteger
localId
\*****************************************************************/
void VtuMeshWriter::
_writeFieldGroupsFromData(vtkFieldData*fieldData,ItemGroup group)
{
vtkLongArray* a = vtkLongArray::New();
a->SetName(group.name().localstr());
a->InsertNextValue(group.itemKind());
ENUMERATE_ITEM(iitem, group){
a->InsertNextValue(iitem->uniqueId());
}
a->SetNumberOfTuples(a->GetNumberOfTuples());
fieldData->AddArray(a);
a->Delete();
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*!
\brief Écrit un maillage.
Les données sont stockées selon ARCANE_VTU_DATA_MODE_TO_[ASCII|BINARY],
le BINARY étant celui par défaut.
\param mesh maillage à écrire
\param file_name nom du fichier
\retval true pour une erreur
\retval false pour un succès
*/
bool VtuMeshWriter::
writeMeshToFile(IMesh* mesh,const String& file_name)
{
Integer mesh_nb_node = mesh->nbNode();
Integer mesh_nb_cell = mesh->nbCell();
std::map<Int64,Integer> uid_to_idx_map; // Unique nodes-IDs array
info() << "[VtuMeshWriter::writeMeshToFile] mesh_nb_node=" <<mesh_nb_node << " mesh_nb_cell="<< mesh_nb_cell
<< " all=" << mesh->allNodes().size() << ", own=" << mesh->ownNodes().size();
/*************************\
* VTK-side initialisation *
\*************************/
vtkPoints* points = vtkPoints::New();
points->SetDataTypeToDouble();
vtkUnstructuredGrid* grid = vtkUnstructuredGrid::New();
grid->Allocate(mesh_nb_cell, mesh_nb_cell);
/*************************\
* ARC-side initialisation *
\*************************/
VariableItemReal3& nodes_coords = PRIMARYMESH_CAST(mesh)->nodesCoordinates();
/*************************\
* Saving Cells Unique IDs *
\*************************/
info() << "[writeMeshToFile] Creating array of CELLS Unique IDs";
vtkCellData* vtk_cell_data = grid->GetCellData(); // Data associated to Cells
vtkLongArray* vtk_cell_uids = vtkLongArray::New();
vtk_cell_uids->SetName("CellsUniqueIDs");
ENUMERATE_CELL(iCell,mesh->allCells()){
Cell cell = *iCell;
vtk_cell_uids->InsertNextValue(cell.uniqueId());
}
vtk_cell_data->AddArray(vtk_cell_uids); // Now add our Cells' UniqueIDs array
vtk_cell_uids->Delete();
/*************************\
* Saving Nodes Unique IDs *
\*************************/
info() << "[writeMeshToFile] Creating array of NODES Unique IDs";
vtkPointData *vtk_point_data=grid->GetPointData(); // Data associated to Points
vtkLongArray *vtk_point_uids = vtkLongArray::New();
vtk_point_uids->SetName("NodesUniqueIDs");
vtkIntArray *vtk_point_owners = vtkIntArray::New();
vtk_point_owners->SetName("NodesOwner");
Integer index = 0;
ENUMERATE_NODE(inode,mesh->allNodes()){
Node node = *inode;
Int64 uid = node.uniqueId();
Real3 coord = nodes_coords[inode];
points->InsertNextPoint(Convert::toDouble(coord.x),
Convert::toDouble(coord.y),
Convert::toDouble(coord.z));
uid_to_idx_map.insert(std::make_pair(uid,index));
vtk_point_uids->InsertNextValue(uid);
vtk_point_owners->InsertNextValue(node.owner());
++index;
}
vtk_point_data->AddArray(vtk_point_uids);
vtk_point_uids->Delete();
vtk_point_data->AddArray(vtk_point_owners);
vtk_point_owners->Delete();
/*****************************\
* Now setting point into grid *
\*****************************/
info() << "[writeMeshToFile] Now setting point into grid";
grid->SetPoints(points);
/**********************************************\
* Scanning cells' nodes to create connectivity *
\**********************************************/
info() << "[writeMeshToFile] Now scanning cells' nodes to create connectivity";
vtkIdList* vtk_point_ids = vtkIdList::New();
ENUMERATE_CELL(iCell,mesh->allCells()){
Cell cell = *iCell;
int nb_node = cell.nbNode();
vtk_point_ids->Allocate(nb_node);
for( Integer j=0; j<nb_node; ++j ){
Int64 node_uid = cell.node(j).uniqueId();
auto x = uid_to_idx_map.find(node_uid);
if (x==uid_to_idx_map.end())
ARCANE_FATAL("InternalError: no index for uid '{0}'",node_uid);
vtk_point_ids->InsertNextId(x->second);
}
int vtk_item = IT_NullType;
switch(cell.type()){
// Linear cells
case(IT_Tetraedron4):
vtk_item = VTK_TETRA;
break;
case(IT_Hexaedron8):
vtk_item = VTK_HEXAHEDRON;
break;
case(IT_Pyramid5):
vtk_item = VTK_PYRAMID;
break;
// Mesh Generator simple-1&2
case(IT_Octaedron12):
vtk_item = VTK_HEXAGONAL_PRISM;
break;
case(IT_Heptaedron10):
vtk_item = VTK_PENTAGONAL_PRISM;
break;
// Prisme
case(IT_Pentaedron6):
vtk_item = VTK_WEDGE;
break;
// A demander
case(IT_HemiHexa7):
info() << "VTK_POLY_VERTEX";
vtk_item = VTK_POLY_VERTEX;
break;
case(IT_HemiHexa6):
info() << "VTK_POLY_VERTEX";
vtk_item = VTK_POLY_VERTEX;
break;
case(IT_HemiHexa5):
info() << "VTK_POLY_VERTEX";
vtk_item = VTK_POLY_VERTEX;
break;
case(IT_AntiWedgeLeft6):
info() << "VTK_POLY_VERTEX";
vtk_item = VTK_POLY_VERTEX;
break;
case(IT_AntiWedgeRight6):
info() << "VTK_POLY_VERTEX";
vtk_item = VTK_POLY_VERTEX;
break;
case(IT_DiTetra5):
info() << "VTK_POLY_VERTEX";
vtk_item = VTK_POLY_VERTEX;
break;
/* Others not yet implemented */
default:
info() << "[writeMeshToFile] Cell type not suported (" << cell.type() << ")";
throw NotSupportedException(A_FUNCINFO);
}
grid->InsertNextCell(vtk_item, vtk_point_ids);
vtk_point_ids->Reset();
}
vtk_point_ids->Delete();
/***********************\
* Fetching Other Groups *
\***********************/
info() << "[writeMeshToFile] ## Now Fetching Groups ##";
vtkFieldData* vtkFieldDataGroups = grid->GetFieldData();
for(ItemGroupCollection::Enumerator igroup(mesh->groups()); ++igroup;){
if (igroup->isAllItems())
continue;
info() << "[writeMeshToFile] Found a " << igroup->itemKind() << "-group " << igroup->name();
_writeFieldGroupsFromData(vtkFieldDataGroups, *igroup);
}
/************************\
* Now prepare for output *
\************************/
vtkXMLUnstructuredGridWriter* vtk_grid_writer = vtkXMLUnstructuredGridWriter::New();
vtk_grid_writer->SetInputData(grid);
String fileNameDotVtu(file_name + ".vtu");
vtk_grid_writer->SetFileName(fileNameDotVtu.localstr());
info() << "[writeMeshToFile] SetFileName " << fileNameDotVtu;
String isAscii = platform::getEnvironmentVariable("ARCANE_VTU_DATA_MODE_TO_ASCII");
if (!isAscii.null())
vtk_grid_writer->SetDataModeToAscii();
else
vtk_grid_writer->SetDataModeToBinary();
vtk_grid_writer->Write();
/**********************\
* And cleanup a little *
\**********************/
points->Delete();
grid->Delete();
vtk_grid_writer->Delete();
info() << "[writeMeshToFile] Done";
return false;
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
ARCANE_END_NAMESPACE
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
| 33.580838 | 109 | 0.562411 | [
"mesh"
] |
e6f0bc9547127de1a896a62fbfc8f03d9a68e803 | 10,547 | cpp | C++ | src/Engine/Collisions/BoundingBox.cpp | SamCZ/NovaEngine | 7f667988467ab611018f650295825b63c97e8d43 | [
"MIT"
] | 2 | 2021-04-18T06:40:19.000Z | 2021-06-29T23:35:31.000Z | src/Engine/Collisions/BoundingBox.cpp | SamCZ/NovaEngine | 7f667988467ab611018f650295825b63c97e8d43 | [
"MIT"
] | null | null | null | src/Engine/Collisions/BoundingBox.cpp | SamCZ/NovaEngine | 7f667988467ab611018f650295825b63c97e8d43 | [
"MIT"
] | null | null | null | #include "Engine/Collisions/BoundingBox.h"
#include "Engine/Collisions/Collidable.h"
#include "Engine/Collisions/Ray.h"
#include <limits>
#include "glm/gtx/matrix_decompose.hpp"
#include "glm/gtx/quaternion.hpp"
#include <glm/gtx/transform.hpp>
#include "Engine/Utils/Buffers.h"
#include <iostream>
#include "Engine/Collisions/Plane.h"
namespace NovaEngine {
BoundingBox::BoundingBox() : _center() {
checkSide = 0;
}
BoundingBox::~BoundingBox() {
}
BoundingBox::BoundingBox(BoundingBox * box) {
_center = box->getCenter();
_xExtent = box->getXExtent();
_yExtent = box->getYExtent();
_zExtent = box->getZExtent();
checkSide = 0;
}
BoundingBox::BoundingBox(glm::vec3 min, glm::vec3 max) : BoundingBox() {
setMinMax(min, max);
checkSide = 0;
}
BoundingBox::BoundingBox(glm::vec3 center, float xExtent, float yExtent, float zExtent) {
_center = center;
_xExtent = xExtent;
_yExtent = yExtent;
_zExtent = zExtent;
checkSide = 0;
}
void BoundingBox::computeFromMesh(Mesh* mesh) {
float _minX = std::numeric_limits<float>::infinity();
float _minY = std::numeric_limits<float>::infinity();
float _minZ = std::numeric_limits<float>::infinity();
float _maxX = -std::numeric_limits<float>::infinity();
float _maxY = -std::numeric_limits<float>::infinity();
float _maxZ = -std::numeric_limits<float>::infinity();
VertexBuffer* indexVertexBuffer = mesh->getVertexBuffer(MeshBuffer::Type::Index);
VertexBuffer* posVertexBuffer = mesh->getVertexBuffer(MeshBuffer::Type::Position);
if (indexVertexBuffer == nullptr) {
std::cout << "NO INDEX" << std::endl;
return;
}
FloatBuffer* vertices = static_cast<FloatBuffer*>(posVertexBuffer->getBuffer());
for (int i = 0; i < vertices->size() / 3; i++) {
glm::vec3 v = glm::vec3(vertices->get(i * 3 + 0), vertices->get(i * 3 + 1), vertices->get(i * 3 + 2));
if (v.x < _minX) {
_minX = v.x;
}
if (v.x > _maxX) {
_maxX = v.x;
}
if (v.y < _minY) {
_minY = v.y;
}
if (v.y > _maxY) {
_maxY = v.y;
}
if (v.z < _minZ) {
_minZ = v.z;
}
if (v.z > _maxZ) {
_maxZ = v.z;
}
}
_center = glm::vec3(_minX + _maxX, _minY + _maxY, _minZ + _maxZ);
_center *= 0.5f;
_xExtent = _maxX - _center.x;
_yExtent = _maxY - _center.y;
_zExtent = _maxZ - _center.z;
}
void BoundingBox::computeFromPoints(std::vector<glm::vec3>& points, glm::mat4* transform) {
float _minX = std::numeric_limits<float>::infinity();
float _minY = std::numeric_limits<float>::infinity();
float _minZ = std::numeric_limits<float>::infinity();
float _maxX = -std::numeric_limits<float>::infinity();
float _maxY = -std::numeric_limits<float>::infinity();
float _maxZ = -std::numeric_limits<float>::infinity();
bool useTransform = transform != nullptr;
for (int i = 0; i < points.size(); i++) {
glm::vec3 v = useTransform ? *transform * glm::vec4(points[i], 1.0) : points[i];
if (v.x < _minX) {
_minX = v.x;
}
if (v.x > _maxX) {
_maxX = v.x;
}
if (v.y < _minY) {
_minY = v.y;
}
if (v.y > _maxY) {
_maxY = v.y;
}
if (v.z < _minZ) {
_minZ = v.z;
}
if (v.z > _maxZ) {
_maxZ = v.z;
}
}
_center = glm::vec3(_minX + _maxX, _minY + _maxY, _minZ + _maxZ);
_center *= 0.5f;
_xExtent = _maxX - _center.x;
_yExtent = _maxY - _center.y;
_zExtent = _maxZ - _center.z;
//setMinMax(glm::vec3(_minX, _minY, _minZ), glm::vec3(_maxX, _maxY, _maxZ));
}
void BoundingBox::computeFromPoints(float * points, int size, glm::mat4 * transform) {
float _minX = std::numeric_limits<float>::infinity();
float _minY = std::numeric_limits<float>::infinity();
float _minZ = std::numeric_limits<float>::infinity();
float _maxX = -std::numeric_limits<float>::infinity();
float _maxY = -std::numeric_limits<float>::infinity();
float _maxZ = -std::numeric_limits<float>::infinity();
bool useTransform = transform != nullptr;
glm::vec3 point = glm::vec3();
for (int i = 0; i < size / 3; i++) {
point.x = points[i * 3 + 0];
point.y = points[i * 3 + 1];
point.z = points[i * 3 + 2];
glm::vec3 v = useTransform ? *transform * glm::vec4(point, 1.0) : point;
if (v.x < _minX) {
_minX = v.x;
}
if (v.x > _maxX) {
_maxX = v.x;
}
if (v.y < _minY) {
_minY = v.y;
}
if (v.y > _maxY) {
_maxY = v.y;
}
if (v.z < _minZ) {
_minZ = v.z;
}
if (v.z > _maxZ) {
_maxZ = v.z;
}
}
_center = glm::vec3(_minX + _maxX, _minY + _maxY, _minZ + _maxZ);
_center *= 0.5f;
_xExtent = _maxX - _center.x;
_yExtent = _maxY - _center.y;
_zExtent = _maxZ - _center.z;
}
int BoundingBox::collideWithRay(Ray ray, CollisionResults& results) {
glm::vec3 diff = ray.origin - _center;
glm::vec3 direction = ray.direction;
_clipTemp[0] = 0;
_clipTemp[1] = std::numeric_limits<float>::infinity();
float saveT0 = _clipTemp[0];
float saveT1 = _clipTemp[1];
bool notEntirelyClipped =
clip(+direction.x, -diff.x - _xExtent, _clipTemp) &&
clip(-direction.x, +diff.x - _xExtent, _clipTemp) &&
clip(+direction.y, -diff.y - _yExtent, _clipTemp) &&
clip(-direction.y, +diff.y - _yExtent, _clipTemp) &&
clip(+direction.z, -diff.z - _zExtent, _clipTemp) &&
clip(-direction.z, +diff.z - _zExtent, _clipTemp);
if (notEntirelyClipped && (_clipTemp[0] != saveT0 || _clipTemp[1] != saveT1)) {
if (_clipTemp[1] > _clipTemp[0]) {
glm::vec3 point0 = (ray.direction * _clipTemp[0]) + ray.origin;
glm::vec3 point1 = (ray.direction * _clipTemp[1]) + ray.origin;
CollisionResult result;
result.isNull = false;
result.contactPoint = point0;
result.distance = _clipTemp[0];
results.addCollision(result);
CollisionResult result2;
result2.isNull = false;
result2.contactPoint = point1;
result2.distance = _clipTemp[1];
results.addCollision(result2);
}
glm::vec3 point = (ray.direction * _clipTemp[0]) + ray.origin;
CollisionResult result;
result.isNull = false;
result.contactPoint = point;
result.distance = _clipTemp[0];
results.addCollision(result);
return 1;
}
return 0;
}
BoundingBox* BoundingBox::transform(glm::vec3 location, glm::vec3 rotation, glm::vec3 scale) {
glm::vec3 center = _center * scale;
glm::mat4 rotationMat = glm::mat4();
rotationMat *= glm::rotate(glm::radians(rotation.x), glm::vec3(1, 0, 0));
rotationMat *= glm::rotate(glm::radians(rotation.y), glm::vec3(0, 1, 0));
rotationMat *= glm::rotate(glm::radians(rotation.z), glm::vec3(0, 0, 1));
//glm::quat rotationQuat = glm::toQuat(rotationMat);
//glm::mat3 rotationMat3 = glm::mat3(rotationMat);
glm::mat3 rot = glm::mat3(rotationMat);
for (int i = 0; i < 3; i++) {
for (int a = 0; a < 3; a++) {
rot[i][a] = glm::abs(rot[i][a]);
}
}
center = rot * center;
center += location;
glm::vec3 vect1 = glm::vec3(_xExtent * glm::abs(scale.x), _yExtent * glm::abs(scale.y), _zExtent * glm::abs(scale.z));
glm::vec3 vect2 = rot * vect1;
float xExtent = glm::abs(vect2.x);
float yExtent = glm::abs(vect2.y);
float zExtent = glm::abs(vect2.z);
return new BoundingBox(center, xExtent, yExtent, zExtent);
/*glm::vec4 newCenter4 = trans * glm::vec4(_center, 1.0f);
glm::vec3 newCenter = newCenter4;
float w = newCenter4.w;
newCenter /= w;
glm::mat3 rotation = glm::mat3(glm::toQuat(trans));
for (int i = 0; i < 3; i++) {
for (int a = 0; a < 3; a++) {
rotation[i][a] = glm::abs(rotation[i][a]);
}
}
glm::vec3 vect1 = rotation * glm::vec3(_xExtent, _yExtent, _zExtent);
float xe = glm::abs(vect1.x);
float ye = glm::abs(vect1.y);
float ze = glm::abs(vect1.z);
return new BoundingBox(newCenter, xe, ye, ze);*/
}
void BoundingBox::checkMinMax(glm::vec3 &min, glm::vec3 &max, glm::vec3 & point) {
if (point.x < min.x) {
min.x = point.x;
}
if (point.x > max.x) {
max.x = point.x;
}
if (point.y < min.y) {
min.y = point.y;
}
if (point.y > max.y) {
max.y = point.y;
}
if (point.z < min.z) {
min.z = point.z;
}
if (point.z > max.z) {
max.z = point.z;
}
}
Side BoundingBox::whichSide(Plane& plane) {
float radius = glm::abs(_xExtent * plane.getNormal().x) + glm::abs(_yExtent * plane.getNormal().y) + glm::abs(_zExtent * plane.getNormal().z);
float distance = plane.pseudoDistance(_center);
//changed to < and > to prevent floating point precision problems
if (distance < -radius) {
return Side::Negative;
} else if (distance > radius) {
return Side::Positive;
} else {
return Side::None;
}
}
glm::vec3 & BoundingBox::getCenter() {
return _center;
}
void BoundingBox::setMinMax(glm::vec3 min, glm::vec3 max) {
_center = max;
_center += min;
_center *= 0.5f;
_xExtent = glm::abs(max.x - _center.x);
_yExtent = glm::abs(max.y - _center.y);
_zExtent = glm::abs(max.z - _center.z);
}
glm::vec3 BoundingBox::getMin() {
return _center - glm::vec3(_xExtent, _yExtent, _zExtent);
}
glm::vec3 BoundingBox::getMax() {
return _center + glm::vec3(_xExtent, _yExtent, _zExtent);
}
glm::vec3 BoundingBox::getExtent() {
return glm::vec3(_xExtent, _yExtent, _zExtent);
}
float BoundingBox::getXExtent() {
return _xExtent;
}
float BoundingBox::getYExtent() {
return _yExtent;
}
float BoundingBox::getZExtent() {
return _zExtent;
}
float BoundingBox::getMinX() {
return getMin().x;
}
float BoundingBox::getMinY() {
return getMin().y;
}
float BoundingBox::getMinZ() {
return getMin().z;
}
float BoundingBox::getMaxX() {
return getMax().x;
}
float BoundingBox::getMaxY() {
return getMax().y;
}
float BoundingBox::getMaxZ() {
return getMax().z;
}
std::string BoundingBox::toString() {
return std::string("Center(x=") + std::string(std::to_string(_center.x)) + std::string(",y=") + std::string(std::to_string(_center.y)) + std::string(",z=") + std::string(std::to_string(_center.z)) + std::string("),xe=") + std::string(std::to_string(_xExtent)) + std::string(",ye=") + std::string(std::to_string(_yExtent)) + std::string(",ze=") + std::string(std::to_string(_zExtent));
}
bool BoundingBox::clip(float denom, float numer, float t[]) {
if (denom > 0.0f) {
float newT = numer / denom;
if (newT > t[1]) {
return false;
}
if (newT > t[0]) {
t[0] = newT;
}
return true;
} else if (denom < 0.0f) {
float newT = numer / denom;
if (newT < t[0]) {
return false;
}
if (newT < t[1]) {
t[1] = newT;
}
return true;
} else {
return numer <= 0.0f;
}
}
}
| 25.72439 | 386 | 0.622357 | [
"mesh",
"vector",
"transform"
] |
e6f9a1a82364a811b0046760b8f6ca83f812d856 | 4,473 | cc | C++ | tensorflow_data_validation/anomalies/image_domain_util.cc | rtg0795/data-validation | 16e57d7d5f1aeb4b7b9b897c5021abf006261bbd | [
"Apache-2.0"
] | 621 | 2018-09-10T19:27:18.000Z | 2022-03-31T06:43:24.000Z | tensorflow_data_validation/anomalies/image_domain_util.cc | rtg0795/data-validation | 16e57d7d5f1aeb4b7b9b897c5021abf006261bbd | [
"Apache-2.0"
] | 157 | 2018-09-10T08:53:18.000Z | 2022-03-31T14:07:51.000Z | tensorflow_data_validation/anomalies/image_domain_util.cc | rtg0795/data-validation | 16e57d7d5f1aeb4b7b9b897c5021abf006261bbd | [
"Apache-2.0"
] | 141 | 2018-09-10T06:38:13.000Z | 2022-03-31T07:27:16.000Z | /* Copyright 2020 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 "tensorflow_data_validation/anomalies/image_domain_util.h"
#include <set>
#include <string>
#include <vector>
#include "absl/strings/str_cat.h"
#include "absl/strings/str_join.h"
#include "tensorflow_data_validation/anomalies/internal_types.h"
#include "tensorflow_data_validation/anomalies/map_util.h"
#include "tensorflow_data_validation/anomalies/statistics_view.h"
#include "tensorflow/core/platform/logging.h"
#include "tensorflow/core/platform/types.h"
#include "tensorflow_metadata/proto/v0/anomalies.pb.h"
#include "tensorflow_metadata/proto/v0/schema.pb.h"
#include "tensorflow_metadata/proto/v0/statistics.pb.h"
namespace tensorflow {
namespace data_validation {
namespace {
using ::tensorflow::metadata::v0::CustomStatistic;
using ::tensorflow::metadata::v0::Feature;
using ::tensorflow::metadata::v0::ImageDomain;
} // namespace
std::vector<Description> UpdateImageDomain(
const FeatureStatsView& feature_stats, Feature* feature) {
std::vector<Description> results;
const ImageDomain& image_domain = feature->image_domain();
if (image_domain.has_minimum_supported_image_fraction()) {
const CustomStatistic* image_format_histogram =
feature_stats.GetCustomStatByName("image_format_histogram");
if (image_format_histogram) {
float supported_image_count = 0;
float unsupported_image_count = 0;
for (const metadata::v0::RankHistogram::Bucket& bucket :
image_format_histogram->rank_histogram().buckets()) {
if (bucket.label() == "UNKNOWN") {
unsupported_image_count += bucket.sample_count();
} else {
supported_image_count += bucket.sample_count();
}
}
float supported_image_fraction =
supported_image_count /
(supported_image_count + unsupported_image_count);
const float original_minimum_supported_image_fraction =
image_domain.minimum_supported_image_fraction();
if (supported_image_fraction <
original_minimum_supported_image_fraction) {
feature->mutable_image_domain()->set_minimum_supported_image_fraction(
supported_image_fraction);
results.push_back(
{tensorflow::metadata::v0::AnomalyInfo::
LOW_SUPPORTED_IMAGE_FRACTION,
"Low supported image fraction",
absl::StrCat(
"Fraction of values containing TensorFlow supported "
"images: ",
std::to_string(supported_image_fraction),
" is lower than the threshold set in the Schema: ",
std::to_string(original_minimum_supported_image_fraction),
".")});
}
} else {
LOG(WARNING)
<< "image_domain.minimum_supported_image_fraction is specified "
"for feature "
<< feature->name()
<< ", but there is no "
"image_format_histogram in the statistics. You must enable "
"semantic "
"domain stats for the image_format_histogram to be generated.";
}
}
if (image_domain.has_max_image_byte_size()) {
const int64_t max_bytes_stat =
feature_stats.bytes_stats().max_num_bytes_int();
const int64_t max_allowed_bytes = image_domain.max_image_byte_size();
if (max_bytes_stat > max_allowed_bytes) {
feature->mutable_image_domain()->set_max_image_byte_size(max_bytes_stat);
results.push_back(
{tensorflow::metadata::v0::AnomalyInfo::MAX_IMAGE_BYTE_SIZE_EXCEEDED,
"Num bytes exceeds the max byte size.",
absl::StrCat("The largest image has bytes: ", max_bytes_stat,
". The max allowed byte size is: ", max_allowed_bytes,
".")});
}
}
return results;
}
} // namespace data_validation
} // namespace tensorflow
| 39.9375 | 80 | 0.68254 | [
"vector"
] |
fc0cdcf478d54cebbe76e3ed0f05b9e000c75deb | 125 | cc | C++ | chapter-11/11.19.cc | hongmi/cpp-primer-4-exercises | 98ddb98b41d457a1caa525d246dfb7453be0c8d2 | [
"MIT"
] | 1 | 2017-04-01T06:57:30.000Z | 2017-04-01T06:57:30.000Z | chapter-11/11.19.cc | hongmi/cpp-primer-4-exercises | 98ddb98b41d457a1caa525d246dfb7453be0c8d2 | [
"MIT"
] | null | null | null | chapter-11/11.19.cc | hongmi/cpp-primer-4-exercises | 98ddb98b41d457a1caa525d246dfb7453be0c8d2 | [
"MIT"
] | null | null | null | vector<int> vi;
vector<int>::reverse_iterator ri = vi.rbegin();
while (ri != vi.rend()) {
cout << *ri << endl;
++ri;
}
| 15.625 | 47 | 0.568 | [
"vector"
] |
fc10d902993010d874a499209b5293191b80b281 | 4,744 | cpp | C++ | miniSQL/Catalog.cpp | watermelooon/MiniSQL | b051afda0b77977c267c15ec77b3519bc42c11cb | [
"MIT"
] | null | null | null | miniSQL/Catalog.cpp | watermelooon/MiniSQL | b051afda0b77977c267c15ec77b3519bc42c11cb | [
"MIT"
] | null | null | null | miniSQL/Catalog.cpp | watermelooon/MiniSQL | b051afda0b77977c267c15ec77b3519bc42c11cb | [
"MIT"
] | null | null | null | #include"catalog.h"
using namespace std;
class XML
{
private:
TiXmlDocument doc;
public:
TiXmlElement* load_root(string database_name)
{
string database_path = database_name + ".xml";
if (!doc.LoadFile(database_path.c_str()))
{
cerr << doc.ErrorDesc() << endl;
return NULL;
}
TiXmlElement* root = doc.FirstChildElement();
if (root == NULL)
{
cerr << "ERROR:Fail to load file: No root element." << endl;
return NULL;
}
return root;
}
void save(string path)
{
path = path + ".xml";
doc.SaveFile(path.c_str());
}
void close()
{
doc.Clear();
}
};
vector<int> get_Attribute_bytes(string database_name, string table_name)
{
vector<int> Attri_bytes;
TiXmlElement* root;
XML xml_file;
root = xml_file.load_root(database_name);
bool found = false;
TiXmlElement* table = root->FirstChildElement();
while (table != NULL)
{
string s = table->Value();
//cout << "#" << s << "," << table_name.c_str() << "#" << endl;
if (s == table_name.c_str())
{
found = true;
//int num = atoi(table->Attribute("attributeNum"));
for (TiXmlElement* attribute = table->FirstChildElement(); attribute != NULL; attribute = attribute->NextSiblingElement())
{
string text = attribute->GetText();
if (text.compare(0, 4, "char") == 0)
Attri_bytes.push_back(atoi(text.substr(5, text.find(')') - 5).c_str()));
else if (text.compare(0, 3, "int") == 0)
Attri_bytes.push_back(10);
else if (text.compare(0, 5, "float") == 0)
Attri_bytes.push_back(10);
}
break;
}
table = table->NextSiblingElement();
}
xml_file.close();
if (found == false)
{
printf("ERROR: No such table\n");
}
return Attri_bytes;
}
vector<string> get_Attribute_list(string database_name, string table_name)
{
vector<string> Attribute_list;
TiXmlElement* root;
XML xml_file;
root = xml_file.load_root(database_name);
bool found = false;
TiXmlElement* table = root->FirstChildElement();
while (table != NULL)
{
string s = table->Value();
if (s == table_name.c_str())
{
found = true;
//int num = atoi(table->Attribute("attributeNum"));
for (TiXmlElement* attribute = table->FirstChildElement(); attribute != NULL; attribute = attribute->NextSiblingElement())
{
string attributeName = attribute->Value();
Attribute_list.push_back(attributeName);
}
break;
}
table = table->NextSiblingElement();
}
xml_file.close();
if (found == false)
{
printf("ERROR: No such table\n");
}
return Attribute_list;
}
string get_primary_key(string database_name, string table_name)
{
TiXmlElement* root;
XML xml_file;
string primary_key;
root = xml_file.load_root(database_name);
bool found = false;
TiXmlElement* table = root->FirstChildElement();
while (table != NULL)
{
string s = table->Value();
if (s == table_name.c_str())
{
primary_key = table->Attribute("primary");
found = true;
break;
}
table = table->NextSiblingElement();
}
xml_file.close();
if (found == false)
{
printf("ERROR: Primary key not found\n");
}
return primary_key;
}
bool createTable_catalog(string database_name, string table_name, string pKey, int num, string* attributeList, string *typeList)
{
TiXmlElement* root;
XML xml_file;
root = xml_file.load_root(database_name);
TiXmlElement* table = root->FirstChildElement();
while (table != NULL)
{
string name = table->Value();
if (name == table_name.c_str())
{
printf("ERROR:Table name already exists!\n");
return 1;
}
table = table->NextSiblingElement();
}
table = new TiXmlElement(table_name.c_str());
root->LinkEndChild(table);
table->SetAttribute("attributeNum", num);
table->SetAttribute("primary", pKey.c_str());
TiXmlElement* table_attribute;
TiXmlText *attribute_type;
for (int i=0; i<num;i++)
{
table_attribute = new TiXmlElement((attributeList[i].c_str()));
table->LinkEndChild(table_attribute);
attribute_type = new TiXmlText(typeList[i].c_str());
table_attribute->LinkEndChild(attribute_type);
}
xml_file.save(database_name);
xml_file.close();
printf("Create table successfully\n");
return 0;
}
bool dropTable_catalog(string database_name, string table_name)
{
int flag=0;
TiXmlElement* root;
XML xml_file;
root = xml_file.load_root(database_name);
TiXmlElement* table = root->FirstChildElement();
while (table != NULL)
{
string s = table->Value();
if (s == table_name.c_str())
{
root->RemoveChild(table);
flag = 1;
break;
}
table = table->NextSiblingElement();
}
//doc.SaveFile("cjt.xml");
//doc.Clear();
xml_file.save(database_name);
xml_file.close();
if (flag == 1)
{
printf("Drop table successfully\n");
return 0;
}
else
{
printf("ERROR:Fail to drop table: no such table\n");
return 1;
}
} | 22.807692 | 128 | 0.672428 | [
"vector"
] |
fc120a6f88e90536161016b2723afc0add601da6 | 93,773 | hpp | C++ | include/universal/number/cfloat/cfloat_impl.hpp | shikharvashistha/universal | 5c20504504f067412958fa61ea3839cf86c3d6f7 | [
"MIT"
] | null | null | null | include/universal/number/cfloat/cfloat_impl.hpp | shikharvashistha/universal | 5c20504504f067412958fa61ea3839cf86c3d6f7 | [
"MIT"
] | null | null | null | include/universal/number/cfloat/cfloat_impl.hpp | shikharvashistha/universal | 5c20504504f067412958fa61ea3839cf86c3d6f7 | [
"MIT"
] | null | null | null | #pragma once
// cfloat.hpp: 'classic' float: definition of an arbitrary configuration linear floating-point representation
//
// Copyright (C) 2017-2021 Stillwater Supercomputing, Inc.
//
// This file is part of the universal numbers project, which is released under an MIT Open Source license.
// compiler specific configuration for C++20 bit_cast
#include <universal/utility/bit_cast.hpp>
// supporting types and functions
#include <universal/native/ieee754.hpp>
#include <universal/native/subnormal.hpp>
#include <universal/native/bit_functions.hpp>
#include <universal/number/shared/nan_encoding.hpp>
#include <universal/number/shared/infinite_encoding.hpp>
#include <universal/number/shared/specific_value_encoding.hpp>
// cfloat exception structure
#include <universal/number/cfloat/exceptions.hpp>
// composition types used by cfloat
#include <universal/internal/blockbinary/blockbinary.hpp>
#include <universal/internal/blocktriple/blocktriple.hpp>
#ifndef CFLOAT_THROW_ARITHMETIC_EXCEPTION
#define CFLOAT_THROW_ARITHMETIC_EXCEPTION 0
#endif
#ifndef TRACE_CONVERSION
#define TRACE_CONVERSION 0
#endif
namespace sw::universal {
constexpr bool _trace_cfloat_add = false; // TODO consolidate in a trace include file
/*
* classic floats have denorms, but no gradual overflow, and
* project values outside of their dynamic range to +-inf
*
* Behavior flags
* gradual underflow: use all fraction encodings when exponent is all 0's
* gradual overflow: use all fraction encodings when exponent is all 1's
* saturation to maxneg or maxpos when value is out of dynamic range
*/
// Forward definitions
template<size_t nbits, size_t es, typename bt,
bool hasSubnormals, bool hasSupernormals, bool isSaturating> class cfloat;
template<size_t nbits, size_t es, typename bt,
bool hasSubnormals, bool hasSupernormals, bool isSaturating>
cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>
abs(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>&);
/// <summary>
/// decode an cfloat value into its constituent parts
/// </summary>
/// <typeparam name="bt"></typeparam>
/// <param name="v"></param>
/// <param name="s"></param>
/// <param name="e"></param>
/// <param name="f"></param>
template<size_t nbits, size_t es, size_t fbits, typename bt,
bool hasSubnormals, bool hasSupernormals, bool isSaturating>
void decode(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& v, bool& s, blockbinary<es, bt>& e, blockbinary<fbits, bt>& f) {
v.sign(s);
v.exponent(e);
v.fraction(f);
}
/// <summary>
/// return the binary scale of the given number
/// </summary>
/// <typeparam name="bt">Block type used for storage: derived through ADL</typeparam>
/// <param name="v">the cfloat number for which we seek to know the binary scale</param>
/// <returns>binary scale, i.e. 2^scale, of the value of the cfloat</returns>
template<size_t nbits, size_t es, typename bt,
bool hasSubnormals, bool hasSupernormals, bool isSaturating>
int scale(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& v) {
return v.scale();
}
/// <summary>
/// parse a text string into a cfloat value
/// </summary>
/// <typeparam name="bt"></typeparam>
/// <param name="str"></param>
/// <returns></returns>
template<size_t nbits, size_t es, typename bt,
bool hasSubnormals, bool hasSupernormals, bool isSaturating>
cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating> parse(const std::string& str) {
using cfloatType = cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>;
cfloatType a{ 0 };
if (str[0] == 'b') {
size_t index = nbits;
for (size_t i = 1; i < str.size(); ++i) {
if (str[i] == '1') {
a.setbit(--index, true);
}
else if (str[i] == '0') {
a.setbit(--index, false);
}
else if (str[i] == '.' || str[i] == '\'') {
// ignore annotation
}
}
}
else {
std::cerr << "parse currently only parses binary string formats\n";
}
return a;
}
// convert a blocktriple to a cfloat
template<size_t srcbits, size_t nbits, size_t es, typename bt,
bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline /*constexpr*/ void convert(const blocktriple<srcbits, bt>& src,
cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& tgt) {
// std::cout << "convert: " << to_binary(src) << std::endl;
using cfloatType = cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>;
// test special cases
if (src.isnan()) {
tgt.setnan(src.sign());
}
else if (src.isinf()) {
tgt.setinf(src.sign());
}
else if (src.iszero()) {
tgt.setzero();
tgt.setsign(src.sign()); // preserve sign
}
else {
int64_t scale = src.scale();
if (scale < cfloatType::MIN_EXP_SUBNORMAL) {
tgt.setzero();
return;
}
if (scale > cfloatType::MAX_EXP) {
if constexpr (isSaturating) {
if (src.sign()) {
tgt.maxneg();
}
else {
tgt.maxpos();
}
}
else {
tgt.setinf(src.sign());
}
return;
}
// tgt.clear();
if constexpr (nbits < 65) {
// we can use a uint64_t to construct the cfloat
uint64_t raw = (src.sign() ? 1ull : 0ull);
raw <<= es; // shift left to make room for the exponent bits
if (scale >= cfloatType::MIN_EXP_SUBNORMAL && scale < cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>::MIN_EXP_NORMAL) {
// resulting cfloat will be a subnormal number: all exponent bits are 0
raw <<= cfloatType::fbits;
int rightShift = cfloatType::MIN_EXP_NORMAL - static_cast<int>(scale);
uint64_t fracbits = (1ull << srcbits) | src.fraction_ull(); // add the hidden bit explicitely as it will shift into the msb of the denorm
//uint64_t fracbits = src.fraction_ull();
fracbits >>= rightShift + (srcbits - cfloatType::fbits);
raw |= fracbits;
tgt.setbits(raw);
}
else {
// resulting cfloat will be a normal number
uint64_t fracbits = src.fraction_ull();
constexpr size_t shift = srcbits - cfloatType::fbits;
// ... lsb | guard round sticky round
// x 0 x x down
// 0 1 0 0 down round to even
// 1 1 0 0 up round to even
// x 1 0 1 up
uint64_t mask = (1ull << shift);
bool lsb = fracbits & mask;
mask >>= 1;
bool guard = fracbits & mask;
mask >>= 1;
bool round = fracbits & mask;
mask = 0xFFFF'FFFF'FFFF'FFFF << (shift - 2);
mask = ~mask;
// std::cout << to_binary(fracbits) << std::endl;
// std::cout << to_binary(mask) << std::endl;
bool sticky = fracbits & mask;
bool roundup = (guard && (lsb || (round || sticky)));
// std::cout << (roundup ? "rounding up\n" : "rounding down\n");
fracbits >>= shift;
fracbits += (roundup ? 1ull : 0ull);
if (fracbits != (1ull << cfloatType::fbits)) { // check for overflow
raw |= scale + cfloatType::EXP_BIAS; // this is guaranteed to be a value that can be unsigned encoded
raw <<= cfloatType::fbits;
raw |= fracbits;
tgt.setbits(raw);
tgt.post_process();
}
else {
// rounding made the fraction overflow
if (scale < cfloatType::MAX_EXP) {
++scale;
raw |= scale + cfloatType::EXP_BIAS;
raw <<= cfloatType::fbits;
raw |= (fracbits & cfloatType::ALL_ONES_FR); // reset the overflow bit
tgt.setbits(raw);
}
else {
tgt.setinf(src.sign());
}
}
}
}
else {
// compose the segments
tgt.setsign(src.sign());
tgt.setexponent(src.scale());
// this api doesn't work: tgt.setfraction(src.significant());
std::cerr << "convert nbits > 64 TBD\n";
}
}
}
/// <summary>
/// An arbitrary configuration real number with gradual under/overflow and uncertainty bit
/// </summary>
/// <typeparam name="nbits">number of bits in the encoding</typeparam>
/// <typeparam name="es">number of exponent bits in the encoding</typeparam>
/// <typeparam name="bt">the type to use as storage class: one of [uint8_t|uint16_t|uint32_t]</typeparam>
template<size_t _nbits, size_t _es, typename bt = uint8_t,
bool _hasSubnormals = true, bool _hasSupernormals = true, bool _isSaturating = false>
class cfloat {
public:
static_assert(_nbits > _es + 1ull, "nbits is too small to accomodate the requested number of exponent bits");
static_assert(_es < 2147483647ull, "my God that is a big number, are you trying to break the Interweb?");
static_assert(_es > 0, "number of exponent bits must be bigger than 0 to be a classic floating point number");
// how do you assert on the condition that if es == 1 then subnormals and supernormals bust be true?
// static_assert(_es == 1 && _hasSubnormals && _hasSupernormals, "when es == 1, cfloat must have both sub and supernormals");
static constexpr size_t bitsInByte = 8ull;
static constexpr size_t bitsInBlock = sizeof(bt) * bitsInByte;
static_assert(bitsInBlock <= 64, "storage unit for block arithmetic needs to be <= uint64_t"); // TODO: carry propagation on uint64_t requires assembly code
static constexpr size_t nbits = _nbits;
static constexpr size_t es = _es;
static constexpr size_t fbits = nbits - 1ull - es; // number of fraction bits excluding the hidden bit
static constexpr size_t fhbits = nbits - es; // number of fraction bits including the hidden bit
static constexpr size_t abits = 2 * fhbits; // size of the addend
static constexpr size_t mbits = 2ull * fhbits; // size of the multiplier output
static constexpr size_t divbits = 3ull * fhbits + 4ull;// size of the divider output
static constexpr size_t storageMask = (0xFFFFFFFFFFFFFFFFull >> (64ull - bitsInBlock));
static constexpr bt ALL_ONES = bt(~0); // block type specific all 1's value
static constexpr uint32_t ALL_ONES_ES = (0xFFFF'FFFFul >> (32 - es));
static constexpr uint64_t ALL_ONES_FR = (0xFFFF'FFFF'FFFF'FFFFull >> (64 - fbits)); // special case for nbits <= 64
static constexpr uint64_t INF_ENCODING = (ALL_ONES_FR & ~1ull);
static constexpr size_t nrBlocks = 1ull + ((nbits - 1ull) / bitsInBlock);
static constexpr size_t MSU = nrBlocks - 1ull; // MSU == Most Significant Unit, as MSB is already taken
static constexpr bt MSU_MASK = (ALL_ONES >> (nrBlocks * bitsInBlock - nbits));
static constexpr size_t bitsInMSU = bitsInBlock - (nrBlocks * bitsInBlock - nbits);
static constexpr size_t fBlocks = 1ull + ((fbits - 1ull) / bitsInBlock); // nr of blocks with fraction bits
static constexpr size_t FSU = fBlocks - 1ull; // FSU = Fraction Significant Unit: the index of the block that contains the most significant fraction bits
static constexpr bt FSU_MASK = (ALL_ONES >> (fBlocks * bitsInBlock - fbits));
static constexpr size_t bitsInFSU = bitsInBlock - (fBlocks * bitsInBlock - fbits);
static constexpr bt SIGN_BIT_MASK = bt(bt(1ull) << ((nbits - 1ull) % bitsInBlock));
static constexpr bt LSB_BIT_MASK = bt(1ull);
static constexpr bool MSU_CAPTURES_E = (1ull + es) <= bitsInMSU;
static constexpr size_t EXP_SHIFT = (MSU_CAPTURES_E ? (1 == nrBlocks ? (nbits - 1ull - es) : (bitsInMSU - 1ull -es)) : 0);
static constexpr bt MSU_EXP_MASK = ((ALL_ONES << EXP_SHIFT) & ~SIGN_BIT_MASK) & MSU_MASK;
static constexpr int EXP_BIAS = ((1l << (es - 1ull)) - 1l);
static constexpr int MAX_EXP = (es == 1) ? 1 : ((1l << es) - EXP_BIAS - 1);
static constexpr int MIN_EXP_NORMAL = 1 - EXP_BIAS;
static constexpr int MIN_EXP_SUBNORMAL = 1 - EXP_BIAS - int(fbits); // the scale of smallest ULP
static constexpr bt BLOCK_MASK = bt(-1);
static constexpr bool hasSubnormals = _hasSubnormals;
static constexpr bool hasSupernormals = _hasSupernormals;
static constexpr bool isSaturating = _isSaturating;
typedef bt BlockType;
// constructors
constexpr cfloat() noexcept : _block{ 0 } {};
constexpr cfloat(const cfloat&) noexcept = default;
constexpr cfloat(cfloat&&) noexcept = default;
constexpr cfloat& operator=(const cfloat&) noexcept = default;
constexpr cfloat& operator=(cfloat&&) noexcept = default;
// decorated/converting constructors
/// <summary>
/// construct an cfloat from another, block type bt must be the same
/// </summary>
/// <param name="rhs"></param>
template<size_t nnbits, size_t ees>
cfloat(const cfloat<nnbits, ees, bt, hasSubnormals, hasSupernormals, isSaturating>& rhs) {
// this->assign(rhs);
}
// specific value constructor
constexpr cfloat(const SpecificValue code) : _block{ 0 } {
switch (code) {
case SpecificValue::maxpos:
maxpos();
break;
case SpecificValue::minpos:
minpos();
break;
case SpecificValue::zero:
default:
zero();
break;
case SpecificValue::minneg:
minneg();
break;
case SpecificValue::maxneg:
maxneg();
break;
}
}
/// <summary>
/// construct an cfloat from a native type, specialized for size
/// </summary>
/// <param name="iv">initial value to construct</param>
constexpr cfloat(signed char iv) noexcept : _block{ 0 } { *this = iv; }
constexpr cfloat(short iv) noexcept : _block{ 0 } { *this = iv; }
constexpr cfloat(int iv) noexcept : _block{ 0 } { *this = iv; }
constexpr cfloat(long iv) noexcept : _block{ 0 } { *this = iv; }
constexpr cfloat(long long iv) noexcept : _block{ 0 } { *this = iv; }
constexpr cfloat(char iv) noexcept : _block{ 0 } { *this = iv; }
constexpr cfloat(unsigned short iv) noexcept : _block{ 0 } { *this = iv; }
constexpr cfloat(unsigned int iv) noexcept : _block{ 0 } { *this = iv; }
constexpr cfloat(unsigned long iv) noexcept : _block{ 0 } { *this = iv; }
constexpr cfloat(unsigned long long iv) noexcept : _block{ 0 } { *this = iv; }
constexpr cfloat(float iv) noexcept : _block{ 0 } { *this = iv; }
constexpr cfloat(double iv) noexcept : _block{ 0 } { *this = iv; }
constexpr cfloat(long double iv) noexcept : _block{ 0 } { *this = iv; }
// assignment operators
constexpr cfloat& operator=(signed char rhs) { return convert_signed_integer(rhs); }
constexpr cfloat& operator=(short rhs) { return convert_signed_integer(rhs); }
constexpr cfloat& operator=(int rhs) { return convert_signed_integer(rhs); }
constexpr cfloat& operator=(long rhs) { return convert_signed_integer(rhs); }
constexpr cfloat& operator=(long long rhs) { return convert_signed_integer(rhs); }
constexpr cfloat& operator=(char rhs) { return convert_unsigned_integer(rhs); }
constexpr cfloat& operator=(unsigned short rhs) { return convert_unsigned_integer(rhs); }
constexpr cfloat& operator=(unsigned int rhs) { return convert_unsigned_integer(rhs); }
constexpr cfloat& operator=(unsigned long rhs) { return convert_unsigned_integer(rhs); }
constexpr cfloat& operator=(unsigned long long rhs) { return convert_unsigned_integer(rhs); }
CONSTEXPRESSION cfloat& operator=(float rhs) { return convert_ieee754(rhs); }
CONSTEXPRESSION cfloat& operator=(double rhs) { return convert_ieee754(rhs); }
CONSTEXPRESSION cfloat& operator=(long double rhs) { return convert_ieee754(rhs); }
// arithmetic operators
// prefix operator
inline cfloat operator-() const {
cfloat tmp(*this);
tmp._block[MSU] ^= SIGN_BIT_MASK;
return tmp;
}
cfloat& operator+=(const cfloat& rhs) {
if constexpr (_trace_cfloat_add) std::cout << "---------------------- ADD -------------------" << std::endl;
// special case handling of the inputs
#if CFLOAT_THROW_ARITHMETIC_EXCEPTION
if (isnan(NAN_TYPE_SIGNALLING) || rhs.isnan(NAN_TYPE_SIGNALLING)) {
throw cfloat_operand_is_nan{};
}
#else
if (isnan(NAN_TYPE_SIGNALLING) || rhs.isnan(NAN_TYPE_SIGNALLING)) {
setnan(NAN_TYPE_SIGNALLING);
return *this;
}
if (isnan(NAN_TYPE_QUIET) || rhs.isnan(NAN_TYPE_QUIET)) {
setnan(NAN_TYPE_QUIET);
return *this;
}
#endif
// normal + inf = inf
// normal + -inf = -inf
// inf + normal = inf
// inf + inf = inf
// inf + -inf = ?
// -inf + normal = -inf
// -inf + -inf = -inf
// -inf + inf = ?
if (isinf()) {
if (rhs.isinf()) {
if (sign() != rhs.sign()) {
setnan(NAN_TYPE_SIGNALLING);
}
return *this;
}
else {
return *this;
}
}
else {
if (rhs.isinf()) {
*this = rhs;
return *this;
}
}
if (iszero()) {
*this = rhs;
return *this;
}
if (rhs.iszero()) return *this;
// arithmetic operation
blocktriple<abits, bt> a, b, sum;
// transform the inputs into (sign,scale,significant)
// triples of the correct width
normalizeAddition(a);
rhs.normalizeAddition(b);
sum.add(a, b);
convert(sum, *this);
return *this;
}
cfloat& operator+=(double rhs) {
return *this += cfloat(rhs);
}
cfloat& operator-=(const cfloat& rhs) {
if (rhs.isnan())
return *this += rhs;
else
return *this += -rhs;
}
cfloat& operator-=(double rhs) {
return *this -= cfloat(rhs);
}
cfloat& operator*=(const cfloat& rhs) {
return *this;
}
cfloat& operator*=(double rhs) {
return *this *= cfloat(rhs);
}
cfloat& operator/=(const cfloat& rhs) {
return *this;
}
cfloat& operator/=(double rhs) {
return *this /= cfloat(rhs);
}
/// <summary>
/// move to the next bit encoding modulo 2^nbits
/// </summary>
/// <typeparam name="bt"></typeparam>
inline cfloat& operator++() {
if constexpr (0 == nrBlocks) {
return *this;
}
else if constexpr (1 == nrBlocks) {
if (ispos()) {
if ((_block[MSU] & (MSU_MASK >> 1)) == (MSU_MASK >> 1)) { // pattern: 0.11.111 = nan
_block[MSU] |= SIGN_BIT_MASK; // pattern: 1.11.111 = snan
}
else {
++_block[MSU];
}
}
else {
if ((_block[MSU] & SIGN_BIT_MASK) == _block[MSU]) { // pattern: 1.00.000 = -0
_block[MSU] = 0; // pattern: 0.00.000 = +0
}
else {
--_block[MSU];
}
}
}
else {
if (ispos()) {
// special case: pattern: 0.11.111 = nan transitions to pattern: 1.11.111 = snan
if (isnan()) {
setnan(NAN_TYPE_SIGNALLING);
}
else {
bool carry = true;
for (unsigned i = 0; i < MSU; ++i) {
if (carry) {
if ((_block[i] & storageMask) == storageMask) { // block will overflow
_block[i] = 0;
carry = true;
}
else {
++_block[i];
carry = false;
}
}
}
if (carry) {
++_block[MSU];
}
}
}
else {
// special case: pattern: 1.00.000 = -0 transitions to pattern: 0.00.000 = +0
if (iszero()) {
setzero();
}
else {
// 1111 0000
// 1110 1111
bool borrow = true;
for (unsigned i = 0; i < MSU; ++i) {
if (borrow) {
if ((_block[i] & storageMask) == 0) { // block will underflow
--_block[i];
borrow = true;
}
else {
--_block[i];
borrow = false;
}
}
}
if (borrow) {
--_block[MSU];
}
}
}
}
return *this;
}
inline cfloat operator++(int) {
cfloat tmp(*this);
operator++();
return tmp;
}
inline cfloat& operator--() {
if constexpr (0 == nrBlocks) {
return *this;
}
else if constexpr (1 == nrBlocks) {
if (ispos()) {
if (_block[MSU] == 0) { // pattern: 0.00.000 = 0
_block[MSU] |= SIGN_BIT_MASK; // pattern: 1.00.000 = -0
}
else {
--_block[MSU];
}
}
else {
if ((_block[MSU] & MSU_MASK) == MSU_MASK) { // pattern: 1.11.111 = snan
_block[MSU] &= ~SIGN_BIT_MASK; // pattern: 0.11.111 = qnan
}
else {
++_block[MSU];
}
}
}
else {
if (ispos()) {
// special case: pattern: 0.00.000 = +0 transitions to pattern: 1.00.000 = -0
if (iszero()) {
setsign(true);
}
else {
bool borrow = true;
for (unsigned i = 0; i < MSU; ++i) {
if (borrow) {
if ((_block[i] & storageMask) == 0) { // block will underflow
--_block[i];
borrow = true;
}
else {
--_block[i];
borrow = false;
}
}
}
if (borrow) {
--_block[MSU];
}
}
}
else {
// special case: pattern: 1.11.111 = snan transitions to pattern: 0.11.111 = qnan
if (isnan()) {
setsign(false);
}
else {
bool carry = true;
for (unsigned i = 0; i < MSU; ++i) {
if (carry) {
if ((_block[i] & storageMask) == storageMask) { // block will overflow
_block[i] = 0;
carry = true;
}
else {
++_block[i];
carry = false;
}
}
}
if (carry) {
++_block[MSU];
}
}
}
}
return *this;
}
inline cfloat operator--(int) {
cfloat tmp(*this);
operator--();
return tmp;
}
// modifiers
/// <summary>
/// clear the content of this cfloat to zero
/// </summary>
/// <returns>void</returns>
inline constexpr void clear() noexcept {
for (size_t i = 0; i < nrBlocks; ++i) {
_block[i] = bt(0);
}
}
/// <summary>
/// set the number to +0
/// </summary>
/// <returns>void</returns>
inline constexpr void setzero() noexcept { clear(); }
/// <summary>
/// set the number to +inf
/// </summary>
/// <param name="sign">boolean to make it + or - infinity, default is -inf</param>
/// <returns>void</returns>
inline constexpr void setinf(bool sign = true) noexcept {
if constexpr (0 == nrBlocks) {
return;
}
else if constexpr (1 == nrBlocks) {
_block[MSU] = sign ? bt(MSU_MASK ^ LSB_BIT_MASK) : bt(~SIGN_BIT_MASK & (MSU_MASK ^ LSB_BIT_MASK));
}
else if constexpr (2 == nrBlocks) {
_block[0] = BLOCK_MASK ^ LSB_BIT_MASK;
_block[MSU] = sign ? MSU_MASK : bt(~SIGN_BIT_MASK & MSU_MASK);
}
else if constexpr (3 == nrBlocks) {
_block[0] = BLOCK_MASK ^ LSB_BIT_MASK;
_block[1] = BLOCK_MASK;
_block[MSU] = sign ? MSU_MASK : bt(~SIGN_BIT_MASK & MSU_MASK);
}
else if constexpr (4 == nrBlocks) {
_block[0] = BLOCK_MASK ^ LSB_BIT_MASK;
_block[1] = BLOCK_MASK;
_block[2] = BLOCK_MASK;
_block[MSU] = sign ? MSU_MASK : bt(~SIGN_BIT_MASK & MSU_MASK);
}
else {
_block[0] = BLOCK_MASK ^ LSB_BIT_MASK;
for (size_t i = 1; i < nrBlocks - 1; ++i) {
_block[i] = BLOCK_MASK;
}
_block[MSU] = sign ? MSU_MASK : bt(~SIGN_BIT_MASK & MSU_MASK);
}
}
/// <summary>
/// set the number to a quiet NaN (+nan) or a signalling NaN (-nan, default)
/// </summary>
/// <param name="sign">boolean to make it + or - infinity, default is -inf</param>
/// <returns>void</returns>
inline constexpr void setnan(int NaNType = NAN_TYPE_SIGNALLING) noexcept {
if constexpr (0 == nrBlocks) {
return;
}
else if constexpr (1 == nrBlocks) {
// fall through
}
else if constexpr (2 == nrBlocks) {
_block[0] = BLOCK_MASK;
}
else if constexpr (3 == nrBlocks) {
_block[0] = BLOCK_MASK;
_block[1] = BLOCK_MASK;
}
else if constexpr (4 == nrBlocks) {
_block[0] = BLOCK_MASK;
_block[1] = BLOCK_MASK;
_block[2] = BLOCK_MASK;
}
else {
for (size_t i = 0; i < nrBlocks - 1; ++i) {
_block[i] = BLOCK_MASK;
}
}
_block[MSU] = NaNType == NAN_TYPE_SIGNALLING ? MSU_MASK : bt(~SIGN_BIT_MASK & MSU_MASK);
}
inline constexpr void setsign(bool sign = true) {
if (sign) {
_block[MSU] |= SIGN_BIT_MASK;
}
else {
_block[MSU] &= ~SIGN_BIT_MASK;
}
}
inline constexpr bool setexponent(int scale) {
if (scale < MIN_EXP_SUBNORMAL || scale > MAX_EXP) return false; // this scale cannot be represented
if constexpr (nbits < 65) {
// we can use a uint64_t to construct the cfloat
//uint64_t raw{ 0 };
if (scale >= MIN_EXP_SUBNORMAL && scale < MIN_EXP_NORMAL) {
// we are a subnormal number: all exponent bits are 1
// what do you do know? If you set them all to 1, you still
// don't have the right scale
return false;
}
else {
// TODO: optimize
uint32_t exponentBits = scale + EXP_BIAS;
uint32_t mask = (1ul << (es - 1));
for (size_t i = nbits - 2; i > nbits - 2 - es; --i) {
setbit(i, (mask & exponentBits));
mask >>= 1;
}
}
}
else {
// TODO: optimize
uint32_t exponentBits = scale + EXP_BIAS;
uint32_t mask = (1ul << (es - 1));
for (size_t i = nbits - 2; i > nbits - 2 - es; --i) {
setbit(i, (mask & exponentBits));
mask >>= 1;
}
}
return true;
}
/// <summary>
/// set the fraction bits given a significant in the form ???
/// </summary>
/// <param name="significant"></param>
inline constexpr void setfraction(const blockbinary<fbits, bt>& fraction) {
for (size_t i = 0; i < fbits; ++i) {
setbit(i, fraction.test(i));
}
}
inline constexpr void setfraction(uint64_t raw_bits) {
// unoptimized as it is not meant to be an end-user API, it is a test API
if constexpr (fbits < 65) {
uint64_t mask{ 1ull };
for (size_t i = 0; i < fbits; ++i) {
setbit(i, (mask & raw_bits));
mask <<= 1;
}
}
}
// specific number system values of interest
inline constexpr cfloat& maxpos() noexcept {
if constexpr (hasSupernormals) {
// maximum positive value has this bit pattern: 0-1...1-111...111, that is, sign = 0, e = 11..11, f = 111...101
clear();
flip();
setbit(nbits - 1ull, false);
setbit(1ull, false);
}
else {
// maximum positive value has this bit pattern: 0-1...0-111...111, that is, sign = 0, e = 11..10, f = 111...111
clear();
flip();
blockbinary<es, bt> scale;
exponent(scale);
--scale;
setexponent(int(scale));
setbit(nbits - 1ull, false);
}
return *this;
}
inline constexpr cfloat& minpos() noexcept {
if constexpr (hasSubnormals) {
// minimum positive value has this bit pattern: 0-000-00...01, that is, sign = 0, e = 000, f = 00001
clear();
setbit(0);
}
else {
// minimum positive value has this bit pattern: 0-001-00...0, that is, sign = 0, e = 001, f = 0000
clear();
setexponent(1);
}
return *this;
}
inline constexpr cfloat& zero() noexcept {
// the zero value
clear();
return *this;
}
inline constexpr cfloat& minneg() noexcept {
if constexpr (hasSubnormals) {
// minimum negative value has this bit pattern: 1-000-00...01, that is, sign = 1, e = 00, f = 00001
clear();
setbit(nbits - 1ull);
setbit(0);
}
else {
// minimum negative value has this bit pattern: 1-001-00...0, that is, sign = 1, e = 001, f = 0000
clear();
setexponent(1);
setbit(nbits - 1ull);
}
return *this;
}
inline constexpr cfloat& maxneg() noexcept {
if constexpr (hasSupernormals) {
// maximum negative value has this bit pattern: 1-1...1-111...101, that is, sign = 1, e = 1..1, f = 111...101
clear();
flip();
setbit(1ull, false);
}
else {
// maximum negative value has this bit pattern: 1-1...0-111...111, that is, sign = 1, e = 11..10, f = 111...111
clear();
flip();
blockbinary<es, bt> scale;
exponent(scale);
--scale;
setexponent(int(scale));
}
return *this;
}
/// <summary>
/// set a specific bit in the encoding to true or false. If bit index is out of bounds, no modification takes place.
/// </summary>
/// <param name="i">bit index to set</param>
/// <param name="v">boolean value to set the bit to. Default is true.</param>
/// <returns>void</returns>
inline constexpr void setbit(size_t i, bool v = true) noexcept {
if (i < nbits) {
bt block = _block[i / bitsInBlock];
bt null = ~(1ull << (i % bitsInBlock));
bt bit = bt(v ? 1 : 0);
bt mask = bt(bit << (i % bitsInBlock));
_block[i / bitsInBlock] = bt((block & null) | mask);
return;
}
}
/// <summary>
/// set the raw bits of the cfloat. This is a required API function for number systems in the Universal Numbers Library
/// This enables verification test suites to inject specific test bit patterns using a common interface.
// This is a memcpy type operator, but the target number system may not have a linear memory layout and
// thus needs to steer the bits in potentially more complicated ways then memcpy.
/// </summary>
/// <param name="raw_bits">unsigned long long carrying bits that will be written verbatim to the cfloat</param>
/// <returns>reference to the cfloat</returns>
inline constexpr cfloat& setbits(uint64_t raw_bits) noexcept {
if constexpr (0 == nrBlocks) {
return *this;
}
else if constexpr (1 == nrBlocks) {
_block[0] = raw_bits & storageMask;
}
else if constexpr (2 == nrBlocks) {
if constexpr (bitsInBlock < 64) {
_block[0] = raw_bits & storageMask;
raw_bits >>= bitsInBlock;
_block[1] = raw_bits & storageMask;
}
else {
_block[0] = raw_bits & storageMask;
_block[1] = 0;
}
}
else if constexpr (3 == nrBlocks) {
if constexpr (bitsInBlock < 64) {
_block[0] = raw_bits & storageMask;
raw_bits >>= bitsInBlock;
_block[1] = raw_bits & storageMask;
raw_bits >>= bitsInBlock;
_block[2] = raw_bits & storageMask;
}
else {
_block[0] = raw_bits & storageMask;
_block[1] = 0;
_block[2] = 0;
}
}
else if constexpr (4 == nrBlocks) {
if constexpr (bitsInBlock < 64) {
_block[0] = raw_bits & storageMask;
raw_bits >>= bitsInBlock;
_block[1] = raw_bits & storageMask;
raw_bits >>= bitsInBlock;
_block[2] = raw_bits & storageMask;
raw_bits >>= bitsInBlock;
_block[3] = raw_bits & storageMask;
}
else {
_block[0] = raw_bits & storageMask;
_block[1] = 0;
_block[2] = 0;
_block[3] = 0;
}
}
else {
if constexpr (bitsInBlock < 64) {
for (size_t i = 0; i < nrBlocks; ++i) {
_block[i] = raw_bits & storageMask;
raw_bits >>= bitsInBlock;
}
}
else {
_block[0] = raw_bits & storageMask;
for (size_t i = 1; i < nrBlocks; ++i) {
_block[i] = 0;
}
}
}
_block[MSU] &= MSU_MASK; // enforce precondition for fast comparison by properly nulling bits that are outside of nbits
return *this;
}
/// <summary>
/// 1's complement of the encoding
/// </summary>
/// <returns>reference to this cfloat object</returns>
inline constexpr cfloat& flip() noexcept { // in-place one's complement
for (size_t i = 0; i < nrBlocks; ++i) {
_block[i] = bt(~_block[i]);
}
_block[MSU] &= MSU_MASK; // assert precondition of properly nulled leading non-bits
return *this;
}
/// <summary>
/// assign the value of the string representation of a scientific number to the cfloat
/// </summary>
/// <param name="stringRep">decimal scientific notation of a real number to be assigned</param>
/// <returns>reference to this cfloat</returns>
inline cfloat& assign(const std::string& stringRep) {
std::cout << "assign TBD\n";
return *this;
}
// selectors
inline constexpr bool sign() const noexcept { return (_block[MSU] & SIGN_BIT_MASK) == SIGN_BIT_MASK; }
inline constexpr int scale() const noexcept {
int e{ 0 };
if constexpr (MSU_CAPTURES_E) {
e = int((_block[MSU] & ~SIGN_BIT_MASK) >> EXP_SHIFT);
if (e == 0) {
// subnormal scale is determined by fraction
// subnormals: (-1)^s * 2^(2-2^(es-1)) * (f/2^fbits))
e = (2l - (1l << (es - 1ull))) - 1;
for (size_t i = nbits - 2ull - es; i > 0; --i) {
if (test(i)) break;
--e;
}
}
else {
e -= EXP_BIAS;
}
}
else {
blockbinary<es, bt> ebits;
exponent(ebits);
if (ebits.iszero()) {
// subnormal scale is determined by fraction
// subnormals: (-1)^s * 2^(2-2^(es-1)) * (f/2^fbits))
e = (2l - (1l << (es - 1ull))) - 1;
for (size_t i = nbits - 2ull - es; i > 0; --i) {
if (test(i)) break;
--e;
}
}
else {
e = unsigned(ebits) - EXP_BIAS;
}
}
return e;
}
// tests
inline constexpr bool isneg() const noexcept { return sign(); }
inline constexpr bool ispos() const noexcept { return !sign(); }
inline constexpr bool iszero() const noexcept {
if constexpr (0 == nrBlocks) {
return true;
}
else if constexpr (1 == nrBlocks) {
return (_block[MSU] & ~SIGN_BIT_MASK) == 0;
}
else if constexpr (2 == nrBlocks) {
return (_block[0] == 0) && (_block[MSU] & ~SIGN_BIT_MASK) == 0;
}
else if constexpr (3 == nrBlocks) {
return (_block[0] == 0) && _block[1] == 0 && (_block[MSU] & ~SIGN_BIT_MASK) == 0;
}
else if constexpr (4 == nrBlocks) {
return (_block[0] == 0) && _block[1] == 0 && _block[2] == 0 && (_block[MSU] & ~SIGN_BIT_MASK) == 0;
}
else {
for (size_t i = 0; i < nrBlocks-1; ++i) if (_block[i] != 0) return false;
return (_block[MSU] & ~SIGN_BIT_MASK) == 0;
}
}
inline constexpr bool isone() const noexcept {
// unbiased exponent = scale = 0, fraction = 0
int s = scale();
if (s == 0) {
blockbinary<fbits, bt> f;
fraction(f);
return f.iszero();
}
return false;
}
/// <summary>
/// check if value is infinite, -inf, or +inf.
/// +inf = 0-1111-11111-0: sign = 0, uncertainty = 0, es/fraction bits = 1
/// -inf = 1-1111-11111-0: sign = 1, uncertainty = 0, es/fraction bits = 1
/// </summary>
/// <param name="InfType">default is 0, both types, -1 checks for -inf, 1 checks for +inf</param>
/// <returns>true if +-inf, false otherwise</returns>
inline constexpr bool isinf(int InfType = INF_TYPE_EITHER) const noexcept {
bool isNegInf = false;
bool isPosInf = false;
if constexpr (0 == nrBlocks) {
return false;
}
else if constexpr (1 == nrBlocks) {
isNegInf = (_block[MSU] & MSU_MASK) == (MSU_MASK ^ LSB_BIT_MASK);
isPosInf = (_block[MSU] & MSU_MASK) == ((MSU_MASK ^ SIGN_BIT_MASK) ^ LSB_BIT_MASK);
}
else if constexpr (2 == nrBlocks) {
bool isInf = (_block[0] == (BLOCK_MASK ^ LSB_BIT_MASK));
isNegInf = isInf && ((_block[MSU] & MSU_MASK) == MSU_MASK);
isPosInf = isInf && (_block[MSU] & MSU_MASK) == (MSU_MASK ^ SIGN_BIT_MASK);
}
else if constexpr (3 == nrBlocks) {
bool isInf = (_block[0] == (BLOCK_MASK ^ LSB_BIT_MASK)) && (_block[1] == BLOCK_MASK);
isNegInf = isInf && ((_block[MSU] & MSU_MASK) == MSU_MASK);
isPosInf = isInf && (_block[MSU] & MSU_MASK) == (MSU_MASK ^ SIGN_BIT_MASK);
}
else if constexpr (4 == nrBlocks) {
bool isInf = (_block[0] == (BLOCK_MASK ^ LSB_BIT_MASK)) && (_block[1] == BLOCK_MASK) && (_block[2] == BLOCK_MASK);
isNegInf = isInf && ((_block[MSU] & MSU_MASK) == MSU_MASK);
isPosInf = isInf && (_block[MSU] & MSU_MASK) == (MSU_MASK ^ SIGN_BIT_MASK);
}
else {
bool isInf = (_block[0] == (BLOCK_MASK ^ LSB_BIT_MASK));
for (size_t i = 1; i < nrBlocks - 1; ++i) {
if (_block[i] != BLOCK_MASK) {
isInf = false;
break;
}
}
isNegInf = isInf && ((_block[MSU] & MSU_MASK) == MSU_MASK);
isPosInf = isInf && (_block[MSU] & MSU_MASK) == (MSU_MASK ^ SIGN_BIT_MASK);
}
return (InfType == INF_TYPE_EITHER ? (isNegInf || isPosInf) :
(InfType == INF_TYPE_NEGATIVE ? isNegInf :
(InfType == INF_TYPE_POSITIVE ? isPosInf : false)));
}
/// <summary>
/// check if a value is a quiet or a signalling NaN
/// quiet NaN = 0-1111-11111-1: sign = 0, uncertainty = 1, es/fraction bits = 1
/// signalling NaN = 1-1111-11111-1: sign = 1, uncertainty = 1, es/fraction bits = 1
/// </summary>
/// <param name="NaNType">default is 0, both types, 1 checks for Signalling NaN, -1 checks for Quiet NaN</param>
/// <returns>true if the right kind of NaN, false otherwise</returns>
inline constexpr bool isnan(int NaNType = NAN_TYPE_EITHER) const noexcept {
bool isNaN = true;
if constexpr (0 == nrBlocks) {
return false;
}
else if constexpr (1 == nrBlocks) {
}
else if constexpr (2 == nrBlocks) {
isNaN = (_block[0] == BLOCK_MASK);
}
else if constexpr (3 == nrBlocks) {
isNaN = (_block[0] == BLOCK_MASK) && (_block[1] == BLOCK_MASK);
}
else if constexpr (4 == nrBlocks) {
isNaN = (_block[0] == BLOCK_MASK) && (_block[1] == BLOCK_MASK) && (_block[2] == BLOCK_MASK);
}
else {
for (size_t i = 0; i < nrBlocks - 1; ++i) {
if (_block[i] != BLOCK_MASK) {
isNaN = false;
break;
}
}
}
bool isNegNaN = isNaN && ((_block[MSU] & MSU_MASK) == MSU_MASK);
bool isPosNaN = isNaN && (_block[MSU] & MSU_MASK) == (MSU_MASK ^ SIGN_BIT_MASK);
return (NaNType == NAN_TYPE_EITHER ? (isNegNaN || isPosNaN) :
(NaNType == NAN_TYPE_SIGNALLING ? isNegNaN :
(NaNType == NAN_TYPE_QUIET ? isPosNaN : false)));
}
inline constexpr bool isnormal() const noexcept {
blockbinary<es, bt> e;
exponent(e);
return !e.iszero() && !isinf() && !isnan();
}
inline constexpr bool isdenorm() const noexcept {
blockbinary<es, bt> e;
exponent(e);
return e.iszero();
}
template<typename NativeReal>
inline constexpr bool inrange(NativeReal v) {
// the valid range for this cfloat includes the interval between
// maxpos and the value that would round down to maxpos
bool bIsInRange = true;
if (v > 0) {
cfloat c(SpecificValue::maxpos);
cfloat<nbits + 1, es, BlockType, hasSubnormals, hasSupernormals, isSaturating> d;
d = NativeReal(c);
++d;
if (v >= NativeReal(d)) bIsInRange = false;
}
else {
cfloat c(SpecificValue::maxneg);
cfloat<nbits + 1, es, BlockType, hasSubnormals, hasSupernormals, isSaturating> d;
d = NativeReal(c);
--d;
if (v <= NativeReal(d)) bIsInRange = false;
}
return bIsInRange;
}
inline constexpr bool test(size_t bitIndex) const noexcept {
return at(bitIndex);
}
inline constexpr bool at(size_t bitIndex) const noexcept {
if (bitIndex < nbits) {
bt word = _block[bitIndex / bitsInBlock];
bt mask = bt(1ull << (bitIndex % bitsInBlock));
return (word & mask);
}
return false;
}
inline constexpr uint8_t nibble(size_t n) const noexcept {
if (n < (1 + ((nbits - 1) >> 2))) {
bt word = _block[(n * 4) / bitsInBlock];
int nibbleIndexInWord = int(n % (bitsInBlock >> 2ull));
bt mask = bt(0xF << (nibbleIndexInWord * 4));
bt nibblebits = bt(mask & word);
return uint8_t(nibblebits >> (nibbleIndexInWord * 4));
}
return false;
}
inline constexpr bt block(size_t b) const noexcept {
if (b < nrBlocks) {
return _block[b];
}
return 0;
}
// helper debug function
void constexprClassParameters() const {
std::cout << "-------------------------------------------------------------\n";
std::cout << "type : " << typeid(*this).name() << '\n';
std::cout << "nbits : " << nbits << '\n';
std::cout << "es : " << es << std::endl;
std::cout << "hasSubnormals : " << (hasSubnormals ? "true" : "false") << '\n';
std::cout << "hasSupernormals : " << (hasSupernormals ? "true" : "false") << '\n';
std::cout << "isSaturating : " << (isSaturating ? "true" : "false") << '\n';
std::cout << "ALL_ONES : " << to_binary(ALL_ONES, 0, true) << '\n';
std::cout << "BLOCK_MASK : " << to_binary(BLOCK_MASK, 0, true) << '\n';
std::cout << "nrBlocks : " << nrBlocks << '\n';
std::cout << "bits in MSU : " << bitsInMSU << '\n';
std::cout << "MSU : " << MSU << '\n';
std::cout << "MSU MASK : " << to_binary(MSU_MASK, 0, true) << '\n';
std::cout << "SIGN_BIT_MASK : " << to_binary(SIGN_BIT_MASK, 0, true) << '\n';
std::cout << "LSB_BIT_MASK : " << to_binary(LSB_BIT_MASK, 0, true) << '\n';
std::cout << "MSU CAPTURES E : " << (MSU_CAPTURES_E ? "yes\n" : "no\n");
std::cout << "EXP_SHIFT : " << EXP_SHIFT << '\n';
std::cout << "MSU EXP MASK : " << to_binary(MSU_EXP_MASK, 0, true) << '\n';
std::cout << "EXP_BIAS : " << EXP_BIAS << '\n';
std::cout << "MAX_EXP : " << MAX_EXP << '\n';
std::cout << "MIN_EXP_NORMAL : " << MIN_EXP_NORMAL << '\n';
std::cout << "MIN_EXP_SUBNORMAL : " << MIN_EXP_SUBNORMAL << '\n';
std::cout << "fraction Blocks : " << fBlocks << '\n';
std::cout << "bits in FSU : " << bitsInFSU << '\n';
std::cout << "FSU : " << FSU << '\n';
std::cout << "FSU MASK : " << to_binary(FSU_MASK, 0, true) << '\n';
}
// extract the sign field from the encoding
inline constexpr void sign(bool& s) const {
s = sign();
}
// extract the exponent field from the encoding
inline constexpr void exponent(blockbinary<es, bt>& e) const {
e.clear();
if constexpr (0 == nrBlocks) return;
else if constexpr (1 == nrBlocks) {
bt ebits = bt(_block[MSU] & ~SIGN_BIT_MASK);
e.setbits(uint64_t(ebits >> EXP_SHIFT));
}
else if constexpr (nrBlocks > 1) {
if (MSU_CAPTURES_E) {
bt ebits = bt(_block[MSU] & ~SIGN_BIT_MASK);
e.setbits(uint64_t(ebits >> ((nbits - 1ull - es) % bitsInBlock)));
}
else {
for (size_t i = 0; i < es; ++i) { e.setbit(i, at(nbits - 1ull - es + i)); }
}
}
}
// extract the fraction field from the encoding
inline constexpr void fraction(blockbinary<fbits, bt>& f) const {
f.clear();
if constexpr (0 == nrBlocks) return;
else if constexpr (1 == nrBlocks) {
bt fraction = bt(_block[MSU] & ~MSU_EXP_MASK);
f.setbits(fraction);
}
else if constexpr (nrBlocks > 1) {
for (size_t i = 0; i < fbits; ++i) { f.setbit(i, at(i)); } // TODO: TEST!
}
}
inline constexpr uint64_t fraction_ull() const {
uint64_t raw{ 0 };
if constexpr (nbits - es - 1ull < 65ull) { // no-op if precondition doesn't hold
if constexpr (1 == nrBlocks) {
uint64_t fbitMask = 0xFFFF'FFFF'FFFF'FFFF >> (64 - fbits);
raw = fbitMask & uint64_t(_block[0]);
}
else if constexpr (2 == nrBlocks) {
uint64_t fbitMask = 0xFFFF'FFFF'FFFF'FFFF >> (64 - fbits);
raw = fbitMask & ((uint64_t(_block[1]) << bitsInBlock) | uint64_t(_block[0]));
}
else if constexpr (3 == nrBlocks) {
uint64_t fbitMask = 0xFFFF'FFFF'FFFF'FFFF >> (64 - fbits);
raw = fbitMask & ((uint64_t(_block[2]) << (2*bitsInBlock)) | (uint64_t(_block[1]) << bitsInBlock) | uint64_t(_block[0]));
}
else if constexpr (4 == nrBlocks) {
uint64_t fbitMask = 0xFFFF'FFFF'FFFF'FFFF >> (64 - fbits);
raw = fbitMask & ((uint64_t(_block[3]) << (3 * bitsInBlock)) | (uint64_t(_block[2]) << (2 * bitsInBlock)) | (uint64_t(_block[1]) << bitsInBlock) | uint64_t(_block[0]));
}
else {
uint64_t mask{ 1 };
for (size_t i = 0; i < fbits; ++i) {
if (test(i)) {
raw |= mask;
}
mask <<= 1;
}
}
}
return raw;
}
// construct the significant from the encoding, returns normalization offset
inline constexpr size_t significant(blockbinary<fhbits, bt>& s, bool isNormal = true) const {
size_t shift = 0;
if (iszero()) return 0;
if constexpr (0 == nrBlocks) return 0;
else if constexpr (1 == nrBlocks) {
bt significant = bt(_block[MSU] & ~MSU_EXP_MASK & ~SIGN_BIT_MASK);
if (isNormal) {
significant |= (bt(0x1ul) << fbits);
}
else {
size_t msb = findMostSignificantBit(significant);
// std::cout << "msb : " << msb << " : fhbits : " << fhbits << " : " << to_binary(significant, true) << std::endl;
shift = fhbits - msb;
significant <<= shift;
}
s.setbits(significant);
}
else if constexpr (nrBlocks > 1) {
s.clear();
// TODO: design and implement a block-oriented algorithm, this sequential algorithm is super slow
if (isNormal) {
s.setbit(fbits);
for (size_t i = 0; i < fbits; ++i) { s.setbit(i, at(i)); }
}
else {
// Find the MSB of the subnormal:
size_t msb = 0;
for (size_t i = 0; i < fbits; ++i) { // msb protected from not being assigned through iszero test at prelude of function
msb = fbits - 1ull - i;
if (test(msb)) break;
}
// m-----lsb
// h00001010101
// 101010100000
for (size_t i = 0; i <= msb; ++i) {
s.setbit(fbits - msb + i, at(i));
}
shift = fhbits - msb;
}
}
return shift;
}
// get the raw bits from the encoding
inline constexpr void getbits(blockbinary<nbits, bt>& b) const {
b.clear();
for (size_t i = 0; i < nbits; ++i) { b.setbit(i, at(i)); }
}
// casts to native types
long to_long() const { return long(to_native<double>()); }
long long to_long_long() const { return (long long)(to_native<double>()); }
// transform an cfloat to a native C++ floating-point. We are using the native
// precision to compute, which means that all sub-values need to be representable
// by the native precision.
// A more accurate appromation would require an adaptive precision algorithm
// with a final rounding step.
template<typename TargetFloat>
TargetFloat to_native() const {
TargetFloat v{ 0 };
if (iszero()) {
if (sign()) { // the optimizer might destroy the sign
return -TargetFloat(0);
}
else {
return TargetFloat(0);
}
}
else if (isnan()) {
v = sign() ? std::numeric_limits<TargetFloat>::signaling_NaN() : std::numeric_limits<TargetFloat>::quiet_NaN();
}
else if (isinf()) {
v = sign() ? -INFINITY : INFINITY;
}
else { // TODO: this approach has catastrophic cancellation when nbits is large and native target float is small
TargetFloat f{ 0 };
TargetFloat fbit{ 0.5 };
for (int i = static_cast<int>(nbits - 2ull - es); i >= 0; --i) {
f += at(static_cast<size_t>(i)) ? fbit : TargetFloat(0);
fbit *= TargetFloat(0.5);
}
blockbinary<es, bt> ebits;
exponent(ebits);
if (ebits.iszero()) {
// subnormals: (-1)^s * 2^(2-2^(es-1)) * (f/2^fbits))
TargetFloat exponentiation = TargetFloat(subnormal_exponent[es]); // precomputed values for 2^(2-2^(es-1))
v = exponentiation * f;
}
else {
// regular: (-1)^s * 2^(e+1-2^(es-1)) * (1 + f/2^fbits))
int exponent = static_cast<int>(unsigned(ebits) - EXP_BIAS);
if (-64 < exponent && exponent < 64) {
TargetFloat exponentiation = (exponent >= 0 ? TargetFloat(1ull << exponent) : (1.0f / TargetFloat(1ull << -exponent)));
v = exponentiation * (TargetFloat(1.0) + f);
}
else {
double exponentiation = ipow(exponent);
v = TargetFloat(exponentiation * (1.0 + f));
}
}
v = sign() ? -v : v;
}
return v;
}
// make conversions to native types explicit
explicit operator int() const { return to_long_long(); }
explicit operator long long() const { return to_long_long(); }
explicit operator long double() const { return to_native<long double>(); }
explicit operator double() const { return to_native<double>(); }
explicit operator float() const { return to_native<float>(); }
#ifdef NEVER
// normalize a non-special cfloat, that is, not a zero, inf, or nan, into a blocktriple
template<size_t tgtSize>
void generate_add_input(blocktriple<tgtSize, bt>& v) const {
bool _sign = sign();
int _scale = scale();
// fraction bits are the bottom fbits in the raw encoding
// normal encoding : 1.fffff
// subnormal encoding : 0.fffff
}
#endif
// convert a cfloat to a blocktriple with the fraction format 01.ffffeeee
// we are using the same block type so that we can use block copies to move bits around.
// Since we tend to have at least two exponent bits, this will lead to
// most cfloat<->blocktriple cases being efficient as the block types are aligned.
// The relationship between the source cfloat and target blocktriple is not
// arbitrary, enforce it: blocktriple fbits = cfloat (nbits - es - 1)
constexpr void normalize(blocktriple<fbits, bt>& tgt) const {
// test special cases
if (isnan()) {
tgt.setnan();
}
else if (isinf()) {
tgt.setinf();
}
else if (iszero()) {
tgt.setzero();
}
else {
tgt.setnormal(); // a blocktriple is always normalized
int scale = this->scale();
tgt.setsign(sign());
tgt.setscale(scale);
// set significant
// we are going to unify to the format 01.ffffeeee
// where 'f' is a fraction bit, and 'e' is an extension bit
// so that normalize can be used to generate blocktriples for add/sub/mul/div/sqrt
if (isnormal()) {
if constexpr (fbits < 64) { // max 63 bits of fraction to yield 64bit of raw significant bits
uint64_t raw = fraction_ull();
raw |= (1ull << fbits);
tgt.setbits(raw);
}
else {
// brute force copy of blocks
if constexpr (1 == fBlocks) {
tgt.setblock(0, _block[0] & FSU_MASK);
}
else if constexpr (2 == fBlocks) {
tgt.setblock(0, _block[0]);
tgt.setblock(1, _block[1] & FSU_MASK);
}
else if constexpr (3 == fBlocks) {
tgt.setblock(0, _block[0]);
tgt.setblock(1, _block[1]);
tgt.setblock(2, _block[2] & FSU_MASK);
}
else if constexpr (4 == fBlocks) {
tgt.setblock(0, _block[0]);
tgt.setblock(1, _block[1]);
tgt.setblock(2, _block[2]);
tgt.setblock(3, _block[3] & FSU_MASK);
}
else {
for (size_t i = 0; i < FSU; ++i) {
tgt.setblock(i, _block[i]);
}
tgt.setblock(FSU, _block[FSU] & FSU_MASK);
}
}
}
else { // it is a subnormal encoding in this target cfloat
if constexpr (fbits < 64) {
uint64_t raw = fraction_ull();
int shift = MIN_EXP_NORMAL - scale;
raw <<= shift;
raw |= (1ull << fbits);
tgt.setbits(raw);
}
else {
// brute force copy of blocks
if constexpr (1 == fBlocks) {
tgt.setblock(0, _block[0] & FSU_MASK);
}
else if constexpr (2 == fBlocks) {
tgt.setblock(0, _block[0]);
tgt.setblock(1, _block[1] & FSU_MASK);
}
else if constexpr (3 == fBlocks) {
tgt.setblock(0, _block[0]);
tgt.setblock(1, _block[1]);
tgt.setblock(2, _block[2] & FSU_MASK);
}
else if constexpr (4 == fBlocks) {
tgt.setblock(0, _block[0]);
tgt.setblock(1, _block[1]);
tgt.setblock(2, _block[2]);
tgt.setblock(3, _block[3] & FSU_MASK);
}
else {
for (size_t i = 0; i < FSU; ++i) {
tgt.setblock(i, _block[i]);
}
tgt.setblock(FSU, _block[FSU] & FSU_MASK);
}
}
}
}
}
// normalize a cfloat to a blocktriple used in add/sub
constexpr void normalizeAddition(blocktriple<abits, bt>& tgt) const {
// test special cases
if (isnan()) {
tgt.setnan();
}
else if (isinf()) {
tgt.setinf();
}
else if (iszero()) {
tgt.setzero();
}
else {
tgt.setnormal(); // a blocktriple is always normalized
int scale = this->scale();
tgt.setsign(sign());
tgt.setscale(scale);
// set significant
// we are going to unify to the format 001.ffffeeee
// where 'f' is a fraction bit, and 'e' is an extension bit
// so that normalize can be used to generate blocktriples for add/sub/mul/div/sqrt
if (isnormal()) {
if constexpr (abits < 64) { // max 63 bits of fraction to yield 64bit of raw significant bits
uint64_t raw = fraction_ull();
raw <<= (abits - fbits);
raw |= (1ull << abits); // add the hidden bit
tgt.setbits(raw);
}
else {
// brute force copy of blocks
if constexpr (1 == fBlocks) {
tgt.setblock(0, _block[0] & FSU_MASK);
}
else if constexpr (2 == fBlocks) {
tgt.setblock(0, _block[0]);
tgt.setblock(1, _block[1] & FSU_MASK);
}
else if constexpr (3 == fBlocks) {
tgt.setblock(0, _block[0]);
tgt.setblock(1, _block[1]);
tgt.setblock(2, _block[2] & FSU_MASK);
}
else if constexpr (4 == fBlocks) {
tgt.setblock(0, _block[0]);
tgt.setblock(1, _block[1]);
tgt.setblock(2, _block[2]);
tgt.setblock(3, _block[3] & FSU_MASK);
}
else {
for (size_t i = 0; i < FSU; ++i) {
tgt.setblock(i, _block[i]);
}
tgt.setblock(FSU, _block[FSU] & FSU_MASK);
}
}
}
else { // it is a subnormal encoding in this target cfloat
if constexpr (abits < 64) {
uint64_t raw = fraction_ull();
raw <<= (abits - fbits);
int shift = MIN_EXP_NORMAL - scale;
raw <<= shift; // shift and do NOT add a hidden bit as MSB of subnormal is shifted in the hidden bit position
tgt.setbits(raw);
}
else {
// brute force copy of blocks
if constexpr (1 == fBlocks) {
tgt.setblock(0, _block[0] & FSU_MASK);
}
else if constexpr (2 == fBlocks) {
tgt.setblock(0, _block[0]);
tgt.setblock(1, _block[1] & FSU_MASK);
}
else if constexpr (3 == fBlocks) {
tgt.setblock(0, _block[0]);
tgt.setblock(1, _block[1]);
tgt.setblock(2, _block[2] & FSU_MASK);
}
else if constexpr (4 == fBlocks) {
tgt.setblock(0, _block[0]);
tgt.setblock(1, _block[1]);
tgt.setblock(2, _block[2]);
tgt.setblock(3, _block[3] & FSU_MASK);
}
else {
for (size_t i = 0; i < FSU; ++i) {
tgt.setblock(i, _block[i]);
}
tgt.setblock(FSU, _block[FSU] & FSU_MASK);
}
}
}
}
}
protected:
// HELPER methods
template<typename Ty>
constexpr cfloat& convert_unsigned_integer(const Ty& rhs) noexcept {
clear();
if (0 == rhs) return *this;
uint64_t raw = static_cast<uint64_t>(rhs);
int exponent = int(findMostSignificantBit(raw)) - 1; // precondition that msb > 0 is satisfied by the zero test above
constexpr uint32_t sizeInBits = 8 * sizeof(Ty);
uint32_t shift = sizeInBits - exponent - 1;
raw <<= shift;
raw = round<sizeInBits, uint64_t>(raw, exponent);
return *this;
}
template<typename Ty>
constexpr cfloat& convert_signed_integer(const Ty& rhs) noexcept {
clear();
if (0 == rhs) return *this;
bool s = (rhs < 0);
uint64_t raw = static_cast<uint64_t>(s ? -rhs : rhs);
int exponent = int(findMostSignificantBit(raw)) - 1; // precondition that msb > 0 is satisfied by the zero test above
constexpr uint32_t sizeInBits = 8 * sizeof(Ty);
uint32_t shift = sizeInBits - exponent - 1;
raw <<= shift;
raw = round<sizeInBits, uint64_t>(raw, exponent);
#ifdef TODO
// construct the target cfloat
if constexpr (64 >= nbits - es - 1ull) {
uint64_t bits = (s ? 1u : 0u);
bits <<= es;
bits |= exponent + EXP_BIAS;
bits <<= nbits - 1ull - es;
bits |= raw;
bits &= 0xFFFF'FFFF;
if constexpr (1 == nrBlocks) {
_block[MSU] = bt(bits);
}
else {
copyBits(bits);
}
}
else {
std::cerr << "TBD\n";
}
#endif
return *this;
}
public:
template<typename Real>
CONSTEXPRESSION cfloat& convert_ieee754(Real rhs) noexcept {
// when we are a perfect match to single precision IEEE-754
// take the bits verbatim as a cfloat is a superset of IEEE-754 in all configurations
if constexpr (nbits == 32 && es == 8) {
bool s{ false };
uint64_t rawExponent{ 0 };
uint64_t rawFraction{ 0 };
// use native conversion
extractFields(float(rhs), s, rawExponent, rawFraction);
uint64_t raw{ s ? 1ull : 0ull };
raw <<= 31;
raw |= (rawExponent << fbits);
raw |= rawFraction;
setbits(raw);
return *this;
}
// when we are a perfect match to double precision IEEE-754
else if constexpr (nbits == 64 && es == 11) {
bool s{ false };
uint64_t rawExponent{ 0 };
uint64_t rawFraction{ 0 };
// use native conversion
extractFields(double(rhs), s, rawExponent, rawFraction);
uint64_t raw{ s ? 1ull : 0ull };
raw <<= 63;
raw |= (rawExponent << fbits);
raw |= rawFraction;
setbits(raw);
return *this;
}
else {
clear();
// extract raw IEEE-754 bits
bool s{ false };
uint64_t rawExponent{ 0 };
uint64_t rawFraction{ 0 };
extractFields(rhs, s, rawExponent, rawFraction);
// special case handling
if (rawExponent == ieee754_parameter<Real>::eallset) { // nan and inf
if (rawFraction == (ieee754_parameter<Real>::fmask & ieee754_parameter<Real>::snanmask) ||
rawFraction == (ieee754_parameter<Real>::fmask & (ieee754_parameter<Real>::qnanmask | ieee754_parameter<Real>::snanmask))) {
// 1.11111111.00000000.......00000001 signalling nan
// 0.11111111.00000000000000000000001 signalling nan
// MSVC
// 1.11111111.10000000.......00000001 signalling nan
// 0.11111111.10000000.......00000001 signalling nan
setnan(NAN_TYPE_SIGNALLING);
return *this;
}
if (rawFraction == (ieee754_parameter<Real>::fmask & ieee754_parameter<Real>::qnanmask)) {
// 1.11111111.10000000.......00000000 quiet nan
// 0.11111111.10000000.......00000000 quiet nan
setnan(NAN_TYPE_QUIET);
return *this;
}
if (rawFraction == 0ull) {
// 1.11111111.0000000.......000000000 -inf
// 0.11111111.0000000.......000000000 +inf
setinf(s);
return *this;
}
}
if (rhs == 0.0) { // IEEE rule: this is valid for + and - 0.0
setbit(nbits - 1ull, s);
return *this;
}
// normal number consists of fbits fraction bits and one hidden bit
// subnormal number has no hidden bit
int exponent = static_cast<int>(rawExponent) - ieee754_parameter<Real>::bias; // unbias the exponent
// check special case of
// 1- saturating to maxpos/maxneg, or
// 2- projecting to +-inf
// if the value is out of range.
//
// One problem here is that at the rounding cusps of maxpos <-> inf <-> nan
// you need to go through the rounding logic to know which encoding you end up
// with.
// For each specific cfloat configuration, you can work out these rounding cusps
// but they need to go through the value transformation to map them back to native
// IEEE-754. That is a complex computation to do as a static constexpr as you need
// to construct the value, then evaluate it, and store it.
//
// The algorithm used here is to check for the obvious out of range values by
// comparing their scale to the max scale this cfloat encoding can represent.
// For the rounding cusps, we go through the rounding logic, and then clean up
// after rounding using the observation that no conversion from a value can ever
// yield the NaN encoding.
// The rounding logic will correctly sort between maxpos and inf, and we clean
// up any NaN encodings by projecting back to the configuration's saturation rule.
//
// We could improve on this by creating the database of rounding cusps and
// referencing them with a direct value comparison with the input. That would be
// the most performant implementation.
if (exponent > MAX_EXP) {
if constexpr (isSaturating) {
if (s) this->maxneg(); else this->maxpos(); // saturate to maxpos or maxneg
}
else {
setinf(s);
}
return *this;
}
if (exponent < MIN_EXP_SUBNORMAL - 1) { // TODO: explain the MIN_EXP_SUBMORNAL - 1
this->setbit(nbits - 1, s);
return *this;
}
/////////////////
/// end of special case processing, move on to value projection and rounding
#if TRACE_CONVERSION
std::cout << '\n';
std::cout << "value : " << rhs << '\n';
std::cout << "segments : " << to_binary(rhs) << '\n';
std::cout << "sign bit : " << (s ? '1' : '0') << '\n';
std::cout << "exponent bits : " << to_binary(rawExponent, ieee754_parameter<Real>::ebits, true) << '\n';
std::cout << "fraction bits : " << to_binary(rawFraction, ieee754_parameter<Real>::fbits, true) << std::endl;
std::cout << "exponent value : " << exponent << '\n';
#endif
// do the following scenarios have different rounding bits?
// input is normal, cfloat is normal <-- rounding can happen with native ieee-754 bits
// input is normal, cfloat is subnormal
// input is subnormal, cfloat is normal
// input is subnormal, cfloat is subnormal
// The first condition is the relationship between the number
// of fraction bits from the source and the number of fraction bits
// in the target cfloat: these are constexpressions and guard the shifts
// input fbits >= cfloat fbits <-- need to round
// input fbits < cfloat fbits <-- no need to round
if constexpr (ieee754_parameter<Real>::fbits > fbits) {
// this is the common case for cfloats that are smaller than single and double precision IEEE-754
constexpr int shiftRight = ieee754_parameter<Real>::fbits - fbits; // this is the bit shift to get the MSB of the src to the MSB of the tgt
uint32_t biasedExponent{ 0 };
int adjustment{ 0 };
uint64_t mask;
if (rawExponent != 0) {
// the source real is a normal number,
if (exponent >= (MIN_EXP_SUBNORMAL - 1) && exponent < MIN_EXP_NORMAL) {
// the value is a subnormal number in this representation: biasedExponent = 0
// add the hidden bit to the fraction bits so the denormalization has the correct MSB
rawFraction |= ieee754_parameter<Real>::hmask;
// fraction processing: we have 1 hidden + 23 explicit fraction bits
// f = 1.ffff 2^exponent * 2^fbits * 2^-(2-2^(es-1)) = 1.ff...ff >> (23 - (-exponent + fbits - (2 -2^(es-1))))
// -exponent because we are right shifting and exponent in this range is negative
adjustment = -(exponent + subnormal_reciprocal_shift[es]);
// this is the right shift adjustment required for subnormal representation due
// to the scale of the input number, i.e. the exponent of 2^-adjustment
}
else {
// the value is a normal number in this representation: common case
biasedExponent = static_cast<uint32_t>(exponent + EXP_BIAS); // project the exponent into the target
// fraction processing
// float structure is: seee'eeee'efff'ffff'ffff'ffff'ffff'ffff, s = sign, e - exponent bit, f = fraction bit
// target structure is for example cfloat<8,2>: seef'ffff
// since both are normals, we can shift the incoming fraction to the target structure bits, and round
// MSB of source = 23 - 1, MSB of target = fbits - 1: shift = MSB of src - MSB of tgt => 23 - fbits
adjustment = 0;
}
if constexpr (shiftRight > 0) { // if true we need to round
// round-to-even logic
// ... lsb | guard round sticky round
// x 0 x x down
// 0 1 0 0 down round to even
// 1 1 0 0 up round to even
// x 1 0 1 up
// x 1 1 0 up
// x 1 1 1 up
// collect lsb, guard, round, and sticky bits
mask = (1ull << (shiftRight + adjustment)); // bit mask for the lsb bit
bool lsb = (mask & rawFraction);
mask >>= 1;
bool guard = (mask & rawFraction);
mask >>= 1;
bool round = (mask & rawFraction);
if constexpr (shiftRight > 1) {
mask = (0xFFFF'FFFF'FFFF'FFFFull << (shiftRight - 2));
mask = ~mask;
}
else {
mask = 0;
}
bool sticky = (mask & rawFraction);
rawFraction >>= (static_cast<int64_t>(shiftRight) + static_cast<int64_t>(adjustment));
// execute rounding operation
if (guard) {
if (lsb && (!round && !sticky)) ++rawFraction; // round to even
if (round || sticky) ++rawFraction;
if (rawFraction == (1ul << fbits)) { // overflow
if (biasedExponent == ALL_ONES_ES) { // overflow to INF == .111..01
rawFraction = INF_ENCODING;
}
else {
++biasedExponent;
rawFraction = 0;
}
}
}
#if TRACE_CONVERSION
std::cout << "lsb : " << (lsb ? "1\n" : "0\n");
std::cout << "guard : " << (guard ? "1\n" : "0\n");
std::cout << "round : " << (round ? "1\n" : "0\n");
std::cout << "sticky : " << (sticky ? "1\n" : "0\n");
std::cout << "rounding decision : " << (lsb && (!round && !sticky) ? "round to even\n" : "-\n");
std::cout << "rounding direction: " << (round || sticky ? "round up\n" : "round down\n");
#endif
}
else { // all bits of the float go into this representation and need to be shifted up
int shiftLeft = fbits - ieee754_parameter<Real>::fbits;
rawFraction <<= shiftLeft;
}
#if TRACE_CONVERSION
std::cout << "biased exponent : " << biasedExponent << " : 0x" << std::hex << biasedExponent << std::dec << '\n';
std::cout << "shift : " << shiftRight << '\n';
std::cout << "adjustment shift : " << adjustment << '\n';
std::cout << "sticky bit mask : " << to_binary(mask, 32, true) << '\n';
std::cout << "fraction bits : " << to_binary(rawFraction, 32, true) << '\n';
#endif
// construct the target cfloat
uint64_t bits = (s ? 1ull : 0ull);
bits <<= es;
bits |= biasedExponent;
bits <<= fbits;
bits |= rawFraction;
setbits(bits);
}
else {
// the source real is a subnormal number
mask = 0x00FF'FFFFu >> (fbits + exponent + subnormal_reciprocal_shift[es] + 1); // mask for sticky bit
// fraction processing: we have fbits+1 bits = 1 hidden + fbits explicit fraction bits
// f = 1.ffff 2^exponent * 2^fbits * 2^-(2-2^(es-1)) = 1.ff...ff >> (23 - (-exponent + fbits - (2 -2^(es-1))))
// -exponent because we are right shifting and exponent in this range is negative
adjustment = -(exponent + subnormal_reciprocal_shift[es]); // this is the right shift adjustment due to the scale of the input number, i.e. the exponent of 2^-adjustment
if (exponent >= (MIN_EXP_SUBNORMAL - 1) && exponent < MIN_EXP_NORMAL) {
// the value is a subnormal number in this representation
}
else {
// the value is a normal number in this representation
}
}
}
else {
// no need to round, but we need to shift left to deliver the bits
// cfloat<40, 8> = float
// cfloat<48, 9> = float
// cfloat<56, 10> = float
// cfloat<64, 11> = float
// cfloat<64, 10> = double
// can we go from an input subnormal to a cfloat normal?
// yes, for example a cfloat<64,11> assigned to a subnormal float
// map exponent into target cfloat encoding
uint64_t biasedExponent = static_cast<uint64_t>(static_cast<int64_t>(exponent) + EXP_BIAS);
constexpr int upshift = fbits - ieee754_parameter<Real>::fbits;
// output processing
if constexpr (nbits < 65) {
// we can compose the bits in a native 64-bit unsigned integer
// common case: normal to normal
// nbits = 40, es = 8, fbits = 31: rhs = float fbits = 23; shift left by (31 - 23) = 8
if (rawExponent != 0) {
// rhs is a normal encoding
uint64_t bits{ s ? 1ull : 0ull };
bits <<= es;
bits |= biasedExponent;
bits <<= fbits;
rawFraction <<= upshift;
bits |= rawFraction;
setbits(bits);
}
else {
// rhs is a subnormal
// std::cerr << "rhs is a subnormal : " << to_binary(rhs) << " : " << rhs << '\n';
// we need to calculate the effective scale to see
// if this value becomes a normal, or maps to a subnormal encoding
// in this target format
}
}
else {
// we need to write and shift bits into place
// use cases are cfloats like cfloat<80, 11, bt>
// even though the bits that come in are single or double precision
// we need to write the fields and then shifting them in place
//
// common case: normal to normal
if (rawExponent != 0) {
// nbits = 128, es = 15, fbits = 112: rhs = float: shift left by (112 - 23) = 89
setbits(biasedExponent);
shiftLeft(fbits);
bt fractionBlock[nrBlocks]{ 0 };
// copy fraction bits
size_t blocksRequired = (8 * sizeof(rawFraction) + 1) / bitsInBlock;
size_t maxBlockNr = (blocksRequired < nrBlocks ? blocksRequired : nrBlocks);
uint64_t mask = static_cast<uint64_t>(ALL_ONES); // set up the block mask
size_t shift = 0;
for (size_t i = 0; i < maxBlockNr; ++i) {
fractionBlock[i] = bt((mask & rawFraction) >> shift);
mask <<= bitsInBlock;
shift += bitsInBlock;
}
// shift fraction bits
int bitsToShift = upshift;
if (bitsToShift >= static_cast<int>(bitsInBlock)) {
int blockShift = static_cast<int>(bitsToShift / bitsInBlock);
for (int i = MSU; i >= blockShift; --i) {
fractionBlock[i] = fractionBlock[i - blockShift];
}
for (int i = blockShift - 1; i >= 0; --i) {
fractionBlock[i] = bt(0);
}
// adjust the shift
bitsToShift -= blockShift * bitsInBlock;
}
if (bitsToShift > 0) {
// construct the mask for the upper bits in the block that need to move to the higher word
bt bitsToMoveMask = bt(ALL_ONES << (bitsInBlock - bitsToShift));
for (size_t i = MSU; i > 0; --i) {
fractionBlock[i] <<= bitsToShift;
// mix in the bits from the right
bt bits = (bitsToMoveMask & fractionBlock[i - 1]);
fractionBlock[i] |= (bits >> (bitsInBlock - bitsToShift));
}
fractionBlock[0] <<= bitsToShift;
}
// OR the bits in
for (size_t i = 0; i < MSU; ++i) {
_block[i] |= fractionBlock[i];
}
// enforce precondition for fast comparison by properly nulling bits that are outside of nbits
_block[MSU] &= MSU_MASK;
// finally, set the sign bit
setsign(s);
}
else { // rhs is a subnormal
// std::cerr << "rhs is a subnormal : " << to_binary(rhs) << " : " << rhs << '\n';
}
}
}
}
// post-processing results to implement saturation and projection after rounding logic
if constexpr (isSaturating) {
if (isinf(INF_TYPE_POSITIVE) || isnan(NAN_TYPE_QUIET)) {
maxpos();
}
else if (isinf(INF_TYPE_NEGATIVE) || isnan(NAN_TYPE_SIGNALLING)) {
maxneg();
}
}
else {
if (isnan(NAN_TYPE_QUIET)) {
setinf(false);
}
else if (isnan(NAN_TYPE_SIGNALLING)) {
setinf(true);
}
}
return *this; // TODO: unreachable in some configurations
}
// post-processing results to implement saturation and projection after rounding logic
// arithmetic bit operations can't produce NaN encodings, so we need to re-interpret
// these encodings and 'project' them to the proper values.
void constexpr post_process() noexcept {
if constexpr (isSaturating) {
if (isinf(INF_TYPE_POSITIVE) || isnan(NAN_TYPE_QUIET)) {
maxpos();
}
else if (isinf(INF_TYPE_NEGATIVE) || isnan(NAN_TYPE_SIGNALLING)) {
maxneg();
}
}
else {
if (isnan(NAN_TYPE_QUIET)) {
setinf(false);
}
else if (isnan(NAN_TYPE_SIGNALLING)) {
setinf(true);
}
}
}
protected:
/// <summary>
/// round a set of source bits to the present representation.
/// srcbits is the number of bits of significant in the source representation
/// </summary>
/// <typeparam name="StorageType"></typeparam>
/// <param name="raw"></param>
/// <returns></returns>
template<size_t srcbits, typename StorageType>
constexpr uint64_t round(StorageType raw, int& exponent) noexcept {
if constexpr (fhbits < srcbits) {
// round to even: lsb guard round sticky
// collect guard, round, and sticky bits
// this same logic will work for the case where
// we only have a guard bit and no round and sticky bits
// because the mask logic will make round and sticky both 0
constexpr uint32_t shift = srcbits - fhbits - 1ull;
StorageType mask = (StorageType(1ull) << shift);
bool guard = (mask & raw);
mask >>= 1;
bool round = (mask & raw);
if constexpr (shift > 1u) { // protect against a negative shift
StorageType allones(StorageType(~0));
mask = StorageType(allones << (shift - 2));
mask = ~mask;
}
else {
mask = 0;
}
bool sticky = (mask & raw);
raw >>= (shift + 1); // shift out the bits we are rounding away
bool lsb = (raw & 0x1u);
// ... lsb | guard round sticky round
// x 0 x x down
// 0 1 0 0 down round to even
// 1 1 0 0 up round to even
// x 1 0 1 up
// x 1 1 0 up
// x 1 1 1 up
if (guard) {
if (lsb && (!round && !sticky)) ++raw; // round to even
if (round || sticky) ++raw;
if (raw == (1ull << nbits)) { // overflow
++exponent;
raw >>= 1u;
}
}
}
else {
constexpr size_t shift = fhbits - srcbits;
if constexpr (shift < (sizeof(StorageType))) {
raw <<= shift;
}
else {
std::cerr << "round: shift " << shift << " >= " << sizeof(StorageType) << std::endl;
raw = 0;
}
}
uint64_t significant = raw;
return significant;
}
template<typename ArgumentBlockType>
constexpr void copyBits(ArgumentBlockType v) {
size_t blocksRequired = (8 * sizeof(v) + 1 ) / bitsInBlock;
size_t maxBlockNr = (blocksRequired < nrBlocks ? blocksRequired : nrBlocks);
bt b{ 0ul }; b = bt(~b);
ArgumentBlockType mask = ArgumentBlockType(b);
size_t shift = 0;
for (size_t i = 0; i < maxBlockNr; ++i) {
_block[i] = bt((mask & v) >> shift);
mask <<= bitsInBlock;
shift += bitsInBlock;
}
}
void shiftLeft(int bitsToShift) {
if (bitsToShift == 0) return;
if (bitsToShift < 0) return shiftRight(-bitsToShift);
if (bitsToShift > long(nbits)) bitsToShift = nbits; // clip to max
if (bitsToShift >= long(bitsInBlock)) {
int blockShift = bitsToShift / bitsInBlock;
for (signed i = signed(MSU); i >= blockShift; --i) {
_block[i] = _block[i - blockShift];
}
for (signed i = blockShift - 1; i >= 0; --i) {
_block[i] = bt(0);
}
// adjust the shift
bitsToShift -= (long)(blockShift * bitsInBlock);
if (bitsToShift == 0) return;
}
// construct the mask for the upper bits in the block that need to move to the higher word
bt mask = 0xFFFFFFFFFFFFFFFF << (bitsInBlock - bitsToShift);
for (unsigned i = MSU; i > 0; --i) {
_block[i] <<= bitsToShift;
// mix in the bits from the right
bt bits = (mask & _block[i - 1]);
_block[i] |= (bits >> (bitsInBlock - bitsToShift));
}
_block[0] <<= bitsToShift;
}
void shiftRight(int bitsToShift) {
if (bitsToShift == 0) return;
if (bitsToShift < 0) return shiftLeft(-bitsToShift);
if (bitsToShift >= long(nbits)) {
setzero();
return;
}
bool signext = sign();
size_t blockShift = 0;
if (bitsToShift >= long(bitsInBlock)) {
blockShift = bitsToShift / bitsInBlock;
if (MSU >= blockShift) {
// shift by blocks
for (size_t i = 0; i <= MSU - blockShift; ++i) {
_block[i] = _block[i + blockShift];
}
}
// adjust the shift
bitsToShift -= (long)(blockShift * bitsInBlock);
if (bitsToShift == 0) {
// fix up the leading zeros if we have a negative number
if (signext) {
// bitsToShift is guaranteed to be less than nbits
bitsToShift += (long)(blockShift * bitsInBlock);
for (size_t i = nbits - bitsToShift; i < nbits; ++i) {
this->setbit(i);
}
}
else {
// clean up the blocks we have shifted clean
bitsToShift += (long)(blockShift * bitsInBlock);
for (size_t i = nbits - bitsToShift; i < nbits; ++i) {
this->setbit(i, false);
}
}
}
}
//bt mask = 0xFFFFFFFFFFFFFFFFull >> (64 - bitsInBlock); // is that shift necessary?
bt mask = bt(0xFFFFFFFFFFFFFFFFull);
mask >>= (bitsInBlock - bitsToShift); // this is a mask for the lower bits in the block that need to move to the lower word
for (unsigned i = 0; i < MSU; ++i) { // TODO: can this be improved? we should not have to work on the upper blocks in case we block shifted
_block[i] >>= bitsToShift;
// mix in the bits from the left
bt bits = (mask & _block[i + 1]);
_block[i] |= (bits << (bitsInBlock - bitsToShift));
}
_block[MSU] >>= bitsToShift;
// fix up the leading zeros if we have a negative number
if (signext) {
// bitsToShift is guaranteed to be less than nbits
bitsToShift += (long)(blockShift * bitsInBlock);
for (size_t i = nbits - bitsToShift; i < nbits; ++i) {
this->setbit(i);
}
}
else {
// clean up the blocks we have shifted clean
bitsToShift += (long)(blockShift * bitsInBlock);
for (size_t i = nbits - bitsToShift; i < nbits; ++i) {
this->setbit(i, false);
}
}
// enforce precondition for fast comparison by properly nulling bits that are outside of nbits
_block[MSU] &= MSU_MASK;
}
// calculate the integer power 2 ^ b using exponentiation by squaring
double ipow(int exponent) const {
bool negative = (exponent < 0);
exponent = negative ? -exponent : exponent;
double result(1.0);
double base = 2.0;
for (;;) {
if (exponent % 2) result *= base;
exponent >>= 1;
if (exponent == 0) break;
base *= base;
}
return (negative ? (1.0 / result) : result);
}
private:
bt _block[nrBlocks];
//////////////////////////////////////////////////////////////////////////////
// friend functions
// template parameters need names different from class template parameters (for gcc and clang)
template<size_t nnbits, size_t nes, typename nbt, bool nsub, bool nsup, bool nsat>
friend std::ostream& operator<< (std::ostream& ostr, const cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& r);
template<size_t nnbits, size_t nes, typename nbt, bool nsub, bool nsup, bool nsat>
friend std::istream& operator>> (std::istream& istr, cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& r);
template<size_t nnbits, size_t nes, typename nbt, bool nsub, bool nsup, bool nsat>
friend bool operator==(const cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& lhs, const cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& rhs);
template<size_t nnbits, size_t nes, typename nbt, bool nsub, bool nsup, bool nsat>
friend bool operator!=(const cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& lhs, const cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& rhs);
template<size_t nnbits, size_t nes, typename nbt, bool nsub, bool nsup, bool nsat>
friend bool operator< (const cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& lhs, const cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& rhs);
template<size_t nnbits, size_t nes, typename nbt, bool nsub, bool nsup, bool nsat>
friend bool operator> (const cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& lhs, const cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& rhs);
template<size_t nnbits, size_t nes, typename nbt, bool nsub, bool nsup, bool nsat>
friend bool operator<=(const cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& lhs, const cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& rhs);
template<size_t nnbits, size_t nes, typename nbt, bool nsub, bool nsup, bool nsat>
friend bool operator>=(const cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& lhs, const cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& rhs);
};
////////////////////// operators
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline std::ostream& operator<<(std::ostream& ostr, const cfloat<nbits,es,bt,hasSubnormals,hasSupernormals,isSaturating>& v) {
// TODO: make it a native conversion
ostr << double(v);
return ostr;
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline std::istream& operator>>(std::istream& istr, const cfloat<nbits,es,bt,hasSubnormals,hasSupernormals,isSaturating>& v) {
istr >> v._fraction;
return istr;
}
template<size_t nnbits, size_t nes, typename nbt, bool nsub, bool nsup, bool nsat>
inline bool operator==(const cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& lhs, const cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& rhs) {
for (size_t i = 0; i < lhs.nrBlocks; ++i) {
if (lhs._block[i] != rhs._block[i]) {
return false;
}
}
return true;
}
template<size_t nnbits, size_t nes, typename nbt, bool nsub, bool nsup, bool nsat>
inline bool operator!=(const cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& lhs, const cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& rhs) { return !operator==(lhs, rhs); }
template<size_t nnbits, size_t nes, typename nbt, bool nsub, bool nsup, bool nsat>
inline bool operator< (const cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& lhs, const cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& rhs) { return (lhs - rhs).isneg(); }
template<size_t nnbits, size_t nes, typename nbt, bool nsub, bool nsup, bool nsat>
inline bool operator> (const cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& lhs, const cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& rhs) { return operator< (rhs, lhs); }
template<size_t nnbits, size_t nes, typename nbt, bool nsub, bool nsup, bool nsat>
inline bool operator<=(const cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& lhs, const cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& rhs) { return !operator> (lhs, rhs); }
template<size_t nnbits, size_t nes, typename nbt, bool nsub, bool nsup, bool nsat>
inline bool operator>=(const cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& lhs, const cfloat<nnbits,nes,nbt,nsub,nsup,nsat>& rhs) { return !operator< (lhs, rhs); }
// posit - posit binary arithmetic operators
// BINARY ADDITION
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating> operator+(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& rhs) {
cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating> sum(lhs);
sum += rhs;
return sum;
}
// BINARY SUBTRACTION
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating> operator-(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& rhs) {
cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating> diff(lhs);
diff -= rhs;
return diff;
}
// BINARY MULTIPLICATION
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating> operator*(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& rhs) {
cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating> mul(lhs);
mul *= rhs;
return mul;
}
// BINARY DIVISION
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating> operator/(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& rhs) {
cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating> ratio(lhs);
ratio /= rhs;
return ratio;
}
// encoding helpers
// return the Unit in the Last Position
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating> ulp(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& a) {
cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating> b(a);
return ++b - a;
}
// convert to std::string
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline std::string to_string(const cfloat<nbits,es,bt, hasSubnormals, hasSupernormals, isSaturating>& v) {
std::stringstream s;
if (v.iszero()) {
s << " zero b";
return s.str();
}
else if (v.isinf()) {
s << " infinite b";
return s.str();
}
// s << "(" << (v.sign() ? "-" : "+") << "," << v.scale() << "," << v.fraction() << ")";
return s.str();
}
// transform cfloat to a binary representation
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline std::string to_binary(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& number, bool nibbleMarker = false) {
std::stringstream s;
s << "0b";
size_t index = nbits;
s << (number.at(--index) ? '1' : '0') << '.';
for (int i = int(es)-1; i >= 0; --i) {
s << (number.at(--index) ? '1' : '0');
if (i > 0 && (i % 4) == 0 && nibbleMarker) s << '\'';
}
s << '.';
constexpr int fbits = nbits - 1ull - es;
for (int i = fbits-1; i >= 0; --i) {
s << (number.at(--index) ? '1' : '0');
if (i > 0 && (i % 4) == 0 && nibbleMarker) s << '\'';
}
return s.str();
}
// transform a cfloat into a triple representation
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline std::string to_triple(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& number, bool nibbleMarker = true) {
std::stringstream s;
blocktriple<cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>::fbits, bt> triple;
number.normalize(triple);
s << to_triple(triple, nibbleMarker);
return s.str();
}
/// Magnitude of a scientific notation value (equivalent to turning the sign bit off).
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>
abs(const cfloat<nbits,es,bt, hasSubnormals, hasSupernormals, isSaturating>& v) {
return cfloat<nbits,es,bt, hasSubnormals, hasSupernormals, isSaturating>(false, v.scale(), v.fraction(), v.isZero());
}
///////////////////////////////////////////////////////////////////////
/// binary logic literal comparisons
// cfloat - literal float logic operators
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator==(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, float rhs) {
return float(lhs) == rhs;
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator!=(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, float rhs) {
return float(lhs) != rhs;
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator< (const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, float rhs) {
return float(lhs) < rhs;
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator> (const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, float rhs) {
return float(lhs) > rhs;
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator<=(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, float rhs) {
return float(lhs) <= rhs;
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator>=(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, float rhs) {
return float(lhs) >= rhs;
}
// cfloat - literal double logic operators
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator==(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, double rhs) {
return double(lhs) == rhs;
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator!=(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, double rhs) {
return double(lhs) != rhs;
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator< (const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, double rhs) {
return double(lhs) < rhs;
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator> (const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, double rhs) {
return double(lhs) > rhs;
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator<=(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, double rhs) {
return double(lhs) <= rhs;
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator>=(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, double rhs) {
return double(lhs) >= rhs;
}
// cfloat - literal long double logic operators
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator==(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, long double rhs) {
return (long double)(lhs) == rhs;
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator!=(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, long double rhs) {
return (long double)(lhs) != rhs;
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator< (const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, long double rhs) {
return (long double)(lhs) < rhs;
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator> (const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, long double rhs) {
return (long double)(lhs) > rhs;
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator<=(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, long double rhs) {
return (long double)(lhs) <= rhs;
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator>=(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, long double rhs) {
return (long double)(lhs) >= rhs;
}
// cfloat - literal int logic operators
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator==(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, int rhs) {
return operator==(lhs, cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>(rhs));
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator!=(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, int rhs) {
return operator!=(lhs, cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>(rhs));
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator< (const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, int rhs) {
return operator<(lhs, cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>(rhs));
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator> (const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, int rhs) {
return operator<(cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>(rhs), lhs);
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator<=(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, int rhs) {
return operator<(lhs, cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>(rhs)) || operator==(lhs, cfloat<nbits, es, bt>(rhs));
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator>=(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, int rhs) {
return !operator<(lhs, cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>(rhs));
}
// cfloat - long long logic operators
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator==(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, long long rhs) {
return operator==(lhs, cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>(rhs));
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator!=(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, long long rhs) {
return operator!=(lhs, cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>(rhs));
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator< (const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, long long rhs) {
return operator<(lhs, cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>(rhs));
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator> (const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, long long rhs) {
return operator<(cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>(rhs), lhs);
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator<=(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, long long rhs) {
return operator<(lhs, cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>(rhs)) || operator==(lhs, cfloat<nbits, es, bt>(rhs));
}
template<size_t nbits, size_t es, typename bt, bool hasSubnormals, bool hasSupernormals, bool isSaturating>
inline bool operator>=(const cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>& lhs, long long rhs) {
return !operator<(lhs, cfloat<nbits, es, bt, hasSubnormals, hasSupernormals, isSaturating>(rhs));
}
} // namespace sw::universal
| 37.735614 | 246 | 0.638339 | [
"object",
"transform"
] |
fc176e1863c7bea2c419e46dcca3140d07889264 | 5,122 | hpp | C++ | src/perception/filters/ray_ground_classifier/include/ray_ground_classifier/ray_aggregator.hpp | jimaldon/AutowareAuto | 2b639aa06f67e41222c89f3885c0472483ac6b38 | [
"Apache-2.0"
] | null | null | null | src/perception/filters/ray_ground_classifier/include/ray_ground_classifier/ray_aggregator.hpp | jimaldon/AutowareAuto | 2b639aa06f67e41222c89f3885c0472483ac6b38 | [
"Apache-2.0"
] | null | null | null | src/perception/filters/ray_ground_classifier/include/ray_ground_classifier/ray_aggregator.hpp | jimaldon/AutowareAuto | 2b639aa06f67e41222c89f3885c0472483ac6b38 | [
"Apache-2.0"
] | 1 | 2020-11-21T04:17:33.000Z | 2020-11-21T04:17:33.000Z | // Copyright 2017-2019 Apex.AI, Inc.
// Co-developed by Tier IV, Inc. and Apex.AI, Inc.
//
// 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.
/// \file
/// \brief This file defines the ray aggregator for generic point cloud support
#ifndef RAY_GROUND_CLASSIFIER__RAY_AGGREGATOR_HPP_
#define RAY_GROUND_CLASSIFIER__RAY_AGGREGATOR_HPP_
#include <algorithm>
#include <cmath>
#include <complex>
#include <cstdint>
#include <vector>
#include "autoware_auto_algorithm/algorithm.hpp"
#include "lidar_utils/lidar_types.hpp"
#include "ray_ground_classifier/ray_ground_point_classifier.hpp"
namespace autoware
{
namespace perception
{
namespace filters
{
namespace ray_ground_classifier
{
using autoware::common::lidar_utils::PointBlock;
/// \brief Used as a prefiltering step for RayGroundClassifier. Aggregates unstructured
/// blobs into rays of points that the RayGroundClassifier can partition.
class RAY_GROUND_CLASSIFIER_PUBLIC RayAggregator
{
public:
/// \brief Configuration object for RayAggregator
class RAY_GROUND_CLASSIFIER_PUBLIC Config
{
public:
/// \brief Constructor
/// \param[in] min_ray_angle_rad Minimum ray angle
/// \param[in] max_ray_angle_rad Maximum ray angle
/// \param[in] ray_width_rad Width of ray, defines number of rays
/// \param[in] min_ray_points Number of points needed in a ray before it's ready for
/// partitioning
Config(
const float min_ray_angle_rad,
const float max_ray_angle_rad,
const float ray_width_rad,
const std::size_t min_ray_points);
/// \brief Get number of rays
/// \return Value
std::size_t get_num_rays() const;
/// \brief Get number of points needed for a ray to be ready for partitioning
/// \return Value
std::size_t get_min_ray_points() const;
/// \brief Get minimum ray angle
/// \return Value
float get_min_angle() const;
/// \brief Get maximum ray angle
/// \return Value
float get_ray_width() const;
/// \brief Whether domain crosses the -PI/+PI singularity, e.g. min_ray_angle=300,
/// max_ray_angle = -300
/// \return Value
bool domain_crosses_180() const;
private:
const std::size_t m_min_ray_points;
std::size_t m_num_rays;
const float m_ray_width_rad;
const float m_min_angle_rad;
const bool m_domain_crosses_180;
}; // class Config
/// \brief Constructor
/// \param[in] cfg Configuration class
explicit RayAggregator(const Config & cfg);
/// \brief Insert point into set of rays
/// \param[in] pt Point to be inserted
void insert(const PointXYZIFR & pt);
/// \brief Insert point into set of rays
/// \param[in] pt Point to be inserted
void insert(const PointXYZIF & pt);
/// \brief Insert points associated with blk into the ray set
/// \param[in] blk Block of points to be added
void insert(const PointBlock & blk);
/// \brief Insert points from an iterator
/// \param[in] first Beginning of iterator
/// \param[in] last One past the last element of the iterator
template<typename InputIT>
void insert(const InputIT first, const InputIT last)
{
// TODO(c.ho) static asserts on declytype(*it) for friendlier error messages
for (InputIT it = first; it != last; ++it) {
insert(*it);
}
}
/// \brief Whether a ray is ready for processing
/// \return Value
bool is_ray_ready() const;
/// \brief Get next ray that is ready for partitioning
/// \return Const reference to next ray ready for processing
/// \throw std::runtime_error If no ray is ready
const Ray & get_next_ray();
private:
enum class RayState : uint8_t
{
/// \brief Ray does not have enough points to be classified
NOT_READY = 0U,
/// \brief Ray has enough points to be classified
READY,
/// \brief Ray has been read via get_next_ray(), and should be reset on next insert
RESET
}; // enum class RayState
/// \brief Compute which bin a point belongs to
std::size_t RAY_GROUND_CLASSIFIER_LOCAL bin(const PointXYZIFR & pt) const;
const Config m_cfg;
std::vector<Ray> m_rays;
autoware::common::algorithm::QuickSorter<Ray> m_ray_sorter;
// simple index ring buffer
std::vector<std::size_t> m_ready_indices;
std::size_t m_ready_start_idx;
std::size_t m_num_ready;
// which rays are ready to be reset etc. TODO(c.ho) fold this into an internal ray class
std::vector<RayState> m_ray_state;
}; // class RayAggregator
} // namespace ray_ground_classifier
} // namespace filters
} // namespace perception
} // namespace autoware
#endif // RAY_GROUND_CLASSIFIER__RAY_AGGREGATOR_HPP_
| 33.92053 | 90 | 0.713588 | [
"object",
"vector"
] |
fc1da5369837684b5e6900e106a9031209e977ef | 7,178 | hpp | C++ | imgui_entt_entity_editor.hpp | flingengine/imgui_entt_entity_editor | f09af05c66dafa28c50f1c8e8a2c6524c495eaed | [
"MIT"
] | 1 | 2020-12-14T21:30:37.000Z | 2020-12-14T21:30:37.000Z | imgui_entt_entity_editor.hpp | flingengine/imgui_entt_entity_editor | f09af05c66dafa28c50f1c8e8a2c6524c495eaed | [
"MIT"
] | null | null | null | imgui_entt_entity_editor.hpp | flingengine/imgui_entt_entity_editor | f09af05c66dafa28c50f1c8e8a2c6524c495eaed | [
"MIT"
] | 1 | 2021-05-28T22:57:44.000Z | 2021-05-28T22:57:44.000Z | // for the license, see the end of the file
#pragma once
#include <set>
#include <map>
#include <entt/entt.hpp>
#include <imgui.h>
// if you have font awesome or something comparable you can set this to a wastebin
#ifndef ESS_IMGUI_ENTT_E_E_DELETE_COMP_STR
#define ESS_IMGUI_ENTT_E_E_DELETE_COMP_STR "-"
#endif
namespace MM {
template<typename Registry>
class ImGuiEntityEditor {
private:
using component_type = entt::component;
std::set<component_type> _component_types;
std::map<component_type, std::string> _component_names;
std::map<component_type, void(*)(Registry&, typename Registry::entity_type)> _component_widget;
std::map<component_type, void(*)(Registry&, typename Registry::entity_type)> _component_create;
std::map<component_type, void(*)(Registry&, typename Registry::entity_type)> _component_destroy;
public:
bool show_window = true;
private:
inline bool entity_has_component(Registry& ecs, typename Registry::entity_type& e, component_type ct) {
component_type type[] = { ct };
auto rv = ecs.runtime_view(std::cbegin(type), std::cend(type));
return rv.contains(e);
}
public:
// calls all the ImGui functions
// call this every frame
void renderImGui(Registry& ecs, typename Registry::entity_type& e) {
if (show_window) {
if(ImGui::Begin("Entity Editor", &show_window)) {
ImGui::TextUnformatted("editing:");
ImGui::SameLine();
//ImGuiWidgets::Entity(e, ecs, true);
if (ecs.valid(e)) {
ImGui::Text("id: %d, v: %d", ecs.entity(e), ecs.version(e));
} else {
ImGui::Text("INVALID ENTITY");
}
// TODO: investigate
if (ImGui::Button("New Entity")) {
e = ecs.create();
}
// TODO: implemnt cloning by ether forking entt or implementing function lists...
//ImGui::SameLine();
//ImGui::TextUnformatted(ICON_II_ARCHIVE " drop to clone Entity");
//if (ImGui::BeginDragDropTarget()) {
//if (auto* payload = ImGui::AcceptDragDropPayload(IMGUI_PAYLOAD_TYPE_MM_ENTITY)) {
//auto clone_e = *(MM::FrameworkConfig::Entity*)payload->Data;
//e = ecs.clone(clone_e);
//}
//ImGui::EndDragDropTarget();
//}
ImGui::Separator();
// TODO: needed?
if (!ecs.valid(e)) {
e = entt::null;
}
if (e != entt::null) {
std::vector<component_type> has_not;
for (auto ct : _component_types) {
if (entity_has_component(ecs, e, ct)) {
// delete component button
if (_component_destroy.count(ct)) {
std::string button_label = ESS_IMGUI_ENTT_E_E_DELETE_COMP_STR "##";
button_label += entt::to_integer(ct);
if (ImGui::Button(button_label.c_str())) {
_component_destroy[ct](ecs, e);
continue; // early out to prevent access to deleted data
} else {
ImGui::SameLine();
}
}
std::string label;
if (_component_names.count(ct)) {
label = _component_names[ct];
} else {
label = "unnamed component (";
label += entt::to_integer(ct);
label += ")";
}
if (ImGui::CollapsingHeader(label.c_str())) {
ImGui::Indent(30.f);
if (_component_widget.count(ct)) {
_component_widget[ct](ecs, e);
} else {
ImGui::TextDisabled("missing widget to display component!");
}
ImGui::Unindent(30.f);
}
} else {
has_not.push_back(ct);
}
}
if (!has_not.empty()) {
if (ImGui::Button("+ Add Component")) {
ImGui::OpenPopup("add component");
}
if (ImGui::BeginPopup("add component")) {
ImGui::TextUnformatted("available:");
ImGui::Separator();
for (auto ct : has_not) {
if (_component_create.count(ct)) {
std::string label;
if (_component_names.count(ct)) {
label = _component_names[ct];
} else {
label = "unnamed component (";
label += entt::to_integer(ct);
label += ")";
}
label += "##"; label += entt::to_integer(ct); // better but optional
if (ImGui::Selectable(label.c_str())) {
_component_create[ct](ecs, e);
}
}
}
ImGui::EndPopup();
}
}
}
}
ImGui::End();
}
}
// call this (or registerTrivial) before any of the other register functions
void registerComponentType(component_type ct) {
if (!_component_types.count(ct)) {
_component_types.emplace(ct);
}
}
// register a name to be displayed for the component
void registerComponentName(component_type ct, const std::string& name) {
_component_names[ct] = name;
}
// register a callback to a function displaying a component. using imgui
void registerComponentWidgetFn(component_type ct, void(*fn)(Registry&, typename Registry::entity_type)) {
_component_widget[ct] = fn;
}
// register a callback to create a component, if none, you wont be able to create it in the editor
void registerComponentCreateFn(component_type ct, void(*fn)(Registry&, typename Registry::entity_type)) {
_component_create[ct] = fn;
}
// register a callback to delete a component, if none, you wont be able to delete it in the editor
void registerComponentDestroyFn(component_type ct, void(*fn)(Registry&, typename Registry::entity_type)) {
_component_destroy[ct] = fn;
}
// registers the component_type, name, create and destroy for rather trivial types
template<typename T>
void registerTrivial(Registry& ecs, const std::string& name) {
registerComponentType(ecs.template type<T>());
registerComponentName(ecs.template type<T>(), name);
registerComponentCreateFn(ecs.template type<T>(),
[](Registry& ecs, typename Registry::entity_type e) {
ecs.template assign<T>(e);
});
registerComponentDestroyFn(ecs.template type<T>(),
[](Registry& ecs, typename Registry::entity_type e) {
ecs.template remove<T>(e);
});
}
};
} // MM
// MIT License
// Copyright (c) 2019 Erik Scholz
// 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.
| 32.044643 | 108 | 0.648231 | [
"vector"
] |
fc2ecd0bfc5a23562bcb6010f4a3d0029283bfa4 | 40,899 | hpp | C++ | examples/amr-merge-tree/include/fab-tmt-block.hpp | skn123/reeber | 7fe16b6addef2c7b2289a40afa0064d9299fcc5e | [
"BSD-3-Clause-LBNL"
] | 4 | 2020-07-08T03:39:37.000Z | 2021-04-30T18:20:39.000Z | examples/amr-merge-tree/include/fab-tmt-block.hpp | skn123/reeber | 7fe16b6addef2c7b2289a40afa0064d9299fcc5e | [
"BSD-3-Clause-LBNL"
] | 1 | 2020-08-28T16:51:53.000Z | 2020-09-01T02:12:34.000Z | examples/amr-merge-tree/include/fab-tmt-block.hpp | skn123/reeber | 7fe16b6addef2c7b2289a40afa0064d9299fcc5e | [
"BSD-3-Clause-LBNL"
] | 3 | 2020-07-22T23:24:11.000Z | 2020-08-28T16:27:39.000Z | template<class Real, unsigned D>
bool FabTmtBlock<Real, D>::cmp(Real a, Real b) const
{
if (negate_)
return a > b;
else
return a < b;
}
template<class Real, unsigned D>
void FabTmtBlock<Real, D>::set_mask(const diy::Point<int, D>& v_mask,
diy::AMRLink* l,
const Real& rho,
bool is_absolute_threshold)
{
using Position = diy::Point<int, D>;
int debug_gid = local_.gid();
bool debug = false; //gid == 24316;
// debug = (gid == 63) and (v_mask[0] == 2 and v_mask[1] == 2 and v_mask[2] == 65);
auto v_local = local_.local_position_from_mask(v_mask);
auto v_global = local_.global_position_from_local(v_local);
bool is_in_core = local_.core_contains_global(v_global);
bool is_on_boundary = local_.is_on_boundary(v_global);
bool is_ghost = local_.is_outer(v_mask);
Real value = std::numeric_limits<Real>::infinity();
if (is_in_core)
{
value = fab_(v_local);
//fmt::print("VALUE = {}, v_local = {}, gid = {}\n", value, v_local, gid);
}
bool is_low = false;
if (is_absolute_threshold and is_in_core)
is_low = not is_ghost and
cmp(rho, value); //(negate_ ? fab_(v_mask) < rho : fab_(v_mask) > rho);
r::AmrVertexId v_idx;
// does not matter here
if (not is_ghost) v_idx = local_.get_vertex_from_global_position(local_.global_position_from_local(v_mask));
if (debug)
{
if (n_debug_printed_core_ < 10 and not is_on_boundary and is_in_core)
{
n_debug_printed_core_++;
fmt::print(
"PRINTING CORE gid = {}, in set_mask, v_mask = {}, v_idx = {}, value = {}, is_ghost = {}, is_on_boundary = {}, is_in_core = {}\n",
debug_gid, v_mask,
v_idx,
value, is_ghost, is_on_boundary, is_in_core);
}
if (n_debug_printed_bdry_ < 10 and is_on_boundary)
{
n_debug_printed_bdry_++;
fmt::print(
"PRINTING BDRY gid = {}, in set_mask, v_mask = {}, v_idx = {}, value = {}, is_ghost = {}, is_on_boundary = {}, is_in_core = {}\n",
debug_gid, v_mask,
v_idx,
value, is_ghost, is_on_boundary, is_in_core);
}
}
// initialization, actual mask to be set later
if (is_ghost)
{
if (debug)
{ fmt::print("in set_mask, gid = {}, v_mask = {}, GHOST detected\n", debug_gid, v_mask); }
local_.set_mask(v_mask, MaskedBox::GHOST);
} else
{
local_.set_mask(v_mask, MaskedBox::ACTIVE);
}
const int v_ref = local_.refinement();
const int v_level = local_.level();
Position v_glob = wrap_point(v_mask + local_.mask_from(), domain_, v_ref, true);
// if (debug)
// {
// fmt::print("in set_mask, gid = {}, unwrapped v_glob = {}, wrapped = {}, v_idx = {}, domain = [{} - {}], local = {}\n", local_.gid(),
// v_mask + local_.mask_from(), v_glob, v_idx, domain_.min, domain_.max, local_);
// }
bool mask_set{false};
// loop over neighbouring blocks one level above
for(int i = 0; i < l->size(); ++i)
if (l->level(i) == v_level + 1 && neighbor_contains<D>(i, l, v_glob, v_ref))
{
if (debug)
{
fmt::print("Is masked ABOVE {} , is_ghost = {}, gid = {}, v_idx = {}\n", local_.gid(), is_ghost,
l->target(i).gid, v_idx);
}
mask_set = true;
local_.set_mask(v_mask, l->target(i).gid);
if (not is_ghost)
n_masked_++;
break;
}
// real cells can only be masked by blocks above, only ghost cells need to look at same level and below
if (not mask_set and is_ghost)
{
// loop over neighbours on the same level
for(int i = 0; i < l->size(); ++i)
{
if (l->level(i) == v_level && neighbor_contains<D>(i, l, v_glob, v_ref))
{
if (debug)
{
fmt::print("Is masked SAME {} , is_ghost = {}, gid = {}, v_idx = {}\n", l->target(i).gid, is_ghost,
local_.gid(), v_idx);
}
mask_set = true;
local_.set_mask(v_mask, l->target(i).gid);
if (not is_ghost)
n_masked_++;
break;
}
}
}
// loop over neighbours one level below. This is not actual masking,
// but we save this info in ghost cells to get outgoing edges.
if (not mask_set and is_ghost)
{
for(int i = 0; i < l->size(); ++i)
{
if (l->level(i) == v_level - 1 && neighbor_contains<D>(i, l, v_glob, v_ref))
{
if (debug)
{
fmt::print("Is masked FAKE {} , is_ghost = {}, gid = {}, v_idx = {}\n", l->target(i).gid, is_ghost,
local_.gid(), v_idx);
}
mask_set = true;
local_.set_mask(v_mask, l->target(i).gid);
break;
}
}
}
if (not mask_set and is_low)
{
local_.set_mask(v_mask, MaskedBox::LOW);
}
if (is_ghost and is_in_core)
throw std::runtime_error("Contradiction");
if (not is_absolute_threshold and not mask_set and not is_ghost)
{
// we need to store local sum and local number of unmasked vertices in a block
// and use this later to mark low vertices
n_unmasked_++;
auto v_local = local_.local_position_from_mask(v_mask);
sum_ += value;
}
if (debug)
{
fmt::print("in set_mask, is_ghost = {}, final mask = {}, {}, gid = {}, v_mask = {}, v_idx = {}\n",
is_ghost, local_.pretty_mask_value(v_mask), local_.mask(v_mask), local_.gid(), v_mask, v_idx);
}
if (is_ghost and local_.mask(v_mask) == gid)
{
fmt::print("in set_mask, is_ghost = {}, final mask = {}, {}, gid = {}, v_mask = {}, v_idx = {}\n",
is_ghost, local_.pretty_mask_value(v_mask), local_.mask(v_mask), local_.gid(), v_mask, v_idx);
fmt::print("Error, same gid in mask\n");
throw std::runtime_error("Bad mask");
}
}
template<class Real, unsigned D>
void FabTmtBlock<Real, D>::set_low(const diy::Point<int, D>& v_bounds,
const Real& absolute_threshold)
{
auto v_mask = local_.mask_position_from_local(v_bounds);
if (local_.mask(v_mask) != MaskedBox::ACTIVE)
return;
bool is_low = cmp(absolute_threshold,
fab_(v_bounds)); // negate_ ? fab_(v_bounds) < absolute_threshold : fab_(v_bounds) > absolute_threshold;
if (is_low)
{
n_low_++;
local_.set_mask(v_mask, MaskedBox::LOW);
} else
{
n_active_++;
// if (gid == 0) fmt::print("HERE ACTIVE: {}\n", local_.global_position_from_local(v_bounds));
}
}
template<class Real, unsigned D>
void FabTmtBlock<Real, D>::init(Real absolute_rho, diy::AMRLink* amr_link)
{
bool debug = false; //gid == 1 or gid == 100;
std::string debug_prefix = "In FabTmtBlock::init, gid = " + std::to_string(gid);
diy::for_each(local_.bounds_shape(), [this, absolute_rho](const Vertex& v_bounds) {
this->set_low(v_bounds, absolute_rho);
});
if (debug)
fmt::print("{}, absolute_rho = {}, n_active = {}, n_masked = {}, total_size = {}, level = {}\n", debug_prefix,
absolute_rho, n_active_,
n_masked_, local_.core_shape()[0] * local_.core_shape()[1] * local_.core_shape()[2], level());
reeber::compute_merge_tree2(current_merge_tree_, local_, fab_);
current_merge_tree_.make_deep_copy(original_tree_);
VertexEdgesMap vertex_to_outgoing_edges;
compute_outgoing_edges(amr_link, vertex_to_outgoing_edges);
compute_original_connected_components(vertex_to_outgoing_edges);
sparsify_prune_original_tree();
// TODO: delete this? we are going to overwrite this in adjust_outgoing_edges anyway
for(int i = 0; i < amr_link->size(); ++i)
{
if (amr_link->target(i).gid != gid)
{
new_receivers_.insert(amr_link->target(i).gid);
original_link_gids_.push_back(amr_link->target(i).gid);
}
}
if (debug)
fmt::print("{}, constructed, refinement = {}, level = {}, local = {}, #components = {}\n",
debug_prefix, refinement(), level(), local_, components_.size());
if (debug)
{
int n_edges = 0;
for(auto& gid_edges : gid_to_outgoing_edges_)
{ n_edges += gid_edges.second.size(); }
fmt::print("{}, constructed, tree.size = {}, new_receivers.size = {}, n_edges = {}\n",
debug_prefix, current_merge_tree_.size(), new_receivers_.size(), n_edges);
}
assert(current_merge_tree_.size() >= original_tree_.size());
}
template<class Real, unsigned D>
void FabTmtBlock<Real, D>::sparsify_prune_original_tree()
{
#ifndef REEBER_NO_SPARSIFICATION
std::unordered_set<AmrVertexId> special;
for(const AmrEdge& out_edge : get_all_outgoing_edges())
{
special.insert(std::get<0>(out_edge));
}
for(AmrVertexId od : original_deepest_)
{
special.insert(od);
}
// r::remove_degree_two(original_tree_, [&special](AmrVertexId u) { return special.find(u) != special.end(); });
r::sparsify(original_tree_, [&special](AmrVertexId u) { return special.find(u) != special.end(); });
#endif
}
template<class Real, unsigned D>
void FabTmtBlock<Real, D>::sparsify_local_tree(const FabTmtBlock::AmrVertexSet& keep)
{
#ifndef REEBER_NO_SPARSIFICATION
r::sparsify(current_merge_tree_,
[this, &keep](AmrVertexId u)
{ return u.gid == this->gid or keep.find(u) != keep.end(); });
#endif
}
template<unsigned D>
r::AmrEdgeContainer
get_vertex_edges(const diy::Point<int, D>& v_glob, const reeber::MaskedBox<D>& local, diy::AMRLink* l,
const diy::DiscreteBounds& domain, bool debug = false)
{
using Position = diy::Point<int, D>;
r::AmrVertexId v_glob_idx = local.get_vertex_from_global_position(v_glob);
// bool debug = v_glob_idx == r::AmrVertexId(0, 64) or v_glob_idx == r::AmrVertexId(1, 4486);
if (debug)
{ fmt::print("get_vertex_edges called for {}, vertex {}, box = {}\n", v_glob, v_glob_idx, local); }
r::AmrEdgeContainer result;
for(const Position& neighb_v_glob : local.outer_edge_link(v_glob))
{
Position neighb_v_bounds = neighb_v_glob - local.bounds_from();
Position wrapped_neighb_vert_glob = wrap_point(neighb_v_glob, domain, local.refinement());
if (debug)
{
fmt::print(
"In get_vertex_edges, v_glob = {}, gid = {}, neighb_v_bounds = {}, neighb_v_glob = {}, wrapped_neighb_vert_glob = {}\n",
v_glob,
local.gid(), neighb_v_bounds, neighb_v_glob, wrapped_neighb_vert_glob);
}
Position neighb_v_mask = local.mask_position_from_local(neighb_v_bounds);
int masking_gid = local.mask(neighb_v_mask);
size_t link_idx = 0;
bool link_idx_found = false;
for(; link_idx < (size_t) l->size(); ++link_idx)
{
if (l->target(link_idx).gid == masking_gid)
{
link_idx_found = true;
break;
}
}
//assert(link_idx_found);
if (not link_idx_found)
{
fmt::print("Error here: masking_gid = {}\n", local.pretty_mask_value(masking_gid));
throw std::runtime_error("masking_gid not found in link");
}
auto nb_level = l->level(link_idx);
Position nb_from = point_from_dynamic_point<D>(l->bounds(link_idx).min);
Position nb_to = point_from_dynamic_point<D>(l->bounds(link_idx).max);
// TODO: vector refinement
int nb_refinement = l->refinement(link_idx)[0];
if (debug)
{
fmt::print(
"In get_vertex_edges, v_glob = {}, gid = {}, masked by masking_gid= {}, glob_coord = {}, nb_from = {}, nb_to = {}\n",
v_glob,
local.gid(), masking_gid, wrapped_neighb_vert_glob, nb_from, nb_to);
}
//assert(abs(nb_level - local.level()) <= 1);
if (nb_level <= local.level())
{
// neighbour is on the same level or below me, neighbouring vertex corresponds
// to the unique vertex in a neighbouring block
size_t neighb_vertex_idx = get_vertex_id(wrapped_neighb_vert_glob, local.refinement(), link_idx, l,
local.mask_grid().c_order());
result.emplace_back(v_glob_idx, reeber::AmrVertexId{masking_gid, neighb_vertex_idx});
if (debug)
{
fmt::print("In get_vertex_edges, v_glob = {}, masking_gid = {}, Added edge to idx = {}\n", v_glob,
masking_gid,
neighb_vertex_idx);
}
} else if (nb_level > local.level())
{
Position masking_box_from, masking_box_to;
std::tie(masking_box_from, masking_box_to) = refine_vertex(neighb_v_glob, local.refinement(),
nb_refinement);
if (debug)
fmt::print(
"In get_vertex_edges, v_glob = {}, masking_gid = {}, masking_box_from = {}, masking_box_to = {}\n",
v_glob, local.gid(), masking_box_from, masking_box_to);
reeber::Box<D> masking_box(masking_box_from, masking_box_to);
reeber::Box<D> covering_box(masking_box_from - Position::one(), masking_box_to + Position::one());
for(const Position& masking_position : masking_box.positions())
{
for(Position covering_position_glob : covering_box.position_link(masking_position))
{
Position covering_position_coarsened = wrap_point(
coarsen_point(covering_position_glob, nb_refinement,
local.refinement()),
domain, local.refinement());
if (debug)
{
fmt::print(
"In get_vertex_edges, v_glob = {}, masking_gid = {}, cov_vert = {}, cov_vert_loc = {}\n",
v_glob, local.gid(), covering_position_glob,
covering_position_coarsened);
}
if (covering_position_coarsened == v_glob)
{
Position masking_position_global = wrap_point(masking_position, domain, nb_refinement);
r::AmrVertexId masking_vertex_idx{masking_gid,
get_vertex_id(masking_position_global, nb_refinement,
link_idx, l,
local.mask_grid().c_order())};
if (debug)
{
fmt::print(
"IN get_vertex_edges, v_glob = {}, masking_gid = {}, masking_position = {}, nb_from = {}, nb_to = {}, adding edge {}\n",
v_glob, local.gid(), masking_position, nb_from, nb_to,
r::AmrEdge{v_glob_idx, masking_vertex_idx});
}
result.emplace_back(v_glob_idx, masking_vertex_idx);
}
}
}
}
} // loop over outer edge link
return result;
}
template<class Real, unsigned D>
void FabTmtBlock<Real, D>::compute_outgoing_edges(diy::AMRLink* l, VertexEdgesMap& vertex_to_outgoing_edges)
{
bool debug = false; //gid == 0 or gid == 1;
if (debug) fmt::print("Enter compute_outgoing_edges, gid = {}\n", gid);
auto receivers = link_unique(l, gid);
if (debug)
fmt::print("In compute_outgoing_edges for block = {}, link size = {}, unique = {}\n", gid, l->size(),
receivers.size());
for(const Vertex& v_glob : local_.active_global_positions())
{
auto v_idx = local_.get_vertex_from_global_position(v_glob);
// debug = (gid == 0 or gid == 1) and (v_idx == 64 or v_idx == 4486);
// debug = (v_idx.gid == 0 and v_idx.vertex == 64) or (v_idx.gid == 1 and v_idx.vertex == 4486);
// debug = (v_glob[0] == 0 and v_glob[1] == 0 and v_glob[2] == 6);
AmrEdgeContainer out_edges = get_vertex_edges(v_glob, local_, l, domain(), debug);
if (debug)
{
for(auto&& e : out_edges)
{
fmt::print("outogoing edge e = {} {}\n", std::get<0>(e), std::get<1>(e));
}
}
if (not out_edges.empty())
{
vertex_to_outgoing_edges[local_.get_vertex_from_global_position(v_glob)] = out_edges;
std::copy(out_edges.begin(), out_edges.end(), std::back_inserter(initial_edges_));
for(const AmrEdge& e : out_edges)
{
assert(std::get<0>(e).gid == gid);
if (debug) fmt::print("in compute_outgoing_edges, adding {} to gid_to_outoging_edges\n", e);
gid_to_outgoing_edges_[std::get<1>(e).gid].push_back(e);
}
}
}
}
//template<class Real, unsigned D>
//void FabTmtBlock<Real, D>::adjust_original_gids(int sender_gid, FabTmtBlock::GidVector& edges_from_sender)
//{
// auto iter = std::find(original_link_gids_.begin(), original_link_gids_.end(), sender_gid);
// bool i_talk_to_sender = iter != original_link_gids_.end();
// bool sender_talks_to_me =
// std::find(edges_from_sender.begin(), edges_from_sender.end(), gid) != edges_from_sender.end();
// if (i_talk_to_sender and not sender_talks_to_me)
// original_link_gids_.erase(iter);
//}
// delete edges from this block that end in a low vertex of a neighbor block.
// edges_from_gid: outogoing eddes we receive from a neigbor block
// subtract them from the edges we keep in gid_to_outgoing_edges_
template<class Real, unsigned D>
void FabTmtBlock<Real, D>::delete_low_edges(int sender_gid, FabTmtBlock::AmrEdgeContainer& edges_from_sender)
{
bool debug = false; //gid == 1 or gid == 100;
auto iter = gid_to_outgoing_edges_.find(sender_gid);
if (iter == gid_to_outgoing_edges_.end())
{
// all edges from neighbor must end in low vertex of mine
if (debug)
fmt::print("In delete_low_edges in block with gid = {}, sender = {}, no edges from this block, exiting\n",
gid, sender_gid);
return; // we don't expect any edges from gid
}
// edges from neighbor come reversed, correct that
std::transform(edges_from_sender.begin(), edges_from_sender.end(), edges_from_sender.begin(),
&reeber::reverse_amr_edge);
// if (debug) fmt::print("in FabTmtBlock::delete_low_edges, transform OK, n_edges_from_sender = {}\n", edges_from_sender.size());
// put edges into set to find the set difference
std::set<AmrEdge> my_edges{iter->second.begin(), iter->second.end()};
std::set<AmrEdge> neighbor_edges{edges_from_sender.begin(), edges_from_sender.end()};
int old_n_edges = my_edges.size();
iter->second.clear();
// if (debug) fmt::print("In delete_low_edges in block with gid = {}, sender = {}, clear OK, my_edges.size = {}, neighbor_edges.size = {}\n", gid, sender_gid, my_edges.size(), neighbor_edges.size());
//if (debug)
//{
// for(auto e : my_edges)
// {
// fmt::print("my gid = {}, sender_gid = {}, my_edge = {}\n", gid, sender_gid, e);
// }
// for(auto e : neighbor_edges)
// {
// fmt::print("my gid = {}, sender_gid = {}, edge_from_sender = {}\n", gid, sender_gid, e);
// }
// }
std::set_intersection(my_edges.begin(), my_edges.end(), neighbor_edges.begin(), neighbor_edges.end(),
std::back_inserter(iter->second));
int new_n_edges = iter->second.size();
if (iter->second.empty())
gid_to_outgoing_edges_.erase(iter);
if (debug)
fmt::print(
"in Block::delete_low_edges, gid = {}, sender_gid = {}, erase OK, old_n_edges = {}, new_n_edges = {}\n",
gid, sender_gid, old_n_edges, new_n_edges);
}
template<class Real, unsigned D>
void FabTmtBlock<Real, D>::adjust_outgoing_edges()
{
bool debug = false;
size_t s = initial_edges_.size();
initial_edges_.clear();
for(const auto& gid_edge_vector_pair : gid_to_outgoing_edges_)
{
std::copy(gid_edge_vector_pair.second.begin(), gid_edge_vector_pair.second.end(),
std::back_inserter(initial_edges_));
}
std::sort(initial_edges_.begin(), initial_edges_.end());
std::set<int> neighbor_gids;
for(const AmrEdge& e : initial_edges_)
{
neighbor_gids.insert(std::get<1>(e).gid);
}
int orig_link_old_size = original_link_gids_.size();
if (debug)
fmt::print(
"In adjust_outgoing_edges for gid = {}, old #edges = {}, new #edges = {}, old link size = {}, new link size = {}, new link = {}\n",
gid, s, initial_edges_.size(), orig_link_old_size, original_link_gids_.size(),
container_to_string(new_receivers_));
#ifdef AMR_MT_SEND_COMPONENTS
for(Component& c : components_)
c.set_edges(initial_edges_, original_vertex_to_deepest_);
#endif
gid_to_outgoing_edges_.clear();
// remove from original_vertex_to_deepest_ map
// inner vertices, we don't need this information any more
std::unordered_set<AmrVertexId> edge_vertices;
for(const auto& e : initial_edges_)
{
assert(std::get<0>(e).gid == gid);
edge_vertices.insert(std::get<0>(e));
}
for(auto iter = original_vertex_to_deepest_.cbegin(); iter != original_vertex_to_deepest_.cend();)
{
iter = (edge_vertices.count(iter->first) == 1) ? std::next(iter) : original_vertex_to_deepest_.erase(iter);
}
}
template<class Real, unsigned D>
r::AmrVertexId FabTmtBlock<Real, D>::original_deepest(const AmrVertexId& v) const
{
auto iter = original_vertex_to_deepest_.find(v);
if (original_vertex_to_deepest_.cend() != iter)
return iter->second;
else
throw std::runtime_error("Deepest not found for vertex");
}
template<class Real, unsigned D>
r::AmrVertexId FabTmtBlock<Real, D>::final_deepest(const AmrVertexId& v) const
{
auto iter = final_vertex_to_deepest_.find(v);
if (final_vertex_to_deepest_.cend() != iter)
return iter->second;
else
throw std::runtime_error("Deepest not found for vertex");
}
// components_ are only computed once, return their roots
// TODO: cache this in ctor?
template<class Real, unsigned D>
std::vector<r::AmrVertexId> FabTmtBlock<Real, D>::get_original_deepest_vertices() const
{
std::vector<AmrVertexId> result(components_.size());
std::transform(components_.begin(), components_.end(), result.begin(), [](const Component& c) { return c.root_; });
return result;
}
//template<class Real, unsigned D>
//void FabTmtBlock<Real, D>::add_component_to_disjoint_sets(const AmrVertexId& deepest_vertex)
//{
// //assert(components_disjoint_set_parent_.find(deepest_vertex) == components_disjoint_set_parent_.end());
// //assert(components_disjoint_set_size_.find(deepest_vertex) == components_disjoint_set_size_.end());
//
// components_disjoint_set_parent_[deepest_vertex] = deepest_vertex;
// components_disjoint_set_size_[deepest_vertex] = 1;
//}
template<class Real, unsigned D>
void FabTmtBlock<Real, D>::create_component(const AmrVertexId& deepest_vertex)
{
bool debug = false;
if (debug) fmt::print("Entered create_component, gid = {}, deepest_vertex = {}\n", gid, deepest_vertex);
set_original_deepest(deepest_vertex, deepest_vertex);
if (debug)
fmt::print("In create_component, gid = {}, deepest_vertex = {}, before emplace, size = {}\n", gid,
deepest_vertex, components_.size());
components_.emplace_back(deepest_vertex);
if (debug)
fmt::print("In create_component, gid = {}, deepest_vertex = {}, added to components, size = {}\n", gid,
deepest_vertex, components_.size());
// add_component_to_disjoint_sets(deepest_vertex);
}
template<class Real, unsigned D>
void FabTmtBlock<Real, D>::compute_original_connected_components(const VertexEdgesMap& vertex_to_outgoing_edges)
{
bool debug = false;
const auto& const_tree = current_merge_tree_;
if (debug) fmt::print("compute_original_connected_components called\n");
VertexNeighborMap component_nodes;
for(const auto& vert_neighb_pair : const_tree.nodes())
{
component_nodes.clear();
if (debug)
fmt::print("in compute_connected_component, gid = {} processing vertex = {}\n", gid,
vert_neighb_pair.first);
component_nodes[vert_neighb_pair.first] = vert_neighb_pair.second;
Neighbor u = vert_neighb_pair.second;
if (!original_deepest_computed(u->vertex))
{
if (debug) fmt::print("in compute_connected_compponent, gid = {}, deepest not computed, traversing\n", gid);
// nodes we traverse while going down,
// they all should get deepest node
std::vector<AmrVertexId> visited_neighbors;
Neighbor u_ = u;
Neighbor v = std::get<1>(u_->parent());
Neighbor s = std::get<0>(u_->parent());
visited_neighbors.push_back(u->vertex);
visited_neighbors.push_back(v->vertex);
visited_neighbors.push_back(s->vertex);
while(u_ != v and not original_deepest_computed(v->vertex))
{
visited_neighbors.push_back(u_->vertex);
visited_neighbors.push_back(v->vertex);
visited_neighbors.push_back(s->vertex);
u_ = v;
v = std::get<1>(u_->parent());
s = std::get<0>(u_->parent());
visited_neighbors.push_back(v->vertex);
visited_neighbors.push_back(s->vertex);
}
AmrVertexId deepest_vertex = (original_deepest_computed(v)) ? original_deepest(v) : v->vertex;
AmrEdgeContainer edges;
for(const AmrVertexId& v : visited_neighbors)
{
auto find_iter = vertex_to_outgoing_edges.find(v);
if (find_iter != vertex_to_outgoing_edges.end())
{
edges.insert(edges.end(), find_iter->second.begin(), find_iter->second.end());
}
}
// if (not original_deepest_computed(v))
// {
// if (debug) fmt::print("in compute_connected_compponent, gid = {}, creating new cc, deepest = {}\n", gid, deepest_vertex);
// create_component(deepest_vertex);
// }
for(const AmrVertexId& v : visited_neighbors)
{
if (debug)
fmt::print(
"in compute_connected_compponent, gid = {}, deepest = {}, setting to visited neighbor {}\n",
gid, deepest_vertex, v);
set_original_deepest(v, deepest_vertex);
}
}
}
//assert(std::accumulate(const_tree.nodes().cbegin(), const_tree.nodes().cend(), true,
// [this](const bool& prev, const typename VertexNeighborMap::value_type& vn) {
// return prev and this->original_deepest_computed(vn.second);
// }));
#ifdef AMR_MT_SEND_COMPONENTS
current_vertex_to_deepest_ = original_vertex_to_deepest_;
// copy nodes from local merge tree of block to merge trees of components
for (const auto& vertex_deepest_pair : original_vertex_to_deepest_)
{
TripletMergeTree& mt = find_component(vertex_deepest_pair.second).merge_tree_;
AmrVertexId u = vertex_deepest_pair.first;
Neighbor mt_n_u = const_tree.nodes().at(u);
Value val = mt_n_u->value;
//assert(u == mt_n_u->vertex);
AmrVertexId s = std::get<0>(mt_n_u->parent())->vertex;
AmrVertexId v = std::get<1>(mt_n_u->parent())->vertex;
Neighbor n_u, n_s, n_v;
n_u = mt.add_or_update(u, val);
n_s = mt.find_or_add(s, 0);
n_v = mt.find_or_add(v, 0);
mt.link(n_u, n_s, n_v);
}
#endif
for(const auto& vertex_deepest_pair : original_vertex_to_deepest_)
{
original_deepest_.insert(vertex_deepest_pair.second);
}
current_deepest_ = original_deepest_;
}
template<class Real, unsigned D>
void FabTmtBlock<Real, D>::compute_final_connected_components()
{
bool debug = false;
const auto& const_tree = current_merge_tree_;
if (debug) fmt::print("compute_final_connected_components called\n");
for(const auto& vert_neighb_pair : const_tree.nodes())
{
// debug = (vert_neighb_pair.second->vertex == reeber::AmrVertexId { 1, 32005});
if (debug)
fmt::print("in compute_final_connected_component, gid = {} processing vertex = {}\n", gid,
vert_neighb_pair.first);
Neighbor u = vert_neighb_pair.second;
if (!final_deepest_computed(u->vertex))
{
if (debug)
fmt::print("in compute_final_connected_compponent, gid = {}, deepest not computed, traversing\n", gid);
// nodes we traverse while going down,
// they all should get deepest node
std::vector<AmrVertexId> visited_neighbors;
Neighbor u_ = u;
Neighbor v = std::get<1>(u_->parent());
Neighbor s = std::get<0>(u_->parent());
visited_neighbors.push_back(u->vertex);
visited_neighbors.push_back(v->vertex);
visited_neighbors.push_back(s->vertex);
while(u_ != v and not final_deepest_computed(v->vertex))
{
// nodes we traverse while going down,
visited_neighbors.push_back(u_->vertex);
visited_neighbors.push_back(v->vertex);
visited_neighbors.push_back(s->vertex);
u_ = v;
v = std::get<1>(u_->parent());
s = std::get<0>(u_->parent());
visited_neighbors.push_back(v->vertex);
visited_neighbors.push_back(s->vertex);
}
AmrVertexId deepest_vertex = (final_deepest_computed(v)) ? final_deepest(v) : v->vertex;
if (debug)
fmt::print("in compute_final_connected_compponent, v = {}, deepest vertex = {}\n", v->vertex,
deepest_vertex);
if (not final_deepest_computed(v))
{
final_vertex_to_deepest_[deepest_vertex] = deepest_vertex;
}
for(const AmrVertexId& v : visited_neighbors)
{
if (debug)
fmt::print(
"in compute_final_connected_compponent, gid = {}, deepest = {}, setting to visited neighbor {}\n",
gid, deepest_vertex, v);
final_vertex_to_deepest_[v] = deepest_vertex;
}
}
}
}
template<class Real, unsigned D>
bool FabTmtBlock<Real, D>::edge_exists(const AmrEdge& e) const
{
return current_merge_tree_.contains(std::get<0>(e)) and current_merge_tree_.contains(std::get<1>(e));
}
template<class Real, unsigned D>
bool FabTmtBlock<Real, D>::edge_goes_out(const AmrEdge& e) const
{
return current_merge_tree_.contains(std::get<0>(e)) xor current_merge_tree_.contains(std::get<1>(e));
}
//template<class Real, unsigned D>
//bool FabTmtBlock<Real, D>::are_components_connected(const AmrVertexId& deepest_a, const AmrVertexId& deepest_b)
//{
// bool result = find_component_in_disjoint_sets(deepest_a) == find_component_in_disjoint_sets(deepest_b);
// // for debug - assume everything is connected
// return result;
//}
//template<class Real, unsigned D>
//bool FabTmtBlock<Real, D>::is_component_connected_to_any_internal(const FabTmtBlock::AmrVertexId& deepest)
//{
// for (const auto& cc : components_)
// if (are_components_connected(deepest, cc.root_))
// return true;
// // for debug - assume everything is connected
// //assert(false);
// return false;
//}
//template<class Real, unsigned D>
//r::AmrVertexId FabTmtBlock<Real, D>::find_component_in_disjoint_sets(AmrVertexId x)
//{
// bool debug = false;
// if (debug) fmt::print("Entered find_component_in_disjoint_sets, x = {}\n", x);
// while (components_disjoint_set_parent_.at(x) != x)
// {
// AmrVertexId next = components_disjoint_set_parent_[x];
// if (debug) fmt::print("in find_component_in_disjoint_sets, x = {}, next = {}\n", x, next);
// components_disjoint_set_parent_[x] = components_disjoint_set_parent_.at(next);
// x = next;
// }
// if (debug) fmt::print("Exiting find_component_in_disjoint_sets, x = {}\n", x);
// return x;
//}
//template<class Real, unsigned D>
//void FabTmtBlock<Real, D>::connect_components(const FabTmtBlock::AmrVertexId& deepest_a,
// const FabTmtBlock::AmrVertexId& deepest_b)
//{
// AmrVertexId a_root = find_component_in_disjoint_sets(deepest_a);
// AmrVertexId b_root = find_component_in_disjoint_sets(deepest_b);
//
// if (a_root == b_root)
// return;
//
// auto a_size = components_disjoint_set_size_.at(a_root);
// auto b_size = components_disjoint_set_size_.at(b_root);
// if (a_size < b_size)
// {
// std::swap(a_root, b_root);
// std::swap(a_size, b_size);
// }
//
// components_disjoint_set_parent_[b_root] = a_root;
// components_disjoint_set_size_[a_root] += b_size;
//}
template<class Real, unsigned D>
Real FabTmtBlock<Real, D>::scaling_factor() const
{
Real result = 1;
for(unsigned i = 0; i < D; ++i)
result /= refinement();
return result;
}
template<class Real, unsigned D>
int FabTmtBlock<Real, D>::is_done_simple(const std::vector<FabTmtBlock::AmrVertexId>& vertices_to_check)
{
// check that all edge outgoing from the current region
// do not start in any component of our original local tree
// bool debug = (gid == 0);
bool debug = false;
if (n_active_ == 0)
return 1;
if (debug)
fmt::print("Enter is_done_simple, gid = {}, #vertices = {}, round = {}\n",
gid, vertices_to_check.size(), round_);
std::set<AmrVertexId> cur_deepest_of_original_deepest;
for(const AmrVertexId v : original_deepest_)
{
if (current_merge_tree_.contains(v))
{
Neighbor nv = current_merge_tree_[v];
AmrVertexId cur_deepest = current_merge_tree_.find_deepest(nv)->vertex;
cur_deepest_of_original_deepest.insert(cur_deepest);
} else
{
fmt::print("ALARM is_done_simple, gid = {}, orginal deepst = {} not found in tree\n", gid, v);
throw std::runtime_error("Here");
}
}
if (debug)
fmt::print("is_done_simple, gid = {}, #vertices = {}, round = {}, cur_deepest_of_original_deepest = {}\n", gid,
vertices_to_check.size(), round_, cur_deepest_of_original_deepest.size());
for(const AmrVertexId& v : vertices_to_check)
{
Neighbor nv = current_merge_tree_[v];
AmrVertexId dnv = current_merge_tree_.find_deepest(nv)->vertex;
if (cur_deepest_of_original_deepest.count(dnv))
return 0;
}
if (debug) fmt::print("is_done_simple, gid = {}, returning 1\n", gid);
return 1;
}
template<class Real, unsigned D>
std::pair<Real, size_t> FabTmtBlock<Real, D>::get_local_stats() const
{
std::pair<Real, size_t> result{0, 0};
for(const auto& vertex_node_pair : get_merge_tree().nodes())
{
AmrVertexId vertex = vertex_node_pair.first;
Neighbor u = vertex_node_pair.second;
// ingore remains of degree 2 vertices in map
if (vertex != u->vertex)
continue;
// ignore non-local vertices
if (vertex.gid != gid)
continue;
result.second++;
result.first += u->value;
for(const auto& val_vertex_pair : u->vertices)
{
if (val_vertex_pair.second.gid != gid)
continue;
result.second++;
result.first += val_vertex_pair.first;
}
}
return result;
}
template<class Real, unsigned D>
void FabTmtBlock<Real, D>::compute_local_integral()
{
local_integral_.clear();
Real sf = scaling_factor();
const bool negate = negate_;
const auto& nodes = get_merge_tree().nodes();
for(const auto& vertex_node_pair : nodes)
{
AmrVertexId current_vertex = vertex_node_pair.first;
assert(current_vertex == vertex_node_pair.second->vertex);
// save only information about local vertices
if (current_vertex.gid != gid)
continue;
Node* current_node = vertex_node_pair.second;
AmrVertexId root = final_vertex_to_deepest_[current_vertex];
Real root_value = nodes.at(root)->value;
local_integral_[root] += sf * current_node->value;
for(const auto& value_vertex_pair : current_node->vertices)
{
assert(value_vertex_pair.second.gid == gid);
local_integral_[root] += sf * value_vertex_pair.first;
}
}
}
#ifdef AMR_MT_SEND_COMPONENTS
template<class Real, unsigned D>
std::vector<r::AmrVertexId> FabTmtBlock<Real, D>::get_current_deepest_vertices() const
{
std::set<AmrVertexId> result_set;
for (const auto& vertex_deepest_pair : current_vertex_to_deepest_)
{
result_set.insert(vertex_deepest_pair.second);
}
std::vector<AmrVertexId> result(result_set.begin(), result_set.end());
return result;
}
template<class Real, unsigned D>
typename FabTmtBlock<Real, D>::Component& FabTmtBlock<Real, D>::find_component(const AmrVertexId& deepest_vertex)
{
for (Component& cc : components_)
{
if (cc.root_ == deepest_vertex)
{
return cc;
}
}
throw std::runtime_error("Connnected component not found");
}
template<class Real, unsigned D>
int FabTmtBlock<Real, D>::are_all_components_done() const
{
bool debug = false;
if (debug) fmt::print("are_all_components_done, gid = {}\n", gid);
for (const Component& c : components_)
if (not c.is_done())
return 0;
if (debug) fmt::print("are_all_components_done, gid = {}, returning 1\n", gid);
return 1;
}
#endif
template<class Real, unsigned D>
void FabTmtBlock<Real, D>::save(const void* b, diy::BinaryBuffer& bb)
{
const FabTmtBlock* block = static_cast<const FabTmtBlock*>(b);
diy::save(bb, block->gid);
// diy::save(bb, block->local_);
diy::save(bb, block->current_merge_tree_);
diy::save(bb, block->original_tree_);
// diy::save(bb, block->components_);
diy::save(bb, block->domain_);
diy::save(bb, block->initial_edges_);
// diy::save(bb, block->gid_to_outgoing_edges_);
diy::save(bb, block->new_receivers_);
diy::save(bb, block->processed_receivers_);
diy::save(bb, block->original_link_gids_);
diy::save(bb, block->negate_);
diy::save(bb, block->original_vertex_to_deepest_);
// diy::save(bb, block->components_disjoint_set_parent_);
// diy::save(bb, block->components_disjoint_set_size_);
diy::save(bb, block->round_);
}
template<class Real, unsigned D>
void FabTmtBlock<Real, D>::load(void* b, diy::BinaryBuffer& bb)
{
FabTmtBlock* block = static_cast<FabTmtBlock*>(b);
diy::load(bb, block->gid);
// diy::load(bb, block->local_);
diy::load(bb, block->current_merge_tree_);
diy::load(bb, block->original_tree_);
// diy::load(bb, block->components_);
diy::load(bb, block->domain_);
diy::load(bb, block->initial_edges_);
// diy::load(bb, block->gid_to_outgoing_edges_);
diy::load(bb, block->new_receivers_);
diy::load(bb, block->processed_receivers_);
diy::load(bb, block->original_link_gids_);
diy::load(bb, block->negate_);
diy::load(bb, block->original_vertex_to_deepest_);
// diy::load(bb, block->components_disjoint_set_parent_);
// diy::load(bb, block->components_disjoint_set_size_);
diy::load(bb, block->round_);
}
| 36.58229 | 202 | 0.600015 | [
"vector",
"transform"
] |
fc32b2de04d0fae64e6307be69687332751f4fed | 6,626 | cpp | C++ | robotarm_grasping/src/VisionManager.cpp | rishabh1b/SimpleRobotArmGrasping | 00c9f29b970c0399d535cdb39f4b3f1b327c344c | [
"BSD-3-Clause"
] | 17 | 2017-12-21T14:24:29.000Z | 2022-03-31T02:09:06.000Z | robotarm_grasping/src/VisionManager.cpp | rishabh1b/SimpleRobotArmGrasping | 00c9f29b970c0399d535cdb39f4b3f1b327c344c | [
"BSD-3-Clause"
] | null | null | null | robotarm_grasping/src/VisionManager.cpp | rishabh1b/SimpleRobotArmGrasping | 00c9f29b970c0399d535cdb39f4b3f1b327c344c | [
"BSD-3-Clause"
] | 6 | 2019-04-04T02:08:44.000Z | 2021-08-24T03:19:10.000Z | // BSD 3-Clause License
// Copyright (c) 2017, Rishabh Biyani
// 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 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.
/**
* @file VisionManger.cpp Class Implementations to detect the object
* and return the co-ordinates in the camera frame
* @author rishabh1b(Rishabh Biyani)
* @copyright BSD 3-Clause License (c) Rishabh Biyani 2017
*/
#include "robotarm_grasping/VisionManager.h"
VisionManager::VisionManager(float length, float breadth) {
this->table_length = length;
this->table_breadth = breadth;
pixel_size_identified = false;
}
void VisionManager::get2DLocation(cv::Mat img, float&x, float& y) {
this->curr_img = img;
img_centre_x_ = img.rows / 2;
img_centre_y_ = img.cols / 2;
if (!pixel_size_identified) {
detectTable();
}
detect2DObject(x, y);
convertToMM(x, y);
}
void VisionManager::detectTable() {
// Extract Table from the image and assign values to pixel_per_mm fields
cv::Mat RGB[3];
cv::Mat image = curr_img.clone();
split(image, RGB);
cv::Mat gray_image_red = RGB[2];
cv::Mat gray_image_green = RGB[1];
cv::Mat denoiseImage;
cv::medianBlur(gray_image_red, denoiseImage, 3);
// Threshold the Image
cv::Mat binaryImage = denoiseImage;
for (int i = 0; i < binaryImage.rows; i++) {
for (int j = 0; j < binaryImage.cols; j++) {
int editValue = binaryImage.at<uchar>(i, j);
int editValue2 = gray_image_green.at<uchar>(i, j);
if ((editValue > 34) && (editValue < 50) && (editValue2 > 18) && (editValue2 < 30)) { // check whether value is within range.
binaryImage.at<uchar>(i, j) = 255;
} else {
binaryImage.at<uchar>(i, j) = 0;
}
}
}
dilate(binaryImage, binaryImage, cv::Mat());
// Get the centroid of the of the blob
std::vector<cv::Point> nonZeroPoints;
cv::findNonZero(binaryImage, nonZeroPoints);
cv::Rect bbox = cv::boundingRect(nonZeroPoints);
cv::Point pt;
pt.x = bbox.x + bbox.width / 2;
pt.y = bbox.y + bbox.height / 2;
cv::circle(image, pt, 2, cv::Scalar(0, 0, 255), -1, 8);
// Update pixels_per_mm fields
pixels_permm_y = bbox.height / table_length;
pixels_permm_x = bbox.width / table_breadth;
// Test the conversion values
std::cout << "Pixels in y" << pixels_permm_y << std::endl;
std::cout << "Pixels in x" << pixels_permm_x << std::endl;
// Update the boolean to indicate measurement has been received
pixel_size_identified = true;
// Draw Contours - For Debugging
std::vector<std::vector<cv::Point> > contours;
std::vector<cv::Vec4i> hierarchy;
cv::findContours(binaryImage, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, cv::Point(0, 0) );
for (int i = 0; i < contours.size(); i++) {
cv::Scalar color = cv::Scalar(255, 0, 0);
cv::drawContours(image, contours, i, color, 1, 8, hierarchy, 0, cv::Point() );
}
// cv::namedWindow("Table Detection", cv::WINDOW_AUTOSIZE);
// cv::imshow("Table Detection", image);
}
void VisionManager::detect2DObject(float& pixel_x, float& pixel_y) {
// Implement Color Thresholding and contour findings to get the location of object to be grasped in 2D
cv::Mat image, gray_image_green;
cv::Mat RGB[3];
image = curr_img.clone();
cv::split(image, RGB);
gray_image_green = RGB[1];
// Denoise the Image
cv::Mat denoiseImage;
cv::medianBlur(gray_image_green, denoiseImage, 3);
// Threshold the Image
cv::Mat binaryImage;
cv::threshold(denoiseImage, binaryImage, 160, 255, cv::THRESH_BINARY);
// Get the centroid of the of the blob
std::vector<cv::Point> nonZeroPoints;
cv::findNonZero(binaryImage, nonZeroPoints);
cv::Rect bbox = cv::boundingRect(nonZeroPoints);
cv::Point pt;
pixel_x = bbox.x + bbox.width / 2;
pixel_y = bbox.y + bbox.height / 2;
// For Drawing
pt.x = bbox.x + bbox.width / 2;
pt.y = bbox.y + bbox.height / 2;
cv::circle(image, pt, 2, cv::Scalar(0, 0, 255), -1, 8);
// Draw Contours
std::vector<std::vector<cv::Point> > contours;
std::vector<cv::Vec4i> hierarchy;
cv::findContours(binaryImage, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, cv::Point(0, 0));
for ( int i = 0; i < contours.size(); i++ ) {
cv::Scalar color = cv::Scalar(255, 0, 0);
cv::drawContours(image, contours, i, color, 1, 8, hierarchy, 0, cv::Point());
}
// cv::namedWindow("Centre point", cv::WINDOW_AUTOSIZE);
// cv::imshow("Centre point", image);
}
void VisionManager::convertToMM(float& x, float& y) {
// Convert from pixel to world co-ordinates in the camera frame
x = (x - img_centre_x_) / pixels_permm_x;
y = (y - img_centre_y_) / pixels_permm_y;
}
// Temporary Main Function for testing- This should go away later
/*
int main(int argc, char** argv ) {
if ( argc != 2 )
{
printf("usage: VisionManager <Image_Path>\n");
return -1;
}
cv::Mat image;
image = cv::imread( argv[1], 1 );
if ( !image.data )
{
printf("No image data \n");
return -1;
}
float length = 1;
float breadth = 0.6;
float obj_x, obj_y;
VisionManager vm(length, breadth);
vm.get2DLocation(image, obj_x, obj_y);
std::cout<< " X-Co-ordinate in Camera Frame :" << obj_x << std::endl;
std::cout<< " Y-Co-ordinate in Camera Frame :" << obj_y << std::endl;
cv::waitKey(0);
}*/
| 32.80198 | 128 | 0.694537 | [
"object",
"vector"
] |
fc3d8ac6aeed1ebb08364035aa13463b42974177 | 7,605 | cpp | C++ | lkRay/Renderer/Renderer.cpp | lookeypl/lkRay | c12d87add95f5958d77a8a8a683fc954837b6c60 | [
"WTFPL"
] | null | null | null | lkRay/Renderer/Renderer.cpp | lookeypl/lkRay | c12d87add95f5958d77a8a8a683fc954837b6c60 | [
"WTFPL"
] | null | null | null | lkRay/Renderer/Renderer.cpp | lookeypl/lkRay | c12d87add95f5958d77a8a8a683fc954837b6c60 | [
"WTFPL"
] | null | null | null | #include "PCH.hpp"
#include "Renderer.hpp"
#include "Geometry/Primitive.hpp"
#include "Distribution/Function.hpp"
#include "Material/Material.hpp"
#include <lkCommon/Utils/Logger.hpp>
#include <lkCommon/Utils/Pixel.hpp>
#include <lkCommon/Math/Utilities.hpp>
#include <lkCommon/Math/Random.hpp>
#include "SurfaceDistribution.hpp"
namespace {
const uint32_t PIXELS_PER_THREAD = 16;
} // namespace
namespace lkRay {
namespace Renderer {
Renderer::Renderer(const uint32_t renderWidth, const uint32_t renderHeight, const uint32_t maxRayDepth, const uint32_t threadCount)
: mImageBuffer(renderWidth, renderHeight)
, mOutputImage(renderWidth, renderHeight)
, mMaxRayDepth(maxRayDepth)
, mThreadPool(threadCount)
, mThreadData(mThreadPool.GetWorkerThreadCount())
, mSampleCount(0)
, mExposure(1.0f)
{
for (uint32_t tid = 0; tid < mThreadPool.GetWorkerThreadCount(); ++tid)
{
mThreadData[tid].rngState = LKCOMMON_XORSHIFT_INITIAL_STATE;
mThreadPool.SetUserPayloadForThread(tid, &mThreadData[tid]);
}
}
lkCommon::Math::Vector4 Renderer::LerpPoints(const lkCommon::Math::Vector4& p1, const lkCommon::Math::Vector4& p2, float factor)
{
return p1 * (1.0f - factor) + p2 * factor;
}
lkCommon::Utils::PixelFloat4 Renderer::PostProcess(const lkCommon::Utils::PixelFloat4& in)
{
// adjust exposure of raw pixel
lkCommon::Utils::PixelFloat4 out = in * mExposure;
// Hejl & Burgess-Dawson gamma correction & tone mapping
lkCommon::Utils::PixelFloat4 tempPixel = lkCommon::Utils::MaxPixel(lkCommon::Utils::PixelFloat4(0.0f), out - 0.004f);
out = (tempPixel * (6.2f * tempPixel + 0.5f)) / (tempPixel * (6.2f * tempPixel + 1.7f) + 0.06f);
return out;
}
lkCommon::Utils::PixelFloat4 Renderer::CalculateLightIntensity(PathContext& context, uint32_t rayDepth)
{
if (rayDepth > mMaxRayDepth)
{
return lkCommon::Utils::PixelFloat4(0.0f);
}
const Scene::Scene& scene = context.scene;
lkCommon::Utils::PixelFloat4 resultColor;
lkCommon::Utils::PixelFloat4 lightContribution;
lkCommon::Utils::PixelFloat4 surfaceSample;
lkCommon::Math::Vector4 reflectedDir;
RayCollision collision = scene.TestCollision(context.ray);
if (collision.mHitID == -1)
{
return scene.GetAmbient();
}
collision.mAllocator = &context.threadData.allocator;
scene.GetPrimitives()[collision.mHitID]->GetMaterial()->PopulateDistributionFunctions(collision);
bool hasDiffuse = collision.mSurfaceDistribution->Sample(Types::Distribution::DIFFUSE | Types::Distribution::REFLECTION,
context, collision, surfaceSample, reflectedDir);
if (hasDiffuse)
{
context.ray.mOrigin = collision.mPoint;
context.ray.mDirection = reflectedDir;
// diffuse surfaces weaken our rays - adjust beta
const float dot = context.ray.mDirection.Dot(collision.mNormal);
lkCommon::Utils::PixelFloat4 incoming = CalculateLightIntensity(context, rayDepth + 1);
resultColor += surfaceSample * incoming * dot;
}
bool hasSpecular = collision.mSurfaceDistribution->Sample(Types::Distribution::SPECULAR | Types::Distribution::REFLECTION,
context, collision, surfaceSample, reflectedDir);
if (hasSpecular)
{
context.ray.mOrigin = collision.mPoint;
context.ray.mDirection = reflectedDir;
resultColor += CalculateLightIntensity(context, rayDepth + 1);
}
bool hasEmissive = collision.mSurfaceDistribution->Sample(Types::Distribution::EMISSIVE,
context, collision, surfaceSample, reflectedDir);
if (hasEmissive)
{
resultColor += surfaceSample;
}
return resultColor;
}
void Renderer::DrawThread(lkCommon::Utils::ThreadPayload& payload, const Scene::Scene& scene, const Scene::Camera& camera, uint32_t widthPos, uint32_t heightPos, uint32_t xCount, uint32_t yCount)
{
LKCOMMON_ASSERT(payload.userData != nullptr, "Thread payload does not contain ArenaAllocator");
ThreadData* threadData = reinterpret_cast<ThreadData*>(payload.userData);
for (uint32_t x = widthPos; x < widthPos + xCount; ++x)
{
for (uint32_t y = heightPos; y < heightPos + yCount; ++y)
{
// don't go out of bounds
if (x >= mImageBuffer.GetWidth() || y >= mImageBuffer.GetHeight())
continue;
// calculate where our ray will shoot
float xFactor = static_cast<float>(x) / static_cast<float>(mImageBuffer.GetWidth());
float yFactor = static_cast<float>(y) / static_cast<float>(mImageBuffer.GetHeight());
// affect factors by random shift to provide pseudo AA
xFactor += (lkCommon::Math::Random::Xorshift(threadData->rngState) - 0.5f) * mXStep;
yFactor += (lkCommon::Math::Random::Xorshift(threadData->rngState) - 0.5f) * mYStep;
lkCommon::Math::Vector4 xLerpTop = LerpPoints(
camera.GetCameraCorner(Scene::Camera::Corners::TOP_L),
camera.GetCameraCorner(Scene::Camera::Corners::TOP_R),
xFactor
);
lkCommon::Math::Vector4 xLerpBot = LerpPoints(
camera.GetCameraCorner(Scene::Camera::Corners::BOT_L),
camera.GetCameraCorner(Scene::Camera::Corners::BOT_R),
xFactor
);
lkCommon::Math::Vector4 rayTarget(LerpPoints(xLerpTop, xLerpBot, yFactor));
lkCommon::Math::Vector4 rayDir((rayTarget - camera.GetPosition()).Normalize());
// form a context and start calculating
PathContext ctx(*threadData, scene, Geometry::Ray(camera.GetPosition(), rayDir));
lkCommon::Utils::PixelFloat4 pixel;
mImageBuffer.GetPixel(x, y, pixel);
// get the value
pixel += CalculateLightIntensity(ctx, 0);
// save current pixel value for later
mImageBuffer.SetPixel(x, y, pixel);
// divide by sample count and post-process for output
pixel /= static_cast<float>(mSampleCount);
mOutputImage.SetPixel(x, y, PostProcess(pixel));
}
}
}
void Renderer::Draw(const Scene::Scene& scene, const Scene::Camera& camera)
{
mSampleCount++;
mXStep = 2.0f / static_cast<float>(mImageBuffer.GetWidth());
mYStep = 2.0f / static_cast<float>(mImageBuffer.GetHeight());
for (uint32_t x = 0; x < mOutputImage.GetWidth(); x += PIXELS_PER_THREAD)
{
for (uint32_t y = 0; y < mOutputImage.GetHeight(); y += PIXELS_PER_THREAD)
{
mThreadPool.AddTask(std::bind(&Renderer::DrawThread, this, std::placeholders::_1,
scene, camera, x, y, PIXELS_PER_THREAD, PIXELS_PER_THREAD));
}
}
mThreadPool.WaitForTasks();
for (auto& td: mThreadData)
{
td.allocator.CollectGarbage();
}
}
bool Renderer::ResizeOutput(const uint32_t width, const uint32_t height)
{
if (width == 0 || height == 0)
{
LOGE("Output dimensions cannot be equal to zero");
return false;
}
if (!mImageBuffer.Resize(width, height))
{
LOGE("Failed to resize output image");
return false;
}
if (!mOutputImage.Resize(width, height))
{
LOGE("Failed to resize output image");
return false;
}
ResetImageBuffer();
return true;
}
} // namespace Renderer
} // namespace lkRay
| 34.726027 | 195 | 0.646548 | [
"geometry"
] |
fc3e485334410a5fe4daf3f9ffe2b34706fc4038 | 22,508 | cc | C++ | src/google_cloud_debugger/google_cloud_debugger_lib/stack_frame_collection.cc | emzeq/google-cloud-dotnet-debugger | 8eafe29b40582ebf735186b574af4d544158033e | [
"Apache-2.0"
] | 12 | 2018-06-05T04:06:26.000Z | 2021-10-09T14:14:18.000Z | src/google_cloud_debugger/google_cloud_debugger_lib/stack_frame_collection.cc | emzeq/google-cloud-dotnet-debugger | 8eafe29b40582ebf735186b574af4d544158033e | [
"Apache-2.0"
] | 47 | 2018-06-01T20:26:22.000Z | 2021-03-20T14:26:21.000Z | src/google_cloud_debugger/google_cloud_debugger_lib/stack_frame_collection.cc | emzeq/google-cloud-dotnet-debugger | 8eafe29b40582ebf735186b574af4d544158033e | [
"Apache-2.0"
] | 14 | 2018-06-04T17:12:25.000Z | 2021-10-09T14:14:04.000Z | // Copyright 2017 Google Inc. 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 "stack_frame_collection.h"
#include <algorithm>
#include <iostream>
#include <string>
#include "dbg_breakpoint.h"
#include "expression_util.h"
#include "i_cor_debug_helper.h"
#include "i_dbg_object_factory.h"
#include "i_eval_coordinator.h"
using google::cloud::diagnostics::debug::Breakpoint;
using google::cloud::diagnostics::debug::SourceLocation;
using google::cloud::diagnostics::debug::StackFrame;
using google::cloud::diagnostics::debug::Variable;
using google_cloud_debugger_portable_pdb::LocalConstantInfo;
using google_cloud_debugger_portable_pdb::LocalVariableInfo;
using google_cloud_debugger_portable_pdb::SequencePoint;
using std::cerr;
using std::cout;
using std::max;
using std::string;
using std::vector;
namespace google_cloud_debugger {
StackFrameCollection::StackFrameCollection(
std::shared_ptr<ICorDebugHelper> debug_helper,
std::shared_ptr<IDbgObjectFactory> obj_factory)
: debug_helper_(debug_helper), obj_factory_(obj_factory) {}
HRESULT StackFrameCollection::ProcessBreakpoint(
const vector<
std::shared_ptr<google_cloud_debugger_portable_pdb::IPortablePdbFile>>
&pdb_files,
DbgBreakpoint *breakpoint, IEvalCoordinator *eval_coordinator) {
if (!breakpoint) {
std::cerr << "DbgBreakpoint is null.";
return E_INVALIDARG;
}
if (!eval_coordinator) {
std::cerr << "Eval coordinator is null.";
return E_INVALIDARG;
}
HRESULT hr;
// If there are conditions or expressions, handle them first.
// TODO(quoct): Add expressions handling.
const std::string &breakpoint_condition = breakpoint->GetCondition();
if (!breakpoint_condition.empty()) {
hr = EvaluateBreakpointCondition(breakpoint, eval_coordinator, pdb_files);
if (FAILED(hr)) {
breakpoint->WriteError("Failed to evaluate breakpoint condition " +
breakpoint_condition);
return hr;
}
if (!breakpoint->GetEvaluatedCondition()) {
return S_FALSE;
}
}
if (!breakpoint->GetExpressions().empty()) {
hr = ProcessExpressions(breakpoint, eval_coordinator, pdb_files);
if (FAILED(hr)) {
breakpoint->WriteError("Failed to evaluate breakpoint expressions.");
return hr;
}
}
return WalkStackAndProcessStackFrame(eval_coordinator, pdb_files);
}
HRESULT StackFrameCollection::PopulateStackFrames(
Breakpoint *breakpoint, IEvalCoordinator *eval_coordinator) {
if (!breakpoint) {
std::cerr << "Null breakpoint.";
return E_INVALIDARG;
}
if (!eval_coordinator) {
std::cerr << "Null eval coordinator.";
return E_INVALIDARG;
}
HRESULT hr = S_OK;
// Gives the first frame half available kb in the breakpoint.
int frame_max_size =
(DbgBreakpoint::kMaximumBreakpointSize - breakpoint->ByteSize()) / 2;
int processed_il_frames_so_far = 0;
for (auto &&dbg_stack_frame : stack_frames_) {
// If this is the last processed IL frame, just gives it the rest
// of the size available.
if (processed_il_frames_so_far == number_of_processed_il_frames_ - 1) {
frame_max_size =
DbgBreakpoint::kMaximumBreakpointSize - breakpoint->ByteSize();
}
StackFrame *frame = breakpoint->add_stack_frames();
// If dbg_stack_frame is an empty stack frame, just says it's undebuggable.
if (dbg_stack_frame->IsEmpty()) {
frame->set_method_name("Undebuggable code.");
continue;
}
frame->set_method_name(dbg_stack_frame->GetShortModuleName() + "!" +
dbg_stack_frame->GetClass() + "." +
dbg_stack_frame->GetMethod());
SourceLocation *frame_location = frame->mutable_location();
if (!frame_location) {
std::cerr << "Mutable location returns null.";
continue;
}
frame_location->set_line(dbg_stack_frame->GetLineNumber());
frame_location->set_path(dbg_stack_frame->GetFile());
hr = dbg_stack_frame->PopulateStackFrame(frame, frame_max_size,
eval_coordinator);
if (FAILED(hr)) {
return hr;
}
if (dbg_stack_frame->IsProcessedIlFrame()) {
++processed_il_frames_so_far;
}
if (breakpoint->ByteSize() > DbgBreakpoint::kMaximumBreakpointSize) {
break;
}
// Updates frame_max_size to half of whatever is left.
frame_max_size =
(DbgBreakpoint::kMaximumBreakpointSize - breakpoint->ByteSize()) / 2;
}
return S_OK;
}
HRESULT StackFrameCollection::PopulateAsyncStackFrameInfo(
DbgStackFrame *async_frame, ICorDebugStackWalk *stack_walk,
const std::vector<
std::shared_ptr<google_cloud_debugger_portable_pdb::IPortablePdbFile>>
&parsed_pdb_files) {
HRESULT hr;
// To get to the stack frame with the actual method information,
// we have to step through the stack twice.
for (int i = 0; i < 2; ++i) {
hr = stack_walk->Next();
if (FAILED(hr)) {
cerr << "Failed to get stack frame's information.";
return hr;
}
}
CComPtr<ICorDebugFrame> real_method_frame;
hr = stack_walk->GetFrame(&real_method_frame);
if (hr == S_FALSE) {
cerr << "Failed to get the stack after async method.";
return E_FAIL;
}
std::shared_ptr<DbgStackFrame> real_method_stack_frame(
new DbgStackFrame(debug_helper_, obj_factory_));
hr = PopulateDbgStackFrameHelper(parsed_pdb_files, real_method_frame,
real_method_stack_frame.get(), false);
if (FAILED(hr)) {
cerr << "Failed to get stack frame's information.";
return hr;
}
async_frame->SetClass(real_method_stack_frame->GetClass());
async_frame->SetModuleName(real_method_stack_frame->GetModule());
async_frame->SetMethod(real_method_stack_frame->GetMethod());
async_frame->SetClassToken(real_method_stack_frame->GetClassToken());
return S_OK;
}
HRESULT StackFrameCollection::PopulateLocalVarsAndMethodArgs(
mdMethodDef target_function_token, DbgStackFrame *dbg_stack_frame,
ICorDebugILFrame *il_frame, IMetaDataImport *metadata_import,
google_cloud_debugger_portable_pdb::IPortablePdbFile *pdb_file) {
if (!dbg_stack_frame || !il_frame || !pdb_file) {
return E_INVALIDARG;
}
HRESULT hr;
// Retrieves the IP offset in the function that corresponds to this stack
// frame.
ULONG32 ip_offset;
CorDebugMappingResult mapping_result;
hr = il_frame->GetIP(&ip_offset, &mapping_result);
if (FAILED(hr)) {
cerr << "Failed to get instruction pointer offset from ICorDebugFrame.";
return hr;
}
// Can't show this stack frame as the mapping is not good.
if (mapping_result == CorDebugMappingResult::MAPPING_NO_INFO ||
mapping_result == CorDebugMappingResult::MAPPING_UNMAPPED_ADDRESS) {
return S_FALSE;
}
// Loops through all methods in all the documents of the pdb file to find
// a MethodInfo object that corresponds with the method at this breakpoint.
for (auto &&document_index : pdb_file->GetDocumentIndexTable()) {
for (auto &&method : document_index->GetMethods()) {
PCCOR_SIGNATURE current_method_signature = 0;
ULONG current_method_virtual_addr = 0;
mdTypeDef type_def = 0;
ULONG method_name_length = 0;
DWORD flags1 = 0;
ULONG signature_blob;
DWORD flags2 = 0;
hr = metadata_import->GetMethodProps(
method.method_def, &type_def, nullptr, 0, &method_name_length,
&flags1, ¤t_method_signature, &signature_blob,
¤t_method_virtual_addr, &flags2);
if (FAILED(hr)) {
cerr << "Failed to extract method info from method "
<< method.method_def;
return hr;
}
// Checks that the virtual address of this method matches the one of the
// stack frame.
if (current_method_virtual_addr !=
dbg_stack_frame->GetFuncVirtualAddr()) {
continue;
}
// Sets the file path since we know we are in the correct function.
dbg_stack_frame->SetFile(document_index->GetFilePath());
long matching_sequence_point_position = -1;
// We find the first non-hidden sequence point that is just larger than
// the ip offset.
for (long index = 0; index < method.sequence_points.size(); index++) {
if (!method.sequence_points[index].is_hidden &&
method.sequence_points[index].il_offset <= ip_offset) {
matching_sequence_point_position =
max(matching_sequence_point_position, index);
}
}
// If we find the matching sequence point, populates the list of local
// variables in dbg_stack_frame from the local variable's vector of the
// matching sequence point.
if (matching_sequence_point_position != -1) {
SequencePoint sequence_point =
method.sequence_points[matching_sequence_point_position];
dbg_stack_frame->SetLineNumber(sequence_point.start_line);
vector<LocalVariableInfo> local_variables;
vector<LocalConstantInfo> local_constants;
for (auto &&local_scope : method.local_scope) {
if (local_scope.start_offset > sequence_point.il_offset ||
local_scope.start_offset + local_scope.length <
sequence_point.il_offset) {
continue;
}
local_variables.insert(local_variables.end(),
local_scope.local_variables.begin(),
local_scope.local_variables.end());
local_constants.insert(local_constants.end(),
local_scope.local_constants.begin(),
local_scope.local_constants.end());
}
hr = dbg_stack_frame->Initialize(il_frame, local_variables,
local_constants, target_function_token,
metadata_import);
}
return S_OK;
}
}
return S_OK;
}
HRESULT StackFrameCollection::PopulateModuleClassAndFunctionName(
DbgStackFrame *dbg_stack_frame, mdMethodDef function_token,
IMetaDataImport *metadata_import) {
if (!dbg_stack_frame || !metadata_import) {
return E_INVALIDARG;
}
HRESULT hr;
mdTypeDef type_def = 0;
ULONG method_name_length = 0;
DWORD flags1 = 0;
ULONG signature_blob = 0;
ULONG target_method_virtual_addr = 0;
DWORD flags2 = 0;
PCCOR_SIGNATURE target_method_signature = 0;
// Retrieves the length of the name of the method that this stack frame
// is at.
hr = metadata_import->GetMethodProps(
function_token, &type_def, nullptr, 0, &method_name_length, &flags1,
&target_method_signature, &signature_blob, &target_method_virtual_addr,
&flags2);
if (FAILED(hr)) {
cerr << "Failed to get length of name of method for stack frame.";
return hr;
}
std::vector<WCHAR> method_name(method_name_length, 0);
// Retrieves the name of the method that this stack frame is at.
hr = metadata_import->GetMethodProps(
function_token, &type_def, method_name.data(), method_name.size(),
&method_name_length, &flags1, &target_method_signature, &signature_blob,
&target_method_virtual_addr, &flags2);
if (FAILED(hr)) {
cerr << "Failed to get name of method for stack frame.";
return hr;
}
// Retrieves the class name.
// TODO(quoct): Cache the class name in MethodInfo method.
mdToken extends_token;
DWORD class_flags;
ULONG class_name_length;
hr = metadata_import->GetTypeDefProps(
type_def, nullptr, 0, &class_name_length, &class_flags, &extends_token);
if (FAILED(hr)) {
cerr << "Failed to get length of name of class type for stack frame.";
return hr;
}
std::vector<WCHAR> class_name(class_name_length, 0);
hr = metadata_import->GetTypeDefProps(type_def, class_name.data(),
class_name.size(), &class_name_length,
&class_flags, &extends_token);
if (FAILED(hr)) {
cerr << "Failed to get name of class type for stack frame.";
return hr;
}
// Even if we cannot get variables, we should still report
// method and class name of this frame.
dbg_stack_frame->SetMethod(method_name);
dbg_stack_frame->SetClass(class_name);
dbg_stack_frame->SetClassToken(type_def);
dbg_stack_frame->SetFuncVirtualAddr(target_method_virtual_addr);
return S_OK;
}
HRESULT StackFrameCollection::WalkStackAndProcessStackFrame(
IEvalCoordinator *eval_coordinator,
const std::vector<
std::shared_ptr<google_cloud_debugger_portable_pdb::IPortablePdbFile>>
&parsed_pdb_files) {
if (stack_walked_) {
return S_OK;
}
CComPtr<ICorDebugStackWalk> debug_stack_walk;
CComPtr<ICorDebugFrame> frame;
int il_frame_parsed_so_far = 0;
int frame_parsed_so_far = 0;
HRESULT hr = eval_coordinator->CreateStackWalk(&debug_stack_walk);
if (FAILED(hr)) {
cerr << "Failed to create stack walk.";
return hr;
}
// Skips the first stack if it is already processed.
if (first_stack_) {
stack_frames_.push_back(first_stack_);
++frame_parsed_so_far;
if (first_stack_->IsProcessedIlFrame()) {
++il_frame_parsed_so_far;
}
int stack_to_skip = first_stack_->IsAsyncMethod() ? 3 : 1;
for (int i = 0; i < stack_to_skip; ++i) {
hr = debug_stack_walk->Next();
}
}
// Walks through the stack and populates stack_frames_ vector.
while (SUCCEEDED(hr)) {
// Don't parse too many stack frames.
if (frame_parsed_so_far >= kMaximumStackFrames) {
stack_walked_ = true;
return S_OK;
}
hr = debug_stack_walk->GetFrame(&frame);
// No more stacks.
if (hr == S_FALSE) {
stack_walked_ = true;
return S_OK;
}
if (FAILED(hr)) {
cerr << "Failed to get active frame.";
return hr;
}
// Do not process too many IL frames to minimize breakpoint size.
bool process_il_frame =
il_frame_parsed_so_far < kMaximumStackFramesWithVariables;
std::shared_ptr<DbgStackFrame> stack_frame(
new DbgStackFrame(debug_helper_, obj_factory_));
hr = PopulateDbgStackFrameHelper(parsed_pdb_files, frame, stack_frame.get(),
process_il_frame);
if (FAILED(hr)) {
cerr << "Failed to process stack frame.";
return hr;
}
++frame_parsed_so_far;
if (stack_frame->IsProcessedIlFrame()) {
++il_frame_parsed_so_far;
}
// If this is an async frame, the method name would be something like
// <RealMethodName>d__18.MoveNext. PopulateAsyncStackFrameInfo
// will populate stack_frame with the correct method name and class token.
if (stack_frame->IsAsyncMethod()) {
hr = PopulateAsyncStackFrameInfo(stack_frame.get(), debug_stack_walk,
parsed_pdb_files);
if (FAILED(hr)) {
cerr << "Failed to get async stack frame's information.";
return hr;
}
}
stack_frames_.push_back(std::move(stack_frame));
hr = debug_stack_walk->Next();
}
if (FAILED(hr)) {
cerr << "Failed to get stack frame's information.";
}
stack_walked_ = true;
return hr;
}
HRESULT StackFrameCollection::EvaluateBreakpointCondition(
DbgBreakpoint *breakpoint, IEvalCoordinator *eval_coordinator,
const std::vector<
std::shared_ptr<google_cloud_debugger_portable_pdb::IPortablePdbFile>>
&parsed_pdb_files) {
HRESULT hr = ProcessFirstStack(eval_coordinator, parsed_pdb_files);
if (FAILED(hr)) {
std::cerr << "Failed to process the first stack.";
return hr;
}
if (first_stack_->IsEmpty() || !first_stack_->IsProcessedIlFrame()) {
std::cerr << "Conditional breakpoint are not "
<< "supported on non-IL frame.";
return E_NOTIMPL;
}
return breakpoint->EvaluateCondition(first_stack_.get(), eval_coordinator,
obj_factory_.get());
}
HRESULT StackFrameCollection::ProcessExpressions(
DbgBreakpoint *breakpoint, IEvalCoordinator *eval_coordinator,
const std::vector<
std::shared_ptr<google_cloud_debugger_portable_pdb::IPortablePdbFile>>
&parsed_pdb_files) {
HRESULT hr = ProcessFirstStack(eval_coordinator, parsed_pdb_files);
if (FAILED(hr)) {
std::cerr << "Failed to process the first stack.";
return hr;
}
if (first_stack_->IsEmpty() || !first_stack_->IsProcessedIlFrame()) {
std::cerr << "Expressions are not "
<< "supported on non-IL frame.";
return E_NOTIMPL;
}
return breakpoint->EvaluateExpressions(first_stack_.get(), eval_coordinator,
obj_factory_.get());
}
HRESULT StackFrameCollection::ProcessFirstStack(
IEvalCoordinator *eval_coordinator,
const std::vector<
std::shared_ptr<google_cloud_debugger_portable_pdb::IPortablePdbFile>>
&parsed_pdb_files) {
if (first_stack_) {
return S_OK;
}
CComPtr<ICorDebugThread> debug_thread;
HRESULT hr = eval_coordinator->GetActiveDebugThread(&debug_thread);
if (FAILED(hr)) {
std::cerr << "Failed to get active thread.";
return hr;
}
CComPtr<ICorDebugFrame> debug_frame;
hr = debug_thread->GetActiveFrame(&debug_frame);
if (FAILED(hr)) {
std::cerr << "Failed to get active frame.";
return hr;
}
first_stack_ = std::shared_ptr<DbgStackFrame>(
new DbgStackFrame(debug_helper_, obj_factory_));
hr = PopulateDbgStackFrameHelper(parsed_pdb_files, debug_frame,
first_stack_.get(), true);
if (FAILED(hr)) {
std::cerr << "Failed to process stack frame.";
first_stack_.reset();
return hr;
}
// If this is an async frame, the method name would be something like
// <RealMethodName>d__18.MoveNext. PopulateAsyncStackFrameInfo
// will populate stack_frame with the correct method name and class token.
if (first_stack_->IsAsyncMethod()) {
CComPtr<ICorDebugStackWalk> debug_stack_walk;
HRESULT hr = eval_coordinator->CreateStackWalk(&debug_stack_walk);
if (FAILED(hr)) {
cerr << "Failed to create stack walk.";
first_stack_.reset();
return hr;
}
hr = PopulateAsyncStackFrameInfo(first_stack_.get(), debug_stack_walk,
parsed_pdb_files);
if (FAILED(hr)) {
cerr << "Failed to get async stack frame's information.";
first_stack_.reset();
return hr;
}
}
return S_OK;
}
HRESULT StackFrameCollection::PopulateDbgStackFrameHelper(
const std::vector<
std::shared_ptr<google_cloud_debugger_portable_pdb::IPortablePdbFile>>
&parsed_pdb_files,
ICorDebugFrame *debug_frame, DbgStackFrame *stack_frame,
bool process_il_frame) {
// Gets ICorDebugFunction that corresponds to the function at this frame.
// We delay the logic to query the IL frame until we have to get the
// variables and method arguments.
CComPtr<ICorDebugFunction> frame_function;
HRESULT hr = debug_frame->GetFunction(&frame_function);
// This means the debug function is not available (mostly because of
// native code) so we skip to the next frame.
if (hr == CORDBG_E_CODE_NOT_AVAILABLE) {
// Adds an empty stack frame.
stack_frame->SetEmpty(true);
return S_OK;
}
if (FAILED(hr)) {
cerr << "Failed to get ICorDebugFunction from IL Frame.";
return hr;
}
// Gets the token of the function above.
mdMethodDef target_function_token;
hr = frame_function->GetToken(&target_function_token);
if (FAILED(hr)) {
cerr << "Failed to extract token from debug function.";
return hr;
}
// Gets the ICorDebugModule of the module at this frame.
CComPtr<ICorDebugModule> frame_module;
hr = frame_function->GetModule(&frame_module);
if (FAILED(hr)) {
cerr << "Failed to get ICorDebugModule from ICorDebugFunction.";
return hr;
}
vector<WCHAR> module_name;
hr = debug_helper_->GetModuleNameFromICorDebugModule(frame_module,
&module_name, &cerr);
if (FAILED(hr)) {
return hr;
}
stack_frame->SetModuleName(module_name);
string target_module_name = stack_frame->GetModule();
CComPtr<IMetaDataImport> metadata_import;
hr = debug_helper_->GetMetadataImportFromICorDebugModule(
frame_module, &metadata_import, &cerr);
if (FAILED(hr)) {
return hr;
}
// Populates the module, class and function name of this stack frame
// so we can report this even if we don't have local variables or
// method arguments.
hr = PopulateModuleClassAndFunctionName(stack_frame, target_function_token,
metadata_import);
if (FAILED(hr)) {
return hr;
}
if (!process_il_frame) {
return S_OK;
}
CComPtr<ICorDebugILFrame> il_frame;
hr = debug_frame->QueryInterface(__uuidof(ICorDebugILFrame),
reinterpret_cast<void **>(&il_frame));
// If this is a non-IL frame, we cannot get local variables
// and method arguments so simply skip that step.
if (hr == E_NOINTERFACE) {
return S_OK;
}
if (FAILED(hr)) {
cerr << "Failed to get ILFrame";
return hr;
}
for (auto &&pdb_file : parsed_pdb_files) {
// TODO(quoct): Possible performance improvement by caching the pdb_file
// based on token.
string pdb_module_name = pdb_file->GetModuleName();
if (pdb_module_name.compare(target_module_name) != 0) {
continue;
}
// Tries to populate local variables and method arguments of this frame.
hr = PopulateLocalVarsAndMethodArgs(target_function_token, stack_frame,
il_frame, metadata_import,
pdb_file.get());
if (FAILED(hr)) {
cerr << "Failed to populate stack frame information.";
return hr;
}
return S_OK;
}
return S_FALSE;
}
} // namespace google_cloud_debugger
| 33.295858 | 80 | 0.676737 | [
"object",
"vector"
] |
fc3f251d50b78a781fcb94114a3b105207c79e5f | 4,743 | cpp | C++ | tree/106_Construct_Binary_Tree_from_Inorder_and_Postorder_Traversal.cpp | zephyr-fun/LeetCodeSolution | adab165bcd269daf3e611a26187977ccd458d02a | [
"MIT"
] | null | null | null | tree/106_Construct_Binary_Tree_from_Inorder_and_Postorder_Traversal.cpp | zephyr-fun/LeetCodeSolution | adab165bcd269daf3e611a26187977ccd458d02a | [
"MIT"
] | null | null | null | tree/106_Construct_Binary_Tree_from_Inorder_and_Postorder_Traversal.cpp | zephyr-fun/LeetCodeSolution | adab165bcd269daf3e611a26187977ccd458d02a | [
"MIT"
] | null | null | null | /***
* Author: zephyr
* Date: 2020-12-12 14:56:36
* LastEditors: zephyr
* LastEditTime: 2021-01-09 11:30:18
* FilePath: \tree\106_Construct_Binary_Tree_from_Inorder_and_Postorder_Traversal.cpp
*/
#include <iostream>
#include <vector>
#include <stack>
#include <unordered_map>
using namespace std;
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode() : val(0), left(nullptr), right(nullptr) {}
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
};
//O(n) using stack
TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder)
{
if(!postorder.size())
{
return nullptr;
}
TreeNode* root = new TreeNode(postorder[postorder.size() - 1]);
stack<TreeNode*> stk;
stk.push(root);
int inorderIndex = inorder.size() - 1;
for(int i = postorder.size() - 2; i >= 0; i--)
{
auto node = stk.top();
if(node->val != inorder[inorderIndex])
{
node->right = new TreeNode(postorder[i]);
stk.push(node->right);
}
else
{
while(!stk.empty() && stk.top()->val == inorder[inorderIndex])
{
node = stk.top();
stk.pop();
inorderIndex--;
}
node->left = new TreeNode(postorder[i]);
stk.push(node->left);
}
}
return root;
}
//O(n) using recursion
unordered_map<int, int> index;
TreeNode* myBuildTree(vector<int>& inorder, vector<int>& postorder, int postorder_left, int postorder_right, int inorder_left, int inorder_right)
{
if(postorder_left > postorder_right)
return nullptr;
TreeNode* root = new TreeNode(postorder[postorder_right]);
int inorderRootIndex = index[root->val];
int right_subtree_size = inorder_right - inorderRootIndex;
root->right = myBuildTree(inorder, postorder, postorder_right - right_subtree_size, postorder_right - 1, inorderRootIndex + 1, inorder_right);
root->left = myBuildTree(inorder, postorder, postorder_left, postorder_right - right_subtree_size - 1, inorder_left, inorderRootIndex - 1);
return root;
}
TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder)
{
for(int i = postorder.size()-1; i >= 0; i--)
{
index[inorder[i]] = i;
}
return myBuildTree(inorder, postorder, 0, postorder.size()-1, 0, inorder.size()-1);
}
// 2nd
// way 1 recursion
unordered_map<int, int> index;
TreeNode* myBuildTree(vector<int>& inorder, vector<int>& postorder, int postorder_left, int postorder_right, int inorder_left, int inorder_right)
{
if(postorder_left > postorder_right)
return nullptr;
int inorder_root = index[postorder[postorder_right]];// postorder_right是索引，记得先用索引取值
int subrighttree = inorder_right - inorder_root;// 右边界减去根节点的值等于右子树长度
TreeNode* root = new TreeNode(postorder[postorder_right]);
root->right = myBuildTree(inorder, postorder, postorder_right - subrighttree, postorder_right - 1, inorder_root + 1, inorder_right);
root->left = myBuildTree(inorder, postorder, postorder_left, postorder_right - subrighttree - 1, inorder_left, inorder_root - 1);
return root;
}
TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder)
{
if(!postorder.size())
return nullptr;
for(int i = postorder.size() - 1; i >= 0; i--)//记录的是从当前根节点出发能到达的最远右子树节点
{
index[inorder[i]] = i;
}
return myBuildTree(inorder, postorder, 0, postorder.size() - 1, 0, inorder.size() - 1);
}
// way 2 non recursion
TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder)
{
if(!postorder.size())
return nullptr;
stack<TreeNode*> stk;
int inorderindex = inorder.size() - 1;
TreeNode* root = new TreeNode(postorder[postorder.size() - 1]);
stk.push(root);
for(int i = postorder.size() - 2; i >= 0; i--)
{
auto node = stk.top();
if(node->val != inorder[inorderindex])
{
node->right = new TreeNode(postorder[i]);// all the way to right
stk.push(node->right);
}
else
{
while(!stk.empty() && stk.top()->val == inorder[inorderindex])// pay more attention to this stk.top()->val
{
node = stk.top();
stk.pop();
inorderindex--;
}
node->left = new TreeNode(postorder[i]);
stk.push(node->left);
}
}
return root;
} | 33.638298 | 146 | 0.618807 | [
"vector"
] |
fc4cd89e5aa296c1a16583da69ec929100de1690 | 1,789 | cpp | C++ | samples/client/petstore-security-test/qt5cpp/client/SWGReturn.cpp | wwadge/swagger-codegen | 777619d4d106b7b387f8ee8469f4ec43f3cdfdc7 | [
"Apache-2.0"
] | 3 | 2017-05-24T11:22:36.000Z | 2021-02-09T15:26:41.000Z | samples/client/petstore-security-test/qt5cpp/client/SWGReturn.cpp | wwadge/swagger-codegen | 777619d4d106b7b387f8ee8469f4ec43f3cdfdc7 | [
"Apache-2.0"
] | 5 | 2019-03-06T07:41:25.000Z | 2020-01-20T12:21:53.000Z | samples/client/petstore-security-test/qt5cpp/client/SWGReturn.cpp | wwadge/swagger-codegen | 777619d4d106b7b387f8ee8469f4ec43f3cdfdc7 | [
"Apache-2.0"
] | 11 | 2017-07-07T18:07:15.000Z | 2021-11-10T02:12:04.000Z | /**
* Swagger Petstore *_/ ' \" =end -- \\r\\n \\n \\r
* This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\ *_/ ' \" =end --
*
* OpenAPI spec version: 1.0.0 *_/ ' \" =end -- \\r\\n \\n \\r
* Contact: apiteam@swagger.io *_/ ' \" =end -- \\r\\n \\n \\r
*
* NOTE: This class is auto generated by the swagger code generator program.
* https://github.com/swagger-api/swagger-codegen.git
* Do not edit the class manually.
*/
#include "SWGReturn.h"
#include "SWGHelpers.h"
#include <QJsonDocument>
#include <QJsonArray>
#include <QObject>
#include <QDebug>
namespace Swagger {
SWGReturn::SWGReturn(QString* json) {
init();
this->fromJson(*json);
}
SWGReturn::SWGReturn() {
init();
}
SWGReturn::~SWGReturn() {
this->cleanup();
}
void
SWGReturn::init() {
return = 0;
}
void
SWGReturn::cleanup() {
}
SWGReturn*
SWGReturn::fromJson(QString &json) {
QByteArray array (json.toStdString().c_str());
QJsonDocument doc = QJsonDocument::fromJson(array);
QJsonObject jsonObject = doc.object();
this->fromJsonObject(jsonObject);
return this;
}
void
SWGReturn::fromJsonObject(QJsonObject &pJson) {
::Swagger::setValue(&return, pJson["return"], "qint32", "");
}
QString
SWGReturn::asJson ()
{
QJsonObject* obj = this->asJsonObject();
QJsonDocument doc(*obj);
QByteArray bytes = doc.toJson();
return QString(bytes);
}
QJsonObject*
SWGReturn::asJsonObject() {
QJsonObject* obj = new QJsonObject();
obj->insert("return", QJsonValue(return));
return obj;
}
qint32
SWGReturn::getReturn() {
return return;
}
void
SWGReturn::setReturn(qint32 return) {
this->return = return;
}
}
| 19.236559 | 184 | 0.64673 | [
"object"
] |
fc53d8dcefacb74c8f074fd581dac914502c2168 | 39,370 | cpp | C++ | TuneDinia/tunedinia/opencl/dwt2d/main.cpp | benvanwerkhoven/TuneDinia | 2817f4d0932b062c9849f163ec280ddee01d82ba | [
"BSD-3-Clause"
] | 1 | 2021-10-04T08:37:42.000Z | 2021-10-04T08:37:42.000Z | TuneDinia/tunedinia/opencl/dwt2d/main.cpp | benvanwerkhoven/TuneDinia | 2817f4d0932b062c9849f163ec280ddee01d82ba | [
"BSD-3-Clause"
] | null | null | null | TuneDinia/tunedinia/opencl/dwt2d/main.cpp | benvanwerkhoven/TuneDinia | 2817f4d0932b062c9849f163ec280ddee01d82ba | [
"BSD-3-Clause"
] | 1 | 2021-07-22T07:45:05.000Z | 2021-07-22T07:45:05.000Z | #include <unistd.h>
#include <error.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <assert.h>
#include <sys/time.h>
#include <getopt.h>
#include <iostream>
#include <vector>
#include <fstream>
#include <sstream>
#include <vector>
#include "common.h"
#include "components.h"
#include "dwt.h"
//using namespace std;
#ifdef __APPLE__
#include <OpenCL/cl.h>
#else
#include <CL/opencl.h>
#endif
#define THREADS 256
struct dwt {
char * srcFilename;
char * outFilename;
unsigned char *srcImg;
int pixWidth;
int pixHeight;
int components;
int dwtLvls;
};
cl_context context = 0;
cl_command_queue commandQueue = 0;
cl_program program = 0;
cl_device_id cldevice = 0;
cl_kernel kernel = 0;
cl_kernel c_CopySrcToComponents = 0;
cl_kernel c_CopySrcToComponent = 0;
cl_kernel kl_fdwt53Kernel;
cl_mem memObjects[3] = { 0, 0, 0 };
cl_int errNum = 0;
int platform = 0;
int device = 0;
#ifdef TIMING
#include "timing.h"
//Primitives for timing
struct timeval tv;
struct timeval tv_total_start, tv_total_end;
struct timeval tv_init_end;
struct timeval tv_h2d_start, tv_h2d_end;
struct timeval tv_d2h_start, tv_d2h_end;
struct timeval tv_kernel_start, tv_kernel_end;
struct timeval tv_mem_alloc_start, tv_mem_alloc_end;
struct timeval tv_close_start, tv_close_end;
float init_time = 0, mem_alloc_time = 0, h2d_time = 0, kernel_time= 0,
d2h_time = 0, d2d_time = 0, close_time = 0, total_time = 0;
#endif
///
// functions for preparing create opencl program, contains CreateContext, CreateProgram, CreateCommandQueue, CreateMemBuffer, and Cleanup
// Create an OpenCL context on the first available GPU platform.
cl_context CreateContext()
{
cl_context context = NULL;
cl_uint platformIdCount = 0;
cl_int errNum;
// get number of platforms
clGetPlatformIDs (0, NULL, &platformIdCount);
std::vector<cl_platform_id> platformIds(platformIdCount);
clGetPlatformIDs (platformIdCount, platformIds.data(), NULL);
// In this example, first platform is a CPU, the second one is a GPU. we just choose the first available device.
cl_context_properties contextProperties[] =
{
CL_CONTEXT_PLATFORM,
(cl_context_properties)platformIds[platform],
0
};
context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_GPU,
NULL, NULL, &errNum);
if (errNum != CL_SUCCESS)
{
std::cout << "Could not create GPU context, trying CPU..." << std::endl;
context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_CPU,
NULL, NULL, &errNum);
if (errNum != CL_SUCCESS)
{
std::cerr << "Failed to create an OpenCL GPU or CPU context." << std::endl;
return NULL;
}
}
return context;
}
///
// Create a command queue on the first device available on the context
//
cl_command_queue CreateCommandQueue(cl_context context, cl_device_id *cldevice)
{
cl_int errNum;
cl_device_id *cldevices;
cl_command_queue commandQueue = NULL;
size_t deviceBufferSize = -1;
// First get the size of the devices buffer
errNum = clGetContextInfo(context, CL_CONTEXT_DEVICES, 0, NULL, &deviceBufferSize);
if (errNum != CL_SUCCESS)
{
std::cerr << "Failed call to clGetContextInfo(...,GL_CONTEXT_DEVICES,...)";
return NULL;
}
if (deviceBufferSize <= 0)
{
std::cerr << "No devices available.";
return NULL;
}
// Allocate memory for the devices buffer
cldevices = new cl_device_id[deviceBufferSize / sizeof(cl_device_id)];
errNum = clGetContextInfo(context, CL_CONTEXT_DEVICES, deviceBufferSize, cldevices, NULL);
if (errNum != CL_SUCCESS)
{
delete [] cldevices;
std::cerr << "Failed to get device IDs";
return NULL;
}
#ifdef TIMING
commandQueue = clCreateCommandQueue(context, cldevices[device], CL_QUEUE_PROFILING_ENABLE, NULL);
#else
commandQueue = clCreateCommandQueue(context, cldevices[device], 0, NULL);
#endif
if (commandQueue == NULL)
{
delete [] cldevices;
std::cerr << "Failed to create commandQueue for device ";
return NULL;
}
*cldevice = cldevices[device];
delete [] cldevices;
return commandQueue;
}
///
// Create an OpenCL program from the kernel source file
//
cl_program CreateProgram(cl_context context, cl_device_id cldevice, const char* fileName)
{
cl_int errNum;
cl_program program;
std::ifstream kernelFile(fileName, std::ios::in);
if (!kernelFile.is_open())
{
std::cerr << "Failed to open file for reading: " << fileName << std::endl;
return NULL;
}
std::ostringstream oss;
oss << kernelFile.rdbuf();
std::string srcStdStr = oss.str();
const char *srcStr = srcStdStr.c_str();
program = clCreateProgramWithSource(context, 1,
(const char**)&srcStr,
NULL, NULL);
if (program == NULL)
{
std::cerr << "Failed to create CL program from source." << std::endl;
return NULL;
}
errNum = clBuildProgram(program, 0, NULL, NULL, NULL, NULL);
if (errNum != CL_SUCCESS)
{
// Determine the reason for the error
char buildLog[16384];
clGetProgramBuildInfo(program, cldevice, CL_PROGRAM_BUILD_LOG,
sizeof(buildLog), buildLog, NULL);
std::cerr << "Error in kernel: " << std::endl;
std::cerr << buildLog;
clReleaseProgram(program);
return NULL;
}
return program;
}
///
// Cleanup any created OpenCL resources
//
void Cleanup(cl_context context, cl_command_queue commandQueue,
cl_program program, cl_kernel kernel)
{
if (commandQueue != 0)
clReleaseCommandQueue(commandQueue);
if (kernel != 0)
clReleaseKernel(kernel);
if (program != 0)
clReleaseProgram(program);
if (context != 0)
clReleaseContext(context);
}
///
// Load the input image.
//
int getImg(char * srcFilename, unsigned char *srcImg, int inputSize)
{
printf("Loading ipnput: %s\n", srcFilename);
//read image
int i = open(srcFilename, O_RDONLY, 0644);
if (i == -1)
{
error(0,errno,"cannot access %s", srcFilename);
return -1;
}
int ret = read(i, srcImg, inputSize);
printf("precteno %d, inputsize %d\n", ret, inputSize);
close(i);
return 0;
}
///
//Show user how to use this program
//
void usage() {
printf("dwt [otpions] src_img.rgb <out_img.dwt>\n\
-D, --dimension\t\tdimensions of src img, e.g. 1920x1080\n\
-c, --components\t\tnumber of color components, default 3\n\
-b, --depth\t\t\tbit depth, default 8\n\
-l, --level\t\t\tDWT level, default 3\n\
-d, --device\t\t\tocl device\n\
-p, --platform\t\t\tocl platform\n\
-f, --forward\t\t\tforward transform\n\
-r, --reverse\t\t\treverse transform\n\
-i, --input-dir\t\t\tinput file directory\n\
-9, --97\t\t\t9/7 transform\n\
-5, --53\t\t\t5/3 transform\n\
-w --write-visual\t\twrite output in visual (tiled) fashion instead of the linear\n");
}
///
// Check the type of error about opencl program
//
void fatal_CL(cl_int error, int line_no)
{
printf("At line %d: ", line_no);
switch(error) {
case CL_SUCCESS: printf("CL_SUCCESS\n"); break;
case CL_DEVICE_NOT_FOUND: printf("CL_DEVICE_NOT_FOUND\n"); break;
case CL_DEVICE_NOT_AVAILABLE: printf("CL_DEVICE_NOT_AVAILABLE\n"); break;
case CL_COMPILER_NOT_AVAILABLE: printf("CL_COMPILER_NOT_AVAILABLE\n"); break;
case CL_MEM_OBJECT_ALLOCATION_FAILURE: printf("CL_MEM_OBJECT_ALLOCATION_FAILURE\n"); break;
case CL_OUT_OF_RESOURCES: printf("CL_OUT_OF_RESOURCES\n"); break;
case CL_OUT_OF_HOST_MEMORY: printf("CL_OUT_OF_HOST_MEMORY\n"); break;
case CL_PROFILING_INFO_NOT_AVAILABLE: printf("CL_PROFILING_INFO_NOT_AVAILABLE\n"); break;
case CL_MEM_COPY_OVERLAP: printf("CL_MEM_COPY_OVERLAP\n"); break;
case CL_IMAGE_FORMAT_MISMATCH: printf("CL_IMAGE_FORMAT_MISMATCH\n"); break;
case CL_IMAGE_FORMAT_NOT_SUPPORTED: printf("CL_IMAGE_FORMAT_NOT_SUPPORTED\n"); break;
case CL_BUILD_PROGRAM_FAILURE: printf("CL_BUILD_PROGRAM_FAILURE\n"); break;
case CL_MAP_FAILURE: printf("CL_MAP_FAILURE\n"); break;
case CL_INVALID_VALUE: printf("CL_INVALID_VALUE\n"); break;
case CL_INVALID_DEVICE_TYPE: printf("CL_INVALID_DEVICE_TYPE\n"); break;
case CL_INVALID_PLATFORM: printf("CL_INVALID_PLATFORM\n"); break;
case CL_INVALID_DEVICE: printf("CL_INVALID_DEVICE\n"); break;
case CL_INVALID_CONTEXT: printf("CL_INVALID_CONTEXT\n"); break;
case CL_INVALID_QUEUE_PROPERTIES: printf("CL_INVALID_QUEUE_PROPERTIES\n"); break;
case CL_INVALID_COMMAND_QUEUE: printf("CL_INVALID_COMMAND_QUEUE\n"); break;
case CL_INVALID_HOST_PTR: printf("CL_INVALID_HOST_PTR\n"); break;
case CL_INVALID_MEM_OBJECT: printf("CL_INVALID_MEM_OBJECT\n"); break;
case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR: printf("CL_INVALID_IMAGE_FORMAT_DESCRIPTOR\n"); break;
case CL_INVALID_IMAGE_SIZE: printf("CL_INVALID_IMAGE_SIZE\n"); break;
case CL_INVALID_SAMPLER: printf("CL_INVALID_SAMPLER\n"); break;
case CL_INVALID_BINARY: printf("CL_INVALID_BINARY\n"); break;
case CL_INVALID_BUILD_OPTIONS: printf("CL_INVALID_BUILD_OPTIONS\n"); break;
case CL_INVALID_PROGRAM: printf("CL_INVALID_PROGRAM\n"); break;
case CL_INVALID_PROGRAM_EXECUTABLE: printf("CL_INVALID_PROGRAM_EXECUTABLE\n"); break;
case CL_INVALID_KERNEL_NAME: printf("CL_INVALID_KERNEL_NAME\n"); break;
case CL_INVALID_KERNEL_DEFINITION: printf("CL_INVALID_KERNEL_DEFINITION\n"); break;
case CL_INVALID_KERNEL: printf("CL_INVALID_KERNEL\n"); break;
case CL_INVALID_ARG_INDEX: printf("CL_INVALID_ARG_INDEX\n"); break;
case CL_INVALID_ARG_VALUE: printf("CL_INVALID_ARG_VALUE\n"); break;
case CL_INVALID_ARG_SIZE: printf("CL_INVALID_ARG_SIZE\n"); break;
case CL_INVALID_KERNEL_ARGS: printf("CL_INVALID_KERNEL_ARGS\n"); break;
case CL_INVALID_WORK_DIMENSION: printf("CL_INVALID_WORK_DIMENSION\n"); break;
case CL_INVALID_WORK_GROUP_SIZE: printf("CL_INVALID_WORK_GROUP_SIZE\n"); break;
case CL_INVALID_WORK_ITEM_SIZE: printf("CL_INVALID_WORK_ITEM_SIZE\n"); break;
case CL_INVALID_GLOBAL_OFFSET: printf("CL_INVALID_GLOBAL_OFFSET\n"); break;
case CL_INVALID_EVENT_WAIT_LIST: printf("CL_INVALID_EVENT_WAIT_LIST\n"); break;
case CL_INVALID_EVENT: printf("CL_INVALID_EVENT\n"); break;
case CL_INVALID_OPERATION: printf("CL_INVALID_OPERATION\n"); break;
case CL_INVALID_GL_OBJECT: printf("CL_INVALID_GL_OBJECT\n"); break;
case CL_INVALID_BUFFER_SIZE: printf("CL_INVALID_BUFFER_SIZE\n"); break;
case CL_INVALID_MIP_LEVEL: printf("CL_INVALID_MIP_LEVEL\n"); break;
case CL_INVALID_GLOBAL_WORK_SIZE: printf("CL_INVALID_GLOBAL_WORK_SIZE\n"); break;
#ifdef CL_VERSION_1_1
case CL_MISALIGNED_SUB_BUFFER_OFFSET: printf("CL_MISALIGNED_SUB_BUFFER_OFFSET\n"); break;
case CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST: printf("CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST\n"); break;
#endif
default: printf("Invalid OpenCL error code\n");
}
}
///
// Separate compoents of 8bit RGB source image
//in file components.cu
void rgbToComponents(cl_mem d_r, cl_mem d_g, cl_mem d_b, unsigned char * h_src, int width, int height)
{
int pixels = width * height;
int alignedSize = DIVANDRND(width*height, THREADS) * THREADS * 3; //aligned to thread block size -- THREADS
#ifdef TIMING
gettimeofday(&tv_mem_alloc_start, NULL);
#endif
cl_mem cl_d_src;
cl_d_src = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, pixels*3, h_src, &errNum);
// fatal_CL(errNum, __LINE__);
#ifdef TIMING
gettimeofday(&tv_mem_alloc_end, NULL);
tvsub(&tv_mem_alloc_end, &tv_mem_alloc_start, &tv);
mem_alloc_time += tv.tv_sec * 1000.0 + (float) tv.tv_usec / 1000.0;
#endif
size_t globalWorkSize[1] = { alignedSize/3};
size_t localWorkSize[1] = { THREADS };
errNum = clSetKernelArg(c_CopySrcToComponents, 0, sizeof(cl_mem), &d_r);
errNum |= clSetKernelArg(c_CopySrcToComponents, 1, sizeof(cl_mem), &d_g);
errNum |= clSetKernelArg(c_CopySrcToComponents, 2, sizeof(cl_mem), &d_b);
errNum |= clSetKernelArg(c_CopySrcToComponents, 3, sizeof(cl_mem), &cl_d_src);
errNum |= clSetKernelArg(c_CopySrcToComponents, 4, sizeof(int), &pixels);
// fatal_CL(errNum, __LINE__);
cl_event event;
errNum = clEnqueueNDRangeKernel(commandQueue, c_CopySrcToComponents, 1, NULL, globalWorkSize, localWorkSize, 0, NULL, &event);
// fatal_CL(errNum, __LINE__);
#ifdef TIMING
kernel_time += probe_event_time(event, commandQueue);
#endif
// Free Memory
#ifdef TIMING
gettimeofday(&tv_close_start, NULL);
#endif
errNum = clReleaseMemObject(cl_d_src);
// fatal_CL(errNum, __LINE__);
#ifdef TIMING
gettimeofday(&tv_close_end, NULL);
tvsub(&tv_close_end, &tv_close_start, &tv);
close_time += tv.tv_sec * 1000.0 + (float) tv.tv_usec / 1000.0;
#endif
}
///
// Copy a 8bit source image data into a color compoment
//in file components.cu
void bwToComponent(cl_mem d_c, unsigned char * h_src, int width, int height)
{
cl_mem cl_d_src;
int pixels = width*height;
int alignedSize = DIVANDRND(pixels, THREADS) * THREADS;
#ifdef TIMING
gettimeofday(&tv_mem_alloc_start, NULL);
#endif
cl_d_src = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, pixels, h_src, NULL);
// fatal_CL(errNum, __LINE__);
#ifdef TIMING
gettimeofday(&tv_mem_alloc_end, NULL);
tvsub(&tv_mem_alloc_end, &tv_mem_alloc_start, &tv);
mem_alloc_time += tv.tv_sec * 1000.0 + (float) tv.tv_usec / 1000.0;
#endif
size_t globalWorkSize[1] = { alignedSize/9};
size_t localWorkSize[1] = { THREADS };
assert(alignedSize%(THREADS*3) == 0);
errNum = clSetKernelArg(c_CopySrcToComponent, 0, sizeof(cl_mem), &d_c);
errNum |= clSetKernelArg(c_CopySrcToComponent, 1, sizeof(cl_mem), &cl_d_src);
errNum |= clSetKernelArg(c_CopySrcToComponent, 2, sizeof(int), &pixels);
// fatal_CL(errNum, __LINE__);
cl_event event;
errNum = clEnqueueNDRangeKernel(commandQueue, c_CopySrcToComponent, 1, NULL, globalWorkSize, localWorkSize, 0, NULL, &event);
#ifdef TIMING
kernel_time += probe_event_time(event, commandQueue);
#endif
std::cout<<"in function bwToComponent errNum= "<<errNum<<"\n";
// fatal_CL(errNum, __LINE__);
std::cout<<"bwToComponent has finished\n";
// Free Memory
#ifdef TIMING
gettimeofday(&tv_close_start, NULL);
#endif
errNum = clReleaseMemObject(cl_d_src);
// fatal_CL(errNum, __LINE__);
#ifdef TIMING
gettimeofday(&tv_close_end, NULL);
tvsub(&tv_close_end, &tv_close_start, &tv);
close_time += tv.tv_sec * 1000.0 + (float) tv.tv_usec / 1000.0;
#endif
}
/// Only computes optimal number of sliding window steps, number of threadblocks and then lanches the 5/3 FDWT kernel.
/// @tparam WIN_SX width of sliding window
/// @tparam WIN_SY height of sliding window
/// @param in input image
/// @param out output buffer
/// @param sx width of the input image
/// @param sy height of the input image
///launchFDWT53Kerneld is in file
void launchFDWT53Kernel (int WIN_SX, int WIN_SY, cl_mem in, cl_mem out, int sx, int sy)
{
// compute optimal number of steps of each sliding window
// cuda_dwt called a function divRndUp from namespace cuda_gwt. this function takes n and d, "return (n / d) + ((n % d) ? 1 : 0);"
//
const int steps = ( sy/ (15 * WIN_SY)) + ((sy % (15 * WIN_SY)) ? 1 : 0);
int gx = ( sx/ WIN_SX) + ((sx % WIN_SX) ? 1 : 0); //use function divRndUp(n, d){return (n / d) + ((n % d) ? 1 : 0);}
int gy = ( sy/ (WIN_SY*steps)) + ((sy % (WIN_SY*steps)) ? 1 : 0);
printf("sliding steps = %d , gx = %d , gy = %d \n", steps, gx, gy);
// prepare grid size
size_t globalWorkSize[2] = { gx*WIN_SX, gy*1};
size_t localWorkSize[2] = { WIN_SX , 1};
// printf("\n globalx=%d, globaly=%d, blocksize=%d\n", gx, gy, WIN_SX);
errNum = clSetKernelArg(kl_fdwt53Kernel, 0, sizeof(cl_mem), &in);
errNum |= clSetKernelArg(kl_fdwt53Kernel, 1, sizeof(cl_mem), &out);
errNum |= clSetKernelArg(kl_fdwt53Kernel, 2, sizeof(int), &sx);
errNum |= clSetKernelArg(kl_fdwt53Kernel, 3, sizeof(int), &sy);
errNum |= clSetKernelArg(kl_fdwt53Kernel, 4, sizeof(int), &steps);
errNum |= clSetKernelArg(kl_fdwt53Kernel, 5, sizeof(int), &WIN_SX);
errNum |= clSetKernelArg(kl_fdwt53Kernel, 6, sizeof(int), &WIN_SY);
// fatal_CL(errNum, __LINE__);
errNum = clEnqueueNDRangeKernel(commandQueue, kl_fdwt53Kernel, 2, NULL, globalWorkSize, localWorkSize, 0, NULL, NULL);
// fatal_CL(errNum, __LINE__);
printf("kl_fdwt53Kernel in launchFDW53Kernel has finished\n");
}
/// Simple cudaMemcpy wrapped in performance tester.
/// param dest destination bufer
/// param src source buffer
/// param sx width of copied image
/// param sy height of copied image
///from /cuda_gwt/common.h/namespace
void memCopy (cl_mem dest, cl_mem src, const size_t sx, const size_t sy){
errNum = clEnqueueCopyBuffer (commandQueue, src, dest, 0, 0, sx*sy*sizeof(int), 0, NULL, NULL);
// fatal_CL (errNum, __LINE__);
}
/// Forward 5/3 2D DWT. See common rules (above) for more details.
/// @param in Expected to be normalized into range [-128, 127].
/// Will not be preserved (will be overwritten).
/// @param out output buffer on GPU
/// @param sizeX width of input image (in pixels)
/// @param sizeY height of input image (in pixels)
/// @param levels number of recursive DWT levels
/// @backup use to test time
//at the end of namespace dwt_cuda (line338)
void fdwt53(cl_mem in, cl_mem out, int sizeX, int sizeY, int levels)
{
// select right width of kernel for the size of the image
if(sizeX >= 960)
{
launchFDWT53Kernel(192, 8, in, out, sizeX, sizeY);
}
else if (sizeX >= 480)
{
launchFDWT53Kernel(128, 8, in, out, sizeX, sizeY);
} else
{
launchFDWT53Kernel(64, 8, in, out, sizeX, sizeY);
}
// if this was not the last level, continue recursively with other levels
if (levels > 1)
{
// copy output's LL band back into input buffer
const int llSizeX = (sizeX / 2) + ((sizeX % 2) ? 1 :0);
const int llSizeY = (sizeY / 2) + ((sizeY % 2) ? 1 :0);
memCopy(in, out, llSizeX, llSizeY);
// run remaining levels of FDWT
fdwt53(in, out, llSizeX, llSizeY, levels - 1);
}
}
///
// in dwt.cu
int nStage2dDWT(cl_mem in, cl_mem out, cl_mem backup, int pixWidth, int pixHeight, int stages, bool forward)
{
printf("\n*** %d stages of 2D forward DWT:\n", stages);
// create backup of input, because each test iteration overwrites it
const int size = pixHeight * pixWidth * sizeof(int);
// Measure time of individual levels.
if (forward)
fdwt53(in, out, pixWidth, pixHeight, stages );
//else
// rdwt(in, out, pixWidth, pixHeight, stages);
// rdwt means rdwt53(can be found in file rdwt53.cu) which has not been defined
return 0;
}
///
//in file dwt.cu
void samplesToChar(unsigned char * dst, int * src, int samplesNum)
{
int i;
for(i = 0; i < samplesNum; i++)
{
int r = src[i]+128;
if (r > 255) r = 255;
if (r < 0) r = 0;
dst[i] = (unsigned char)r;
}
}
///
//in file dwt.cu
/// Write output linear orderd
int writeLinear(cl_mem component, int pixWidth, int pixHeight, const char * filename, const char * suffix)
{
unsigned char * result;
int *gpu_output;
int i;
int size;
int samplesNum = pixWidth*pixHeight;
size = samplesNum*sizeof(int);
gpu_output = (int *)malloc(size);
memset(gpu_output, 0, size);
result = (unsigned char *)malloc(samplesNum);
// ReadBuffer op is blocking, and it does not always succeed.
#ifdef TIMING
gettimeofday(&tv_d2h_start, NULL);
#endif
errNum = clEnqueueReadBuffer(commandQueue, component, CL_TRUE, 0, size, gpu_output, 0, NULL, NULL);
// fatal_CL(errNum, __LINE__);
#ifdef TIMING
gettimeofday(&tv_d2h_end, NULL);
tvsub(&tv_d2h_end, &tv_d2h_start, &tv);
d2h_time += tv.tv_sec * 1000.0 + (float) tv.tv_usec / 1000.0;
#endif
// T to char
samplesToChar(result, gpu_output, samplesNum);
// Write component
char outfile[strlen(filename)+strlen(suffix)];
strcpy(outfile, filename);
strcpy(outfile+strlen(filename), suffix);
i = open(outfile, O_CREAT|O_WRONLY, 0644);
if (i == -1)
{
error(0,errno,"cannot access %s", outfile);
return -1;
}
printf("\nWriting to %s (%d x %d)\n", outfile, pixWidth, pixHeight);
write(i, result, samplesNum);
close(i);
// Clean up
free(gpu_output);
free(result);
return 0;
}
///
// Write output visual ordered
//in file dwt.cu
int writeNStage2DDWT(cl_mem component, int pixWidth, int pixHeight, int stages, const char * filename, const char * suffix)
{
struct band {
int dimX;
int dimY;
};
struct dimensions {
struct band LL;
struct band HL;
struct band LH;
struct band HH;
};
unsigned char * result;
int *src;
int *dst;
int i,s;
int size;
int offset;
int yOffset;
int samplesNum = pixWidth*pixHeight;
struct dimensions * bandDims;
bandDims = (struct dimensions *)malloc(stages * sizeof(struct dimensions));
bandDims[0].LL.dimX = DIVANDRND(pixWidth,2);
bandDims[0].LL.dimY = DIVANDRND(pixHeight,2);
bandDims[0].HL.dimX = pixWidth - bandDims[0].LL.dimX;
bandDims[0].HL.dimY = bandDims[0].LL.dimY;
bandDims[0].LH.dimX = bandDims[0].LL.dimX;
bandDims[0].LH.dimY = pixHeight - bandDims[0].LL.dimY;
bandDims[0].HH.dimX = bandDims[0].HL.dimX;
bandDims[0].HH.dimY = bandDims[0].LH.dimY;
for (i = 1; i < stages; i++)
{
bandDims[i].LL.dimX = DIVANDRND(bandDims[i-1].LL.dimX,2);
bandDims[i].LL.dimY = DIVANDRND(bandDims[i-1].LL.dimY,2);
bandDims[i].HL.dimX = bandDims[i-1].LL.dimX - bandDims[i].LL.dimX;
bandDims[i].HL.dimY = bandDims[i].LL.dimY;
bandDims[i].LH.dimX = bandDims[i].LL.dimX;
bandDims[i].LH.dimY = bandDims[i-1].LL.dimY - bandDims[i].LL.dimY;
bandDims[i].HH.dimX = bandDims[i].HL.dimX;
bandDims[i].HH.dimY = bandDims[i].LH.dimY;
}
#if 0
printf("Original image pixWidth x pixHeight: %d x %d\n", pixWidth, pixHeight);
for (i = 0; i < stages; i++)
{
printf("Stage %d: LL: pixWidth x pixHeight: %d x %d\n", i, bandDims[i].LL.dimX, bandDims[i].LL.dimY);
printf("Stage %d: HL: pixWidth x pixHeight: %d x %d\n", i, bandDims[i].HL.dimX, bandDims[i].HL.dimY);
printf("Stage %d: LH: pixWidth x pixHeight: %d x %d\n", i, bandDims[i].LH.dimX, bandDims[i].LH.dimY);
printf("Stage %d: HH: pixWidth x pixHeight: %d x %d\n", i, bandDims[i].HH.dimX, bandDims[i].HH.dimY);
}
#endif
size = samplesNum*sizeof(int);
src = (int *)malloc(size);
memset(src, 0, size);
dst = (int *)malloc(size);
memset(dst, 0, size);
result = (unsigned char *)malloc(samplesNum);
// ReadBuffer op is blocking, and it does not always succeed.
#ifdef TIMING
gettimeofday(&tv_d2h_start, NULL);
#endif
errNum = clEnqueueReadBuffer(commandQueue, component, CL_TRUE, 0, size, src, 0, NULL, NULL);
// fatal_CL(errNum, __LINE__);
#ifdef TIMING
gettimeofday(&tv_d2h_end, NULL);
tvsub(&tv_d2h_end, &tv_d2h_start, &tv);
d2h_time += tv.tv_sec * 1000.0 + (float) tv.tv_usec / 1000.0;
#endif
// LL Band
size = bandDims[stages-1].LL.dimX * sizeof(int);
for (i = 0; i < bandDims[stages-1].LL.dimY; i++)
{
memcpy(dst+i*pixWidth, src+i*bandDims[stages-1].LL.dimX, size);
}
for (s = stages - 1; s >= 0; s--) {
// HL Band
size = bandDims[s].HL.dimX * sizeof(int);
offset = bandDims[s].LL.dimX * bandDims[s].LL.dimY;
for (i = 0; i < bandDims[s].HL.dimY; i++)
{
memcpy(dst+i*pixWidth+bandDims[s].LL.dimX,
src+offset+i*bandDims[s].HL.dimX,
size);
}
// LH band
size = bandDims[s].LH.dimX * sizeof(int);
offset += bandDims[s].HL.dimX * bandDims[s].HL.dimY;
yOffset = bandDims[s].LL.dimY;
for (i = 0; i < bandDims[s].HL.dimY; i++)
{
memcpy(dst+(yOffset+i)*pixWidth,
src+offset+i*bandDims[s].LH.dimX,
size);
}
//HH band
size = bandDims[s].HH.dimX * sizeof(int);
offset += bandDims[s].LH.dimX * bandDims[s].LH.dimY;
yOffset = bandDims[s].HL.dimY;
for (i = 0; i < bandDims[s].HH.dimY; i++)
{
memcpy(dst+(yOffset+i)*pixWidth+bandDims[s].LH.dimX,
src+offset+i*bandDims[s].HH.dimX,
size);
}
}
// Write component
samplesToChar(result, dst, samplesNum);
char outfile[strlen(filename)+strlen(suffix)];
strcpy(outfile, filename);
strcpy(outfile+strlen(filename), suffix);
i = open(outfile, O_CREAT|O_WRONLY, 0644);
if (i == -1)
{
error(0,errno,"cannot access %s", outfile);
return -1;
}
printf("\nWriting to %s (%d x %d)\n", outfile, pixWidth, pixHeight);
write(i, result, samplesNum);
close(i);
free(src);
free(dst);
free(result);
free(bandDims);
return 0;
}
///
// Process of DWT algorithm
//
template <typename T>
void processDWT(struct dwt *d, int forward, int writeVisual)
{
int componentSize = d->pixWidth * d->pixHeight * sizeof(T);
T *c_r_out, *c_g_out, *c_b_out, *backup, *c_r, *c_g, *c_b;
// initialize to zeros
T *temp = (T *)malloc(componentSize);
memset(temp, 0, componentSize);
#ifdef TIMING
gettimeofday(&tv_mem_alloc_start, NULL);
#endif
cl_mem cl_c_r_out;
cl_c_r_out = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, componentSize, temp, &errNum);
// fatal_CL(errNum, __LINE__);
cl_mem cl_backup;
cl_backup = clCreateBuffer(context, CL_MEM_READ_WRITE |CL_MEM_COPY_HOST_PTR, componentSize, temp, &errNum);
// fatal_CL(errNum, __LINE__);
if (d->components == 3) {
// Alloc two more buffers for G and B
cl_mem cl_c_g_out;
cl_c_g_out = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, componentSize, temp, &errNum);
// fatal_CL(errNum, __LINE__);
cl_mem cl_c_b_out;
cl_c_b_out = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, componentSize, temp, &errNum);
// fatal_CL(errNum, __LINE__);
// Load components
cl_mem cl_c_r, cl_c_g, cl_c_b;
cl_c_r = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR,componentSize, temp, &errNum);
// fatal_CL(errNum, __LINE__);
cl_c_g = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR,componentSize, temp, &errNum);
// fatal_CL(errNum, __LINE__);
cl_c_b = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR,componentSize, temp, &errNum);
// fatal_CL(errNum, __LINE__);
#ifdef TIMING
gettimeofday(&tv_mem_alloc_end, NULL);
tvsub(&tv_mem_alloc_end, &tv_mem_alloc_start, &tv);
mem_alloc_time += tv.tv_sec * 1000.0 + (float) tv.tv_usec / 1000.0;
#endif
rgbToComponents(cl_c_r, cl_c_g, cl_c_b, d->srcImg, d->pixWidth, d->pixHeight);
//Compute DWT and always store int file
nStage2dDWT(cl_c_r, cl_c_r_out, cl_backup, d->pixWidth, d->pixHeight, d->dwtLvls, forward);
nStage2dDWT(cl_c_g, cl_c_g_out, cl_backup, d->pixWidth, d->pixHeight, d->dwtLvls, forward);
nStage2dDWT(cl_c_b, cl_c_b_out, cl_backup, d->pixWidth, d->pixHeight, d->dwtLvls, forward);
// ---------test----------
/* T *h_r_out=(T*)malloc(componentSize);
errNum = clEnqueueReadBuffer(commandQueue, cl_c_g_out, CL_TRUE, 0, componentSize, h_r_out, 0, NULL, NULL);
fatal_CL(errNum, __LINE__);
int ii;
for(ii=0;ii<componentSize/sizeof(T);ii++) {
fprintf(stderr, "%d ", (int)h_r_out[ii]);
if((ii+1) % (d->pixWidth) == 0) fprintf(stderr, "\n");
}
*/ // ---------test----------
#ifdef OUTPUT
// Store DWT to file
if(writeVisual){
writeNStage2DDWT(cl_c_r_out, d->pixWidth, d->pixHeight, d->dwtLvls, d->outFilename, ".r");
writeNStage2DDWT(cl_c_g_out, d->pixWidth, d->pixHeight, d->dwtLvls, d->outFilename, ".g");
writeNStage2DDWT(cl_c_b_out, d->pixWidth, d->pixHeight, d->dwtLvls, d->outFilename, ".b");
} else {
writeLinear(cl_c_r_out, d->pixWidth, d->pixHeight, d->outFilename, ".r");
writeLinear(cl_c_g_out, d->pixWidth, d->pixHeight, d->outFilename, ".g");
writeLinear(cl_c_b_out, d->pixWidth, d->pixHeight, d->outFilename, ".b");
}
#endif
#ifdef TIMING
gettimeofday(&tv_close_start, NULL);
#endif
clReleaseMemObject(cl_c_r);
clReleaseMemObject(cl_c_g);
clReleaseMemObject(cl_c_b);
clReleaseMemObject(cl_c_g_out);
clReleaseMemObject(cl_c_b_out);
} else if(d->components == 1) {
#ifdef TIMING
gettimeofday(&tv_mem_alloc_start, NULL);
#endif
// Load components
cl_mem cl_c_r;
cl_c_r = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR,componentSize, temp, &errNum);
// fatal_CL(errNum, __LINE__);
#ifdef TIMING
gettimeofday(&tv_mem_alloc_end, NULL);
tvsub(&tv_mem_alloc_end, &tv_mem_alloc_start, &tv);
mem_alloc_time += tv.tv_sec * 1000.0 + (float) tv.tv_usec / 1000.0;
#endif
bwToComponent(cl_c_r, d->srcImg, d->pixWidth, d->pixHeight);
// Compute DWT
nStage2dDWT(cl_c_r, cl_c_r_out, cl_backup, d->pixWidth, d->pixHeight, d->dwtLvls, forward);
//Store DWT to file
if(writeVisual){
writeNStage2DDWT(cl_c_r_out, d->pixWidth, d->pixHeight, d->dwtLvls, d->outFilename, ".r");
} else {
writeLinear(cl_c_r_out, d->pixWidth, d->pixHeight, d->outFilename, ".r");
}
#ifdef TIMING
gettimeofday(&tv_close_start, NULL);
#endif
clReleaseMemObject(cl_c_r);
}
free(temp);
clReleaseMemObject(cl_c_r_out);
#ifdef TIMING
gettimeofday(&tv_close_end, NULL);
tvsub(&tv_close_end, &tv_close_start, &tv);
close_time += tv.tv_sec * 1000.0 + (float) tv.tv_usec / 1000.0;
#endif
}
int main(int argc, char **argv)
{
int optindex = 0;
char ch;
struct option longopts[] =
{
{"dimension", required_argument, 0, 'D'}, //dimensions of src img
{"components", required_argument, 0, 'c'}, //numger of components of src img
{"depth", required_argument, 0, 'b'}, //bit depth of src img
{"level", required_argument, 0, 'l'}, //level of dwt
{"device", required_argument, 0, 'd'}, //ocl device
{"platform", required_argument, 0, 'p'}, //ocl platform
{"input-dir", required_argument, 0, 'i'}, //input file directory
{"forward", no_argument, 0, 'f'}, //forward transform
{"reverse", no_argument, 0, 'r'}, //forward transform
{"97", no_argument, 0, '9'}, //9/7 transform
{"53", no_argument, 0, '5' }, //5/3transform
{"write-visual",no_argument, 0, 'w' }, //write output (subbands) in visual (tiled) order instead of linear
{"help", no_argument, 0, 'h'}
};
int pixWidth = 0; //<real pixWidth
int pixHeight = 0; //<real pixHeight
int compCount = 3; //number of components; 3 for RGB or YUV, 4 for RGBA
int bitDepth = 8;
int dwtLvls = 3; //default numuber of DWT levels
int forward = 1; //forward transform
int dwt97 = 0; //1=dwt9/7, 0=dwt5/3 transform
int writeVisual = 0; //write output (subbands) in visual (tiled) order instead of linear
char input_dir[100] = {"."};
char * pos;
while ((ch = getopt_long(argc, argv, "d:p:c:b:l:i:D:fr95wh", longopts, &optindex)) != -1)
{
switch (ch) {
case 'D':
pixWidth = atoi(optarg);
pos = strstr(optarg, "x");
if (pos == NULL || pixWidth == 0 || (strlen(pos) >= strlen(optarg)))
{
usage();
return -1;
}
pixHeight = atoi(pos+1);
break;
case 'c':
compCount = atoi(optarg);
break;
case 'b':
bitDepth = atoi(optarg);
break;
case 'l':
dwtLvls = atoi(optarg);
break;
case 'd':
device = atoi(optarg);
break;
case 'p':
platform = atoi(optarg);
break;
case 'i':
strcpy(input_dir, optarg);
break;
case 'f':
forward = 1;
break;
case 'r':
forward = 0;
break;
case '9':
dwt97 = 1;
break;
case '5':
dwt97 = 0;
break;
case 'w':
writeVisual = 1;
break;
case 'h':
usage();
return 0;
case '?':
return -1;
default :
usage();
return -1;
}
}
argc -= optind;
argv += optind;
if (argc == 0)
{ // at least one filename is expected
printf("Please supply src file name\n");
usage();
return -1;
}
if (pixWidth <= 0 || pixHeight <=0)
{
printf("Wrong or missing dimensions\n");
usage();
return -1;
}
if (forward == 0)
{
writeVisual = 0; //do not write visual when RDWT
}
// device init
// Create an OpenCL context on first available platform
#ifdef TIMING
gettimeofday(&tv_total_start, NULL);
#endif
context = CreateContext();
if (context == NULL)
{
std::cerr << "Failed to create OpenCL context." << std::endl;
return 1;
}
// Create a command-queue on the first device available
// on the created context
commandQueue = CreateCommandQueue(context, &cldevice);
if (commandQueue == NULL)
{
Cleanup(context, commandQueue, program, kernel);
return 1;
}
// Create OpenCL program from com_dwt.cl kernel source
program = CreateProgram(context, cldevice, "com_dwt.cl");
if (program == NULL)
{
printf("fail to create program!!\n");
}
// Create OpenCL kernel
c_CopySrcToComponents = clCreateKernel(program, "c_CopySrcToComponents", NULL);
if (c_CopySrcToComponents == NULL)
{
std::cerr << "Failed to create kernel" << std::endl;
}
c_CopySrcToComponent = clCreateKernel(program, "c_CopySrcToComponent", NULL);
if (c_CopySrcToComponent == NULL)
{
std::cerr << "Failed to create kernel" << std::endl;
}
kl_fdwt53Kernel = clCreateKernel(program, "cl_fdwt53Kernel", NULL);
if (kl_fdwt53Kernel == NULL)
{
std::cerr<<"Failed to create kernel\n";
}
#ifdef TIMING
gettimeofday(&tv_init_end, NULL);
tvsub(&tv_init_end, &tv_total_start, &tv);
init_time = tv.tv_sec * 1000.0 + (float) tv.tv_usec / 1000.0;
#endif
//initialize struct dwt
struct dwt *d;
d = (struct dwt *)malloc(sizeof(struct dwt));
d->srcImg = NULL;
d->pixWidth = pixWidth;
d->pixHeight = pixHeight;
d->components = compCount;
d->dwtLvls = dwtLvls;
// file names
d->srcFilename = (char *)malloc(strlen(argv[0]));
strcpy(d->srcFilename, argv[0]);
if (argc == 1)
{ // only one filename supplyed
d->outFilename = (char *)malloc(strlen(d->srcFilename)+4);
strcpy(d->outFilename, d->srcFilename);
strcpy(d->outFilename+strlen(d->srcFilename), ".dwt");
} else {
d->outFilename = strdup(argv[1]);
}
char real_filename[100];
sprintf(real_filename, "%s/%s", input_dir, d->srcFilename);
//Input review
printf("\nSource file:\t\t%s\n", real_filename);
printf(" Dimensions:\t\t%dx%d\n", pixWidth, pixHeight);
printf(" Components count:\t%d\n", compCount);
printf(" Bit depth:\t\t%d\n", bitDepth);
printf(" DWT levels:\t\t%d\n", dwtLvls);
printf(" Forward transform:\t%d\n", forward);
printf(" 9/7 transform:\t\t%d\n", dwt97);
//data sizes
int inputSize = pixWidth*pixHeight*compCount; //<amount of data (in bytes) to proccess
//load img source image
d->srcImg = (unsigned char *) malloc (inputSize);
if (getImg(real_filename, d->srcImg, inputSize) == -1)
return -1;
// DWT
// Create memory objects, Set arguments for kernel functions, Queue the kernel up for execution across the array, Read the output buffer back to the Host, Output the result buffer
if (forward == 1)
{
if(dwt97 == 1 )
processDWT<float>(d, forward, writeVisual);
else // 5/3
processDWT<int>(d, forward, writeVisual);
}
else
{ // reverse
if(dwt97 == 1 )
processDWT<float>(d, forward, writeVisual);
else // 5/3
processDWT<int>(d, forward, writeVisual);
}
#ifdef TIMING
gettimeofday(&tv_close_start, NULL);
#endif
Cleanup(context, commandQueue, program, kernel);
clReleaseKernel(c_CopySrcToComponents);
clReleaseKernel(c_CopySrcToComponent);
#ifdef TIMING
gettimeofday(&tv_total_end, NULL);
tvsub(&tv_total_end, &tv_close_start, &tv);
close_time += tv.tv_sec * 1000.0 + (float) tv.tv_usec / 1000.0;
tvsub(&tv_total_end, &tv_total_start, &tv);
total_time = tv.tv_sec * 1000.0 + (float) tv.tv_usec / 1000.0;
printf("Init: %f\n", init_time);
printf("MemAlloc: %f\n", mem_alloc_time);
printf("HtoD: %f\n", h2d_time);
printf("Exec: %f\n", kernel_time);
printf("DtoH: %f\n", d2h_time);
printf("Close: %f\n", close_time);
printf("Total: %f\n", total_time);
#endif
free(d->srcFilename);
free(d->srcImg);
free(d);
return 0;
}
| 33.364407 | 181 | 0.623419 | [
"vector",
"transform"
] |
fc5f924772dea586b16da20deef37d54d4d9d02d | 2,886 | cc | C++ | chrome/browser/sync/glue/synced_session.cc | Scopetta197/chromium | b7bf8e39baadfd9089de2ebdc0c5d982de4a9820 | [
"BSD-3-Clause"
] | 212 | 2015-01-31T11:55:58.000Z | 2022-02-22T06:35:11.000Z | chrome/browser/sync/glue/synced_session.cc | 1065672644894730302/Chromium | 239dd49e906be4909e293d8991e998c9816eaa35 | [
"BSD-3-Clause"
] | 5 | 2015-03-27T14:29:23.000Z | 2019-09-25T13:23:12.000Z | chrome/browser/sync/glue/synced_session.cc | 1065672644894730302/Chromium | 239dd49e906be4909e293d8991e998c9816eaa35 | [
"BSD-3-Clause"
] | 221 | 2015-01-07T06:21:24.000Z | 2022-02-11T02:51:12.000Z | // Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/sync/glue/synced_session.h"
#include "base/stl_util.h"
#include "chrome/common/url_constants.h"
#include "content/public/browser/navigation_entry.h"
namespace browser_sync {
SyncedTabNavigation::SyncedTabNavigation() : unique_id_(0) {
}
SyncedTabNavigation::SyncedTabNavigation(const SyncedTabNavigation& tab)
: TabNavigation(tab),
unique_id_(tab.unique_id_),
timestamp_(tab.timestamp_) {
}
SyncedTabNavigation::SyncedTabNavigation(int index,
const GURL& virtual_url,
const content::Referrer& referrer,
const string16& title,
const std::string& state,
content::PageTransition transition,
int unique_id,
const base::Time& timestamp)
: TabNavigation(index, virtual_url, referrer, title, state, transition),
unique_id_(unique_id),
timestamp_(timestamp) {
}
SyncedTabNavigation::~SyncedTabNavigation() {
}
void SyncedTabNavigation::set_unique_id(int unique_id) {
unique_id_ = unique_id;
}
int SyncedTabNavigation::unique_id() const {
return unique_id_;
}
void SyncedTabNavigation::set_timestamp(const base::Time& timestamp) {
timestamp_ = timestamp;
}
base::Time SyncedTabNavigation::timestamp() const {
return timestamp_;
}
SyncedSessionTab::SyncedSessionTab() {}
SyncedSessionTab::~SyncedSessionTab() {}
SyncedSession::SyncedSession() : session_tag("invalid"),
device_type(TYPE_UNSET) {
}
SyncedSession::~SyncedSession() {
STLDeleteContainerPairSecondPointers(windows.begin(), windows.end());
}
// Note: if you modify this, make sure you modify
// SessionModelAssociator::ShouldSyncTab to ensure the logic matches.
bool ShouldSyncSessionTab(const SessionTab& tab) {
if (tab.navigations.empty())
return false;
bool found_valid_url = false;
for (size_t i = 0; i < tab.navigations.size(); ++i) {
if (tab.navigations.at(i).virtual_url().is_valid() &&
!tab.navigations.at(i).virtual_url().SchemeIs("chrome") &&
!tab.navigations.at(i).virtual_url().SchemeIsFile()) {
found_valid_url = true;
}
}
return found_valid_url;
}
bool SessionWindowHasNoTabsToSync(const SessionWindow& window) {
int num_populated = 0;
for (std::vector<SessionTab*>::const_iterator i = window.tabs.begin();
i != window.tabs.end(); ++i) {
const SessionTab* tab = *i;
if (ShouldSyncSessionTab(*tab))
num_populated++;
}
return (num_populated == 0);
}
} // namespace browser_sync
| 31.369565 | 76 | 0.651074 | [
"vector"
] |
fc616bb0bd27c299a7f7abfaf80f93405581f68d | 2,474 | cpp | C++ | VFCLibrary/SKYPatch.cpp | idiap/CitySim-Solver | fec9007a67660186e7bc3b090651bf80e08d4d0d | [
"BSD-3-Clause"
] | 2 | 2020-11-26T09:31:10.000Z | 2020-12-09T17:13:28.000Z | VFCLibrary/SKYPatch.cpp | kaemco/CitySim-Solver | 4274f442f57ab9e59869ec6652c370cc5bd400ee | [
"BSD-3-Clause"
] | 1 | 2022-02-03T09:40:17.000Z | 2022-02-03T09:40:17.000Z | VFCLibrary/SKYPatch.cpp | idiap/CitySim-Solver | fec9007a67660186e7bc3b090651bf80e08d4d0d | [
"BSD-3-Clause"
] | 3 | 2020-10-30T20:48:15.000Z | 2021-09-03T08:51:39.000Z | #include "./SKYPatch.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
SKYPatch::SKYPatch(const GENPoint &patchDir) :
m_patchDir(patchDir)
{
}
SKYPatch::~SKYPatch(void)
{
}
/**
* Note that this function calculates the centroid of the potentially visible
* cells, if all cells are visible the centroid is *NOT* the same as the patch
* direction specified at construction, this is due to a couple of reasons:
* - solid angle of cells decrease as altitude increases
* - even if dw was the same for each cell, the centroid works out a bit lower
* than the average angle of altitude of the cells
*
*/
GENPoint SKYPatch::averageVisibleDirection(const GENPoint& viewDir) const
{
GENPoint sum=GENPoint::Origin();
for (std::vector<SKYCell>::const_iterator cell=m_Cells.begin();
cell!=m_Cells.end();
++cell)
{
const GENPoint& thisCellDir=cell->direction();
if (dot_product(viewDir, thisCellDir) > 0)
{
sum+=thisCellDir*cell->solidAngle();
}
}
return GENPoint::UnitVector(sum);
}
// ..........................................................................
float SKYPatch::formFactor(const GENPoint& viewDir) const
{
float viewfactor=0;
for (std::vector<SKYCell>::const_iterator cell=m_Cells.begin();
cell!=m_Cells.end();
++cell)
{
viewfactor+=cell->formFactor(viewDir);
}
return viewfactor;
}
// ..........................................................................
void SKYPatch::addCell(const SKYCell &cell)
{
m_Cells.push_back(cell);
}
// ..........................................................................
const SKYCell& SKYPatch::getCell(int i) const
{
return m_Cells[i];
}
// ..........................................................................
unsigned int SKYPatch::cellCount() const
{
return (unsigned int)m_Cells.size();
}
// ..........................................................................
const GENPoint& SKYPatch::centroid() const
{
return m_patchDir;
}
// ..........................................................................
float SKYPatch::solidAngle() const
{
float solidAngle=0.f;
for (std::vector<SKYCell>::const_iterator cell=m_Cells.begin();
cell!=m_Cells.end();
++cell)
{
solidAngle+=cell->solidAngle();
}
return solidAngle;
}
| 23.339623 | 79 | 0.556993 | [
"vector",
"solid"
] |
fc653f538c7d1ad401ca8eca54ecb8c39c1cbf07 | 14,853 | cpp | C++ | dev/Tools/Wwise/SDK/samples/SoundFrame/SFTest/SFTestEnvironmentDlg.cpp | chrisinajar/spark | 3c6b30592c00bc38738cc3aaca2144edfc6cc8b2 | [
"AML"
] | 2 | 2020-08-20T03:40:24.000Z | 2021-02-07T20:31:43.000Z | dev/Tools/Wwise/SDK/samples/SoundFrame/SFTest/SFTestEnvironmentDlg.cpp | chrisinajar/spark | 3c6b30592c00bc38738cc3aaca2144edfc6cc8b2 | [
"AML"
] | null | null | null | dev/Tools/Wwise/SDK/samples/SoundFrame/SFTest/SFTestEnvironmentDlg.cpp | chrisinajar/spark | 3c6b30592c00bc38738cc3aaca2144edfc6cc8b2 | [
"AML"
] | 5 | 2020-08-27T20:44:18.000Z | 2021-08-21T22:54:11.000Z | /*******************************************************************************
The content of this file includes portions of the AUDIOKINETIC Wwise Technology
released in source code form as part of the SDK installer package.
Commercial License Usage
Licensees holding valid commercial licenses to the AUDIOKINETIC Wwise Technology
may use this file in accordance with the end user license agreement provided
with the software or, alternatively, in accordance with the terms contained in a
written agreement between you and Audiokinetic Inc.
Version: v2017.2.9 Build: 6726
Copyright (c) 2006-2019 Audiokinetic Inc.
*******************************************************************************/
#include "stdafx.h"
#include "SFTestEnvironmentDlg.h"
#include <vector>
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
CSFTestAuxBusDlg::ObstructionOcclusionLevel::ObstructionOcclusionLevel()
: m_fObstruction( 0.0f )
, m_fOcclusion( 0.0f )
{}
CSFTestAuxBusDlg::GameObjectAuxBus::GameObjectAuxBus()
: m_fDryLevel( 1.0f )
{
for( int i = 0; i < s_iNumOfAuxBus; ++i )
{
m_sAuxBusValue[i].auxBusID = AK_INVALID_AUX_ID;
m_sAuxBusValue[i].fControlValue = 0.0f;
}
}
CSFTestAuxBusDlg::CSFTestAuxBusDlg(CWnd* pParent /*= NULL*/)
: CDialog(CSFTestAuxBusDlg::IDD, pParent)
, m_pSoundFrame( NULL )
, m_pDropTarget( NULL )
{}
CSFTestAuxBusDlg::~CSFTestAuxBusDlg()
{}
void CSFTestAuxBusDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
DDX_Control(pDX, IDC_ENVIRONMENT_LIST, m_AuxBusList);
DDX_Control(pDX, IDC_ACTIVE_GAME_OBJECT_COMBO, m_activeGameObjectCombo);
DDX_Control(pDX, IDC_ACTIVE_LISTENER_COMBO, m_activeListenerCombo);
DDX_Control(pDX, IDC_OBSTRUCTION_LEVEL_SLIDER, m_obstructionLevelSlider);
DDX_Control(pDX, IDC_OCCLUSION_LEVEL_SLIDER, m_occlusionLevelSlider);
DDX_Control(pDX, IDC_GAME_OBJECT_COMBO, m_AuxBusGameObjectCombo);
DDX_Control(pDX, IDC_ENVIRONMENT_1_COMBO, m_AuxBusCombo[0]);
DDX_Control(pDX, IDC_ENVIRONMENT_2_COMBO, m_AuxBusCombo[1]);
DDX_Control(pDX, IDC_ENVIRONMENT_3_COMBO, m_AuxBusCombo[2]);
DDX_Control(pDX, IDC_ENVIRONMENT_4_COMBO, m_AuxBusCombo[3]);
DDX_Control(pDX, IDC_ENVIRONMENT_1_LEVEL_SLIDER, m_AuxBusSlider[0]);
DDX_Control(pDX, IDC_ENVIRONMENT_2_LEVEL_SLIDER, m_AuxBusSlider[1]);
DDX_Control(pDX, IDC_ENVIRONMENT_3_LEVEL_SLIDER, m_AuxBusSlider[2]);
DDX_Control(pDX, IDC_ENVIRONMENT_4_LEVEL_SLIDER, m_AuxBusSlider[3]);
DDX_Control(pDX, IDC_ENVIRONMENT_1_LEVEL_STATIC, m_AuxBusStatic[0]);
DDX_Control(pDX, IDC_ENVIRONMENT_2_LEVEL_STATIC, m_AuxBusStatic[1]);
DDX_Control(pDX, IDC_ENVIRONMENT_3_LEVEL_STATIC, m_AuxBusStatic[2]);
DDX_Control(pDX, IDC_ENVIRONMENT_4_LEVEL_STATIC, m_AuxBusStatic[3]);
DDX_Control(pDX, IDC_GAME_OBJECT_DRY_LEVEL_SLIDER, m_dryLevelSlider);
}
BEGIN_MESSAGE_MAP(CSFTestAuxBusDlg, CDialog)
ON_WM_DESTROY()
ON_WM_QUERYDRAGICON()
//}}AFX_MSG_MAP
ON_CBN_SELCHANGE(IDC_ACTIVE_GAME_OBJECT_COMBO, OnLbnSelchangeActiveGameObjectListenerCombo)
ON_CBN_SELCHANGE(IDC_ACTIVE_LISTENER_COMBO, OnLbnSelchangeActiveGameObjectListenerCombo)
ON_CBN_SELCHANGE(IDC_GAME_OBJECT_COMBO, OnLbnSelchangeAuxBusGameObjectCombo)
ON_CBN_SELCHANGE(IDC_ENVIRONMENT_1_COMBO, OnGameObjectAuxBusChange)
ON_CBN_SELCHANGE(IDC_ENVIRONMENT_2_COMBO, OnGameObjectAuxBusChange)
ON_CBN_SELCHANGE(IDC_ENVIRONMENT_3_COMBO, OnGameObjectAuxBusChange)
ON_CBN_SELCHANGE(IDC_ENVIRONMENT_4_COMBO, OnGameObjectAuxBusChange)
ON_BN_CLICKED(IDC_GETALLENVIRONMENTS, OnBnClickedGetAllAuxBus)
ON_BN_CLICKED(IDC_CLEARENVIRONMENTS, OnBnClickedClearAuxBus)
ON_WM_HSCROLL()
ON_WM_VSCROLL()
ON_MESSAGE(WM_SF_SHOW, OnShowListItems)
END_MESSAGE_MAP()
BOOL CSFTestAuxBusDlg::OnInitDialog()
{
CDialog::OnInitDialog();
SetIcon(m_hIcon, TRUE); // Set big icon
SetIcon(m_hIcon, FALSE); // Set small icon
ASSERT( m_pSoundFrame && m_pDropTarget );
m_pDropTarget->Register( &m_AuxBusList );
m_obstructionLevelSlider.SetRange( 0, 100, TRUE );
m_occlusionLevelSlider.SetRange( 0, 100, TRUE );
m_dryLevelSlider.SetRange( 0, 100, TRUE );
for(int i = 0; i < s_iNumOfAuxBus; ++i)
m_AuxBusSlider[i].SetRange( 0, 100, TRUE );
m_activeListenerCombo.SetCurSel( 0 );
FillAuxBusCombo();
UpdateGameObjectList();
return TRUE; // return TRUE unless you set the focus to a control
}
void CSFTestAuxBusDlg::OnDestroy()
{
m_pDropTarget->Revoke();
m_AuxBusList.ClearList();
m_activeGameObjectCombo.ClearCombo();
m_AuxBusGameObjectCombo.ClearCombo();
for(int i = 0; i < s_iNumOfAuxBus; ++i )
m_AuxBusCombo[i].ClearCombo();
}
HCURSOR CSFTestAuxBusDlg::OnQueryDragIcon()
{
return static_cast<HCURSOR>(m_hIcon);
}
void CSFTestAuxBusDlg::Init( ISoundFrame * in_pSoundFrame, CSFAuxBusDropTarget* in_pDropTarget )
{
m_pSoundFrame = in_pSoundFrame;
m_pDropTarget = in_pDropTarget;
}
void CSFTestAuxBusDlg::AddAuxBusToList( IAuxBusList * in_pAuxBusList )
{
if( ::IsWindow( m_AuxBusList.GetSafeHwnd() ) )
m_AuxBusList.AddObjects( in_pAuxBusList );
}
void CSFTestAuxBusDlg::OnAuxBusNotif( IClient::Notif in_eNotif, AkUniqueID in_AuxBusID )
{
if( !::IsWindow( m_AuxBusList.GetSafeHwnd() ) )
return;
bool bHadAuxBus = false;
bool bSelected = false;
bool aWasSelected[s_iNumOfAuxBus] = {0};
if ( in_eNotif == IClient::Notif_Removed || in_eNotif == IClient::Notif_Changed )
{
// Remove AuxBus from list
bHadAuxBus = m_AuxBusList.RemoveObject( in_AuxBusID, bSelected );
// Remove the AuxBus from the Combo box
for(int i = 0; i < s_iNumOfAuxBus; ++i)
m_AuxBusCombo[i].RemoveObject( in_AuxBusID, aWasSelected[i] );
}
if ( in_eNotif == IClient::Notif_Changed || in_eNotif == IClient::Notif_Added )
{
IAuxBus * pAuxBus = NULL;
// Get the IAuxBus from its ID
m_pSoundFrame->GetAuxBus( in_AuxBusID, &pAuxBus );
if ( pAuxBus )
{
if ( bHadAuxBus && ( in_eNotif == IClient::Notif_Changed ) )
{
int idx = m_AuxBusList.AddObject( pAuxBus );
if ( bSelected )
m_AuxBusList.SetCurSel( idx );
}
for(int i = 0; i < s_iNumOfAuxBus; ++i)
{
int idx = m_AuxBusCombo[i].AddObject( pAuxBus );
if ( aWasSelected[i] )
m_AuxBusCombo[i].SetCurSel( idx );
}
// Release the AuxBus
pAuxBus->Release();
}
}
}
void CSFTestAuxBusDlg::UpdateGameObjectList()
{
if( ::IsWindow( m_activeGameObjectCombo.GetSafeHwnd() )
&& ::IsWindow( m_AuxBusGameObjectCombo.GetSafeHwnd() ))
{
AkGameObjectID selectedActiveObject = AK_INVALID_GAME_OBJECT;
AkGameObjectID selectedAuxBusObject = AK_INVALID_GAME_OBJECT;
int idx = m_activeGameObjectCombo.GetCurSel();
if( idx != CB_ERR )
selectedActiveObject = m_activeGameObjectCombo.GetObject( idx )->GetID();
idx = m_AuxBusGameObjectCombo.GetCurSel();
if( idx != CB_ERR )
selectedAuxBusObject = m_AuxBusGameObjectCombo.GetObject( idx )->GetID();
m_activeGameObjectCombo.ClearCombo();
m_AuxBusGameObjectCombo.ClearCombo();
IGameObjectList * pGameObjectList = NULL;
// Get all game object registered in Wwise
if ( m_pSoundFrame->GetGameObjectList( &pGameObjectList ) )
{
m_activeGameObjectCombo.AddObjects( pGameObjectList );
m_AuxBusGameObjectCombo.AddObjects( pGameObjectList );
pGameObjectList->Release();
if( ! m_activeGameObjectCombo.SelectObject( selectedActiveObject ) )
m_activeGameObjectCombo.SetCurSel( 0 );
if( ! m_AuxBusGameObjectCombo.SelectObject( selectedAuxBusObject ) )
m_AuxBusGameObjectCombo.SetCurSel( 0 );
}
OnLbnSelchangeActiveGameObjectListenerCombo();
OnLbnSelchangeAuxBusGameObjectCombo();
}
}
void CSFTestAuxBusDlg::OnLbnSelchangeActiveGameObjectListenerCombo()
{
int idxGO = m_activeGameObjectCombo.GetCurSel();
int iListenerIndex = m_activeListenerCombo.GetCurSel();
if( idxGO != CB_ERR && iListenerIndex != CB_ERR )
{
IGameObject* pGameObject = m_activeGameObjectCombo.GetObject( idxGO );
const ObstructionOcclusionLevel& rObsOccLevel = m_obstructionOcclusionMap[ GameObjectListenerPair( pGameObject->GetID(), iListenerIndex ) ];
m_obstructionLevelSlider.SetPos( (int)(rObsOccLevel.m_fObstruction * 100.0f) );
m_occlusionLevelSlider.SetPos( (int)(rObsOccLevel.m_fOcclusion * 100.0f) );
CString csTemp;
csTemp.Format( _T("%.2f"), rObsOccLevel.m_fObstruction );
SetDlgItemText( IDC_OBSTRUCTION_LEVEL_STATIC, csTemp );
csTemp.Format( _T("%.2f"), rObsOccLevel.m_fOcclusion );
SetDlgItemText( IDC_OCCLUSION_LEVEL_STATIC, csTemp );
}
else
{
m_obstructionLevelSlider.SetPos( 0 );
m_occlusionLevelSlider.SetPos( 0 );
SetDlgItemText( IDC_OBSTRUCTION_LEVEL_STATIC, _T("") );
SetDlgItemText( IDC_OCCLUSION_LEVEL_STATIC, _T("") );
}
}
void CSFTestAuxBusDlg::OnLbnSelchangeAuxBusGameObjectCombo()
{
int idx = m_AuxBusGameObjectCombo.GetCurSel();
if( idx != CB_ERR )
{
IGameObject* pGameObject = m_AuxBusGameObjectCombo.GetObject( idx );
const GameObjectAuxBus& rGameObjectAuxBus = m_gameObjectAuxBusMap[ pGameObject->GetID() ];
CString csTemp;
for(int i = 0; i < s_iNumOfAuxBus; ++i)
{
if( rGameObjectAuxBus.m_sAuxBusValue[i].auxBusID != AK_INVALID_AUX_ID )
{
m_AuxBusCombo[i].SelectObject( rGameObjectAuxBus.m_sAuxBusValue[i].auxBusID );
m_AuxBusSlider[i].SetPos( (int)(rGameObjectAuxBus.m_sAuxBusValue[i].fControlValue * 100.0f) );
csTemp.Format( _T("%.2f"), rGameObjectAuxBus.m_sAuxBusValue[i].fControlValue );
m_AuxBusStatic[i].SetWindowText( csTemp );
}
else
{
m_AuxBusCombo[i].SetCurSel( 0 );
m_AuxBusSlider[i].SetPos( 0 );
m_AuxBusStatic[i].SetWindowText( _T("") );
}
}
m_dryLevelSlider.SetPos( (int)(rGameObjectAuxBus.m_fDryLevel * 100.0f) );
csTemp.Format( _T("%.2f"), rGameObjectAuxBus.m_fDryLevel );
SetDlgItemText( IDC_GAME_OBJECT_DRY_LEVEL_STATIC, csTemp );
}
else
{
for(int i = 0; i < s_iNumOfAuxBus; ++i)
{
m_AuxBusCombo[i].SetCurSel( 0 );
m_AuxBusSlider[i].SetPos( 0 );
m_AuxBusStatic[i].SetWindowText( _T("") );
}
m_dryLevelSlider.SetPos(0);
SetDlgItemText( IDC_GAME_OBJECT_DRY_LEVEL_STATIC, _T("") );
}
}
void CSFTestAuxBusDlg::OnBnClickedGetAllAuxBus()
{
m_AuxBusList.ClearList();
IAuxBusList * pAuxBusList = NULL;
// Get all AuxBus created in the current Wwise project
if ( m_pSoundFrame->GetAuxBusList( &pAuxBusList ) )
{
AddAuxBusToList( pAuxBusList );
pAuxBusList->Release();
}
}
void CSFTestAuxBusDlg::OnBnClickedClearAuxBus()
{
m_AuxBusList.ClearList();
}
void CSFTestAuxBusDlg::OnGameObjectAuxBusChange()
{
int idx = m_AuxBusGameObjectCombo.GetCurSel();
if( idx != CB_ERR )
{
IGameObject* pGameObject = m_AuxBusGameObjectCombo.GetObject( idx );
GameObjectAuxBus& rGameObjectAuxBus = m_gameObjectAuxBusMap[ pGameObject->GetID() ];
std::vector<AkAuxSendValue> auxBusToSet;
for( int i = 0; i < s_iNumOfAuxBus; ++i )
{
IAuxBus* pEnv = NULL;
int envIdx = m_AuxBusCombo[i].GetCurSel();
if( envIdx != CB_ERR )
pEnv = m_AuxBusCombo[i].GetObject( envIdx );
if( pEnv )
{
rGameObjectAuxBus.m_sAuxBusValue[i].auxBusID = pEnv->GetID();
rGameObjectAuxBus.m_sAuxBusValue[i].fControlValue = (AkReal32)m_AuxBusSlider[i].GetPos() / 100.0f;
auxBusToSet.push_back( rGameObjectAuxBus.m_sAuxBusValue[i] );
CString csValue;
csValue.Format( _T("%.2f"), rGameObjectAuxBus.m_sAuxBusValue[i].fControlValue );
m_AuxBusStatic[i].SetWindowText( csValue );
}
else
{
rGameObjectAuxBus.m_sAuxBusValue[i].auxBusID = AK_INVALID_AUX_ID;
rGameObjectAuxBus.m_sAuxBusValue[i].fControlValue = 0.0f;
m_AuxBusSlider[i].SetPos( 0 );
m_AuxBusStatic[i].SetWindowText( _T("") );
}
}
// Set the AuxBus for the Selected Game Object
m_pSoundFrame->SetGameObjectAuxSendValues( pGameObject->GetID(), auxBusToSet.empty() ? NULL : &(auxBusToSet[0]), (AkUInt32)auxBusToSet.size() );
}
}
void CSFTestAuxBusDlg::OnHScroll( UINT nSBCode, UINT nPos, CScrollBar* pScrollBar )
{
if( pScrollBar->m_hWnd == m_obstructionLevelSlider.m_hWnd
|| pScrollBar->m_hWnd == m_occlusionLevelSlider.m_hWnd )
{
OnObstructionOcclusionChanged();
}
else if( pScrollBar->m_hWnd == m_dryLevelSlider.m_hWnd )
{
OnDryLevelChanged();
}
else
{
for( int i = 0; i < s_iNumOfAuxBus; ++i )
{
if( pScrollBar->m_hWnd == m_AuxBusSlider[i].m_hWnd )
{
OnGameObjectAuxBusChange();
break;
}
}
}
}
LRESULT CSFTestAuxBusDlg::OnShowListItems( WPARAM in_wParam, LPARAM in_lParam )
{
std::vector<GUID> * pGuids = (std::vector<GUID> *) in_lParam;
m_pSoundFrame->ShowWwiseObject( &pGuids->front(), pGuids->size(), (AK::SoundFrame::ISoundFrame::ShowLocation) in_wParam );
return TRUE;
}
void CSFTestAuxBusDlg::OnObstructionOcclusionChanged()
{
int idxGO = m_activeGameObjectCombo.GetCurSel();
int iListenerIndex = m_activeListenerCombo.GetCurSel();
if( idxGO != CB_ERR && iListenerIndex != CB_ERR )
{
IGameObject* pGameObject = m_activeGameObjectCombo.GetObject( idxGO );
ObstructionOcclusionLevel& rObsOccLevel = m_obstructionOcclusionMap[ GameObjectListenerPair( pGameObject->GetID(), iListenerIndex ) ];
// Keep the value in the map
rObsOccLevel.m_fObstruction = (AkReal32)m_obstructionLevelSlider.GetPos() / 100.0f;
rObsOccLevel.m_fOcclusion = (AkReal32)m_occlusionLevelSlider.GetPos() / 100.0f;
CString csTemp;
csTemp.Format( _T("%.2f"), rObsOccLevel.m_fObstruction );
SetDlgItemText( IDC_OBSTRUCTION_LEVEL_STATIC, csTemp );
csTemp.Format( _T("%.2f"), rObsOccLevel.m_fOcclusion );
SetDlgItemText( IDC_OCCLUSION_LEVEL_STATIC, csTemp );
// Change the obstruction and occlusion level between the Selected Game object and the Selected Listener.
m_pSoundFrame->SetObjectObstructionAndOcclusion( pGameObject->GetID(), iListenerIndex, rObsOccLevel.m_fObstruction, rObsOccLevel.m_fOcclusion );
}
}
void CSFTestAuxBusDlg::OnDryLevelChanged()
{
int idx = m_AuxBusGameObjectCombo.GetCurSel();
if( idx != CB_ERR )
{
IGameObject* pGameObject = m_AuxBusGameObjectCombo.GetObject( idx );
GameObjectAuxBus& rGameObjectAuxBus = m_gameObjectAuxBusMap[ pGameObject->GetID() ];
// Keep the value in the map
rGameObjectAuxBus.m_fDryLevel = (AkReal32)m_dryLevelSlider.GetPos() / 100.0f;
CString csTemp;
csTemp.Format( _T("%.2f"), rGameObjectAuxBus.m_fDryLevel );
SetDlgItemText( IDC_GAME_OBJECT_DRY_LEVEL_STATIC, csTemp );
// Set the Game object Dry level
m_pSoundFrame->SetGameObjectOutputBusVolume( pGameObject->GetID(), AK_INVALID_GAME_OBJECT, rGameObjectAuxBus.m_fDryLevel );
}
}
void CSFTestAuxBusDlg::FillAuxBusCombo()
{
IAuxBusList * pAuxBusList = NULL;
if ( m_pSoundFrame->GetAuxBusList( &pAuxBusList ) )
{
for(int i = 0; i < s_iNumOfAuxBus; ++i)
{
m_AuxBusCombo[i].ClearCombo();
// Add the none AuxBus
// Make sure that sorting is off in the combo box since we assume that the None element is
// at the index 0.
int idx = m_AuxBusCombo[i].AddString( _T("None") );
m_AuxBusCombo[i].SetItemDataPtr( idx, NULL );
m_AuxBusCombo[i].AddObjects( pAuxBusList );
}
pAuxBusList->Release();
}
} | 31.401691 | 146 | 0.745708 | [
"object",
"vector"
] |
fc65e761e29e9e18f463a61ad9b937a6bb38f628 | 924 | cpp | C++ | tests/test_hough_circle.cpp | hyu754/CV | b60a99ca1df9ae102baaa80a046b898ec0230b32 | [
"MIT"
] | null | null | null | tests/test_hough_circle.cpp | hyu754/CV | b60a99ca1df9ae102baaa80a046b898ec0230b32 | [
"MIT"
] | null | null | null | tests/test_hough_circle.cpp | hyu754/CV | b60a99ca1df9ae102baaa80a046b898ec0230b32 | [
"MIT"
] | null | null | null |
#include <iostream>
#include <ctime>
#include "opencv2/opencv_modules.hpp"
#include "opencv2/core.hpp"
#include "opencv2/features2d.hpp"
#include "opencv2/highgui.hpp"
#include "opencv2/cudafeatures2d.hpp"
#include "opencv2/xfeatures2d/cuda.hpp"
#include <opencv2/cudastereo.hpp>
#include <opencv2/cudaimgproc.hpp>
#include "hough_circle.h"
using namespace std;
using namespace cv;
using namespace cv::cuda;
int main(int argc, char* argv[])
{
VideoCapture cap(0);
if (!cap.isOpened()){
return -1;
}
cv::Mat input_image;
cap >> input_image;
hough_circle h_circle;
while (1){
cap >> input_image;
std::vector<cv::KeyPoint> keypoints_output = h_circle.find_circles(input_image);
cv::drawKeypoints(input_image, keypoints_output, input_image, cv::Scalar(200, 100, 200), cv::DrawMatchesFlags::DRAW_RICH_KEYPOINTS);
cv::imshow("keypoints", input_image);
cv::waitKey(1);
}
return 0;
}
| 16.5 | 134 | 0.721861 | [
"vector"
] |
fc6f9855af8843056ca699d979351c36779a4a3a | 9,512 | cc | C++ | tests/ut/cpp/dataset/c_api_vision_r_to_z_test.cc | chncwang/mindspore | 6dac92aedf0aa1541d181e6aedab29aaadc2dafb | [
"Apache-2.0"
] | null | null | null | tests/ut/cpp/dataset/c_api_vision_r_to_z_test.cc | chncwang/mindspore | 6dac92aedf0aa1541d181e6aedab29aaadc2dafb | [
"Apache-2.0"
] | null | null | null | tests/ut/cpp/dataset/c_api_vision_r_to_z_test.cc | chncwang/mindspore | 6dac92aedf0aa1541d181e6aedab29aaadc2dafb | [
"Apache-2.0"
] | null | null | null | /**
* Copyright 2020-2021 Huawei Technologies Co., Ltd
*
* 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 "common/common.h"
#include "minddata/dataset/include/datasets.h"
#include "minddata/dataset/include/transforms.h"
#include "minddata/dataset/include/vision.h"
using namespace mindspore::dataset;
class MindDataTestPipeline : public UT::DatasetOpTesting {
protected:
};
// Tests for vision C++ API R to Z TensorTransform Operations (in alphabetical order)
TEST_F(MindDataTestPipeline, TestRescaleSucess1) {
MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRescaleSucess1.";
// Create an ImageFolder Dataset
std::string folder_path = datasets_root_path_ + "/testPK/data/";
std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, std::make_shared<SequentialSampler>(0, 1));
EXPECT_NE(ds, nullptr);
// Create an iterator over the result of the above dataset
// This will trigger the creation of the Execution Tree and launch it.
std::shared_ptr<Iterator> iter = ds->CreateIterator();
EXPECT_NE(iter, nullptr);
// Iterate the dataset and get each row
std::unordered_map<std::string, mindspore::MSTensor> row;
iter->GetNextRow(&row);
auto image = row["image"];
// Create objects for the tensor ops
std::shared_ptr<TensorTransform> rescale(new mindspore::dataset::vision::Rescale(1.0, 0.0));
EXPECT_NE(rescale, nullptr);
// Convert to the same type
std::shared_ptr<TensorTransform> type_cast(new transforms::TypeCast("uint8"));
EXPECT_NE(type_cast, nullptr);
ds = ds->Map({rescale, type_cast}, {"image"});
EXPECT_NE(ds, nullptr);
// Create an iterator over the result of the above dataset
// This will trigger the creation of the Execution Tree and launch it.
std::shared_ptr<Iterator> iter1 = ds->CreateIterator();
EXPECT_NE(iter1, nullptr);
// Iterate the dataset and get each row1
std::unordered_map<std::string, mindspore::MSTensor> row1;
iter1->GetNextRow(&row1);
auto image1 = row1["image"];
// EXPECT_EQ(*image, *image1);
// Manually terminate the pipeline
iter1->Stop();
}
TEST_F(MindDataTestPipeline, TestRescaleSucess2) {
MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRescaleSucess2 with different params.";
// Create an ImageFolder Dataset
std::string folder_path = datasets_root_path_ + "/testPK/data/";
std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, std::make_shared<RandomSampler>(false, 1));
EXPECT_NE(ds, nullptr);
// Create objects for the tensor ops
std::shared_ptr<TensorTransform> rescale(new mindspore::dataset::vision::Rescale(1.0 / 255, 1.0));
EXPECT_NE(rescale, nullptr);
ds = ds->Map({rescale}, {"image"});
EXPECT_NE(ds, nullptr);
// Create an iterator over the result of the above dataset
// This will trigger the creation of the Execution Tree and launch it.
std::shared_ptr<Iterator> iter = ds->CreateIterator();
EXPECT_NE(iter, nullptr);
// Iterate the dataset and get each row
std::unordered_map<std::string, mindspore::MSTensor> row;
iter->GetNextRow(&row);
uint64_t i = 0;
while (row.size() != 0) {
i++;
// auto image = row["image"];
// MS_LOG(INFO) << "Tensor image shape: " << image->shape();
iter->GetNextRow(&row);
}
EXPECT_EQ(i, 1);
// Manually terminate the pipeline
iter->Stop();
}
TEST_F(MindDataTestPipeline, TestRescaleFail) {
MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRescaleFail with invalid params.";
// FIXME: For error tests, need to check for failure from CreateIterator execution
// incorrect negative rescale parameter
std::shared_ptr<TensorTransform> rescale(new mindspore::dataset::vision::Rescale(-1.0, 0.0));
EXPECT_NE(rescale, nullptr);
}
TEST_F(MindDataTestPipeline, TestResize1) {
MS_LOG(INFO) << "Doing MindDataTestPipeline-TestResize1 with single integer input.";
// Create an ImageFolder Dataset
std::string folder_path = datasets_root_path_ + "/testPK/data/";
std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, std::make_shared<RandomSampler>(false, 6));
EXPECT_NE(ds, nullptr);
// Create a Repeat operation on ds
int32_t repeat_num = 4;
ds = ds->Repeat(repeat_num);
EXPECT_NE(ds, nullptr);
// Create resize object with single integer input
std::shared_ptr<TensorTransform> resize_op(new vision::Resize({30}));
EXPECT_NE(resize_op, nullptr);
// Create a Map operation on ds
ds = ds->Map({resize_op});
EXPECT_NE(ds, nullptr);
// Create a Batch operation on ds
int32_t batch_size = 1;
ds = ds->Batch(batch_size);
EXPECT_NE(ds, nullptr);
// Create an iterator over the result of the above dataset
// This will trigger the creation of the Execution Tree and launch it.
std::shared_ptr<Iterator> iter = ds->CreateIterator();
EXPECT_NE(iter, nullptr);
// Iterate the dataset and get each row
std::unordered_map<std::string, mindspore::MSTensor> row;
iter->GetNextRow(&row);
uint64_t i = 0;
while (row.size() != 0) {
i++;
// auto image = row["image"];
// MS_LOG(INFO) << "Tensor image shape: " << image->shape();
iter->GetNextRow(&row);
}
EXPECT_EQ(i, 24);
// Manually terminate the pipeline
iter->Stop();
}
TEST_F(MindDataTestPipeline, TestResizeFail) {
MS_LOG(INFO) << "Doing MindDataTestPipeline-TestResize with invalid parameters.";
// FIXME: For error tests, need to check for failure from CreateIterator execution
// negative resize value
std::shared_ptr<TensorTransform> resize_op1(new mindspore::dataset::vision::Resize({30, -30}));
EXPECT_NE(resize_op1, nullptr);
// zero resize value
std::shared_ptr<TensorTransform> resize_op2(new mindspore::dataset::vision::Resize({0, 30}));
EXPECT_NE(resize_op2, nullptr);
// resize with 3 values
std::shared_ptr<TensorTransform> resize_op3(new mindspore::dataset::vision::Resize({30, 20, 10}));
EXPECT_NE(resize_op3, nullptr);
}
TEST_F(MindDataTestPipeline, TestResizeWithBBoxSuccess) {
MS_LOG(INFO) << "Doing MindDataTestPipeline-TestResizeWithBBoxSuccess.";
// Create an VOC Dataset
std::string folder_path = datasets_root_path_ + "/testVOC2012_2";
std::shared_ptr<Dataset> ds = VOC(folder_path, "Detection", "train", {}, true, std::make_shared<SequentialSampler>(0, 3));
EXPECT_NE(ds, nullptr);
// Create objects for the tensor ops
std::shared_ptr<TensorTransform> resize_with_bbox_op(new vision::ResizeWithBBox({30}));
EXPECT_NE(resize_with_bbox_op, nullptr);
std::shared_ptr<TensorTransform> resize_with_bbox_op1(new vision::ResizeWithBBox({30, 30}));
EXPECT_NE(resize_with_bbox_op1, nullptr);
// Create a Map operation on ds
ds = ds->Map({resize_with_bbox_op, resize_with_bbox_op1}, {"image", "bbox"}, {"image", "bbox"}, {"image", "bbox"});
EXPECT_NE(ds, nullptr);
// Create an iterator over the result of the above dataset
// This will trigger the creation of the Execution Tree and launch it.
std::shared_ptr<Iterator> iter = ds->CreateIterator();
EXPECT_NE(iter, nullptr);
// Iterate the dataset and get each row
std::unordered_map<std::string, mindspore::MSTensor> row;
iter->GetNextRow(&row);
uint64_t i = 0;
while (row.size() != 0) {
i++;
// auto image = row["image"];
// MS_LOG(INFO) << "Tensor image shape: " << image->shape();
iter->GetNextRow(&row);
}
EXPECT_EQ(i, 3);
// Manually terminate the pipeline
iter->Stop();
}
TEST_F(MindDataTestPipeline, TestResizeWithBBoxFail) {
MS_LOG(INFO) << "Doing MindDataTestPipeline-TestResizeWithBBoxFail with invalid parameters.";
// FIXME: For error tests, need to check for failure from CreateIterator execution
// Testing negative resize value
std::shared_ptr<TensorTransform> resize_with_bbox_op(new vision::ResizeWithBBox({10, -10}));
EXPECT_NE(resize_with_bbox_op, nullptr);
// Testing negative resize value
std::shared_ptr<TensorTransform> resize_with_bbox_op1(new vision::ResizeWithBBox({-10}));
EXPECT_NE(resize_with_bbox_op1, nullptr);
// Testinig zero resize value
std::shared_ptr<TensorTransform> resize_with_bbox_op2(new vision::ResizeWithBBox({0, 10}));
EXPECT_NE(resize_with_bbox_op2, nullptr);
// Testing resize with 3 values
std::shared_ptr<TensorTransform> resize_with_bbox_op3(new vision::ResizeWithBBox({10, 10, 10}));
EXPECT_NE(resize_with_bbox_op3, nullptr);
}
TEST_F(MindDataTestPipeline, TestVisionOperationName) {
MS_LOG(INFO) << "Doing MindDataTestPipeline-TestVisionOperationName.";
std::string correct_name;
// Create object for the tensor op, and check the name
/* FIXME - Update and move test to IR level
std::shared_ptr<TensorOperation> random_vertical_flip_op = vision::RandomVerticalFlip(0.5);
correct_name = "RandomVerticalFlip";
EXPECT_EQ(correct_name, random_vertical_flip_op->Name());
// Create object for the tensor op, and check the name
std::shared_ptr<TensorOperation> softDvpp_decode_resize_jpeg_op = vision::SoftDvppDecodeResizeJpeg({1, 1});
correct_name = "SoftDvppDecodeResizeJpeg";
EXPECT_EQ(correct_name, softDvpp_decode_resize_jpeg_op->Name());
*/
}
| 37.15625 | 124 | 0.728553 | [
"object",
"shape"
] |
fc7550e7bb13064e05997c573c1993f1bc1ec64b | 6,643 | cpp | C++ | src/SingleLayerOptics/src/BSDFIntegrator.cpp | bakonyidani/Windows-CalcEngine | afa4c4a9f88199c6206af8bc994a073931fc8b91 | [
"BSD-3-Clause-LBNL"
] | null | null | null | src/SingleLayerOptics/src/BSDFIntegrator.cpp | bakonyidani/Windows-CalcEngine | afa4c4a9f88199c6206af8bc994a073931fc8b91 | [
"BSD-3-Clause-LBNL"
] | null | null | null | src/SingleLayerOptics/src/BSDFIntegrator.cpp | bakonyidani/Windows-CalcEngine | afa4c4a9f88199c6206af8bc994a073931fc8b91 | [
"BSD-3-Clause-LBNL"
] | null | null | null | #include "BSDFIntegrator.hpp"
#include "BSDFDirections.hpp"
#include "BSDFPatch.hpp"
#include "WCECommon.hpp"
using namespace FenestrationCommon;
namespace SingleLayerOptics
{
CBSDFIntegrator::CBSDFIntegrator(const std::shared_ptr<const CBSDFIntegrator> & t_Integrator) :
m_Directions(t_Integrator->m_Directions),
m_DimMatrices(m_Directions.size()),
m_HemisphericalCalculated(false),
m_DiffuseDiffuseCalculated(false)
{
for(auto t_Side : EnumSide())
{
for(auto t_Property : EnumPropertySimple())
{
m_Matrix[std::make_pair(t_Side, t_Property)] = SquareMatrix(m_DimMatrices);
m_Hem[std::make_pair(t_Side, t_Property)] = std::vector<double>(m_DimMatrices);
}
}
}
CBSDFIntegrator::CBSDFIntegrator(const CBSDFDirections & t_Directions) :
m_Directions(t_Directions),
m_DimMatrices(m_Directions.size()),
m_HemisphericalCalculated(false),
m_DiffuseDiffuseCalculated(false)
{
for(auto t_Side : EnumSide())
{
for(auto t_Property : EnumPropertySimple())
{
m_Matrix[std::make_pair(t_Side, t_Property)] = SquareMatrix(m_DimMatrices);
m_Hem[std::make_pair(t_Side, t_Property)] = std::vector<double>(m_DimMatrices);
}
}
}
double CBSDFIntegrator::DiffDiff(const Side t_Side, const PropertySimple t_Property)
{
calcDiffuseDiffuse();
return m_MapDiffDiff.at(t_Side, t_Property);
}
SquareMatrix & CBSDFIntegrator::getMatrix(const Side t_Side, const PropertySimple t_Property)
{
return m_Matrix[std::make_pair(t_Side, t_Property)];
}
const FenestrationCommon::SquareMatrix &
CBSDFIntegrator::at(const FenestrationCommon::Side t_Side,
const FenestrationCommon::PropertySimple t_Property) const
{
return m_Matrix.at(std::make_pair(t_Side, t_Property));
}
void CBSDFIntegrator::setResultMatrices(const SquareMatrix & t_Tau,
const SquareMatrix & t_Rho,
Side t_Side)
{
m_Matrix[std::make_pair(t_Side, PropertySimple::T)] = t_Tau;
m_Matrix[std::make_pair(t_Side, PropertySimple::R)] = t_Rho;
}
double CBSDFIntegrator::DirDir(const Side t_Side,
const PropertySimple t_Property,
const double t_Theta,
const double t_Phi) const
{
const auto index = m_Directions.getNearestBeamIndex(t_Theta, t_Phi);
const auto lambda = m_Directions.lambdaVector()[index];
const auto tau = at(t_Side, t_Property)(index, index);
return tau * lambda;
}
double CBSDFIntegrator::DirDir(const Side t_Side,
const PropertySimple t_Property,
const size_t Index) const
{
const auto lambda = m_Directions.lambdaVector()[Index];
const auto tau = at(t_Side, t_Property)(Index, Index);
return tau * lambda;
}
std::vector<double> CBSDFIntegrator::DirHem(const FenestrationCommon::Side t_Side,
const FenestrationCommon::PropertySimple t_Property)
{
calcHemispherical();
return m_Hem.at(std::make_pair(t_Side, t_Property));
}
std::vector<double> CBSDFIntegrator::Abs(Side t_Side)
{
calcHemispherical();
return m_Abs.at(t_Side);
}
double CBSDFIntegrator::DirHem(const Side t_Side,
const PropertySimple t_Property,
const double t_Theta,
const double t_Phi)
{
const auto index = m_Directions.getNearestBeamIndex(t_Theta, t_Phi);
return DirHem(t_Side, t_Property)[index];
}
double CBSDFIntegrator::Abs(const Side t_Side, const double t_Theta, const double t_Phi)
{
const auto index = m_Directions.getNearestBeamIndex(t_Theta, t_Phi);
return Abs(t_Side)[index];
}
double CBSDFIntegrator::Abs(const Side t_Side, const size_t Index)
{
return Abs(t_Side)[Index];
}
std::vector<double> CBSDFIntegrator::lambdaVector() const
{
return m_Directions.lambdaVector();
}
SquareMatrix CBSDFIntegrator::lambdaMatrix() const
{
return m_Directions.lambdaMatrix();
}
double CBSDFIntegrator::integrate(SquareMatrix const & t_Matrix) const
{
using ConstantsData::PI;
double sum = 0;
for(size_t i = 0; i < m_DimMatrices; ++i)
{
for(size_t j = 0; j < m_DimMatrices; ++j)
{
sum += t_Matrix(i, j) * m_Directions[i].lambda() * m_Directions[j].lambda();
}
}
return sum / PI;
}
void CBSDFIntegrator::calcDiffuseDiffuse()
{
if(!m_DiffuseDiffuseCalculated)
{
for(auto t_Side : EnumSide())
{
for(auto t_Property : EnumPropertySimple())
{
m_MapDiffDiff(t_Side, t_Property) = integrate(getMatrix(t_Side, t_Property));
}
}
m_DiffuseDiffuseCalculated = true;
}
}
size_t CBSDFIntegrator::getNearestBeamIndex(const double t_Theta, const double t_Phi) const
{
return m_Directions.getNearestBeamIndex(t_Theta, t_Phi);
}
void CBSDFIntegrator::calcHemispherical()
{
if(!m_HemisphericalCalculated)
{
for(Side t_Side : EnumSide())
{
for(PropertySimple t_Property : EnumPropertySimple())
{
m_Hem[std::make_pair(t_Side, t_Property)] =
m_Directions.lambdaVector() * m_Matrix.at(std::make_pair(t_Side, t_Property));
}
m_Abs[t_Side] = std::vector<double>();
}
const auto size = m_Hem[std::make_pair(Side::Front, PropertySimple::T)].size();
for(size_t i = 0; i < size; ++i)
{
for(Side t_Side : EnumSide())
{
m_Abs.at(t_Side).push_back(
1.0 - m_Hem.at(std::make_pair(t_Side, PropertySimple::T))[i]
- m_Hem.at(std::make_pair(t_Side, PropertySimple::R))[i]);
}
}
m_HemisphericalCalculated = true;
}
}
} // namespace SingleLayerOptics
| 34.242268 | 100 | 0.576396 | [
"vector"
] |
fc764866a256ea169654ebbd96d23dc905105cd0 | 20,465 | cpp | C++ | SDK/src/NDK/Lua/LuaBinding_Graphics.cpp | AntoineJT/NazaraEngine | e0b05a7e7a2779e20a593b4083b4a881cc57ce14 | [
"BSD-3-Clause-Clear",
"Apache-2.0",
"MIT"
] | null | null | null | SDK/src/NDK/Lua/LuaBinding_Graphics.cpp | AntoineJT/NazaraEngine | e0b05a7e7a2779e20a593b4083b4a881cc57ce14 | [
"BSD-3-Clause-Clear",
"Apache-2.0",
"MIT"
] | null | null | null | SDK/src/NDK/Lua/LuaBinding_Graphics.cpp | AntoineJT/NazaraEngine | e0b05a7e7a2779e20a593b4083b4a881cc57ce14 | [
"BSD-3-Clause-Clear",
"Apache-2.0",
"MIT"
] | null | null | null | // This file is part of the "Nazara Development Kit"
// For conditions of distribution and use, see copyright notice in Prerequisites.hpp
#include <NDK/Lua/LuaBinding_Graphics.hpp>
#include <NDK/LuaAPI.hpp>
namespace Ndk
{
std::unique_ptr<LuaBinding_Base> LuaBinding_Base::BindGraphics(LuaBinding& binding)
{
return std::make_unique<LuaBinding_Graphics>(binding);
}
LuaBinding_Graphics::LuaBinding_Graphics(LuaBinding& binding) :
LuaBinding_Base(binding)
{
/*********************************** Nz::AbstractViewer ***********************************/
abstractViewer.Reset("AbstractViewer");
{
abstractViewer.BindMethod("GetAspectRatio", &Nz::AbstractViewer::GetAspectRatio);
abstractViewer.BindMethod("GetEyePosition", &Nz::AbstractViewer::GetEyePosition);
abstractViewer.BindMethod("GetForward", &Nz::AbstractViewer::GetForward);
//abstractViewer.BindMethod("GetFrustum", &Nz::AbstractViewer::GetFrustum);
abstractViewer.BindMethod("GetProjectionMatrix", &Nz::AbstractViewer::GetProjectionMatrix);
//abstractViewer.BindMethod("GetTarget", &Nz::AbstractViewer::GetTarget);
abstractViewer.BindMethod("GetViewMatrix", &Nz::AbstractViewer::GetViewMatrix);
abstractViewer.BindMethod("GetViewport", &Nz::AbstractViewer::GetViewport);
abstractViewer.BindMethod("GetZFar", &Nz::AbstractViewer::GetZFar);
abstractViewer.BindMethod("GetZNear", &Nz::AbstractViewer::GetZNear);
}
/*********************************** Nz::InstancedRenderable ***********************************/
instancedRenderable.Reset("InstancedRenderable");
{
instancedRenderable.BindMethod("GetMaterial", [] (Nz::LuaState& lua, Nz::InstancedRenderable* instance, std::size_t argumentCount) -> int
{
std::size_t argCount = std::min<std::size_t>(argumentCount, 2U);
switch (argCount)
{
case 0:
case 1:
{
int argIndex = 2;
std::size_t matIndex(lua.Check<std::size_t>(&argIndex, 0));
return lua.Push(instance->GetMaterial(matIndex));
}
case 2:
{
int argIndex = 2;
std::size_t skinIndex(lua.Check<std::size_t>(&argIndex));
std::size_t matIndex(lua.Check<std::size_t>(&argIndex));
return lua.Push(instance->GetMaterial(skinIndex, matIndex));
}
}
lua.Error("No matching overload for method GetMaterial");
return 0;
});
instancedRenderable.BindMethod("GetMaterialCount", &Nz::InstancedRenderable::GetMaterialCount);
instancedRenderable.BindMethod("GetSkin", &Nz::InstancedRenderable::GetSkin);
instancedRenderable.BindMethod("GetSkinCount", &Nz::InstancedRenderable::GetSkinCount);
instancedRenderable.BindMethod("SetSkin", &Nz::InstancedRenderable::SetSkin);
instancedRenderable.BindMethod("SetSkinCount", &Nz::InstancedRenderable::SetSkinCount);
}
/*********************************** Nz::Material ***********************************/
material.Reset("Material");
{
material.SetConstructor([] (Nz::LuaState& lua, Nz::MaterialRef* instance, std::size_t argumentCount)
{
switch (argumentCount)
{
case 0:
Nz::PlacementNew(instance, Nz::Material::New());
return true;
case 1:
{
int argIndex = 1;
if (lua.IsOfType(argIndex, "MaterialPipeline"))
{
Nz::PlacementNew(instance, Nz::Material::New(*static_cast<Nz::MaterialPipelineRef*>(lua.ToUserdata(argIndex))));
return true;
}
else if (lua.IsOfType(argIndex, "Material"))
{
Nz::PlacementNew(instance, Nz::Material::New(**static_cast<Nz::MaterialRef*>(lua.ToUserdata(argIndex))));
return true;
}
else
{
Nz::PlacementNew(instance, Nz::Material::New(lua.Check<Nz::String>(&argIndex)));
return true;
}
}
}
lua.Error("No matching overload for constructor");
return false;
});
material.BindMethod("Configure", [] (Nz::LuaState& lua, Nz::MaterialRef& instance, std::size_t /*argumentCount*/) -> int
{
int argIndex = 2;
if (lua.IsOfType(argIndex, "MaterialPipeline"))
{
instance->Configure(*static_cast<Nz::MaterialPipelineRef*>(lua.ToUserdata(argIndex)));
return 0;
}
else
{
lua.Push(instance->Configure(lua.Check<Nz::String>(&argIndex)));
return 1;
}
});
material.BindMethod("EnableAlphaTest", &Nz::Material::EnableAlphaTest);
material.BindMethod("EnableBlending", &Nz::Material::EnableBlending);
material.BindMethod("EnableColorWrite", &Nz::Material::EnableColorWrite);
material.BindMethod("EnableDepthBuffer", &Nz::Material::EnableDepthBuffer);
material.BindMethod("EnableDepthSorting", &Nz::Material::EnableDepthSorting);
material.BindMethod("EnableDepthWrite", &Nz::Material::EnableDepthWrite);
material.BindMethod("EnableFaceCulling", &Nz::Material::EnableFaceCulling);
material.BindMethod("EnableReflectionMapping", &Nz::Material::EnableReflectionMapping);
material.BindMethod("EnableScissorTest", &Nz::Material::EnableScissorTest);
material.BindMethod("EnableShadowCasting", &Nz::Material::EnableShadowCasting);
material.BindMethod("EnableShadowReceive", &Nz::Material::EnableShadowReceive);
material.BindMethod("EnableStencilTest", &Nz::Material::EnableStencilTest);
material.BindMethod("EnsurePipelineUpdate", &Nz::Material::EnsurePipelineUpdate);
material.BindMethod("GetAlphaMap", &Nz::Material::GetAlphaMap);
material.BindMethod("GetAlphaThreshold", &Nz::Material::GetAlphaThreshold);
material.BindMethod("GetAmbientColor", &Nz::Material::GetAmbientColor);
material.BindMethod("GetDepthFunc", &Nz::Material::GetDepthFunc);
material.BindMethod("GetDepthMaterial", &Nz::Material::GetDepthMaterial);
material.BindMethod("GetDiffuseColor", &Nz::Material::GetDiffuseColor);
material.BindMethod("GetDiffuseMap", &Nz::Material::GetDiffuseMap);
//material.BindMethod("GetDiffuseSampler", &Nz::Material::GetDiffuseSampler);
material.BindMethod("GetDstBlend", &Nz::Material::GetDstBlend);
material.BindMethod("GetEmissiveMap", &Nz::Material::GetEmissiveMap);
material.BindMethod("GetFaceCulling", &Nz::Material::GetFaceCulling);
material.BindMethod("GetFaceFilling", &Nz::Material::GetFaceFilling);
material.BindMethod("GetHeightMap", &Nz::Material::GetHeightMap);
material.BindMethod("GetLineWidth", &Nz::Material::GetLineWidth);
material.BindMethod("GetNormalMap", &Nz::Material::GetNormalMap);
//material.BindMethod("GetPipeline", &Nz::Material::GetPipeline);
//material.BindMethod("GetPipelineInfo", &Nz::Material::GetPipelineInfo);
material.BindMethod("GetPointSize", &Nz::Material::GetPointSize);
material.BindMethod("GetReflectionMode", &Nz::Material::GetReflectionMode);
//material.BindMethod("GetShader", &Nz::Material::GetShader);
material.BindMethod("GetShininess", &Nz::Material::GetShininess);
material.BindMethod("GetSpecularColor", &Nz::Material::GetSpecularColor);
material.BindMethod("GetSpecularMap", &Nz::Material::GetSpecularMap);
//material.BindMethod("GetSpecularSampler", &Nz::Material::GetSpecularSampler);
material.BindMethod("GetSrcBlend", &Nz::Material::GetSrcBlend);
material.BindMethod("HasAlphaMap", &Nz::Material::HasAlphaMap);
material.BindMethod("HasDepthMaterial", &Nz::Material::HasDepthMaterial);
material.BindMethod("HasDiffuseMap", &Nz::Material::HasDiffuseMap);
material.BindMethod("HasEmissiveMap", &Nz::Material::HasEmissiveMap);
material.BindMethod("HasHeightMap", &Nz::Material::HasHeightMap);
material.BindMethod("HasNormalMap", &Nz::Material::HasNormalMap);
material.BindMethod("HasSpecularMap", &Nz::Material::HasSpecularMap);
material.BindMethod("IsAlphaTestEnabled", &Nz::Material::IsAlphaTestEnabled);
material.BindMethod("IsBlendingEnabled", &Nz::Material::IsBlendingEnabled);
material.BindMethod("IsColorWriteEnabled", &Nz::Material::IsColorWriteEnabled);
material.BindMethod("IsDepthBufferEnabled", &Nz::Material::IsDepthBufferEnabled);
material.BindMethod("IsDepthSortingEnabled", &Nz::Material::IsDepthSortingEnabled);
material.BindMethod("IsDepthWriteEnabled", &Nz::Material::IsDepthWriteEnabled);
material.BindMethod("IsFaceCullingEnabled", &Nz::Material::IsFaceCullingEnabled);
material.BindMethod("IsReflectionMappingEnabled", &Nz::Material::IsReflectionMappingEnabled);
material.BindMethod("IsScissorTestEnabled", &Nz::Material::IsScissorTestEnabled);
material.BindMethod("IsStencilTestEnabled", &Nz::Material::IsStencilTestEnabled);
material.BindMethod("IsShadowCastingEnabled", &Nz::Material::IsShadowCastingEnabled);
material.BindMethod("IsShadowReceiveEnabled", &Nz::Material::IsShadowReceiveEnabled);
material.BindMethod("Reset", &Nz::Material::Reset);
material.BindMethod("SetAlphaThreshold", &Nz::Material::SetAlphaThreshold);
material.BindMethod("SetAmbientColor", &Nz::Material::SetAmbientColor);
material.BindMethod("SetDepthFunc", &Nz::Material::SetDepthFunc);
material.BindMethod("SetDepthFunc", &Nz::Material::SetDepthFunc);
material.BindMethod("SetDepthMaterial", &Nz::Material::SetDepthMaterial);
material.BindMethod("SetDiffuseColor", &Nz::Material::SetDiffuseColor);
//material.BindMethod("SetDiffuseSampler", &Nz::Material::SetDiffuseSampler);
material.BindMethod("SetDstBlend", &Nz::Material::SetDstBlend);
material.BindMethod("SetFaceCulling", &Nz::Material::SetFaceCulling);
material.BindMethod("SetFaceFilling", &Nz::Material::SetFaceFilling);
material.BindMethod("SetLineWidth", &Nz::Material::SetLineWidth);
material.BindMethod("SetPointSize", &Nz::Material::SetPointSize);
material.BindMethod("SetReflectionMode", &Nz::Material::SetReflectionMode);
material.BindMethod("SetShininess", &Nz::Material::SetShininess);
material.BindMethod("SetSpecularColor", &Nz::Material::SetSpecularColor);
material.BindMethod("SetSpecularColor", &Nz::Material::SetSpecularColor);
//material.BindMethod("SetSpecularSampler", &Nz::Material::SetSpecularSampler);
material.BindMethod("SetSrcBlend", &Nz::Material::SetSrcBlend);
material.BindStaticMethod("GetDefault", &Nz::Material::GetDefault);
material.BindStaticMethod("LoadFromFile", &Nz::Material::LoadFromFile, Nz::MaterialParams());
material.BindMethod("SetAlphaMap", [] (Nz::LuaState& lua, Nz::MaterialRef& instance, std::size_t /*argumentCount*/) -> int
{
int argIndex = 2;
if (lua.IsOfType(argIndex, "Texture"))
{
instance->SetAlphaMap(*static_cast<Nz::TextureRef*>(lua.ToUserdata(argIndex)));
return 0;
}
else
return lua.Push(instance->SetAlphaMap(lua.Check<Nz::String>(&argIndex)));
});
material.BindMethod("SetDiffuseMap", [] (Nz::LuaState& lua, Nz::MaterialRef& instance, std::size_t /*argumentCount*/) -> int
{
int argIndex = 2;
if (lua.IsOfType(argIndex, "Texture"))
{
instance->SetDiffuseMap(*static_cast<Nz::TextureRef*>(lua.ToUserdata(argIndex)));
return 0;
}
else
return lua.Push(instance->SetDiffuseMap(lua.Check<Nz::String>(&argIndex)));
});
material.BindMethod("SetEmissiveMap", [] (Nz::LuaState& lua, Nz::MaterialRef& instance, std::size_t /*argumentCount*/) -> int
{
int argIndex = 2;
if (lua.IsOfType(argIndex, "Texture"))
{
instance->SetEmissiveMap(*static_cast<Nz::TextureRef*>(lua.ToUserdata(argIndex)));
return 0;
}
else
return lua.Push(instance->SetEmissiveMap(lua.Check<Nz::String>(&argIndex)));
});
material.BindMethod("SetHeightMap", [] (Nz::LuaState& lua, Nz::MaterialRef& instance, std::size_t /*argumentCount*/) -> int
{
int argIndex = 2;
if (lua.IsOfType(argIndex, "Texture"))
{
instance->SetHeightMap(*static_cast<Nz::TextureRef*>(lua.ToUserdata(argIndex)));
return 0;
}
else
return lua.Push(instance->SetHeightMap(lua.Check<Nz::String>(&argIndex)));
});
material.BindMethod("SetNormalMap", [] (Nz::LuaState& lua, Nz::MaterialRef& instance, std::size_t /*argumentCount*/) -> int
{
int argIndex = 2;
if (lua.IsOfType(argIndex, "Texture"))
{
instance->SetNormalMap(*static_cast<Nz::TextureRef*>(lua.ToUserdata(argIndex)));
return 0;
}
else
return lua.Push(instance->SetNormalMap(lua.Check<Nz::String>(&argIndex)));
});
material.BindMethod("SetShader", [] (Nz::LuaState& lua, Nz::MaterialRef& instance, std::size_t /*argumentCount*/) -> int
{
int argIndex = 2;
if (lua.IsOfType(argIndex, "UberShader"))
{
instance->SetShader(*static_cast<Nz::UberShaderRef*>(lua.ToUserdata(argIndex)));
return 0;
}
else
return lua.Push(instance->SetShader(lua.Check<Nz::String>(&argIndex)));
});
material.BindMethod("SetSpecularMap", [] (Nz::LuaState& lua, Nz::MaterialRef& instance, std::size_t /*argumentCount*/) -> int
{
int argIndex = 2;
if (lua.IsOfType(argIndex, "Texture"))
{
instance->SetSpecularMap(*static_cast<Nz::TextureRef*>(lua.ToUserdata(argIndex)));
return 0;
}
else
return lua.Push(instance->SetSpecularMap(lua.Check<Nz::String>(&argIndex)));
});
}
/*********************************** Nz::Model ***********************************/
model.Reset("Model");
{
model.Inherit<Nz::InstancedRenderableRef>(instancedRenderable, [] (Nz::ModelRef* modelRef) -> Nz::InstancedRenderableRef*
{
return reinterpret_cast<Nz::InstancedRenderableRef*>(modelRef); //TODO: Make a ObjectRefCast
});
model.SetConstructor([] (Nz::LuaState& /*lua*/, Nz::ModelRef* instance, std::size_t /*argumentCount*/)
{
Nz::PlacementNew(instance, Nz::Model::New());
return true;
});
//modelClass.SetMethod("GetMesh", &Nz::Model::GetMesh);
model.BindMethod("IsAnimated", &Nz::Model::IsAnimated);
model.BindMethod("SetMaterial", [] (Nz::LuaState& lua, Nz::Model* instance, std::size_t argumentCount) -> int
{
std::size_t argCount = std::min<std::size_t>(argumentCount, 3U);
switch (argCount)
{
case 2:
{
int argIndex = 2;
if (lua.IsOfType(argIndex, Nz::LuaType_Number))
{
std::size_t matIndex(lua.Check<std::size_t>(&argIndex));
Nz::MaterialRef mat(lua.Check<Nz::MaterialRef>(&argIndex));
instance->SetMaterial(matIndex, std::move(mat));
return 0;
}
else if (lua.IsOfType(argIndex, Nz::LuaType_String))
{
Nz::String subMesh(lua.Check<Nz::String>(&argIndex));
Nz::MaterialRef mat(lua.Check<Nz::MaterialRef>(&argIndex));
instance->SetMaterial(subMesh, std::move(mat));
return 0;
}
break;
}
case 3:
{
int argIndex = 2;
if (lua.IsOfType(argIndex, Nz::LuaType_Number))
{
std::size_t skinIndex(lua.Check<std::size_t>(&argIndex));
std::size_t matIndex(lua.Check<std::size_t>(&argIndex));
Nz::MaterialRef mat(lua.Check<Nz::MaterialRef>(&argIndex));
instance->SetMaterial(skinIndex, matIndex, std::move(mat));
return 0;
}
else if (lua.IsOfType(argIndex, Nz::LuaType_String))
{
std::size_t skinIndex(lua.Check<std::size_t>(&argIndex));
Nz::String subMesh(lua.Check<Nz::String>(&argIndex));
Nz::MaterialRef materialRef(lua.Check<Nz::MaterialRef>(&argIndex));
instance->SetMaterial(skinIndex, subMesh, std::move(materialRef));
return 0;
}
break;
}
}
lua.Error("No matching overload for method SetMaterial");
return 0;
});
//modelClass.SetMethod("SetMesh", &Nz::Model::SetMesh);
//modelClass.SetMethod("SetSequence", &Nz::Model::SetSequence);
model.BindStaticMethod("LoadFromFile", &Nz::Model::LoadFromFile, Nz::ModelParameters());
}
/*********************************** Nz::Sprite ***********************************/
sprite.Reset("Sprite");
{
sprite.Inherit<Nz::InstancedRenderableRef>(instancedRenderable, [] (Nz::SpriteRef* spriteRef) -> Nz::InstancedRenderableRef*
{
return reinterpret_cast<Nz::InstancedRenderableRef*>(spriteRef); //TODO: Make a ObjectRefCast
});
sprite.SetConstructor([] (Nz::LuaState& /*lua*/, Nz::SpriteRef* instance, std::size_t /*argumentCount*/)
{
Nz::PlacementNew(instance, Nz::Sprite::New());
return true;
});
sprite.BindMethod("GetColor", &Nz::Sprite::GetColor);
sprite.BindMethod("GetCornerColor", &Nz::Sprite::GetCornerColor);
sprite.BindMethod("GetOrigin", &Nz::Sprite::GetOrigin);
sprite.BindMethod("GetSize", &Nz::Sprite::GetSize);
sprite.BindMethod("GetTextureCoords", &Nz::Sprite::GetTextureCoords);
sprite.BindMethod("SetColor", &Nz::Sprite::SetColor);
sprite.BindMethod("SetCornerColor", &Nz::Sprite::SetCornerColor);
sprite.BindMethod("SetDefaultMaterial", &Nz::Sprite::SetDefaultMaterial);
sprite.BindMethod("SetOrigin", &Nz::Sprite::SetOrigin);
sprite.BindMethod("SetSize", (void(Nz::Sprite::*)(const Nz::Vector2f&)) &Nz::Sprite::SetSize);
sprite.BindMethod("SetTextureCoords", &Nz::Sprite::SetTextureCoords);
sprite.BindMethod("SetTextureRect", &Nz::Sprite::SetTextureRect);
sprite.BindMethod("SetMaterial", [] (Nz::LuaState& lua, Nz::SpriteRef& instance, std::size_t /*argumentCount*/) -> int
{
int argIndex = 2;
if (lua.IsOfType(argIndex, "Material"))
{
bool resizeSprite = lua.CheckBoolean(argIndex + 1, true);
instance->SetMaterial(*static_cast<Nz::MaterialRef*>(lua.ToUserdata(argIndex)), resizeSprite);
}
else if (lua.IsOfType(argIndex, Nz::LuaType_String))
{
bool resizeSprite = lua.CheckBoolean(argIndex + 1, true);
instance->SetMaterial(lua.ToString(argIndex), resizeSprite);
}
else if (lua.IsOfType(argIndex, Nz::LuaType_Number))
{
std::size_t skinIndex(lua.Check<std::size_t>(&argIndex));
bool resizeSprite = lua.CheckBoolean(argIndex + 1, true);
if (lua.IsOfType(argIndex, "Material"))
instance->SetMaterial(skinIndex, *static_cast<Nz::MaterialRef*>(lua.ToUserdata(argIndex)), resizeSprite);
else
instance->SetMaterial(skinIndex, lua.Check<Nz::String>(&argIndex), resizeSprite);
}
return 0;
});
sprite.BindMethod("SetTexture", [] (Nz::LuaState& lua, Nz::SpriteRef& instance, std::size_t /*argumentCount*/) -> int
{
int argIndex = 2;
if (lua.IsOfType(argIndex, "Texture"))
{
bool resizeSprite = lua.CheckBoolean(argIndex + 1, true);
instance->SetTexture(*static_cast<Nz::TextureRef*>(lua.ToUserdata(argIndex)), resizeSprite);
}
else if (lua.IsOfType(argIndex, Nz::LuaType_String))
{
bool resizeSprite = lua.CheckBoolean(argIndex + 1, true);
instance->SetTexture(lua.ToString(argIndex), resizeSprite);
}
else if (lua.IsOfType(argIndex, Nz::LuaType_Number))
{
std::size_t skinIndex(lua.Check<std::size_t>(&argIndex));
bool resizeSprite = lua.CheckBoolean(argIndex + 1, true);
if (lua.IsOfType(argIndex, "Texture"))
instance->SetTexture(skinIndex, *static_cast<Nz::TextureRef*>(lua.ToUserdata(argIndex)), resizeSprite);
else
instance->SetTexture(skinIndex, lua.Check<Nz::String>(&argIndex), resizeSprite);
}
return 0;
});
}
/*********************************** Nz::SpriteLibrary ***********************************/
spriteLibrary.Reset("SpriteLibrary");
{
spriteLibrary.BindStaticMethod("Get", &Nz::SpriteLibrary::Get);
spriteLibrary.BindStaticMethod("Has", &Nz::SpriteLibrary::Has);
spriteLibrary.BindStaticMethod("Register", &Nz::SpriteLibrary::Register);
spriteLibrary.BindStaticMethod("Query", &Nz::SpriteLibrary::Query);
spriteLibrary.BindStaticMethod("Unregister", &Nz::SpriteLibrary::Unregister);
}
}
/*!
* \brief Registers the classes that will be used by the Lua instance
*
* \param instance Lua instance that will interact with the Graphics classes
*/
void LuaBinding_Graphics::Register(Nz::LuaState& state)
{
abstractViewer.Register(state);
instancedRenderable.Register(state);
material.Register(state);
model.Register(state);
sprite.Register(state);
spriteLibrary.Register(state);
// Nz::ReflectionMode
static_assert(Nz::ReflectionMode_Max + 1 == 3, "Nz::ReflectionMode has been updated but change was not reflected to Lua binding");
state.PushTable(0, 3);
{
state.PushField("Probe", Nz::ReflectionMode_Probe);
state.PushField("RealTime", Nz::ReflectionMode_RealTime);
state.PushField("Skybox", Nz::ReflectionMode_Skybox);
}
state.SetGlobal("ReflectionMode");
}
}
| 41.012024 | 140 | 0.684877 | [
"model"
] |
fc80bb16242adab3d62973c7bc0c609a656f2082 | 28,535 | cpp | C++ | AgentWorlds/GameDesign/GameSimulationOptionDlg.cpp | chen0040/cpp-ogre-mllab | b85305cd7e95559a178664577c8e858a5b9dd05b | [
"MIT"
] | 1 | 2021-10-04T09:40:26.000Z | 2021-10-04T09:40:26.000Z | AgentWorlds/GameDesign/GameSimulationOptionDlg.cpp | chen0040/cpp-ogre-mllab | b85305cd7e95559a178664577c8e858a5b9dd05b | [
"MIT"
] | null | null | null | AgentWorlds/GameDesign/GameSimulationOptionDlg.cpp | chen0040/cpp-ogre-mllab | b85305cd7e95559a178664577c8e858a5b9dd05b | [
"MIT"
] | 6 | 2019-05-05T22:29:55.000Z | 2022-01-03T14:18:54.000Z | #include "GameSimulationOptionDlg.h"
#include "../../tinyxml/tinyxml.h"
#include "../../OSEnvironment/OSEnvironment.h"
#include "../../ScriptEngine/ScriptManager.h"
#include "../../Widgets/GUIManager.h"
GameSimulationOptionDlg::GameSimulationOptionDlg(const std::string& rootId, CEGUI::Window* parentWindow)
: CIWidget(NULL, parentWindow)
{
this->initializeComponents(rootId);
}
const std::vector<std::string>& GameSimulationOptionDlg::getSimulationScripts() const
{
return mSimulationScripts;
}
GameSimulationOptionDlg::~GameSimulationOptionDlg()
{
if(mEditTerminatePeriod != NULL)
{
delete mEditTerminatePeriod;
mEditTerminatePeriod=NULL;
}
if(mEditTerminateLives != NULL)
{
delete mEditTerminateLives;
mEditTerminateLives=NULL;
}
if(mEditSimulationCount != NULL)
{
delete mEditSimulationCount;
mEditSimulationCount=NULL;
}
if(mEditMaxX != NULL)
{
delete mEditMaxX;
mEditMaxX= NULL;
}
if(mEditMinZ != NULL)
{
delete mEditMinZ;
mEditMinZ= NULL;
}
if(mEditMinX != NULL)
{
delete mEditMinX;
mEditMinX= NULL;
}
if(mEditMaxZ != NULL)
{
delete mEditMaxZ;
mEditMaxZ= NULL;
}
mParentWindow->removeChildWindow(mRootWindow);
CEGUI::WindowManager* wm=CEGUI::WindowManager::getSingletonPtr();
wm->destroyWindow(mRootWindow);
}
void GameSimulationOptionDlg::create()
{
load();
const float txtWidth=1.0f;
const float txtHeight=0.1f;
const float labelWidth=0.6f;
const float labelWidth2=0.45f;
const float chkWidth=0.91f;
const float vgap=0.01f;
const float hgap=0.01f;
const float left=0.1f;
const float top=0.3f;
float x=left;
float y=top;
CEGUI::WindowManager* wm=CEGUI::WindowManager::getSingletonPtr();
CEGUI::FrameWindow* frame=static_cast<CEGUI::FrameWindow*>(wm->createWindow(CIWidget::getGUIType("FrameWindow"), getRootId()));
//frame->toggleRollup();
mRootWindow=frame;
mRootWindow->setSize(CEGUI::UVector2(cegui_reldim(0.4f), cegui_reldim(0.5f)));
mRootWindow->setPosition(CEGUI::UVector2(cegui_reldim(0.3f), cegui_reldim(0.25f)));
mRootWindow->setAlpha(0.6f);
mRootWindow->setText((CEGUI::utf8*)"Game Simulation Options");
CEGUI::TabControl* tc=static_cast<CEGUI::TabControl*>(wm->createWindow(CIWidget::getGUIType("TabControl"), this->getUIId("TabControl")));
tc->setSize(CEGUI::UVector2(cegui_reldim(0.9f), cegui_reldim(0.82f)));
tc->setPosition(CEGUI::UVector2(cegui_reldim(0.05f), cegui_reldim(0.07f)));
mRootWindow->addChildWindow(tc);
CEGUI::Window* tabMode =wm->createWindow(CIWidget::getGUIType("ScrollablePane"), getUIId("tabMode"));
tabMode->setText("Mode");
tabMode->setPosition(CEGUI::UVector2(cegui_reldim(0.05f), cegui_reldim(0.05f)));
tabMode->setSize(CEGUI::UVector2(cegui_reldim(0.9f), cegui_reldim(0.95f)));
//tabMode->setProperty((CEGUI::utf8*)"Font", (CEGUI::utf8*)"Commonwealth-8");
tc->addTab(tabMode);
x=left;
y=top;
mChkExpertMode=static_cast<CEGUI::Checkbox*>(wm->createWindow(CIWidget::getGUIType("Checkbox"), this->getUIId("chkExpertMode")));
mChkExpertMode->setSize(CEGUI::UVector2(cegui_reldim(chkWidth), cegui_reldim(txtHeight)));
mChkExpertMode->setPosition(CEGUI::UVector2(cegui_reldim(x), cegui_reldim(y)));
mChkExpertMode->setText("Expert Mode");
tabMode->addChildWindow(mChkExpertMode);
y+=(txtHeight+vgap);
mScrollableText=static_cast<CEGUI::MultiLineEditbox*>(wm->createWindow(CIWidget::getGUIType("MultiLineEditbox"), getUIId("scrollPane")));
mScrollableText->setSize(CEGUI::UVector2(cegui_reldim(0.9f), cegui_reldim(0.7f)));
mScrollableText->setPosition(CEGUI::UVector2(cegui_reldim(x), cegui_reldim(y)));
mScrollableText->setText(OSEnvironment::readFile(OSEnvironment::getFullPath("..\\config\\SimulationOption.txt").c_str()));
mScrollableText->setReadOnly(true);
tabMode->addChildWindow(mScrollableText);
CEGUI::Window* tabInit =wm->createWindow(CIWidget::getGUIType("ScrollablePane"), getUIId("tabInit"));
tabInit->setText("Initialization");
tabInit->setPosition(CEGUI::UVector2(cegui_reldim(0.05f), cegui_reldim(0.05f)));
tabInit->setSize(CEGUI::UVector2(cegui_reldim(0.9f), cegui_reldim(0.95f)));
//tabInit->setProperty((CEGUI::utf8*)"Font", (CEGUI::utf8*)"Commonwealth-8");
tc->addTab(tabInit);
x=left;
y=top;
mEditMaxX=new CITextFieldWidget(getUIId("editMaxX"), this, tabInit, txtWidth, txtHeight, labelWidth);
mEditMaxX->setLabel("Max region X (limit: 1250): ");
mEditMaxX->setPosition(x, y);
y+=(txtHeight+vgap);
mEditMinX=new CITextFieldWidget(getUIId("editMinX"), this, tabInit, txtWidth, txtHeight, labelWidth);
mEditMinX->setLabel("Min region X (limit: 250): ");
mEditMinX->setPosition(x, y);
y+=(txtHeight+vgap);
mEditMaxZ=new CITextFieldWidget(getUIId("editMaxZ"), this, tabInit, txtWidth, txtHeight, labelWidth);
mEditMaxZ->setLabel("Max region Z (limit: 1250): ");
mEditMaxZ->setPosition(x, y);
y+=(txtHeight+vgap);
mEditMinZ=new CITextFieldWidget(getUIId("editMinZ"), this, tabInit, txtWidth, txtHeight, labelWidth);
mEditMinZ->setLabel("Min region Z (limit: 250): ");
mEditMinZ->setPosition(x, y);
y+=(txtHeight+vgap);
mChkCellInit=static_cast<CEGUI::Checkbox*>(wm->createWindow(CIWidget::getGUIType("Checkbox"), this->getUIId("chkCellInit")));
mChkCellInit->setSize(CEGUI::UVector2(cegui_reldim(chkWidth), cegui_reldim(txtHeight)));
mChkCellInit->setPosition(CEGUI::UVector2(cegui_reldim(x), cegui_reldim(y)));
mChkCellInit->setText("Initialization with cell confinement");
tabInit->addChildWindow(mChkCellInit);
y+=(txtHeight+vgap);
mChkRandomAuraColor=static_cast<CEGUI::Checkbox*>(wm->createWindow(CIWidget::getGUIType("Checkbox"), this->getUIId("chkRandomAuraColor")));
mChkRandomAuraColor->setSize(CEGUI::UVector2(cegui_reldim(chkWidth), cegui_reldim(txtHeight)));
mChkRandomAuraColor->setPosition(CEGUI::UVector2(cegui_reldim(x), cegui_reldim(y)));
mChkRandomAuraColor->setText("Randomize agent aura at new simulation");
tabInit->addChildWindow(mChkRandomAuraColor);
y+=(txtHeight+vgap);
mChkRemoveAgentsOnStart=static_cast<CEGUI::Checkbox*>(wm->createWindow(CIWidget::getGUIType("Checkbox"), this->getUIId("chkRemoveAgentsOnStart")));
mChkRemoveAgentsOnStart->setSize(CEGUI::UVector2(cegui_reldim(0.9f), cegui_reldim(txtHeight)));
mChkRemoveAgentsOnStart->setPosition(CEGUI::UVector2(cegui_reldim(x), cegui_reldim(y)));
mChkRemoveAgentsOnStart->setText("Remove all agents at new simulation");
tabInit->addChildWindow(mChkRemoveAgentsOnStart);
y+=(txtHeight+vgap);
mChkSoundEnabled=static_cast<CEGUI::Checkbox*>(wm->createWindow(CIWidget::getGUIType("Checkbox"), this->getUIId("khkSoundEnabled")));
mChkSoundEnabled->setSize(CEGUI::UVector2(cegui_reldim(0.9f), cegui_reldim(txtHeight)));
mChkSoundEnabled->setPosition(CEGUI::UVector2(cegui_reldim(x), cegui_reldim(y)));
mChkSoundEnabled->setText("Enable sound at new simulation");
tabInit->addChildWindow(mChkSoundEnabled);
CEGUI::Window* tabTerminate =wm->createWindow(CIWidget::getGUIType("ScrollablePane"), getUIId("tabTerminate"));
tabTerminate->setText("Termination");
tabTerminate->setPosition(CEGUI::UVector2(cegui_reldim(0.05f), cegui_reldim(0.05f)));
tabTerminate->setSize(CEGUI::UVector2(cegui_reldim(chkWidth), cegui_reldim(0.95f)));
//tabTerminate->setProperty((CEGUI::utf8*)"Font", (CEGUI::utf8*)"Commonwealth-8");
tc->addTab(tabTerminate);
x=left;
y=top;
mEditTerminatePeriod=new CITextFieldWidget(getUIId("editTerminatePeriod"), this, tabTerminate, txtWidth, txtHeight, labelWidth2);
mEditTerminatePeriod->setLabel("Period (secs): ");
mEditTerminatePeriod->setPosition(x, y);
y+=(txtHeight+vgap);
mEditTerminateLives=new CITextFieldWidget(getUIId("editTerminateLives"), this, tabTerminate, txtWidth, txtHeight, labelWidth2);
mEditTerminateLives->setLabel("Lives to remain: ");
mEditTerminateLives->setPosition(x, y);
y+=(txtHeight+vgap);
mEditSimulationCount=new CITextFieldWidget(getUIId("editSimulationCount"), this, tabTerminate, txtWidth, txtHeight, labelWidth2);
mEditSimulationCount->setLabel("Simulation Count: ");
mEditSimulationCount->setPosition(x, y);
y+=(txtHeight+vgap);
mChkTerminateOnLives=static_cast<CEGUI::Checkbox*>(wm->createWindow(CIWidget::getGUIType("Checkbox"), this->getUIId("chkTerminateOnLives")));
mChkTerminateOnLives->setSize(CEGUI::UVector2(cegui_reldim(chkWidth), cegui_reldim(txtHeight)));
mChkTerminateOnLives->setPosition(CEGUI::UVector2(cegui_reldim(x), cegui_reldim(y)));
mChkTerminateOnLives->setText("Terminate on limited survivers");
tabTerminate->addChildWindow(mChkTerminateOnLives);
y+=(txtHeight+vgap);
mChkTerminateOnPeriod=static_cast<CEGUI::Checkbox*>(wm->createWindow(CIWidget::getGUIType("Checkbox"), this->getUIId("chkTerminateOnPeriod")));
mChkTerminateOnPeriod->setSize(CEGUI::UVector2(cegui_reldim(chkWidth), cegui_reldim(txtHeight)));
mChkTerminateOnPeriod->setPosition(CEGUI::UVector2(cegui_reldim(x), cegui_reldim(y)));
mChkTerminateOnPeriod->setText("Terminate after limited seconds");
tabTerminate->addChildWindow(mChkTerminateOnPeriod);
y+=(txtHeight+vgap);
mChkRecordLastEntry=static_cast<CEGUI::Checkbox*>(wm->createWindow(CIWidget::getGUIType("Checkbox"), this->getUIId("chkRecordLastEntry")));
mChkRecordLastEntry->setSize(CEGUI::UVector2(cegui_reldim(chkWidth), cegui_reldim(txtHeight)));
mChkRecordLastEntry->setPosition(CEGUI::UVector2(cegui_reldim(x), cegui_reldim(y)));
mChkRecordLastEntry->setText("Record only the final entry");
tabTerminate->addChildWindow(mChkRecordLastEntry);
CEGUI::Window* tabAgents =wm->createWindow(CIWidget::getGUIType("ScrollablePane"), getUIId("tabAgents"));
tabAgents->setText("Agents");
tabAgents->setPosition(CEGUI::UVector2(cegui_reldim(0.05f), cegui_reldim(0.05f)));
tabAgents->setSize(CEGUI::UVector2(cegui_reldim(0.9f), cegui_reldim(0.95f)));
//tabAgents->setProperty((CEGUI::utf8*)"Font", (CEGUI::utf8*)"Commonwealth-8");
tc->addTab(tabAgents);
const float listingWidth=0.47f;
const float listingHeight=0.7f;
y=top;
x=left;
CEGUI::Window* lblScriptListing=wm->createWindow(CIWidget::getGUIType("StaticText"), getUIId("lblScriptListing"));
lblScriptListing->setText("Available Scripts");
lblScriptListing->setSize(CEGUI::UVector2(cegui_reldim(listingWidth), cegui_reldim(txtHeight)));
lblScriptListing->setPosition(CEGUI::UVector2(cegui_reldim(x), cegui_reldim(y)));
lblScriptListing->setProperty((CEGUI::utf8*)"FrameEnabled", (CEGUI::utf8*)"false");
tabAgents->addChildWindow(lblScriptListing);
x+=(listingWidth+hgap);
lblScriptListing=wm->createWindow(CIWidget::getGUIType("StaticText"), getUIId("lblSimulationScriptListing"));
lblScriptListing->setText("Simulation Scripts");
lblScriptListing->setSize(CEGUI::UVector2(cegui_reldim(listingWidth), cegui_reldim(txtHeight)));
lblScriptListing->setPosition(CEGUI::UVector2(cegui_reldim(x), cegui_reldim(y)));
lblScriptListing->setProperty((CEGUI::utf8*)"FrameEnabled", (CEGUI::utf8*)"false");
tabAgents->addChildWindow(lblScriptListing);
y+=(txtHeight+vgap);
x=left;
mScriptListing=static_cast<CEGUI::Listbox*>(wm->createWindow(CIWidget::getGUIType("Listbox"), getUIId("ScriptListing")));
mScriptListing->setSize(CEGUI::UVector2(cegui_reldim(listingWidth), cegui_reldim(listingHeight)));
mScriptListing->setPosition(CEGUI::UVector2(cegui_reldim(x), cegui_reldim(y)));
mScriptListing->setMultiselectEnabled(true);
tabAgents->addChildWindow(mScriptListing);
x+=(listingWidth+hgap);
mSimulationScriptListing=static_cast<CEGUI::Listbox*>(wm->createWindow(CIWidget::getGUIType("Listbox"), getUIId("SimulationScriptListing")));
mSimulationScriptListing->setSize(CEGUI::UVector2(cegui_reldim(listingWidth), cegui_reldim(listingHeight)));
mSimulationScriptListing->setPosition(CEGUI::UVector2(cegui_reldim(x), cegui_reldim(y)));
mSimulationScriptListing->setMultiselectEnabled(true);
tabAgents->addChildWindow(mSimulationScriptListing);
x=left;
y+=(listingHeight+vgap);
const float btnWidth=0.3f;
mBtnAddScript=static_cast<CEGUI::PushButton*>(wm->createWindow(CIWidget::getGUIType("Button"), getUIId("btnAddScript")));
mBtnAddScript->setText((CEGUI::utf8*)"Add");
mBtnAddScript->setSize(CEGUI::UVector2(cegui_reldim(btnWidth), cegui_reldim(txtHeight)));
mBtnAddScript->setPosition(CEGUI::UVector2(cegui_reldim(x), cegui_reldim(y)));
tabAgents->addChildWindow(mBtnAddScript);
x+=(btnWidth+hgap);
mBtnRemoveScript=static_cast<CEGUI::PushButton*>(wm->createWindow(CIWidget::getGUIType("Button"), getUIId("btnRemoveScript")));
mBtnRemoveScript->setText((CEGUI::utf8*)"Remove");
mBtnRemoveScript->setSize(CEGUI::UVector2(cegui_reldim(btnWidth), cegui_reldim(txtHeight)));
mBtnRemoveScript->setPosition(CEGUI::UVector2(cegui_reldim(x), cegui_reldim(y)));
tabAgents->addChildWindow(mBtnRemoveScript);
x+=(btnWidth+hgap);
mBtnClearScripts=static_cast<CEGUI::PushButton*>(wm->createWindow(CIWidget::getGUIType("Button"), getUIId("btnClearScripts")));
mBtnClearScripts->setText((CEGUI::utf8*)"Remove All");
mBtnClearScripts->setSize(CEGUI::UVector2(cegui_reldim(btnWidth), cegui_reldim(txtHeight)));
mBtnClearScripts->setPosition(CEGUI::UVector2(cegui_reldim(x), cegui_reldim(y)));
tabAgents->addChildWindow(mBtnClearScripts);
const float normalizedButtonHeight=0.08f;
x=0.54f;
mBtnOK=static_cast<CEGUI::PushButton*>(wm->createWindow(CIWidget::getGUIType("Button"), this->getUIId("OK")));
mBtnOK->setText((CEGUI::utf8*)"OK");
mBtnOK->setSize(CEGUI::UVector2(cegui_reldim(0.20f), cegui_reldim(normalizedButtonHeight)));
mBtnOK->setPosition(CEGUI::UVector2(cegui_reldim(x), cegui_reldim(0.9f)));
mRootWindow->addChildWindow(mBtnOK);
x+=(0.20f+hgap);
mBtnApply=static_cast<CEGUI::PushButton*>(wm->createWindow(CIWidget::getGUIType("Button"), this->getUIId("btnApply")));
mBtnApply->setText((CEGUI::utf8*)"Apply");
mBtnApply->setSize(CEGUI::UVector2(cegui_reldim(0.20f), cegui_reldim(normalizedButtonHeight)));
mBtnApply->setPosition(CEGUI::UVector2(cegui_reldim(x), cegui_reldim(0.9f)));
mRootWindow->addChildWindow(mBtnApply);
mParentWindow->addChildWindow(mRootWindow);
mRootWindow->hide();
}
void GameSimulationOptionDlg::subscribeEvents()
{
mEventWindowClosed=mRootWindow->subscribeEvent(CEGUI::FrameWindow::EventCloseClicked, CEGUI::Event::Subscriber(&GameSimulationOptionDlg::onCloseClicked, this));
mEventOK=mBtnOK->subscribeEvent(CEGUI::PushButton::EventClicked, CEGUI::Event::Subscriber(&GameSimulationOptionDlg::onOK, this));
mEventApply=mBtnApply->subscribeEvent(CEGUI::PushButton::EventClicked, CEGUI::Event::Subscriber(&GameSimulationOptionDlg::onApply, this));
mEventAddScript=mBtnAddScript->subscribeEvent(CEGUI::PushButton::EventClicked, CEGUI::Event::Subscriber(&GameSimulationOptionDlg::onClicked_AddScript, this));
mEventRemoveScript=mBtnRemoveScript->subscribeEvent(CEGUI::PushButton::EventClicked, CEGUI::Event::Subscriber(&GameSimulationOptionDlg::onClicked_RemoveScript, this));
mEventClearScripts=mBtnClearScripts->subscribeEvent(CEGUI::PushButton::EventClicked, CEGUI::Event::Subscriber(&GameSimulationOptionDlg::onClicked_ClearScripts, this));
}
void GameSimulationOptionDlg::unsubscribeEvents()
{
mEventWindowClosed->disconnect();
mEventOK->disconnect();
mEventApply->disconnect();
mEventAddScript->disconnect();
mEventRemoveScript->disconnect();
mEventClearScripts->disconnect();
}
bool GameSimulationOptionDlg::onClicked_AddScript(const CEGUI::EventArgs& evt)
{
size_t selectedItemCount=mScriptListing->getSelectedCount();
if(selectedItemCount == 0)
{
GUIManager::getSingletonPtr()->showMsgBox("No script selected", "Please select scripts from the available scripts first");
return true;
}
size_t itemCount=mScriptListing->getItemCount();
for(size_t i=0; i != itemCount; ++i)
{
CEGUI::ListboxTextItem* item=static_cast<CEGUI::ListboxTextItem*>(mScriptListing->getListboxItemFromIndex(i));
if(item->isSelected())
{
CEGUI::ListboxTextItem* newItem=new CEGUI::ListboxTextItem(item->getText(), static_cast<CEGUI::uint>(mSimulationScriptListing->getItemCount()));
newItem->setTooltipText(item->getTooltipText());
newItem->setSelectionBrushImage((CEGUI::utf8*)GUIManager::getSingletonPtr()->getGUITheme().c_str(), (CEGUI::utf8*)"MultiListSelectionBrush");
mSimulationScriptListing->addItem(newItem);
}
}
return true;
}
bool GameSimulationOptionDlg::onClicked_RemoveScript(const CEGUI::EventArgs& evt)
{
size_t selectedItemCount=mSimulationScriptListing->getSelectedCount();
if(selectedItemCount == 0)
{
GUIManager::getSingletonPtr()->showMsgBox("No script selected", "Please select scripts from the simulation scripts first");
return true;
}
size_t itemCount=mSimulationScriptListing->getItemCount();
std::vector<CEGUI::ListboxTextItem*> removedItems;
for(size_t i=0; i != itemCount; ++i)
{
CEGUI::ListboxTextItem* item=static_cast<CEGUI::ListboxTextItem*>(mSimulationScriptListing->getListboxItemFromIndex(i));
if(item->isSelected())
{
removedItems.push_back(item);
}
}
for(size_t i=0; i != selectedItemCount; ++i)
{
mSimulationScriptListing->removeItem(removedItems[i]);
}
return true;
}
bool GameSimulationOptionDlg::onClicked_ClearScripts(const CEGUI::EventArgs& evt)
{
mSimulationScriptListing->resetList();
return true;
}
bool GameSimulationOptionDlg::onOK(const CEGUI::EventArgs& evt)
{
updateData(true);
save();
this->hideWindow();
return true;
}
bool GameSimulationOptionDlg::onApply(const CEGUI::EventArgs& evt)
{
updateData(true);
save();
return true;
}
void GameSimulationOptionDlg::updateData(bool validateAndSaved)
{
if(validateAndSaved)
{
this->mDefaultSimulationCount=atoi(this->mEditSimulationCount->getText().c_str());
this->mSimulationCount=mDefaultSimulationCount;
this->mLivesRemained2OnTermination=atoi(this->mEditTerminateLives->getText().c_str());
this->mSecondsOnTermination=static_cast<float>(atof(this->mEditTerminatePeriod->getText().c_str()));
this->mExpertMode=mChkExpertMode->isSelected();
this->mTerminationOnLivesRemained=mChkTerminateOnLives->isSelected();
this->mTerminationOnSecondsReached=mChkTerminateOnPeriod->isSelected();
this->mRecordLastEntry=mChkRecordLastEntry->isSelected();
this->mMaxX=atoi(this->mEditMaxX->getText().c_str());
this->mMinX=atoi(this->mEditMinX->getText().c_str());
this->mMaxZ=atoi(this->mEditMaxZ->getText().c_str());
this->mMinZ=atoi(this->mEditMinZ->getText().c_str());
this->mCellInit=mChkCellInit->isSelected();
this->mRemoveAllAgentsOnStarted=mChkRemoveAgentsOnStart->isSelected();
this->mRandomAuraColor=mChkRandomAuraColor->isSelected();
this->mSoundEnabled=mChkSoundEnabled->isSelected();
this->mSimulationScripts.clear();
size_t itemCount=mSimulationScriptListing->getItemCount();
for(size_t i=0; i != itemCount; ++i)
{
CEGUI::ListboxTextItem* item=static_cast<CEGUI::ListboxTextItem*>(mSimulationScriptListing->getListboxItemFromIndex(i));
mSimulationScripts.push_back(item->getTooltipText().c_str());
}
}
else
{
mEditTerminatePeriod->setText(OSEnvironment::toString(this->mSecondsOnTermination));
mEditTerminateLives->setText(OSEnvironment::toString(this->mLivesRemained2OnTermination));
mEditSimulationCount->setText(OSEnvironment::toString(this->mDefaultSimulationCount));
mChkExpertMode->setSelected(this->mExpertMode);
mChkTerminateOnLives->setSelected(this->mTerminationOnLivesRemained);
mChkTerminateOnPeriod->setSelected(this->mTerminationOnSecondsReached);
mChkRecordLastEntry->setSelected(this->mRecordLastEntry);
mEditMaxX->setText(OSEnvironment::toString(this->mMaxX));
mEditMaxZ->setText(OSEnvironment::toString(this->mMaxZ));
mEditMinX->setText(OSEnvironment::toString(this->mMinX));
mEditMinZ->setText(OSEnvironment::toString(this->mMinZ));
mChkCellInit->setSelected(this->mCellInit);
mChkRemoveAgentsOnStart->setSelected(this->mRemoveAllAgentsOnStarted);
mChkRandomAuraColor->setSelected(this->mRandomAuraColor);
mChkSoundEnabled->setSelected(this->mSoundEnabled);
mScriptListing->resetList();
ScriptManager* sm=ScriptManager::getSingletonPtr();
const std::vector<std::string>& scriptListings=sm->getScriptListings();
size_t scriptListingSize=scriptListings.size();
for(size_t k=0; k != scriptListingSize; k++)
{
CEGUI::ListboxTextItem* item=new CEGUI::ListboxTextItem(sm->getNickname(scriptListings[k]), static_cast<CEGUI::uint>(k));
item->setTooltipText(scriptListings[k]);
item->setSelectionBrushImage((CEGUI::utf8*)GUIManager::getSingletonPtr()->getGUITheme().c_str(), (CEGUI::utf8*)"MultiListSelectionBrush");
if(k==0)
{
item->setSelected(true);
}
mScriptListing->addItem(item);
}
mSimulationScriptListing->resetList();
std::vector<std::string>::iterator siter=mSimulationScripts.begin();
std::vector<std::string>::iterator siter_end=mSimulationScripts.end();
CEGUI::uint k=0;
while(siter != siter_end)
{
if(isValidScript(*siter))
{
CEGUI::ListboxTextItem* item=new CEGUI::ListboxTextItem(sm->getNickname(*siter), k++);
item->setTooltipText(*siter);
item->setSelectionBrushImage((CEGUI::utf8*)GUIManager::getSingletonPtr()->getGUITheme().c_str(), (CEGUI::utf8*)"MultiListSelectionBrush");
mSimulationScriptListing->addItem(item);
++siter;
}
else
{
siter=mSimulationScripts.erase(siter);
}
}
mSimulationScriptListing->setSortingEnabled(true);
}
}
bool GameSimulationOptionDlg::isValidScript(const std::string& scriptId) const
{
return OSEnvironment::exists(OSEnvironment::getFullPath(OSEnvironment::append("..\\scripts\\", scriptId)));
}
void GameSimulationOptionDlg::show()
{
updateData(false);
this->showWindow();
}
bool GameSimulationOptionDlg::onCloseClicked(const CEGUI::EventArgs& evt)
{
this->hideWindow();
return true;
}
bool GameSimulationOptionDlg::isExpertMode() const
{
return mExpertMode;
}
std::string GameSimulationOptionDlg::getSimulationModel() const
{
float r=Ogre::Math::RangeRandom(0, 1);
std::map<std::string, float>::const_iterator miter_begin=mSimulationModels.begin();
std::map<std::string, float>::const_iterator miter=miter_begin;
std::map<std::string, float>::const_iterator miter_end=mSimulationModels.end();
for(; miter != miter_end; ++miter)
{
if(r < miter->second)
{
return miter->first;
}
}
return "";
}
void GameSimulationOptionDlg::load()
{
TiXmlDocument doc;
if(!doc.LoadFile(OSEnvironment::getFullPath("..\\config\\simulation.xml").c_str()))
{
throw Ogre::Exception(42, "Failed to load simulation.xml", "GameSimulationControlBox::load()");
}
TiXmlElement* xmlRoot=doc.RootElement();
if(strcmp(xmlRoot->Attribute("remove_agents_on_start"), "true")==0)
{
mRemoveAllAgentsOnStarted=true;
}
else
{
mRemoveAllAgentsOnStarted=false;
}
if(strcmp(xmlRoot->Attribute("record_last_entry"), "true")==0)
{
mRecordLastEntry=true;
}
else
{
mRecordLastEntry=false;
}
if(strcmp(xmlRoot->Attribute("sound_enabled"), "true")==0)
{
mSoundEnabled=true;
}
else
{
mSoundEnabled=false;
}
if(strcmp(xmlRoot->Attribute("expert_mode"), "true")==0)
{
mExpertMode=true;
}
else
{
mExpertMode=false;
}
if(strcmp(xmlRoot->Attribute("cell_initialization"), "true")==0)
{
mCellInit=true;
}
else
{
mCellInit=false;
}
if(strcmp(xmlRoot->Attribute("random_aura_color"), "true")==0)
{
mRandomAuraColor=true;
}
else
{
mRandomAuraColor=false;
}
xmlRoot->QueryIntAttribute("simulation_count", &mDefaultSimulationCount);
mSimulationCount=mDefaultSimulationCount;
for(TiXmlElement* xmlLevel1=xmlRoot->FirstChildElement(); xmlLevel1 != NULL; xmlLevel1 = xmlLevel1->NextSiblingElement())
{
if(strcmp(xmlLevel1->Value(), "agents")==0)
{
for(TiXmlElement* xmlLevel2=xmlLevel1->FirstChildElement(); xmlLevel2 != NULL; xmlLevel2 = xmlLevel2->NextSiblingElement())
{
if(strcmp(xmlLevel2->Value(), "agent")==0)
{
std::string scriptId=xmlLevel2->Attribute("scriptId");
if(isValidScript(scriptId))
{
mSimulationScripts.push_back(scriptId);
}
}
}
}
else if(strcmp(xmlLevel1->Value(), "models")==0)
{
float frequency=0;
float accum_frequency=0;
std::string model_name="";
for(TiXmlElement* xmlLevel2=xmlLevel1->FirstChildElement(); xmlLevel2 != NULL; xmlLevel2=xmlLevel2->NextSiblingElement())
{
if(strcmp(xmlLevel2->Value(), "model")==0)
{
xmlLevel2->QueryFloatAttribute("frequency", &frequency);
accum_frequency+=frequency;
model_name=xmlLevel2->Attribute("name");
mSimulationModelFrequency[model_name]=frequency;
mSimulationModels[model_name]=accum_frequency;
}
}
}
else if(strcmp(xmlLevel1->Value(), "region")==0)
{
xmlLevel1->QueryFloatAttribute("minX", &mMinX);
xmlLevel1->QueryFloatAttribute("maxX", &mMaxX);
xmlLevel1->QueryFloatAttribute("minZ", &mMinZ);
xmlLevel1->QueryFloatAttribute("maxZ", &mMaxZ);
}
else if(strcmp(xmlLevel1->Value(), "stop_after_seconds")==0)
{
if(strcmp(xmlLevel1->Attribute("enabled"), "true")==0)
{
mTerminationOnSecondsReached=true;
}
else
{
mTerminationOnSecondsReached=false;
}
xmlLevel1->QueryFloatAttribute("seconds", &mSecondsOnTermination);
}
else if(strcmp(xmlLevel1->Value(), "stop_after_lifes")==0)
{
if(strcmp(xmlLevel1->Attribute("enabled"), "true")==0)
{
mTerminationOnLivesRemained=true;
}
else
{
mTerminationOnLivesRemained=false;
}
xmlLevel1->QueryIntAttribute("lives_remained", &mLivesRemained2OnTermination);
}
}
}
void GameSimulationOptionDlg::save()
{
TiXmlDocument doc;
doc.LinkEndChild(new TiXmlDeclaration("1.0", "", ""));
TiXmlElement* xmlRoot=new TiXmlElement("simulation");
doc.LinkEndChild(xmlRoot);
if(this->mExpertMode)
{
xmlRoot->SetAttribute("expert_mode", "true");
}
else
{
xmlRoot->SetAttribute("expert_mode", "false");
}
if(this->isAllAgentsRemovedOnStarted())
{
xmlRoot->SetAttribute("remove_agents_on_start", "true");
}
else
{
xmlRoot->SetAttribute("remove_agents_on_start", "false");
}
if(this->mRecordLastEntry)
{
xmlRoot->SetAttribute("record_last_entry", "true");
}
else
{
xmlRoot->SetAttribute("record_last_entry", "false");
}
if(this->mSoundEnabled)
{
xmlRoot->SetAttribute("sound_enabled", "true");
}
else
{
xmlRoot->SetAttribute("sound_enabled", "false");
}
if(this->isInitializationCellBased())
{
xmlRoot->SetAttribute("cell_initialization", "true");
}
else
{
xmlRoot->SetAttribute("cell_initialization", "false");
}
if(this->mRandomAuraColor)
{
xmlRoot->SetAttribute("random_aura_color", "true");
}
else
{
xmlRoot->SetAttribute("random_aura_color", "false");
}
xmlRoot->SetAttribute("simulation_count", this->mDefaultSimulationCount);
TiXmlElement* xmlLevel1=new TiXmlElement("stop_after_seconds");
xmlRoot->LinkEndChild(xmlLevel1);
if(this->isTerminationOnSecondsReached())
{
xmlLevel1->SetAttribute("enabled", "true");
}
else
{
xmlLevel1->SetAttribute("enabled", "false");
}
xmlLevel1->SetDoubleAttribute("seconds", this->getSecondsOnTermination());
xmlLevel1=new TiXmlElement("stop_after_lifes");
xmlRoot->LinkEndChild(xmlLevel1);
if(this->isTerminationOnLivesRemained())
{
xmlLevel1->SetAttribute("enabled", "true");
}
else
{
xmlLevel1->SetAttribute("enabled", "false");
}
xmlLevel1->SetAttribute("lives_remained", this->getLivesRemainedOnTermination());
xmlLevel1=new TiXmlElement("region");
xmlRoot->LinkEndChild(xmlLevel1);
xmlLevel1->SetDoubleAttribute("minX", this->getMinX());
xmlLevel1->SetDoubleAttribute("maxX", this->getMaxX());
xmlLevel1->SetDoubleAttribute("minZ", this->getMinZ());
xmlLevel1->SetDoubleAttribute("maxZ", this->getMaxZ());
xmlLevel1=new TiXmlElement("models");
xmlRoot->LinkEndChild(xmlLevel1);
std::map<std::string, float>::const_iterator miter=mSimulationModelFrequency.begin();
std::map<std::string, float>::const_iterator miter_end=mSimulationModelFrequency.end();
for(;miter != miter_end; ++miter)
{
TiXmlElement* xmlLevel2=new TiXmlElement("model");
xmlLevel1->LinkEndChild(xmlLevel2);
xmlLevel2->SetAttribute("name", (miter->first).c_str());
xmlLevel2->SetDoubleAttribute("frequency", (miter->second));
}
xmlLevel1=new TiXmlElement("agents");
xmlRoot->LinkEndChild(xmlLevel1);
std::vector<std::string>::const_iterator siter=mSimulationScripts.begin();
std::vector<std::string>::const_iterator siter_end=mSimulationScripts.end();
for(;siter != siter_end; ++siter)
{
TiXmlElement* xmlLevel2=new TiXmlElement("agent");
xmlLevel1->LinkEndChild(xmlLevel2);
xmlLevel2->SetAttribute("scriptId", (*siter).c_str());
}
doc.SaveFile(OSEnvironment::getFullPath("..\\config\\simulation.xml").c_str());
} | 35.62422 | 168 | 0.757 | [
"vector",
"model"
] |
fc863a13ac3cf08384ce02f363e7f84095407aaa | 28,640 | cc | C++ | packages/apib-parser/test/snowcrash/test-snowcrash.cc | synaptiko/drafter | 66c85964deb4a77c49460e318912ebda579ee645 | [
"BSL-1.0",
"MIT"
] | 317 | 2015-03-21T15:05:38.000Z | 2022-02-15T19:27:38.000Z | packages/apib-parser/test/snowcrash/test-snowcrash.cc | synaptiko/drafter | 66c85964deb4a77c49460e318912ebda579ee645 | [
"BSL-1.0",
"MIT"
] | 489 | 2015-02-13T15:36:09.000Z | 2022-01-14T03:25:19.000Z | packages/apib-parser/test/snowcrash/test-snowcrash.cc | synaptiko/drafter | 66c85964deb4a77c49460e318912ebda579ee645 | [
"BSL-1.0",
"MIT"
] | 81 | 2015-02-10T09:52:49.000Z | 2022-03-17T08:58:42.000Z | //
// test-snowcrash.cc
// snowcrash
//
// Created by Zdenek Nemec on 4/2/13.
// Copyright (c) 2013 Apiary Inc. All rights reserved.
//
#include "snowcrashtest.h"
#include "snowcrash.h"
using namespace snowcrash;
using namespace snowcrashtest;
TEST_CASE("Parse empty blueprint", "[parser]")
{
mdp::ByteBuffer source = "";
ParseResult<Blueprint> blueprint;
parse(source, 0, blueprint);
REQUIRE(blueprint.report.error.code == Error::OK);
REQUIRE(blueprint.report.warnings.empty());
REQUIRE(blueprint.node.metadata.empty());
REQUIRE(blueprint.node.name.empty());
REQUIRE(blueprint.node.description.empty());
REQUIRE(blueprint.node.content.elements().empty());
}
TEST_CASE("Parse simple blueprint", "[parser]")
{
mdp::ByteBuffer source
= "# Snowcrash API \n\n"
"# GET /resource\n"
"Resource **description**\n\n"
"+ Response 200\n"
" + Body\n\n"
" Text\n\n"
" { ... }\n";
ParseResult<Blueprint> blueprint;
parse(source, 0, blueprint);
REQUIRE(blueprint.report.error.code == Error::OK);
REQUIRE(blueprint.report.warnings.empty());
REQUIRE(blueprint.node.name == "Snowcrash API");
REQUIRE(blueprint.node.description.empty());
REQUIRE(blueprint.node.content.elements().size() == 1);
REQUIRE(blueprint.node.content.elements().at(0).attributes.name.empty());
REQUIRE(blueprint.node.content.elements().at(0).element == Element::ResourceElement);
REQUIRE(blueprint.node.content.elements().at(0).content.elements().size() == 0);
const Resource& resource = blueprint.node.content.elements().at(0).content.resource;
REQUIRE(resource.uriTemplate == "/resource");
REQUIRE(resource.actions.size() == 1);
const Action& action = resource.actions.at(0);
REQUIRE(action.method == "GET");
REQUIRE(action.description == "Resource **description**");
REQUIRE(action.examples.size() == 1);
REQUIRE(action.examples.front().requests.empty());
REQUIRE(action.examples.front().responses.size() == 1);
const Response& response = action.examples.front().responses.at(0);
REQUIRE(response.name == "200");
REQUIRE(response.body == "Text\n\n{ ... }\n");
}
TEST_CASE("Parse blueprint with unsupported characters", "[parser]")
{
ParseResult<Blueprint> blueprint1;
parse("hello\t", 0, blueprint1);
REQUIRE(blueprint1.report.error.code != Error::OK);
SourceMapHelper::check(blueprint1.report.error.location, 5, 1);
ParseResult<Blueprint> blueprint2;
parse("sun\n\rsalt\n\r", 0, blueprint2);
REQUIRE(blueprint2.report.error.code != Error::OK);
SourceMapHelper::check(blueprint2.report.error.location, 4, 1);
}
TEST_CASE("Do not report duplicate response when media type differs", "[method][14]")
{
mdp::ByteBuffer source
= "# GET /message\n"
"+ Response 200 (application/json)\n\n"
" { \"msg\": \"Hello.\" }\n\n"
"+ Response 200 (text/plain)\n\n"
" Hello.\n";
ParseResult<Blueprint> blueprint;
parse(source, 0, blueprint);
REQUIRE(blueprint.report.error.code == Error::OK);
REQUIRE(blueprint.report.warnings.empty());
}
TEST_CASE("Support description ending with an list item", "[parser][8]")
{
mdp::ByteBuffer source
= "# GET /1\n"
"+ a description item\n"
"+ Response 200\n\n"
" ...\n";
ParseResult<Blueprint> blueprint;
parse(source, 0, blueprint);
REQUIRE(blueprint.report.error.code == Error::OK);
REQUIRE(blueprint.report.warnings.empty());
REQUIRE(blueprint.node.content.elements().size() == 1);
REQUIRE(blueprint.node.content.elements().at(0).element == Element::ResourceElement);
REQUIRE(blueprint.node.content.elements().at(0).content.elements().size() == 0);
const Resource& resource = blueprint.node.content.elements().at(0).content.resource;
REQUIRE(resource.actions.size() == 1);
REQUIRE(resource.actions[0].description == "+ a description item");
REQUIRE(resource.actions[0].examples.size() == 1);
REQUIRE(resource.actions[0].examples[0].responses.size() == 1);
REQUIRE(resource.actions[0].examples[0].responses[0].name == "200");
REQUIRE(resource.actions[0].examples[0].responses[0].body == "...\n");
}
TEST_CASE("Invalid ‘warning: empty body asset’ for certain status codes", "[parser][13]")
{
mdp::ByteBuffer source
= "# GET /1\n"
"+ Response 304\n";
ParseResult<Blueprint> blueprint;
parse(source, 0, blueprint);
REQUIRE(blueprint.report.error.code == Error::OK);
REQUIRE(blueprint.report.warnings.empty());
REQUIRE(blueprint.node.content.elements().size() == 1);
REQUIRE(blueprint.node.content.elements().at(0).element == Element::ResourceElement);
REQUIRE(blueprint.node.content.elements().at(0).content.elements().size() == 0);
const Resource& resource = blueprint.node.content.elements().at(0).content.resource;
REQUIRE(resource.actions.size() == 1);
REQUIRE(resource.actions[0].description.empty());
REQUIRE(resource.actions[0].examples.size() == 1);
REQUIRE(resource.actions[0].examples[0].responses.size() == 1);
REQUIRE(resource.actions[0].examples[0].responses[0].name == "304");
REQUIRE(resource.actions[0].examples[0].responses[0].body.empty());
}
TEST_CASE("SIGTERM parsing blueprint", "[parser][45]")
{
mdp::ByteBuffer source
= "# A\n"
"# B\n"
"C\n\n"
"D\n\n"
"E\n\n"
"F\n\n"
"G\n\n"
"# /1\n"
"# GET\n"
"+ Request\n"
"+ Response 200\n"
" + Body\n\n"
" H\n\n"
"I\n"
"# J\n"
"> K";
ParseResult<Blueprint> blueprint;
parse(source, 0, blueprint);
REQUIRE(blueprint.report.error.code == Error::OK);
REQUIRE(blueprint.report.warnings.size() == 4);
}
TEST_CASE("Parse adjacent asset blocks", "[parser][9]")
{
mdp::ByteBuffer source
= "# GET /1\n"
"+ response 200\n"
"\n"
"asset\n"
"\n"
" pre\n"
"+ response 404\n"
"\n"
" Not found\n";
ParseResult<Blueprint> blueprint;
parse(source, 0, blueprint);
REQUIRE(blueprint.report.error.code == Error::OK);
REQUIRE(blueprint.report.warnings.size() == 2);
REQUIRE(blueprint.node.content.elements().size() == 1);
REQUIRE(blueprint.node.content.elements().at(0).element == Element::ResourceElement);
REQUIRE(blueprint.node.content.elements().at(0).content.elements().size() == 0);
const Resource& resource = blueprint.node.content.elements().at(0).content.resource;
REQUIRE(resource.actions.size() == 1);
REQUIRE(resource.actions[0].description.empty());
REQUIRE(resource.actions[0].examples.size() == 1);
REQUIRE(resource.actions[0].examples[0].responses.size() == 2);
REQUIRE(resource.actions[0].examples[0].responses[0].name == "200");
REQUIRE(resource.actions[0].examples[0].responses[0].body == "asset\n\npre\n\n");
REQUIRE(resource.actions[0].examples[0].responses[1].name == "404");
REQUIRE(resource.actions[0].examples[0].responses[1].body == "Not found\n");
}
TEST_CASE("Parse adjacent asset list blocks", "[parser][9]")
{
mdp::ByteBuffer source
= "# GET /1\n"
"+ response 200\n"
"+ list\n";
ParseResult<Blueprint> blueprint;
parse(source, 0, blueprint);
REQUIRE(blueprint.report.error.code == Error::OK);
REQUIRE(blueprint.report.warnings.size() == 1);
REQUIRE(blueprint.report.warnings[0].code == IgnoringWarning);
REQUIRE(blueprint.node.content.elements().size() == 1);
REQUIRE(blueprint.node.content.elements().at(0).element == Element::ResourceElement);
REQUIRE(blueprint.node.content.elements().at(0).content.elements().size() == 0);
const Resource& resource = blueprint.node.content.elements().at(0).content.resource;
REQUIRE(resource.actions.size() == 1);
REQUIRE(resource.actions[0].description.empty());
REQUIRE(resource.actions[0].examples[0].responses.size() == 1);
REQUIRE(resource.actions[0].examples[0].responses[0].name == "200");
REQUIRE(resource.actions[0].examples[0].responses[0].body.empty());
}
TEST_CASE("Parse adjacent nested asset blocks", "[parser][9]")
{
mdp::ByteBuffer source
= "# GET /1\n"
"+ response 200\n"
" + body\n"
"\n"
" A\n"
"\n"
" B\n"
"C\n";
ParseResult<Blueprint> blueprint;
parse(source, 0, blueprint);
REQUIRE(blueprint.report.error.code == Error::OK);
REQUIRE(blueprint.report.warnings.size() == 2);
REQUIRE(blueprint.report.warnings[0].code == IndentationWarning);
REQUIRE(blueprint.report.warnings[1].code == IndentationWarning);
REQUIRE(blueprint.node.content.elements().size() == 1);
REQUIRE(blueprint.node.content.elements().at(0).element == Element::ResourceElement);
REQUIRE(blueprint.node.content.elements().at(0).content.elements().size() == 0);
const Resource& resource = blueprint.node.content.elements().at(0).content.resource;
REQUIRE(resource.actions.size() == 1);
REQUIRE(resource.actions[0].description.empty());
REQUIRE(resource.actions[0].examples[0].responses.size() == 1);
REQUIRE(resource.actions[0].examples[0].responses[0].name == "200");
REQUIRE(resource.actions[0].examples[0].responses[0].body == "A\nB\nC\n\n");
}
TEST_CASE("Exception while parsing a blueprint with leading empty space", "[regression][parser]")
{
mdp::ByteBuffer source
= "\n"
"# PUT /branch\n";
ParseResult<Blueprint> blueprint;
REQUIRE_NOTHROW(parse(source, 0, blueprint));
REQUIRE(blueprint.report.error.code == Error::OK);
REQUIRE(blueprint.report.warnings.size() == 1);
REQUIRE(blueprint.report.warnings[0].code == EmptyDefinitionWarning);
}
TEST_CASE("Invalid source map without closing newline", "[regression][parser]")
{
mdp::ByteBuffer source = "# PUT /branch";
ParseResult<Blueprint> blueprint;
REQUIRE_NOTHROW(parse(source, 0, blueprint));
REQUIRE(blueprint.report.error.code == Error::OK);
REQUIRE(blueprint.report.warnings.size() == 1);
REQUIRE(blueprint.report.warnings[0].code == EmptyDefinitionWarning);
SourceMapHelper::check(blueprint.report.warnings[0].location, 0, 13);
}
TEST_CASE("Warn about missing API name if there is an API description", "[parser][regression]")
{
mdp::ByteBuffer source1 = "Hello World\n";
ParseResult<Blueprint> blueprint1;
parse(source1, 0, blueprint1);
REQUIRE(blueprint1.report.error.code == Error::OK);
REQUIRE(blueprint1.report.warnings.size() == 1);
REQUIRE(blueprint1.report.warnings[0].code == APINameWarning);
REQUIRE(blueprint1.node.name.empty());
REQUIRE(blueprint1.node.description == "Hello World");
REQUIRE(blueprint1.node.content.elements().empty());
mdp::ByteBuffer source2
= "# API\n"
"Hello World\n";
ParseResult<Blueprint> blueprint2;
parse(source2, 0, blueprint2);
REQUIRE(blueprint2.report.error.code == Error::OK);
REQUIRE(blueprint2.report.warnings.empty());
REQUIRE(blueprint2.node.name == "API");
REQUIRE(blueprint2.node.description == "Hello World");
REQUIRE(blueprint2.node.content.elements().empty());
mdp::ByteBuffer source3
= "# POST /1\n"
"+ Response 201";
ParseResult<Blueprint> blueprint3;
parse(source3, 0, blueprint3);
REQUIRE(blueprint3.report.error.code == Error::OK);
REQUIRE(blueprint3.report.warnings.empty());
}
TEST_CASE("Resource with incorrect URI segfault", "[parser][regression]")
{
mdp::ByteBuffer source
= "# Group A\n"
"## Resource [wronguri]\n"
"### Retrieve [GET]\n"
"+ Response 200\n"
"\n";
ParseResult<Blueprint> blueprint;
parse(source, 0, blueprint);
REQUIRE(blueprint.report.error.code == Error::OK);
REQUIRE(blueprint.report.warnings.empty());
REQUIRE(blueprint.node.name.empty());
REQUIRE(blueprint.node.description.empty());
REQUIRE(blueprint.node.content.elements().size() == 1);
REQUIRE(blueprint.node.content.elements().at(0).element == Element::CategoryElement);
REQUIRE(blueprint.node.content.elements().at(0).attributes.name == "A");
REQUIRE(blueprint.node.content.elements().at(0).content.elements().size() == 1);
REQUIRE(blueprint.node.content.elements().at(0).content.elements().at(0).element == Element::CopyElement);
REQUIRE(blueprint.node.content.elements().at(0).content.elements().at(0).content.copy
== "## Resource [wronguri]\n\n### Retrieve [GET]\n\n+ Response 200");
}
TEST_CASE("Dangling block not recognized", "[parser][regression][186]")
{
mdp::ByteBuffer source
= "# A [/a]\n"
"+ Model\n"
"\n"
"```js\n"
" { ... }\n"
"```\n";
ParseResult<Blueprint> blueprint;
parse(source, 0, blueprint);
REQUIRE(blueprint.report.error.code == Error::OK);
REQUIRE(blueprint.report.warnings.size() == 1);
REQUIRE(blueprint.report.warnings[0].code == IndentationWarning);
REQUIRE(blueprint.node.name.empty());
REQUIRE(blueprint.node.description.empty());
REQUIRE(blueprint.node.content.elements().size() == 1);
REQUIRE(blueprint.node.content.elements().at(0).element == Element::ResourceElement);
REQUIRE(blueprint.node.content.elements().at(0).content.elements().size() == 0);
const Resource& resource = blueprint.node.content.elements().at(0).content.resource;
REQUIRE(resource.name == "A");
REQUIRE(resource.uriTemplate == "/a");
REQUIRE(resource.model.body == " { ... }\n\n");
}
TEST_CASE("Ignoring block recovery", "[parser][regression][188]")
{
mdp::ByteBuffer source
= "## Note [/notes/{id}]\n"
"\n"
"+ Parameters\n"
" + id\n"
"\n"
"+ Response 200\n"
"\n"
"### Remove a Note [DELETE]\n";
ParseResult<Blueprint> blueprint;
parse(source, 0, blueprint);
REQUIRE(blueprint.report.error.code == Error::OK);
REQUIRE(blueprint.report.warnings.size() == 2);
REQUIRE(blueprint.report.warnings[0].code == IgnoringWarning);
REQUIRE(blueprint.report.warnings[1].code == EmptyDefinitionWarning);
REQUIRE(blueprint.node.content.elements().size() == 1);
REQUIRE(blueprint.node.content.elements().at(0).element == Element::ResourceElement);
REQUIRE(blueprint.node.content.elements().at(0).content.elements().size() == 0);
const Resource& resource = blueprint.node.content.elements().at(0).content.resource;
REQUIRE(resource.name == "Note");
REQUIRE(resource.actions.size() == 1);
REQUIRE(resource.actions[0].name == "Remove a Note");
REQUIRE(resource.actions[0].method == "DELETE");
}
TEST_CASE("Ignoring dangling model assets", "[parser][regression][196]")
{
mdp::ByteBuffer source
= "# A [/A]\n"
"+ model (Y)\n"
"\n"
"{ A }\n"
"\n"
"## POST /B\n"
"+ Response 200\n"
"\n"
" [A][]\n";
ParseResult<Blueprint> blueprint;
parse(source, 0, blueprint);
REQUIRE(blueprint.report.error.code == Error::OK);
REQUIRE(blueprint.report.warnings.size() == 1);
REQUIRE(blueprint.report.warnings[0].code == IndentationWarning);
REQUIRE(blueprint.node.content.elements().size() == 2);
REQUIRE(blueprint.node.content.elements().at(0).element == Element::ResourceElement);
REQUIRE(blueprint.node.content.elements().at(0).content.elements().size() == 0);
REQUIRE(blueprint.node.content.elements().at(1).element == Element::ResourceElement);
REQUIRE(blueprint.node.content.elements().at(1).content.elements().size() == 0);
const Resource& resource = blueprint.node.content.elements().at(1).content.resource;
REQUIRE(resource.name.empty());
REQUIRE(resource.uriTemplate == "/B");
REQUIRE(resource.actions.size() == 1);
REQUIRE(resource.actions[0].method == "POST");
REQUIRE(resource.actions[0].examples.size() == 1);
REQUIRE(resource.actions[0].examples[0].responses.size() == 1);
REQUIRE(resource.actions[0].examples[0].responses[0].name == "200");
REQUIRE(resource.actions[0].examples[0].responses[0].body == "{ A }\n\n");
}
TEST_CASE("Ignoring local media type", "[parser][regression][195]")
{
mdp::ByteBuffer source
= "# A [/A]\n"
"+ model (Y)\n"
"\n"
" { A }\n"
"\n"
"## Retrieve [GET]\n"
"+ Response 200 (X)\n"
"\n"
" [A][]\n";
ParseResult<Blueprint> blueprint;
parse(source, ExportSourcemapOption, blueprint);
REQUIRE(blueprint.report.error.code == Error::OK);
REQUIRE(blueprint.report.warnings.size() == 1);
REQUIRE(blueprint.report.warnings[0].code == IgnoringWarning);
REQUIRE(blueprint.node.content.elements().size() == 1);
REQUIRE(blueprint.node.content.elements().at(0).element == Element::ResourceElement);
REQUIRE(blueprint.node.content.elements().at(0).content.elements().size() == 0);
const Resource& resource = blueprint.node.content.elements().at(0).content.resource;
REQUIRE(resource.actions.size() == 1);
REQUIRE(resource.actions[0].examples.size() == 1);
REQUIRE(resource.actions[0].examples[0].responses.size() == 1);
REQUIRE(resource.actions[0].examples[0].responses[0].name == "200");
REQUIRE(resource.actions[0].examples[0].responses[0].headers.size() == 1);
REQUIRE(resource.actions[0].examples[0].responses[0].headers[0].first == "Content-Type");
REQUIRE(resource.actions[0].examples[0].responses[0].headers[0].second == "Y");
REQUIRE(blueprint.sourceMap.content.elements().collection.size() == 1);
SourceMap<Resource> resourceSM = blueprint.sourceMap.content.elements().collection[0].content.resource;
REQUIRE(resourceSM.actions.collection.size() == 1);
REQUIRE(resourceSM.actions.collection[0].examples.collection.size() == 1);
REQUIRE(resourceSM.actions.collection[0].examples.collection[0].responses.collection.size() == 1);
REQUIRE(
resourceSM.actions.collection[0].examples.collection[0].responses.collection[0].headers.collection.size() == 1);
SourceMapHelper::check(
resourceSM.actions.collection[0].examples.collection[0].responses.collection[0].headers.collection[0].sourceMap,
11,
11);
}
TEST_CASE("Using local media type", "[parser][regression][195]")
{
mdp::ByteBuffer source
= "# A [/A]\n"
"+ model\n"
"\n"
" { A }\n"
"\n"
"## Retrieve [GET]\n"
"+ Response 200 (X)\n"
"\n"
" [A][]\n";
ParseResult<Blueprint> blueprint;
parse(source, ExportSourcemapOption, blueprint);
REQUIRE(blueprint.report.error.code == Error::OK);
REQUIRE(blueprint.report.warnings.empty());
REQUIRE(blueprint.node.content.elements().size() == 1);
REQUIRE(blueprint.node.content.elements().at(0).element == Element::ResourceElement);
REQUIRE(blueprint.node.content.elements().at(0).content.elements().size() == 0);
const Resource& resource = blueprint.node.content.elements().at(0).content.resource;
REQUIRE(resource.actions.size() == 1);
REQUIRE(resource.actions[0].examples.size() == 1);
REQUIRE(resource.actions[0].examples[0].responses.size() == 1);
REQUIRE(resource.actions[0].examples[0].responses[0].name == "200");
REQUIRE(resource.actions[0].examples[0].responses[0].headers.size() == 1);
REQUIRE(resource.actions[0].examples[0].responses[0].headers[0].first == "Content-Type");
REQUIRE(resource.actions[0].examples[0].responses[0].headers[0].second == "X");
REQUIRE(blueprint.sourceMap.content.elements().collection.size() == 1);
SourceMap<Resource> resourceSM = blueprint.sourceMap.content.elements().collection[0].content.resource;
REQUIRE(resourceSM.actions.collection.size() == 1);
REQUIRE(resourceSM.actions.collection[0].examples.collection.size() == 1);
REQUIRE(resourceSM.actions.collection[0].examples.collection[0].responses.collection.size() == 1);
REQUIRE(
resourceSM.actions.collection[0].examples.collection[0].responses.collection[0].headers.collection.size() == 1);
SourceMapHelper::check(
resourceSM.actions.collection[0].examples.collection[0].responses.collection[0].headers.collection[0].sourceMap,
53,
18);
}
TEST_CASE("Parse ill-formatted header", "[parser][198][regression]")
{
mdp::ByteBuffer source
= "# GET /A\n"
"+ Response 200\n"
" + Header\n"
" Location: new_url\n";
ParseResult<Blueprint> blueprint;
parse(source, 0, blueprint);
REQUIRE(blueprint.report.error.code == Error::OK);
REQUIRE(blueprint.report.warnings.size() == 1);
REQUIRE(blueprint.report.warnings[0].code == IndentationWarning);
REQUIRE(blueprint.node.content.elements().size() == 1);
REQUIRE(blueprint.node.content.elements().at(0).element == Element::ResourceElement);
REQUIRE(blueprint.node.content.elements().at(0).content.elements().size() == 0);
const Resource& resource = blueprint.node.content.elements().at(0).content.resource;
REQUIRE(resource.actions.size() == 1);
REQUIRE(resource.actions[0].examples.size() == 1);
REQUIRE(resource.actions[0].examples[0].responses.size() == 1);
REQUIRE(resource.actions[0].examples[0].responses[0].name == "200");
REQUIRE(resource.actions[0].examples[0].responses[0].headers.size() == 1);
REQUIRE(resource.actions[0].examples[0].responses[0].headers[0].first == "Location");
REQUIRE(resource.actions[0].examples[0].responses[0].headers[0].second == "new_url");
}
TEST_CASE("Overshadow parameters", "[parser][201][regression][parameters]")
{
mdp::ByteBuffer source
= "# /{a,b,c}\n"
"\n"
"## GET\n"
"+ parameters\n"
" + a ... 1\n"
" + b ... 2\n"
" + c ... 3\n"
"\n"
"+ parameters\n"
" + a ... 4\n"
"\n"
"+ response 200\n";
ParseResult<Blueprint> blueprint;
parse(source, 0, blueprint);
REQUIRE(blueprint.report.error.code == Error::OK);
REQUIRE(blueprint.report.warnings.size() == 1);
REQUIRE(blueprint.report.warnings[0].code == RedefinitionWarning);
REQUIRE(blueprint.node.content.elements().size() == 1);
REQUIRE(blueprint.node.content.elements().at(0).element == Element::ResourceElement);
REQUIRE(blueprint.node.content.elements().at(0).content.elements().size() == 0);
const Resource& resource = blueprint.node.content.elements().at(0).content.resource;
REQUIRE(resource.actions.size() == 1);
REQUIRE(resource.actions[0].parameters.size() == 3);
REQUIRE(resource.actions[0].parameters[0].name == "b");
REQUIRE(resource.actions[0].parameters[0].description == "2");
REQUIRE(resource.actions[0].parameters[1].name == "c");
REQUIRE(resource.actions[0].parameters[1].description == "3");
REQUIRE(resource.actions[0].parameters[2].name == "a");
REQUIRE(resource.actions[0].parameters[2].description == "4");
}
TEST_CASE("Segfault parsing metadata only", "[parser][205][regression]")
{
mdp::ByteBuffer source = "FORMAT: 1A : SOJ\n";
ParseResult<Blueprint> blueprint;
parse(source, 0, blueprint);
REQUIRE(blueprint.report.error.code == Error::OK);
REQUIRE(blueprint.report.warnings.empty());
REQUIRE(blueprint.node.metadata.size() == 1);
REQUIRE(blueprint.node.metadata[0].first == "FORMAT");
REQUIRE(blueprint.node.metadata[0].second == "1A : SOJ");
REQUIRE(blueprint.node.content.elements().empty());
}
TEST_CASE("Don't remove link references", "[parser][213]")
{
mdp::ByteBuffer source
= "# API\n\n"
"This is [first example][id]\n\n"
"[id]: http://a.com\n\n"
"# Group A\n\n"
"This is [second example][id]\n\n"
"[id]: http://b.com\n\n"
"## /a\n\n"
"This is [third example][id]\n\n"
"[id]: http://c.com\n\n";
ParseResult<Blueprint> blueprint;
parse(source, 0, blueprint);
REQUIRE(blueprint.report.error.code == Error::OK);
REQUIRE(blueprint.report.warnings.empty());
REQUIRE(blueprint.node.name == "API");
REQUIRE(blueprint.node.description == "This is [first example][id]\n\n[id]: http://a.com");
REQUIRE(blueprint.node.content.elements().size() == 1);
REQUIRE(blueprint.node.content.elements().at(0).attributes.name == "A");
REQUIRE(blueprint.node.content.elements().at(0).element == Element::CategoryElement);
REQUIRE(blueprint.node.content.elements().at(0).content.elements().size() == 2);
REQUIRE(blueprint.node.content.elements().at(0).content.elements().at(0).element == Element::CopyElement);
REQUIRE(blueprint.node.content.elements().at(0).content.elements().at(0).content.copy
== "This is [second example][id]\n\n[id]: http://b.com");
REQUIRE(blueprint.node.content.elements().at(0).content.elements().at(1).element == Element::ResourceElement);
const Resource& resource = blueprint.node.content.elements().at(0).content.elements().at(1).content.resource;
REQUIRE(resource.uriTemplate == "/a");
REQUIRE(resource.description == "This is [third example][id]\n\n[id]: http://c.com");
}
TEST_CASE("Don't mess up sourcemaps when there are references", "[parser][213]")
{
mdp::ByteBuffer source
= "# API\n\n"
"[very][] [much][] [reference][]\n\n"
"[very]: http://a.com\n\n"
"[much]: http://b.com\n\n"
"[reference]: http://c.com\n\n"
"# GET /1";
ParseResult<Blueprint> blueprint;
parse(source, ExportSourcemapOption, blueprint);
REQUIRE(blueprint.report.error.code == Error::OK);
REQUIRE(blueprint.report.warnings.size() == 1);
REQUIRE(blueprint.report.warnings[0].code == EmptyDefinitionWarning);
REQUIRE(blueprint.sourceMap.content.elements().collection.size() == 1);
SourceMap<Resource> resourceSM = blueprint.sourceMap.content.elements().collection[0].content.resource;
REQUIRE(resourceSM.actions.collection.size() == 1);
SourceMapHelper::check(resourceSM.actions.collection[0].method.sourceMap, 111, 8);
}
TEST_CASE("doesn't crash while parsing response followed by a block quote and heading", "[parser][322]")
{
mdp::ByteBuffer source
= "# GET /a\n\n"
"+ Response 200\n\n"
" a\n"
"> b\n"
" e\n"
"# B";
ParseResult<Blueprint> blueprint;
parse(source, ExportSourcemapOption, blueprint);
REQUIRE(blueprint.report.error.code == Error::OK);
SourceMap<Resource> resourceSM = blueprint.sourceMap.content.elements().collection[0].content.resource;
SourceMap<Action> actionSM = resourceSM.actions.collection[0];
SourceMap<Payload> payloadSM = actionSM.examples.collection[0].responses.collection[0];
SourceMapHelper::check(payloadSM.body.sourceMap, 30, 22);
}
TEST_CASE("doesn't crash while parsing response followed by a block quote settext heading", "[parser][322]")
{
mdp::ByteBuffer source
= "# GET /a\n\n"
"+ Response 200\n\n"
" a\n"
"> b\n"
" e\n"
"Heading\n"
"-------\n";
ParseResult<Blueprint> blueprint;
parse(source, ExportSourcemapOption, blueprint);
REQUIRE(blueprint.report.error.code == Error::OK);
SourceMap<Resource> resourceSM = blueprint.sourceMap.content.elements().collection[0].content.resource;
SourceMap<Action> actionSM = resourceSM.actions.collection[0];
SourceMap<Payload> payloadSM = actionSM.examples.collection[0].responses.collection[0];
SourceMapHelper::check(payloadSM.body.sourceMap, 30, 22, 1);
}
TEST_CASE("Parse blueprint with mismatched adapter blocks", "[blueprint]")
{
mdp::ByteBuffer source
= "# Data Structures\n"
"# User\n"
"Some description\n"
"+ Properties\n"
" + a: b\n";
ParseResult<Blueprint> blueprint;
parse(source, ExportSourcemapOption, blueprint);
REQUIRE(blueprint.report.error.code != Error::OK);
REQUIRE(blueprint.report.warnings.empty());
SourceMapHelper::check(blueprint.report.error.location, 42, 24);
}
| 37.486911 | 120 | 0.6397 | [
"model"
] |
475d0051e0c96c23ccf16246c82372abccf58f6d | 1,862 | cpp | C++ | ACM Training/2018-08-25/dfs.cpp | Wycers/Codelib | 86d83787aa577b8f2d66b5410e73102411c45e46 | [
"MIT"
] | 22 | 2018-08-07T06:55:10.000Z | 2021-06-12T02:12:19.000Z | ACM Training/2018-08-25/dfs.cpp | Wycers/Codelib | 86d83787aa577b8f2d66b5410e73102411c45e46 | [
"MIT"
] | 28 | 2020-03-04T23:47:22.000Z | 2022-02-26T18:50:00.000Z | ACM Training/2018-08-25/dfs.cpp | Wycers/Codelib | 86d83787aa577b8f2d66b5410e73102411c45e46 | [
"MIT"
] | 4 | 2019-11-09T15:41:26.000Z | 2021-10-10T08:56:57.000Z | #include <bits/stdc++.h>
using namespace std;
const int N = 210;
int n, s[N][N];vector<pair<int, int> > v;
int check()
{
int ans = 0;
for (int a = 0; a < n; ++a)
{
for (int b = 0; b < n; ++b)
{
if (b == a)
continue;
for (int c = 0; c < n; ++c)
{
if (c == a || c == b)
continue;
for (int d = 0; d < n; ++d)
{
if (d == a || d == b || d == c)
continue;
if (s[a][b] == s[b][c] && s[b][c] == s[c][d] && s[c][d] == s[d][a])
++ans;
if (s[a][b] != s[b][c] && s[b][c] != s[c][d] && s[c][d] != s[d][a])
--ans;
}
}
}
}
return ans;
}
char str[N];
int ans = 0;
void dfs(int now)
{
if (now == v.size())
{
// for (int i = 1; i <= 5; ++i)
// {
// for (int j = 1; j <= 5; ++j)
// printf("%d ", s[i][j]);
// puts("");
// }
ans = max(ans, check());
return;
}
for (int i = 0; i <= 1; ++i)
{
s[v[now].first][v[now].second] = i;
s[v[now].second][v[now].first] = i ^ 1;
dfs(now + 1);
}
}
void solve()
{
scanf("%d", &n);
v.clear();
memset(s, 0, sizeof s);
for (int i = 1; i <= n; ++i)
{
scanf("%s", str);
for (int j = 0; j < n; ++j)
{
if (str[j] == '1')
s[i][j + 1] = 1;
if (str[j] == '2' && i < j + 1)
v.push_back(make_pair(i, j + 1));
}
}
ans = 0;
dfs(0);
printf("%d\n", ans);
}
int main()
{
freopen("test.in", "r", stdin);
int T; scanf("%d", &T);
while (T--)
solve();
return 0;
} | 22.707317 | 87 | 0.303974 | [
"vector"
] |
476079644f710fc0b38a3410c7549bd43e6a38b2 | 18,675 | cpp | C++ | src/nimbro/tools/trajectory_editor/src/mainwindow.cpp | hfarazi/humanoid_op_ros_kinetic | 84712bd541d0130b840ad1935d5bfe301814dbe6 | [
"BSD-3-Clause"
] | 45 | 2015-11-04T01:29:12.000Z | 2022-02-11T05:37:42.000Z | src/nimbro/tools/trajectory_editor/src/mainwindow.cpp | hfarazi/humanoid_op_ros_kinetic | 84712bd541d0130b840ad1935d5bfe301814dbe6 | [
"BSD-3-Clause"
] | 1 | 2016-08-10T04:00:32.000Z | 2016-08-10T12:59:36.000Z | src/nimbro/tools/trajectory_editor/src/mainwindow.cpp | hfarazi/humanoid_op_ros_kinetic | 84712bd541d0130b840ad1935d5bfe301814dbe6 | [
"BSD-3-Clause"
] | 20 | 2016-03-05T14:28:45.000Z | 2021-01-30T00:50:47.000Z | // Trajectory editor main window
// Authors: Max Schwarz <max.schwarz@uni-bonn.de>, Dmytro Pavlichenko <dm.mark999@gmail.com>
#include <trajectory_editor/mainwindow.h>
#include <trajectory_editor/rvizwidget.h>
#include <trajectory_editor/headerview.h>
#include "ui_mainwindow_2.h"
#include "ui_controls.h"
#include "ui_about.h"
#include <QAction>
#include <QStatusBar>
#include <QKeyEvent>
#include <QShortcut>
#include <QMessageBox>
#include <ros/node_handle.h>
MainWindow::MainWindow()
: QMainWindow()
{
// GUI setup
m_ui = new Ui::MainWindow;
m_ui->setupUi(this);
setMinimumSize(1300, 650);
m_ui->jointsTabWidget->setMinimumSize(850, 200);
m_ui->trajectoryView->setMinimumHeight(350);
QFont font = m_ui->headerLabel->font();
font.setPointSize(14);
m_ui->headerLabel->setFont(font);
m_ui->trajectoryView->setAcceptDrops(true);
m_ui->trajectoryView->setDragEnabled(true);
m_ui->trajectoryView->setDropIndicatorShown(true);
m_ui->trajectoryView->setDragDropMode(QAbstractItemView::DragDrop);
m_ui->trajectoryView->setSelectionMode(QAbstractItemView::ExtendedSelection);
setControlButtonsEnabled(false);
setPlayButtonsEnabled(false);
updateCurrentFileLabel(QString("Nothing is opened"));
// About/Controls views setup
m_controls_view = new QWidget();
m_about_view = new QWidget();
Ui::Controls controlsUI;
controlsUI.setupUi(m_controls_view);
Ui::About aboutUI;
aboutUI.setupUi(m_about_view);
// Progress bar setup
m_progress_bar = new QProgressBar(this);
m_progress_bar->hide();
m_ui->statusbar->addPermanentWidget(m_progress_bar);
// Core setup
ros::NodeHandle nh("~");
m_ui->rviz->initialize(&nh);
initHeaderWidgets();
m_kModel = new KeyframeModel(this);
m_ui->trajectoryView->setModel(m_kModel);
m_motion_player_client = new MotionPlayerClient();
m_save_controller = new SaveController(m_header_view, m_kModel->getPerspectiveManager());
m_recent_files = new RecentFiles(m_ui->menuMotion->addMenu("Recent"));
initSpaces();
// Subscribe to MotionPlayerState
m_state_subscriber = nh.subscribe("/motion_player/state", 1, &MainWindow::motionPlayerStateReceived, this);
// Connections setup TODO: refactor
connect(m_kModel, SIGNAL(modelChanged(std::string)), m_ui->rviz, SLOT(setModel(std::string)));
connect(m_kModel, SIGNAL(updateRobot(std::vector<std::string>&,std::vector<double>&))
, m_ui->rviz, SLOT(updateRobotDisplay(std::vector<std::string>&,std::vector<double>&)));
// Header and Frame views
connect(m_header_view, SIGNAL(dataChanged(HeaderData)), m_kModel, SLOT(updateHeaderData(HeaderData)));
connect(m_kModel, SIGNAL(headerDataChanged(HeaderData)), m_header_view, SLOT(setData(HeaderData)));
connect(m_header_view, SIGNAL(pidEnabledChanged(bool)), m_pid_space, SLOT(setEnabled(bool)));
connect(m_frame_view, SIGNAL(updateFrame()), m_kModel, SLOT(handleUpdateFrame()));
connect(m_frame_view, SIGNAL(frameLoaded(KeyframePtr)), m_kModel, SLOT(handeFrameLoaded(KeyframePtr)));
connect(m_frame_view, SIGNAL(changeEffortForAllFrames(std::vector<int>, double))
, m_kModel, SLOT(handleChangeEffortForAllFrames(std::vector<int>, double)));
connect(m_save_controller, SIGNAL(newPath(QString)), m_frame_view, SLOT(setPathAndName(QString)));
connect(m_save_controller, SIGNAL(modelChanged(std::string, std::vector<std::string> &))
, m_ui->rviz, SLOT(setModel(std::string, std::vector<std::string> &)));
connect(m_kModel, SIGNAL(jointListChanged(std::vector<std::string>))
, m_frame_view, SLOT(updateJointList(std::vector<std::string>)));
connect(m_kModel, SIGNAL(currentFrameChanged(KeyframePtr)), m_frame_view, SLOT(setFrame(KeyframePtr)));
// Rule view
connect(m_kModel, SIGNAL(gotRules(std::vector<motionfile::Rule>)), m_rule_view, SLOT(handleRulesLoaded(std::vector<motionfile::Rule>)));
connect(m_rule_view, SIGNAL(applyRule(double, int)), m_kModel, SLOT(applyRule(double, int)));
// Play frame/motion
connect(m_ui->playFrameButton, SIGNAL(clicked(bool)), this, SLOT(playFrameClicked()));
connect(m_ui->playFrameSlowButton, SIGNAL(clicked(bool)), this, SLOT(playFrameSlowClicked()));
connect(m_ui->playMotionButton, SIGNAL(clicked(bool)), this, SLOT(playMotionClicked()));
connect(m_ui->playMotionSlowButton, SIGNAL(clicked(bool)), this, SLOT(playSlowMotionClicked()));
connect(m_ui->actionPlay, SIGNAL(triggered()), this, SLOT(playMotionClicked()));
connect(m_ui->actionPlayMotionSlow, SIGNAL(triggered()), this, SLOT(playSlowMotionClicked()));
connect(m_ui->playSequenceButton, SIGNAL(clicked(bool)), this, SLOT(playSequenceClicked()));
connect(m_ui->updateMotionButton, SIGNAL(clicked(bool)), this, SLOT(updateMotionClicked()));
// Add/remove frame
connect(m_ui->addFrameButton, SIGNAL(clicked(bool)), this, SLOT(handleAddFrameButton()));
connect(m_ui->remFrameButton, SIGNAL(clicked(bool)), this, SLOT(handleRemoveButton()));
// Move selection up/down
connect(m_ui->moveUpButton, SIGNAL(clicked(bool)), this, SLOT(handleMoveUp()));
connect(m_ui->moveDownButton, SIGNAL(clicked(bool)), this, SLOT(handleMoveDown()));
// Open/New/Save
connect(m_ui->openButton, SIGNAL(clicked(bool)), this, SLOT(handleLoad()));
connect(m_ui->actionOpen, SIGNAL(triggered()), this, SLOT(handleLoad()));
connect(m_ui->saveButton, SIGNAL(clicked(bool)), this, SLOT(handleSave()));
connect(m_ui->actionSave, SIGNAL(triggered()), this, SLOT(handleSave()));
connect(m_ui->actionSave_as, SIGNAL(triggered()), this, SLOT(handleSaveAs()));
connect(m_ui->actionSave_mirrored_as, SIGNAL(triggered()), this, SLOT(handleSaveMirroredAs()));
connect(m_ui->actionNew_motion, SIGNAL(triggered()), this, SLOT(handleNewMotion()));
connect(m_recent_files, SIGNAL(requestOpen(QString)), this, SLOT(handleLoad(QString)));
connect(m_ui->actionShow_in_folder, SIGNAL(triggered()), m_kModel, SLOT(showMotionInFolder()));
// Show widgets with help info
connect(m_ui->actionControls, SIGNAL(triggered()), this, SLOT(showControls()));
connect(m_ui->actionAbout, SIGNAL(triggered()), this, SLOT(showAbout()));
connect(m_ui->trajectoryView->selectionModel(), SIGNAL(selectionChanged(QItemSelection, QItemSelection)),
this, SLOT(handleSelectionChanged(QItemSelection)));
// Model view
connect(m_kModel, SIGNAL(setViewSelection(int)), this, SLOT(setViewSelection(int)));
connect(m_kModel, SIGNAL(setViewSelection(QItemSelection)), this, SLOT(setViewSelection(QItemSelection)));
connect(m_kModel, SIGNAL(updateCurrentFileLabel(QString)), this, SLOT(updateCurrentFileLabel(QString)));
connect(m_kModel, SIGNAL(gotMotion(bool)), this, SLOT(setControlButtonsEnabled(bool)));
// Set up shortcuts
QShortcut *shortcutCopy = new QShortcut(QKeySequence(tr("Ctrl+C", "copy")), this);
QShortcut *shortcutPaste = new QShortcut(QKeySequence(tr("Ctrl+V", "paste")), this);
QShortcut *shortcutDisable = new QShortcut(QKeySequence(tr("Ctrl+D", "disable")), this);
connect(shortcutCopy, SIGNAL(activated()), this, SLOT(ctrlC()));
connect(shortcutPaste, SIGNAL(activated()), this, SLOT(ctrlV()));
connect(shortcutDisable, SIGNAL(activated()), this, SLOT(handleDisableSelected()));
}
void MainWindow::handleNewMotion()
{
motionfile::Motion newMotion;
QString path = m_save_controller->newMotion(newMotion);
if(path != "")
{
if(m_kModel->hasMotion() && m_kModel->hasUnsavedChanges())
proposeSave();
m_kModel->setMotion(newMotion);
m_recent_files->addRecentFile(path);
}
}
void MainWindow::handleLoad()
{
motionfile::Motion loadedMotion;
QString path = m_save_controller->open(loadedMotion);
handleLoad(path);
}
void MainWindow::handleLoad(QString path)
{
motionfile::Motion loadedMotion;
QString ckeckPath = m_save_controller->open(loadedMotion, path);
if(ckeckPath != "")
{
if(m_kModel->hasMotion() && m_kModel->hasUnsavedChanges())
proposeSave();
m_kModel->setMotion(loadedMotion);
m_recent_files->addRecentFile(ckeckPath);
}
else
QMessageBox::critical(0, "Error", "File you tried to open is not a valid motion!");
}
void MainWindow::handleSave()
{
m_save_controller->save(m_kModel->getMotion());
m_kModel->setSaved();
}
void MainWindow::handleSaveAs()
{
m_save_controller->saveAs(m_kModel->getMotion());
}
void MainWindow::handleSaveMirroredAs()
{
motionfile::Motion motion = m_kModel->getMotionCopy();
m_save_controller->saveMirroredAs(m_kModel->getMotion(), motion);
}
void MainWindow::initHeaderWidgets()
{
// Create Header
m_header_view = new HeaderView(m_ui->headerTabWidget);
m_header_view->enableEdit(false);
m_ui->headerTabWidget->addTab(createAreaWithWidget(m_header_view), "Header");
m_header_view->resize(800, 250);
m_ui->headerTabWidget->updateGeometry();
// Create Frame view
m_frame_view = new FrameView(m_ui->headerTabWidget);
m_ui->headerTabWidget->addTab(createAreaWithWidget(m_frame_view), "Frame");
// Create Rule view
m_rule_view = new RuleView(m_ui->headerTabWidget);
m_ui->headerTabWidget->addTab(createAreaWithWidget(m_rule_view), "Rule");
}
void MainWindow::initSpaces()
{
// Create Joint tabs
m_joint_space = new JointManager(m_kModel->getJointList(), m_ui->jointsTabWidget);
m_ui->jointsTabWidget->addTab(createAreaWithWidget(m_joint_space), "Joint Space");
m_abstract_space = new AbstractSpace(m_kModel->getJointList(), m_ui->jointsTabWidget);
m_ui->jointsTabWidget->addTab(createAreaWithWidget(m_abstract_space), "Abstract Space");
m_inverse_space = new InverseSpace(m_kModel->getJointList(), m_ui->jointsTabWidget);
m_ui->jointsTabWidget->addTab(createAreaWithWidget(m_inverse_space), "Inverse Space");
m_pid_space = new PIDSpace(m_kModel->getJointList(), m_ui->jointsTabWidget);
m_ui->jointsTabWidget->addTab(createAreaWithWidget(m_pid_space), "PID Space");
m_joint_space->resize(800, 150);
m_ui->jointsTabWidget->updateGeometry();
m_spaces.push_back(m_joint_space);
m_spaces.push_back(m_abstract_space);
m_spaces.push_back(m_inverse_space);
m_spaces.push_back(m_pid_space);
// Set up connections
for(unsigned i = 0; i < m_spaces.size(); i++)
{
m_spaces.at(i)->setEnabled(false);
connect(m_spaces.at(i), SIGNAL(updateRobot()), m_kModel, SLOT(updateRobotDisplay()));
connect(m_kModel, SIGNAL(currentFrameChanged(KeyframePtr)), m_spaces.at(i), SLOT(setFrame(KeyframePtr)));
connect(m_kModel, SIGNAL(jointListChanged(std::vector<std::string>)), m_spaces.at(i), SLOT(updateJointList(std::vector<std::string>)));
connect(m_kModel, SIGNAL(perspectiveChanged(joint_perspective::JointPerspective)),
m_spaces.at(i), SLOT(handlePerspectiveUpdate(joint_perspective::JointPerspective)));
}
connect(m_kModel, SIGNAL(getInverseLimits(bool&,double&)), m_inverse_space, SLOT(getInverseLimits(bool&,double&)));
connect(m_ui->jointsTabWidget, SIGNAL(currentChanged(int)), m_kModel, SLOT(handleTabChange(int)));
}
QScrollArea* MainWindow::createAreaWithWidget(QWidget* widget)
{
QScrollArea *area = new QScrollArea;
area->setWidget(widget);
area->setWidgetResizable(true);
return area;
}
void MainWindow::motionPlayerStateReceived(const motion_player::MotionPlayerState& stateMsg)
{
if(m_kModel->hasMotion() == false)
return;
QString state;
if(stateMsg.isPlaying)
{
setPlayButtonsEnabled(false);
state = QString("Motion %1 is being played").arg(QString::fromStdString(stateMsg.motionName));
// Visualize duration via progress bar
m_progress_bar->setMinimum(0);
m_progress_bar->setMaximum((int)(stateMsg.motionDuration*100));
m_progress_bar->setValue((int)(stateMsg.currentTime*100));
QString progressBarText = QString("%1 / %2 seconds (%p%)" ).arg(stateMsg.currentTime)
.arg(stateMsg.motionDuration);
m_progress_bar->setFormat(progressBarText);
if(m_progress_bar->isHidden())
m_progress_bar->show();
}
else
{
setPlayButtonsEnabled(true);
state = QString("Nothing is being played");
m_motion_player_client->tryPlayDelayedMotion();
if(m_progress_bar->isHidden() == false)
m_progress_bar->hide();
}
m_ui->statusbar->showMessage(state);
}
void MainWindow::playFrameClicked()
{
m_motion_player_client->playFrame(m_kModel->getCurrentFrameCopy(), m_kModel->getJointList(), 1);
}
void MainWindow::playFrameSlowClicked()
{
m_motion_player_client->playFrame(m_kModel->getCurrentFrameCopy()
, m_kModel->getJointList(), m_header_view->getFactor());
}
void MainWindow::playMotionClicked()
{
m_save_controller->saveBackup(m_kModel->getMotion());
m_motion_player_client->playMotion(m_kModel->getMotionCopy(), 1);
}
void MainWindow::playSlowMotionClicked()
{
m_save_controller->saveBackup(m_kModel->getMotion());
m_motion_player_client->playMotion(m_kModel->getMotionCopy(), m_header_view->getFactor());
}
// If there are at least 2 frames selected - play motion constructed from these frames
void MainWindow::playSequenceClicked()
{
std::vector<int> indices = getSelectedIndices(true);
if(indices.size() >= 2)
m_motion_player_client->playSequence(m_kModel->getMotionCopy(), indices);
}
void MainWindow::updateMotionClicked()
{
m_motion_player_client->updateMotion(m_kModel->getMotionCopy());
}
void MainWindow::setPlayButtonsEnabled(bool flag)
{
m_ui->playFrameButton->setEnabled(flag);
m_ui->playFrameSlowButton->setEnabled(flag);
m_ui->playMotionButton->setEnabled(flag);
m_ui->playMotionSlowButton->setEnabled(flag);
m_ui->playSequenceButton->setEnabled(flag);
m_ui->updateMotionButton->setEnabled(flag);
m_ui->actionPlay->setEnabled(flag);
m_ui->actionPlayMotionSlow->setEnabled(flag);
}
void MainWindow::setControlButtonsEnabled(bool flag)
{
m_ui->saveButton->setEnabled(flag);
m_ui->actionSave->setEnabled(flag);
m_ui->actionSave_as->setEnabled(flag);
m_ui->actionSave_mirrored_as->setEnabled(flag);
m_ui->moveUpButton->setEnabled(flag);
m_ui->moveDownButton->setEnabled(flag);
m_ui->addFrameButton->setEnabled(flag);
m_ui->remFrameButton->setEnabled(flag);
}
void MainWindow::ctrlC()
{
QModelIndexList selectedIndices = m_ui->trajectoryView->selectionModel()->selectedIndexes();
m_kModel->copySelectedFrames(selectedIndices);
}
void MainWindow::ctrlV()
{
m_kModel->insertCopiedFrames();
}
void MainWindow::handleAddFrameButton()
{
// Get current selection
QModelIndexList selectedIndices = m_ui->trajectoryView->selectionModel()->selectedIndexes();
if(selectedIndices.size() > 0)
m_kModel->addFrame(selectedIndices.last().row() + 1); // If something is selected - add frame after it
else
m_kModel->addFrame(m_kModel->rowCount()); // Otherwise - add frame to the end
}
// Rturn vector of currently selected indices. Sorted if sort == true
std::vector<int> MainWindow::getSelectedIndices(bool sort)
{
// Get current selection
QModelIndexList selectedIndices = m_ui->trajectoryView->selectionModel()->selectedIndexes();
std::vector<int> indices;
for(int i = 0; i < selectedIndices.size(); i++)
indices.push_back(selectedIndices.at(i).row());
// Sort indices from lesser to bigger if requested
if(sort)
std::sort(indices.begin(), indices.end());
return indices;
}
void MainWindow::handleSelectionChanged(QItemSelection selection)
{
QModelIndexList selectedIndexes = selection.indexes();
if(selectedIndexes.size() > 0)
m_kModel->handleIndexChange(selectedIndexes.first());
}
void MainWindow::setViewSelection(int row)
{
QModelIndex index = m_kModel->index(row, 0, QModelIndex());
m_ui->trajectoryView->setCurrentIndex(index);
m_ui->trajectoryView->update();
m_ui->trajectoryView->setFocus();
}
void MainWindow::setViewSelection(QItemSelection selection)
{
QItemSelectionModel *selectionModel = m_ui->trajectoryView->selectionModel();
m_ui->trajectoryView->clearSelection();
selectionModel->select(selection, QItemSelectionModel::Select);
m_ui->trajectoryView->update();
m_ui->trajectoryView->setFocus();
}
void MainWindow::updateCurrentFileLabel(QString newTitle)
{
m_ui->headerLabel->setText(newTitle);
}
void MainWindow::handleMoveUp()
{
QModelIndexList selectedIndexes = m_ui->trajectoryView->selectionModel()->selectedIndexes();
qSort(selectedIndexes.begin(), selectedIndexes.end(), qLess<QModelIndex>());
if(selectedIndexes.isEmpty())
return;
if(selectedIndexes.at(0).row() == 0)
return;
QItemSelection selection;
for(int i = 0; i < selectedIndexes.size(); i++)
{
m_kModel->moveFrame(selectedIndexes.at(i).row(), -1); // move
QModelIndex index = m_kModel->index(selectedIndexes.at(i).row()-1, 0, QModelIndex());
selection.select(index, index); // create new selection
}
this->setViewSelection(selection);
}
void MainWindow::handleMoveDown()
{
QModelIndexList selectedIndexes = m_ui->trajectoryView->selectionModel()->selectedIndexes();
qSort(selectedIndexes.begin(), selectedIndexes.end(), qGreater<QModelIndex>());
if(selectedIndexes.isEmpty())
return;
if(selectedIndexes.at(0).row() == m_kModel->rowCount()-1)
return;
QItemSelection selection;
for(int i = 0; i < selectedIndexes.size(); i++)
{
m_kModel->moveFrame(selectedIndexes.at(i).row(), 1); // move
QModelIndex index = m_kModel->index(selectedIndexes.at(i).row()+1, 0, QModelIndex());
selection.select(index, index); // create new selection
}
this->setViewSelection(selection);
}
void MainWindow::handleRemoveButton()
{
QModelIndexList list = m_ui->trajectoryView->selectionModel()->selectedIndexes();
qSort(list.begin(), list.end(), qGreater<QModelIndex>());
for(int i = 0; i < list.size(); i++)
m_kModel->removeFrame(list.at(i).row());
}
void MainWindow::handleDisableSelected()
{
QModelIndexList list = m_ui->trajectoryView->selectionModel()->selectedIndexes();
qSort(list.begin(), list.end(), qGreater<QModelIndex>());
for(int i = 0; i < list.size(); i++)
m_kModel->disableFrame(list.at(i).row());
}
void MainWindow::showAbout()
{
m_about_view->show();
}
void MainWindow::showControls()
{
m_controls_view->show();
}
void MainWindow::proposeSave()
{
QMessageBox proposeSaveBox;
proposeSaveBox.setWindowTitle("Trajectory Editor warning");
proposeSaveBox.setText("You have unsaved changes! Do you want to save them?");;
proposeSaveBox.setStandardButtons(QMessageBox::Save | QMessageBox::Close);
proposeSaveBox.setDefaultButton(QMessageBox::Save);
int answer = proposeSaveBox.exec();
if(answer == QMessageBox::Save)
handleSave();
}
void MainWindow::onQuit()
{
if(m_kModel->hasMotion() && m_kModel->hasUnsavedChanges())
proposeSave();
}
MainWindow::~MainWindow()
{
onQuit();
delete m_kModel;
delete m_motion_player_client;
delete m_save_controller;
delete m_recent_files;
delete m_ui;
delete m_controls_view;
delete m_about_view;
}
| 32.198276 | 137 | 0.748541 | [
"vector",
"model"
] |
4760ccd473dccd6dbe5abded5c5feb848f77fc3a | 2,016 | cpp | C++ | src/States/PauseState.cpp | baiyqukq/Gems | 3ae5889ec1e7a6c06a3c4cfc6a587ee5922e1e61 | [
"MIT"
] | null | null | null | src/States/PauseState.cpp | baiyqukq/Gems | 3ae5889ec1e7a6c06a3c4cfc6a587ee5922e1e61 | [
"MIT"
] | null | null | null | src/States/PauseState.cpp | baiyqukq/Gems | 3ae5889ec1e7a6c06a3c4cfc6a587ee5922e1e61 | [
"MIT"
] | null | null | null | #include "PauseState.h"
#include "GameStateMachine.h"
#include "MainMenuState.h"
#include "StateParser.h"
#include "Objects/MenuButton.h"
#include "TextureManager.h"
#include "InputHandler.h"
#include "Engine.h"
#include "LoaderParams.h"
using namespace std;
const std::string PauseState::s_stateID = "PauseState";
PauseState::PauseState()
{
}
void PauseState::render()
{
for (size_t i = 0; i < m_gameObjects.size(); i++) {
m_gameObjects[i]->draw();
}
}
std::string PauseState::getStateID() const
{
return s_stateID;
}
void PauseState::setCallbacks(const std::vector<MenuState::Callback> &callbacks)
{
MenuButton *menuBtn;
for(size_t i = 0; i < m_gameObjects.size(); i++)
{
// if they are of type MenuButton then assign a callback based on the id passed in from the file
menuBtn = dynamic_cast<MenuButton*>(m_gameObjects[i]);
if (menuBtn)
{
menuBtn->setCallback(callbacks[menuBtn->getCallbackID()]);
}
}
}
void PauseState::s_pauseToMain()
{
TheEngine::Instance()->getGameStateMachine()->changeState(new MainMenuState);
}
void PauseState::s_resumePlay()
{
TheEngine::Instance()->getGameStateMachine()->popState();
}
void PauseState::update()
{
for (size_t i = 0; i < m_gameObjects.size(); i++) {
m_gameObjects[i]->update();
}
}
void PauseState::onEnter()
{
StateParser parser;
parser.parseState("xml/states.xml", "STATE_PAUSE", &m_gameObjects, &m_textureIDs);
m_callbacks.push_back(s_pauseToMain);
m_callbacks.push_back(s_resumePlay);
setCallbacks(m_callbacks);
}
void PauseState::onExit()
{
for (size_t i = 0; i < m_gameObjects.size(); i++) {
m_gameObjects[i]->clear();
}
m_gameObjects.clear();
for (size_t i = 0; i < m_textureIDs.size(); i++) {
TextureManager::Instance()->clearFromTextureMap(m_textureIDs[i]);
}
m_textureIDs.clear();
// reset the mouse button states to false
InputHandler::Instance()->reset();
}
| 21.446809 | 104 | 0.660218 | [
"render",
"vector"
] |
476590cd65baf581eca651c1190302d6cb9b43f5 | 810,573 | cpp | C++ | Library/Il2cppBuildCache/Lumin/il2cppOutput/UnresolvedVirtualCallStubs.cpp | coderrick/xrrx-snake | acc1212ff0cf5aba3ad101f7cabb4adab935fb62 | [
"MIT"
] | null | null | null | Library/Il2cppBuildCache/Lumin/il2cppOutput/UnresolvedVirtualCallStubs.cpp | coderrick/xrrx-snake | acc1212ff0cf5aba3ad101f7cabb4adab935fb62 | [
"MIT"
] | null | null | null | Library/Il2cppBuildCache/Lumin/il2cppOutput/UnresolvedVirtualCallStubs.cpp | coderrick/xrrx-snake | acc1212ff0cf5aba3ad101f7cabb4adab935fb62 | [
"MIT"
] | null | null | null | #include "pch-cpp.hpp"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <stdint.h>
#include <limits>
// System.Action`1<System.Object>
struct Action_1_tD9663D9715FAA4E62035CFCF1AD4D094EE7872DC;
// System.Collections.Generic.Dictionary`2<System.UInt32,System.Func`2<System.IntPtr,System.Single>>
struct Dictionary_2_t178D95092ECF265C706E3FC09C95B1DF57EFA43C;
// System.Collections.Generic.Dictionary`2<UnityEngine.XR.MagicLeap.MLResult/Code,UnityEngine.XR.MagicLeap.MLResult>
struct Dictionary_2_tD6F5BABC8E0815B66CB3FCE70A8A0FCF9837CBF1;
// System.Func`1<System.Byte[]>
struct Func_1_tD8059ADEA67BC54CB9CB92E8719A3A6BE8473473;
// System.Collections.Generic.List`1<System.Object>
struct List_1_t3F94120C77410A62EAE48421CF166B83AB95A2F5;
// System.Collections.Generic.List`1<System.String>
struct List_1_t6C9F81EDBF0F4A31A9B0DA372D2EF34BDA3A1AF3;
// System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.UI.ThemeProperty>
struct List_1_tB423C8A3B8886D82EADF0276CDCC6A9572ED6DDC;
// System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.UI.ThemeStateProperty>
struct List_1_tF1E76A3D523F2AEA047842F1BB441371552FC7F9;
// System.Collections.Generic.List`1<UnityEngine.SpatialTracking.TrackedPoseDriver/TrackedPose>
struct List_1_tA9A7E2A508B3146A7DE46E73A64E988FE4BD5248;
// System.Threading.Tasks.Task`1<System.String>
struct Task_1_t30D80D0F41B19BC27A8D1141D69741D0B986B2C3;
// System.Byte[]
struct ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726;
// System.Char[]
struct CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34;
// System.Int32[]
struct Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32;
// System.Single[]
struct SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA;
// System.String[]
struct StringU5BU5D_tACEBFEDE350025B554CD507C9AE8FFE49359549A;
// System.UInt32[]
struct UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF;
// UnityEngine.XR.MagicLeap.MLBluetoothLE/Descriptor[]
struct DescriptorU5BU5D_tD7F5ECF9C146C84AF8669CB04F50DAFB8BE8E5F8;
// UnityEngine.XR.MagicLeap.MLMediaPlayer/Cea608CaptionLine[]
struct Cea608CaptionLineU5BU5D_tD5903054F45675025C96AE02F39A8BA8C6599182;
// UnityEngine.XR.MagicLeap.MLPlanes/Boundaries[]
struct BoundariesU5BU5D_t0531CA96D172062A97850316ECA6C164BF6BBDE3;
// UnityEngine.XR.MagicLeap.MLPlanes/Plane[]
struct PlaneU5BU5D_tDA0004DD30CE85D4657F29D2F513A9D13DBA5CC4;
// UnityEngine.XR.MagicLeap.MLHandMeshing/Mesh/Block[]
struct BlockU5BU5D_tF12A3EC47CD39550BDB4B5CD7AD65F79F5601113;
// UnityEngine.XR.MagicLeap.MLMRCamera/Frame/ImagePlane[]
struct ImagePlaneU5BU5D_tB00DBE0C67553311B758AA016D527AAEC57CA334;
// UnityEngine.XR.MagicLeap.MLWebRTC/VideoSink/Frame/ImagePlane[]
struct ImagePlaneU5BU5D_t7E88C21096FFC2D5885B1B4DB4B91918F52C4383;
// UnityEngine.AnimationCurve
struct AnimationCurve_t2D452A14820CEDB83BFF2C911682A4E59001AD03;
// UnityEngine.AudioClip
struct AudioClip_t16D2E573E7CC1C5118D8EE0F0692D46866A1C0EE;
// UnityEngine.EventSystems.BaseRaycaster
struct BaseRaycaster_tBC0FB2CBE6D3D40991EC20F689C43F76AD82A876;
// System.Threading.CancellationTokenSource
struct CancellationTokenSource_t78B989179DE23EDD36F870FFEE20A15D6D3C65B3;
// UnityEngine.Collider
struct Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02;
// Microsoft.MixedReality.Toolkit.Utilities.Easing
struct Easing_tAA867F785964FBF3969D6B74FF22B130B0C59833;
// UnityEngine.GameObject
struct GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319;
// UnityEngine.UI.Graphic
struct Graphic_tF07D777035055CF93BA5F46F77ED5EDFEFF9AE24;
// UnityEngine.EventSystems.IEventSystemHandler
struct IEventSystemHandler_t1DD10C5DE6E83E93893A57F62794B08E3FD64DC6;
// Microsoft.MixedReality.Toolkit.Input.IMixedRealityPointer
struct IMixedRealityPointer_tF6CC763A793FD3C0F29BBAA0EE6780064868118C;
// System.Threading.ManualResetEvent
struct ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA;
// UnityEngine.Material
struct Material_t8927C00353A72755313F046D0CE85178AE8218EE;
// UnityEngine.MaterialPropertyBlock
struct MaterialPropertyBlock_t6C45FC5DE951DA662BBB7A55EEB3DEF33C5431A0;
// System.Reflection.MemberInfo
struct MemberInfo_t;
// UnityEngine.Mesh
struct Mesh_t2F5992DBA650D5862B43D3823ACD997132A57DA6;
// UnityEngine.MeshCollider
struct MeshCollider_t1983F4E7E53D8C6B65FE21A8B4E2345A84D57E98;
// UnityEngine.Object
struct Object_tF2F3778131EFF286AF62B7B013A170F95A91571A;
// System.Security.Cryptography.RandomNumberGenerator
struct RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50;
// System.Text.RegularExpressions.Regex
struct Regex_t90F443D398F44965EA241A652ED75DF5BA072A1F;
// UnityEngine.RenderTexture
struct RenderTexture_t5FE7A5B47EF962A0E8D7BEBA05E9FC87D49A1849;
// UnityEngine.Renderer
struct Renderer_t58147AB5B00224FE1460FD47542DC0DA7EC9378C;
// UnityEngine.ScriptableObject
struct ScriptableObject_t4361E08CEBF052C650D3666C7CEC37EB31DE116A;
// UnityEngine.UI.Selectable
struct Selectable_t34088A3677CC9D344F81B0D91999D8C5963D7DBD;
// System.Threading.SendOrPostCallback
struct SendOrPostCallback_t6B7334CE017AF595535507519400AC02D688DC3C;
// UnityEngine.Sprite
struct Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9;
// System.String
struct String_t;
// UnityEngine.Texture
struct Texture_t9FE0218A1EEDF266E8C85879FE123265CACC95AE;
// UnityEngine.Texture2D
struct Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF;
// UnityEngine.Transform
struct Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1;
// System.Type
struct Type_t;
// UnityEngine.Events.UnityAction
struct UnityAction_t22E545F8BE0A62EE051C6A83E209587A0DB1C099;
// UnityEngine.Events.UnityEvent
struct UnityEvent_tA0EA9BC49FD7D5185E7A238EF2E0E6F5D0EE27F4;
// UnityEngine.VFX.VFXEventAttribute
struct VFXEventAttribute_tC4E90458100D52776F591CE62B19FF6051F423EF;
// System.Void
struct Void_t700C6383A2A510C2CF4DD86DABD5CA9FF70ADAC5;
// UnityEngine.XR.MagicLeap.MLContacts/Contact
struct Contact_t857FE58A25A2CDF327C7C5F7F3A6946AEC210DFE;
// UnityEngine.XR.MagicLeap.MLDispatch/OAuthHandler
struct OAuthHandler_t3B1901EF51E905EF87344BA6AD7223C9127914C7;
// UnityEngine.XR.MagicLeap.MLPlanes/QueryResultsDelegate
struct QueryResultsDelegate_t195F1788456C85C6008A57CA5D8806BB6C819599;
struct AnimationCurve_t2D452A14820CEDB83BFF2C911682A4E59001AD03_marshaled_com;
struct Block_tBDA4C589DF3FAA41A92D19E5CC013C74B4F83EC0_marshaled_com;
struct Block_tBDA4C589DF3FAA41A92D19E5CC013C74B4F83EC0_marshaled_pinvoke;
struct Boundaries_t9D05C3A6C63A9D441F79E0E47B2E536E4A049694_marshaled_com;
struct Boundaries_t9D05C3A6C63A9D441F79E0E47B2E536E4A049694_marshaled_pinvoke;
struct Descriptor_t369955C9D183FE09E69BB860543789ACE71BFBF3_marshaled_com;
struct Descriptor_t369955C9D183FE09E69BB860543789ACE71BFBF3_marshaled_pinvoke;
struct ImagePlane_t2D929496EA001719A11E4DF9B11BD09B7B538D46_marshaled_com;
struct ImagePlane_t2D929496EA001719A11E4DF9B11BD09B7B538D46_marshaled_pinvoke;
struct ImagePlane_t91027FEA4D694BC1810C3A63484BBC6DDA7C44DF ;
struct Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_marshaled_com;
struct Plane_tC3C9B3B2357B4E474F4DBA0AB9E2E0A40E766287 ;
struct ScriptableObject_t4361E08CEBF052C650D3666C7CEC37EB31DE116A_marshaled_com;
struct VFXEventAttribute_tC4E90458100D52776F591CE62B19FF6051F423EF_marshaled_com;
struct VFXEventAttribute_tC4E90458100D52776F591CE62B19FF6051F423EF_marshaled_pinvoke;
IL2CPP_EXTERN_C_BEGIN
IL2CPP_EXTERN_C_END
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Object
// System.ValueType
struct ValueType_tDBF999C1B75C48C68621878250DBF6CDBCF51E52 : public RuntimeObject
{
public:
public:
};
// Native definition for P/Invoke marshalling of System.ValueType
struct ValueType_tDBF999C1B75C48C68621878250DBF6CDBCF51E52_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.ValueType
struct ValueType_tDBF999C1B75C48C68621878250DBF6CDBCF51E52_marshaled_com
{
};
// System.Collections.Generic.KeyValuePair`2<System.Byte,System.Object>
struct KeyValuePair_2_t174DCFB8AAA63D8A6758035BD4B81EDA4A4A7957
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
uint8_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
RuntimeObject * ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t174DCFB8AAA63D8A6758035BD4B81EDA4A4A7957, ___key_0)); }
inline uint8_t get_key_0() const { return ___key_0; }
inline uint8_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(uint8_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t174DCFB8AAA63D8A6758035BD4B81EDA4A4A7957, ___value_1)); }
inline RuntimeObject * get_value_1() const { return ___value_1; }
inline RuntimeObject ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(RuntimeObject * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// System.Collections.Generic.KeyValuePair`2<System.Int32,System.Boolean>
struct KeyValuePair_2_t239694BB713649B9F5326D1A5BC3143EA54316B3
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
int32_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
bool ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t239694BB713649B9F5326D1A5BC3143EA54316B3, ___key_0)); }
inline int32_t get_key_0() const { return ___key_0; }
inline int32_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(int32_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t239694BB713649B9F5326D1A5BC3143EA54316B3, ___value_1)); }
inline bool get_value_1() const { return ___value_1; }
inline bool* get_address_of_value_1() { return &___value_1; }
inline void set_value_1(bool value)
{
___value_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.Int32,System.Char>
struct KeyValuePair_2_t1E4C4AAA2E07F40196F2EBEC29A6D137D0A9D265
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
int32_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
Il2CppChar ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t1E4C4AAA2E07F40196F2EBEC29A6D137D0A9D265, ___key_0)); }
inline int32_t get_key_0() const { return ___key_0; }
inline int32_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(int32_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t1E4C4AAA2E07F40196F2EBEC29A6D137D0A9D265, ___value_1)); }
inline Il2CppChar get_value_1() const { return ___value_1; }
inline Il2CppChar* get_address_of_value_1() { return &___value_1; }
inline void set_value_1(Il2CppChar value)
{
___value_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.Int32,System.Int32>
struct KeyValuePair_2_tE78AD78874BCE1BC993F92EF8CBBDC3B30E44CBB
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
int32_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
int32_t ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tE78AD78874BCE1BC993F92EF8CBBDC3B30E44CBB, ___key_0)); }
inline int32_t get_key_0() const { return ___key_0; }
inline int32_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(int32_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tE78AD78874BCE1BC993F92EF8CBBDC3B30E44CBB, ___value_1)); }
inline int32_t get_value_1() const { return ___value_1; }
inline int32_t* get_address_of_value_1() { return &___value_1; }
inline void set_value_1(int32_t value)
{
___value_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.Int32,System.Int64>
struct KeyValuePair_2_tE8FA5EF9EFE23FF7AB54968FA25D3487B37D4D28
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
int32_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
int64_t ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tE8FA5EF9EFE23FF7AB54968FA25D3487B37D4D28, ___key_0)); }
inline int32_t get_key_0() const { return ___key_0; }
inline int32_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(int32_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tE8FA5EF9EFE23FF7AB54968FA25D3487B37D4D28, ___value_1)); }
inline int64_t get_value_1() const { return ___value_1; }
inline int64_t* get_address_of_value_1() { return &___value_1; }
inline void set_value_1(int64_t value)
{
___value_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>
struct KeyValuePair_2_t56E20A5489EE435FD8BBE3EFACF6219A626E04C0
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
int32_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
RuntimeObject * ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t56E20A5489EE435FD8BBE3EFACF6219A626E04C0, ___key_0)); }
inline int32_t get_key_0() const { return ___key_0; }
inline int32_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(int32_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t56E20A5489EE435FD8BBE3EFACF6219A626E04C0, ___value_1)); }
inline RuntimeObject * get_value_1() const { return ___value_1; }
inline RuntimeObject ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(RuntimeObject * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// System.Collections.Generic.KeyValuePair`2<System.Int32,System.UInt32>
struct KeyValuePair_2_tDD55E6C6020C20298FD24189CC4023F8D8751975
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
int32_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
uint32_t ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tDD55E6C6020C20298FD24189CC4023F8D8751975, ___key_0)); }
inline int32_t get_key_0() const { return ___key_0; }
inline int32_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(int32_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tDD55E6C6020C20298FD24189CC4023F8D8751975, ___value_1)); }
inline uint32_t get_value_1() const { return ___value_1; }
inline uint32_t* get_address_of_value_1() { return &___value_1; }
inline void set_value_1(uint32_t value)
{
___value_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.Int32,System.UInt64>
struct KeyValuePair_2_tAD021667BA62C6C3CEE28B2A5D24AF5111FC8095
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
int32_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
uint64_t ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tAD021667BA62C6C3CEE28B2A5D24AF5111FC8095, ___key_0)); }
inline int32_t get_key_0() const { return ___key_0; }
inline int32_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(int32_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tAD021667BA62C6C3CEE28B2A5D24AF5111FC8095, ___value_1)); }
inline uint64_t get_value_1() const { return ___value_1; }
inline uint64_t* get_address_of_value_1() { return &___value_1; }
inline void set_value_1(uint64_t value)
{
___value_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.Int64,System.Object>
struct KeyValuePair_2_t8EB09BF4DD251CCCBB6F85C46B29153BF9822DA2
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
int64_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
RuntimeObject * ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t8EB09BF4DD251CCCBB6F85C46B29153BF9822DA2, ___key_0)); }
inline int64_t get_key_0() const { return ___key_0; }
inline int64_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(int64_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t8EB09BF4DD251CCCBB6F85C46B29153BF9822DA2, ___value_1)); }
inline RuntimeObject * get_value_1() const { return ___value_1; }
inline RuntimeObject ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(RuntimeObject * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// System.Collections.Generic.KeyValuePair`2<System.Object,System.Boolean>
struct KeyValuePair_2_tF48C056DF83BF9AF3BAE277B149EC5E4E436BD1A
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
RuntimeObject * ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
bool ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tF48C056DF83BF9AF3BAE277B149EC5E4E436BD1A, ___key_0)); }
inline RuntimeObject * get_key_0() const { return ___key_0; }
inline RuntimeObject ** get_address_of_key_0() { return &___key_0; }
inline void set_key_0(RuntimeObject * value)
{
___key_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___key_0), (void*)value);
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tF48C056DF83BF9AF3BAE277B149EC5E4E436BD1A, ___value_1)); }
inline bool get_value_1() const { return ___value_1; }
inline bool* get_address_of_value_1() { return &___value_1; }
inline void set_value_1(bool value)
{
___value_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>
struct KeyValuePair_2_t95507C2A8401F2191EE3D308B1B00E3729AE41B5
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
RuntimeObject * ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
int32_t ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t95507C2A8401F2191EE3D308B1B00E3729AE41B5, ___key_0)); }
inline RuntimeObject * get_key_0() const { return ___key_0; }
inline RuntimeObject ** get_address_of_key_0() { return &___key_0; }
inline void set_key_0(RuntimeObject * value)
{
___key_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___key_0), (void*)value);
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t95507C2A8401F2191EE3D308B1B00E3729AE41B5, ___value_1)); }
inline int32_t get_value_1() const { return ___value_1; }
inline int32_t* get_address_of_value_1() { return &___value_1; }
inline void set_value_1(int32_t value)
{
___value_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>
struct KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
RuntimeObject * ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
RuntimeObject * ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625, ___key_0)); }
inline RuntimeObject * get_key_0() const { return ___key_0; }
inline RuntimeObject ** get_address_of_key_0() { return &___key_0; }
inline void set_key_0(RuntimeObject * value)
{
___key_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___key_0), (void*)value);
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625, ___value_1)); }
inline RuntimeObject * get_value_1() const { return ___value_1; }
inline RuntimeObject ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(RuntimeObject * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// System.Collections.Generic.KeyValuePair`2<System.Object,System.UInt32>
struct KeyValuePair_2_t0BDEBB7E26082FCC604A0CE9B29AB0FCE1140700
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
RuntimeObject * ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
uint32_t ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t0BDEBB7E26082FCC604A0CE9B29AB0FCE1140700, ___key_0)); }
inline RuntimeObject * get_key_0() const { return ___key_0; }
inline RuntimeObject ** get_address_of_key_0() { return &___key_0; }
inline void set_key_0(RuntimeObject * value)
{
___key_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___key_0), (void*)value);
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t0BDEBB7E26082FCC604A0CE9B29AB0FCE1140700, ___value_1)); }
inline uint32_t get_value_1() const { return ___value_1; }
inline uint32_t* get_address_of_value_1() { return &___value_1; }
inline void set_value_1(uint32_t value)
{
___value_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.UInt32,System.Boolean>
struct KeyValuePair_2_t504EC26DD47F99A8C06286072D44FAA1ABD0CD93
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
uint32_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
bool ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t504EC26DD47F99A8C06286072D44FAA1ABD0CD93, ___key_0)); }
inline uint32_t get_key_0() const { return ___key_0; }
inline uint32_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(uint32_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t504EC26DD47F99A8C06286072D44FAA1ABD0CD93, ___value_1)); }
inline bool get_value_1() const { return ___value_1; }
inline bool* get_address_of_value_1() { return &___value_1; }
inline void set_value_1(bool value)
{
___value_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.UInt32,System.Int32>
struct KeyValuePair_2_t1C899E1D384EB1A82B398076E49CE2B74F0CE329
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
uint32_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
int32_t ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t1C899E1D384EB1A82B398076E49CE2B74F0CE329, ___key_0)); }
inline uint32_t get_key_0() const { return ___key_0; }
inline uint32_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(uint32_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t1C899E1D384EB1A82B398076E49CE2B74F0CE329, ___value_1)); }
inline int32_t get_value_1() const { return ___value_1; }
inline int32_t* get_address_of_value_1() { return &___value_1; }
inline void set_value_1(int32_t value)
{
___value_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.UInt32,System.Object>
struct KeyValuePair_2_tCEEEA2545C9572EC331DBB69871921A5B01E60DA
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
uint32_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
RuntimeObject * ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tCEEEA2545C9572EC331DBB69871921A5B01E60DA, ___key_0)); }
inline uint32_t get_key_0() const { return ___key_0; }
inline uint32_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(uint32_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tCEEEA2545C9572EC331DBB69871921A5B01E60DA, ___value_1)); }
inline RuntimeObject * get_value_1() const { return ___value_1; }
inline RuntimeObject ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(RuntimeObject * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>
struct KeyValuePair_2_tB8C085DAB5BB6A37255E0F93DBDCB70456DA2703
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
uint64_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
RuntimeObject * ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tB8C085DAB5BB6A37255E0F93DBDCB70456DA2703, ___key_0)); }
inline uint64_t get_key_0() const { return ___key_0; }
inline uint64_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(uint64_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tB8C085DAB5BB6A37255E0F93DBDCB70456DA2703, ___value_1)); }
inline RuntimeObject * get_value_1() const { return ___value_1; }
inline RuntimeObject ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(RuntimeObject * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// System.Nullable`1<System.Boolean>
struct Nullable_1_t1D1CD146BFCBDC2E53E1F700889F8C5C21063EF3
{
public:
// T System.Nullable`1::value
bool ___value_0;
// System.Boolean System.Nullable`1::has_value
bool ___has_value_1;
public:
inline static int32_t get_offset_of_value_0() { return static_cast<int32_t>(offsetof(Nullable_1_t1D1CD146BFCBDC2E53E1F700889F8C5C21063EF3, ___value_0)); }
inline bool get_value_0() const { return ___value_0; }
inline bool* get_address_of_value_0() { return &___value_0; }
inline void set_value_0(bool value)
{
___value_0 = value;
}
inline static int32_t get_offset_of_has_value_1() { return static_cast<int32_t>(offsetof(Nullable_1_t1D1CD146BFCBDC2E53E1F700889F8C5C21063EF3, ___has_value_1)); }
inline bool get_has_value_1() const { return ___has_value_1; }
inline bool* get_address_of_has_value_1() { return &___has_value_1; }
inline void set_has_value_1(bool value)
{
___has_value_1 = value;
}
};
// System.Nullable`1<System.Int32>
struct Nullable_1_t864FD0051A05D37F91C857AB496BFCB3FE756103
{
public:
// T System.Nullable`1::value
int32_t ___value_0;
// System.Boolean System.Nullable`1::has_value
bool ___has_value_1;
public:
inline static int32_t get_offset_of_value_0() { return static_cast<int32_t>(offsetof(Nullable_1_t864FD0051A05D37F91C857AB496BFCB3FE756103, ___value_0)); }
inline int32_t get_value_0() const { return ___value_0; }
inline int32_t* get_address_of_value_0() { return &___value_0; }
inline void set_value_0(int32_t value)
{
___value_0 = value;
}
inline static int32_t get_offset_of_has_value_1() { return static_cast<int32_t>(offsetof(Nullable_1_t864FD0051A05D37F91C857AB496BFCB3FE756103, ___has_value_1)); }
inline bool get_has_value_1() const { return ___has_value_1; }
inline bool* get_address_of_has_value_1() { return &___has_value_1; }
inline void set_has_value_1(bool value)
{
___has_value_1 = value;
}
};
// UnityEngine.XR.Bone
struct Bone_t8EDF2FA2139528015195AF2EA866A28947C3F070
{
public:
// System.UInt64 UnityEngine.XR.Bone::m_DeviceId
uint64_t ___m_DeviceId_0;
// System.UInt32 UnityEngine.XR.Bone::m_FeatureIndex
uint32_t ___m_FeatureIndex_1;
public:
inline static int32_t get_offset_of_m_DeviceId_0() { return static_cast<int32_t>(offsetof(Bone_t8EDF2FA2139528015195AF2EA866A28947C3F070, ___m_DeviceId_0)); }
inline uint64_t get_m_DeviceId_0() const { return ___m_DeviceId_0; }
inline uint64_t* get_address_of_m_DeviceId_0() { return &___m_DeviceId_0; }
inline void set_m_DeviceId_0(uint64_t value)
{
___m_DeviceId_0 = value;
}
inline static int32_t get_offset_of_m_FeatureIndex_1() { return static_cast<int32_t>(offsetof(Bone_t8EDF2FA2139528015195AF2EA866A28947C3F070, ___m_FeatureIndex_1)); }
inline uint32_t get_m_FeatureIndex_1() const { return ___m_FeatureIndex_1; }
inline uint32_t* get_address_of_m_FeatureIndex_1() { return &___m_FeatureIndex_1; }
inline void set_m_FeatureIndex_1(uint32_t value)
{
___m_FeatureIndex_1 = value;
}
};
// System.Boolean
struct Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37
{
public:
// System.Boolean System.Boolean::m_value
bool ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37, ___m_value_0)); }
inline bool get_m_value_0() const { return ___m_value_0; }
inline bool* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(bool value)
{
___m_value_0 = value;
}
};
struct Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37_StaticFields
{
public:
// System.String System.Boolean::TrueString
String_t* ___TrueString_5;
// System.String System.Boolean::FalseString
String_t* ___FalseString_6;
public:
inline static int32_t get_offset_of_TrueString_5() { return static_cast<int32_t>(offsetof(Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37_StaticFields, ___TrueString_5)); }
inline String_t* get_TrueString_5() const { return ___TrueString_5; }
inline String_t** get_address_of_TrueString_5() { return &___TrueString_5; }
inline void set_TrueString_5(String_t* value)
{
___TrueString_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___TrueString_5), (void*)value);
}
inline static int32_t get_offset_of_FalseString_6() { return static_cast<int32_t>(offsetof(Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37_StaticFields, ___FalseString_6)); }
inline String_t* get_FalseString_6() const { return ___FalseString_6; }
inline String_t** get_address_of_FalseString_6() { return &___FalseString_6; }
inline void set_FalseString_6(String_t* value)
{
___FalseString_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___FalseString_6), (void*)value);
}
};
// System.Threading.CancellationToken
struct CancellationToken_tC9D68381C9164A4BA10397257E87ADC832AF5FFD
{
public:
// System.Threading.CancellationTokenSource System.Threading.CancellationToken::m_source
CancellationTokenSource_t78B989179DE23EDD36F870FFEE20A15D6D3C65B3 * ___m_source_0;
public:
inline static int32_t get_offset_of_m_source_0() { return static_cast<int32_t>(offsetof(CancellationToken_tC9D68381C9164A4BA10397257E87ADC832AF5FFD, ___m_source_0)); }
inline CancellationTokenSource_t78B989179DE23EDD36F870FFEE20A15D6D3C65B3 * get_m_source_0() const { return ___m_source_0; }
inline CancellationTokenSource_t78B989179DE23EDD36F870FFEE20A15D6D3C65B3 ** get_address_of_m_source_0() { return &___m_source_0; }
inline void set_m_source_0(CancellationTokenSource_t78B989179DE23EDD36F870FFEE20A15D6D3C65B3 * value)
{
___m_source_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_source_0), (void*)value);
}
};
struct CancellationToken_tC9D68381C9164A4BA10397257E87ADC832AF5FFD_StaticFields
{
public:
// System.Action`1<System.Object> System.Threading.CancellationToken::s_ActionToActionObjShunt
Action_1_tD9663D9715FAA4E62035CFCF1AD4D094EE7872DC * ___s_ActionToActionObjShunt_1;
public:
inline static int32_t get_offset_of_s_ActionToActionObjShunt_1() { return static_cast<int32_t>(offsetof(CancellationToken_tC9D68381C9164A4BA10397257E87ADC832AF5FFD_StaticFields, ___s_ActionToActionObjShunt_1)); }
inline Action_1_tD9663D9715FAA4E62035CFCF1AD4D094EE7872DC * get_s_ActionToActionObjShunt_1() const { return ___s_ActionToActionObjShunt_1; }
inline Action_1_tD9663D9715FAA4E62035CFCF1AD4D094EE7872DC ** get_address_of_s_ActionToActionObjShunt_1() { return &___s_ActionToActionObjShunt_1; }
inline void set_s_ActionToActionObjShunt_1(Action_1_tD9663D9715FAA4E62035CFCF1AD4D094EE7872DC * value)
{
___s_ActionToActionObjShunt_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_ActionToActionObjShunt_1), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.Threading.CancellationToken
struct CancellationToken_tC9D68381C9164A4BA10397257E87ADC832AF5FFD_marshaled_pinvoke
{
CancellationTokenSource_t78B989179DE23EDD36F870FFEE20A15D6D3C65B3 * ___m_source_0;
};
// Native definition for COM marshalling of System.Threading.CancellationToken
struct CancellationToken_tC9D68381C9164A4BA10397257E87ADC832AF5FFD_marshaled_com
{
CancellationTokenSource_t78B989179DE23EDD36F870FFEE20A15D6D3C65B3 * ___m_source_0;
};
// UnityEngine.Color
struct Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659
{
public:
// System.Single UnityEngine.Color::r
float ___r_0;
// System.Single UnityEngine.Color::g
float ___g_1;
// System.Single UnityEngine.Color::b
float ___b_2;
// System.Single UnityEngine.Color::a
float ___a_3;
public:
inline static int32_t get_offset_of_r_0() { return static_cast<int32_t>(offsetof(Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659, ___r_0)); }
inline float get_r_0() const { return ___r_0; }
inline float* get_address_of_r_0() { return &___r_0; }
inline void set_r_0(float value)
{
___r_0 = value;
}
inline static int32_t get_offset_of_g_1() { return static_cast<int32_t>(offsetof(Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659, ___g_1)); }
inline float get_g_1() const { return ___g_1; }
inline float* get_address_of_g_1() { return &___g_1; }
inline void set_g_1(float value)
{
___g_1 = value;
}
inline static int32_t get_offset_of_b_2() { return static_cast<int32_t>(offsetof(Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659, ___b_2)); }
inline float get_b_2() const { return ___b_2; }
inline float* get_address_of_b_2() { return &___b_2; }
inline void set_b_2(float value)
{
___b_2 = value;
}
inline static int32_t get_offset_of_a_3() { return static_cast<int32_t>(offsetof(Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659, ___a_3)); }
inline float get_a_3() const { return ___a_3; }
inline float* get_address_of_a_3() { return &___a_3; }
inline void set_a_3(float value)
{
___a_3 = value;
}
};
// UnityEngine.Color32
struct Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D
{
public:
union
{
#pragma pack(push, tp, 1)
struct
{
// System.Int32 UnityEngine.Color32::rgba
int32_t ___rgba_0;
};
#pragma pack(pop, tp)
struct
{
int32_t ___rgba_0_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
// System.Byte UnityEngine.Color32::r
uint8_t ___r_1;
};
#pragma pack(pop, tp)
struct
{
uint8_t ___r_1_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___g_2_OffsetPadding[1];
// System.Byte UnityEngine.Color32::g
uint8_t ___g_2;
};
#pragma pack(pop, tp)
struct
{
char ___g_2_OffsetPadding_forAlignmentOnly[1];
uint8_t ___g_2_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___b_3_OffsetPadding[2];
// System.Byte UnityEngine.Color32::b
uint8_t ___b_3;
};
#pragma pack(pop, tp)
struct
{
char ___b_3_OffsetPadding_forAlignmentOnly[2];
uint8_t ___b_3_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___a_4_OffsetPadding[3];
// System.Byte UnityEngine.Color32::a
uint8_t ___a_4;
};
#pragma pack(pop, tp)
struct
{
char ___a_4_OffsetPadding_forAlignmentOnly[3];
uint8_t ___a_4_forAlignmentOnly;
};
};
public:
inline static int32_t get_offset_of_rgba_0() { return static_cast<int32_t>(offsetof(Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D, ___rgba_0)); }
inline int32_t get_rgba_0() const { return ___rgba_0; }
inline int32_t* get_address_of_rgba_0() { return &___rgba_0; }
inline void set_rgba_0(int32_t value)
{
___rgba_0 = value;
}
inline static int32_t get_offset_of_r_1() { return static_cast<int32_t>(offsetof(Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D, ___r_1)); }
inline uint8_t get_r_1() const { return ___r_1; }
inline uint8_t* get_address_of_r_1() { return &___r_1; }
inline void set_r_1(uint8_t value)
{
___r_1 = value;
}
inline static int32_t get_offset_of_g_2() { return static_cast<int32_t>(offsetof(Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D, ___g_2)); }
inline uint8_t get_g_2() const { return ___g_2; }
inline uint8_t* get_address_of_g_2() { return &___g_2; }
inline void set_g_2(uint8_t value)
{
___g_2 = value;
}
inline static int32_t get_offset_of_b_3() { return static_cast<int32_t>(offsetof(Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D, ___b_3)); }
inline uint8_t get_b_3() const { return ___b_3; }
inline uint8_t* get_address_of_b_3() { return &___b_3; }
inline void set_b_3(uint8_t value)
{
___b_3 = value;
}
inline static int32_t get_offset_of_a_4() { return static_cast<int32_t>(offsetof(Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D, ___a_4)); }
inline uint8_t get_a_4() const { return ___a_4; }
inline uint8_t* get_address_of_a_4() { return &___a_4; }
inline void set_a_4(uint8_t value)
{
___a_4 = value;
}
};
// UnityEngine.CullingGroupEvent
struct CullingGroupEvent_t58E1718FD0A5FC5037538BD223DCF1385014185C
{
public:
// System.Int32 UnityEngine.CullingGroupEvent::m_Index
int32_t ___m_Index_0;
// System.Byte UnityEngine.CullingGroupEvent::m_PrevState
uint8_t ___m_PrevState_1;
// System.Byte UnityEngine.CullingGroupEvent::m_ThisState
uint8_t ___m_ThisState_2;
public:
inline static int32_t get_offset_of_m_Index_0() { return static_cast<int32_t>(offsetof(CullingGroupEvent_t58E1718FD0A5FC5037538BD223DCF1385014185C, ___m_Index_0)); }
inline int32_t get_m_Index_0() const { return ___m_Index_0; }
inline int32_t* get_address_of_m_Index_0() { return &___m_Index_0; }
inline void set_m_Index_0(int32_t value)
{
___m_Index_0 = value;
}
inline static int32_t get_offset_of_m_PrevState_1() { return static_cast<int32_t>(offsetof(CullingGroupEvent_t58E1718FD0A5FC5037538BD223DCF1385014185C, ___m_PrevState_1)); }
inline uint8_t get_m_PrevState_1() const { return ___m_PrevState_1; }
inline uint8_t* get_address_of_m_PrevState_1() { return &___m_PrevState_1; }
inline void set_m_PrevState_1(uint8_t value)
{
___m_PrevState_1 = value;
}
inline static int32_t get_offset_of_m_ThisState_2() { return static_cast<int32_t>(offsetof(CullingGroupEvent_t58E1718FD0A5FC5037538BD223DCF1385014185C, ___m_ThisState_2)); }
inline uint8_t get_m_ThisState_2() const { return ___m_ThisState_2; }
inline uint8_t* get_address_of_m_ThisState_2() { return &___m_ThisState_2; }
inline void set_m_ThisState_2(uint8_t value)
{
___m_ThisState_2 = value;
}
};
// System.Reflection.CustomAttributeTypedArgument
struct CustomAttributeTypedArgument_tE7152E8FACDD29A8E0040E151C86F436FA8E6910
{
public:
// System.Type System.Reflection.CustomAttributeTypedArgument::argumentType
Type_t * ___argumentType_0;
// System.Object System.Reflection.CustomAttributeTypedArgument::value
RuntimeObject * ___value_1;
public:
inline static int32_t get_offset_of_argumentType_0() { return static_cast<int32_t>(offsetof(CustomAttributeTypedArgument_tE7152E8FACDD29A8E0040E151C86F436FA8E6910, ___argumentType_0)); }
inline Type_t * get_argumentType_0() const { return ___argumentType_0; }
inline Type_t ** get_address_of_argumentType_0() { return &___argumentType_0; }
inline void set_argumentType_0(Type_t * value)
{
___argumentType_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___argumentType_0), (void*)value);
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(CustomAttributeTypedArgument_tE7152E8FACDD29A8E0040E151C86F436FA8E6910, ___value_1)); }
inline RuntimeObject * get_value_1() const { return ___value_1; }
inline RuntimeObject ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(RuntimeObject * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.Reflection.CustomAttributeTypedArgument
struct CustomAttributeTypedArgument_tE7152E8FACDD29A8E0040E151C86F436FA8E6910_marshaled_pinvoke
{
Type_t * ___argumentType_0;
Il2CppIUnknown* ___value_1;
};
// Native definition for COM marshalling of System.Reflection.CustomAttributeTypedArgument
struct CustomAttributeTypedArgument_tE7152E8FACDD29A8E0040E151C86F436FA8E6910_marshaled_com
{
Type_t * ___argumentType_0;
Il2CppIUnknown* ___value_1;
};
// System.DateTime
struct DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405
{
public:
// System.UInt64 System.DateTime::dateData
uint64_t ___dateData_44;
public:
inline static int32_t get_offset_of_dateData_44() { return static_cast<int32_t>(offsetof(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405, ___dateData_44)); }
inline uint64_t get_dateData_44() const { return ___dateData_44; }
inline uint64_t* get_address_of_dateData_44() { return &___dateData_44; }
inline void set_dateData_44(uint64_t value)
{
___dateData_44 = value;
}
};
struct DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405_StaticFields
{
public:
// System.Int32[] System.DateTime::DaysToMonth365
Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* ___DaysToMonth365_29;
// System.Int32[] System.DateTime::DaysToMonth366
Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* ___DaysToMonth366_30;
// System.DateTime System.DateTime::MinValue
DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 ___MinValue_31;
// System.DateTime System.DateTime::MaxValue
DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 ___MaxValue_32;
public:
inline static int32_t get_offset_of_DaysToMonth365_29() { return static_cast<int32_t>(offsetof(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405_StaticFields, ___DaysToMonth365_29)); }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* get_DaysToMonth365_29() const { return ___DaysToMonth365_29; }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32** get_address_of_DaysToMonth365_29() { return &___DaysToMonth365_29; }
inline void set_DaysToMonth365_29(Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* value)
{
___DaysToMonth365_29 = value;
Il2CppCodeGenWriteBarrier((void**)(&___DaysToMonth365_29), (void*)value);
}
inline static int32_t get_offset_of_DaysToMonth366_30() { return static_cast<int32_t>(offsetof(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405_StaticFields, ___DaysToMonth366_30)); }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* get_DaysToMonth366_30() const { return ___DaysToMonth366_30; }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32** get_address_of_DaysToMonth366_30() { return &___DaysToMonth366_30; }
inline void set_DaysToMonth366_30(Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* value)
{
___DaysToMonth366_30 = value;
Il2CppCodeGenWriteBarrier((void**)(&___DaysToMonth366_30), (void*)value);
}
inline static int32_t get_offset_of_MinValue_31() { return static_cast<int32_t>(offsetof(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405_StaticFields, ___MinValue_31)); }
inline DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 get_MinValue_31() const { return ___MinValue_31; }
inline DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 * get_address_of_MinValue_31() { return &___MinValue_31; }
inline void set_MinValue_31(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 value)
{
___MinValue_31 = value;
}
inline static int32_t get_offset_of_MaxValue_32() { return static_cast<int32_t>(offsetof(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405_StaticFields, ___MaxValue_32)); }
inline DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 get_MaxValue_32() const { return ___MaxValue_32; }
inline DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 * get_address_of_MaxValue_32() { return &___MaxValue_32; }
inline void set_MaxValue_32(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 value)
{
___MaxValue_32 = value;
}
};
// System.Decimal
struct Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7
{
public:
// System.Int32 System.Decimal::flags
int32_t ___flags_14;
// System.Int32 System.Decimal::hi
int32_t ___hi_15;
// System.Int32 System.Decimal::lo
int32_t ___lo_16;
// System.Int32 System.Decimal::mid
int32_t ___mid_17;
public:
inline static int32_t get_offset_of_flags_14() { return static_cast<int32_t>(offsetof(Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7, ___flags_14)); }
inline int32_t get_flags_14() const { return ___flags_14; }
inline int32_t* get_address_of_flags_14() { return &___flags_14; }
inline void set_flags_14(int32_t value)
{
___flags_14 = value;
}
inline static int32_t get_offset_of_hi_15() { return static_cast<int32_t>(offsetof(Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7, ___hi_15)); }
inline int32_t get_hi_15() const { return ___hi_15; }
inline int32_t* get_address_of_hi_15() { return &___hi_15; }
inline void set_hi_15(int32_t value)
{
___hi_15 = value;
}
inline static int32_t get_offset_of_lo_16() { return static_cast<int32_t>(offsetof(Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7, ___lo_16)); }
inline int32_t get_lo_16() const { return ___lo_16; }
inline int32_t* get_address_of_lo_16() { return &___lo_16; }
inline void set_lo_16(int32_t value)
{
___lo_16 = value;
}
inline static int32_t get_offset_of_mid_17() { return static_cast<int32_t>(offsetof(Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7, ___mid_17)); }
inline int32_t get_mid_17() const { return ___mid_17; }
inline int32_t* get_address_of_mid_17() { return &___mid_17; }
inline void set_mid_17(int32_t value)
{
___mid_17 = value;
}
};
struct Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7_StaticFields
{
public:
// System.UInt32[] System.Decimal::Powers10
UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF* ___Powers10_6;
// System.Decimal System.Decimal::Zero
Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 ___Zero_7;
// System.Decimal System.Decimal::One
Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 ___One_8;
// System.Decimal System.Decimal::MinusOne
Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 ___MinusOne_9;
// System.Decimal System.Decimal::MaxValue
Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 ___MaxValue_10;
// System.Decimal System.Decimal::MinValue
Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 ___MinValue_11;
// System.Decimal System.Decimal::NearNegativeZero
Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 ___NearNegativeZero_12;
// System.Decimal System.Decimal::NearPositiveZero
Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 ___NearPositiveZero_13;
public:
inline static int32_t get_offset_of_Powers10_6() { return static_cast<int32_t>(offsetof(Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7_StaticFields, ___Powers10_6)); }
inline UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF* get_Powers10_6() const { return ___Powers10_6; }
inline UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF** get_address_of_Powers10_6() { return &___Powers10_6; }
inline void set_Powers10_6(UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF* value)
{
___Powers10_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Powers10_6), (void*)value);
}
inline static int32_t get_offset_of_Zero_7() { return static_cast<int32_t>(offsetof(Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7_StaticFields, ___Zero_7)); }
inline Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 get_Zero_7() const { return ___Zero_7; }
inline Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 * get_address_of_Zero_7() { return &___Zero_7; }
inline void set_Zero_7(Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 value)
{
___Zero_7 = value;
}
inline static int32_t get_offset_of_One_8() { return static_cast<int32_t>(offsetof(Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7_StaticFields, ___One_8)); }
inline Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 get_One_8() const { return ___One_8; }
inline Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 * get_address_of_One_8() { return &___One_8; }
inline void set_One_8(Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 value)
{
___One_8 = value;
}
inline static int32_t get_offset_of_MinusOne_9() { return static_cast<int32_t>(offsetof(Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7_StaticFields, ___MinusOne_9)); }
inline Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 get_MinusOne_9() const { return ___MinusOne_9; }
inline Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 * get_address_of_MinusOne_9() { return &___MinusOne_9; }
inline void set_MinusOne_9(Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 value)
{
___MinusOne_9 = value;
}
inline static int32_t get_offset_of_MaxValue_10() { return static_cast<int32_t>(offsetof(Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7_StaticFields, ___MaxValue_10)); }
inline Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 get_MaxValue_10() const { return ___MaxValue_10; }
inline Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 * get_address_of_MaxValue_10() { return &___MaxValue_10; }
inline void set_MaxValue_10(Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 value)
{
___MaxValue_10 = value;
}
inline static int32_t get_offset_of_MinValue_11() { return static_cast<int32_t>(offsetof(Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7_StaticFields, ___MinValue_11)); }
inline Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 get_MinValue_11() const { return ___MinValue_11; }
inline Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 * get_address_of_MinValue_11() { return &___MinValue_11; }
inline void set_MinValue_11(Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 value)
{
___MinValue_11 = value;
}
inline static int32_t get_offset_of_NearNegativeZero_12() { return static_cast<int32_t>(offsetof(Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7_StaticFields, ___NearNegativeZero_12)); }
inline Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 get_NearNegativeZero_12() const { return ___NearNegativeZero_12; }
inline Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 * get_address_of_NearNegativeZero_12() { return &___NearNegativeZero_12; }
inline void set_NearNegativeZero_12(Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 value)
{
___NearNegativeZero_12 = value;
}
inline static int32_t get_offset_of_NearPositiveZero_13() { return static_cast<int32_t>(offsetof(Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7_StaticFields, ___NearPositiveZero_13)); }
inline Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 get_NearPositiveZero_13() const { return ___NearPositiveZero_13; }
inline Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 * get_address_of_NearPositiveZero_13() { return &___NearPositiveZero_13; }
inline void set_NearPositiveZero_13(Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 value)
{
___NearPositiveZero_13 = value;
}
};
// System.Collections.DictionaryEntry
struct DictionaryEntry_tF60471FAB430320A9C7D4382BF966EAAC06D7A90
{
public:
// System.Object System.Collections.DictionaryEntry::_key
RuntimeObject * ____key_0;
// System.Object System.Collections.DictionaryEntry::_value
RuntimeObject * ____value_1;
public:
inline static int32_t get_offset_of__key_0() { return static_cast<int32_t>(offsetof(DictionaryEntry_tF60471FAB430320A9C7D4382BF966EAAC06D7A90, ____key_0)); }
inline RuntimeObject * get__key_0() const { return ____key_0; }
inline RuntimeObject ** get_address_of__key_0() { return &____key_0; }
inline void set__key_0(RuntimeObject * value)
{
____key_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&____key_0), (void*)value);
}
inline static int32_t get_offset_of__value_1() { return static_cast<int32_t>(offsetof(DictionaryEntry_tF60471FAB430320A9C7D4382BF966EAAC06D7A90, ____value_1)); }
inline RuntimeObject * get__value_1() const { return ____value_1; }
inline RuntimeObject ** get_address_of__value_1() { return &____value_1; }
inline void set__value_1(RuntimeObject * value)
{
____value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&____value_1), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.Collections.DictionaryEntry
struct DictionaryEntry_tF60471FAB430320A9C7D4382BF966EAAC06D7A90_marshaled_pinvoke
{
Il2CppIUnknown* ____key_0;
Il2CppIUnknown* ____value_1;
};
// Native definition for COM marshalling of System.Collections.DictionaryEntry
struct DictionaryEntry_tF60471FAB430320A9C7D4382BF966EAAC06D7A90_marshaled_com
{
Il2CppIUnknown* ____key_0;
Il2CppIUnknown* ____value_1;
};
// System.Enum
struct Enum_t23B90B40F60E677A8025267341651C94AE079CDA : public ValueType_tDBF999C1B75C48C68621878250DBF6CDBCF51E52
{
public:
public:
};
struct Enum_t23B90B40F60E677A8025267341651C94AE079CDA_StaticFields
{
public:
// System.Char[] System.Enum::enumSeperatorCharArray
CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* ___enumSeperatorCharArray_0;
public:
inline static int32_t get_offset_of_enumSeperatorCharArray_0() { return static_cast<int32_t>(offsetof(Enum_t23B90B40F60E677A8025267341651C94AE079CDA_StaticFields, ___enumSeperatorCharArray_0)); }
inline CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* get_enumSeperatorCharArray_0() const { return ___enumSeperatorCharArray_0; }
inline CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34** get_address_of_enumSeperatorCharArray_0() { return &___enumSeperatorCharArray_0; }
inline void set_enumSeperatorCharArray_0(CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* value)
{
___enumSeperatorCharArray_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___enumSeperatorCharArray_0), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.Enum
struct Enum_t23B90B40F60E677A8025267341651C94AE079CDA_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.Enum
struct Enum_t23B90B40F60E677A8025267341651C94AE079CDA_marshaled_com
{
};
// UnityEngine.XR.InteractionSubsystems.GestureId
struct GestureId_tF3EFA115E02FC8A313B1019689130A09419B1EC7
{
public:
// System.UInt64 UnityEngine.XR.InteractionSubsystems.GestureId::m_SubId1
uint64_t ___m_SubId1_1;
// System.UInt64 UnityEngine.XR.InteractionSubsystems.GestureId::m_SubId2
uint64_t ___m_SubId2_2;
public:
inline static int32_t get_offset_of_m_SubId1_1() { return static_cast<int32_t>(offsetof(GestureId_tF3EFA115E02FC8A313B1019689130A09419B1EC7, ___m_SubId1_1)); }
inline uint64_t get_m_SubId1_1() const { return ___m_SubId1_1; }
inline uint64_t* get_address_of_m_SubId1_1() { return &___m_SubId1_1; }
inline void set_m_SubId1_1(uint64_t value)
{
___m_SubId1_1 = value;
}
inline static int32_t get_offset_of_m_SubId2_2() { return static_cast<int32_t>(offsetof(GestureId_tF3EFA115E02FC8A313B1019689130A09419B1EC7, ___m_SubId2_2)); }
inline uint64_t get_m_SubId2_2() const { return ___m_SubId2_2; }
inline uint64_t* get_address_of_m_SubId2_2() { return &___m_SubId2_2; }
inline void set_m_SubId2_2(uint64_t value)
{
___m_SubId2_2 = value;
}
};
struct GestureId_tF3EFA115E02FC8A313B1019689130A09419B1EC7_StaticFields
{
public:
// UnityEngine.XR.InteractionSubsystems.GestureId UnityEngine.XR.InteractionSubsystems.GestureId::s_InvalidId
GestureId_tF3EFA115E02FC8A313B1019689130A09419B1EC7 ___s_InvalidId_0;
public:
inline static int32_t get_offset_of_s_InvalidId_0() { return static_cast<int32_t>(offsetof(GestureId_tF3EFA115E02FC8A313B1019689130A09419B1EC7_StaticFields, ___s_InvalidId_0)); }
inline GestureId_tF3EFA115E02FC8A313B1019689130A09419B1EC7 get_s_InvalidId_0() const { return ___s_InvalidId_0; }
inline GestureId_tF3EFA115E02FC8A313B1019689130A09419B1EC7 * get_address_of_s_InvalidId_0() { return &___s_InvalidId_0; }
inline void set_s_InvalidId_0(GestureId_tF3EFA115E02FC8A313B1019689130A09419B1EC7 value)
{
___s_InvalidId_0 = value;
}
};
// UnityEngine.TextCore.GlyphRect
struct GlyphRect_t4F6A791326A28C2CEC6B13B0BD50A4F78280289D
{
public:
// System.Int32 UnityEngine.TextCore.GlyphRect::m_X
int32_t ___m_X_0;
// System.Int32 UnityEngine.TextCore.GlyphRect::m_Y
int32_t ___m_Y_1;
// System.Int32 UnityEngine.TextCore.GlyphRect::m_Width
int32_t ___m_Width_2;
// System.Int32 UnityEngine.TextCore.GlyphRect::m_Height
int32_t ___m_Height_3;
public:
inline static int32_t get_offset_of_m_X_0() { return static_cast<int32_t>(offsetof(GlyphRect_t4F6A791326A28C2CEC6B13B0BD50A4F78280289D, ___m_X_0)); }
inline int32_t get_m_X_0() const { return ___m_X_0; }
inline int32_t* get_address_of_m_X_0() { return &___m_X_0; }
inline void set_m_X_0(int32_t value)
{
___m_X_0 = value;
}
inline static int32_t get_offset_of_m_Y_1() { return static_cast<int32_t>(offsetof(GlyphRect_t4F6A791326A28C2CEC6B13B0BD50A4F78280289D, ___m_Y_1)); }
inline int32_t get_m_Y_1() const { return ___m_Y_1; }
inline int32_t* get_address_of_m_Y_1() { return &___m_Y_1; }
inline void set_m_Y_1(int32_t value)
{
___m_Y_1 = value;
}
inline static int32_t get_offset_of_m_Width_2() { return static_cast<int32_t>(offsetof(GlyphRect_t4F6A791326A28C2CEC6B13B0BD50A4F78280289D, ___m_Width_2)); }
inline int32_t get_m_Width_2() const { return ___m_Width_2; }
inline int32_t* get_address_of_m_Width_2() { return &___m_Width_2; }
inline void set_m_Width_2(int32_t value)
{
___m_Width_2 = value;
}
inline static int32_t get_offset_of_m_Height_3() { return static_cast<int32_t>(offsetof(GlyphRect_t4F6A791326A28C2CEC6B13B0BD50A4F78280289D, ___m_Height_3)); }
inline int32_t get_m_Height_3() const { return ___m_Height_3; }
inline int32_t* get_address_of_m_Height_3() { return &___m_Height_3; }
inline void set_m_Height_3(int32_t value)
{
___m_Height_3 = value;
}
};
struct GlyphRect_t4F6A791326A28C2CEC6B13B0BD50A4F78280289D_StaticFields
{
public:
// UnityEngine.TextCore.GlyphRect UnityEngine.TextCore.GlyphRect::s_ZeroGlyphRect
GlyphRect_t4F6A791326A28C2CEC6B13B0BD50A4F78280289D ___s_ZeroGlyphRect_4;
public:
inline static int32_t get_offset_of_s_ZeroGlyphRect_4() { return static_cast<int32_t>(offsetof(GlyphRect_t4F6A791326A28C2CEC6B13B0BD50A4F78280289D_StaticFields, ___s_ZeroGlyphRect_4)); }
inline GlyphRect_t4F6A791326A28C2CEC6B13B0BD50A4F78280289D get_s_ZeroGlyphRect_4() const { return ___s_ZeroGlyphRect_4; }
inline GlyphRect_t4F6A791326A28C2CEC6B13B0BD50A4F78280289D * get_address_of_s_ZeroGlyphRect_4() { return &___s_ZeroGlyphRect_4; }
inline void set_s_ZeroGlyphRect_4(GlyphRect_t4F6A791326A28C2CEC6B13B0BD50A4F78280289D value)
{
___s_ZeroGlyphRect_4 = value;
}
};
// System.Guid
struct Guid_t
{
public:
// System.Int32 System.Guid::_a
int32_t ____a_1;
// System.Int16 System.Guid::_b
int16_t ____b_2;
// System.Int16 System.Guid::_c
int16_t ____c_3;
// System.Byte System.Guid::_d
uint8_t ____d_4;
// System.Byte System.Guid::_e
uint8_t ____e_5;
// System.Byte System.Guid::_f
uint8_t ____f_6;
// System.Byte System.Guid::_g
uint8_t ____g_7;
// System.Byte System.Guid::_h
uint8_t ____h_8;
// System.Byte System.Guid::_i
uint8_t ____i_9;
// System.Byte System.Guid::_j
uint8_t ____j_10;
// System.Byte System.Guid::_k
uint8_t ____k_11;
public:
inline static int32_t get_offset_of__a_1() { return static_cast<int32_t>(offsetof(Guid_t, ____a_1)); }
inline int32_t get__a_1() const { return ____a_1; }
inline int32_t* get_address_of__a_1() { return &____a_1; }
inline void set__a_1(int32_t value)
{
____a_1 = value;
}
inline static int32_t get_offset_of__b_2() { return static_cast<int32_t>(offsetof(Guid_t, ____b_2)); }
inline int16_t get__b_2() const { return ____b_2; }
inline int16_t* get_address_of__b_2() { return &____b_2; }
inline void set__b_2(int16_t value)
{
____b_2 = value;
}
inline static int32_t get_offset_of__c_3() { return static_cast<int32_t>(offsetof(Guid_t, ____c_3)); }
inline int16_t get__c_3() const { return ____c_3; }
inline int16_t* get_address_of__c_3() { return &____c_3; }
inline void set__c_3(int16_t value)
{
____c_3 = value;
}
inline static int32_t get_offset_of__d_4() { return static_cast<int32_t>(offsetof(Guid_t, ____d_4)); }
inline uint8_t get__d_4() const { return ____d_4; }
inline uint8_t* get_address_of__d_4() { return &____d_4; }
inline void set__d_4(uint8_t value)
{
____d_4 = value;
}
inline static int32_t get_offset_of__e_5() { return static_cast<int32_t>(offsetof(Guid_t, ____e_5)); }
inline uint8_t get__e_5() const { return ____e_5; }
inline uint8_t* get_address_of__e_5() { return &____e_5; }
inline void set__e_5(uint8_t value)
{
____e_5 = value;
}
inline static int32_t get_offset_of__f_6() { return static_cast<int32_t>(offsetof(Guid_t, ____f_6)); }
inline uint8_t get__f_6() const { return ____f_6; }
inline uint8_t* get_address_of__f_6() { return &____f_6; }
inline void set__f_6(uint8_t value)
{
____f_6 = value;
}
inline static int32_t get_offset_of__g_7() { return static_cast<int32_t>(offsetof(Guid_t, ____g_7)); }
inline uint8_t get__g_7() const { return ____g_7; }
inline uint8_t* get_address_of__g_7() { return &____g_7; }
inline void set__g_7(uint8_t value)
{
____g_7 = value;
}
inline static int32_t get_offset_of__h_8() { return static_cast<int32_t>(offsetof(Guid_t, ____h_8)); }
inline uint8_t get__h_8() const { return ____h_8; }
inline uint8_t* get_address_of__h_8() { return &____h_8; }
inline void set__h_8(uint8_t value)
{
____h_8 = value;
}
inline static int32_t get_offset_of__i_9() { return static_cast<int32_t>(offsetof(Guid_t, ____i_9)); }
inline uint8_t get__i_9() const { return ____i_9; }
inline uint8_t* get_address_of__i_9() { return &____i_9; }
inline void set__i_9(uint8_t value)
{
____i_9 = value;
}
inline static int32_t get_offset_of__j_10() { return static_cast<int32_t>(offsetof(Guid_t, ____j_10)); }
inline uint8_t get__j_10() const { return ____j_10; }
inline uint8_t* get_address_of__j_10() { return &____j_10; }
inline void set__j_10(uint8_t value)
{
____j_10 = value;
}
inline static int32_t get_offset_of__k_11() { return static_cast<int32_t>(offsetof(Guid_t, ____k_11)); }
inline uint8_t get__k_11() const { return ____k_11; }
inline uint8_t* get_address_of__k_11() { return &____k_11; }
inline void set__k_11(uint8_t value)
{
____k_11 = value;
}
};
struct Guid_t_StaticFields
{
public:
// System.Guid System.Guid::Empty
Guid_t ___Empty_0;
// System.Object System.Guid::_rngAccess
RuntimeObject * ____rngAccess_12;
// System.Security.Cryptography.RandomNumberGenerator System.Guid::_rng
RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50 * ____rng_13;
// System.Security.Cryptography.RandomNumberGenerator System.Guid::_fastRng
RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50 * ____fastRng_14;
public:
inline static int32_t get_offset_of_Empty_0() { return static_cast<int32_t>(offsetof(Guid_t_StaticFields, ___Empty_0)); }
inline Guid_t get_Empty_0() const { return ___Empty_0; }
inline Guid_t * get_address_of_Empty_0() { return &___Empty_0; }
inline void set_Empty_0(Guid_t value)
{
___Empty_0 = value;
}
inline static int32_t get_offset_of__rngAccess_12() { return static_cast<int32_t>(offsetof(Guid_t_StaticFields, ____rngAccess_12)); }
inline RuntimeObject * get__rngAccess_12() const { return ____rngAccess_12; }
inline RuntimeObject ** get_address_of__rngAccess_12() { return &____rngAccess_12; }
inline void set__rngAccess_12(RuntimeObject * value)
{
____rngAccess_12 = value;
Il2CppCodeGenWriteBarrier((void**)(&____rngAccess_12), (void*)value);
}
inline static int32_t get_offset_of__rng_13() { return static_cast<int32_t>(offsetof(Guid_t_StaticFields, ____rng_13)); }
inline RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50 * get__rng_13() const { return ____rng_13; }
inline RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50 ** get_address_of__rng_13() { return &____rng_13; }
inline void set__rng_13(RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50 * value)
{
____rng_13 = value;
Il2CppCodeGenWriteBarrier((void**)(&____rng_13), (void*)value);
}
inline static int32_t get_offset_of__fastRng_14() { return static_cast<int32_t>(offsetof(Guid_t_StaticFields, ____fastRng_14)); }
inline RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50 * get__fastRng_14() const { return ____fastRng_14; }
inline RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50 ** get_address_of__fastRng_14() { return &____fastRng_14; }
inline void set__fastRng_14(RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50 * value)
{
____fastRng_14 = value;
Il2CppCodeGenWriteBarrier((void**)(&____fastRng_14), (void*)value);
}
};
// UnityEngine.XR.InputDevice
struct InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E
{
public:
// System.UInt64 UnityEngine.XR.InputDevice::m_DeviceId
uint64_t ___m_DeviceId_0;
// System.Boolean UnityEngine.XR.InputDevice::m_Initialized
bool ___m_Initialized_1;
public:
inline static int32_t get_offset_of_m_DeviceId_0() { return static_cast<int32_t>(offsetof(InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E, ___m_DeviceId_0)); }
inline uint64_t get_m_DeviceId_0() const { return ___m_DeviceId_0; }
inline uint64_t* get_address_of_m_DeviceId_0() { return &___m_DeviceId_0; }
inline void set_m_DeviceId_0(uint64_t value)
{
___m_DeviceId_0 = value;
}
inline static int32_t get_offset_of_m_Initialized_1() { return static_cast<int32_t>(offsetof(InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E, ___m_Initialized_1)); }
inline bool get_m_Initialized_1() const { return ___m_Initialized_1; }
inline bool* get_address_of_m_Initialized_1() { return &___m_Initialized_1; }
inline void set_m_Initialized_1(bool value)
{
___m_Initialized_1 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.InputDevice
struct InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E_marshaled_pinvoke
{
uint64_t ___m_DeviceId_0;
int32_t ___m_Initialized_1;
};
// Native definition for COM marshalling of UnityEngine.XR.InputDevice
struct InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E_marshaled_com
{
uint64_t ___m_DeviceId_0;
int32_t ___m_Initialized_1;
};
// System.IntPtr
struct IntPtr_t
{
public:
// System.Void* System.IntPtr::m_value
void* ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(IntPtr_t, ___m_value_0)); }
inline void* get_m_value_0() const { return ___m_value_0; }
inline void** get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(void* value)
{
___m_value_0 = value;
}
};
struct IntPtr_t_StaticFields
{
public:
// System.IntPtr System.IntPtr::Zero
intptr_t ___Zero_1;
public:
inline static int32_t get_offset_of_Zero_1() { return static_cast<int32_t>(offsetof(IntPtr_t_StaticFields, ___Zero_1)); }
inline intptr_t get_Zero_1() const { return ___Zero_1; }
inline intptr_t* get_address_of_Zero_1() { return &___Zero_1; }
inline void set_Zero_1(intptr_t value)
{
___Zero_1 = value;
}
};
// UnityEngine.Matrix4x4
struct Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461
{
public:
// System.Single UnityEngine.Matrix4x4::m00
float ___m00_0;
// System.Single UnityEngine.Matrix4x4::m10
float ___m10_1;
// System.Single UnityEngine.Matrix4x4::m20
float ___m20_2;
// System.Single UnityEngine.Matrix4x4::m30
float ___m30_3;
// System.Single UnityEngine.Matrix4x4::m01
float ___m01_4;
// System.Single UnityEngine.Matrix4x4::m11
float ___m11_5;
// System.Single UnityEngine.Matrix4x4::m21
float ___m21_6;
// System.Single UnityEngine.Matrix4x4::m31
float ___m31_7;
// System.Single UnityEngine.Matrix4x4::m02
float ___m02_8;
// System.Single UnityEngine.Matrix4x4::m12
float ___m12_9;
// System.Single UnityEngine.Matrix4x4::m22
float ___m22_10;
// System.Single UnityEngine.Matrix4x4::m32
float ___m32_11;
// System.Single UnityEngine.Matrix4x4::m03
float ___m03_12;
// System.Single UnityEngine.Matrix4x4::m13
float ___m13_13;
// System.Single UnityEngine.Matrix4x4::m23
float ___m23_14;
// System.Single UnityEngine.Matrix4x4::m33
float ___m33_15;
public:
inline static int32_t get_offset_of_m00_0() { return static_cast<int32_t>(offsetof(Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461, ___m00_0)); }
inline float get_m00_0() const { return ___m00_0; }
inline float* get_address_of_m00_0() { return &___m00_0; }
inline void set_m00_0(float value)
{
___m00_0 = value;
}
inline static int32_t get_offset_of_m10_1() { return static_cast<int32_t>(offsetof(Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461, ___m10_1)); }
inline float get_m10_1() const { return ___m10_1; }
inline float* get_address_of_m10_1() { return &___m10_1; }
inline void set_m10_1(float value)
{
___m10_1 = value;
}
inline static int32_t get_offset_of_m20_2() { return static_cast<int32_t>(offsetof(Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461, ___m20_2)); }
inline float get_m20_2() const { return ___m20_2; }
inline float* get_address_of_m20_2() { return &___m20_2; }
inline void set_m20_2(float value)
{
___m20_2 = value;
}
inline static int32_t get_offset_of_m30_3() { return static_cast<int32_t>(offsetof(Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461, ___m30_3)); }
inline float get_m30_3() const { return ___m30_3; }
inline float* get_address_of_m30_3() { return &___m30_3; }
inline void set_m30_3(float value)
{
___m30_3 = value;
}
inline static int32_t get_offset_of_m01_4() { return static_cast<int32_t>(offsetof(Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461, ___m01_4)); }
inline float get_m01_4() const { return ___m01_4; }
inline float* get_address_of_m01_4() { return &___m01_4; }
inline void set_m01_4(float value)
{
___m01_4 = value;
}
inline static int32_t get_offset_of_m11_5() { return static_cast<int32_t>(offsetof(Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461, ___m11_5)); }
inline float get_m11_5() const { return ___m11_5; }
inline float* get_address_of_m11_5() { return &___m11_5; }
inline void set_m11_5(float value)
{
___m11_5 = value;
}
inline static int32_t get_offset_of_m21_6() { return static_cast<int32_t>(offsetof(Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461, ___m21_6)); }
inline float get_m21_6() const { return ___m21_6; }
inline float* get_address_of_m21_6() { return &___m21_6; }
inline void set_m21_6(float value)
{
___m21_6 = value;
}
inline static int32_t get_offset_of_m31_7() { return static_cast<int32_t>(offsetof(Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461, ___m31_7)); }
inline float get_m31_7() const { return ___m31_7; }
inline float* get_address_of_m31_7() { return &___m31_7; }
inline void set_m31_7(float value)
{
___m31_7 = value;
}
inline static int32_t get_offset_of_m02_8() { return static_cast<int32_t>(offsetof(Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461, ___m02_8)); }
inline float get_m02_8() const { return ___m02_8; }
inline float* get_address_of_m02_8() { return &___m02_8; }
inline void set_m02_8(float value)
{
___m02_8 = value;
}
inline static int32_t get_offset_of_m12_9() { return static_cast<int32_t>(offsetof(Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461, ___m12_9)); }
inline float get_m12_9() const { return ___m12_9; }
inline float* get_address_of_m12_9() { return &___m12_9; }
inline void set_m12_9(float value)
{
___m12_9 = value;
}
inline static int32_t get_offset_of_m22_10() { return static_cast<int32_t>(offsetof(Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461, ___m22_10)); }
inline float get_m22_10() const { return ___m22_10; }
inline float* get_address_of_m22_10() { return &___m22_10; }
inline void set_m22_10(float value)
{
___m22_10 = value;
}
inline static int32_t get_offset_of_m32_11() { return static_cast<int32_t>(offsetof(Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461, ___m32_11)); }
inline float get_m32_11() const { return ___m32_11; }
inline float* get_address_of_m32_11() { return &___m32_11; }
inline void set_m32_11(float value)
{
___m32_11 = value;
}
inline static int32_t get_offset_of_m03_12() { return static_cast<int32_t>(offsetof(Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461, ___m03_12)); }
inline float get_m03_12() const { return ___m03_12; }
inline float* get_address_of_m03_12() { return &___m03_12; }
inline void set_m03_12(float value)
{
___m03_12 = value;
}
inline static int32_t get_offset_of_m13_13() { return static_cast<int32_t>(offsetof(Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461, ___m13_13)); }
inline float get_m13_13() const { return ___m13_13; }
inline float* get_address_of_m13_13() { return &___m13_13; }
inline void set_m13_13(float value)
{
___m13_13 = value;
}
inline static int32_t get_offset_of_m23_14() { return static_cast<int32_t>(offsetof(Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461, ___m23_14)); }
inline float get_m23_14() const { return ___m23_14; }
inline float* get_address_of_m23_14() { return &___m23_14; }
inline void set_m23_14(float value)
{
___m23_14 = value;
}
inline static int32_t get_offset_of_m33_15() { return static_cast<int32_t>(offsetof(Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461, ___m33_15)); }
inline float get_m33_15() const { return ___m33_15; }
inline float* get_address_of_m33_15() { return &___m33_15; }
inline void set_m33_15(float value)
{
___m33_15 = value;
}
};
struct Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461_StaticFields
{
public:
// UnityEngine.Matrix4x4 UnityEngine.Matrix4x4::zeroMatrix
Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461 ___zeroMatrix_16;
// UnityEngine.Matrix4x4 UnityEngine.Matrix4x4::identityMatrix
Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461 ___identityMatrix_17;
public:
inline static int32_t get_offset_of_zeroMatrix_16() { return static_cast<int32_t>(offsetof(Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461_StaticFields, ___zeroMatrix_16)); }
inline Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461 get_zeroMatrix_16() const { return ___zeroMatrix_16; }
inline Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461 * get_address_of_zeroMatrix_16() { return &___zeroMatrix_16; }
inline void set_zeroMatrix_16(Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461 value)
{
___zeroMatrix_16 = value;
}
inline static int32_t get_offset_of_identityMatrix_17() { return static_cast<int32_t>(offsetof(Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461_StaticFields, ___identityMatrix_17)); }
inline Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461 get_identityMatrix_17() const { return ___identityMatrix_17; }
inline Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461 * get_address_of_identityMatrix_17() { return &___identityMatrix_17; }
inline void set_identityMatrix_17(Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461 value)
{
___identityMatrix_17 = value;
}
};
// UnityEngine.XR.MeshId
struct MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767
{
public:
// System.UInt64 UnityEngine.XR.MeshId::m_SubId1
uint64_t ___m_SubId1_1;
// System.UInt64 UnityEngine.XR.MeshId::m_SubId2
uint64_t ___m_SubId2_2;
public:
inline static int32_t get_offset_of_m_SubId1_1() { return static_cast<int32_t>(offsetof(MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767, ___m_SubId1_1)); }
inline uint64_t get_m_SubId1_1() const { return ___m_SubId1_1; }
inline uint64_t* get_address_of_m_SubId1_1() { return &___m_SubId1_1; }
inline void set_m_SubId1_1(uint64_t value)
{
___m_SubId1_1 = value;
}
inline static int32_t get_offset_of_m_SubId2_2() { return static_cast<int32_t>(offsetof(MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767, ___m_SubId2_2)); }
inline uint64_t get_m_SubId2_2() const { return ___m_SubId2_2; }
inline uint64_t* get_address_of_m_SubId2_2() { return &___m_SubId2_2; }
inline void set_m_SubId2_2(uint64_t value)
{
___m_SubId2_2 = value;
}
};
struct MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767_StaticFields
{
public:
// UnityEngine.XR.MeshId UnityEngine.XR.MeshId::s_InvalidId
MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 ___s_InvalidId_0;
public:
inline static int32_t get_offset_of_s_InvalidId_0() { return static_cast<int32_t>(offsetof(MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767_StaticFields, ___s_InvalidId_0)); }
inline MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 get_s_InvalidId_0() const { return ___s_InvalidId_0; }
inline MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 * get_address_of_s_InvalidId_0() { return &___s_InvalidId_0; }
inline void set_s_InvalidId_0(MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 value)
{
___s_InvalidId_0 = value;
}
};
// Microsoft.MixedReality.Toolkit.Utilities.ProcessResult
struct ProcessResult_tCDC0BFAF5E3ED595F750AA1D99F9864CCB168523
{
public:
// System.Int32 Microsoft.MixedReality.Toolkit.Utilities.ProcessResult::<ExitCode>k__BackingField
int32_t ___U3CExitCodeU3Ek__BackingField_0;
// System.String[] Microsoft.MixedReality.Toolkit.Utilities.ProcessResult::<Errors>k__BackingField
StringU5BU5D_tACEBFEDE350025B554CD507C9AE8FFE49359549A* ___U3CErrorsU3Ek__BackingField_1;
// System.String[] Microsoft.MixedReality.Toolkit.Utilities.ProcessResult::<Output>k__BackingField
StringU5BU5D_tACEBFEDE350025B554CD507C9AE8FFE49359549A* ___U3COutputU3Ek__BackingField_2;
public:
inline static int32_t get_offset_of_U3CExitCodeU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(ProcessResult_tCDC0BFAF5E3ED595F750AA1D99F9864CCB168523, ___U3CExitCodeU3Ek__BackingField_0)); }
inline int32_t get_U3CExitCodeU3Ek__BackingField_0() const { return ___U3CExitCodeU3Ek__BackingField_0; }
inline int32_t* get_address_of_U3CExitCodeU3Ek__BackingField_0() { return &___U3CExitCodeU3Ek__BackingField_0; }
inline void set_U3CExitCodeU3Ek__BackingField_0(int32_t value)
{
___U3CExitCodeU3Ek__BackingField_0 = value;
}
inline static int32_t get_offset_of_U3CErrorsU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(ProcessResult_tCDC0BFAF5E3ED595F750AA1D99F9864CCB168523, ___U3CErrorsU3Ek__BackingField_1)); }
inline StringU5BU5D_tACEBFEDE350025B554CD507C9AE8FFE49359549A* get_U3CErrorsU3Ek__BackingField_1() const { return ___U3CErrorsU3Ek__BackingField_1; }
inline StringU5BU5D_tACEBFEDE350025B554CD507C9AE8FFE49359549A** get_address_of_U3CErrorsU3Ek__BackingField_1() { return &___U3CErrorsU3Ek__BackingField_1; }
inline void set_U3CErrorsU3Ek__BackingField_1(StringU5BU5D_tACEBFEDE350025B554CD507C9AE8FFE49359549A* value)
{
___U3CErrorsU3Ek__BackingField_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CErrorsU3Ek__BackingField_1), (void*)value);
}
inline static int32_t get_offset_of_U3COutputU3Ek__BackingField_2() { return static_cast<int32_t>(offsetof(ProcessResult_tCDC0BFAF5E3ED595F750AA1D99F9864CCB168523, ___U3COutputU3Ek__BackingField_2)); }
inline StringU5BU5D_tACEBFEDE350025B554CD507C9AE8FFE49359549A* get_U3COutputU3Ek__BackingField_2() const { return ___U3COutputU3Ek__BackingField_2; }
inline StringU5BU5D_tACEBFEDE350025B554CD507C9AE8FFE49359549A** get_address_of_U3COutputU3Ek__BackingField_2() { return &___U3COutputU3Ek__BackingField_2; }
inline void set_U3COutputU3Ek__BackingField_2(StringU5BU5D_tACEBFEDE350025B554CD507C9AE8FFE49359549A* value)
{
___U3COutputU3Ek__BackingField_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3COutputU3Ek__BackingField_2), (void*)value);
}
};
// Native definition for P/Invoke marshalling of Microsoft.MixedReality.Toolkit.Utilities.ProcessResult
struct ProcessResult_tCDC0BFAF5E3ED595F750AA1D99F9864CCB168523_marshaled_pinvoke
{
int32_t ___U3CExitCodeU3Ek__BackingField_0;
char** ___U3CErrorsU3Ek__BackingField_1;
char** ___U3COutputU3Ek__BackingField_2;
};
// Native definition for COM marshalling of Microsoft.MixedReality.Toolkit.Utilities.ProcessResult
struct ProcessResult_tCDC0BFAF5E3ED595F750AA1D99F9864CCB168523_marshaled_com
{
int32_t ___U3CExitCodeU3Ek__BackingField_0;
Il2CppChar** ___U3CErrorsU3Ek__BackingField_1;
Il2CppChar** ___U3COutputU3Ek__BackingField_2;
};
// UnityEngine.Quaternion
struct Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4
{
public:
// System.Single UnityEngine.Quaternion::x
float ___x_0;
// System.Single UnityEngine.Quaternion::y
float ___y_1;
// System.Single UnityEngine.Quaternion::z
float ___z_2;
// System.Single UnityEngine.Quaternion::w
float ___w_3;
public:
inline static int32_t get_offset_of_x_0() { return static_cast<int32_t>(offsetof(Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4, ___x_0)); }
inline float get_x_0() const { return ___x_0; }
inline float* get_address_of_x_0() { return &___x_0; }
inline void set_x_0(float value)
{
___x_0 = value;
}
inline static int32_t get_offset_of_y_1() { return static_cast<int32_t>(offsetof(Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4, ___y_1)); }
inline float get_y_1() const { return ___y_1; }
inline float* get_address_of_y_1() { return &___y_1; }
inline void set_y_1(float value)
{
___y_1 = value;
}
inline static int32_t get_offset_of_z_2() { return static_cast<int32_t>(offsetof(Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4, ___z_2)); }
inline float get_z_2() const { return ___z_2; }
inline float* get_address_of_z_2() { return &___z_2; }
inline void set_z_2(float value)
{
___z_2 = value;
}
inline static int32_t get_offset_of_w_3() { return static_cast<int32_t>(offsetof(Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4, ___w_3)); }
inline float get_w_3() const { return ___w_3; }
inline float* get_address_of_w_3() { return &___w_3; }
inline void set_w_3(float value)
{
___w_3 = value;
}
};
struct Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4_StaticFields
{
public:
// UnityEngine.Quaternion UnityEngine.Quaternion::identityQuaternion
Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___identityQuaternion_4;
public:
inline static int32_t get_offset_of_identityQuaternion_4() { return static_cast<int32_t>(offsetof(Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4_StaticFields, ___identityQuaternion_4)); }
inline Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 get_identityQuaternion_4() const { return ___identityQuaternion_4; }
inline Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 * get_address_of_identityQuaternion_4() { return &___identityQuaternion_4; }
inline void set_identityQuaternion_4(Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 value)
{
___identityQuaternion_4 = value;
}
};
// UnityEngine.Rect
struct Rect_t7D9187DB6339DBA5741C09B6CCEF2F54F1966878
{
public:
// System.Single UnityEngine.Rect::m_XMin
float ___m_XMin_0;
// System.Single UnityEngine.Rect::m_YMin
float ___m_YMin_1;
// System.Single UnityEngine.Rect::m_Width
float ___m_Width_2;
// System.Single UnityEngine.Rect::m_Height
float ___m_Height_3;
public:
inline static int32_t get_offset_of_m_XMin_0() { return static_cast<int32_t>(offsetof(Rect_t7D9187DB6339DBA5741C09B6CCEF2F54F1966878, ___m_XMin_0)); }
inline float get_m_XMin_0() const { return ___m_XMin_0; }
inline float* get_address_of_m_XMin_0() { return &___m_XMin_0; }
inline void set_m_XMin_0(float value)
{
___m_XMin_0 = value;
}
inline static int32_t get_offset_of_m_YMin_1() { return static_cast<int32_t>(offsetof(Rect_t7D9187DB6339DBA5741C09B6CCEF2F54F1966878, ___m_YMin_1)); }
inline float get_m_YMin_1() const { return ___m_YMin_1; }
inline float* get_address_of_m_YMin_1() { return &___m_YMin_1; }
inline void set_m_YMin_1(float value)
{
___m_YMin_1 = value;
}
inline static int32_t get_offset_of_m_Width_2() { return static_cast<int32_t>(offsetof(Rect_t7D9187DB6339DBA5741C09B6CCEF2F54F1966878, ___m_Width_2)); }
inline float get_m_Width_2() const { return ___m_Width_2; }
inline float* get_address_of_m_Width_2() { return &___m_Width_2; }
inline void set_m_Width_2(float value)
{
___m_Width_2 = value;
}
inline static int32_t get_offset_of_m_Height_3() { return static_cast<int32_t>(offsetof(Rect_t7D9187DB6339DBA5741C09B6CCEF2F54F1966878, ___m_Height_3)); }
inline float get_m_Height_3() const { return ___m_Height_3; }
inline float* get_address_of_m_Height_3() { return &___m_Height_3; }
inline void set_m_Height_3(float value)
{
___m_Height_3 = value;
}
};
// UnityEngine.RectInt
struct RectInt_tE7B8105A280C1AC73A4157ED41F9B86C9BD91E49
{
public:
// System.Int32 UnityEngine.RectInt::m_XMin
int32_t ___m_XMin_0;
// System.Int32 UnityEngine.RectInt::m_YMin
int32_t ___m_YMin_1;
// System.Int32 UnityEngine.RectInt::m_Width
int32_t ___m_Width_2;
// System.Int32 UnityEngine.RectInt::m_Height
int32_t ___m_Height_3;
public:
inline static int32_t get_offset_of_m_XMin_0() { return static_cast<int32_t>(offsetof(RectInt_tE7B8105A280C1AC73A4157ED41F9B86C9BD91E49, ___m_XMin_0)); }
inline int32_t get_m_XMin_0() const { return ___m_XMin_0; }
inline int32_t* get_address_of_m_XMin_0() { return &___m_XMin_0; }
inline void set_m_XMin_0(int32_t value)
{
___m_XMin_0 = value;
}
inline static int32_t get_offset_of_m_YMin_1() { return static_cast<int32_t>(offsetof(RectInt_tE7B8105A280C1AC73A4157ED41F9B86C9BD91E49, ___m_YMin_1)); }
inline int32_t get_m_YMin_1() const { return ___m_YMin_1; }
inline int32_t* get_address_of_m_YMin_1() { return &___m_YMin_1; }
inline void set_m_YMin_1(int32_t value)
{
___m_YMin_1 = value;
}
inline static int32_t get_offset_of_m_Width_2() { return static_cast<int32_t>(offsetof(RectInt_tE7B8105A280C1AC73A4157ED41F9B86C9BD91E49, ___m_Width_2)); }
inline int32_t get_m_Width_2() const { return ___m_Width_2; }
inline int32_t* get_address_of_m_Width_2() { return &___m_Width_2; }
inline void set_m_Width_2(int32_t value)
{
___m_Width_2 = value;
}
inline static int32_t get_offset_of_m_Height_3() { return static_cast<int32_t>(offsetof(RectInt_tE7B8105A280C1AC73A4157ED41F9B86C9BD91E49, ___m_Height_3)); }
inline int32_t get_m_Height_3() const { return ___m_Height_3; }
inline int32_t* get_address_of_m_Height_3() { return &___m_Height_3; }
inline void set_m_Height_3(int32_t value)
{
___m_Height_3 = value;
}
};
// System.Resources.ResourceLocator
struct ResourceLocator_t3D496606F94367D5D6B24DA9DC0A3B46E6B53B11
{
public:
// System.Object System.Resources.ResourceLocator::_value
RuntimeObject * ____value_0;
// System.Int32 System.Resources.ResourceLocator::_dataPos
int32_t ____dataPos_1;
public:
inline static int32_t get_offset_of__value_0() { return static_cast<int32_t>(offsetof(ResourceLocator_t3D496606F94367D5D6B24DA9DC0A3B46E6B53B11, ____value_0)); }
inline RuntimeObject * get__value_0() const { return ____value_0; }
inline RuntimeObject ** get_address_of__value_0() { return &____value_0; }
inline void set__value_0(RuntimeObject * value)
{
____value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&____value_0), (void*)value);
}
inline static int32_t get_offset_of__dataPos_1() { return static_cast<int32_t>(offsetof(ResourceLocator_t3D496606F94367D5D6B24DA9DC0A3B46E6B53B11, ____dataPos_1)); }
inline int32_t get__dataPos_1() const { return ____dataPos_1; }
inline int32_t* get_address_of__dataPos_1() { return &____dataPos_1; }
inline void set__dataPos_1(int32_t value)
{
____dataPos_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Resources.ResourceLocator
struct ResourceLocator_t3D496606F94367D5D6B24DA9DC0A3B46E6B53B11_marshaled_pinvoke
{
Il2CppIUnknown* ____value_0;
int32_t ____dataPos_1;
};
// Native definition for COM marshalling of System.Resources.ResourceLocator
struct ResourceLocator_t3D496606F94367D5D6B24DA9DC0A3B46E6B53B11_marshaled_com
{
Il2CppIUnknown* ____value_0;
int32_t ____dataPos_1;
};
// Microsoft.MixedReality.Toolkit.Utilities.Response
struct Response_t6299078D176E4C83778DF09816E38C75EFE60512
{
public:
// System.Boolean Microsoft.MixedReality.Toolkit.Utilities.Response::<Successful>k__BackingField
bool ___U3CSuccessfulU3Ek__BackingField_0;
// System.String Microsoft.MixedReality.Toolkit.Utilities.Response::responseBody
String_t* ___responseBody_1;
// System.Threading.Tasks.Task`1<System.String> Microsoft.MixedReality.Toolkit.Utilities.Response::responseBodyTask
Task_1_t30D80D0F41B19BC27A8D1141D69741D0B986B2C3 * ___responseBodyTask_2;
// System.Byte[] Microsoft.MixedReality.Toolkit.Utilities.Response::responseData
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* ___responseData_3;
// System.Func`1<System.Byte[]> Microsoft.MixedReality.Toolkit.Utilities.Response::responseDataAction
Func_1_tD8059ADEA67BC54CB9CB92E8719A3A6BE8473473 * ___responseDataAction_4;
// System.Int64 Microsoft.MixedReality.Toolkit.Utilities.Response::<ResponseCode>k__BackingField
int64_t ___U3CResponseCodeU3Ek__BackingField_5;
public:
inline static int32_t get_offset_of_U3CSuccessfulU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(Response_t6299078D176E4C83778DF09816E38C75EFE60512, ___U3CSuccessfulU3Ek__BackingField_0)); }
inline bool get_U3CSuccessfulU3Ek__BackingField_0() const { return ___U3CSuccessfulU3Ek__BackingField_0; }
inline bool* get_address_of_U3CSuccessfulU3Ek__BackingField_0() { return &___U3CSuccessfulU3Ek__BackingField_0; }
inline void set_U3CSuccessfulU3Ek__BackingField_0(bool value)
{
___U3CSuccessfulU3Ek__BackingField_0 = value;
}
inline static int32_t get_offset_of_responseBody_1() { return static_cast<int32_t>(offsetof(Response_t6299078D176E4C83778DF09816E38C75EFE60512, ___responseBody_1)); }
inline String_t* get_responseBody_1() const { return ___responseBody_1; }
inline String_t** get_address_of_responseBody_1() { return &___responseBody_1; }
inline void set_responseBody_1(String_t* value)
{
___responseBody_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___responseBody_1), (void*)value);
}
inline static int32_t get_offset_of_responseBodyTask_2() { return static_cast<int32_t>(offsetof(Response_t6299078D176E4C83778DF09816E38C75EFE60512, ___responseBodyTask_2)); }
inline Task_1_t30D80D0F41B19BC27A8D1141D69741D0B986B2C3 * get_responseBodyTask_2() const { return ___responseBodyTask_2; }
inline Task_1_t30D80D0F41B19BC27A8D1141D69741D0B986B2C3 ** get_address_of_responseBodyTask_2() { return &___responseBodyTask_2; }
inline void set_responseBodyTask_2(Task_1_t30D80D0F41B19BC27A8D1141D69741D0B986B2C3 * value)
{
___responseBodyTask_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___responseBodyTask_2), (void*)value);
}
inline static int32_t get_offset_of_responseData_3() { return static_cast<int32_t>(offsetof(Response_t6299078D176E4C83778DF09816E38C75EFE60512, ___responseData_3)); }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* get_responseData_3() const { return ___responseData_3; }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726** get_address_of_responseData_3() { return &___responseData_3; }
inline void set_responseData_3(ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* value)
{
___responseData_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___responseData_3), (void*)value);
}
inline static int32_t get_offset_of_responseDataAction_4() { return static_cast<int32_t>(offsetof(Response_t6299078D176E4C83778DF09816E38C75EFE60512, ___responseDataAction_4)); }
inline Func_1_tD8059ADEA67BC54CB9CB92E8719A3A6BE8473473 * get_responseDataAction_4() const { return ___responseDataAction_4; }
inline Func_1_tD8059ADEA67BC54CB9CB92E8719A3A6BE8473473 ** get_address_of_responseDataAction_4() { return &___responseDataAction_4; }
inline void set_responseDataAction_4(Func_1_tD8059ADEA67BC54CB9CB92E8719A3A6BE8473473 * value)
{
___responseDataAction_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___responseDataAction_4), (void*)value);
}
inline static int32_t get_offset_of_U3CResponseCodeU3Ek__BackingField_5() { return static_cast<int32_t>(offsetof(Response_t6299078D176E4C83778DF09816E38C75EFE60512, ___U3CResponseCodeU3Ek__BackingField_5)); }
inline int64_t get_U3CResponseCodeU3Ek__BackingField_5() const { return ___U3CResponseCodeU3Ek__BackingField_5; }
inline int64_t* get_address_of_U3CResponseCodeU3Ek__BackingField_5() { return &___U3CResponseCodeU3Ek__BackingField_5; }
inline void set_U3CResponseCodeU3Ek__BackingField_5(int64_t value)
{
___U3CResponseCodeU3Ek__BackingField_5 = value;
}
};
// Native definition for P/Invoke marshalling of Microsoft.MixedReality.Toolkit.Utilities.Response
struct Response_t6299078D176E4C83778DF09816E38C75EFE60512_marshaled_pinvoke
{
int32_t ___U3CSuccessfulU3Ek__BackingField_0;
char* ___responseBody_1;
Task_1_t30D80D0F41B19BC27A8D1141D69741D0B986B2C3 * ___responseBodyTask_2;
Il2CppSafeArray/*NONE*/* ___responseData_3;
Il2CppMethodPointer ___responseDataAction_4;
int64_t ___U3CResponseCodeU3Ek__BackingField_5;
};
// Native definition for COM marshalling of Microsoft.MixedReality.Toolkit.Utilities.Response
struct Response_t6299078D176E4C83778DF09816E38C75EFE60512_marshaled_com
{
int32_t ___U3CSuccessfulU3Ek__BackingField_0;
Il2CppChar* ___responseBody_1;
Task_1_t30D80D0F41B19BC27A8D1141D69741D0B986B2C3 * ___responseBodyTask_2;
Il2CppSafeArray/*NONE*/* ___responseData_3;
Il2CppMethodPointer ___responseDataAction_4;
int64_t ___U3CResponseCodeU3Ek__BackingField_5;
};
// UnityEngine.SceneManagement.Scene
struct Scene_t5495AD2FDC587DB2E94D9BDE2B85868BFB9A92EE
{
public:
// System.Int32 UnityEngine.SceneManagement.Scene::m_Handle
int32_t ___m_Handle_0;
public:
inline static int32_t get_offset_of_m_Handle_0() { return static_cast<int32_t>(offsetof(Scene_t5495AD2FDC587DB2E94D9BDE2B85868BFB9A92EE, ___m_Handle_0)); }
inline int32_t get_m_Handle_0() const { return ___m_Handle_0; }
inline int32_t* get_address_of_m_Handle_0() { return &___m_Handle_0; }
inline void set_m_Handle_0(int32_t value)
{
___m_Handle_0 = value;
}
};
// UnityEngine.XR.ARSubsystems.SerializableGuid
struct SerializableGuid_t5F8E8B4FF33F91AF9B16C6CC3F75AE00014505CC
{
public:
// System.UInt64 UnityEngine.XR.ARSubsystems.SerializableGuid::m_GuidLow
uint64_t ___m_GuidLow_1;
// System.UInt64 UnityEngine.XR.ARSubsystems.SerializableGuid::m_GuidHigh
uint64_t ___m_GuidHigh_2;
public:
inline static int32_t get_offset_of_m_GuidLow_1() { return static_cast<int32_t>(offsetof(SerializableGuid_t5F8E8B4FF33F91AF9B16C6CC3F75AE00014505CC, ___m_GuidLow_1)); }
inline uint64_t get_m_GuidLow_1() const { return ___m_GuidLow_1; }
inline uint64_t* get_address_of_m_GuidLow_1() { return &___m_GuidLow_1; }
inline void set_m_GuidLow_1(uint64_t value)
{
___m_GuidLow_1 = value;
}
inline static int32_t get_offset_of_m_GuidHigh_2() { return static_cast<int32_t>(offsetof(SerializableGuid_t5F8E8B4FF33F91AF9B16C6CC3F75AE00014505CC, ___m_GuidHigh_2)); }
inline uint64_t get_m_GuidHigh_2() const { return ___m_GuidHigh_2; }
inline uint64_t* get_address_of_m_GuidHigh_2() { return &___m_GuidHigh_2; }
inline void set_m_GuidHigh_2(uint64_t value)
{
___m_GuidHigh_2 = value;
}
};
struct SerializableGuid_t5F8E8B4FF33F91AF9B16C6CC3F75AE00014505CC_StaticFields
{
public:
// UnityEngine.XR.ARSubsystems.SerializableGuid UnityEngine.XR.ARSubsystems.SerializableGuid::k_Empty
SerializableGuid_t5F8E8B4FF33F91AF9B16C6CC3F75AE00014505CC ___k_Empty_0;
public:
inline static int32_t get_offset_of_k_Empty_0() { return static_cast<int32_t>(offsetof(SerializableGuid_t5F8E8B4FF33F91AF9B16C6CC3F75AE00014505CC_StaticFields, ___k_Empty_0)); }
inline SerializableGuid_t5F8E8B4FF33F91AF9B16C6CC3F75AE00014505CC get_k_Empty_0() const { return ___k_Empty_0; }
inline SerializableGuid_t5F8E8B4FF33F91AF9B16C6CC3F75AE00014505CC * get_address_of_k_Empty_0() { return &___k_Empty_0; }
inline void set_k_Empty_0(SerializableGuid_t5F8E8B4FF33F91AF9B16C6CC3F75AE00014505CC value)
{
___k_Empty_0 = value;
}
};
// UnityEngine.Rendering.ShaderTagId
struct ShaderTagId_t51914C89B8119195DACD234D1A624AAB7A07F795
{
public:
// System.Int32 UnityEngine.Rendering.ShaderTagId::m_Id
int32_t ___m_Id_1;
public:
inline static int32_t get_offset_of_m_Id_1() { return static_cast<int32_t>(offsetof(ShaderTagId_t51914C89B8119195DACD234D1A624AAB7A07F795, ___m_Id_1)); }
inline int32_t get_m_Id_1() const { return ___m_Id_1; }
inline int32_t* get_address_of_m_Id_1() { return &___m_Id_1; }
inline void set_m_Id_1(int32_t value)
{
___m_Id_1 = value;
}
};
struct ShaderTagId_t51914C89B8119195DACD234D1A624AAB7A07F795_StaticFields
{
public:
// UnityEngine.Rendering.ShaderTagId UnityEngine.Rendering.ShaderTagId::none
ShaderTagId_t51914C89B8119195DACD234D1A624AAB7A07F795 ___none_0;
public:
inline static int32_t get_offset_of_none_0() { return static_cast<int32_t>(offsetof(ShaderTagId_t51914C89B8119195DACD234D1A624AAB7A07F795_StaticFields, ___none_0)); }
inline ShaderTagId_t51914C89B8119195DACD234D1A624AAB7A07F795 get_none_0() const { return ___none_0; }
inline ShaderTagId_t51914C89B8119195DACD234D1A624AAB7A07F795 * get_address_of_none_0() { return &___none_0; }
inline void set_none_0(ShaderTagId_t51914C89B8119195DACD234D1A624AAB7A07F795 value)
{
___none_0 = value;
}
};
// UnityEngine.UI.SpriteState
struct SpriteState_t9024961148433175CE2F3D9E8E9239A8B1CAB15E
{
public:
// UnityEngine.Sprite UnityEngine.UI.SpriteState::m_HighlightedSprite
Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 * ___m_HighlightedSprite_0;
// UnityEngine.Sprite UnityEngine.UI.SpriteState::m_PressedSprite
Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 * ___m_PressedSprite_1;
// UnityEngine.Sprite UnityEngine.UI.SpriteState::m_SelectedSprite
Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 * ___m_SelectedSprite_2;
// UnityEngine.Sprite UnityEngine.UI.SpriteState::m_DisabledSprite
Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 * ___m_DisabledSprite_3;
public:
inline static int32_t get_offset_of_m_HighlightedSprite_0() { return static_cast<int32_t>(offsetof(SpriteState_t9024961148433175CE2F3D9E8E9239A8B1CAB15E, ___m_HighlightedSprite_0)); }
inline Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 * get_m_HighlightedSprite_0() const { return ___m_HighlightedSprite_0; }
inline Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 ** get_address_of_m_HighlightedSprite_0() { return &___m_HighlightedSprite_0; }
inline void set_m_HighlightedSprite_0(Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 * value)
{
___m_HighlightedSprite_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_HighlightedSprite_0), (void*)value);
}
inline static int32_t get_offset_of_m_PressedSprite_1() { return static_cast<int32_t>(offsetof(SpriteState_t9024961148433175CE2F3D9E8E9239A8B1CAB15E, ___m_PressedSprite_1)); }
inline Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 * get_m_PressedSprite_1() const { return ___m_PressedSprite_1; }
inline Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 ** get_address_of_m_PressedSprite_1() { return &___m_PressedSprite_1; }
inline void set_m_PressedSprite_1(Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 * value)
{
___m_PressedSprite_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_PressedSprite_1), (void*)value);
}
inline static int32_t get_offset_of_m_SelectedSprite_2() { return static_cast<int32_t>(offsetof(SpriteState_t9024961148433175CE2F3D9E8E9239A8B1CAB15E, ___m_SelectedSprite_2)); }
inline Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 * get_m_SelectedSprite_2() const { return ___m_SelectedSprite_2; }
inline Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 ** get_address_of_m_SelectedSprite_2() { return &___m_SelectedSprite_2; }
inline void set_m_SelectedSprite_2(Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 * value)
{
___m_SelectedSprite_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_SelectedSprite_2), (void*)value);
}
inline static int32_t get_offset_of_m_DisabledSprite_3() { return static_cast<int32_t>(offsetof(SpriteState_t9024961148433175CE2F3D9E8E9239A8B1CAB15E, ___m_DisabledSprite_3)); }
inline Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 * get_m_DisabledSprite_3() const { return ___m_DisabledSprite_3; }
inline Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 ** get_address_of_m_DisabledSprite_3() { return &___m_DisabledSprite_3; }
inline void set_m_DisabledSprite_3(Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 * value)
{
___m_DisabledSprite_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_DisabledSprite_3), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.UI.SpriteState
struct SpriteState_t9024961148433175CE2F3D9E8E9239A8B1CAB15E_marshaled_pinvoke
{
Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 * ___m_HighlightedSprite_0;
Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 * ___m_PressedSprite_1;
Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 * ___m_SelectedSprite_2;
Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 * ___m_DisabledSprite_3;
};
// Native definition for COM marshalling of UnityEngine.UI.SpriteState
struct SpriteState_t9024961148433175CE2F3D9E8E9239A8B1CAB15E_marshaled_com
{
Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 * ___m_HighlightedSprite_0;
Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 * ___m_PressedSprite_1;
Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 * ___m_SelectedSprite_2;
Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 * ___m_DisabledSprite_3;
};
// Microsoft.MixedReality.Toolkit.UI.ThemeDefinition
struct ThemeDefinition_tDC1C1DE1B953BC552C4A4D956F12537CC94E400E
{
public:
// System.Type Microsoft.MixedReality.Toolkit.UI.ThemeDefinition::Type
Type_t * ___Type_0;
// System.String Microsoft.MixedReality.Toolkit.UI.ThemeDefinition::ClassName
String_t* ___ClassName_1;
// System.String Microsoft.MixedReality.Toolkit.UI.ThemeDefinition::AssemblyQualifiedName
String_t* ___AssemblyQualifiedName_2;
// System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.UI.ThemeStateProperty> Microsoft.MixedReality.Toolkit.UI.ThemeDefinition::stateProperties
List_1_tF1E76A3D523F2AEA047842F1BB441371552FC7F9 * ___stateProperties_3;
// System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.UI.ThemeProperty> Microsoft.MixedReality.Toolkit.UI.ThemeDefinition::customProperties
List_1_tB423C8A3B8886D82EADF0276CDCC6A9572ED6DDC * ___customProperties_4;
// Microsoft.MixedReality.Toolkit.Utilities.Easing Microsoft.MixedReality.Toolkit.UI.ThemeDefinition::easing
Easing_tAA867F785964FBF3969D6B74FF22B130B0C59833 * ___easing_5;
public:
inline static int32_t get_offset_of_Type_0() { return static_cast<int32_t>(offsetof(ThemeDefinition_tDC1C1DE1B953BC552C4A4D956F12537CC94E400E, ___Type_0)); }
inline Type_t * get_Type_0() const { return ___Type_0; }
inline Type_t ** get_address_of_Type_0() { return &___Type_0; }
inline void set_Type_0(Type_t * value)
{
___Type_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Type_0), (void*)value);
}
inline static int32_t get_offset_of_ClassName_1() { return static_cast<int32_t>(offsetof(ThemeDefinition_tDC1C1DE1B953BC552C4A4D956F12537CC94E400E, ___ClassName_1)); }
inline String_t* get_ClassName_1() const { return ___ClassName_1; }
inline String_t** get_address_of_ClassName_1() { return &___ClassName_1; }
inline void set_ClassName_1(String_t* value)
{
___ClassName_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___ClassName_1), (void*)value);
}
inline static int32_t get_offset_of_AssemblyQualifiedName_2() { return static_cast<int32_t>(offsetof(ThemeDefinition_tDC1C1DE1B953BC552C4A4D956F12537CC94E400E, ___AssemblyQualifiedName_2)); }
inline String_t* get_AssemblyQualifiedName_2() const { return ___AssemblyQualifiedName_2; }
inline String_t** get_address_of_AssemblyQualifiedName_2() { return &___AssemblyQualifiedName_2; }
inline void set_AssemblyQualifiedName_2(String_t* value)
{
___AssemblyQualifiedName_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___AssemblyQualifiedName_2), (void*)value);
}
inline static int32_t get_offset_of_stateProperties_3() { return static_cast<int32_t>(offsetof(ThemeDefinition_tDC1C1DE1B953BC552C4A4D956F12537CC94E400E, ___stateProperties_3)); }
inline List_1_tF1E76A3D523F2AEA047842F1BB441371552FC7F9 * get_stateProperties_3() const { return ___stateProperties_3; }
inline List_1_tF1E76A3D523F2AEA047842F1BB441371552FC7F9 ** get_address_of_stateProperties_3() { return &___stateProperties_3; }
inline void set_stateProperties_3(List_1_tF1E76A3D523F2AEA047842F1BB441371552FC7F9 * value)
{
___stateProperties_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___stateProperties_3), (void*)value);
}
inline static int32_t get_offset_of_customProperties_4() { return static_cast<int32_t>(offsetof(ThemeDefinition_tDC1C1DE1B953BC552C4A4D956F12537CC94E400E, ___customProperties_4)); }
inline List_1_tB423C8A3B8886D82EADF0276CDCC6A9572ED6DDC * get_customProperties_4() const { return ___customProperties_4; }
inline List_1_tB423C8A3B8886D82EADF0276CDCC6A9572ED6DDC ** get_address_of_customProperties_4() { return &___customProperties_4; }
inline void set_customProperties_4(List_1_tB423C8A3B8886D82EADF0276CDCC6A9572ED6DDC * value)
{
___customProperties_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___customProperties_4), (void*)value);
}
inline static int32_t get_offset_of_easing_5() { return static_cast<int32_t>(offsetof(ThemeDefinition_tDC1C1DE1B953BC552C4A4D956F12537CC94E400E, ___easing_5)); }
inline Easing_tAA867F785964FBF3969D6B74FF22B130B0C59833 * get_easing_5() const { return ___easing_5; }
inline Easing_tAA867F785964FBF3969D6B74FF22B130B0C59833 ** get_address_of_easing_5() { return &___easing_5; }
inline void set_easing_5(Easing_tAA867F785964FBF3969D6B74FF22B130B0C59833 * value)
{
___easing_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___easing_5), (void*)value);
}
};
// Native definition for P/Invoke marshalling of Microsoft.MixedReality.Toolkit.UI.ThemeDefinition
struct ThemeDefinition_tDC1C1DE1B953BC552C4A4D956F12537CC94E400E_marshaled_pinvoke
{
Type_t * ___Type_0;
char* ___ClassName_1;
char* ___AssemblyQualifiedName_2;
List_1_tF1E76A3D523F2AEA047842F1BB441371552FC7F9 * ___stateProperties_3;
List_1_tB423C8A3B8886D82EADF0276CDCC6A9572ED6DDC * ___customProperties_4;
Easing_tAA867F785964FBF3969D6B74FF22B130B0C59833 * ___easing_5;
};
// Native definition for COM marshalling of Microsoft.MixedReality.Toolkit.UI.ThemeDefinition
struct ThemeDefinition_tDC1C1DE1B953BC552C4A4D956F12537CC94E400E_marshaled_com
{
Type_t * ___Type_0;
Il2CppChar* ___ClassName_1;
Il2CppChar* ___AssemblyQualifiedName_2;
List_1_tF1E76A3D523F2AEA047842F1BB441371552FC7F9 * ___stateProperties_3;
List_1_tB423C8A3B8886D82EADF0276CDCC6A9572ED6DDC * ___customProperties_4;
Easing_tAA867F785964FBF3969D6B74FF22B130B0C59833 * ___easing_5;
};
// UnityEngine.XR.ARSubsystems.TrackableId
struct TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B
{
public:
// System.UInt64 UnityEngine.XR.ARSubsystems.TrackableId::m_SubId1
uint64_t ___m_SubId1_2;
// System.UInt64 UnityEngine.XR.ARSubsystems.TrackableId::m_SubId2
uint64_t ___m_SubId2_3;
public:
inline static int32_t get_offset_of_m_SubId1_2() { return static_cast<int32_t>(offsetof(TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B, ___m_SubId1_2)); }
inline uint64_t get_m_SubId1_2() const { return ___m_SubId1_2; }
inline uint64_t* get_address_of_m_SubId1_2() { return &___m_SubId1_2; }
inline void set_m_SubId1_2(uint64_t value)
{
___m_SubId1_2 = value;
}
inline static int32_t get_offset_of_m_SubId2_3() { return static_cast<int32_t>(offsetof(TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B, ___m_SubId2_3)); }
inline uint64_t get_m_SubId2_3() const { return ___m_SubId2_3; }
inline uint64_t* get_address_of_m_SubId2_3() { return &___m_SubId2_3; }
inline void set_m_SubId2_3(uint64_t value)
{
___m_SubId2_3 = value;
}
};
struct TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B_StaticFields
{
public:
// System.Text.RegularExpressions.Regex UnityEngine.XR.ARSubsystems.TrackableId::s_TrackableIdRegex
Regex_t90F443D398F44965EA241A652ED75DF5BA072A1F * ___s_TrackableIdRegex_0;
// UnityEngine.XR.ARSubsystems.TrackableId UnityEngine.XR.ARSubsystems.TrackableId::s_InvalidId
TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B ___s_InvalidId_1;
public:
inline static int32_t get_offset_of_s_TrackableIdRegex_0() { return static_cast<int32_t>(offsetof(TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B_StaticFields, ___s_TrackableIdRegex_0)); }
inline Regex_t90F443D398F44965EA241A652ED75DF5BA072A1F * get_s_TrackableIdRegex_0() const { return ___s_TrackableIdRegex_0; }
inline Regex_t90F443D398F44965EA241A652ED75DF5BA072A1F ** get_address_of_s_TrackableIdRegex_0() { return &___s_TrackableIdRegex_0; }
inline void set_s_TrackableIdRegex_0(Regex_t90F443D398F44965EA241A652ED75DF5BA072A1F * value)
{
___s_TrackableIdRegex_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_TrackableIdRegex_0), (void*)value);
}
inline static int32_t get_offset_of_s_InvalidId_1() { return static_cast<int32_t>(offsetof(TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B_StaticFields, ___s_InvalidId_1)); }
inline TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B get_s_InvalidId_1() const { return ___s_InvalidId_1; }
inline TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B * get_address_of_s_InvalidId_1() { return &___s_InvalidId_1; }
inline void set_s_InvalidId_1(TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B value)
{
___s_InvalidId_1 = value;
}
};
// UnityEngine.UILineInfo
struct UILineInfo_tD082FF4894030AD4EBF57ACF6A997135E4B8B67C
{
public:
// System.Int32 UnityEngine.UILineInfo::startCharIdx
int32_t ___startCharIdx_0;
// System.Int32 UnityEngine.UILineInfo::height
int32_t ___height_1;
// System.Single UnityEngine.UILineInfo::topY
float ___topY_2;
// System.Single UnityEngine.UILineInfo::leading
float ___leading_3;
public:
inline static int32_t get_offset_of_startCharIdx_0() { return static_cast<int32_t>(offsetof(UILineInfo_tD082FF4894030AD4EBF57ACF6A997135E4B8B67C, ___startCharIdx_0)); }
inline int32_t get_startCharIdx_0() const { return ___startCharIdx_0; }
inline int32_t* get_address_of_startCharIdx_0() { return &___startCharIdx_0; }
inline void set_startCharIdx_0(int32_t value)
{
___startCharIdx_0 = value;
}
inline static int32_t get_offset_of_height_1() { return static_cast<int32_t>(offsetof(UILineInfo_tD082FF4894030AD4EBF57ACF6A997135E4B8B67C, ___height_1)); }
inline int32_t get_height_1() const { return ___height_1; }
inline int32_t* get_address_of_height_1() { return &___height_1; }
inline void set_height_1(int32_t value)
{
___height_1 = value;
}
inline static int32_t get_offset_of_topY_2() { return static_cast<int32_t>(offsetof(UILineInfo_tD082FF4894030AD4EBF57ACF6A997135E4B8B67C, ___topY_2)); }
inline float get_topY_2() const { return ___topY_2; }
inline float* get_address_of_topY_2() { return &___topY_2; }
inline void set_topY_2(float value)
{
___topY_2 = value;
}
inline static int32_t get_offset_of_leading_3() { return static_cast<int32_t>(offsetof(UILineInfo_tD082FF4894030AD4EBF57ACF6A997135E4B8B67C, ___leading_3)); }
inline float get_leading_3() const { return ___leading_3; }
inline float* get_address_of_leading_3() { return &___leading_3; }
inline void set_leading_3(float value)
{
___leading_3 = value;
}
};
// UnityEngine.VFX.VFXOutputEventArgs
struct VFXOutputEventArgs_tE7E97EDFD67E4561E4412D2E4B1C999F95850BF5
{
public:
// System.Int32 UnityEngine.VFX.VFXOutputEventArgs::<nameId>k__BackingField
int32_t ___U3CnameIdU3Ek__BackingField_0;
// UnityEngine.VFX.VFXEventAttribute UnityEngine.VFX.VFXOutputEventArgs::<eventAttribute>k__BackingField
VFXEventAttribute_tC4E90458100D52776F591CE62B19FF6051F423EF * ___U3CeventAttributeU3Ek__BackingField_1;
public:
inline static int32_t get_offset_of_U3CnameIdU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(VFXOutputEventArgs_tE7E97EDFD67E4561E4412D2E4B1C999F95850BF5, ___U3CnameIdU3Ek__BackingField_0)); }
inline int32_t get_U3CnameIdU3Ek__BackingField_0() const { return ___U3CnameIdU3Ek__BackingField_0; }
inline int32_t* get_address_of_U3CnameIdU3Ek__BackingField_0() { return &___U3CnameIdU3Ek__BackingField_0; }
inline void set_U3CnameIdU3Ek__BackingField_0(int32_t value)
{
___U3CnameIdU3Ek__BackingField_0 = value;
}
inline static int32_t get_offset_of_U3CeventAttributeU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(VFXOutputEventArgs_tE7E97EDFD67E4561E4412D2E4B1C999F95850BF5, ___U3CeventAttributeU3Ek__BackingField_1)); }
inline VFXEventAttribute_tC4E90458100D52776F591CE62B19FF6051F423EF * get_U3CeventAttributeU3Ek__BackingField_1() const { return ___U3CeventAttributeU3Ek__BackingField_1; }
inline VFXEventAttribute_tC4E90458100D52776F591CE62B19FF6051F423EF ** get_address_of_U3CeventAttributeU3Ek__BackingField_1() { return &___U3CeventAttributeU3Ek__BackingField_1; }
inline void set_U3CeventAttributeU3Ek__BackingField_1(VFXEventAttribute_tC4E90458100D52776F591CE62B19FF6051F423EF * value)
{
___U3CeventAttributeU3Ek__BackingField_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CeventAttributeU3Ek__BackingField_1), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.VFX.VFXOutputEventArgs
struct VFXOutputEventArgs_tE7E97EDFD67E4561E4412D2E4B1C999F95850BF5_marshaled_pinvoke
{
int32_t ___U3CnameIdU3Ek__BackingField_0;
VFXEventAttribute_tC4E90458100D52776F591CE62B19FF6051F423EF_marshaled_pinvoke* ___U3CeventAttributeU3Ek__BackingField_1;
};
// Native definition for COM marshalling of UnityEngine.VFX.VFXOutputEventArgs
struct VFXOutputEventArgs_tE7E97EDFD67E4561E4412D2E4B1C999F95850BF5_marshaled_com
{
int32_t ___U3CnameIdU3Ek__BackingField_0;
VFXEventAttribute_tC4E90458100D52776F591CE62B19FF6051F423EF_marshaled_com* ___U3CeventAttributeU3Ek__BackingField_1;
};
// UnityEngine.Vector2
struct Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9
{
public:
// System.Single UnityEngine.Vector2::x
float ___x_0;
// System.Single UnityEngine.Vector2::y
float ___y_1;
public:
inline static int32_t get_offset_of_x_0() { return static_cast<int32_t>(offsetof(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9, ___x_0)); }
inline float get_x_0() const { return ___x_0; }
inline float* get_address_of_x_0() { return &___x_0; }
inline void set_x_0(float value)
{
___x_0 = value;
}
inline static int32_t get_offset_of_y_1() { return static_cast<int32_t>(offsetof(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9, ___y_1)); }
inline float get_y_1() const { return ___y_1; }
inline float* get_address_of_y_1() { return &___y_1; }
inline void set_y_1(float value)
{
___y_1 = value;
}
};
struct Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9_StaticFields
{
public:
// UnityEngine.Vector2 UnityEngine.Vector2::zeroVector
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___zeroVector_2;
// UnityEngine.Vector2 UnityEngine.Vector2::oneVector
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___oneVector_3;
// UnityEngine.Vector2 UnityEngine.Vector2::upVector
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___upVector_4;
// UnityEngine.Vector2 UnityEngine.Vector2::downVector
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___downVector_5;
// UnityEngine.Vector2 UnityEngine.Vector2::leftVector
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___leftVector_6;
// UnityEngine.Vector2 UnityEngine.Vector2::rightVector
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___rightVector_7;
// UnityEngine.Vector2 UnityEngine.Vector2::positiveInfinityVector
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___positiveInfinityVector_8;
// UnityEngine.Vector2 UnityEngine.Vector2::negativeInfinityVector
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___negativeInfinityVector_9;
public:
inline static int32_t get_offset_of_zeroVector_2() { return static_cast<int32_t>(offsetof(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9_StaticFields, ___zeroVector_2)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_zeroVector_2() const { return ___zeroVector_2; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_zeroVector_2() { return &___zeroVector_2; }
inline void set_zeroVector_2(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___zeroVector_2 = value;
}
inline static int32_t get_offset_of_oneVector_3() { return static_cast<int32_t>(offsetof(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9_StaticFields, ___oneVector_3)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_oneVector_3() const { return ___oneVector_3; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_oneVector_3() { return &___oneVector_3; }
inline void set_oneVector_3(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___oneVector_3 = value;
}
inline static int32_t get_offset_of_upVector_4() { return static_cast<int32_t>(offsetof(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9_StaticFields, ___upVector_4)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_upVector_4() const { return ___upVector_4; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_upVector_4() { return &___upVector_4; }
inline void set_upVector_4(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___upVector_4 = value;
}
inline static int32_t get_offset_of_downVector_5() { return static_cast<int32_t>(offsetof(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9_StaticFields, ___downVector_5)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_downVector_5() const { return ___downVector_5; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_downVector_5() { return &___downVector_5; }
inline void set_downVector_5(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___downVector_5 = value;
}
inline static int32_t get_offset_of_leftVector_6() { return static_cast<int32_t>(offsetof(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9_StaticFields, ___leftVector_6)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_leftVector_6() const { return ___leftVector_6; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_leftVector_6() { return &___leftVector_6; }
inline void set_leftVector_6(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___leftVector_6 = value;
}
inline static int32_t get_offset_of_rightVector_7() { return static_cast<int32_t>(offsetof(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9_StaticFields, ___rightVector_7)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_rightVector_7() const { return ___rightVector_7; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_rightVector_7() { return &___rightVector_7; }
inline void set_rightVector_7(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___rightVector_7 = value;
}
inline static int32_t get_offset_of_positiveInfinityVector_8() { return static_cast<int32_t>(offsetof(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9_StaticFields, ___positiveInfinityVector_8)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_positiveInfinityVector_8() const { return ___positiveInfinityVector_8; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_positiveInfinityVector_8() { return &___positiveInfinityVector_8; }
inline void set_positiveInfinityVector_8(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___positiveInfinityVector_8 = value;
}
inline static int32_t get_offset_of_negativeInfinityVector_9() { return static_cast<int32_t>(offsetof(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9_StaticFields, ___negativeInfinityVector_9)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_negativeInfinityVector_9() const { return ___negativeInfinityVector_9; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_negativeInfinityVector_9() { return &___negativeInfinityVector_9; }
inline void set_negativeInfinityVector_9(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___negativeInfinityVector_9 = value;
}
};
// UnityEngine.Vector3
struct Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E
{
public:
// System.Single UnityEngine.Vector3::x
float ___x_2;
// System.Single UnityEngine.Vector3::y
float ___y_3;
// System.Single UnityEngine.Vector3::z
float ___z_4;
public:
inline static int32_t get_offset_of_x_2() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E, ___x_2)); }
inline float get_x_2() const { return ___x_2; }
inline float* get_address_of_x_2() { return &___x_2; }
inline void set_x_2(float value)
{
___x_2 = value;
}
inline static int32_t get_offset_of_y_3() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E, ___y_3)); }
inline float get_y_3() const { return ___y_3; }
inline float* get_address_of_y_3() { return &___y_3; }
inline void set_y_3(float value)
{
___y_3 = value;
}
inline static int32_t get_offset_of_z_4() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E, ___z_4)); }
inline float get_z_4() const { return ___z_4; }
inline float* get_address_of_z_4() { return &___z_4; }
inline void set_z_4(float value)
{
___z_4 = value;
}
};
struct Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields
{
public:
// UnityEngine.Vector3 UnityEngine.Vector3::zeroVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___zeroVector_5;
// UnityEngine.Vector3 UnityEngine.Vector3::oneVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___oneVector_6;
// UnityEngine.Vector3 UnityEngine.Vector3::upVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___upVector_7;
// UnityEngine.Vector3 UnityEngine.Vector3::downVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___downVector_8;
// UnityEngine.Vector3 UnityEngine.Vector3::leftVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___leftVector_9;
// UnityEngine.Vector3 UnityEngine.Vector3::rightVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___rightVector_10;
// UnityEngine.Vector3 UnityEngine.Vector3::forwardVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___forwardVector_11;
// UnityEngine.Vector3 UnityEngine.Vector3::backVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___backVector_12;
// UnityEngine.Vector3 UnityEngine.Vector3::positiveInfinityVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___positiveInfinityVector_13;
// UnityEngine.Vector3 UnityEngine.Vector3::negativeInfinityVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___negativeInfinityVector_14;
public:
inline static int32_t get_offset_of_zeroVector_5() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___zeroVector_5)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_zeroVector_5() const { return ___zeroVector_5; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_zeroVector_5() { return &___zeroVector_5; }
inline void set_zeroVector_5(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___zeroVector_5 = value;
}
inline static int32_t get_offset_of_oneVector_6() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___oneVector_6)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_oneVector_6() const { return ___oneVector_6; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_oneVector_6() { return &___oneVector_6; }
inline void set_oneVector_6(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___oneVector_6 = value;
}
inline static int32_t get_offset_of_upVector_7() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___upVector_7)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_upVector_7() const { return ___upVector_7; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_upVector_7() { return &___upVector_7; }
inline void set_upVector_7(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___upVector_7 = value;
}
inline static int32_t get_offset_of_downVector_8() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___downVector_8)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_downVector_8() const { return ___downVector_8; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_downVector_8() { return &___downVector_8; }
inline void set_downVector_8(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___downVector_8 = value;
}
inline static int32_t get_offset_of_leftVector_9() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___leftVector_9)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_leftVector_9() const { return ___leftVector_9; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_leftVector_9() { return &___leftVector_9; }
inline void set_leftVector_9(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___leftVector_9 = value;
}
inline static int32_t get_offset_of_rightVector_10() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___rightVector_10)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_rightVector_10() const { return ___rightVector_10; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_rightVector_10() { return &___rightVector_10; }
inline void set_rightVector_10(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___rightVector_10 = value;
}
inline static int32_t get_offset_of_forwardVector_11() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___forwardVector_11)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_forwardVector_11() const { return ___forwardVector_11; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_forwardVector_11() { return &___forwardVector_11; }
inline void set_forwardVector_11(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___forwardVector_11 = value;
}
inline static int32_t get_offset_of_backVector_12() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___backVector_12)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_backVector_12() const { return ___backVector_12; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_backVector_12() { return &___backVector_12; }
inline void set_backVector_12(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___backVector_12 = value;
}
inline static int32_t get_offset_of_positiveInfinityVector_13() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___positiveInfinityVector_13)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_positiveInfinityVector_13() const { return ___positiveInfinityVector_13; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_positiveInfinityVector_13() { return &___positiveInfinityVector_13; }
inline void set_positiveInfinityVector_13(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___positiveInfinityVector_13 = value;
}
inline static int32_t get_offset_of_negativeInfinityVector_14() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___negativeInfinityVector_14)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_negativeInfinityVector_14() const { return ___negativeInfinityVector_14; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_negativeInfinityVector_14() { return &___negativeInfinityVector_14; }
inline void set_negativeInfinityVector_14(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___negativeInfinityVector_14 = value;
}
};
// UnityEngine.Vector3Int
struct Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA
{
public:
// System.Int32 UnityEngine.Vector3Int::m_X
int32_t ___m_X_0;
// System.Int32 UnityEngine.Vector3Int::m_Y
int32_t ___m_Y_1;
// System.Int32 UnityEngine.Vector3Int::m_Z
int32_t ___m_Z_2;
public:
inline static int32_t get_offset_of_m_X_0() { return static_cast<int32_t>(offsetof(Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA, ___m_X_0)); }
inline int32_t get_m_X_0() const { return ___m_X_0; }
inline int32_t* get_address_of_m_X_0() { return &___m_X_0; }
inline void set_m_X_0(int32_t value)
{
___m_X_0 = value;
}
inline static int32_t get_offset_of_m_Y_1() { return static_cast<int32_t>(offsetof(Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA, ___m_Y_1)); }
inline int32_t get_m_Y_1() const { return ___m_Y_1; }
inline int32_t* get_address_of_m_Y_1() { return &___m_Y_1; }
inline void set_m_Y_1(int32_t value)
{
___m_Y_1 = value;
}
inline static int32_t get_offset_of_m_Z_2() { return static_cast<int32_t>(offsetof(Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA, ___m_Z_2)); }
inline int32_t get_m_Z_2() const { return ___m_Z_2; }
inline int32_t* get_address_of_m_Z_2() { return &___m_Z_2; }
inline void set_m_Z_2(int32_t value)
{
___m_Z_2 = value;
}
};
struct Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA_StaticFields
{
public:
// UnityEngine.Vector3Int UnityEngine.Vector3Int::s_Zero
Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA ___s_Zero_3;
// UnityEngine.Vector3Int UnityEngine.Vector3Int::s_One
Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA ___s_One_4;
// UnityEngine.Vector3Int UnityEngine.Vector3Int::s_Up
Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA ___s_Up_5;
// UnityEngine.Vector3Int UnityEngine.Vector3Int::s_Down
Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA ___s_Down_6;
// UnityEngine.Vector3Int UnityEngine.Vector3Int::s_Left
Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA ___s_Left_7;
// UnityEngine.Vector3Int UnityEngine.Vector3Int::s_Right
Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA ___s_Right_8;
// UnityEngine.Vector3Int UnityEngine.Vector3Int::s_Forward
Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA ___s_Forward_9;
// UnityEngine.Vector3Int UnityEngine.Vector3Int::s_Back
Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA ___s_Back_10;
public:
inline static int32_t get_offset_of_s_Zero_3() { return static_cast<int32_t>(offsetof(Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA_StaticFields, ___s_Zero_3)); }
inline Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA get_s_Zero_3() const { return ___s_Zero_3; }
inline Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA * get_address_of_s_Zero_3() { return &___s_Zero_3; }
inline void set_s_Zero_3(Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA value)
{
___s_Zero_3 = value;
}
inline static int32_t get_offset_of_s_One_4() { return static_cast<int32_t>(offsetof(Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA_StaticFields, ___s_One_4)); }
inline Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA get_s_One_4() const { return ___s_One_4; }
inline Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA * get_address_of_s_One_4() { return &___s_One_4; }
inline void set_s_One_4(Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA value)
{
___s_One_4 = value;
}
inline static int32_t get_offset_of_s_Up_5() { return static_cast<int32_t>(offsetof(Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA_StaticFields, ___s_Up_5)); }
inline Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA get_s_Up_5() const { return ___s_Up_5; }
inline Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA * get_address_of_s_Up_5() { return &___s_Up_5; }
inline void set_s_Up_5(Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA value)
{
___s_Up_5 = value;
}
inline static int32_t get_offset_of_s_Down_6() { return static_cast<int32_t>(offsetof(Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA_StaticFields, ___s_Down_6)); }
inline Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA get_s_Down_6() const { return ___s_Down_6; }
inline Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA * get_address_of_s_Down_6() { return &___s_Down_6; }
inline void set_s_Down_6(Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA value)
{
___s_Down_6 = value;
}
inline static int32_t get_offset_of_s_Left_7() { return static_cast<int32_t>(offsetof(Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA_StaticFields, ___s_Left_7)); }
inline Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA get_s_Left_7() const { return ___s_Left_7; }
inline Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA * get_address_of_s_Left_7() { return &___s_Left_7; }
inline void set_s_Left_7(Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA value)
{
___s_Left_7 = value;
}
inline static int32_t get_offset_of_s_Right_8() { return static_cast<int32_t>(offsetof(Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA_StaticFields, ___s_Right_8)); }
inline Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA get_s_Right_8() const { return ___s_Right_8; }
inline Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA * get_address_of_s_Right_8() { return &___s_Right_8; }
inline void set_s_Right_8(Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA value)
{
___s_Right_8 = value;
}
inline static int32_t get_offset_of_s_Forward_9() { return static_cast<int32_t>(offsetof(Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA_StaticFields, ___s_Forward_9)); }
inline Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA get_s_Forward_9() const { return ___s_Forward_9; }
inline Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA * get_address_of_s_Forward_9() { return &___s_Forward_9; }
inline void set_s_Forward_9(Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA value)
{
___s_Forward_9 = value;
}
inline static int32_t get_offset_of_s_Back_10() { return static_cast<int32_t>(offsetof(Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA_StaticFields, ___s_Back_10)); }
inline Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA get_s_Back_10() const { return ___s_Back_10; }
inline Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA * get_address_of_s_Back_10() { return &___s_Back_10; }
inline void set_s_Back_10(Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA value)
{
___s_Back_10 = value;
}
};
// UnityEngine.Vector4
struct Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7
{
public:
// System.Single UnityEngine.Vector4::x
float ___x_1;
// System.Single UnityEngine.Vector4::y
float ___y_2;
// System.Single UnityEngine.Vector4::z
float ___z_3;
// System.Single UnityEngine.Vector4::w
float ___w_4;
public:
inline static int32_t get_offset_of_x_1() { return static_cast<int32_t>(offsetof(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7, ___x_1)); }
inline float get_x_1() const { return ___x_1; }
inline float* get_address_of_x_1() { return &___x_1; }
inline void set_x_1(float value)
{
___x_1 = value;
}
inline static int32_t get_offset_of_y_2() { return static_cast<int32_t>(offsetof(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7, ___y_2)); }
inline float get_y_2() const { return ___y_2; }
inline float* get_address_of_y_2() { return &___y_2; }
inline void set_y_2(float value)
{
___y_2 = value;
}
inline static int32_t get_offset_of_z_3() { return static_cast<int32_t>(offsetof(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7, ___z_3)); }
inline float get_z_3() const { return ___z_3; }
inline float* get_address_of_z_3() { return &___z_3; }
inline void set_z_3(float value)
{
___z_3 = value;
}
inline static int32_t get_offset_of_w_4() { return static_cast<int32_t>(offsetof(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7, ___w_4)); }
inline float get_w_4() const { return ___w_4; }
inline float* get_address_of_w_4() { return &___w_4; }
inline void set_w_4(float value)
{
___w_4 = value;
}
};
struct Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7_StaticFields
{
public:
// UnityEngine.Vector4 UnityEngine.Vector4::zeroVector
Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 ___zeroVector_5;
// UnityEngine.Vector4 UnityEngine.Vector4::oneVector
Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 ___oneVector_6;
// UnityEngine.Vector4 UnityEngine.Vector4::positiveInfinityVector
Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 ___positiveInfinityVector_7;
// UnityEngine.Vector4 UnityEngine.Vector4::negativeInfinityVector
Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 ___negativeInfinityVector_8;
public:
inline static int32_t get_offset_of_zeroVector_5() { return static_cast<int32_t>(offsetof(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7_StaticFields, ___zeroVector_5)); }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 get_zeroVector_5() const { return ___zeroVector_5; }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 * get_address_of_zeroVector_5() { return &___zeroVector_5; }
inline void set_zeroVector_5(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 value)
{
___zeroVector_5 = value;
}
inline static int32_t get_offset_of_oneVector_6() { return static_cast<int32_t>(offsetof(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7_StaticFields, ___oneVector_6)); }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 get_oneVector_6() const { return ___oneVector_6; }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 * get_address_of_oneVector_6() { return &___oneVector_6; }
inline void set_oneVector_6(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 value)
{
___oneVector_6 = value;
}
inline static int32_t get_offset_of_positiveInfinityVector_7() { return static_cast<int32_t>(offsetof(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7_StaticFields, ___positiveInfinityVector_7)); }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 get_positiveInfinityVector_7() const { return ___positiveInfinityVector_7; }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 * get_address_of_positiveInfinityVector_7() { return &___positiveInfinityVector_7; }
inline void set_positiveInfinityVector_7(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 value)
{
___positiveInfinityVector_7 = value;
}
inline static int32_t get_offset_of_negativeInfinityVector_8() { return static_cast<int32_t>(offsetof(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7_StaticFields, ___negativeInfinityVector_8)); }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 get_negativeInfinityVector_8() const { return ___negativeInfinityVector_8; }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 * get_address_of_negativeInfinityVector_8() { return &___negativeInfinityVector_8; }
inline void set_negativeInfinityVector_8(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 value)
{
___negativeInfinityVector_8 = value;
}
};
// System.Threading.Tasks.VoidTaskResult
struct VoidTaskResult_t28D1A323545DE024749196472558F49F1AAF0004
{
public:
union
{
struct
{
};
uint8_t VoidTaskResult_t28D1A323545DE024749196472558F49F1AAF0004__padding[1];
};
public:
};
// UnityEngine.Yoga.YogaSize
struct YogaSize_tC805BF63DE9A9E4B9984B964AB0A1CFA04ADC1FD
{
public:
// System.Single UnityEngine.Yoga.YogaSize::width
float ___width_0;
// System.Single UnityEngine.Yoga.YogaSize::height
float ___height_1;
public:
inline static int32_t get_offset_of_width_0() { return static_cast<int32_t>(offsetof(YogaSize_tC805BF63DE9A9E4B9984B964AB0A1CFA04ADC1FD, ___width_0)); }
inline float get_width_0() const { return ___width_0; }
inline float* get_address_of_width_0() { return &___width_0; }
inline void set_width_0(float value)
{
___width_0 = value;
}
inline static int32_t get_offset_of_height_1() { return static_cast<int32_t>(offsetof(YogaSize_tC805BF63DE9A9E4B9984B964AB0A1CFA04ADC1FD, ___height_1)); }
inline float get_height_1() const { return ___height_1; }
inline float* get_address_of_height_1() { return &___height_1; }
inline void set_height_1(float value)
{
___height_1 = value;
}
};
// Microsoft.MixedReality.Toolkit.Audio.AudioLoFiEffect/AudioLoFiFilterSettings
struct AudioLoFiFilterSettings_t5EC9A0E1CF4DFFC4BA58E1DF6D4E880F9404B0A8
{
public:
// System.Single Microsoft.MixedReality.Toolkit.Audio.AudioLoFiEffect/AudioLoFiFilterSettings::<LowPassCutoff>k__BackingField
float ___U3CLowPassCutoffU3Ek__BackingField_0;
// System.Single Microsoft.MixedReality.Toolkit.Audio.AudioLoFiEffect/AudioLoFiFilterSettings::<HighPassCutoff>k__BackingField
float ___U3CHighPassCutoffU3Ek__BackingField_1;
public:
inline static int32_t get_offset_of_U3CLowPassCutoffU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(AudioLoFiFilterSettings_t5EC9A0E1CF4DFFC4BA58E1DF6D4E880F9404B0A8, ___U3CLowPassCutoffU3Ek__BackingField_0)); }
inline float get_U3CLowPassCutoffU3Ek__BackingField_0() const { return ___U3CLowPassCutoffU3Ek__BackingField_0; }
inline float* get_address_of_U3CLowPassCutoffU3Ek__BackingField_0() { return &___U3CLowPassCutoffU3Ek__BackingField_0; }
inline void set_U3CLowPassCutoffU3Ek__BackingField_0(float value)
{
___U3CLowPassCutoffU3Ek__BackingField_0 = value;
}
inline static int32_t get_offset_of_U3CHighPassCutoffU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(AudioLoFiFilterSettings_t5EC9A0E1CF4DFFC4BA58E1DF6D4E880F9404B0A8, ___U3CHighPassCutoffU3Ek__BackingField_1)); }
inline float get_U3CHighPassCutoffU3Ek__BackingField_1() const { return ___U3CHighPassCutoffU3Ek__BackingField_1; }
inline float* get_address_of_U3CHighPassCutoffU3Ek__BackingField_1() { return &___U3CHighPassCutoffU3Ek__BackingField_1; }
inline void set_U3CHighPassCutoffU3Ek__BackingField_1(float value)
{
___U3CHighPassCutoffU3Ek__BackingField_1 = value;
}
};
// Microsoft.MixedReality.Toolkit.BaseEventSystem/EventHandlerEntry
struct EventHandlerEntry_tD4B30F35FCE99CEB4F1BFF88A3F5FA0407C3C927
{
public:
// UnityEngine.EventSystems.IEventSystemHandler Microsoft.MixedReality.Toolkit.BaseEventSystem/EventHandlerEntry::handler
RuntimeObject* ___handler_0;
// System.Boolean Microsoft.MixedReality.Toolkit.BaseEventSystem/EventHandlerEntry::parentObjectIsInObjectCollection
bool ___parentObjectIsInObjectCollection_1;
public:
inline static int32_t get_offset_of_handler_0() { return static_cast<int32_t>(offsetof(EventHandlerEntry_tD4B30F35FCE99CEB4F1BFF88A3F5FA0407C3C927, ___handler_0)); }
inline RuntimeObject* get_handler_0() const { return ___handler_0; }
inline RuntimeObject** get_address_of_handler_0() { return &___handler_0; }
inline void set_handler_0(RuntimeObject* value)
{
___handler_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___handler_0), (void*)value);
}
inline static int32_t get_offset_of_parentObjectIsInObjectCollection_1() { return static_cast<int32_t>(offsetof(EventHandlerEntry_tD4B30F35FCE99CEB4F1BFF88A3F5FA0407C3C927, ___parentObjectIsInObjectCollection_1)); }
inline bool get_parentObjectIsInObjectCollection_1() const { return ___parentObjectIsInObjectCollection_1; }
inline bool* get_address_of_parentObjectIsInObjectCollection_1() { return &___parentObjectIsInObjectCollection_1; }
inline void set_parentObjectIsInObjectCollection_1(bool value)
{
___parentObjectIsInObjectCollection_1 = value;
}
};
// Native definition for P/Invoke marshalling of Microsoft.MixedReality.Toolkit.BaseEventSystem/EventHandlerEntry
struct EventHandlerEntry_tD4B30F35FCE99CEB4F1BFF88A3F5FA0407C3C927_marshaled_pinvoke
{
RuntimeObject* ___handler_0;
int32_t ___parentObjectIsInObjectCollection_1;
};
// Native definition for COM marshalling of Microsoft.MixedReality.Toolkit.BaseEventSystem/EventHandlerEntry
struct EventHandlerEntry_tD4B30F35FCE99CEB4F1BFF88A3F5FA0407C3C927_marshaled_com
{
RuntimeObject* ___handler_0;
int32_t ___parentObjectIsInObjectCollection_1;
};
// UnityEngine.BeforeRenderHelper/OrderBlock
struct OrderBlock_t0B106828F588BC2F0B9895425E6FD39EDA45C1E2
{
public:
// System.Int32 UnityEngine.BeforeRenderHelper/OrderBlock::order
int32_t ___order_0;
// UnityEngine.Events.UnityAction UnityEngine.BeforeRenderHelper/OrderBlock::callback
UnityAction_t22E545F8BE0A62EE051C6A83E209587A0DB1C099 * ___callback_1;
public:
inline static int32_t get_offset_of_order_0() { return static_cast<int32_t>(offsetof(OrderBlock_t0B106828F588BC2F0B9895425E6FD39EDA45C1E2, ___order_0)); }
inline int32_t get_order_0() const { return ___order_0; }
inline int32_t* get_address_of_order_0() { return &___order_0; }
inline void set_order_0(int32_t value)
{
___order_0 = value;
}
inline static int32_t get_offset_of_callback_1() { return static_cast<int32_t>(offsetof(OrderBlock_t0B106828F588BC2F0B9895425E6FD39EDA45C1E2, ___callback_1)); }
inline UnityAction_t22E545F8BE0A62EE051C6A83E209587A0DB1C099 * get_callback_1() const { return ___callback_1; }
inline UnityAction_t22E545F8BE0A62EE051C6A83E209587A0DB1C099 ** get_address_of_callback_1() { return &___callback_1; }
inline void set_callback_1(UnityAction_t22E545F8BE0A62EE051C6A83E209587A0DB1C099 * value)
{
___callback_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___callback_1), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.BeforeRenderHelper/OrderBlock
struct OrderBlock_t0B106828F588BC2F0B9895425E6FD39EDA45C1E2_marshaled_pinvoke
{
int32_t ___order_0;
Il2CppMethodPointer ___callback_1;
};
// Native definition for COM marshalling of UnityEngine.BeforeRenderHelper/OrderBlock
struct OrderBlock_t0B106828F588BC2F0B9895425E6FD39EDA45C1E2_marshaled_com
{
int32_t ___order_0;
Il2CppMethodPointer ___callback_1;
};
// Microsoft.MixedReality.Toolkit.UI.InteractableColorChildrenTheme/BlocksAndRenderer
struct BlocksAndRenderer_tF583D143167DBC0C9BA5575BCE054D11CD059F0C
{
public:
// UnityEngine.MaterialPropertyBlock Microsoft.MixedReality.Toolkit.UI.InteractableColorChildrenTheme/BlocksAndRenderer::Block
MaterialPropertyBlock_t6C45FC5DE951DA662BBB7A55EEB3DEF33C5431A0 * ___Block_0;
// UnityEngine.Renderer Microsoft.MixedReality.Toolkit.UI.InteractableColorChildrenTheme/BlocksAndRenderer::Renderer
Renderer_t58147AB5B00224FE1460FD47542DC0DA7EC9378C * ___Renderer_1;
public:
inline static int32_t get_offset_of_Block_0() { return static_cast<int32_t>(offsetof(BlocksAndRenderer_tF583D143167DBC0C9BA5575BCE054D11CD059F0C, ___Block_0)); }
inline MaterialPropertyBlock_t6C45FC5DE951DA662BBB7A55EEB3DEF33C5431A0 * get_Block_0() const { return ___Block_0; }
inline MaterialPropertyBlock_t6C45FC5DE951DA662BBB7A55EEB3DEF33C5431A0 ** get_address_of_Block_0() { return &___Block_0; }
inline void set_Block_0(MaterialPropertyBlock_t6C45FC5DE951DA662BBB7A55EEB3DEF33C5431A0 * value)
{
___Block_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Block_0), (void*)value);
}
inline static int32_t get_offset_of_Renderer_1() { return static_cast<int32_t>(offsetof(BlocksAndRenderer_tF583D143167DBC0C9BA5575BCE054D11CD059F0C, ___Renderer_1)); }
inline Renderer_t58147AB5B00224FE1460FD47542DC0DA7EC9378C * get_Renderer_1() const { return ___Renderer_1; }
inline Renderer_t58147AB5B00224FE1460FD47542DC0DA7EC9378C ** get_address_of_Renderer_1() { return &___Renderer_1; }
inline void set_Renderer_1(Renderer_t58147AB5B00224FE1460FD47542DC0DA7EC9378C * value)
{
___Renderer_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Renderer_1), (void*)value);
}
};
// Native definition for P/Invoke marshalling of Microsoft.MixedReality.Toolkit.UI.InteractableColorChildrenTheme/BlocksAndRenderer
struct BlocksAndRenderer_tF583D143167DBC0C9BA5575BCE054D11CD059F0C_marshaled_pinvoke
{
MaterialPropertyBlock_t6C45FC5DE951DA662BBB7A55EEB3DEF33C5431A0 * ___Block_0;
Renderer_t58147AB5B00224FE1460FD47542DC0DA7EC9378C * ___Renderer_1;
};
// Native definition for COM marshalling of Microsoft.MixedReality.Toolkit.UI.InteractableColorChildrenTheme/BlocksAndRenderer
struct BlocksAndRenderer_tF583D143167DBC0C9BA5575BCE054D11CD059F0C_marshaled_com
{
MaterialPropertyBlock_t6C45FC5DE951DA662BBB7A55EEB3DEF33C5431A0 * ___Block_0;
Renderer_t58147AB5B00224FE1460FD47542DC0DA7EC9378C * ___Renderer_1;
};
// UnityEngine.XR.MagicLeap.MLAppConnect/MicrophoneEventInfo
struct MicrophoneEventInfo_t436D3A8AC50B8EA7F08628301510BA2CCD3BCD42
{
public:
// System.UInt32 UnityEngine.XR.MagicLeap.MLAppConnect/MicrophoneEventInfo::Version
uint32_t ___Version_0;
// System.String UnityEngine.XR.MagicLeap.MLAppConnect/MicrophoneEventInfo::UserName
String_t* ___UserName_1;
public:
inline static int32_t get_offset_of_Version_0() { return static_cast<int32_t>(offsetof(MicrophoneEventInfo_t436D3A8AC50B8EA7F08628301510BA2CCD3BCD42, ___Version_0)); }
inline uint32_t get_Version_0() const { return ___Version_0; }
inline uint32_t* get_address_of_Version_0() { return &___Version_0; }
inline void set_Version_0(uint32_t value)
{
___Version_0 = value;
}
inline static int32_t get_offset_of_UserName_1() { return static_cast<int32_t>(offsetof(MicrophoneEventInfo_t436D3A8AC50B8EA7F08628301510BA2CCD3BCD42, ___UserName_1)); }
inline String_t* get_UserName_1() const { return ___UserName_1; }
inline String_t** get_address_of_UserName_1() { return &___UserName_1; }
inline void set_UserName_1(String_t* value)
{
___UserName_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___UserName_1), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MagicLeap.MLAppConnect/MicrophoneEventInfo
struct MicrophoneEventInfo_t436D3A8AC50B8EA7F08628301510BA2CCD3BCD42_marshaled_pinvoke
{
uint32_t ___Version_0;
char* ___UserName_1;
};
// Native definition for COM marshalling of UnityEngine.XR.MagicLeap.MLAppConnect/MicrophoneEventInfo
struct MicrophoneEventInfo_t436D3A8AC50B8EA7F08628301510BA2CCD3BCD42_marshaled_com
{
uint32_t ___Version_0;
char* ___UserName_1;
};
// UnityEngine.XR.MagicLeap.MLAppConnect/UserEventInfo
struct UserEventInfo_tFC25DD77EA4674A99AA0D54F2A5772E796437777
{
public:
// System.UInt32 UnityEngine.XR.MagicLeap.MLAppConnect/UserEventInfo::Version
uint32_t ___Version_0;
// System.String UnityEngine.XR.MagicLeap.MLAppConnect/UserEventInfo::UserName
String_t* ___UserName_1;
// System.String UnityEngine.XR.MagicLeap.MLAppConnect/UserEventInfo::Status
String_t* ___Status_2;
public:
inline static int32_t get_offset_of_Version_0() { return static_cast<int32_t>(offsetof(UserEventInfo_tFC25DD77EA4674A99AA0D54F2A5772E796437777, ___Version_0)); }
inline uint32_t get_Version_0() const { return ___Version_0; }
inline uint32_t* get_address_of_Version_0() { return &___Version_0; }
inline void set_Version_0(uint32_t value)
{
___Version_0 = value;
}
inline static int32_t get_offset_of_UserName_1() { return static_cast<int32_t>(offsetof(UserEventInfo_tFC25DD77EA4674A99AA0D54F2A5772E796437777, ___UserName_1)); }
inline String_t* get_UserName_1() const { return ___UserName_1; }
inline String_t** get_address_of_UserName_1() { return &___UserName_1; }
inline void set_UserName_1(String_t* value)
{
___UserName_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___UserName_1), (void*)value);
}
inline static int32_t get_offset_of_Status_2() { return static_cast<int32_t>(offsetof(UserEventInfo_tFC25DD77EA4674A99AA0D54F2A5772E796437777, ___Status_2)); }
inline String_t* get_Status_2() const { return ___Status_2; }
inline String_t** get_address_of_Status_2() { return &___Status_2; }
inline void set_Status_2(String_t* value)
{
___Status_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Status_2), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MagicLeap.MLAppConnect/UserEventInfo
struct UserEventInfo_tFC25DD77EA4674A99AA0D54F2A5772E796437777_marshaled_pinvoke
{
uint32_t ___Version_0;
char* ___UserName_1;
char* ___Status_2;
};
// Native definition for COM marshalling of UnityEngine.XR.MagicLeap.MLAppConnect/UserEventInfo
struct UserEventInfo_tFC25DD77EA4674A99AA0D54F2A5772E796437777_marshaled_com
{
uint32_t ___Version_0;
char* ___UserName_1;
char* ___Status_2;
};
// UnityEngine.XR.MagicLeap.MLCoordinateFrameUID/<data>e__FixedBuffer
struct U3CdataU3Ee__FixedBuffer_t9C20A467F80740C3FBC07EC06843565A49351FB6
{
public:
union
{
struct
{
// System.UInt64 UnityEngine.XR.MagicLeap.MLCoordinateFrameUID/<data>e__FixedBuffer::FixedElementField
uint64_t ___FixedElementField_0;
};
uint8_t U3CdataU3Ee__FixedBuffer_t9C20A467F80740C3FBC07EC06843565A49351FB6__padding[16];
};
public:
inline static int32_t get_offset_of_FixedElementField_0() { return static_cast<int32_t>(offsetof(U3CdataU3Ee__FixedBuffer_t9C20A467F80740C3FBC07EC06843565A49351FB6, ___FixedElementField_0)); }
inline uint64_t get_FixedElementField_0() const { return ___FixedElementField_0; }
inline uint64_t* get_address_of_FixedElementField_0() { return &___FixedElementField_0; }
inline void set_FixedElementField_0(uint64_t value)
{
___FixedElementField_0 = value;
}
};
// UnityEngine.XR.MagicLeap.MLDispatch/OAuthPair
struct OAuthPair_t6862D91D872AA10E48A8FFB13C4B2D677ACE6FC0
{
public:
// System.String UnityEngine.XR.MagicLeap.MLDispatch/OAuthPair::Schema
String_t* ___Schema_0;
// UnityEngine.XR.MagicLeap.MLDispatch/OAuthHandler UnityEngine.XR.MagicLeap.MLDispatch/OAuthPair::Callback
OAuthHandler_t3B1901EF51E905EF87344BA6AD7223C9127914C7 * ___Callback_1;
public:
inline static int32_t get_offset_of_Schema_0() { return static_cast<int32_t>(offsetof(OAuthPair_t6862D91D872AA10E48A8FFB13C4B2D677ACE6FC0, ___Schema_0)); }
inline String_t* get_Schema_0() const { return ___Schema_0; }
inline String_t** get_address_of_Schema_0() { return &___Schema_0; }
inline void set_Schema_0(String_t* value)
{
___Schema_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Schema_0), (void*)value);
}
inline static int32_t get_offset_of_Callback_1() { return static_cast<int32_t>(offsetof(OAuthPair_t6862D91D872AA10E48A8FFB13C4B2D677ACE6FC0, ___Callback_1)); }
inline OAuthHandler_t3B1901EF51E905EF87344BA6AD7223C9127914C7 * get_Callback_1() const { return ___Callback_1; }
inline OAuthHandler_t3B1901EF51E905EF87344BA6AD7223C9127914C7 ** get_address_of_Callback_1() { return &___Callback_1; }
inline void set_Callback_1(OAuthHandler_t3B1901EF51E905EF87344BA6AD7223C9127914C7 * value)
{
___Callback_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Callback_1), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MagicLeap.MLDispatch/OAuthPair
struct OAuthPair_t6862D91D872AA10E48A8FFB13C4B2D677ACE6FC0_marshaled_pinvoke
{
char* ___Schema_0;
Il2CppMethodPointer ___Callback_1;
};
// Native definition for COM marshalling of UnityEngine.XR.MagicLeap.MLDispatch/OAuthPair
struct OAuthPair_t6862D91D872AA10E48A8FFB13C4B2D677ACE6FC0_marshaled_com
{
Il2CppChar* ___Schema_0;
Il2CppMethodPointer ___Callback_1;
};
// UnityEngine.XR.MagicLeap.MLHandMeshing/Mesh
struct Mesh_t2F73AAA4971480C39E8BC56781D08C22A7DC5F0C
{
public:
// UnityEngine.XR.MagicLeap.MLHandMeshing/Mesh/Block[] UnityEngine.XR.MagicLeap.MLHandMeshing/Mesh::<MeshBlock>k__BackingField
BlockU5BU5D_tF12A3EC47CD39550BDB4B5CD7AD65F79F5601113* ___U3CMeshBlockU3Ek__BackingField_0;
public:
inline static int32_t get_offset_of_U3CMeshBlockU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(Mesh_t2F73AAA4971480C39E8BC56781D08C22A7DC5F0C, ___U3CMeshBlockU3Ek__BackingField_0)); }
inline BlockU5BU5D_tF12A3EC47CD39550BDB4B5CD7AD65F79F5601113* get_U3CMeshBlockU3Ek__BackingField_0() const { return ___U3CMeshBlockU3Ek__BackingField_0; }
inline BlockU5BU5D_tF12A3EC47CD39550BDB4B5CD7AD65F79F5601113** get_address_of_U3CMeshBlockU3Ek__BackingField_0() { return &___U3CMeshBlockU3Ek__BackingField_0; }
inline void set_U3CMeshBlockU3Ek__BackingField_0(BlockU5BU5D_tF12A3EC47CD39550BDB4B5CD7AD65F79F5601113* value)
{
___U3CMeshBlockU3Ek__BackingField_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CMeshBlockU3Ek__BackingField_0), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MagicLeap.MLHandMeshing/Mesh
struct Mesh_t2F73AAA4971480C39E8BC56781D08C22A7DC5F0C_marshaled_pinvoke
{
Block_tBDA4C589DF3FAA41A92D19E5CC013C74B4F83EC0_marshaled_pinvoke* ___U3CMeshBlockU3Ek__BackingField_0;
};
// Native definition for COM marshalling of UnityEngine.XR.MagicLeap.MLHandMeshing/Mesh
struct Mesh_t2F73AAA4971480C39E8BC56781D08C22A7DC5F0C_marshaled_com
{
Block_tBDA4C589DF3FAA41A92D19E5CC013C74B4F83EC0_marshaled_com* ___U3CMeshBlockU3Ek__BackingField_0;
};
// UnityEngine.XR.MagicLeap.MLMediaPlayer/Cea608CaptionSegment
struct Cea608CaptionSegment_t6F927E35AC06808226EFA60FE3824A954CCC70EE
{
public:
// UnityEngine.XR.MagicLeap.MLMediaPlayer/Cea608CaptionLine[] UnityEngine.XR.MagicLeap.MLMediaPlayer/Cea608CaptionSegment::CCLines
Cea608CaptionLineU5BU5D_tD5903054F45675025C96AE02F39A8BA8C6599182* ___CCLines_0;
public:
inline static int32_t get_offset_of_CCLines_0() { return static_cast<int32_t>(offsetof(Cea608CaptionSegment_t6F927E35AC06808226EFA60FE3824A954CCC70EE, ___CCLines_0)); }
inline Cea608CaptionLineU5BU5D_tD5903054F45675025C96AE02F39A8BA8C6599182* get_CCLines_0() const { return ___CCLines_0; }
inline Cea608CaptionLineU5BU5D_tD5903054F45675025C96AE02F39A8BA8C6599182** get_address_of_CCLines_0() { return &___CCLines_0; }
inline void set_CCLines_0(Cea608CaptionLineU5BU5D_tD5903054F45675025C96AE02F39A8BA8C6599182* value)
{
___CCLines_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___CCLines_0), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MagicLeap.MLMediaPlayer/Cea608CaptionSegment
struct Cea608CaptionSegment_t6F927E35AC06808226EFA60FE3824A954CCC70EE_marshaled_pinvoke
{
Cea608CaptionLineU5BU5D_tD5903054F45675025C96AE02F39A8BA8C6599182* ___CCLines_0;
};
// Native definition for COM marshalling of UnityEngine.XR.MagicLeap.MLMediaPlayer/Cea608CaptionSegment
struct Cea608CaptionSegment_t6F927E35AC06808226EFA60FE3824A954CCC70EE_marshaled_com
{
Cea608CaptionLineU5BU5D_tD5903054F45675025C96AE02F39A8BA8C6599182* ___CCLines_0;
};
// UnityEngine.XR.MagicLeap.MLMusicService/Metadata
struct Metadata_t07980C3F5037AD27F0828FC795343DBB860E7AD4
{
public:
// System.String UnityEngine.XR.MagicLeap.MLMusicService/Metadata::TrackTitle
String_t* ___TrackTitle_0;
// System.String UnityEngine.XR.MagicLeap.MLMusicService/Metadata::AlbumInfoName
String_t* ___AlbumInfoName_1;
// System.String UnityEngine.XR.MagicLeap.MLMusicService/Metadata::AlbumInfoUrl
String_t* ___AlbumInfoUrl_2;
// System.String UnityEngine.XR.MagicLeap.MLMusicService/Metadata::AlbumInfoCoverUrl
String_t* ___AlbumInfoCoverUrl_3;
// System.String UnityEngine.XR.MagicLeap.MLMusicService/Metadata::ArtistInfoName
String_t* ___ArtistInfoName_4;
// System.String UnityEngine.XR.MagicLeap.MLMusicService/Metadata::ArtistInfoUrl
String_t* ___ArtistInfoUrl_5;
// System.UInt32 UnityEngine.XR.MagicLeap.MLMusicService/Metadata::Length
uint32_t ___Length_6;
public:
inline static int32_t get_offset_of_TrackTitle_0() { return static_cast<int32_t>(offsetof(Metadata_t07980C3F5037AD27F0828FC795343DBB860E7AD4, ___TrackTitle_0)); }
inline String_t* get_TrackTitle_0() const { return ___TrackTitle_0; }
inline String_t** get_address_of_TrackTitle_0() { return &___TrackTitle_0; }
inline void set_TrackTitle_0(String_t* value)
{
___TrackTitle_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___TrackTitle_0), (void*)value);
}
inline static int32_t get_offset_of_AlbumInfoName_1() { return static_cast<int32_t>(offsetof(Metadata_t07980C3F5037AD27F0828FC795343DBB860E7AD4, ___AlbumInfoName_1)); }
inline String_t* get_AlbumInfoName_1() const { return ___AlbumInfoName_1; }
inline String_t** get_address_of_AlbumInfoName_1() { return &___AlbumInfoName_1; }
inline void set_AlbumInfoName_1(String_t* value)
{
___AlbumInfoName_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___AlbumInfoName_1), (void*)value);
}
inline static int32_t get_offset_of_AlbumInfoUrl_2() { return static_cast<int32_t>(offsetof(Metadata_t07980C3F5037AD27F0828FC795343DBB860E7AD4, ___AlbumInfoUrl_2)); }
inline String_t* get_AlbumInfoUrl_2() const { return ___AlbumInfoUrl_2; }
inline String_t** get_address_of_AlbumInfoUrl_2() { return &___AlbumInfoUrl_2; }
inline void set_AlbumInfoUrl_2(String_t* value)
{
___AlbumInfoUrl_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___AlbumInfoUrl_2), (void*)value);
}
inline static int32_t get_offset_of_AlbumInfoCoverUrl_3() { return static_cast<int32_t>(offsetof(Metadata_t07980C3F5037AD27F0828FC795343DBB860E7AD4, ___AlbumInfoCoverUrl_3)); }
inline String_t* get_AlbumInfoCoverUrl_3() const { return ___AlbumInfoCoverUrl_3; }
inline String_t** get_address_of_AlbumInfoCoverUrl_3() { return &___AlbumInfoCoverUrl_3; }
inline void set_AlbumInfoCoverUrl_3(String_t* value)
{
___AlbumInfoCoverUrl_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___AlbumInfoCoverUrl_3), (void*)value);
}
inline static int32_t get_offset_of_ArtistInfoName_4() { return static_cast<int32_t>(offsetof(Metadata_t07980C3F5037AD27F0828FC795343DBB860E7AD4, ___ArtistInfoName_4)); }
inline String_t* get_ArtistInfoName_4() const { return ___ArtistInfoName_4; }
inline String_t** get_address_of_ArtistInfoName_4() { return &___ArtistInfoName_4; }
inline void set_ArtistInfoName_4(String_t* value)
{
___ArtistInfoName_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___ArtistInfoName_4), (void*)value);
}
inline static int32_t get_offset_of_ArtistInfoUrl_5() { return static_cast<int32_t>(offsetof(Metadata_t07980C3F5037AD27F0828FC795343DBB860E7AD4, ___ArtistInfoUrl_5)); }
inline String_t* get_ArtistInfoUrl_5() const { return ___ArtistInfoUrl_5; }
inline String_t** get_address_of_ArtistInfoUrl_5() { return &___ArtistInfoUrl_5; }
inline void set_ArtistInfoUrl_5(String_t* value)
{
___ArtistInfoUrl_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___ArtistInfoUrl_5), (void*)value);
}
inline static int32_t get_offset_of_Length_6() { return static_cast<int32_t>(offsetof(Metadata_t07980C3F5037AD27F0828FC795343DBB860E7AD4, ___Length_6)); }
inline uint32_t get_Length_6() const { return ___Length_6; }
inline uint32_t* get_address_of_Length_6() { return &___Length_6; }
inline void set_Length_6(uint32_t value)
{
___Length_6 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MagicLeap.MLMusicService/Metadata
struct Metadata_t07980C3F5037AD27F0828FC795343DBB860E7AD4_marshaled_pinvoke
{
char* ___TrackTitle_0;
char* ___AlbumInfoName_1;
char* ___AlbumInfoUrl_2;
char* ___AlbumInfoCoverUrl_3;
char* ___ArtistInfoName_4;
char* ___ArtistInfoUrl_5;
uint32_t ___Length_6;
};
// Native definition for COM marshalling of UnityEngine.XR.MagicLeap.MLMusicService/Metadata
struct Metadata_t07980C3F5037AD27F0828FC795343DBB860E7AD4_marshaled_com
{
Il2CppChar* ___TrackTitle_0;
Il2CppChar* ___AlbumInfoName_1;
Il2CppChar* ___AlbumInfoUrl_2;
Il2CppChar* ___AlbumInfoCoverUrl_3;
Il2CppChar* ___ArtistInfoName_4;
Il2CppChar* ___ArtistInfoUrl_5;
uint32_t ___Length_6;
};
// UnityEngine.XR.MagicLeap.MLWebRTC/IceCandidate
struct IceCandidate_tB24683852F651BE72764839BCB14E52F11411253
{
public:
// System.String UnityEngine.XR.MagicLeap.MLWebRTC/IceCandidate::<Candidate>k__BackingField
String_t* ___U3CCandidateU3Ek__BackingField_0;
// System.String UnityEngine.XR.MagicLeap.MLWebRTC/IceCandidate::<SdpMid>k__BackingField
String_t* ___U3CSdpMidU3Ek__BackingField_1;
// System.Int32 UnityEngine.XR.MagicLeap.MLWebRTC/IceCandidate::<SdpMLineIndex>k__BackingField
int32_t ___U3CSdpMLineIndexU3Ek__BackingField_2;
public:
inline static int32_t get_offset_of_U3CCandidateU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(IceCandidate_tB24683852F651BE72764839BCB14E52F11411253, ___U3CCandidateU3Ek__BackingField_0)); }
inline String_t* get_U3CCandidateU3Ek__BackingField_0() const { return ___U3CCandidateU3Ek__BackingField_0; }
inline String_t** get_address_of_U3CCandidateU3Ek__BackingField_0() { return &___U3CCandidateU3Ek__BackingField_0; }
inline void set_U3CCandidateU3Ek__BackingField_0(String_t* value)
{
___U3CCandidateU3Ek__BackingField_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CCandidateU3Ek__BackingField_0), (void*)value);
}
inline static int32_t get_offset_of_U3CSdpMidU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(IceCandidate_tB24683852F651BE72764839BCB14E52F11411253, ___U3CSdpMidU3Ek__BackingField_1)); }
inline String_t* get_U3CSdpMidU3Ek__BackingField_1() const { return ___U3CSdpMidU3Ek__BackingField_1; }
inline String_t** get_address_of_U3CSdpMidU3Ek__BackingField_1() { return &___U3CSdpMidU3Ek__BackingField_1; }
inline void set_U3CSdpMidU3Ek__BackingField_1(String_t* value)
{
___U3CSdpMidU3Ek__BackingField_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CSdpMidU3Ek__BackingField_1), (void*)value);
}
inline static int32_t get_offset_of_U3CSdpMLineIndexU3Ek__BackingField_2() { return static_cast<int32_t>(offsetof(IceCandidate_tB24683852F651BE72764839BCB14E52F11411253, ___U3CSdpMLineIndexU3Ek__BackingField_2)); }
inline int32_t get_U3CSdpMLineIndexU3Ek__BackingField_2() const { return ___U3CSdpMLineIndexU3Ek__BackingField_2; }
inline int32_t* get_address_of_U3CSdpMLineIndexU3Ek__BackingField_2() { return &___U3CSdpMLineIndexU3Ek__BackingField_2; }
inline void set_U3CSdpMLineIndexU3Ek__BackingField_2(int32_t value)
{
___U3CSdpMLineIndexU3Ek__BackingField_2 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MagicLeap.MLWebRTC/IceCandidate
struct IceCandidate_tB24683852F651BE72764839BCB14E52F11411253_marshaled_pinvoke
{
char* ___U3CCandidateU3Ek__BackingField_0;
char* ___U3CSdpMidU3Ek__BackingField_1;
int32_t ___U3CSdpMLineIndexU3Ek__BackingField_2;
};
// Native definition for COM marshalling of UnityEngine.XR.MagicLeap.MLWebRTC/IceCandidate
struct IceCandidate_tB24683852F651BE72764839BCB14E52F11411253_marshaled_com
{
Il2CppChar* ___U3CCandidateU3Ek__BackingField_0;
Il2CppChar* ___U3CSdpMidU3Ek__BackingField_1;
int32_t ___U3CSdpMLineIndexU3Ek__BackingField_2;
};
// UnityEngine.XR.MagicLeap.Native.MagicLeapNativeBindings/MLCoordinateFrameUID
struct MLCoordinateFrameUID_t7ADFCEC93CA8B3DDFB41EC8157D03B51D0611AC9
{
public:
// System.UInt64 UnityEngine.XR.MagicLeap.Native.MagicLeapNativeBindings/MLCoordinateFrameUID::First
uint64_t ___First_0;
// System.UInt64 UnityEngine.XR.MagicLeap.Native.MagicLeapNativeBindings/MLCoordinateFrameUID::Second
uint64_t ___Second_1;
public:
inline static int32_t get_offset_of_First_0() { return static_cast<int32_t>(offsetof(MLCoordinateFrameUID_t7ADFCEC93CA8B3DDFB41EC8157D03B51D0611AC9, ___First_0)); }
inline uint64_t get_First_0() const { return ___First_0; }
inline uint64_t* get_address_of_First_0() { return &___First_0; }
inline void set_First_0(uint64_t value)
{
___First_0 = value;
}
inline static int32_t get_offset_of_Second_1() { return static_cast<int32_t>(offsetof(MLCoordinateFrameUID_t7ADFCEC93CA8B3DDFB41EC8157D03B51D0611AC9, ___Second_1)); }
inline uint64_t get_Second_1() const { return ___Second_1; }
inline uint64_t* get_address_of_Second_1() { return &___Second_1; }
inline void set_Second_1(uint64_t value)
{
___Second_1 = value;
}
};
// UnityEngine.XR.MagicLeap.Native.MagicLeapNativeBindings/MLVec3f
struct MLVec3f_tABDB2B7D293736251D00845A7551060DB2CB1952
{
public:
// System.Single UnityEngine.XR.MagicLeap.Native.MagicLeapNativeBindings/MLVec3f::X
float ___X_0;
// System.Single UnityEngine.XR.MagicLeap.Native.MagicLeapNativeBindings/MLVec3f::Y
float ___Y_1;
// System.Single UnityEngine.XR.MagicLeap.Native.MagicLeapNativeBindings/MLVec3f::Z
float ___Z_2;
public:
inline static int32_t get_offset_of_X_0() { return static_cast<int32_t>(offsetof(MLVec3f_tABDB2B7D293736251D00845A7551060DB2CB1952, ___X_0)); }
inline float get_X_0() const { return ___X_0; }
inline float* get_address_of_X_0() { return &___X_0; }
inline void set_X_0(float value)
{
___X_0 = value;
}
inline static int32_t get_offset_of_Y_1() { return static_cast<int32_t>(offsetof(MLVec3f_tABDB2B7D293736251D00845A7551060DB2CB1952, ___Y_1)); }
inline float get_Y_1() const { return ___Y_1; }
inline float* get_address_of_Y_1() { return &___Y_1; }
inline void set_Y_1(float value)
{
___Y_1 = value;
}
inline static int32_t get_offset_of_Z_2() { return static_cast<int32_t>(offsetof(MLVec3f_tABDB2B7D293736251D00845A7551060DB2CB1952, ___Z_2)); }
inline float get_Z_2() const { return ___Z_2; }
inline float* get_address_of_Z_2() { return &___Z_2; }
inline void set_Z_2(float value)
{
___Z_2 = value;
}
};
// System.IO.Stream/ReadWriteParameters
struct ReadWriteParameters_tA71BF6299932C54DB368B7F5A9BDD9C70908BC47
{
public:
// System.Byte[] System.IO.Stream/ReadWriteParameters::Buffer
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* ___Buffer_0;
// System.Int32 System.IO.Stream/ReadWriteParameters::Offset
int32_t ___Offset_1;
// System.Int32 System.IO.Stream/ReadWriteParameters::Count
int32_t ___Count_2;
public:
inline static int32_t get_offset_of_Buffer_0() { return static_cast<int32_t>(offsetof(ReadWriteParameters_tA71BF6299932C54DB368B7F5A9BDD9C70908BC47, ___Buffer_0)); }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* get_Buffer_0() const { return ___Buffer_0; }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726** get_address_of_Buffer_0() { return &___Buffer_0; }
inline void set_Buffer_0(ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* value)
{
___Buffer_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Buffer_0), (void*)value);
}
inline static int32_t get_offset_of_Offset_1() { return static_cast<int32_t>(offsetof(ReadWriteParameters_tA71BF6299932C54DB368B7F5A9BDD9C70908BC47, ___Offset_1)); }
inline int32_t get_Offset_1() const { return ___Offset_1; }
inline int32_t* get_address_of_Offset_1() { return &___Offset_1; }
inline void set_Offset_1(int32_t value)
{
___Offset_1 = value;
}
inline static int32_t get_offset_of_Count_2() { return static_cast<int32_t>(offsetof(ReadWriteParameters_tA71BF6299932C54DB368B7F5A9BDD9C70908BC47, ___Count_2)); }
inline int32_t get_Count_2() const { return ___Count_2; }
inline int32_t* get_address_of_Count_2() { return &___Count_2; }
inline void set_Count_2(int32_t value)
{
___Count_2 = value;
}
};
// Native definition for P/Invoke marshalling of System.IO.Stream/ReadWriteParameters
struct ReadWriteParameters_tA71BF6299932C54DB368B7F5A9BDD9C70908BC47_marshaled_pinvoke
{
Il2CppSafeArray/*NONE*/* ___Buffer_0;
int32_t ___Offset_1;
int32_t ___Count_2;
};
// Native definition for COM marshalling of System.IO.Stream/ReadWriteParameters
struct ReadWriteParameters_tA71BF6299932C54DB368B7F5A9BDD9C70908BC47_marshaled_com
{
Il2CppSafeArray/*NONE*/* ___Buffer_0;
int32_t ___Offset_1;
int32_t ___Count_2;
};
// TMPro.SpriteAssetUtilities.TexturePacker_JsonArray/SpriteFrame
struct SpriteFrame_t5B610F44C5943B89962CC8CC4245EECDE29E94D9
{
public:
// System.Single TMPro.SpriteAssetUtilities.TexturePacker_JsonArray/SpriteFrame::x
float ___x_0;
// System.Single TMPro.SpriteAssetUtilities.TexturePacker_JsonArray/SpriteFrame::y
float ___y_1;
// System.Single TMPro.SpriteAssetUtilities.TexturePacker_JsonArray/SpriteFrame::w
float ___w_2;
// System.Single TMPro.SpriteAssetUtilities.TexturePacker_JsonArray/SpriteFrame::h
float ___h_3;
public:
inline static int32_t get_offset_of_x_0() { return static_cast<int32_t>(offsetof(SpriteFrame_t5B610F44C5943B89962CC8CC4245EECDE29E94D9, ___x_0)); }
inline float get_x_0() const { return ___x_0; }
inline float* get_address_of_x_0() { return &___x_0; }
inline void set_x_0(float value)
{
___x_0 = value;
}
inline static int32_t get_offset_of_y_1() { return static_cast<int32_t>(offsetof(SpriteFrame_t5B610F44C5943B89962CC8CC4245EECDE29E94D9, ___y_1)); }
inline float get_y_1() const { return ___y_1; }
inline float* get_address_of_y_1() { return &___y_1; }
inline void set_y_1(float value)
{
___y_1 = value;
}
inline static int32_t get_offset_of_w_2() { return static_cast<int32_t>(offsetof(SpriteFrame_t5B610F44C5943B89962CC8CC4245EECDE29E94D9, ___w_2)); }
inline float get_w_2() const { return ___w_2; }
inline float* get_address_of_w_2() { return &___w_2; }
inline void set_w_2(float value)
{
___w_2 = value;
}
inline static int32_t get_offset_of_h_3() { return static_cast<int32_t>(offsetof(SpriteFrame_t5B610F44C5943B89962CC8CC4245EECDE29E94D9, ___h_3)); }
inline float get_h_3() const { return ___h_3; }
inline float* get_address_of_h_3() { return &___h_3; }
inline void set_h_3(float value)
{
___h_3 = value;
}
};
// TMPro.SpriteAssetUtilities.TexturePacker_JsonArray/SpriteSize
struct SpriteSize_t7D47B39A52139B8CD3CE7F233C48981F70275A3D
{
public:
// System.Single TMPro.SpriteAssetUtilities.TexturePacker_JsonArray/SpriteSize::w
float ___w_0;
// System.Single TMPro.SpriteAssetUtilities.TexturePacker_JsonArray/SpriteSize::h
float ___h_1;
public:
inline static int32_t get_offset_of_w_0() { return static_cast<int32_t>(offsetof(SpriteSize_t7D47B39A52139B8CD3CE7F233C48981F70275A3D, ___w_0)); }
inline float get_w_0() const { return ___w_0; }
inline float* get_address_of_w_0() { return &___w_0; }
inline void set_w_0(float value)
{
___w_0 = value;
}
inline static int32_t get_offset_of_h_1() { return static_cast<int32_t>(offsetof(SpriteSize_t7D47B39A52139B8CD3CE7F233C48981F70275A3D, ___h_1)); }
inline float get_h_1() const { return ___h_1; }
inline float* get_address_of_h_1() { return &___h_1; }
inline void set_h_1(float value)
{
___h_1 = value;
}
};
// UnityEngine.SpatialTracking.TrackedPoseDriverDataDescription/PoseData
struct PoseData_t3F5C8C74C50A6ECAE42890BBEF683882DB4E97C3
{
public:
// System.Collections.Generic.List`1<System.String> UnityEngine.SpatialTracking.TrackedPoseDriverDataDescription/PoseData::PoseNames
List_1_t6C9F81EDBF0F4A31A9B0DA372D2EF34BDA3A1AF3 * ___PoseNames_0;
// System.Collections.Generic.List`1<UnityEngine.SpatialTracking.TrackedPoseDriver/TrackedPose> UnityEngine.SpatialTracking.TrackedPoseDriverDataDescription/PoseData::Poses
List_1_tA9A7E2A508B3146A7DE46E73A64E988FE4BD5248 * ___Poses_1;
public:
inline static int32_t get_offset_of_PoseNames_0() { return static_cast<int32_t>(offsetof(PoseData_t3F5C8C74C50A6ECAE42890BBEF683882DB4E97C3, ___PoseNames_0)); }
inline List_1_t6C9F81EDBF0F4A31A9B0DA372D2EF34BDA3A1AF3 * get_PoseNames_0() const { return ___PoseNames_0; }
inline List_1_t6C9F81EDBF0F4A31A9B0DA372D2EF34BDA3A1AF3 ** get_address_of_PoseNames_0() { return &___PoseNames_0; }
inline void set_PoseNames_0(List_1_t6C9F81EDBF0F4A31A9B0DA372D2EF34BDA3A1AF3 * value)
{
___PoseNames_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___PoseNames_0), (void*)value);
}
inline static int32_t get_offset_of_Poses_1() { return static_cast<int32_t>(offsetof(PoseData_t3F5C8C74C50A6ECAE42890BBEF683882DB4E97C3, ___Poses_1)); }
inline List_1_tA9A7E2A508B3146A7DE46E73A64E988FE4BD5248 * get_Poses_1() const { return ___Poses_1; }
inline List_1_tA9A7E2A508B3146A7DE46E73A64E988FE4BD5248 ** get_address_of_Poses_1() { return &___Poses_1; }
inline void set_Poses_1(List_1_tA9A7E2A508B3146A7DE46E73A64E988FE4BD5248 * value)
{
___Poses_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Poses_1), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.SpatialTracking.TrackedPoseDriverDataDescription/PoseData
struct PoseData_t3F5C8C74C50A6ECAE42890BBEF683882DB4E97C3_marshaled_pinvoke
{
List_1_t6C9F81EDBF0F4A31A9B0DA372D2EF34BDA3A1AF3 * ___PoseNames_0;
List_1_tA9A7E2A508B3146A7DE46E73A64E988FE4BD5248 * ___Poses_1;
};
// Native definition for COM marshalling of UnityEngine.SpatialTracking.TrackedPoseDriverDataDescription/PoseData
struct PoseData_t3F5C8C74C50A6ECAE42890BBEF683882DB4E97C3_marshaled_com
{
List_1_t6C9F81EDBF0F4A31A9B0DA372D2EF34BDA3A1AF3 * ___PoseNames_0;
List_1_tA9A7E2A508B3146A7DE46E73A64E988FE4BD5248 * ___Poses_1;
};
// UnityEngine.UnitySynchronizationContext/WorkRequest
struct WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393
{
public:
// System.Threading.SendOrPostCallback UnityEngine.UnitySynchronizationContext/WorkRequest::m_DelagateCallback
SendOrPostCallback_t6B7334CE017AF595535507519400AC02D688DC3C * ___m_DelagateCallback_0;
// System.Object UnityEngine.UnitySynchronizationContext/WorkRequest::m_DelagateState
RuntimeObject * ___m_DelagateState_1;
// System.Threading.ManualResetEvent UnityEngine.UnitySynchronizationContext/WorkRequest::m_WaitHandle
ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA * ___m_WaitHandle_2;
public:
inline static int32_t get_offset_of_m_DelagateCallback_0() { return static_cast<int32_t>(offsetof(WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393, ___m_DelagateCallback_0)); }
inline SendOrPostCallback_t6B7334CE017AF595535507519400AC02D688DC3C * get_m_DelagateCallback_0() const { return ___m_DelagateCallback_0; }
inline SendOrPostCallback_t6B7334CE017AF595535507519400AC02D688DC3C ** get_address_of_m_DelagateCallback_0() { return &___m_DelagateCallback_0; }
inline void set_m_DelagateCallback_0(SendOrPostCallback_t6B7334CE017AF595535507519400AC02D688DC3C * value)
{
___m_DelagateCallback_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_DelagateCallback_0), (void*)value);
}
inline static int32_t get_offset_of_m_DelagateState_1() { return static_cast<int32_t>(offsetof(WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393, ___m_DelagateState_1)); }
inline RuntimeObject * get_m_DelagateState_1() const { return ___m_DelagateState_1; }
inline RuntimeObject ** get_address_of_m_DelagateState_1() { return &___m_DelagateState_1; }
inline void set_m_DelagateState_1(RuntimeObject * value)
{
___m_DelagateState_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_DelagateState_1), (void*)value);
}
inline static int32_t get_offset_of_m_WaitHandle_2() { return static_cast<int32_t>(offsetof(WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393, ___m_WaitHandle_2)); }
inline ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA * get_m_WaitHandle_2() const { return ___m_WaitHandle_2; }
inline ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA ** get_address_of_m_WaitHandle_2() { return &___m_WaitHandle_2; }
inline void set_m_WaitHandle_2(ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA * value)
{
___m_WaitHandle_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_WaitHandle_2), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.UnitySynchronizationContext/WorkRequest
struct WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393_marshaled_pinvoke
{
Il2CppMethodPointer ___m_DelagateCallback_0;
Il2CppIUnknown* ___m_DelagateState_1;
ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA * ___m_WaitHandle_2;
};
// Native definition for COM marshalling of UnityEngine.UnitySynchronizationContext/WorkRequest
struct WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393_marshaled_com
{
Il2CppMethodPointer ___m_DelagateCallback_0;
Il2CppIUnknown* ___m_DelagateState_1;
ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA * ___m_WaitHandle_2;
};
// UnityEngine.XR.MagicLeap.MLMediaPlayer/MLMediaPlayerLumin/QueuedCallback
struct QueuedCallback_tEF82DE1B0127F3722835BFB0ABC1D2280C6278D2
{
public:
// System.String UnityEngine.XR.MagicLeap.MLMediaPlayer/MLMediaPlayerLumin/QueuedCallback::CallbackPrefix
String_t* ___CallbackPrefix_0;
// System.Collections.Generic.List`1<System.Object> UnityEngine.XR.MagicLeap.MLMediaPlayer/MLMediaPlayerLumin/QueuedCallback::Parameters
List_1_t3F94120C77410A62EAE48421CF166B83AB95A2F5 * ___Parameters_1;
public:
inline static int32_t get_offset_of_CallbackPrefix_0() { return static_cast<int32_t>(offsetof(QueuedCallback_tEF82DE1B0127F3722835BFB0ABC1D2280C6278D2, ___CallbackPrefix_0)); }
inline String_t* get_CallbackPrefix_0() const { return ___CallbackPrefix_0; }
inline String_t** get_address_of_CallbackPrefix_0() { return &___CallbackPrefix_0; }
inline void set_CallbackPrefix_0(String_t* value)
{
___CallbackPrefix_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___CallbackPrefix_0), (void*)value);
}
inline static int32_t get_offset_of_Parameters_1() { return static_cast<int32_t>(offsetof(QueuedCallback_tEF82DE1B0127F3722835BFB0ABC1D2280C6278D2, ___Parameters_1)); }
inline List_1_t3F94120C77410A62EAE48421CF166B83AB95A2F5 * get_Parameters_1() const { return ___Parameters_1; }
inline List_1_t3F94120C77410A62EAE48421CF166B83AB95A2F5 ** get_address_of_Parameters_1() { return &___Parameters_1; }
inline void set_Parameters_1(List_1_t3F94120C77410A62EAE48421CF166B83AB95A2F5 * value)
{
___Parameters_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Parameters_1), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MagicLeap.MLMediaPlayer/MLMediaPlayerLumin/QueuedCallback
struct QueuedCallback_tEF82DE1B0127F3722835BFB0ABC1D2280C6278D2_marshaled_pinvoke
{
char* ___CallbackPrefix_0;
List_1_t3F94120C77410A62EAE48421CF166B83AB95A2F5 * ___Parameters_1;
};
// Native definition for COM marshalling of UnityEngine.XR.MagicLeap.MLMediaPlayer/MLMediaPlayerLumin/QueuedCallback
struct QueuedCallback_tEF82DE1B0127F3722835BFB0ABC1D2280C6278D2_marshaled_com
{
Il2CppChar* ___CallbackPrefix_0;
List_1_t3F94120C77410A62EAE48421CF166B83AB95A2F5 * ___Parameters_1;
};
// UnityEngine.Experimental.TerrainAPI.TerrainUtility/TerrainMap/TileCoord
struct TileCoord_t491EABF2B90DFB255C8F7624FF5528F2DE2CC901
{
public:
// System.Int32 UnityEngine.Experimental.TerrainAPI.TerrainUtility/TerrainMap/TileCoord::tileX
int32_t ___tileX_0;
// System.Int32 UnityEngine.Experimental.TerrainAPI.TerrainUtility/TerrainMap/TileCoord::tileZ
int32_t ___tileZ_1;
public:
inline static int32_t get_offset_of_tileX_0() { return static_cast<int32_t>(offsetof(TileCoord_t491EABF2B90DFB255C8F7624FF5528F2DE2CC901, ___tileX_0)); }
inline int32_t get_tileX_0() const { return ___tileX_0; }
inline int32_t* get_address_of_tileX_0() { return &___tileX_0; }
inline void set_tileX_0(int32_t value)
{
___tileX_0 = value;
}
inline static int32_t get_offset_of_tileZ_1() { return static_cast<int32_t>(offsetof(TileCoord_t491EABF2B90DFB255C8F7624FF5528F2DE2CC901, ___tileZ_1)); }
inline int32_t get_tileZ_1() const { return ___tileZ_1; }
inline int32_t* get_address_of_tileZ_1() { return &___tileZ_1; }
inline void set_tileZ_1(int32_t value)
{
___tileZ_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>
struct KeyValuePair_2_tB6ECB423D6D4B3D2F916E061DDF9A7C3F0958D57
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
RuntimeObject * ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tB6ECB423D6D4B3D2F916E061DDF9A7C3F0958D57, ___key_0)); }
inline DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 get_key_0() const { return ___key_0; }
inline DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 * get_address_of_key_0() { return &___key_0; }
inline void set_key_0(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tB6ECB423D6D4B3D2F916E061DDF9A7C3F0958D57, ___value_1)); }
inline RuntimeObject * get_value_1() const { return ___value_1; }
inline RuntimeObject ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(RuntimeObject * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// System.Collections.Generic.KeyValuePair`2<UnityEngine.XR.InputDevice,System.Object>
struct KeyValuePair_2_tCD5866451146985D9716EA94548482C8AC3F7569
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
RuntimeObject * ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tCD5866451146985D9716EA94548482C8AC3F7569, ___key_0)); }
inline InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E get_key_0() const { return ___key_0; }
inline InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E * get_address_of_key_0() { return &___key_0; }
inline void set_key_0(InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tCD5866451146985D9716EA94548482C8AC3F7569, ___value_1)); }
inline RuntimeObject * get_value_1() const { return ___value_1; }
inline RuntimeObject ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(RuntimeObject * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// System.Collections.Generic.KeyValuePair`2<System.Int32,UnityEngine.Vector3>
struct KeyValuePair_2_t35D22D0A0BCEE8A48032CF74DA9E44BEA074DC19
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
int32_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t35D22D0A0BCEE8A48032CF74DA9E44BEA074DC19, ___key_0)); }
inline int32_t get_key_0() const { return ___key_0; }
inline int32_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(int32_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t35D22D0A0BCEE8A48032CF74DA9E44BEA074DC19, ___value_1)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_value_1() const { return ___value_1; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_value_1() { return &___value_1; }
inline void set_value_1(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___value_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.Int32,UnityEngine.XR.MagicLeap.MLDispatch/OAuthPair>
struct KeyValuePair_2_tF35DAECB86CC92713433F8BD088E96D5A05E579D
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
int32_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
OAuthPair_t6862D91D872AA10E48A8FFB13C4B2D677ACE6FC0 ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tF35DAECB86CC92713433F8BD088E96D5A05E579D, ___key_0)); }
inline int32_t get_key_0() const { return ___key_0; }
inline int32_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(int32_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tF35DAECB86CC92713433F8BD088E96D5A05E579D, ___value_1)); }
inline OAuthPair_t6862D91D872AA10E48A8FFB13C4B2D677ACE6FC0 get_value_1() const { return ___value_1; }
inline OAuthPair_t6862D91D872AA10E48A8FFB13C4B2D677ACE6FC0 * get_address_of_value_1() { return &___value_1; }
inline void set_value_1(OAuthPair_t6862D91D872AA10E48A8FFB13C4B2D677ACE6FC0 value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)&(((&___value_1))->___Schema_0), (void*)NULL);
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&(((&___value_1))->___Callback_1), (void*)NULL);
#endif
}
};
// System.Collections.Generic.KeyValuePair`2<UnityEngine.XR.MeshId,System.Object>
struct KeyValuePair_2_t8E89E9D1B769A568C239665DE81AF65F368CE31D
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
RuntimeObject * ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t8E89E9D1B769A568C239665DE81AF65F368CE31D, ___key_0)); }
inline MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 get_key_0() const { return ___key_0; }
inline MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 * get_address_of_key_0() { return &___key_0; }
inline void set_key_0(MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t8E89E9D1B769A568C239665DE81AF65F368CE31D, ___value_1)); }
inline RuntimeObject * get_value_1() const { return ___value_1; }
inline RuntimeObject ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(RuntimeObject * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// System.Collections.Generic.KeyValuePair`2<System.Object,System.IntPtr>
struct KeyValuePair_2_tB240266E51130B1787D14A384667BB023D3E2BE8
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
RuntimeObject * ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
intptr_t ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tB240266E51130B1787D14A384667BB023D3E2BE8, ___key_0)); }
inline RuntimeObject * get_key_0() const { return ___key_0; }
inline RuntimeObject ** get_address_of_key_0() { return &___key_0; }
inline void set_key_0(RuntimeObject * value)
{
___key_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___key_0), (void*)value);
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tB240266E51130B1787D14A384667BB023D3E2BE8, ___value_1)); }
inline intptr_t get_value_1() const { return ___value_1; }
inline intptr_t* get_address_of_value_1() { return &___value_1; }
inline void set_value_1(intptr_t value)
{
___value_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>
struct KeyValuePair_2_t6A417393575389EF0D895B62580FBC33E95066EF
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
RuntimeObject * ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
ResourceLocator_t3D496606F94367D5D6B24DA9DC0A3B46E6B53B11 ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t6A417393575389EF0D895B62580FBC33E95066EF, ___key_0)); }
inline RuntimeObject * get_key_0() const { return ___key_0; }
inline RuntimeObject ** get_address_of_key_0() { return &___key_0; }
inline void set_key_0(RuntimeObject * value)
{
___key_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___key_0), (void*)value);
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t6A417393575389EF0D895B62580FBC33E95066EF, ___value_1)); }
inline ResourceLocator_t3D496606F94367D5D6B24DA9DC0A3B46E6B53B11 get_value_1() const { return ___value_1; }
inline ResourceLocator_t3D496606F94367D5D6B24DA9DC0A3B46E6B53B11 * get_address_of_value_1() { return &___value_1; }
inline void set_value_1(ResourceLocator_t3D496606F94367D5D6B24DA9DC0A3B46E6B53B11 value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)&(((&___value_1))->____value_0), (void*)NULL);
}
};
// System.Collections.Generic.KeyValuePair`2<System.Object,Microsoft.MixedReality.Toolkit.UI.ThemeDefinition>
struct KeyValuePair_2_t2FBC235D01262BC0B3F17DADD97D977EFD0AE4D1
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
RuntimeObject * ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
ThemeDefinition_tDC1C1DE1B953BC552C4A4D956F12537CC94E400E ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t2FBC235D01262BC0B3F17DADD97D977EFD0AE4D1, ___key_0)); }
inline RuntimeObject * get_key_0() const { return ___key_0; }
inline RuntimeObject ** get_address_of_key_0() { return &___key_0; }
inline void set_key_0(RuntimeObject * value)
{
___key_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___key_0), (void*)value);
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t2FBC235D01262BC0B3F17DADD97D977EFD0AE4D1, ___value_1)); }
inline ThemeDefinition_tDC1C1DE1B953BC552C4A4D956F12537CC94E400E get_value_1() const { return ___value_1; }
inline ThemeDefinition_tDC1C1DE1B953BC552C4A4D956F12537CC94E400E * get_address_of_value_1() { return &___value_1; }
inline void set_value_1(ThemeDefinition_tDC1C1DE1B953BC552C4A4D956F12537CC94E400E value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)&(((&___value_1))->___Type_0), (void*)NULL);
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&(((&___value_1))->___ClassName_1), (void*)NULL);
#endif
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&(((&___value_1))->___AssemblyQualifiedName_2), (void*)NULL);
#endif
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&(((&___value_1))->___stateProperties_3), (void*)NULL);
#endif
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&(((&___value_1))->___customProperties_4), (void*)NULL);
#endif
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&(((&___value_1))->___easing_5), (void*)NULL);
#endif
}
};
// System.Collections.Generic.KeyValuePair`2<System.Object,UnityEngine.Vector3>
struct KeyValuePair_2_t08B9657641C90B74353E46A763B776CE57CCE823
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
RuntimeObject * ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t08B9657641C90B74353E46A763B776CE57CCE823, ___key_0)); }
inline RuntimeObject * get_key_0() const { return ___key_0; }
inline RuntimeObject ** get_address_of_key_0() { return &___key_0; }
inline void set_key_0(RuntimeObject * value)
{
___key_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___key_0), (void*)value);
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t08B9657641C90B74353E46A763B776CE57CCE823, ___value_1)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_value_1() const { return ___value_1; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_value_1() { return &___value_1; }
inline void set_value_1(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___value_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.UInt32,UnityEngine.Vector3>
struct KeyValuePair_2_tD4BF07211CB64F83F284ECDF1B2D43A7CA28E512
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
uint32_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tD4BF07211CB64F83F284ECDF1B2D43A7CA28E512, ___key_0)); }
inline uint32_t get_key_0() const { return ___key_0; }
inline uint32_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(uint32_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tD4BF07211CB64F83F284ECDF1B2D43A7CA28E512, ___value_1)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_value_1() const { return ___value_1; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_value_1() { return &___value_1; }
inline void set_value_1(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___value_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<UnityEngine.Vector3,System.Object>
struct KeyValuePair_2_t7C40DFD3E4598A1814263BCC6543EBD170B7664D
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
RuntimeObject * ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t7C40DFD3E4598A1814263BCC6543EBD170B7664D, ___key_0)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_key_0() const { return ___key_0; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_key_0() { return &___key_0; }
inline void set_key_0(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t7C40DFD3E4598A1814263BCC6543EBD170B7664D, ___value_1)); }
inline RuntimeObject * get_value_1() const { return ___value_1; }
inline RuntimeObject ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(RuntimeObject * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// System.Collections.Generic.KeyValuePair`2<UnityEngine.XR.MagicLeap.Native.MagicLeapNativeBindings/MLCoordinateFrameUID,System.Object>
struct KeyValuePair_2_t4EFD7904997EA402D1CAF1AF8E029EEDF23B8E5E
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
MLCoordinateFrameUID_t7ADFCEC93CA8B3DDFB41EC8157D03B51D0611AC9 ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
RuntimeObject * ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t4EFD7904997EA402D1CAF1AF8E029EEDF23B8E5E, ___key_0)); }
inline MLCoordinateFrameUID_t7ADFCEC93CA8B3DDFB41EC8157D03B51D0611AC9 get_key_0() const { return ___key_0; }
inline MLCoordinateFrameUID_t7ADFCEC93CA8B3DDFB41EC8157D03B51D0611AC9 * get_address_of_key_0() { return &___key_0; }
inline void set_key_0(MLCoordinateFrameUID_t7ADFCEC93CA8B3DDFB41EC8157D03B51D0611AC9 value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t4EFD7904997EA402D1CAF1AF8E029EEDF23B8E5E, ___value_1)); }
inline RuntimeObject * get_value_1() const { return ___value_1; }
inline RuntimeObject ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(RuntimeObject * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// System.Collections.Generic.KeyValuePair`2<UnityEngine.Experimental.TerrainAPI.TerrainUtility/TerrainMap/TileCoord,System.Object>
struct KeyValuePair_2_tCBAAE4FBE6091373C1916EE17527311382CF4551
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
TileCoord_t491EABF2B90DFB255C8F7624FF5528F2DE2CC901 ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
RuntimeObject * ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tCBAAE4FBE6091373C1916EE17527311382CF4551, ___key_0)); }
inline TileCoord_t491EABF2B90DFB255C8F7624FF5528F2DE2CC901 get_key_0() const { return ___key_0; }
inline TileCoord_t491EABF2B90DFB255C8F7624FF5528F2DE2CC901 * get_address_of_key_0() { return &___key_0; }
inline void set_key_0(TileCoord_t491EABF2B90DFB255C8F7624FF5528F2DE2CC901 value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tCBAAE4FBE6091373C1916EE17527311382CF4551, ___value_1)); }
inline RuntimeObject * get_value_1() const { return ___value_1; }
inline RuntimeObject ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(RuntimeObject * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// System.Nullable`1<UnityEngine.Vector3>
struct Nullable_1_t1829213F3538788DF79B4659AFC9D6A9C90C3258
{
public:
// T System.Nullable`1::value
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___value_0;
// System.Boolean System.Nullable`1::has_value
bool ___has_value_1;
public:
inline static int32_t get_offset_of_value_0() { return static_cast<int32_t>(offsetof(Nullable_1_t1829213F3538788DF79B4659AFC9D6A9C90C3258, ___value_0)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_value_0() const { return ___value_0; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_value_0() { return &___value_0; }
inline void set_value_0(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___value_0 = value;
}
inline static int32_t get_offset_of_has_value_1() { return static_cast<int32_t>(offsetof(Nullable_1_t1829213F3538788DF79B4659AFC9D6A9C90C3258, ___has_value_1)); }
inline bool get_has_value_1() const { return ___has_value_1; }
inline bool* get_address_of_has_value_1() { return &___has_value_1; }
inline void set_has_value_1(bool value)
{
___has_value_1 = value;
}
};
// Unity.Collections.Allocator
struct Allocator_t9888223DEF4F46F3419ECFCCD0753599BEE52A05
{
public:
// System.Int32 Unity.Collections.Allocator::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(Allocator_t9888223DEF4F46F3419ECFCCD0753599BEE52A05, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.AnimationCurve
struct AnimationCurve_t2D452A14820CEDB83BFF2C911682A4E59001AD03 : public RuntimeObject
{
public:
// System.IntPtr UnityEngine.AnimationCurve::m_Ptr
intptr_t ___m_Ptr_0;
public:
inline static int32_t get_offset_of_m_Ptr_0() { return static_cast<int32_t>(offsetof(AnimationCurve_t2D452A14820CEDB83BFF2C911682A4E59001AD03, ___m_Ptr_0)); }
inline intptr_t get_m_Ptr_0() const { return ___m_Ptr_0; }
inline intptr_t* get_address_of_m_Ptr_0() { return &___m_Ptr_0; }
inline void set_m_Ptr_0(intptr_t value)
{
___m_Ptr_0 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.AnimationCurve
struct AnimationCurve_t2D452A14820CEDB83BFF2C911682A4E59001AD03_marshaled_pinvoke
{
intptr_t ___m_Ptr_0;
};
// Native definition for COM marshalling of UnityEngine.AnimationCurve
struct AnimationCurve_t2D452A14820CEDB83BFF2C911682A4E59001AD03_marshaled_com
{
intptr_t ___m_Ptr_0;
};
// UnityEngine.XR.AvailableTrackingData
struct AvailableTrackingData_tECF9F41E063E32F92AF43156E0C61190C82B47FC
{
public:
// System.Int32 UnityEngine.XR.AvailableTrackingData::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(AvailableTrackingData_tECF9F41E063E32F92AF43156E0C61190C82B47FC, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// Microsoft.MixedReality.Toolkit.Utilities.AxisType
struct AxisType_tB606C85BE8C41F8EDB09DBC39718C91E7CA874D1
{
public:
// System.Int32 Microsoft.MixedReality.Toolkit.Utilities.AxisType::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(AxisType_tB606C85BE8C41F8EDB09DBC39718C91E7CA874D1, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.Bounds
struct Bounds_t0F1F36D4F7AF49524B3C2A2259594412A3D3AE37
{
public:
// UnityEngine.Vector3 UnityEngine.Bounds::m_Center
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Center_0;
// UnityEngine.Vector3 UnityEngine.Bounds::m_Extents
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Extents_1;
public:
inline static int32_t get_offset_of_m_Center_0() { return static_cast<int32_t>(offsetof(Bounds_t0F1F36D4F7AF49524B3C2A2259594412A3D3AE37, ___m_Center_0)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_Center_0() const { return ___m_Center_0; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_Center_0() { return &___m_Center_0; }
inline void set_m_Center_0(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_Center_0 = value;
}
inline static int32_t get_offset_of_m_Extents_1() { return static_cast<int32_t>(offsetof(Bounds_t0F1F36D4F7AF49524B3C2A2259594412A3D3AE37, ___m_Extents_1)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_Extents_1() const { return ___m_Extents_1; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_Extents_1() { return &___m_Extents_1; }
inline void set_m_Extents_1(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_Extents_1 = value;
}
};
// System.ByteEnum
struct ByteEnum_t39285A9D8C7F88982FF718C04A9FA1AE64827307
{
public:
// System.Byte System.ByteEnum::value__
uint8_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(ByteEnum_t39285A9D8C7F88982FF718C04A9FA1AE64827307, ___value___2)); }
inline uint8_t get_value___2() const { return ___value___2; }
inline uint8_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(uint8_t value)
{
___value___2 = value;
}
};
// UnityEngine.UI.ColorBlock
struct ColorBlock_t04DFBB97B4772D2E00FD17ED2E3E6590E6916955
{
public:
// UnityEngine.Color UnityEngine.UI.ColorBlock::m_NormalColor
Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 ___m_NormalColor_0;
// UnityEngine.Color UnityEngine.UI.ColorBlock::m_HighlightedColor
Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 ___m_HighlightedColor_1;
// UnityEngine.Color UnityEngine.UI.ColorBlock::m_PressedColor
Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 ___m_PressedColor_2;
// UnityEngine.Color UnityEngine.UI.ColorBlock::m_SelectedColor
Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 ___m_SelectedColor_3;
// UnityEngine.Color UnityEngine.UI.ColorBlock::m_DisabledColor
Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 ___m_DisabledColor_4;
// System.Single UnityEngine.UI.ColorBlock::m_ColorMultiplier
float ___m_ColorMultiplier_5;
// System.Single UnityEngine.UI.ColorBlock::m_FadeDuration
float ___m_FadeDuration_6;
public:
inline static int32_t get_offset_of_m_NormalColor_0() { return static_cast<int32_t>(offsetof(ColorBlock_t04DFBB97B4772D2E00FD17ED2E3E6590E6916955, ___m_NormalColor_0)); }
inline Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 get_m_NormalColor_0() const { return ___m_NormalColor_0; }
inline Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 * get_address_of_m_NormalColor_0() { return &___m_NormalColor_0; }
inline void set_m_NormalColor_0(Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 value)
{
___m_NormalColor_0 = value;
}
inline static int32_t get_offset_of_m_HighlightedColor_1() { return static_cast<int32_t>(offsetof(ColorBlock_t04DFBB97B4772D2E00FD17ED2E3E6590E6916955, ___m_HighlightedColor_1)); }
inline Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 get_m_HighlightedColor_1() const { return ___m_HighlightedColor_1; }
inline Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 * get_address_of_m_HighlightedColor_1() { return &___m_HighlightedColor_1; }
inline void set_m_HighlightedColor_1(Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 value)
{
___m_HighlightedColor_1 = value;
}
inline static int32_t get_offset_of_m_PressedColor_2() { return static_cast<int32_t>(offsetof(ColorBlock_t04DFBB97B4772D2E00FD17ED2E3E6590E6916955, ___m_PressedColor_2)); }
inline Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 get_m_PressedColor_2() const { return ___m_PressedColor_2; }
inline Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 * get_address_of_m_PressedColor_2() { return &___m_PressedColor_2; }
inline void set_m_PressedColor_2(Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 value)
{
___m_PressedColor_2 = value;
}
inline static int32_t get_offset_of_m_SelectedColor_3() { return static_cast<int32_t>(offsetof(ColorBlock_t04DFBB97B4772D2E00FD17ED2E3E6590E6916955, ___m_SelectedColor_3)); }
inline Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 get_m_SelectedColor_3() const { return ___m_SelectedColor_3; }
inline Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 * get_address_of_m_SelectedColor_3() { return &___m_SelectedColor_3; }
inline void set_m_SelectedColor_3(Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 value)
{
___m_SelectedColor_3 = value;
}
inline static int32_t get_offset_of_m_DisabledColor_4() { return static_cast<int32_t>(offsetof(ColorBlock_t04DFBB97B4772D2E00FD17ED2E3E6590E6916955, ___m_DisabledColor_4)); }
inline Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 get_m_DisabledColor_4() const { return ___m_DisabledColor_4; }
inline Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 * get_address_of_m_DisabledColor_4() { return &___m_DisabledColor_4; }
inline void set_m_DisabledColor_4(Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 value)
{
___m_DisabledColor_4 = value;
}
inline static int32_t get_offset_of_m_ColorMultiplier_5() { return static_cast<int32_t>(offsetof(ColorBlock_t04DFBB97B4772D2E00FD17ED2E3E6590E6916955, ___m_ColorMultiplier_5)); }
inline float get_m_ColorMultiplier_5() const { return ___m_ColorMultiplier_5; }
inline float* get_address_of_m_ColorMultiplier_5() { return &___m_ColorMultiplier_5; }
inline void set_m_ColorMultiplier_5(float value)
{
___m_ColorMultiplier_5 = value;
}
inline static int32_t get_offset_of_m_FadeDuration_6() { return static_cast<int32_t>(offsetof(ColorBlock_t04DFBB97B4772D2E00FD17ED2E3E6590E6916955, ___m_FadeDuration_6)); }
inline float get_m_FadeDuration_6() const { return ___m_FadeDuration_6; }
inline float* get_address_of_m_FadeDuration_6() { return &___m_FadeDuration_6; }
inline void set_m_FadeDuration_6(float value)
{
___m_FadeDuration_6 = value;
}
};
struct ColorBlock_t04DFBB97B4772D2E00FD17ED2E3E6590E6916955_StaticFields
{
public:
// UnityEngine.UI.ColorBlock UnityEngine.UI.ColorBlock::defaultColorBlock
ColorBlock_t04DFBB97B4772D2E00FD17ED2E3E6590E6916955 ___defaultColorBlock_7;
public:
inline static int32_t get_offset_of_defaultColorBlock_7() { return static_cast<int32_t>(offsetof(ColorBlock_t04DFBB97B4772D2E00FD17ED2E3E6590E6916955_StaticFields, ___defaultColorBlock_7)); }
inline ColorBlock_t04DFBB97B4772D2E00FD17ED2E3E6590E6916955 get_defaultColorBlock_7() const { return ___defaultColorBlock_7; }
inline ColorBlock_t04DFBB97B4772D2E00FD17ED2E3E6590E6916955 * get_address_of_defaultColorBlock_7() { return &___defaultColorBlock_7; }
inline void set_defaultColorBlock_7(ColorBlock_t04DFBB97B4772D2E00FD17ED2E3E6590E6916955 value)
{
___defaultColorBlock_7 = value;
}
};
// System.ConsoleKey
struct ConsoleKey_t4708A928547D666CF632F6F46340F476155566D4
{
public:
// System.Int32 System.ConsoleKey::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(ConsoleKey_t4708A928547D666CF632F6F46340F476155566D4, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.ConsoleModifiers
struct ConsoleModifiers_t8465A8BC80F4BDB8816D80AA7CBE483DC7D01EBE
{
public:
// System.Int32 System.ConsoleModifiers::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(ConsoleModifiers_t8465A8BC80F4BDB8816D80AA7CBE483DC7D01EBE, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Reflection.CustomAttributeNamedArgument
struct CustomAttributeNamedArgument_t618778691CF7F5B44F7177210A817A29D3DAEDDA
{
public:
// System.Reflection.CustomAttributeTypedArgument System.Reflection.CustomAttributeNamedArgument::typedArgument
CustomAttributeTypedArgument_tE7152E8FACDD29A8E0040E151C86F436FA8E6910 ___typedArgument_0;
// System.Reflection.MemberInfo System.Reflection.CustomAttributeNamedArgument::memberInfo
MemberInfo_t * ___memberInfo_1;
public:
inline static int32_t get_offset_of_typedArgument_0() { return static_cast<int32_t>(offsetof(CustomAttributeNamedArgument_t618778691CF7F5B44F7177210A817A29D3DAEDDA, ___typedArgument_0)); }
inline CustomAttributeTypedArgument_tE7152E8FACDD29A8E0040E151C86F436FA8E6910 get_typedArgument_0() const { return ___typedArgument_0; }
inline CustomAttributeTypedArgument_tE7152E8FACDD29A8E0040E151C86F436FA8E6910 * get_address_of_typedArgument_0() { return &___typedArgument_0; }
inline void set_typedArgument_0(CustomAttributeTypedArgument_tE7152E8FACDD29A8E0040E151C86F436FA8E6910 value)
{
___typedArgument_0 = value;
Il2CppCodeGenWriteBarrier((void**)&(((&___typedArgument_0))->___argumentType_0), (void*)NULL);
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&(((&___typedArgument_0))->___value_1), (void*)NULL);
#endif
}
inline static int32_t get_offset_of_memberInfo_1() { return static_cast<int32_t>(offsetof(CustomAttributeNamedArgument_t618778691CF7F5B44F7177210A817A29D3DAEDDA, ___memberInfo_1)); }
inline MemberInfo_t * get_memberInfo_1() const { return ___memberInfo_1; }
inline MemberInfo_t ** get_address_of_memberInfo_1() { return &___memberInfo_1; }
inline void set_memberInfo_1(MemberInfo_t * value)
{
___memberInfo_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___memberInfo_1), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.Reflection.CustomAttributeNamedArgument
struct CustomAttributeNamedArgument_t618778691CF7F5B44F7177210A817A29D3DAEDDA_marshaled_pinvoke
{
CustomAttributeTypedArgument_tE7152E8FACDD29A8E0040E151C86F436FA8E6910_marshaled_pinvoke ___typedArgument_0;
MemberInfo_t * ___memberInfo_1;
};
// Native definition for COM marshalling of System.Reflection.CustomAttributeNamedArgument
struct CustomAttributeNamedArgument_t618778691CF7F5B44F7177210A817A29D3DAEDDA_marshaled_com
{
CustomAttributeTypedArgument_tE7152E8FACDD29A8E0040E151C86F436FA8E6910_marshaled_com ___typedArgument_0;
MemberInfo_t * ___memberInfo_1;
};
// Microsoft.MixedReality.Toolkit.Boundary.Edge
struct Edge_t9E8220DAC70F321BE68E4872C23B5F4AC8A5E2EE
{
public:
// UnityEngine.Vector2 Microsoft.MixedReality.Toolkit.Boundary.Edge::PointA
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___PointA_0;
// UnityEngine.Vector2 Microsoft.MixedReality.Toolkit.Boundary.Edge::PointB
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___PointB_1;
public:
inline static int32_t get_offset_of_PointA_0() { return static_cast<int32_t>(offsetof(Edge_t9E8220DAC70F321BE68E4872C23B5F4AC8A5E2EE, ___PointA_0)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_PointA_0() const { return ___PointA_0; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_PointA_0() { return &___PointA_0; }
inline void set_PointA_0(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___PointA_0 = value;
}
inline static int32_t get_offset_of_PointB_1() { return static_cast<int32_t>(offsetof(Edge_t9E8220DAC70F321BE68E4872C23B5F4AC8A5E2EE, ___PointB_1)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_PointB_1() const { return ___PointB_1; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_PointB_1() { return &___PointB_1; }
inline void set_PointB_1(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___PointB_1 = value;
}
};
// UnityEngine.XR.InteractionSubsystems.GestureState
struct GestureState_tF46000290CC6332630D7FE0425DA51EB79CBE557
{
public:
// System.Int32 UnityEngine.XR.InteractionSubsystems.GestureState::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(GestureState_tF46000290CC6332630D7FE0425DA51EB79CBE557, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Int32Enum
struct Int32Enum_t9B63F771913F2B6D586F1173B44A41FBE26F6B5C
{
public:
// System.Int32 System.Int32Enum::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(Int32Enum_t9B63F771913F2B6D586F1173B44A41FBE26F6B5C, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// Unity.Jobs.JobHandle
struct JobHandle_t8AEB8D31C25D7774C71D62B0C662525E6E36D847
{
public:
// System.IntPtr Unity.Jobs.JobHandle::jobGroup
intptr_t ___jobGroup_0;
// System.Int32 Unity.Jobs.JobHandle::version
int32_t ___version_1;
public:
inline static int32_t get_offset_of_jobGroup_0() { return static_cast<int32_t>(offsetof(JobHandle_t8AEB8D31C25D7774C71D62B0C662525E6E36D847, ___jobGroup_0)); }
inline intptr_t get_jobGroup_0() const { return ___jobGroup_0; }
inline intptr_t* get_address_of_jobGroup_0() { return &___jobGroup_0; }
inline void set_jobGroup_0(intptr_t value)
{
___jobGroup_0 = value;
}
inline static int32_t get_offset_of_version_1() { return static_cast<int32_t>(offsetof(JobHandle_t8AEB8D31C25D7774C71D62B0C662525E6E36D847, ___version_1)); }
inline int32_t get_version_1() const { return ___version_1; }
inline int32_t* get_address_of_version_1() { return &___version_1; }
inline void set_version_1(int32_t value)
{
___version_1 = value;
}
};
// UnityEngine.KeyCode
struct KeyCode_t1D303F7D061BF4429872E9F109ADDBCB431671F4
{
public:
// System.Int32 UnityEngine.KeyCode::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(KeyCode_t1D303F7D061BF4429872E9F109ADDBCB431671F4, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.Rendering.LODParameters
struct LODParameters_tA41D06C4BDB03138144BE9DCC4BC6B37963DC5CD
{
public:
// System.Int32 UnityEngine.Rendering.LODParameters::m_IsOrthographic
int32_t ___m_IsOrthographic_0;
// UnityEngine.Vector3 UnityEngine.Rendering.LODParameters::m_CameraPosition
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_CameraPosition_1;
// System.Single UnityEngine.Rendering.LODParameters::m_FieldOfView
float ___m_FieldOfView_2;
// System.Single UnityEngine.Rendering.LODParameters::m_OrthoSize
float ___m_OrthoSize_3;
// System.Int32 UnityEngine.Rendering.LODParameters::m_CameraPixelHeight
int32_t ___m_CameraPixelHeight_4;
public:
inline static int32_t get_offset_of_m_IsOrthographic_0() { return static_cast<int32_t>(offsetof(LODParameters_tA41D06C4BDB03138144BE9DCC4BC6B37963DC5CD, ___m_IsOrthographic_0)); }
inline int32_t get_m_IsOrthographic_0() const { return ___m_IsOrthographic_0; }
inline int32_t* get_address_of_m_IsOrthographic_0() { return &___m_IsOrthographic_0; }
inline void set_m_IsOrthographic_0(int32_t value)
{
___m_IsOrthographic_0 = value;
}
inline static int32_t get_offset_of_m_CameraPosition_1() { return static_cast<int32_t>(offsetof(LODParameters_tA41D06C4BDB03138144BE9DCC4BC6B37963DC5CD, ___m_CameraPosition_1)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_CameraPosition_1() const { return ___m_CameraPosition_1; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_CameraPosition_1() { return &___m_CameraPosition_1; }
inline void set_m_CameraPosition_1(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_CameraPosition_1 = value;
}
inline static int32_t get_offset_of_m_FieldOfView_2() { return static_cast<int32_t>(offsetof(LODParameters_tA41D06C4BDB03138144BE9DCC4BC6B37963DC5CD, ___m_FieldOfView_2)); }
inline float get_m_FieldOfView_2() const { return ___m_FieldOfView_2; }
inline float* get_address_of_m_FieldOfView_2() { return &___m_FieldOfView_2; }
inline void set_m_FieldOfView_2(float value)
{
___m_FieldOfView_2 = value;
}
inline static int32_t get_offset_of_m_OrthoSize_3() { return static_cast<int32_t>(offsetof(LODParameters_tA41D06C4BDB03138144BE9DCC4BC6B37963DC5CD, ___m_OrthoSize_3)); }
inline float get_m_OrthoSize_3() const { return ___m_OrthoSize_3; }
inline float* get_address_of_m_OrthoSize_3() { return &___m_OrthoSize_3; }
inline void set_m_OrthoSize_3(float value)
{
___m_OrthoSize_3 = value;
}
inline static int32_t get_offset_of_m_CameraPixelHeight_4() { return static_cast<int32_t>(offsetof(LODParameters_tA41D06C4BDB03138144BE9DCC4BC6B37963DC5CD, ___m_CameraPixelHeight_4)); }
inline int32_t get_m_CameraPixelHeight_4() const { return ___m_CameraPixelHeight_4; }
inline int32_t* get_address_of_m_CameraPixelHeight_4() { return &___m_CameraPixelHeight_4; }
inline void set_m_CameraPixelHeight_4(int32_t value)
{
___m_CameraPixelHeight_4 = value;
}
};
// UnityEngine.SceneManagement.LoadSceneMode
struct LoadSceneMode_tF5060E18B71D524860ECBF7B9B56193B1907E5CC
{
public:
// System.Int32 UnityEngine.SceneManagement.LoadSceneMode::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(LoadSceneMode_tF5060E18B71D524860ECBF7B9B56193B1907E5CC, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.SceneManagement.LocalPhysicsMode
struct LocalPhysicsMode_t0BC6949E496E4E126141A944F9B5A26939798BE6
{
public:
// System.Int32 UnityEngine.SceneManagement.LocalPhysicsMode::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(LocalPhysicsMode_t0BC6949E496E4E126141A944F9B5A26939798BE6, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MagicLeap.MLCoordinateFrameUID
struct MLCoordinateFrameUID_tA8D0393E638F9B4C5B7EBB2A1073BF5CB5FB71F5
{
public:
// UnityEngine.XR.MagicLeap.MLCoordinateFrameUID/<data>e__FixedBuffer UnityEngine.XR.MagicLeap.MLCoordinateFrameUID::data
U3CdataU3Ee__FixedBuffer_t9C20A467F80740C3FBC07EC06843565A49351FB6 ___data_0;
public:
inline static int32_t get_offset_of_data_0() { return static_cast<int32_t>(offsetof(MLCoordinateFrameUID_tA8D0393E638F9B4C5B7EBB2A1073BF5CB5FB71F5, ___data_0)); }
inline U3CdataU3Ee__FixedBuffer_t9C20A467F80740C3FBC07EC06843565A49351FB6 get_data_0() const { return ___data_0; }
inline U3CdataU3Ee__FixedBuffer_t9C20A467F80740C3FBC07EC06843565A49351FB6 * get_address_of_data_0() { return &___data_0; }
inline void set_data_0(U3CdataU3Ee__FixedBuffer_t9C20A467F80740C3FBC07EC06843565A49351FB6 value)
{
___data_0 = value;
}
};
// UnityEngine.XR.MagicLeap.MagicLeapHand
struct MagicLeapHand_t0F99E3713B0F20BEECA12493DE64B4AADAAB3ECD
{
public:
// System.Int32 UnityEngine.XR.MagicLeap.MagicLeapHand::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(MagicLeapHand_t0F99E3713B0F20BEECA12493DE64B4AADAAB3ECD, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MagicLeap.MagicLeapInputControllerTouchpadGestureType
struct MagicLeapInputControllerTouchpadGestureType_tF1C4715339E8995AC9C59DD1B11D835455B7D15C
{
public:
// System.Int32 UnityEngine.XR.MagicLeap.MagicLeapInputControllerTouchpadGestureType::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(MagicLeapInputControllerTouchpadGestureType_tF1C4715339E8995AC9C59DD1B11D835455B7D15C, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MagicLeap.MagicLeapKeyPose
struct MagicLeapKeyPose_t90CC68B994A5F62785A05139FA1740CC2BBA654D
{
public:
// System.Int32 UnityEngine.XR.MagicLeap.MagicLeapKeyPose::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(MagicLeapKeyPose_t90CC68B994A5F62785A05139FA1740CC2BBA654D, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MagicLeap.MagicLeapTouchpadGestureDirection
struct MagicLeapTouchpadGestureDirection_t77023274D95B2D28302E19D628E10228888B2F5D
{
public:
// System.Int32 UnityEngine.XR.MagicLeap.MagicLeapTouchpadGestureDirection::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(MagicLeapTouchpadGestureDirection_t77023274D95B2D28302E19D628E10228888B2F5D, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MeshChangeState
struct MeshChangeState_t577B449627A869D7B8E062F9D9C218418790E046
{
public:
// System.Int32 UnityEngine.XR.MeshChangeState::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(MeshChangeState_t577B449627A869D7B8E062F9D9C218418790E046, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MeshGenerationStatus
struct MeshGenerationStatus_t25EB712EAD94A279AD7D5A00E0CB6EDC8AB1FE79
{
public:
// System.Int32 UnityEngine.XR.MeshGenerationStatus::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(MeshGenerationStatus_t25EB712EAD94A279AD7D5A00E0CB6EDC8AB1FE79, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MeshVertexAttributes
struct MeshVertexAttributes_t7CCF6BE6BB4E908E1ECF9F9AF76968FA38A672CE
{
public:
// System.Int32 UnityEngine.XR.MeshVertexAttributes::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(MeshVertexAttributes_t7CCF6BE6BB4E908E1ECF9F9AF76968FA38A672CE, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// Microsoft.MixedReality.Toolkit.Utilities.MixedRealityPose
struct MixedRealityPose_t9A27AAE05672995793F76985CE167AA85B8DF5AF
{
public:
// UnityEngine.Vector3 Microsoft.MixedReality.Toolkit.Utilities.MixedRealityPose::position
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___position_1;
// UnityEngine.Quaternion Microsoft.MixedReality.Toolkit.Utilities.MixedRealityPose::rotation
Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___rotation_2;
public:
inline static int32_t get_offset_of_position_1() { return static_cast<int32_t>(offsetof(MixedRealityPose_t9A27AAE05672995793F76985CE167AA85B8DF5AF, ___position_1)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_position_1() const { return ___position_1; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_position_1() { return &___position_1; }
inline void set_position_1(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___position_1 = value;
}
inline static int32_t get_offset_of_rotation_2() { return static_cast<int32_t>(offsetof(MixedRealityPose_t9A27AAE05672995793F76985CE167AA85B8DF5AF, ___rotation_2)); }
inline Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 get_rotation_2() const { return ___rotation_2; }
inline Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 * get_address_of_rotation_2() { return &___rotation_2; }
inline void set_rotation_2(Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 value)
{
___rotation_2 = value;
}
};
struct MixedRealityPose_t9A27AAE05672995793F76985CE167AA85B8DF5AF_StaticFields
{
public:
// Microsoft.MixedReality.Toolkit.Utilities.MixedRealityPose Microsoft.MixedReality.Toolkit.Utilities.MixedRealityPose::<ZeroIdentity>k__BackingField
MixedRealityPose_t9A27AAE05672995793F76985CE167AA85B8DF5AF ___U3CZeroIdentityU3Ek__BackingField_0;
public:
inline static int32_t get_offset_of_U3CZeroIdentityU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(MixedRealityPose_t9A27AAE05672995793F76985CE167AA85B8DF5AF_StaticFields, ___U3CZeroIdentityU3Ek__BackingField_0)); }
inline MixedRealityPose_t9A27AAE05672995793F76985CE167AA85B8DF5AF get_U3CZeroIdentityU3Ek__BackingField_0() const { return ___U3CZeroIdentityU3Ek__BackingField_0; }
inline MixedRealityPose_t9A27AAE05672995793F76985CE167AA85B8DF5AF * get_address_of_U3CZeroIdentityU3Ek__BackingField_0() { return &___U3CZeroIdentityU3Ek__BackingField_0; }
inline void set_U3CZeroIdentityU3Ek__BackingField_0(MixedRealityPose_t9A27AAE05672995793F76985CE167AA85B8DF5AF value)
{
___U3CZeroIdentityU3Ek__BackingField_0 = value;
}
};
// Microsoft.MixedReality.Toolkit.Input.MixedRealityRaycastHit
struct MixedRealityRaycastHit_tD69CF29AE572AB1F40DCAA41425AC72EC4031E48
{
public:
// UnityEngine.Vector3 Microsoft.MixedReality.Toolkit.Input.MixedRealityRaycastHit::point
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___point_0;
// UnityEngine.Vector3 Microsoft.MixedReality.Toolkit.Input.MixedRealityRaycastHit::normal
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___normal_1;
// UnityEngine.Vector3 Microsoft.MixedReality.Toolkit.Input.MixedRealityRaycastHit::barycentricCoordinate
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___barycentricCoordinate_2;
// System.Single Microsoft.MixedReality.Toolkit.Input.MixedRealityRaycastHit::distance
float ___distance_3;
// System.Int32 Microsoft.MixedReality.Toolkit.Input.MixedRealityRaycastHit::triangleIndex
int32_t ___triangleIndex_4;
// UnityEngine.Vector2 Microsoft.MixedReality.Toolkit.Input.MixedRealityRaycastHit::textureCoord
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___textureCoord_5;
// UnityEngine.Vector2 Microsoft.MixedReality.Toolkit.Input.MixedRealityRaycastHit::textureCoord2
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___textureCoord2_6;
// UnityEngine.Transform Microsoft.MixedReality.Toolkit.Input.MixedRealityRaycastHit::transform
Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 * ___transform_7;
// UnityEngine.Vector2 Microsoft.MixedReality.Toolkit.Input.MixedRealityRaycastHit::lightmapCoord
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___lightmapCoord_8;
// System.Boolean Microsoft.MixedReality.Toolkit.Input.MixedRealityRaycastHit::raycastValid
bool ___raycastValid_9;
// UnityEngine.Collider Microsoft.MixedReality.Toolkit.Input.MixedRealityRaycastHit::collider
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___collider_10;
public:
inline static int32_t get_offset_of_point_0() { return static_cast<int32_t>(offsetof(MixedRealityRaycastHit_tD69CF29AE572AB1F40DCAA41425AC72EC4031E48, ___point_0)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_point_0() const { return ___point_0; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_point_0() { return &___point_0; }
inline void set_point_0(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___point_0 = value;
}
inline static int32_t get_offset_of_normal_1() { return static_cast<int32_t>(offsetof(MixedRealityRaycastHit_tD69CF29AE572AB1F40DCAA41425AC72EC4031E48, ___normal_1)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_normal_1() const { return ___normal_1; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_normal_1() { return &___normal_1; }
inline void set_normal_1(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___normal_1 = value;
}
inline static int32_t get_offset_of_barycentricCoordinate_2() { return static_cast<int32_t>(offsetof(MixedRealityRaycastHit_tD69CF29AE572AB1F40DCAA41425AC72EC4031E48, ___barycentricCoordinate_2)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_barycentricCoordinate_2() const { return ___barycentricCoordinate_2; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_barycentricCoordinate_2() { return &___barycentricCoordinate_2; }
inline void set_barycentricCoordinate_2(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___barycentricCoordinate_2 = value;
}
inline static int32_t get_offset_of_distance_3() { return static_cast<int32_t>(offsetof(MixedRealityRaycastHit_tD69CF29AE572AB1F40DCAA41425AC72EC4031E48, ___distance_3)); }
inline float get_distance_3() const { return ___distance_3; }
inline float* get_address_of_distance_3() { return &___distance_3; }
inline void set_distance_3(float value)
{
___distance_3 = value;
}
inline static int32_t get_offset_of_triangleIndex_4() { return static_cast<int32_t>(offsetof(MixedRealityRaycastHit_tD69CF29AE572AB1F40DCAA41425AC72EC4031E48, ___triangleIndex_4)); }
inline int32_t get_triangleIndex_4() const { return ___triangleIndex_4; }
inline int32_t* get_address_of_triangleIndex_4() { return &___triangleIndex_4; }
inline void set_triangleIndex_4(int32_t value)
{
___triangleIndex_4 = value;
}
inline static int32_t get_offset_of_textureCoord_5() { return static_cast<int32_t>(offsetof(MixedRealityRaycastHit_tD69CF29AE572AB1F40DCAA41425AC72EC4031E48, ___textureCoord_5)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_textureCoord_5() const { return ___textureCoord_5; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_textureCoord_5() { return &___textureCoord_5; }
inline void set_textureCoord_5(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___textureCoord_5 = value;
}
inline static int32_t get_offset_of_textureCoord2_6() { return static_cast<int32_t>(offsetof(MixedRealityRaycastHit_tD69CF29AE572AB1F40DCAA41425AC72EC4031E48, ___textureCoord2_6)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_textureCoord2_6() const { return ___textureCoord2_6; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_textureCoord2_6() { return &___textureCoord2_6; }
inline void set_textureCoord2_6(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___textureCoord2_6 = value;
}
inline static int32_t get_offset_of_transform_7() { return static_cast<int32_t>(offsetof(MixedRealityRaycastHit_tD69CF29AE572AB1F40DCAA41425AC72EC4031E48, ___transform_7)); }
inline Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 * get_transform_7() const { return ___transform_7; }
inline Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 ** get_address_of_transform_7() { return &___transform_7; }
inline void set_transform_7(Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 * value)
{
___transform_7 = value;
Il2CppCodeGenWriteBarrier((void**)(&___transform_7), (void*)value);
}
inline static int32_t get_offset_of_lightmapCoord_8() { return static_cast<int32_t>(offsetof(MixedRealityRaycastHit_tD69CF29AE572AB1F40DCAA41425AC72EC4031E48, ___lightmapCoord_8)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_lightmapCoord_8() const { return ___lightmapCoord_8; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_lightmapCoord_8() { return &___lightmapCoord_8; }
inline void set_lightmapCoord_8(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___lightmapCoord_8 = value;
}
inline static int32_t get_offset_of_raycastValid_9() { return static_cast<int32_t>(offsetof(MixedRealityRaycastHit_tD69CF29AE572AB1F40DCAA41425AC72EC4031E48, ___raycastValid_9)); }
inline bool get_raycastValid_9() const { return ___raycastValid_9; }
inline bool* get_address_of_raycastValid_9() { return &___raycastValid_9; }
inline void set_raycastValid_9(bool value)
{
___raycastValid_9 = value;
}
inline static int32_t get_offset_of_collider_10() { return static_cast<int32_t>(offsetof(MixedRealityRaycastHit_tD69CF29AE572AB1F40DCAA41425AC72EC4031E48, ___collider_10)); }
inline Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * get_collider_10() const { return ___collider_10; }
inline Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 ** get_address_of_collider_10() { return &___collider_10; }
inline void set_collider_10(Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * value)
{
___collider_10 = value;
Il2CppCodeGenWriteBarrier((void**)(&___collider_10), (void*)value);
}
};
// Native definition for P/Invoke marshalling of Microsoft.MixedReality.Toolkit.Input.MixedRealityRaycastHit
struct MixedRealityRaycastHit_tD69CF29AE572AB1F40DCAA41425AC72EC4031E48_marshaled_pinvoke
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___point_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___normal_1;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___barycentricCoordinate_2;
float ___distance_3;
int32_t ___triangleIndex_4;
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___textureCoord_5;
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___textureCoord2_6;
Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 * ___transform_7;
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___lightmapCoord_8;
int32_t ___raycastValid_9;
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___collider_10;
};
// Native definition for COM marshalling of Microsoft.MixedReality.Toolkit.Input.MixedRealityRaycastHit
struct MixedRealityRaycastHit_tD69CF29AE572AB1F40DCAA41425AC72EC4031E48_marshaled_com
{
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___point_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___normal_1;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___barycentricCoordinate_2;
float ___distance_3;
int32_t ___triangleIndex_4;
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___textureCoord_5;
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___textureCoord2_6;
Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 * ___transform_7;
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___lightmapCoord_8;
int32_t ___raycastValid_9;
Collider_t5E81E43C2ECA0209A7C4528E84A632712D192B02 * ___collider_10;
};
// UnityEngine.Object
struct Object_tF2F3778131EFF286AF62B7B013A170F95A91571A : public RuntimeObject
{
public:
// System.IntPtr UnityEngine.Object::m_CachedPtr
intptr_t ___m_CachedPtr_0;
public:
inline static int32_t get_offset_of_m_CachedPtr_0() { return static_cast<int32_t>(offsetof(Object_tF2F3778131EFF286AF62B7B013A170F95A91571A, ___m_CachedPtr_0)); }
inline intptr_t get_m_CachedPtr_0() const { return ___m_CachedPtr_0; }
inline intptr_t* get_address_of_m_CachedPtr_0() { return &___m_CachedPtr_0; }
inline void set_m_CachedPtr_0(intptr_t value)
{
___m_CachedPtr_0 = value;
}
};
struct Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_StaticFields
{
public:
// System.Int32 UnityEngine.Object::OffsetOfInstanceIDInCPlusPlusObject
int32_t ___OffsetOfInstanceIDInCPlusPlusObject_1;
public:
inline static int32_t get_offset_of_OffsetOfInstanceIDInCPlusPlusObject_1() { return static_cast<int32_t>(offsetof(Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_StaticFields, ___OffsetOfInstanceIDInCPlusPlusObject_1)); }
inline int32_t get_OffsetOfInstanceIDInCPlusPlusObject_1() const { return ___OffsetOfInstanceIDInCPlusPlusObject_1; }
inline int32_t* get_address_of_OffsetOfInstanceIDInCPlusPlusObject_1() { return &___OffsetOfInstanceIDInCPlusPlusObject_1; }
inline void set_OffsetOfInstanceIDInCPlusPlusObject_1(int32_t value)
{
___OffsetOfInstanceIDInCPlusPlusObject_1 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.Object
struct Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_marshaled_pinvoke
{
intptr_t ___m_CachedPtr_0;
};
// Native definition for COM marshalling of UnityEngine.Object
struct Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_marshaled_com
{
intptr_t ___m_CachedPtr_0;
};
// UnityEngine.XR.ARSubsystems.PlaneAlignment
struct PlaneAlignment_t1BB7048E3969913434FB1B3BCBCA2E81D4E71ADA
{
public:
// System.Int32 UnityEngine.XR.ARSubsystems.PlaneAlignment::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(PlaneAlignment_t1BB7048E3969913434FB1B3BCBCA2E81D4E71ADA, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.ARSubsystems.PlaneClassification
struct PlaneClassification_tAC2E2E9609D4396BC311E2987CA3EFA5115EDD10
{
public:
// System.Int32 UnityEngine.XR.ARSubsystems.PlaneClassification::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(PlaneClassification_tAC2E2E9609D4396BC311E2987CA3EFA5115EDD10, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.Playables.PlayableGraph
struct PlayableGraph_t2D5083CFACB413FA1BB13FF054BE09A5A55A205A
{
public:
// System.IntPtr UnityEngine.Playables.PlayableGraph::m_Handle
intptr_t ___m_Handle_0;
// System.UInt32 UnityEngine.Playables.PlayableGraph::m_Version
uint32_t ___m_Version_1;
public:
inline static int32_t get_offset_of_m_Handle_0() { return static_cast<int32_t>(offsetof(PlayableGraph_t2D5083CFACB413FA1BB13FF054BE09A5A55A205A, ___m_Handle_0)); }
inline intptr_t get_m_Handle_0() const { return ___m_Handle_0; }
inline intptr_t* get_address_of_m_Handle_0() { return &___m_Handle_0; }
inline void set_m_Handle_0(intptr_t value)
{
___m_Handle_0 = value;
}
inline static int32_t get_offset_of_m_Version_1() { return static_cast<int32_t>(offsetof(PlayableGraph_t2D5083CFACB413FA1BB13FF054BE09A5A55A205A, ___m_Version_1)); }
inline uint32_t get_m_Version_1() const { return ___m_Version_1; }
inline uint32_t* get_address_of_m_Version_1() { return &___m_Version_1; }
inline void set_m_Version_1(uint32_t value)
{
___m_Version_1 = value;
}
};
// UnityEngine.Playables.PlayableHandle
struct PlayableHandle_t50DCD240B0400DDAD0822C13E5DBC7AD64DC027A
{
public:
// System.IntPtr UnityEngine.Playables.PlayableHandle::m_Handle
intptr_t ___m_Handle_0;
// System.UInt32 UnityEngine.Playables.PlayableHandle::m_Version
uint32_t ___m_Version_1;
public:
inline static int32_t get_offset_of_m_Handle_0() { return static_cast<int32_t>(offsetof(PlayableHandle_t50DCD240B0400DDAD0822C13E5DBC7AD64DC027A, ___m_Handle_0)); }
inline intptr_t get_m_Handle_0() const { return ___m_Handle_0; }
inline intptr_t* get_address_of_m_Handle_0() { return &___m_Handle_0; }
inline void set_m_Handle_0(intptr_t value)
{
___m_Handle_0 = value;
}
inline static int32_t get_offset_of_m_Version_1() { return static_cast<int32_t>(offsetof(PlayableHandle_t50DCD240B0400DDAD0822C13E5DBC7AD64DC027A, ___m_Version_1)); }
inline uint32_t get_m_Version_1() const { return ___m_Version_1; }
inline uint32_t* get_address_of_m_Version_1() { return &___m_Version_1; }
inline void set_m_Version_1(uint32_t value)
{
___m_Version_1 = value;
}
};
struct PlayableHandle_t50DCD240B0400DDAD0822C13E5DBC7AD64DC027A_StaticFields
{
public:
// UnityEngine.Playables.PlayableHandle UnityEngine.Playables.PlayableHandle::m_Null
PlayableHandle_t50DCD240B0400DDAD0822C13E5DBC7AD64DC027A ___m_Null_2;
public:
inline static int32_t get_offset_of_m_Null_2() { return static_cast<int32_t>(offsetof(PlayableHandle_t50DCD240B0400DDAD0822C13E5DBC7AD64DC027A_StaticFields, ___m_Null_2)); }
inline PlayableHandle_t50DCD240B0400DDAD0822C13E5DBC7AD64DC027A get_m_Null_2() const { return ___m_Null_2; }
inline PlayableHandle_t50DCD240B0400DDAD0822C13E5DBC7AD64DC027A * get_address_of_m_Null_2() { return &___m_Null_2; }
inline void set_m_Null_2(PlayableHandle_t50DCD240B0400DDAD0822C13E5DBC7AD64DC027A value)
{
___m_Null_2 = value;
}
};
// UnityEngine.Playables.PlayableOutputHandle
struct PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1
{
public:
// System.IntPtr UnityEngine.Playables.PlayableOutputHandle::m_Handle
intptr_t ___m_Handle_0;
// System.UInt32 UnityEngine.Playables.PlayableOutputHandle::m_Version
uint32_t ___m_Version_1;
public:
inline static int32_t get_offset_of_m_Handle_0() { return static_cast<int32_t>(offsetof(PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1, ___m_Handle_0)); }
inline intptr_t get_m_Handle_0() const { return ___m_Handle_0; }
inline intptr_t* get_address_of_m_Handle_0() { return &___m_Handle_0; }
inline void set_m_Handle_0(intptr_t value)
{
___m_Handle_0 = value;
}
inline static int32_t get_offset_of_m_Version_1() { return static_cast<int32_t>(offsetof(PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1, ___m_Version_1)); }
inline uint32_t get_m_Version_1() const { return ___m_Version_1; }
inline uint32_t* get_address_of_m_Version_1() { return &___m_Version_1; }
inline void set_m_Version_1(uint32_t value)
{
___m_Version_1 = value;
}
};
struct PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1_StaticFields
{
public:
// UnityEngine.Playables.PlayableOutputHandle UnityEngine.Playables.PlayableOutputHandle::m_Null
PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1 ___m_Null_2;
public:
inline static int32_t get_offset_of_m_Null_2() { return static_cast<int32_t>(offsetof(PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1_StaticFields, ___m_Null_2)); }
inline PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1 get_m_Null_2() const { return ___m_Null_2; }
inline PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1 * get_address_of_m_Null_2() { return &___m_Null_2; }
inline void set_m_Null_2(PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1 value)
{
___m_Null_2 = value;
}
};
// UnityEngine.Pose
struct Pose_t9F30358E65733E60A1DC8682FDB7104F40C9434A
{
public:
// UnityEngine.Vector3 UnityEngine.Pose::position
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___position_0;
// UnityEngine.Quaternion UnityEngine.Pose::rotation
Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___rotation_1;
public:
inline static int32_t get_offset_of_position_0() { return static_cast<int32_t>(offsetof(Pose_t9F30358E65733E60A1DC8682FDB7104F40C9434A, ___position_0)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_position_0() const { return ___position_0; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_position_0() { return &___position_0; }
inline void set_position_0(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___position_0 = value;
}
inline static int32_t get_offset_of_rotation_1() { return static_cast<int32_t>(offsetof(Pose_t9F30358E65733E60A1DC8682FDB7104F40C9434A, ___rotation_1)); }
inline Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 get_rotation_1() const { return ___rotation_1; }
inline Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 * get_address_of_rotation_1() { return &___rotation_1; }
inline void set_rotation_1(Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 value)
{
___rotation_1 = value;
}
};
struct Pose_t9F30358E65733E60A1DC8682FDB7104F40C9434A_StaticFields
{
public:
// UnityEngine.Pose UnityEngine.Pose::k_Identity
Pose_t9F30358E65733E60A1DC8682FDB7104F40C9434A ___k_Identity_2;
public:
inline static int32_t get_offset_of_k_Identity_2() { return static_cast<int32_t>(offsetof(Pose_t9F30358E65733E60A1DC8682FDB7104F40C9434A_StaticFields, ___k_Identity_2)); }
inline Pose_t9F30358E65733E60A1DC8682FDB7104F40C9434A get_k_Identity_2() const { return ___k_Identity_2; }
inline Pose_t9F30358E65733E60A1DC8682FDB7104F40C9434A * get_address_of_k_Identity_2() { return &___k_Identity_2; }
inline void set_k_Identity_2(Pose_t9F30358E65733E60A1DC8682FDB7104F40C9434A value)
{
___k_Identity_2 = value;
}
};
// UnityEngine.Ray
struct Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6
{
public:
// UnityEngine.Vector3 UnityEngine.Ray::m_Origin
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Origin_0;
// UnityEngine.Vector3 UnityEngine.Ray::m_Direction
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Direction_1;
public:
inline static int32_t get_offset_of_m_Origin_0() { return static_cast<int32_t>(offsetof(Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6, ___m_Origin_0)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_Origin_0() const { return ___m_Origin_0; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_Origin_0() { return &___m_Origin_0; }
inline void set_m_Origin_0(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_Origin_0 = value;
}
inline static int32_t get_offset_of_m_Direction_1() { return static_cast<int32_t>(offsetof(Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6, ___m_Direction_1)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_Direction_1() const { return ___m_Direction_1; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_Direction_1() { return &___m_Direction_1; }
inline void set_m_Direction_1(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_Direction_1 = value;
}
};
// Microsoft.MixedReality.Toolkit.Physics.RayStep
struct RayStep_t1BDD462CBD5B96D20141BF5AF5E2F93D60E317BF
{
public:
// UnityEngine.Vector3 Microsoft.MixedReality.Toolkit.Physics.RayStep::<Origin>k__BackingField
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___U3COriginU3Ek__BackingField_3;
// UnityEngine.Vector3 Microsoft.MixedReality.Toolkit.Physics.RayStep::<Terminus>k__BackingField
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___U3CTerminusU3Ek__BackingField_4;
// UnityEngine.Vector3 Microsoft.MixedReality.Toolkit.Physics.RayStep::<Direction>k__BackingField
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___U3CDirectionU3Ek__BackingField_5;
// System.Single Microsoft.MixedReality.Toolkit.Physics.RayStep::<Length>k__BackingField
float ___U3CLengthU3Ek__BackingField_6;
// System.Single Microsoft.MixedReality.Toolkit.Physics.RayStep::epsilon
float ___epsilon_7;
public:
inline static int32_t get_offset_of_U3COriginU3Ek__BackingField_3() { return static_cast<int32_t>(offsetof(RayStep_t1BDD462CBD5B96D20141BF5AF5E2F93D60E317BF, ___U3COriginU3Ek__BackingField_3)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_U3COriginU3Ek__BackingField_3() const { return ___U3COriginU3Ek__BackingField_3; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_U3COriginU3Ek__BackingField_3() { return &___U3COriginU3Ek__BackingField_3; }
inline void set_U3COriginU3Ek__BackingField_3(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___U3COriginU3Ek__BackingField_3 = value;
}
inline static int32_t get_offset_of_U3CTerminusU3Ek__BackingField_4() { return static_cast<int32_t>(offsetof(RayStep_t1BDD462CBD5B96D20141BF5AF5E2F93D60E317BF, ___U3CTerminusU3Ek__BackingField_4)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_U3CTerminusU3Ek__BackingField_4() const { return ___U3CTerminusU3Ek__BackingField_4; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_U3CTerminusU3Ek__BackingField_4() { return &___U3CTerminusU3Ek__BackingField_4; }
inline void set_U3CTerminusU3Ek__BackingField_4(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___U3CTerminusU3Ek__BackingField_4 = value;
}
inline static int32_t get_offset_of_U3CDirectionU3Ek__BackingField_5() { return static_cast<int32_t>(offsetof(RayStep_t1BDD462CBD5B96D20141BF5AF5E2F93D60E317BF, ___U3CDirectionU3Ek__BackingField_5)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_U3CDirectionU3Ek__BackingField_5() const { return ___U3CDirectionU3Ek__BackingField_5; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_U3CDirectionU3Ek__BackingField_5() { return &___U3CDirectionU3Ek__BackingField_5; }
inline void set_U3CDirectionU3Ek__BackingField_5(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___U3CDirectionU3Ek__BackingField_5 = value;
}
inline static int32_t get_offset_of_U3CLengthU3Ek__BackingField_6() { return static_cast<int32_t>(offsetof(RayStep_t1BDD462CBD5B96D20141BF5AF5E2F93D60E317BF, ___U3CLengthU3Ek__BackingField_6)); }
inline float get_U3CLengthU3Ek__BackingField_6() const { return ___U3CLengthU3Ek__BackingField_6; }
inline float* get_address_of_U3CLengthU3Ek__BackingField_6() { return &___U3CLengthU3Ek__BackingField_6; }
inline void set_U3CLengthU3Ek__BackingField_6(float value)
{
___U3CLengthU3Ek__BackingField_6 = value;
}
inline static int32_t get_offset_of_epsilon_7() { return static_cast<int32_t>(offsetof(RayStep_t1BDD462CBD5B96D20141BF5AF5E2F93D60E317BF, ___epsilon_7)); }
inline float get_epsilon_7() const { return ___epsilon_7; }
inline float* get_address_of_epsilon_7() { return &___epsilon_7; }
inline void set_epsilon_7(float value)
{
___epsilon_7 = value;
}
};
struct RayStep_t1BDD462CBD5B96D20141BF5AF5E2F93D60E317BF_StaticFields
{
public:
// UnityEngine.Vector3 Microsoft.MixedReality.Toolkit.Physics.RayStep::dist
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___dist_0;
// UnityEngine.Vector3 Microsoft.MixedReality.Toolkit.Physics.RayStep::dir
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___dir_1;
// UnityEngine.Vector3 Microsoft.MixedReality.Toolkit.Physics.RayStep::pos
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___pos_2;
public:
inline static int32_t get_offset_of_dist_0() { return static_cast<int32_t>(offsetof(RayStep_t1BDD462CBD5B96D20141BF5AF5E2F93D60E317BF_StaticFields, ___dist_0)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_dist_0() const { return ___dist_0; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_dist_0() { return &___dist_0; }
inline void set_dist_0(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___dist_0 = value;
}
inline static int32_t get_offset_of_dir_1() { return static_cast<int32_t>(offsetof(RayStep_t1BDD462CBD5B96D20141BF5AF5E2F93D60E317BF_StaticFields, ___dir_1)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_dir_1() const { return ___dir_1; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_dir_1() { return &___dir_1; }
inline void set_dir_1(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___dir_1 = value;
}
inline static int32_t get_offset_of_pos_2() { return static_cast<int32_t>(offsetof(RayStep_t1BDD462CBD5B96D20141BF5AF5E2F93D60E317BF_StaticFields, ___pos_2)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_pos_2() const { return ___pos_2; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_pos_2() { return &___pos_2; }
inline void set_pos_2(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___pos_2 = value;
}
};
// UnityEngine.RaycastHit
struct RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89
{
public:
// UnityEngine.Vector3 UnityEngine.RaycastHit::m_Point
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Point_0;
// UnityEngine.Vector3 UnityEngine.RaycastHit::m_Normal
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Normal_1;
// System.UInt32 UnityEngine.RaycastHit::m_FaceID
uint32_t ___m_FaceID_2;
// System.Single UnityEngine.RaycastHit::m_Distance
float ___m_Distance_3;
// UnityEngine.Vector2 UnityEngine.RaycastHit::m_UV
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___m_UV_4;
// System.Int32 UnityEngine.RaycastHit::m_Collider
int32_t ___m_Collider_5;
public:
inline static int32_t get_offset_of_m_Point_0() { return static_cast<int32_t>(offsetof(RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89, ___m_Point_0)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_Point_0() const { return ___m_Point_0; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_Point_0() { return &___m_Point_0; }
inline void set_m_Point_0(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_Point_0 = value;
}
inline static int32_t get_offset_of_m_Normal_1() { return static_cast<int32_t>(offsetof(RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89, ___m_Normal_1)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_Normal_1() const { return ___m_Normal_1; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_Normal_1() { return &___m_Normal_1; }
inline void set_m_Normal_1(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_Normal_1 = value;
}
inline static int32_t get_offset_of_m_FaceID_2() { return static_cast<int32_t>(offsetof(RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89, ___m_FaceID_2)); }
inline uint32_t get_m_FaceID_2() const { return ___m_FaceID_2; }
inline uint32_t* get_address_of_m_FaceID_2() { return &___m_FaceID_2; }
inline void set_m_FaceID_2(uint32_t value)
{
___m_FaceID_2 = value;
}
inline static int32_t get_offset_of_m_Distance_3() { return static_cast<int32_t>(offsetof(RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89, ___m_Distance_3)); }
inline float get_m_Distance_3() const { return ___m_Distance_3; }
inline float* get_address_of_m_Distance_3() { return &___m_Distance_3; }
inline void set_m_Distance_3(float value)
{
___m_Distance_3 = value;
}
inline static int32_t get_offset_of_m_UV_4() { return static_cast<int32_t>(offsetof(RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89, ___m_UV_4)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_m_UV_4() const { return ___m_UV_4; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_m_UV_4() { return &___m_UV_4; }
inline void set_m_UV_4(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___m_UV_4 = value;
}
inline static int32_t get_offset_of_m_Collider_5() { return static_cast<int32_t>(offsetof(RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89, ___m_Collider_5)); }
inline int32_t get_m_Collider_5() const { return ___m_Collider_5; }
inline int32_t* get_address_of_m_Collider_5() { return &___m_Collider_5; }
inline void set_m_Collider_5(int32_t value)
{
___m_Collider_5 = value;
}
};
// UnityEngine.RaycastHit2D
struct RaycastHit2D_t210878DAEBC96C1F69DF9883C454758724A106A4
{
public:
// UnityEngine.Vector2 UnityEngine.RaycastHit2D::m_Centroid
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___m_Centroid_0;
// UnityEngine.Vector2 UnityEngine.RaycastHit2D::m_Point
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___m_Point_1;
// UnityEngine.Vector2 UnityEngine.RaycastHit2D::m_Normal
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___m_Normal_2;
// System.Single UnityEngine.RaycastHit2D::m_Distance
float ___m_Distance_3;
// System.Single UnityEngine.RaycastHit2D::m_Fraction
float ___m_Fraction_4;
// System.Int32 UnityEngine.RaycastHit2D::m_Collider
int32_t ___m_Collider_5;
public:
inline static int32_t get_offset_of_m_Centroid_0() { return static_cast<int32_t>(offsetof(RaycastHit2D_t210878DAEBC96C1F69DF9883C454758724A106A4, ___m_Centroid_0)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_m_Centroid_0() const { return ___m_Centroid_0; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_m_Centroid_0() { return &___m_Centroid_0; }
inline void set_m_Centroid_0(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___m_Centroid_0 = value;
}
inline static int32_t get_offset_of_m_Point_1() { return static_cast<int32_t>(offsetof(RaycastHit2D_t210878DAEBC96C1F69DF9883C454758724A106A4, ___m_Point_1)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_m_Point_1() const { return ___m_Point_1; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_m_Point_1() { return &___m_Point_1; }
inline void set_m_Point_1(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___m_Point_1 = value;
}
inline static int32_t get_offset_of_m_Normal_2() { return static_cast<int32_t>(offsetof(RaycastHit2D_t210878DAEBC96C1F69DF9883C454758724A106A4, ___m_Normal_2)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_m_Normal_2() const { return ___m_Normal_2; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_m_Normal_2() { return &___m_Normal_2; }
inline void set_m_Normal_2(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___m_Normal_2 = value;
}
inline static int32_t get_offset_of_m_Distance_3() { return static_cast<int32_t>(offsetof(RaycastHit2D_t210878DAEBC96C1F69DF9883C454758724A106A4, ___m_Distance_3)); }
inline float get_m_Distance_3() const { return ___m_Distance_3; }
inline float* get_address_of_m_Distance_3() { return &___m_Distance_3; }
inline void set_m_Distance_3(float value)
{
___m_Distance_3 = value;
}
inline static int32_t get_offset_of_m_Fraction_4() { return static_cast<int32_t>(offsetof(RaycastHit2D_t210878DAEBC96C1F69DF9883C454758724A106A4, ___m_Fraction_4)); }
inline float get_m_Fraction_4() const { return ___m_Fraction_4; }
inline float* get_address_of_m_Fraction_4() { return &___m_Fraction_4; }
inline void set_m_Fraction_4(float value)
{
___m_Fraction_4 = value;
}
inline static int32_t get_offset_of_m_Collider_5() { return static_cast<int32_t>(offsetof(RaycastHit2D_t210878DAEBC96C1F69DF9883C454758724A106A4, ___m_Collider_5)); }
inline int32_t get_m_Collider_5() const { return ___m_Collider_5; }
inline int32_t* get_address_of_m_Collider_5() { return &___m_Collider_5; }
inline void set_m_Collider_5(int32_t value)
{
___m_Collider_5 = value;
}
};
// UnityEngine.EventSystems.RaycastResult
struct RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE
{
public:
// UnityEngine.GameObject UnityEngine.EventSystems.RaycastResult::m_GameObject
GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * ___m_GameObject_0;
// UnityEngine.EventSystems.BaseRaycaster UnityEngine.EventSystems.RaycastResult::module
BaseRaycaster_tBC0FB2CBE6D3D40991EC20F689C43F76AD82A876 * ___module_1;
// System.Single UnityEngine.EventSystems.RaycastResult::distance
float ___distance_2;
// System.Single UnityEngine.EventSystems.RaycastResult::index
float ___index_3;
// System.Int32 UnityEngine.EventSystems.RaycastResult::depth
int32_t ___depth_4;
// System.Int32 UnityEngine.EventSystems.RaycastResult::sortingLayer
int32_t ___sortingLayer_5;
// System.Int32 UnityEngine.EventSystems.RaycastResult::sortingOrder
int32_t ___sortingOrder_6;
// UnityEngine.Vector3 UnityEngine.EventSystems.RaycastResult::worldPosition
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___worldPosition_7;
// UnityEngine.Vector3 UnityEngine.EventSystems.RaycastResult::worldNormal
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___worldNormal_8;
// UnityEngine.Vector2 UnityEngine.EventSystems.RaycastResult::screenPosition
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___screenPosition_9;
// System.Int32 UnityEngine.EventSystems.RaycastResult::displayIndex
int32_t ___displayIndex_10;
public:
inline static int32_t get_offset_of_m_GameObject_0() { return static_cast<int32_t>(offsetof(RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE, ___m_GameObject_0)); }
inline GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * get_m_GameObject_0() const { return ___m_GameObject_0; }
inline GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 ** get_address_of_m_GameObject_0() { return &___m_GameObject_0; }
inline void set_m_GameObject_0(GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * value)
{
___m_GameObject_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_GameObject_0), (void*)value);
}
inline static int32_t get_offset_of_module_1() { return static_cast<int32_t>(offsetof(RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE, ___module_1)); }
inline BaseRaycaster_tBC0FB2CBE6D3D40991EC20F689C43F76AD82A876 * get_module_1() const { return ___module_1; }
inline BaseRaycaster_tBC0FB2CBE6D3D40991EC20F689C43F76AD82A876 ** get_address_of_module_1() { return &___module_1; }
inline void set_module_1(BaseRaycaster_tBC0FB2CBE6D3D40991EC20F689C43F76AD82A876 * value)
{
___module_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___module_1), (void*)value);
}
inline static int32_t get_offset_of_distance_2() { return static_cast<int32_t>(offsetof(RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE, ___distance_2)); }
inline float get_distance_2() const { return ___distance_2; }
inline float* get_address_of_distance_2() { return &___distance_2; }
inline void set_distance_2(float value)
{
___distance_2 = value;
}
inline static int32_t get_offset_of_index_3() { return static_cast<int32_t>(offsetof(RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE, ___index_3)); }
inline float get_index_3() const { return ___index_3; }
inline float* get_address_of_index_3() { return &___index_3; }
inline void set_index_3(float value)
{
___index_3 = value;
}
inline static int32_t get_offset_of_depth_4() { return static_cast<int32_t>(offsetof(RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE, ___depth_4)); }
inline int32_t get_depth_4() const { return ___depth_4; }
inline int32_t* get_address_of_depth_4() { return &___depth_4; }
inline void set_depth_4(int32_t value)
{
___depth_4 = value;
}
inline static int32_t get_offset_of_sortingLayer_5() { return static_cast<int32_t>(offsetof(RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE, ___sortingLayer_5)); }
inline int32_t get_sortingLayer_5() const { return ___sortingLayer_5; }
inline int32_t* get_address_of_sortingLayer_5() { return &___sortingLayer_5; }
inline void set_sortingLayer_5(int32_t value)
{
___sortingLayer_5 = value;
}
inline static int32_t get_offset_of_sortingOrder_6() { return static_cast<int32_t>(offsetof(RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE, ___sortingOrder_6)); }
inline int32_t get_sortingOrder_6() const { return ___sortingOrder_6; }
inline int32_t* get_address_of_sortingOrder_6() { return &___sortingOrder_6; }
inline void set_sortingOrder_6(int32_t value)
{
___sortingOrder_6 = value;
}
inline static int32_t get_offset_of_worldPosition_7() { return static_cast<int32_t>(offsetof(RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE, ___worldPosition_7)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_worldPosition_7() const { return ___worldPosition_7; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_worldPosition_7() { return &___worldPosition_7; }
inline void set_worldPosition_7(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___worldPosition_7 = value;
}
inline static int32_t get_offset_of_worldNormal_8() { return static_cast<int32_t>(offsetof(RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE, ___worldNormal_8)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_worldNormal_8() const { return ___worldNormal_8; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_worldNormal_8() { return &___worldNormal_8; }
inline void set_worldNormal_8(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___worldNormal_8 = value;
}
inline static int32_t get_offset_of_screenPosition_9() { return static_cast<int32_t>(offsetof(RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE, ___screenPosition_9)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_screenPosition_9() const { return ___screenPosition_9; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_screenPosition_9() { return &___screenPosition_9; }
inline void set_screenPosition_9(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___screenPosition_9 = value;
}
inline static int32_t get_offset_of_displayIndex_10() { return static_cast<int32_t>(offsetof(RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE, ___displayIndex_10)); }
inline int32_t get_displayIndex_10() const { return ___displayIndex_10; }
inline int32_t* get_address_of_displayIndex_10() { return &___displayIndex_10; }
inline void set_displayIndex_10(int32_t value)
{
___displayIndex_10 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.EventSystems.RaycastResult
struct RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE_marshaled_pinvoke
{
GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * ___m_GameObject_0;
BaseRaycaster_tBC0FB2CBE6D3D40991EC20F689C43F76AD82A876 * ___module_1;
float ___distance_2;
float ___index_3;
int32_t ___depth_4;
int32_t ___sortingLayer_5;
int32_t ___sortingOrder_6;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___worldPosition_7;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___worldNormal_8;
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___screenPosition_9;
int32_t ___displayIndex_10;
};
// Native definition for COM marshalling of UnityEngine.EventSystems.RaycastResult
struct RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE_marshaled_com
{
GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * ___m_GameObject_0;
BaseRaycaster_tBC0FB2CBE6D3D40991EC20F689C43F76AD82A876 * ___module_1;
float ___distance_2;
float ___index_3;
int32_t ___depth_4;
int32_t ___sortingLayer_5;
int32_t ___sortingOrder_6;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___worldPosition_7;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___worldNormal_8;
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___screenPosition_9;
int32_t ___displayIndex_10;
};
// System.RuntimeFieldHandle
struct RuntimeFieldHandle_t7BE65FC857501059EBAC9772C93B02CD413D9C96
{
public:
// System.IntPtr System.RuntimeFieldHandle::value
intptr_t ___value_0;
public:
inline static int32_t get_offset_of_value_0() { return static_cast<int32_t>(offsetof(RuntimeFieldHandle_t7BE65FC857501059EBAC9772C93B02CD413D9C96, ___value_0)); }
inline intptr_t get_value_0() const { return ___value_0; }
inline intptr_t* get_address_of_value_0() { return &___value_0; }
inline void set_value_0(intptr_t value)
{
___value_0 = value;
}
};
// System.RuntimeMethodHandle
struct RuntimeMethodHandle_t8974037C4FE5F6C3AE7D3731057CDB2891A21C9A
{
public:
// System.IntPtr System.RuntimeMethodHandle::value
intptr_t ___value_0;
public:
inline static int32_t get_offset_of_value_0() { return static_cast<int32_t>(offsetof(RuntimeMethodHandle_t8974037C4FE5F6C3AE7D3731057CDB2891A21C9A, ___value_0)); }
inline intptr_t get_value_0() const { return ___value_0; }
inline intptr_t* get_address_of_value_0() { return &___value_0; }
inline void set_value_0(intptr_t value)
{
___value_0 = value;
}
};
// System.RuntimeTypeHandle
struct RuntimeTypeHandle_tC33965ADA3E041E0C94AF05E5CB527B56482CEF9
{
public:
// System.IntPtr System.RuntimeTypeHandle::value
intptr_t ___value_0;
public:
inline static int32_t get_offset_of_value_0() { return static_cast<int32_t>(offsetof(RuntimeTypeHandle_tC33965ADA3E041E0C94AF05E5CB527B56482CEF9, ___value_0)); }
inline intptr_t get_value_0() const { return ___value_0; }
inline intptr_t* get_address_of_value_0() { return &___value_0; }
inline void set_value_0(intptr_t value)
{
___value_0 = value;
}
};
// UnityEngine.Rendering.ScriptableRenderContext
struct ScriptableRenderContext_tEDDDFFA7401E6860E1D82DFD779B7A101939F52D
{
public:
// System.IntPtr UnityEngine.Rendering.ScriptableRenderContext::m_Ptr
intptr_t ___m_Ptr_1;
public:
inline static int32_t get_offset_of_m_Ptr_1() { return static_cast<int32_t>(offsetof(ScriptableRenderContext_tEDDDFFA7401E6860E1D82DFD779B7A101939F52D, ___m_Ptr_1)); }
inline intptr_t get_m_Ptr_1() const { return ___m_Ptr_1; }
inline intptr_t* get_address_of_m_Ptr_1() { return &___m_Ptr_1; }
inline void set_m_Ptr_1(intptr_t value)
{
___m_Ptr_1 = value;
}
};
struct ScriptableRenderContext_tEDDDFFA7401E6860E1D82DFD779B7A101939F52D_StaticFields
{
public:
// UnityEngine.Rendering.ShaderTagId UnityEngine.Rendering.ScriptableRenderContext::kRenderTypeTag
ShaderTagId_t51914C89B8119195DACD234D1A624AAB7A07F795 ___kRenderTypeTag_0;
public:
inline static int32_t get_offset_of_kRenderTypeTag_0() { return static_cast<int32_t>(offsetof(ScriptableRenderContext_tEDDDFFA7401E6860E1D82DFD779B7A101939F52D_StaticFields, ___kRenderTypeTag_0)); }
inline ShaderTagId_t51914C89B8119195DACD234D1A624AAB7A07F795 get_kRenderTypeTag_0() const { return ___kRenderTypeTag_0; }
inline ShaderTagId_t51914C89B8119195DACD234D1A624AAB7A07F795 * get_address_of_kRenderTypeTag_0() { return &___kRenderTypeTag_0; }
inline void set_kRenderTypeTag_0(ShaderTagId_t51914C89B8119195DACD234D1A624AAB7A07F795 value)
{
___kRenderTypeTag_0 = value;
}
};
// Microsoft.MixedReality.Toolkit.UI.ShaderPropertyType
struct ShaderPropertyType_t353134E9210F62702235725302AC4325CF05A555
{
public:
// System.Int32 Microsoft.MixedReality.Toolkit.UI.ShaderPropertyType::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(ShaderPropertyType_t353134E9210F62702235725302AC4325CF05A555, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Runtime.Serialization.StreamingContextStates
struct StreamingContextStates_tF4C7FE6D6121BD4C67699869C8269A60B36B42C3
{
public:
// System.Int32 System.Runtime.Serialization.StreamingContextStates::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(StreamingContextStates_tF4C7FE6D6121BD4C67699869C8269A60B36B42C3, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.TextureFormat
struct TextureFormat_tBED5388A0445FE978F97B41D247275B036407932
{
public:
// System.Int32 UnityEngine.TextureFormat::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(TextureFormat_tBED5388A0445FE978F97B41D247275B036407932, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.TimeSpan
struct TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203
{
public:
// System.Int64 System.TimeSpan::_ticks
int64_t ____ticks_3;
public:
inline static int32_t get_offset_of__ticks_3() { return static_cast<int32_t>(offsetof(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203, ____ticks_3)); }
inline int64_t get__ticks_3() const { return ____ticks_3; }
inline int64_t* get_address_of__ticks_3() { return &____ticks_3; }
inline void set__ticks_3(int64_t value)
{
____ticks_3 = value;
}
};
struct TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203_StaticFields
{
public:
// System.TimeSpan System.TimeSpan::Zero
TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ___Zero_0;
// System.TimeSpan System.TimeSpan::MaxValue
TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ___MaxValue_1;
// System.TimeSpan System.TimeSpan::MinValue
TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ___MinValue_2;
// System.Boolean modreq(System.Runtime.CompilerServices.IsVolatile) System.TimeSpan::_legacyConfigChecked
bool ____legacyConfigChecked_4;
// System.Boolean modreq(System.Runtime.CompilerServices.IsVolatile) System.TimeSpan::_legacyMode
bool ____legacyMode_5;
public:
inline static int32_t get_offset_of_Zero_0() { return static_cast<int32_t>(offsetof(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203_StaticFields, ___Zero_0)); }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 get_Zero_0() const { return ___Zero_0; }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * get_address_of_Zero_0() { return &___Zero_0; }
inline void set_Zero_0(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 value)
{
___Zero_0 = value;
}
inline static int32_t get_offset_of_MaxValue_1() { return static_cast<int32_t>(offsetof(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203_StaticFields, ___MaxValue_1)); }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 get_MaxValue_1() const { return ___MaxValue_1; }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * get_address_of_MaxValue_1() { return &___MaxValue_1; }
inline void set_MaxValue_1(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 value)
{
___MaxValue_1 = value;
}
inline static int32_t get_offset_of_MinValue_2() { return static_cast<int32_t>(offsetof(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203_StaticFields, ___MinValue_2)); }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 get_MinValue_2() const { return ___MinValue_2; }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * get_address_of_MinValue_2() { return &___MinValue_2; }
inline void set_MinValue_2(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 value)
{
___MinValue_2 = value;
}
inline static int32_t get_offset_of__legacyConfigChecked_4() { return static_cast<int32_t>(offsetof(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203_StaticFields, ____legacyConfigChecked_4)); }
inline bool get__legacyConfigChecked_4() const { return ____legacyConfigChecked_4; }
inline bool* get_address_of__legacyConfigChecked_4() { return &____legacyConfigChecked_4; }
inline void set__legacyConfigChecked_4(bool value)
{
____legacyConfigChecked_4 = value;
}
inline static int32_t get_offset_of__legacyMode_5() { return static_cast<int32_t>(offsetof(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203_StaticFields, ____legacyMode_5)); }
inline bool get__legacyMode_5() const { return ____legacyMode_5; }
inline bool* get_address_of__legacyMode_5() { return &____legacyMode_5; }
inline void set__legacyMode_5(bool value)
{
____legacyMode_5 = value;
}
};
// UnityEngine.TouchPhase
struct TouchPhase_tB52B8A497547FB9575DE7975D13AC7D64C3A958A
{
public:
// System.Int32 UnityEngine.TouchPhase::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(TouchPhase_tB52B8A497547FB9575DE7975D13AC7D64C3A958A, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.TouchType
struct TouchType_t2EF726465ABD45681A6686BAC426814AA087C20F
{
public:
// System.Int32 UnityEngine.TouchType::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(TouchType_t2EF726465ABD45681A6686BAC426814AA087C20F, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.ARSubsystems.TrackingState
struct TrackingState_tB6996ED0D52D2A17DFACC90800705B81D370FC38
{
public:
// System.Int32 UnityEngine.XR.ARSubsystems.TrackingState::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(TrackingState_tB6996ED0D52D2A17DFACC90800705B81D370FC38, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.UICharInfo
struct UICharInfo_tDEA65B831FAD06D1E9B10A6088E05C6D615B089A
{
public:
// UnityEngine.Vector2 UnityEngine.UICharInfo::cursorPos
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___cursorPos_0;
// System.Single UnityEngine.UICharInfo::charWidth
float ___charWidth_1;
public:
inline static int32_t get_offset_of_cursorPos_0() { return static_cast<int32_t>(offsetof(UICharInfo_tDEA65B831FAD06D1E9B10A6088E05C6D615B089A, ___cursorPos_0)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_cursorPos_0() const { return ___cursorPos_0; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_cursorPos_0() { return &___cursorPos_0; }
inline void set_cursorPos_0(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___cursorPos_0 = value;
}
inline static int32_t get_offset_of_charWidth_1() { return static_cast<int32_t>(offsetof(UICharInfo_tDEA65B831FAD06D1E9B10A6088E05C6D615B089A, ___charWidth_1)); }
inline float get_charWidth_1() const { return ___charWidth_1; }
inline float* get_address_of_charWidth_1() { return &___charWidth_1; }
inline void set_charWidth_1(float value)
{
___charWidth_1 = value;
}
};
// UnityEngine.UIVertex
struct UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A
{
public:
// UnityEngine.Vector3 UnityEngine.UIVertex::position
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___position_0;
// UnityEngine.Vector3 UnityEngine.UIVertex::normal
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___normal_1;
// UnityEngine.Vector4 UnityEngine.UIVertex::tangent
Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 ___tangent_2;
// UnityEngine.Color32 UnityEngine.UIVertex::color
Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D ___color_3;
// UnityEngine.Vector4 UnityEngine.UIVertex::uv0
Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 ___uv0_4;
// UnityEngine.Vector4 UnityEngine.UIVertex::uv1
Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 ___uv1_5;
// UnityEngine.Vector4 UnityEngine.UIVertex::uv2
Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 ___uv2_6;
// UnityEngine.Vector4 UnityEngine.UIVertex::uv3
Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 ___uv3_7;
public:
inline static int32_t get_offset_of_position_0() { return static_cast<int32_t>(offsetof(UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A, ___position_0)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_position_0() const { return ___position_0; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_position_0() { return &___position_0; }
inline void set_position_0(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___position_0 = value;
}
inline static int32_t get_offset_of_normal_1() { return static_cast<int32_t>(offsetof(UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A, ___normal_1)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_normal_1() const { return ___normal_1; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_normal_1() { return &___normal_1; }
inline void set_normal_1(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___normal_1 = value;
}
inline static int32_t get_offset_of_tangent_2() { return static_cast<int32_t>(offsetof(UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A, ___tangent_2)); }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 get_tangent_2() const { return ___tangent_2; }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 * get_address_of_tangent_2() { return &___tangent_2; }
inline void set_tangent_2(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 value)
{
___tangent_2 = value;
}
inline static int32_t get_offset_of_color_3() { return static_cast<int32_t>(offsetof(UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A, ___color_3)); }
inline Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D get_color_3() const { return ___color_3; }
inline Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D * get_address_of_color_3() { return &___color_3; }
inline void set_color_3(Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D value)
{
___color_3 = value;
}
inline static int32_t get_offset_of_uv0_4() { return static_cast<int32_t>(offsetof(UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A, ___uv0_4)); }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 get_uv0_4() const { return ___uv0_4; }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 * get_address_of_uv0_4() { return &___uv0_4; }
inline void set_uv0_4(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 value)
{
___uv0_4 = value;
}
inline static int32_t get_offset_of_uv1_5() { return static_cast<int32_t>(offsetof(UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A, ___uv1_5)); }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 get_uv1_5() const { return ___uv1_5; }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 * get_address_of_uv1_5() { return &___uv1_5; }
inline void set_uv1_5(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 value)
{
___uv1_5 = value;
}
inline static int32_t get_offset_of_uv2_6() { return static_cast<int32_t>(offsetof(UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A, ___uv2_6)); }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 get_uv2_6() const { return ___uv2_6; }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 * get_address_of_uv2_6() { return &___uv2_6; }
inline void set_uv2_6(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 value)
{
___uv2_6 = value;
}
inline static int32_t get_offset_of_uv3_7() { return static_cast<int32_t>(offsetof(UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A, ___uv3_7)); }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 get_uv3_7() const { return ___uv3_7; }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 * get_address_of_uv3_7() { return &___uv3_7; }
inline void set_uv3_7(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 value)
{
___uv3_7 = value;
}
};
struct UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A_StaticFields
{
public:
// UnityEngine.Color32 UnityEngine.UIVertex::s_DefaultColor
Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D ___s_DefaultColor_8;
// UnityEngine.Vector4 UnityEngine.UIVertex::s_DefaultTangent
Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 ___s_DefaultTangent_9;
// UnityEngine.UIVertex UnityEngine.UIVertex::simpleVert
UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A ___simpleVert_10;
public:
inline static int32_t get_offset_of_s_DefaultColor_8() { return static_cast<int32_t>(offsetof(UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A_StaticFields, ___s_DefaultColor_8)); }
inline Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D get_s_DefaultColor_8() const { return ___s_DefaultColor_8; }
inline Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D * get_address_of_s_DefaultColor_8() { return &___s_DefaultColor_8; }
inline void set_s_DefaultColor_8(Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D value)
{
___s_DefaultColor_8 = value;
}
inline static int32_t get_offset_of_s_DefaultTangent_9() { return static_cast<int32_t>(offsetof(UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A_StaticFields, ___s_DefaultTangent_9)); }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 get_s_DefaultTangent_9() const { return ___s_DefaultTangent_9; }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 * get_address_of_s_DefaultTangent_9() { return &___s_DefaultTangent_9; }
inline void set_s_DefaultTangent_9(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 value)
{
___s_DefaultTangent_9 = value;
}
inline static int32_t get_offset_of_simpleVert_10() { return static_cast<int32_t>(offsetof(UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A_StaticFields, ___simpleVert_10)); }
inline UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A get_simpleVert_10() const { return ___simpleVert_10; }
inline UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A * get_address_of_simpleVert_10() { return &___simpleVert_10; }
inline void set_simpleVert_10(UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A value)
{
___simpleVert_10 = value;
}
};
// System.UInt32Enum
struct UInt32Enum_t205AC9FF1DBA9F24788030B596D7BE3A2E808EF1
{
public:
// System.UInt32 System.UInt32Enum::value__
uint32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(UInt32Enum_t205AC9FF1DBA9F24788030B596D7BE3A2E808EF1, ___value___2)); }
inline uint32_t get_value___2() const { return ___value___2; }
inline uint32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(uint32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.XRNode
struct XRNode_t07B789D60F5B3A4F0E4A169143881ABCA4176DBD
{
public:
// System.Int32 UnityEngine.XR.XRNode::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(XRNode_t07B789D60F5B3A4F0E4A169143881ABCA4176DBD, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.ARSubsystems.XRReferenceImage
struct XRReferenceImage_tB1803A72EB581FB35B2CA944973679132A1D4467
{
public:
// UnityEngine.XR.ARSubsystems.SerializableGuid UnityEngine.XR.ARSubsystems.XRReferenceImage::m_SerializedGuid
SerializableGuid_t5F8E8B4FF33F91AF9B16C6CC3F75AE00014505CC ___m_SerializedGuid_0;
// UnityEngine.XR.ARSubsystems.SerializableGuid UnityEngine.XR.ARSubsystems.XRReferenceImage::m_SerializedTextureGuid
SerializableGuid_t5F8E8B4FF33F91AF9B16C6CC3F75AE00014505CC ___m_SerializedTextureGuid_1;
// UnityEngine.Vector2 UnityEngine.XR.ARSubsystems.XRReferenceImage::m_Size
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___m_Size_2;
// System.Boolean UnityEngine.XR.ARSubsystems.XRReferenceImage::m_SpecifySize
bool ___m_SpecifySize_3;
// System.String UnityEngine.XR.ARSubsystems.XRReferenceImage::m_Name
String_t* ___m_Name_4;
// UnityEngine.Texture2D UnityEngine.XR.ARSubsystems.XRReferenceImage::m_Texture
Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF * ___m_Texture_5;
public:
inline static int32_t get_offset_of_m_SerializedGuid_0() { return static_cast<int32_t>(offsetof(XRReferenceImage_tB1803A72EB581FB35B2CA944973679132A1D4467, ___m_SerializedGuid_0)); }
inline SerializableGuid_t5F8E8B4FF33F91AF9B16C6CC3F75AE00014505CC get_m_SerializedGuid_0() const { return ___m_SerializedGuid_0; }
inline SerializableGuid_t5F8E8B4FF33F91AF9B16C6CC3F75AE00014505CC * get_address_of_m_SerializedGuid_0() { return &___m_SerializedGuid_0; }
inline void set_m_SerializedGuid_0(SerializableGuid_t5F8E8B4FF33F91AF9B16C6CC3F75AE00014505CC value)
{
___m_SerializedGuid_0 = value;
}
inline static int32_t get_offset_of_m_SerializedTextureGuid_1() { return static_cast<int32_t>(offsetof(XRReferenceImage_tB1803A72EB581FB35B2CA944973679132A1D4467, ___m_SerializedTextureGuid_1)); }
inline SerializableGuid_t5F8E8B4FF33F91AF9B16C6CC3F75AE00014505CC get_m_SerializedTextureGuid_1() const { return ___m_SerializedTextureGuid_1; }
inline SerializableGuid_t5F8E8B4FF33F91AF9B16C6CC3F75AE00014505CC * get_address_of_m_SerializedTextureGuid_1() { return &___m_SerializedTextureGuid_1; }
inline void set_m_SerializedTextureGuid_1(SerializableGuid_t5F8E8B4FF33F91AF9B16C6CC3F75AE00014505CC value)
{
___m_SerializedTextureGuid_1 = value;
}
inline static int32_t get_offset_of_m_Size_2() { return static_cast<int32_t>(offsetof(XRReferenceImage_tB1803A72EB581FB35B2CA944973679132A1D4467, ___m_Size_2)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_m_Size_2() const { return ___m_Size_2; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_m_Size_2() { return &___m_Size_2; }
inline void set_m_Size_2(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___m_Size_2 = value;
}
inline static int32_t get_offset_of_m_SpecifySize_3() { return static_cast<int32_t>(offsetof(XRReferenceImage_tB1803A72EB581FB35B2CA944973679132A1D4467, ___m_SpecifySize_3)); }
inline bool get_m_SpecifySize_3() const { return ___m_SpecifySize_3; }
inline bool* get_address_of_m_SpecifySize_3() { return &___m_SpecifySize_3; }
inline void set_m_SpecifySize_3(bool value)
{
___m_SpecifySize_3 = value;
}
inline static int32_t get_offset_of_m_Name_4() { return static_cast<int32_t>(offsetof(XRReferenceImage_tB1803A72EB581FB35B2CA944973679132A1D4467, ___m_Name_4)); }
inline String_t* get_m_Name_4() const { return ___m_Name_4; }
inline String_t** get_address_of_m_Name_4() { return &___m_Name_4; }
inline void set_m_Name_4(String_t* value)
{
___m_Name_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_Name_4), (void*)value);
}
inline static int32_t get_offset_of_m_Texture_5() { return static_cast<int32_t>(offsetof(XRReferenceImage_tB1803A72EB581FB35B2CA944973679132A1D4467, ___m_Texture_5)); }
inline Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF * get_m_Texture_5() const { return ___m_Texture_5; }
inline Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF ** get_address_of_m_Texture_5() { return &___m_Texture_5; }
inline void set_m_Texture_5(Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF * value)
{
___m_Texture_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_Texture_5), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.ARSubsystems.XRReferenceImage
struct XRReferenceImage_tB1803A72EB581FB35B2CA944973679132A1D4467_marshaled_pinvoke
{
SerializableGuid_t5F8E8B4FF33F91AF9B16C6CC3F75AE00014505CC ___m_SerializedGuid_0;
SerializableGuid_t5F8E8B4FF33F91AF9B16C6CC3F75AE00014505CC ___m_SerializedTextureGuid_1;
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___m_Size_2;
int32_t ___m_SpecifySize_3;
char* ___m_Name_4;
Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF * ___m_Texture_5;
};
// Native definition for COM marshalling of UnityEngine.XR.ARSubsystems.XRReferenceImage
struct XRReferenceImage_tB1803A72EB581FB35B2CA944973679132A1D4467_marshaled_com
{
SerializableGuid_t5F8E8B4FF33F91AF9B16C6CC3F75AE00014505CC ___m_SerializedGuid_0;
SerializableGuid_t5F8E8B4FF33F91AF9B16C6CC3F75AE00014505CC ___m_SerializedTextureGuid_1;
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___m_Size_2;
int32_t ___m_SpecifySize_3;
Il2CppChar* ___m_Name_4;
Texture2D_t9B604D0D8E28032123641A7E7338FA872E2698BF * ___m_Texture_5;
};
// UnityEngine.Camera/RenderRequestMode
struct RenderRequestMode_tCB120B82DED523ADBA2D6093A1A8ABF17D94A313
{
public:
// System.Int32 UnityEngine.Camera/RenderRequestMode::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(RenderRequestMode_tCB120B82DED523ADBA2D6093A1A8ABF17D94A313, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.Camera/RenderRequestOutputSpace
struct RenderRequestOutputSpace_t8EB93E4720B2D1BAB624A04ADB473C37C7F3D6A5
{
public:
// System.Int32 UnityEngine.Camera/RenderRequestOutputSpace::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(RenderRequestOutputSpace_t8EB93E4720B2D1BAB624A04ADB473C37C7F3D6A5, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorField/FieldTypes
struct FieldTypes_t36DB12D15BD91868F40CF4DA209EECA8BB377668
{
public:
// System.Int32 Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorField/FieldTypes::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(FieldTypes_t36DB12D15BD91868F40CF4DA209EECA8BB377668, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MagicLeap.MLAppConnect/PipeDirection
struct PipeDirection_tE389ECF3AD3312D12AA40C1ACA635964494BAAE7
{
public:
// System.Int32 UnityEngine.XR.MagicLeap.MLAppConnect/PipeDirection::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(PipeDirection_tE389ECF3AD3312D12AA40C1ACA635964494BAAE7, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MagicLeap.MLAppConnect/PipeType
struct PipeType_tD0721A5C1E8A62B6D852D3F80698EFD3836ED9E9
{
public:
// System.Int32 UnityEngine.XR.MagicLeap.MLAppConnect/PipeType::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(PipeType_tD0721A5C1E8A62B6D852D3F80698EFD3836ED9E9, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MagicLeap.MLAudio/SampleFormatType
struct SampleFormatType_t8EBB3BBE86661814EDE08C00C67D03094F145CC7
{
public:
// System.UInt32 UnityEngine.XR.MagicLeap.MLAudio/SampleFormatType::value__
uint32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(SampleFormatType_t8EBB3BBE86661814EDE08C00C67D03094F145CC7, ___value___2)); }
inline uint32_t get_value___2() const { return ___value___2; }
inline uint32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(uint32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MagicLeap.MLBluetoothLE/AttributePermissions
struct AttributePermissions_t8EED5C14E5808474977CE11CE9B81924C458767A
{
public:
// System.Int32 UnityEngine.XR.MagicLeap.MLBluetoothLE/AttributePermissions::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(AttributePermissions_t8EED5C14E5808474977CE11CE9B81924C458767A, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MagicLeap.MLBluetoothLE/CharacteristicProperties
struct CharacteristicProperties_tBA909FBA5EFF010FAA1799482410D01C1931C1E0
{
public:
// System.Int32 UnityEngine.XR.MagicLeap.MLBluetoothLE/CharacteristicProperties::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(CharacteristicProperties_tBA909FBA5EFF010FAA1799482410D01C1931C1E0, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MagicLeap.MLBluetoothLE/DeviceType
struct DeviceType_t344092C06819A6E8532B7013B5001296301F4634
{
public:
// System.UInt32 UnityEngine.XR.MagicLeap.MLBluetoothLE/DeviceType::value__
uint32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(DeviceType_t344092C06819A6E8532B7013B5001296301F4634, ___value___2)); }
inline uint32_t get_value___2() const { return ___value___2; }
inline uint32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(uint32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MagicLeap.MLBluetoothLE/WriteType
struct WriteType_tCF8E4F9004A77A8922D660BF99F060787EE17660
{
public:
// System.Int32 UnityEngine.XR.MagicLeap.MLBluetoothLE/WriteType::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(WriteType_tCF8E4F9004A77A8922D660BF99F060787EE17660, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MagicLeap.MLConnections/InvitationDeliveryStatus
struct InvitationDeliveryStatus_tF36A9D0C4ECB9B1B6C9912374D741C9CEF3400C8
{
public:
// System.UInt32 UnityEngine.XR.MagicLeap.MLConnections/InvitationDeliveryStatus::value__
uint32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(InvitationDeliveryStatus_tF36A9D0C4ECB9B1B6C9912374D741C9CEF3400C8, ___value___2)); }
inline uint32_t get_value___2() const { return ___value___2; }
inline uint32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(uint32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MagicLeap.MLConnections/InviteStatus
struct InviteStatus_t4A032B69EF0B4D99A4616F16C96CB02E5BA408C7
{
public:
// System.UInt32 UnityEngine.XR.MagicLeap.MLConnections/InviteStatus::value__
uint32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(InviteStatus_t4A032B69EF0B4D99A4616F16C96CB02E5BA408C7, ___value___2)); }
inline uint32_t get_value___2() const { return ___value___2; }
inline uint32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(uint32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MagicLeap.MLContacts/OperationStatus
struct OperationStatus_t37D5121AEDAC8C7EB7AF9941E678DD6A42914A76
{
public:
// System.Int32 UnityEngine.XR.MagicLeap.MLContacts/OperationStatus::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(OperationStatus_t37D5121AEDAC8C7EB7AF9941E678DD6A42914A76, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MagicLeap.MLInput/TabletDeviceStateMask
struct TabletDeviceStateMask_tA408FEA59A6728B1BF3D87996441E197CB37031A
{
public:
// System.UInt32 UnityEngine.XR.MagicLeap.MLInput/TabletDeviceStateMask::value__
uint32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(TabletDeviceStateMask_tA408FEA59A6728B1BF3D87996441E197CB37031A, ___value___2)); }
inline uint32_t get_value___2() const { return ___value___2; }
inline uint32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(uint32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MagicLeap.MLInput/TabletDeviceToolType
struct TabletDeviceToolType_t5A771F8047E1630DF570D878610A126C22AF2818
{
public:
// System.UInt32 UnityEngine.XR.MagicLeap.MLInput/TabletDeviceToolType::value__
uint32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(TabletDeviceToolType_t5A771F8047E1630DF570D878610A126C22AF2818, ___value___2)); }
inline uint32_t get_value___2() const { return ___value___2; }
inline uint32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(uint32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MagicLeap.MLInput/TabletDeviceType
struct TabletDeviceType_tD84E110EC46E24B01F5CE12BB35350CD7446771F
{
public:
// System.UInt32 UnityEngine.XR.MagicLeap.MLInput/TabletDeviceType::value__
uint32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(TabletDeviceType_tD84E110EC46E24B01F5CE12BB35350CD7446771F, ___value___2)); }
inline uint32_t get_value___2() const { return ___value___2; }
inline uint32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(uint32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MagicLeap.MLInputRaycasterBehavior/RaycastHitData
struct RaycastHitData_tC9D839911FFA6A7160E7E0DBD8DF17D78FCEBA6F
{
public:
// UnityEngine.UI.Graphic UnityEngine.XR.MagicLeap.MLInputRaycasterBehavior/RaycastHitData::<Graphic>k__BackingField
Graphic_tF07D777035055CF93BA5F46F77ED5EDFEFF9AE24 * ___U3CGraphicU3Ek__BackingField_0;
// UnityEngine.Vector3 UnityEngine.XR.MagicLeap.MLInputRaycasterBehavior/RaycastHitData::<WorldHitPosition>k__BackingField
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___U3CWorldHitPositionU3Ek__BackingField_1;
// UnityEngine.Vector3 UnityEngine.XR.MagicLeap.MLInputRaycasterBehavior/RaycastHitData::<WorldHitNormal>k__BackingField
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___U3CWorldHitNormalU3Ek__BackingField_2;
// System.Single UnityEngine.XR.MagicLeap.MLInputRaycasterBehavior/RaycastHitData::<Distance>k__BackingField
float ___U3CDistanceU3Ek__BackingField_3;
public:
inline static int32_t get_offset_of_U3CGraphicU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(RaycastHitData_tC9D839911FFA6A7160E7E0DBD8DF17D78FCEBA6F, ___U3CGraphicU3Ek__BackingField_0)); }
inline Graphic_tF07D777035055CF93BA5F46F77ED5EDFEFF9AE24 * get_U3CGraphicU3Ek__BackingField_0() const { return ___U3CGraphicU3Ek__BackingField_0; }
inline Graphic_tF07D777035055CF93BA5F46F77ED5EDFEFF9AE24 ** get_address_of_U3CGraphicU3Ek__BackingField_0() { return &___U3CGraphicU3Ek__BackingField_0; }
inline void set_U3CGraphicU3Ek__BackingField_0(Graphic_tF07D777035055CF93BA5F46F77ED5EDFEFF9AE24 * value)
{
___U3CGraphicU3Ek__BackingField_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CGraphicU3Ek__BackingField_0), (void*)value);
}
inline static int32_t get_offset_of_U3CWorldHitPositionU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(RaycastHitData_tC9D839911FFA6A7160E7E0DBD8DF17D78FCEBA6F, ___U3CWorldHitPositionU3Ek__BackingField_1)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_U3CWorldHitPositionU3Ek__BackingField_1() const { return ___U3CWorldHitPositionU3Ek__BackingField_1; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_U3CWorldHitPositionU3Ek__BackingField_1() { return &___U3CWorldHitPositionU3Ek__BackingField_1; }
inline void set_U3CWorldHitPositionU3Ek__BackingField_1(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___U3CWorldHitPositionU3Ek__BackingField_1 = value;
}
inline static int32_t get_offset_of_U3CWorldHitNormalU3Ek__BackingField_2() { return static_cast<int32_t>(offsetof(RaycastHitData_tC9D839911FFA6A7160E7E0DBD8DF17D78FCEBA6F, ___U3CWorldHitNormalU3Ek__BackingField_2)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_U3CWorldHitNormalU3Ek__BackingField_2() const { return ___U3CWorldHitNormalU3Ek__BackingField_2; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_U3CWorldHitNormalU3Ek__BackingField_2() { return &___U3CWorldHitNormalU3Ek__BackingField_2; }
inline void set_U3CWorldHitNormalU3Ek__BackingField_2(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___U3CWorldHitNormalU3Ek__BackingField_2 = value;
}
inline static int32_t get_offset_of_U3CDistanceU3Ek__BackingField_3() { return static_cast<int32_t>(offsetof(RaycastHitData_tC9D839911FFA6A7160E7E0DBD8DF17D78FCEBA6F, ___U3CDistanceU3Ek__BackingField_3)); }
inline float get_U3CDistanceU3Ek__BackingField_3() const { return ___U3CDistanceU3Ek__BackingField_3; }
inline float* get_address_of_U3CDistanceU3Ek__BackingField_3() { return &___U3CDistanceU3Ek__BackingField_3; }
inline void set_U3CDistanceU3Ek__BackingField_3(float value)
{
___U3CDistanceU3Ek__BackingField_3 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MagicLeap.MLInputRaycasterBehavior/RaycastHitData
struct RaycastHitData_tC9D839911FFA6A7160E7E0DBD8DF17D78FCEBA6F_marshaled_pinvoke
{
Graphic_tF07D777035055CF93BA5F46F77ED5EDFEFF9AE24 * ___U3CGraphicU3Ek__BackingField_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___U3CWorldHitPositionU3Ek__BackingField_1;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___U3CWorldHitNormalU3Ek__BackingField_2;
float ___U3CDistanceU3Ek__BackingField_3;
};
// Native definition for COM marshalling of UnityEngine.XR.MagicLeap.MLInputRaycasterBehavior/RaycastHitData
struct RaycastHitData_tC9D839911FFA6A7160E7E0DBD8DF17D78FCEBA6F_marshaled_com
{
Graphic_tF07D777035055CF93BA5F46F77ED5EDFEFF9AE24 * ___U3CGraphicU3Ek__BackingField_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___U3CWorldHitPositionU3Ek__BackingField_1;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___U3CWorldHitNormalU3Ek__BackingField_2;
float ___U3CDistanceU3Ek__BackingField_3;
};
// UnityEngine.XR.MagicLeap.MLMRCamera/OutputFormat
struct OutputFormat_tDC3F4B5F31B675CDE9223BE14A38F1452DFBDF98
{
public:
// System.Int32 UnityEngine.XR.MagicLeap.MLMRCamera/OutputFormat::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(OutputFormat_tDC3F4B5F31B675CDE9223BE14A38F1452DFBDF98, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MagicLeap.MLMediaPlayer/Cea708CaptionEmitCommand
struct Cea708CaptionEmitCommand_t47FFB2B354CAE4948767C3299ADE1671DED67A18
{
public:
// System.Int32 UnityEngine.XR.MagicLeap.MLMediaPlayer/Cea708CaptionEmitCommand::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(Cea708CaptionEmitCommand_t47FFB2B354CAE4948767C3299ADE1671DED67A18, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MagicLeap.MLMediaPlayer/MediaPlayerTracks
struct MediaPlayerTracks_tEAC176EC77BB5617A82189EC66BC4AAEAF613CF7
{
public:
// System.IntPtr UnityEngine.XR.MagicLeap.MLMediaPlayer/MediaPlayerTracks::Tracks
intptr_t ___Tracks_0;
// System.UInt32 UnityEngine.XR.MagicLeap.MLMediaPlayer/MediaPlayerTracks::Length
uint32_t ___Length_1;
public:
inline static int32_t get_offset_of_Tracks_0() { return static_cast<int32_t>(offsetof(MediaPlayerTracks_tEAC176EC77BB5617A82189EC66BC4AAEAF613CF7, ___Tracks_0)); }
inline intptr_t get_Tracks_0() const { return ___Tracks_0; }
inline intptr_t* get_address_of_Tracks_0() { return &___Tracks_0; }
inline void set_Tracks_0(intptr_t value)
{
___Tracks_0 = value;
}
inline static int32_t get_offset_of_Length_1() { return static_cast<int32_t>(offsetof(MediaPlayerTracks_tEAC176EC77BB5617A82189EC66BC4AAEAF613CF7, ___Length_1)); }
inline uint32_t get_Length_1() const { return ___Length_1; }
inline uint32_t* get_address_of_Length_1() { return &___Length_1; }
inline void set_Length_1(uint32_t value)
{
___Length_1 = value;
}
};
// UnityEngine.XR.MagicLeap.MLMediaPlayer/PlayerTrackType
struct PlayerTrackType_t214DFBDB13C9572A3C2D036FC7319691A8AF6980
{
public:
// System.UInt32 UnityEngine.XR.MagicLeap.MLMediaPlayer/PlayerTrackType::value__
uint32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(PlayerTrackType_t214DFBDB13C9572A3C2D036FC7319691A8AF6980, ___value___2)); }
inline uint32_t get_value___2() const { return ___value___2; }
inline uint32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(uint32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MagicLeap.MLMusicService/ErrorType
struct ErrorType_t1B9A5605C994D7B34D00468D72F37B8F4FAA3E9A
{
public:
// System.UInt32 UnityEngine.XR.MagicLeap.MLMusicService/ErrorType::value__
uint32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(ErrorType_t1B9A5605C994D7B34D00468D72F37B8F4FAA3E9A, ___value___2)); }
inline uint32_t get_value___2() const { return ___value___2; }
inline uint32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(uint32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MagicLeap.MLRaycast/ResultState
struct ResultState_tB68151984EB584112578A91B1A656323B40288EF
{
public:
// System.Int32 UnityEngine.XR.MagicLeap.MLRaycast/ResultState::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(ResultState_tB68151984EB584112578A91B1A656323B40288EF, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MagicLeap.MLResult/Code
struct Code_t188333EEE5268C7988596D9ED31D430EF7C049D8
{
public:
// System.Int32 UnityEngine.XR.MagicLeap.MLResult/Code::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(Code_t188333EEE5268C7988596D9ED31D430EF7C049D8, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// Microsoft.MixedReality.Toolkit.UI.ManipulationHandler/PointerData
struct PointerData_tC90DB32A4F2EF1FC975FEAE81DE66BC21FE1351F
{
public:
// Microsoft.MixedReality.Toolkit.Input.IMixedRealityPointer Microsoft.MixedReality.Toolkit.UI.ManipulationHandler/PointerData::pointer
RuntimeObject* ___pointer_0;
// UnityEngine.Vector3 Microsoft.MixedReality.Toolkit.UI.ManipulationHandler/PointerData::initialGrabPointInPointer
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___initialGrabPointInPointer_1;
public:
inline static int32_t get_offset_of_pointer_0() { return static_cast<int32_t>(offsetof(PointerData_tC90DB32A4F2EF1FC975FEAE81DE66BC21FE1351F, ___pointer_0)); }
inline RuntimeObject* get_pointer_0() const { return ___pointer_0; }
inline RuntimeObject** get_address_of_pointer_0() { return &___pointer_0; }
inline void set_pointer_0(RuntimeObject* value)
{
___pointer_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___pointer_0), (void*)value);
}
inline static int32_t get_offset_of_initialGrabPointInPointer_1() { return static_cast<int32_t>(offsetof(PointerData_tC90DB32A4F2EF1FC975FEAE81DE66BC21FE1351F, ___initialGrabPointInPointer_1)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_initialGrabPointInPointer_1() const { return ___initialGrabPointInPointer_1; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_initialGrabPointInPointer_1() { return &___initialGrabPointInPointer_1; }
inline void set_initialGrabPointInPointer_1(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___initialGrabPointInPointer_1 = value;
}
};
// Native definition for P/Invoke marshalling of Microsoft.MixedReality.Toolkit.UI.ManipulationHandler/PointerData
struct PointerData_tC90DB32A4F2EF1FC975FEAE81DE66BC21FE1351F_marshaled_pinvoke
{
RuntimeObject* ___pointer_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___initialGrabPointInPointer_1;
};
// Native definition for COM marshalling of Microsoft.MixedReality.Toolkit.UI.ManipulationHandler/PointerData
struct PointerData_tC90DB32A4F2EF1FC975FEAE81DE66BC21FE1351F_marshaled_com
{
RuntimeObject* ___pointer_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___initialGrabPointInPointer_1;
};
// UnityEngine.UI.Navigation/Mode
struct Mode_t3113FDF05158BBA1DFC78D7F69E4C1D25135CB0F
{
public:
// System.Int32 UnityEngine.UI.Navigation/Mode::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(Mode_t3113FDF05158BBA1DFC78D7F69E4C1D25135CB0F, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// Microsoft.MixedReality.Toolkit.UI.ObjectManipulator/PointerData
struct PointerData_t217FAEE1441F0ADC5F7B08E3987B1C08E48B7DD4
{
public:
// Microsoft.MixedReality.Toolkit.Input.IMixedRealityPointer Microsoft.MixedReality.Toolkit.UI.ObjectManipulator/PointerData::pointer
RuntimeObject* ___pointer_0;
// UnityEngine.Vector3 Microsoft.MixedReality.Toolkit.UI.ObjectManipulator/PointerData::initialGrabPointInPointer
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___initialGrabPointInPointer_1;
public:
inline static int32_t get_offset_of_pointer_0() { return static_cast<int32_t>(offsetof(PointerData_t217FAEE1441F0ADC5F7B08E3987B1C08E48B7DD4, ___pointer_0)); }
inline RuntimeObject* get_pointer_0() const { return ___pointer_0; }
inline RuntimeObject** get_address_of_pointer_0() { return &___pointer_0; }
inline void set_pointer_0(RuntimeObject* value)
{
___pointer_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___pointer_0), (void*)value);
}
inline static int32_t get_offset_of_initialGrabPointInPointer_1() { return static_cast<int32_t>(offsetof(PointerData_t217FAEE1441F0ADC5F7B08E3987B1C08E48B7DD4, ___initialGrabPointInPointer_1)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_initialGrabPointInPointer_1() const { return ___initialGrabPointInPointer_1; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_initialGrabPointInPointer_1() { return &___initialGrabPointInPointer_1; }
inline void set_initialGrabPointInPointer_1(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___initialGrabPointInPointer_1 = value;
}
};
// Native definition for P/Invoke marshalling of Microsoft.MixedReality.Toolkit.UI.ObjectManipulator/PointerData
struct PointerData_t217FAEE1441F0ADC5F7B08E3987B1C08E48B7DD4_marshaled_pinvoke
{
RuntimeObject* ___pointer_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___initialGrabPointInPointer_1;
};
// Native definition for COM marshalling of Microsoft.MixedReality.Toolkit.UI.ObjectManipulator/PointerData
struct PointerData_t217FAEE1441F0ADC5F7B08E3987B1C08E48B7DD4_marshaled_com
{
RuntimeObject* ___pointer_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___initialGrabPointInPointer_1;
};
// TMPro.SpriteAssetUtilities.TexturePacker_JsonArray/Frame
struct Frame_t277B57D2C572A3B179CEA0357869DB245F52128D
{
public:
// System.String TMPro.SpriteAssetUtilities.TexturePacker_JsonArray/Frame::filename
String_t* ___filename_0;
// TMPro.SpriteAssetUtilities.TexturePacker_JsonArray/SpriteFrame TMPro.SpriteAssetUtilities.TexturePacker_JsonArray/Frame::frame
SpriteFrame_t5B610F44C5943B89962CC8CC4245EECDE29E94D9 ___frame_1;
// System.Boolean TMPro.SpriteAssetUtilities.TexturePacker_JsonArray/Frame::rotated
bool ___rotated_2;
// System.Boolean TMPro.SpriteAssetUtilities.TexturePacker_JsonArray/Frame::trimmed
bool ___trimmed_3;
// TMPro.SpriteAssetUtilities.TexturePacker_JsonArray/SpriteFrame TMPro.SpriteAssetUtilities.TexturePacker_JsonArray/Frame::spriteSourceSize
SpriteFrame_t5B610F44C5943B89962CC8CC4245EECDE29E94D9 ___spriteSourceSize_4;
// TMPro.SpriteAssetUtilities.TexturePacker_JsonArray/SpriteSize TMPro.SpriteAssetUtilities.TexturePacker_JsonArray/Frame::sourceSize
SpriteSize_t7D47B39A52139B8CD3CE7F233C48981F70275A3D ___sourceSize_5;
// UnityEngine.Vector2 TMPro.SpriteAssetUtilities.TexturePacker_JsonArray/Frame::pivot
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___pivot_6;
public:
inline static int32_t get_offset_of_filename_0() { return static_cast<int32_t>(offsetof(Frame_t277B57D2C572A3B179CEA0357869DB245F52128D, ___filename_0)); }
inline String_t* get_filename_0() const { return ___filename_0; }
inline String_t** get_address_of_filename_0() { return &___filename_0; }
inline void set_filename_0(String_t* value)
{
___filename_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___filename_0), (void*)value);
}
inline static int32_t get_offset_of_frame_1() { return static_cast<int32_t>(offsetof(Frame_t277B57D2C572A3B179CEA0357869DB245F52128D, ___frame_1)); }
inline SpriteFrame_t5B610F44C5943B89962CC8CC4245EECDE29E94D9 get_frame_1() const { return ___frame_1; }
inline SpriteFrame_t5B610F44C5943B89962CC8CC4245EECDE29E94D9 * get_address_of_frame_1() { return &___frame_1; }
inline void set_frame_1(SpriteFrame_t5B610F44C5943B89962CC8CC4245EECDE29E94D9 value)
{
___frame_1 = value;
}
inline static int32_t get_offset_of_rotated_2() { return static_cast<int32_t>(offsetof(Frame_t277B57D2C572A3B179CEA0357869DB245F52128D, ___rotated_2)); }
inline bool get_rotated_2() const { return ___rotated_2; }
inline bool* get_address_of_rotated_2() { return &___rotated_2; }
inline void set_rotated_2(bool value)
{
___rotated_2 = value;
}
inline static int32_t get_offset_of_trimmed_3() { return static_cast<int32_t>(offsetof(Frame_t277B57D2C572A3B179CEA0357869DB245F52128D, ___trimmed_3)); }
inline bool get_trimmed_3() const { return ___trimmed_3; }
inline bool* get_address_of_trimmed_3() { return &___trimmed_3; }
inline void set_trimmed_3(bool value)
{
___trimmed_3 = value;
}
inline static int32_t get_offset_of_spriteSourceSize_4() { return static_cast<int32_t>(offsetof(Frame_t277B57D2C572A3B179CEA0357869DB245F52128D, ___spriteSourceSize_4)); }
inline SpriteFrame_t5B610F44C5943B89962CC8CC4245EECDE29E94D9 get_spriteSourceSize_4() const { return ___spriteSourceSize_4; }
inline SpriteFrame_t5B610F44C5943B89962CC8CC4245EECDE29E94D9 * get_address_of_spriteSourceSize_4() { return &___spriteSourceSize_4; }
inline void set_spriteSourceSize_4(SpriteFrame_t5B610F44C5943B89962CC8CC4245EECDE29E94D9 value)
{
___spriteSourceSize_4 = value;
}
inline static int32_t get_offset_of_sourceSize_5() { return static_cast<int32_t>(offsetof(Frame_t277B57D2C572A3B179CEA0357869DB245F52128D, ___sourceSize_5)); }
inline SpriteSize_t7D47B39A52139B8CD3CE7F233C48981F70275A3D get_sourceSize_5() const { return ___sourceSize_5; }
inline SpriteSize_t7D47B39A52139B8CD3CE7F233C48981F70275A3D * get_address_of_sourceSize_5() { return &___sourceSize_5; }
inline void set_sourceSize_5(SpriteSize_t7D47B39A52139B8CD3CE7F233C48981F70275A3D value)
{
___sourceSize_5 = value;
}
inline static int32_t get_offset_of_pivot_6() { return static_cast<int32_t>(offsetof(Frame_t277B57D2C572A3B179CEA0357869DB245F52128D, ___pivot_6)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_pivot_6() const { return ___pivot_6; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_pivot_6() { return &___pivot_6; }
inline void set_pivot_6(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___pivot_6 = value;
}
};
// Native definition for P/Invoke marshalling of TMPro.SpriteAssetUtilities.TexturePacker_JsonArray/Frame
struct Frame_t277B57D2C572A3B179CEA0357869DB245F52128D_marshaled_pinvoke
{
char* ___filename_0;
SpriteFrame_t5B610F44C5943B89962CC8CC4245EECDE29E94D9 ___frame_1;
int32_t ___rotated_2;
int32_t ___trimmed_3;
SpriteFrame_t5B610F44C5943B89962CC8CC4245EECDE29E94D9 ___spriteSourceSize_4;
SpriteSize_t7D47B39A52139B8CD3CE7F233C48981F70275A3D ___sourceSize_5;
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___pivot_6;
};
// Native definition for COM marshalling of TMPro.SpriteAssetUtilities.TexturePacker_JsonArray/Frame
struct Frame_t277B57D2C572A3B179CEA0357869DB245F52128D_marshaled_com
{
Il2CppChar* ___filename_0;
SpriteFrame_t5B610F44C5943B89962CC8CC4245EECDE29E94D9 ___frame_1;
int32_t ___rotated_2;
int32_t ___trimmed_3;
SpriteFrame_t5B610F44C5943B89962CC8CC4245EECDE29E94D9 ___spriteSourceSize_4;
SpriteSize_t7D47B39A52139B8CD3CE7F233C48981F70275A3D ___sourceSize_5;
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___pivot_6;
};
// UnityEngine.XR.MagicLeap.MLArucoTracker/NativeBindings/MLArucoTrackerResultNative
struct MLArucoTrackerResultNative_t6B156A863352A63682C2FE6AA83A77F9B36435CA
{
public:
// System.Int32 UnityEngine.XR.MagicLeap.MLArucoTracker/NativeBindings/MLArucoTrackerResultNative::Id
int32_t ___Id_0;
// UnityEngine.XR.MagicLeap.Native.MagicLeapNativeBindings/MLCoordinateFrameUID UnityEngine.XR.MagicLeap.MLArucoTracker/NativeBindings/MLArucoTrackerResultNative::CFUID
MLCoordinateFrameUID_t7ADFCEC93CA8B3DDFB41EC8157D03B51D0611AC9 ___CFUID_1;
// System.Single UnityEngine.XR.MagicLeap.MLArucoTracker/NativeBindings/MLArucoTrackerResultNative::ReprojectionError
float ___ReprojectionError_2;
public:
inline static int32_t get_offset_of_Id_0() { return static_cast<int32_t>(offsetof(MLArucoTrackerResultNative_t6B156A863352A63682C2FE6AA83A77F9B36435CA, ___Id_0)); }
inline int32_t get_Id_0() const { return ___Id_0; }
inline int32_t* get_address_of_Id_0() { return &___Id_0; }
inline void set_Id_0(int32_t value)
{
___Id_0 = value;
}
inline static int32_t get_offset_of_CFUID_1() { return static_cast<int32_t>(offsetof(MLArucoTrackerResultNative_t6B156A863352A63682C2FE6AA83A77F9B36435CA, ___CFUID_1)); }
inline MLCoordinateFrameUID_t7ADFCEC93CA8B3DDFB41EC8157D03B51D0611AC9 get_CFUID_1() const { return ___CFUID_1; }
inline MLCoordinateFrameUID_t7ADFCEC93CA8B3DDFB41EC8157D03B51D0611AC9 * get_address_of_CFUID_1() { return &___CFUID_1; }
inline void set_CFUID_1(MLCoordinateFrameUID_t7ADFCEC93CA8B3DDFB41EC8157D03B51D0611AC9 value)
{
___CFUID_1 = value;
}
inline static int32_t get_offset_of_ReprojectionError_2() { return static_cast<int32_t>(offsetof(MLArucoTrackerResultNative_t6B156A863352A63682C2FE6AA83A77F9B36435CA, ___ReprojectionError_2)); }
inline float get_ReprojectionError_2() const { return ___ReprojectionError_2; }
inline float* get_address_of_ReprojectionError_2() { return &___ReprojectionError_2; }
inline void set_ReprojectionError_2(float value)
{
___ReprojectionError_2 = value;
}
};
// UnityEngine.XR.MagicLeap.MLImageTracker/Target/TrackingStatus
struct TrackingStatus_tD8289AF09A6CFB8A29BA63FF0D4677EAF4BAB4A4
{
public:
// System.Int32 UnityEngine.XR.MagicLeap.MLImageTracker/Target/TrackingStatus::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(TrackingStatus_tD8289AF09A6CFB8A29BA63FF0D4677EAF4BAB4A4, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.XR.MagicLeap.MLMRCamera/Frame/ImagePlane
struct ImagePlane_t2D929496EA001719A11E4DF9B11BD09B7B538D46
{
public:
// System.UInt32 UnityEngine.XR.MagicLeap.MLMRCamera/Frame/ImagePlane::<Width>k__BackingField
uint32_t ___U3CWidthU3Ek__BackingField_0;
// System.UInt32 UnityEngine.XR.MagicLeap.MLMRCamera/Frame/ImagePlane::<Height>k__BackingField
uint32_t ___U3CHeightU3Ek__BackingField_1;
// System.UInt32 UnityEngine.XR.MagicLeap.MLMRCamera/Frame/ImagePlane::<Stride>k__BackingField
uint32_t ___U3CStrideU3Ek__BackingField_2;
// System.UInt32 UnityEngine.XR.MagicLeap.MLMRCamera/Frame/ImagePlane::<BytesPerPixel>k__BackingField
uint32_t ___U3CBytesPerPixelU3Ek__BackingField_3;
// System.UInt32 UnityEngine.XR.MagicLeap.MLMRCamera/Frame/ImagePlane::<Size>k__BackingField
uint32_t ___U3CSizeU3Ek__BackingField_4;
// System.Byte[] UnityEngine.XR.MagicLeap.MLMRCamera/Frame/ImagePlane::Data
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* ___Data_5;
// System.IntPtr UnityEngine.XR.MagicLeap.MLMRCamera/Frame/ImagePlane::<DataPtr>k__BackingField
intptr_t ___U3CDataPtrU3Ek__BackingField_6;
public:
inline static int32_t get_offset_of_U3CWidthU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(ImagePlane_t2D929496EA001719A11E4DF9B11BD09B7B538D46, ___U3CWidthU3Ek__BackingField_0)); }
inline uint32_t get_U3CWidthU3Ek__BackingField_0() const { return ___U3CWidthU3Ek__BackingField_0; }
inline uint32_t* get_address_of_U3CWidthU3Ek__BackingField_0() { return &___U3CWidthU3Ek__BackingField_0; }
inline void set_U3CWidthU3Ek__BackingField_0(uint32_t value)
{
___U3CWidthU3Ek__BackingField_0 = value;
}
inline static int32_t get_offset_of_U3CHeightU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(ImagePlane_t2D929496EA001719A11E4DF9B11BD09B7B538D46, ___U3CHeightU3Ek__BackingField_1)); }
inline uint32_t get_U3CHeightU3Ek__BackingField_1() const { return ___U3CHeightU3Ek__BackingField_1; }
inline uint32_t* get_address_of_U3CHeightU3Ek__BackingField_1() { return &___U3CHeightU3Ek__BackingField_1; }
inline void set_U3CHeightU3Ek__BackingField_1(uint32_t value)
{
___U3CHeightU3Ek__BackingField_1 = value;
}
inline static int32_t get_offset_of_U3CStrideU3Ek__BackingField_2() { return static_cast<int32_t>(offsetof(ImagePlane_t2D929496EA001719A11E4DF9B11BD09B7B538D46, ___U3CStrideU3Ek__BackingField_2)); }
inline uint32_t get_U3CStrideU3Ek__BackingField_2() const { return ___U3CStrideU3Ek__BackingField_2; }
inline uint32_t* get_address_of_U3CStrideU3Ek__BackingField_2() { return &___U3CStrideU3Ek__BackingField_2; }
inline void set_U3CStrideU3Ek__BackingField_2(uint32_t value)
{
___U3CStrideU3Ek__BackingField_2 = value;
}
inline static int32_t get_offset_of_U3CBytesPerPixelU3Ek__BackingField_3() { return static_cast<int32_t>(offsetof(ImagePlane_t2D929496EA001719A11E4DF9B11BD09B7B538D46, ___U3CBytesPerPixelU3Ek__BackingField_3)); }
inline uint32_t get_U3CBytesPerPixelU3Ek__BackingField_3() const { return ___U3CBytesPerPixelU3Ek__BackingField_3; }
inline uint32_t* get_address_of_U3CBytesPerPixelU3Ek__BackingField_3() { return &___U3CBytesPerPixelU3Ek__BackingField_3; }
inline void set_U3CBytesPerPixelU3Ek__BackingField_3(uint32_t value)
{
___U3CBytesPerPixelU3Ek__BackingField_3 = value;
}
inline static int32_t get_offset_of_U3CSizeU3Ek__BackingField_4() { return static_cast<int32_t>(offsetof(ImagePlane_t2D929496EA001719A11E4DF9B11BD09B7B538D46, ___U3CSizeU3Ek__BackingField_4)); }
inline uint32_t get_U3CSizeU3Ek__BackingField_4() const { return ___U3CSizeU3Ek__BackingField_4; }
inline uint32_t* get_address_of_U3CSizeU3Ek__BackingField_4() { return &___U3CSizeU3Ek__BackingField_4; }
inline void set_U3CSizeU3Ek__BackingField_4(uint32_t value)
{
___U3CSizeU3Ek__BackingField_4 = value;
}
inline static int32_t get_offset_of_Data_5() { return static_cast<int32_t>(offsetof(ImagePlane_t2D929496EA001719A11E4DF9B11BD09B7B538D46, ___Data_5)); }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* get_Data_5() const { return ___Data_5; }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726** get_address_of_Data_5() { return &___Data_5; }
inline void set_Data_5(ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* value)
{
___Data_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Data_5), (void*)value);
}
inline static int32_t get_offset_of_U3CDataPtrU3Ek__BackingField_6() { return static_cast<int32_t>(offsetof(ImagePlane_t2D929496EA001719A11E4DF9B11BD09B7B538D46, ___U3CDataPtrU3Ek__BackingField_6)); }
inline intptr_t get_U3CDataPtrU3Ek__BackingField_6() const { return ___U3CDataPtrU3Ek__BackingField_6; }
inline intptr_t* get_address_of_U3CDataPtrU3Ek__BackingField_6() { return &___U3CDataPtrU3Ek__BackingField_6; }
inline void set_U3CDataPtrU3Ek__BackingField_6(intptr_t value)
{
___U3CDataPtrU3Ek__BackingField_6 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MagicLeap.MLMRCamera/Frame/ImagePlane
struct ImagePlane_t2D929496EA001719A11E4DF9B11BD09B7B538D46_marshaled_pinvoke
{
uint32_t ___U3CWidthU3Ek__BackingField_0;
uint32_t ___U3CHeightU3Ek__BackingField_1;
uint32_t ___U3CStrideU3Ek__BackingField_2;
uint32_t ___U3CBytesPerPixelU3Ek__BackingField_3;
uint32_t ___U3CSizeU3Ek__BackingField_4;
Il2CppSafeArray/*NONE*/* ___Data_5;
intptr_t ___U3CDataPtrU3Ek__BackingField_6;
};
// Native definition for COM marshalling of UnityEngine.XR.MagicLeap.MLMRCamera/Frame/ImagePlane
struct ImagePlane_t2D929496EA001719A11E4DF9B11BD09B7B538D46_marshaled_com
{
uint32_t ___U3CWidthU3Ek__BackingField_0;
uint32_t ___U3CHeightU3Ek__BackingField_1;
uint32_t ___U3CStrideU3Ek__BackingField_2;
uint32_t ___U3CBytesPerPixelU3Ek__BackingField_3;
uint32_t ___U3CSizeU3Ek__BackingField_4;
Il2CppSafeArray/*NONE*/* ___Data_5;
intptr_t ___U3CDataPtrU3Ek__BackingField_6;
};
// UnityEngine.XR.MagicLeap.MLPlanes/NativeBindings/BoundariesListNative
struct BoundariesListNative_t993026976BA61E4DBFE13483C88853F226856CA4
{
public:
// System.UInt32 UnityEngine.XR.MagicLeap.MLPlanes/NativeBindings/BoundariesListNative::Version
uint32_t ___Version_0;
// System.IntPtr UnityEngine.XR.MagicLeap.MLPlanes/NativeBindings/BoundariesListNative::PlaneBoundaries
intptr_t ___PlaneBoundaries_1;
// System.UInt32 UnityEngine.XR.MagicLeap.MLPlanes/NativeBindings/BoundariesListNative::PlaneBoundariesCount
uint32_t ___PlaneBoundariesCount_2;
public:
inline static int32_t get_offset_of_Version_0() { return static_cast<int32_t>(offsetof(BoundariesListNative_t993026976BA61E4DBFE13483C88853F226856CA4, ___Version_0)); }
inline uint32_t get_Version_0() const { return ___Version_0; }
inline uint32_t* get_address_of_Version_0() { return &___Version_0; }
inline void set_Version_0(uint32_t value)
{
___Version_0 = value;
}
inline static int32_t get_offset_of_PlaneBoundaries_1() { return static_cast<int32_t>(offsetof(BoundariesListNative_t993026976BA61E4DBFE13483C88853F226856CA4, ___PlaneBoundaries_1)); }
inline intptr_t get_PlaneBoundaries_1() const { return ___PlaneBoundaries_1; }
inline intptr_t* get_address_of_PlaneBoundaries_1() { return &___PlaneBoundaries_1; }
inline void set_PlaneBoundaries_1(intptr_t value)
{
___PlaneBoundaries_1 = value;
}
inline static int32_t get_offset_of_PlaneBoundariesCount_2() { return static_cast<int32_t>(offsetof(BoundariesListNative_t993026976BA61E4DBFE13483C88853F226856CA4, ___PlaneBoundariesCount_2)); }
inline uint32_t get_PlaneBoundariesCount_2() const { return ___PlaneBoundariesCount_2; }
inline uint32_t* get_address_of_PlaneBoundariesCount_2() { return &___PlaneBoundariesCount_2; }
inline void set_PlaneBoundariesCount_2(uint32_t value)
{
___PlaneBoundariesCount_2 = value;
}
};
// UnityEngine.XR.MagicLeap.MLWebRTC/VideoSink/Frame/OutputFormat
struct OutputFormat_tE1FB72971045C542F632F97BF1D59838AE8AAC87
{
public:
// System.Int32 UnityEngine.XR.MagicLeap.MLWebRTC/VideoSink/Frame/OutputFormat::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(OutputFormat_tE1FB72971045C542F632F97BF1D59838AE8AAC87, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.ByteEnum,UnityEngine.Bounds>
struct KeyValuePair_2_t4C06AD7A4B066AA7DEB169481DEE9B0F19B74AF4
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
uint8_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
Bounds_t0F1F36D4F7AF49524B3C2A2259594412A3D3AE37 ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t4C06AD7A4B066AA7DEB169481DEE9B0F19B74AF4, ___key_0)); }
inline uint8_t get_key_0() const { return ___key_0; }
inline uint8_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(uint8_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t4C06AD7A4B066AA7DEB169481DEE9B0F19B74AF4, ___value_1)); }
inline Bounds_t0F1F36D4F7AF49524B3C2A2259594412A3D3AE37 get_value_1() const { return ___value_1; }
inline Bounds_t0F1F36D4F7AF49524B3C2A2259594412A3D3AE37 * get_address_of_value_1() { return &___value_1; }
inline void set_value_1(Bounds_t0F1F36D4F7AF49524B3C2A2259594412A3D3AE37 value)
{
___value_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.ByteEnum,UnityEngine.Matrix4x4>
struct KeyValuePair_2_t199D25DC5B4AEC9DE9D3DF1C79A0E1EC4FC9D750
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
uint8_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461 ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t199D25DC5B4AEC9DE9D3DF1C79A0E1EC4FC9D750, ___key_0)); }
inline uint8_t get_key_0() const { return ___key_0; }
inline uint8_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(uint8_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t199D25DC5B4AEC9DE9D3DF1C79A0E1EC4FC9D750, ___value_1)); }
inline Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461 get_value_1() const { return ___value_1; }
inline Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461 * get_address_of_value_1() { return &___value_1; }
inline void set_value_1(Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461 value)
{
___value_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.ByteEnum,System.Object>
struct KeyValuePair_2_t7DD7DA129ACC317FEC6BA4C4AFB8531E3BD44B8F
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
uint8_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
RuntimeObject * ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t7DD7DA129ACC317FEC6BA4C4AFB8531E3BD44B8F, ___key_0)); }
inline uint8_t get_key_0() const { return ___key_0; }
inline uint8_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(uint8_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t7DD7DA129ACC317FEC6BA4C4AFB8531E3BD44B8F, ___value_1)); }
inline RuntimeObject * get_value_1() const { return ___value_1; }
inline RuntimeObject ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(RuntimeObject * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// System.Collections.Generic.KeyValuePair`2<System.Int32,UnityEngine.XR.MagicLeap.MLArucoTracker/NativeBindings/MLArucoTrackerResultNative>
struct KeyValuePair_2_tB857CDE0014FDA4A1BC9392C7A05FC222849182C
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
int32_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
MLArucoTrackerResultNative_t6B156A863352A63682C2FE6AA83A77F9B36435CA ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tB857CDE0014FDA4A1BC9392C7A05FC222849182C, ___key_0)); }
inline int32_t get_key_0() const { return ___key_0; }
inline int32_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(int32_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tB857CDE0014FDA4A1BC9392C7A05FC222849182C, ___value_1)); }
inline MLArucoTrackerResultNative_t6B156A863352A63682C2FE6AA83A77F9B36435CA get_value_1() const { return ___value_1; }
inline MLArucoTrackerResultNative_t6B156A863352A63682C2FE6AA83A77F9B36435CA * get_address_of_value_1() { return &___value_1; }
inline void set_value_1(MLArucoTrackerResultNative_t6B156A863352A63682C2FE6AA83A77F9B36435CA value)
{
___value_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.Int32Enum,Microsoft.MixedReality.Toolkit.Utilities.MixedRealityPose>
struct KeyValuePair_2_t9CFCF96A7E2633151295BA93C1343297C5B91BAF
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
int32_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
MixedRealityPose_t9A27AAE05672995793F76985CE167AA85B8DF5AF ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t9CFCF96A7E2633151295BA93C1343297C5B91BAF, ___key_0)); }
inline int32_t get_key_0() const { return ___key_0; }
inline int32_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(int32_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t9CFCF96A7E2633151295BA93C1343297C5B91BAF, ___value_1)); }
inline MixedRealityPose_t9A27AAE05672995793F76985CE167AA85B8DF5AF get_value_1() const { return ___value_1; }
inline MixedRealityPose_t9A27AAE05672995793F76985CE167AA85B8DF5AF * get_address_of_value_1() { return &___value_1; }
inline void set_value_1(MixedRealityPose_t9A27AAE05672995793F76985CE167AA85B8DF5AF value)
{
___value_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.Int32Enum,System.Object>
struct KeyValuePair_2_t83B2885C02C836E233B38F12A0F13CDC8DBE3ED1
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
int32_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
RuntimeObject * ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t83B2885C02C836E233B38F12A0F13CDC8DBE3ED1, ___key_0)); }
inline int32_t get_key_0() const { return ___key_0; }
inline int32_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(int32_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t83B2885C02C836E233B38F12A0F13CDC8DBE3ED1, ___value_1)); }
inline RuntimeObject * get_value_1() const { return ___value_1; }
inline RuntimeObject ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(RuntimeObject * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// System.Collections.Generic.KeyValuePair`2<System.Int32Enum,System.Single>
struct KeyValuePair_2_t981AE20097B6314BF8A205CF34ECF3A7E18B66DA
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
int32_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
float ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t981AE20097B6314BF8A205CF34ECF3A7E18B66DA, ___key_0)); }
inline int32_t get_key_0() const { return ___key_0; }
inline int32_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(int32_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t981AE20097B6314BF8A205CF34ECF3A7E18B66DA, ___value_1)); }
inline float get_value_1() const { return ___value_1; }
inline float* get_address_of_value_1() { return &___value_1; }
inline void set_value_1(float value)
{
___value_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.Int32Enum,Microsoft.MixedReality.Toolkit.Audio.AudioLoFiEffect/AudioLoFiFilterSettings>
struct KeyValuePair_2_tDEBAC4204942613BBD810AE61B8879E16B16BE22
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
int32_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
AudioLoFiFilterSettings_t5EC9A0E1CF4DFFC4BA58E1DF6D4E880F9404B0A8 ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tDEBAC4204942613BBD810AE61B8879E16B16BE22, ___key_0)); }
inline int32_t get_key_0() const { return ___key_0; }
inline int32_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(int32_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tDEBAC4204942613BBD810AE61B8879E16B16BE22, ___value_1)); }
inline AudioLoFiFilterSettings_t5EC9A0E1CF4DFFC4BA58E1DF6D4E880F9404B0A8 get_value_1() const { return ___value_1; }
inline AudioLoFiFilterSettings_t5EC9A0E1CF4DFFC4BA58E1DF6D4E880F9404B0A8 * get_address_of_value_1() { return &___value_1; }
inline void set_value_1(AudioLoFiFilterSettings_t5EC9A0E1CF4DFFC4BA58E1DF6D4E880F9404B0A8 value)
{
___value_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.UInt32,Microsoft.MixedReality.Toolkit.UI.ManipulationHandler/PointerData>
struct KeyValuePair_2_tE732F29FAAE8258AADE79971F5F981B5A975E69F
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
uint32_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
PointerData_tC90DB32A4F2EF1FC975FEAE81DE66BC21FE1351F ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tE732F29FAAE8258AADE79971F5F981B5A975E69F, ___key_0)); }
inline uint32_t get_key_0() const { return ___key_0; }
inline uint32_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(uint32_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tE732F29FAAE8258AADE79971F5F981B5A975E69F, ___value_1)); }
inline PointerData_tC90DB32A4F2EF1FC975FEAE81DE66BC21FE1351F get_value_1() const { return ___value_1; }
inline PointerData_tC90DB32A4F2EF1FC975FEAE81DE66BC21FE1351F * get_address_of_value_1() { return &___value_1; }
inline void set_value_1(PointerData_tC90DB32A4F2EF1FC975FEAE81DE66BC21FE1351F value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)&(((&___value_1))->___pointer_0), (void*)NULL);
}
};
// System.Collections.Generic.KeyValuePair`2<System.UInt32,Microsoft.MixedReality.Toolkit.UI.ObjectManipulator/PointerData>
struct KeyValuePair_2_t3099483093B475AC1712E315486784320D93D045
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
uint32_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
PointerData_t217FAEE1441F0ADC5F7B08E3987B1C08E48B7DD4 ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t3099483093B475AC1712E315486784320D93D045, ___key_0)); }
inline uint32_t get_key_0() const { return ___key_0; }
inline uint32_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(uint32_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t3099483093B475AC1712E315486784320D93D045, ___value_1)); }
inline PointerData_t217FAEE1441F0ADC5F7B08E3987B1C08E48B7DD4 get_value_1() const { return ___value_1; }
inline PointerData_t217FAEE1441F0ADC5F7B08E3987B1C08E48B7DD4 * get_address_of_value_1() { return &___value_1; }
inline void set_value_1(PointerData_t217FAEE1441F0ADC5F7B08E3987B1C08E48B7DD4 value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)&(((&___value_1))->___pointer_0), (void*)NULL);
}
};
// System.Collections.Generic.KeyValuePair`2<System.UInt32Enum,System.Object>
struct KeyValuePair_2_t78B694E8342E86089FB515D21C3CB9F12838A5CB
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
uint32_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
RuntimeObject * ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t78B694E8342E86089FB515D21C3CB9F12838A5CB, ___key_0)); }
inline uint32_t get_key_0() const { return ___key_0; }
inline uint32_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(uint32_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t78B694E8342E86089FB515D21C3CB9F12838A5CB, ___value_1)); }
inline RuntimeObject * get_value_1() const { return ___value_1; }
inline RuntimeObject ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(RuntimeObject * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// Unity.Collections.NativeArray`1<UnityEngine.Rendering.BatchVisibility>
struct NativeArray_1_t18D233A2E30E28048C1252473AFD0799557294DA
{
public:
// System.Void* Unity.Collections.NativeArray`1::m_Buffer
void* ___m_Buffer_0;
// System.Int32 Unity.Collections.NativeArray`1::m_Length
int32_t ___m_Length_1;
// Unity.Collections.Allocator Unity.Collections.NativeArray`1::m_AllocatorLabel
int32_t ___m_AllocatorLabel_2;
public:
inline static int32_t get_offset_of_m_Buffer_0() { return static_cast<int32_t>(offsetof(NativeArray_1_t18D233A2E30E28048C1252473AFD0799557294DA, ___m_Buffer_0)); }
inline void* get_m_Buffer_0() const { return ___m_Buffer_0; }
inline void** get_address_of_m_Buffer_0() { return &___m_Buffer_0; }
inline void set_m_Buffer_0(void* value)
{
___m_Buffer_0 = value;
}
inline static int32_t get_offset_of_m_Length_1() { return static_cast<int32_t>(offsetof(NativeArray_1_t18D233A2E30E28048C1252473AFD0799557294DA, ___m_Length_1)); }
inline int32_t get_m_Length_1() const { return ___m_Length_1; }
inline int32_t* get_address_of_m_Length_1() { return &___m_Length_1; }
inline void set_m_Length_1(int32_t value)
{
___m_Length_1 = value;
}
inline static int32_t get_offset_of_m_AllocatorLabel_2() { return static_cast<int32_t>(offsetof(NativeArray_1_t18D233A2E30E28048C1252473AFD0799557294DA, ___m_AllocatorLabel_2)); }
inline int32_t get_m_AllocatorLabel_2() const { return ___m_AllocatorLabel_2; }
inline int32_t* get_address_of_m_AllocatorLabel_2() { return &___m_AllocatorLabel_2; }
inline void set_m_AllocatorLabel_2(int32_t value)
{
___m_AllocatorLabel_2 = value;
}
};
// Unity.Collections.NativeArray`1<System.Byte>
struct NativeArray_1_t3C2855C5B238E8C6739D4C17833F244B95C0F785
{
public:
// System.Void* Unity.Collections.NativeArray`1::m_Buffer
void* ___m_Buffer_0;
// System.Int32 Unity.Collections.NativeArray`1::m_Length
int32_t ___m_Length_1;
// Unity.Collections.Allocator Unity.Collections.NativeArray`1::m_AllocatorLabel
int32_t ___m_AllocatorLabel_2;
public:
inline static int32_t get_offset_of_m_Buffer_0() { return static_cast<int32_t>(offsetof(NativeArray_1_t3C2855C5B238E8C6739D4C17833F244B95C0F785, ___m_Buffer_0)); }
inline void* get_m_Buffer_0() const { return ___m_Buffer_0; }
inline void** get_address_of_m_Buffer_0() { return &___m_Buffer_0; }
inline void set_m_Buffer_0(void* value)
{
___m_Buffer_0 = value;
}
inline static int32_t get_offset_of_m_Length_1() { return static_cast<int32_t>(offsetof(NativeArray_1_t3C2855C5B238E8C6739D4C17833F244B95C0F785, ___m_Length_1)); }
inline int32_t get_m_Length_1() const { return ___m_Length_1; }
inline int32_t* get_address_of_m_Length_1() { return &___m_Length_1; }
inline void set_m_Length_1(int32_t value)
{
___m_Length_1 = value;
}
inline static int32_t get_offset_of_m_AllocatorLabel_2() { return static_cast<int32_t>(offsetof(NativeArray_1_t3C2855C5B238E8C6739D4C17833F244B95C0F785, ___m_AllocatorLabel_2)); }
inline int32_t get_m_AllocatorLabel_2() const { return ___m_AllocatorLabel_2; }
inline int32_t* get_address_of_m_AllocatorLabel_2() { return &___m_AllocatorLabel_2; }
inline void set_m_AllocatorLabel_2(int32_t value)
{
___m_AllocatorLabel_2 = value;
}
};
// Unity.Collections.NativeArray`1<System.Int32>
struct NativeArray_1_tD60079F06B473C85CF6C2BB4F2D203F38191AE99
{
public:
// System.Void* Unity.Collections.NativeArray`1::m_Buffer
void* ___m_Buffer_0;
// System.Int32 Unity.Collections.NativeArray`1::m_Length
int32_t ___m_Length_1;
// Unity.Collections.Allocator Unity.Collections.NativeArray`1::m_AllocatorLabel
int32_t ___m_AllocatorLabel_2;
public:
inline static int32_t get_offset_of_m_Buffer_0() { return static_cast<int32_t>(offsetof(NativeArray_1_tD60079F06B473C85CF6C2BB4F2D203F38191AE99, ___m_Buffer_0)); }
inline void* get_m_Buffer_0() const { return ___m_Buffer_0; }
inline void** get_address_of_m_Buffer_0() { return &___m_Buffer_0; }
inline void set_m_Buffer_0(void* value)
{
___m_Buffer_0 = value;
}
inline static int32_t get_offset_of_m_Length_1() { return static_cast<int32_t>(offsetof(NativeArray_1_tD60079F06B473C85CF6C2BB4F2D203F38191AE99, ___m_Length_1)); }
inline int32_t get_m_Length_1() const { return ___m_Length_1; }
inline int32_t* get_address_of_m_Length_1() { return &___m_Length_1; }
inline void set_m_Length_1(int32_t value)
{
___m_Length_1 = value;
}
inline static int32_t get_offset_of_m_AllocatorLabel_2() { return static_cast<int32_t>(offsetof(NativeArray_1_tD60079F06B473C85CF6C2BB4F2D203F38191AE99, ___m_AllocatorLabel_2)); }
inline int32_t get_m_AllocatorLabel_2() const { return ___m_AllocatorLabel_2; }
inline int32_t* get_address_of_m_AllocatorLabel_2() { return &___m_AllocatorLabel_2; }
inline void set_m_AllocatorLabel_2(int32_t value)
{
___m_AllocatorLabel_2 = value;
}
};
// Unity.Collections.NativeArray`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>
struct NativeArray_1_tF6A10DD2511425342F2B1B19CF0EA313D4F300D2
{
public:
// System.Void* Unity.Collections.NativeArray`1::m_Buffer
void* ___m_Buffer_0;
// System.Int32 Unity.Collections.NativeArray`1::m_Length
int32_t ___m_Length_1;
// Unity.Collections.Allocator Unity.Collections.NativeArray`1::m_AllocatorLabel
int32_t ___m_AllocatorLabel_2;
public:
inline static int32_t get_offset_of_m_Buffer_0() { return static_cast<int32_t>(offsetof(NativeArray_1_tF6A10DD2511425342F2B1B19CF0EA313D4F300D2, ___m_Buffer_0)); }
inline void* get_m_Buffer_0() const { return ___m_Buffer_0; }
inline void** get_address_of_m_Buffer_0() { return &___m_Buffer_0; }
inline void set_m_Buffer_0(void* value)
{
___m_Buffer_0 = value;
}
inline static int32_t get_offset_of_m_Length_1() { return static_cast<int32_t>(offsetof(NativeArray_1_tF6A10DD2511425342F2B1B19CF0EA313D4F300D2, ___m_Length_1)); }
inline int32_t get_m_Length_1() const { return ___m_Length_1; }
inline int32_t* get_address_of_m_Length_1() { return &___m_Length_1; }
inline void set_m_Length_1(int32_t value)
{
___m_Length_1 = value;
}
inline static int32_t get_offset_of_m_AllocatorLabel_2() { return static_cast<int32_t>(offsetof(NativeArray_1_tF6A10DD2511425342F2B1B19CF0EA313D4F300D2, ___m_AllocatorLabel_2)); }
inline int32_t get_m_AllocatorLabel_2() const { return ___m_AllocatorLabel_2; }
inline int32_t* get_address_of_m_AllocatorLabel_2() { return &___m_AllocatorLabel_2; }
inline void set_m_AllocatorLabel_2(int32_t value)
{
___m_AllocatorLabel_2 = value;
}
};
// Unity.Collections.NativeArray`1<UnityEngine.Plane>
struct NativeArray_1_t527C586787ACD1AD75E3C78BFB024FFA9925662E
{
public:
// System.Void* Unity.Collections.NativeArray`1::m_Buffer
void* ___m_Buffer_0;
// System.Int32 Unity.Collections.NativeArray`1::m_Length
int32_t ___m_Length_1;
// Unity.Collections.Allocator Unity.Collections.NativeArray`1::m_AllocatorLabel
int32_t ___m_AllocatorLabel_2;
public:
inline static int32_t get_offset_of_m_Buffer_0() { return static_cast<int32_t>(offsetof(NativeArray_1_t527C586787ACD1AD75E3C78BFB024FFA9925662E, ___m_Buffer_0)); }
inline void* get_m_Buffer_0() const { return ___m_Buffer_0; }
inline void** get_address_of_m_Buffer_0() { return &___m_Buffer_0; }
inline void set_m_Buffer_0(void* value)
{
___m_Buffer_0 = value;
}
inline static int32_t get_offset_of_m_Length_1() { return static_cast<int32_t>(offsetof(NativeArray_1_t527C586787ACD1AD75E3C78BFB024FFA9925662E, ___m_Length_1)); }
inline int32_t get_m_Length_1() const { return ___m_Length_1; }
inline int32_t* get_address_of_m_Length_1() { return &___m_Length_1; }
inline void set_m_Length_1(int32_t value)
{
___m_Length_1 = value;
}
inline static int32_t get_offset_of_m_AllocatorLabel_2() { return static_cast<int32_t>(offsetof(NativeArray_1_t527C586787ACD1AD75E3C78BFB024FFA9925662E, ___m_AllocatorLabel_2)); }
inline int32_t get_m_AllocatorLabel_2() const { return ___m_AllocatorLabel_2; }
inline int32_t* get_address_of_m_AllocatorLabel_2() { return &___m_AllocatorLabel_2; }
inline void set_m_AllocatorLabel_2(int32_t value)
{
___m_AllocatorLabel_2 = value;
}
};
// UnityEngine.XR.InteractionSubsystems.ActivateGestureEvent
struct ActivateGestureEvent_tE62B374FD7C61FB39DBE074BAC40308F033D4337
{
public:
// UnityEngine.XR.InteractionSubsystems.GestureId UnityEngine.XR.InteractionSubsystems.ActivateGestureEvent::m_Id
GestureId_tF3EFA115E02FC8A313B1019689130A09419B1EC7 ___m_Id_0;
// UnityEngine.XR.InteractionSubsystems.GestureState UnityEngine.XR.InteractionSubsystems.ActivateGestureEvent::m_State
int32_t ___m_State_1;
public:
inline static int32_t get_offset_of_m_Id_0() { return static_cast<int32_t>(offsetof(ActivateGestureEvent_tE62B374FD7C61FB39DBE074BAC40308F033D4337, ___m_Id_0)); }
inline GestureId_tF3EFA115E02FC8A313B1019689130A09419B1EC7 get_m_Id_0() const { return ___m_Id_0; }
inline GestureId_tF3EFA115E02FC8A313B1019689130A09419B1EC7 * get_address_of_m_Id_0() { return &___m_Id_0; }
inline void set_m_Id_0(GestureId_tF3EFA115E02FC8A313B1019689130A09419B1EC7 value)
{
___m_Id_0 = value;
}
inline static int32_t get_offset_of_m_State_1() { return static_cast<int32_t>(offsetof(ActivateGestureEvent_tE62B374FD7C61FB39DBE074BAC40308F033D4337, ___m_State_1)); }
inline int32_t get_m_State_1() const { return ___m_State_1; }
inline int32_t* get_address_of_m_State_1() { return &___m_State_1; }
inline void set_m_State_1(int32_t value)
{
___m_State_1 = value;
}
};
// UnityEngine.XR.ARSubsystems.BoundedPlane
struct BoundedPlane_t9001963C43ACDF4CDEA8BBF97CD783B7969B79C5
{
public:
// UnityEngine.XR.ARSubsystems.TrackableId UnityEngine.XR.ARSubsystems.BoundedPlane::m_TrackableId
TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B ___m_TrackableId_1;
// UnityEngine.XR.ARSubsystems.TrackableId UnityEngine.XR.ARSubsystems.BoundedPlane::m_SubsumedById
TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B ___m_SubsumedById_2;
// UnityEngine.Vector2 UnityEngine.XR.ARSubsystems.BoundedPlane::m_Center
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___m_Center_3;
// UnityEngine.Pose UnityEngine.XR.ARSubsystems.BoundedPlane::m_Pose
Pose_t9F30358E65733E60A1DC8682FDB7104F40C9434A ___m_Pose_4;
// UnityEngine.Vector2 UnityEngine.XR.ARSubsystems.BoundedPlane::m_Size
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___m_Size_5;
// UnityEngine.XR.ARSubsystems.PlaneAlignment UnityEngine.XR.ARSubsystems.BoundedPlane::m_Alignment
int32_t ___m_Alignment_6;
// UnityEngine.XR.ARSubsystems.TrackingState UnityEngine.XR.ARSubsystems.BoundedPlane::m_TrackingState
int32_t ___m_TrackingState_7;
// System.IntPtr UnityEngine.XR.ARSubsystems.BoundedPlane::m_NativePtr
intptr_t ___m_NativePtr_8;
// UnityEngine.XR.ARSubsystems.PlaneClassification UnityEngine.XR.ARSubsystems.BoundedPlane::m_Classification
int32_t ___m_Classification_9;
public:
inline static int32_t get_offset_of_m_TrackableId_1() { return static_cast<int32_t>(offsetof(BoundedPlane_t9001963C43ACDF4CDEA8BBF97CD783B7969B79C5, ___m_TrackableId_1)); }
inline TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B get_m_TrackableId_1() const { return ___m_TrackableId_1; }
inline TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B * get_address_of_m_TrackableId_1() { return &___m_TrackableId_1; }
inline void set_m_TrackableId_1(TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B value)
{
___m_TrackableId_1 = value;
}
inline static int32_t get_offset_of_m_SubsumedById_2() { return static_cast<int32_t>(offsetof(BoundedPlane_t9001963C43ACDF4CDEA8BBF97CD783B7969B79C5, ___m_SubsumedById_2)); }
inline TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B get_m_SubsumedById_2() const { return ___m_SubsumedById_2; }
inline TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B * get_address_of_m_SubsumedById_2() { return &___m_SubsumedById_2; }
inline void set_m_SubsumedById_2(TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B value)
{
___m_SubsumedById_2 = value;
}
inline static int32_t get_offset_of_m_Center_3() { return static_cast<int32_t>(offsetof(BoundedPlane_t9001963C43ACDF4CDEA8BBF97CD783B7969B79C5, ___m_Center_3)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_m_Center_3() const { return ___m_Center_3; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_m_Center_3() { return &___m_Center_3; }
inline void set_m_Center_3(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___m_Center_3 = value;
}
inline static int32_t get_offset_of_m_Pose_4() { return static_cast<int32_t>(offsetof(BoundedPlane_t9001963C43ACDF4CDEA8BBF97CD783B7969B79C5, ___m_Pose_4)); }
inline Pose_t9F30358E65733E60A1DC8682FDB7104F40C9434A get_m_Pose_4() const { return ___m_Pose_4; }
inline Pose_t9F30358E65733E60A1DC8682FDB7104F40C9434A * get_address_of_m_Pose_4() { return &___m_Pose_4; }
inline void set_m_Pose_4(Pose_t9F30358E65733E60A1DC8682FDB7104F40C9434A value)
{
___m_Pose_4 = value;
}
inline static int32_t get_offset_of_m_Size_5() { return static_cast<int32_t>(offsetof(BoundedPlane_t9001963C43ACDF4CDEA8BBF97CD783B7969B79C5, ___m_Size_5)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_m_Size_5() const { return ___m_Size_5; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_m_Size_5() { return &___m_Size_5; }
inline void set_m_Size_5(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___m_Size_5 = value;
}
inline static int32_t get_offset_of_m_Alignment_6() { return static_cast<int32_t>(offsetof(BoundedPlane_t9001963C43ACDF4CDEA8BBF97CD783B7969B79C5, ___m_Alignment_6)); }
inline int32_t get_m_Alignment_6() const { return ___m_Alignment_6; }
inline int32_t* get_address_of_m_Alignment_6() { return &___m_Alignment_6; }
inline void set_m_Alignment_6(int32_t value)
{
___m_Alignment_6 = value;
}
inline static int32_t get_offset_of_m_TrackingState_7() { return static_cast<int32_t>(offsetof(BoundedPlane_t9001963C43ACDF4CDEA8BBF97CD783B7969B79C5, ___m_TrackingState_7)); }
inline int32_t get_m_TrackingState_7() const { return ___m_TrackingState_7; }
inline int32_t* get_address_of_m_TrackingState_7() { return &___m_TrackingState_7; }
inline void set_m_TrackingState_7(int32_t value)
{
___m_TrackingState_7 = value;
}
inline static int32_t get_offset_of_m_NativePtr_8() { return static_cast<int32_t>(offsetof(BoundedPlane_t9001963C43ACDF4CDEA8BBF97CD783B7969B79C5, ___m_NativePtr_8)); }
inline intptr_t get_m_NativePtr_8() const { return ___m_NativePtr_8; }
inline intptr_t* get_address_of_m_NativePtr_8() { return &___m_NativePtr_8; }
inline void set_m_NativePtr_8(intptr_t value)
{
___m_NativePtr_8 = value;
}
inline static int32_t get_offset_of_m_Classification_9() { return static_cast<int32_t>(offsetof(BoundedPlane_t9001963C43ACDF4CDEA8BBF97CD783B7969B79C5, ___m_Classification_9)); }
inline int32_t get_m_Classification_9() const { return ___m_Classification_9; }
inline int32_t* get_address_of_m_Classification_9() { return &___m_Classification_9; }
inline void set_m_Classification_9(int32_t value)
{
___m_Classification_9 = value;
}
};
struct BoundedPlane_t9001963C43ACDF4CDEA8BBF97CD783B7969B79C5_StaticFields
{
public:
// UnityEngine.XR.ARSubsystems.BoundedPlane UnityEngine.XR.ARSubsystems.BoundedPlane::s_Default
BoundedPlane_t9001963C43ACDF4CDEA8BBF97CD783B7969B79C5 ___s_Default_0;
public:
inline static int32_t get_offset_of_s_Default_0() { return static_cast<int32_t>(offsetof(BoundedPlane_t9001963C43ACDF4CDEA8BBF97CD783B7969B79C5_StaticFields, ___s_Default_0)); }
inline BoundedPlane_t9001963C43ACDF4CDEA8BBF97CD783B7969B79C5 get_s_Default_0() const { return ___s_Default_0; }
inline BoundedPlane_t9001963C43ACDF4CDEA8BBF97CD783B7969B79C5 * get_address_of_s_Default_0() { return &___s_Default_0; }
inline void set_s_Default_0(BoundedPlane_t9001963C43ACDF4CDEA8BBF97CD783B7969B79C5 value)
{
___s_Default_0 = value;
}
};
// Microsoft.MixedReality.Toolkit.Physics.ComparableRaycastResult
struct ComparableRaycastResult_tACF79BA2E300399251DFA7C2D1E633E8F0C3062D
{
public:
// System.Int32 Microsoft.MixedReality.Toolkit.Physics.ComparableRaycastResult::LayerMaskIndex
int32_t ___LayerMaskIndex_0;
// UnityEngine.EventSystems.RaycastResult Microsoft.MixedReality.Toolkit.Physics.ComparableRaycastResult::RaycastResult
RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE ___RaycastResult_1;
public:
inline static int32_t get_offset_of_LayerMaskIndex_0() { return static_cast<int32_t>(offsetof(ComparableRaycastResult_tACF79BA2E300399251DFA7C2D1E633E8F0C3062D, ___LayerMaskIndex_0)); }
inline int32_t get_LayerMaskIndex_0() const { return ___LayerMaskIndex_0; }
inline int32_t* get_address_of_LayerMaskIndex_0() { return &___LayerMaskIndex_0; }
inline void set_LayerMaskIndex_0(int32_t value)
{
___LayerMaskIndex_0 = value;
}
inline static int32_t get_offset_of_RaycastResult_1() { return static_cast<int32_t>(offsetof(ComparableRaycastResult_tACF79BA2E300399251DFA7C2D1E633E8F0C3062D, ___RaycastResult_1)); }
inline RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE get_RaycastResult_1() const { return ___RaycastResult_1; }
inline RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE * get_address_of_RaycastResult_1() { return &___RaycastResult_1; }
inline void set_RaycastResult_1(RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE value)
{
___RaycastResult_1 = value;
Il2CppCodeGenWriteBarrier((void**)&(((&___RaycastResult_1))->___m_GameObject_0), (void*)NULL);
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&(((&___RaycastResult_1))->___module_1), (void*)NULL);
#endif
}
};
// Native definition for P/Invoke marshalling of Microsoft.MixedReality.Toolkit.Physics.ComparableRaycastResult
struct ComparableRaycastResult_tACF79BA2E300399251DFA7C2D1E633E8F0C3062D_marshaled_pinvoke
{
int32_t ___LayerMaskIndex_0;
RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE_marshaled_pinvoke ___RaycastResult_1;
};
// Native definition for COM marshalling of Microsoft.MixedReality.Toolkit.Physics.ComparableRaycastResult
struct ComparableRaycastResult_tACF79BA2E300399251DFA7C2D1E633E8F0C3062D_marshaled_com
{
int32_t ___LayerMaskIndex_0;
RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE_marshaled_com ___RaycastResult_1;
};
// System.ConsoleKeyInfo
struct ConsoleKeyInfo_tDA8AC07839288484FCB167A81B4FBA92ECCEAF88
{
public:
// System.Char System.ConsoleKeyInfo::_keyChar
Il2CppChar ____keyChar_0;
// System.ConsoleKey System.ConsoleKeyInfo::_key
int32_t ____key_1;
// System.ConsoleModifiers System.ConsoleKeyInfo::_mods
int32_t ____mods_2;
public:
inline static int32_t get_offset_of__keyChar_0() { return static_cast<int32_t>(offsetof(ConsoleKeyInfo_tDA8AC07839288484FCB167A81B4FBA92ECCEAF88, ____keyChar_0)); }
inline Il2CppChar get__keyChar_0() const { return ____keyChar_0; }
inline Il2CppChar* get_address_of__keyChar_0() { return &____keyChar_0; }
inline void set__keyChar_0(Il2CppChar value)
{
____keyChar_0 = value;
}
inline static int32_t get_offset_of__key_1() { return static_cast<int32_t>(offsetof(ConsoleKeyInfo_tDA8AC07839288484FCB167A81B4FBA92ECCEAF88, ____key_1)); }
inline int32_t get__key_1() const { return ____key_1; }
inline int32_t* get_address_of__key_1() { return &____key_1; }
inline void set__key_1(int32_t value)
{
____key_1 = value;
}
inline static int32_t get_offset_of__mods_2() { return static_cast<int32_t>(offsetof(ConsoleKeyInfo_tDA8AC07839288484FCB167A81B4FBA92ECCEAF88, ____mods_2)); }
inline int32_t get__mods_2() const { return ____mods_2; }
inline int32_t* get_address_of__mods_2() { return &____mods_2; }
inline void set__mods_2(int32_t value)
{
____mods_2 = value;
}
};
// Native definition for P/Invoke marshalling of System.ConsoleKeyInfo
struct ConsoleKeyInfo_tDA8AC07839288484FCB167A81B4FBA92ECCEAF88_marshaled_pinvoke
{
uint8_t ____keyChar_0;
int32_t ____key_1;
int32_t ____mods_2;
};
// Native definition for COM marshalling of System.ConsoleKeyInfo
struct ConsoleKeyInfo_tDA8AC07839288484FCB167A81B4FBA92ECCEAF88_marshaled_com
{
uint8_t ____keyChar_0;
int32_t ____key_1;
int32_t ____mods_2;
};
// Microsoft.MixedReality.Toolkit.Physics.FocusDetails
struct FocusDetails_t9D9111B483D3807234CD405067A29099A79620DA
{
public:
// System.Single Microsoft.MixedReality.Toolkit.Physics.FocusDetails::<RayDistance>k__BackingField
float ___U3CRayDistanceU3Ek__BackingField_0;
// UnityEngine.Vector3 Microsoft.MixedReality.Toolkit.Physics.FocusDetails::<Point>k__BackingField
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___U3CPointU3Ek__BackingField_1;
// UnityEngine.Vector3 Microsoft.MixedReality.Toolkit.Physics.FocusDetails::<Normal>k__BackingField
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___U3CNormalU3Ek__BackingField_2;
// UnityEngine.GameObject Microsoft.MixedReality.Toolkit.Physics.FocusDetails::<Object>k__BackingField
GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * ___U3CObjectU3Ek__BackingField_3;
// Microsoft.MixedReality.Toolkit.Input.MixedRealityRaycastHit Microsoft.MixedReality.Toolkit.Physics.FocusDetails::<LastRaycastHit>k__BackingField
MixedRealityRaycastHit_tD69CF29AE572AB1F40DCAA41425AC72EC4031E48 ___U3CLastRaycastHitU3Ek__BackingField_4;
// UnityEngine.EventSystems.RaycastResult Microsoft.MixedReality.Toolkit.Physics.FocusDetails::<LastGraphicsRaycastResult>k__BackingField
RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE ___U3CLastGraphicsRaycastResultU3Ek__BackingField_5;
// UnityEngine.Vector3 Microsoft.MixedReality.Toolkit.Physics.FocusDetails::<PointLocalSpace>k__BackingField
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___U3CPointLocalSpaceU3Ek__BackingField_6;
// UnityEngine.Vector3 Microsoft.MixedReality.Toolkit.Physics.FocusDetails::<NormalLocalSpace>k__BackingField
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___U3CNormalLocalSpaceU3Ek__BackingField_7;
public:
inline static int32_t get_offset_of_U3CRayDistanceU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(FocusDetails_t9D9111B483D3807234CD405067A29099A79620DA, ___U3CRayDistanceU3Ek__BackingField_0)); }
inline float get_U3CRayDistanceU3Ek__BackingField_0() const { return ___U3CRayDistanceU3Ek__BackingField_0; }
inline float* get_address_of_U3CRayDistanceU3Ek__BackingField_0() { return &___U3CRayDistanceU3Ek__BackingField_0; }
inline void set_U3CRayDistanceU3Ek__BackingField_0(float value)
{
___U3CRayDistanceU3Ek__BackingField_0 = value;
}
inline static int32_t get_offset_of_U3CPointU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(FocusDetails_t9D9111B483D3807234CD405067A29099A79620DA, ___U3CPointU3Ek__BackingField_1)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_U3CPointU3Ek__BackingField_1() const { return ___U3CPointU3Ek__BackingField_1; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_U3CPointU3Ek__BackingField_1() { return &___U3CPointU3Ek__BackingField_1; }
inline void set_U3CPointU3Ek__BackingField_1(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___U3CPointU3Ek__BackingField_1 = value;
}
inline static int32_t get_offset_of_U3CNormalU3Ek__BackingField_2() { return static_cast<int32_t>(offsetof(FocusDetails_t9D9111B483D3807234CD405067A29099A79620DA, ___U3CNormalU3Ek__BackingField_2)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_U3CNormalU3Ek__BackingField_2() const { return ___U3CNormalU3Ek__BackingField_2; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_U3CNormalU3Ek__BackingField_2() { return &___U3CNormalU3Ek__BackingField_2; }
inline void set_U3CNormalU3Ek__BackingField_2(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___U3CNormalU3Ek__BackingField_2 = value;
}
inline static int32_t get_offset_of_U3CObjectU3Ek__BackingField_3() { return static_cast<int32_t>(offsetof(FocusDetails_t9D9111B483D3807234CD405067A29099A79620DA, ___U3CObjectU3Ek__BackingField_3)); }
inline GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * get_U3CObjectU3Ek__BackingField_3() const { return ___U3CObjectU3Ek__BackingField_3; }
inline GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 ** get_address_of_U3CObjectU3Ek__BackingField_3() { return &___U3CObjectU3Ek__BackingField_3; }
inline void set_U3CObjectU3Ek__BackingField_3(GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * value)
{
___U3CObjectU3Ek__BackingField_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CObjectU3Ek__BackingField_3), (void*)value);
}
inline static int32_t get_offset_of_U3CLastRaycastHitU3Ek__BackingField_4() { return static_cast<int32_t>(offsetof(FocusDetails_t9D9111B483D3807234CD405067A29099A79620DA, ___U3CLastRaycastHitU3Ek__BackingField_4)); }
inline MixedRealityRaycastHit_tD69CF29AE572AB1F40DCAA41425AC72EC4031E48 get_U3CLastRaycastHitU3Ek__BackingField_4() const { return ___U3CLastRaycastHitU3Ek__BackingField_4; }
inline MixedRealityRaycastHit_tD69CF29AE572AB1F40DCAA41425AC72EC4031E48 * get_address_of_U3CLastRaycastHitU3Ek__BackingField_4() { return &___U3CLastRaycastHitU3Ek__BackingField_4; }
inline void set_U3CLastRaycastHitU3Ek__BackingField_4(MixedRealityRaycastHit_tD69CF29AE572AB1F40DCAA41425AC72EC4031E48 value)
{
___U3CLastRaycastHitU3Ek__BackingField_4 = value;
Il2CppCodeGenWriteBarrier((void**)&(((&___U3CLastRaycastHitU3Ek__BackingField_4))->___transform_7), (void*)NULL);
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&(((&___U3CLastRaycastHitU3Ek__BackingField_4))->___collider_10), (void*)NULL);
#endif
}
inline static int32_t get_offset_of_U3CLastGraphicsRaycastResultU3Ek__BackingField_5() { return static_cast<int32_t>(offsetof(FocusDetails_t9D9111B483D3807234CD405067A29099A79620DA, ___U3CLastGraphicsRaycastResultU3Ek__BackingField_5)); }
inline RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE get_U3CLastGraphicsRaycastResultU3Ek__BackingField_5() const { return ___U3CLastGraphicsRaycastResultU3Ek__BackingField_5; }
inline RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE * get_address_of_U3CLastGraphicsRaycastResultU3Ek__BackingField_5() { return &___U3CLastGraphicsRaycastResultU3Ek__BackingField_5; }
inline void set_U3CLastGraphicsRaycastResultU3Ek__BackingField_5(RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE value)
{
___U3CLastGraphicsRaycastResultU3Ek__BackingField_5 = value;
Il2CppCodeGenWriteBarrier((void**)&(((&___U3CLastGraphicsRaycastResultU3Ek__BackingField_5))->___m_GameObject_0), (void*)NULL);
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&(((&___U3CLastGraphicsRaycastResultU3Ek__BackingField_5))->___module_1), (void*)NULL);
#endif
}
inline static int32_t get_offset_of_U3CPointLocalSpaceU3Ek__BackingField_6() { return static_cast<int32_t>(offsetof(FocusDetails_t9D9111B483D3807234CD405067A29099A79620DA, ___U3CPointLocalSpaceU3Ek__BackingField_6)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_U3CPointLocalSpaceU3Ek__BackingField_6() const { return ___U3CPointLocalSpaceU3Ek__BackingField_6; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_U3CPointLocalSpaceU3Ek__BackingField_6() { return &___U3CPointLocalSpaceU3Ek__BackingField_6; }
inline void set_U3CPointLocalSpaceU3Ek__BackingField_6(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___U3CPointLocalSpaceU3Ek__BackingField_6 = value;
}
inline static int32_t get_offset_of_U3CNormalLocalSpaceU3Ek__BackingField_7() { return static_cast<int32_t>(offsetof(FocusDetails_t9D9111B483D3807234CD405067A29099A79620DA, ___U3CNormalLocalSpaceU3Ek__BackingField_7)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_U3CNormalLocalSpaceU3Ek__BackingField_7() const { return ___U3CNormalLocalSpaceU3Ek__BackingField_7; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_U3CNormalLocalSpaceU3Ek__BackingField_7() { return &___U3CNormalLocalSpaceU3Ek__BackingField_7; }
inline void set_U3CNormalLocalSpaceU3Ek__BackingField_7(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___U3CNormalLocalSpaceU3Ek__BackingField_7 = value;
}
};
// Native definition for P/Invoke marshalling of Microsoft.MixedReality.Toolkit.Physics.FocusDetails
struct FocusDetails_t9D9111B483D3807234CD405067A29099A79620DA_marshaled_pinvoke
{
float ___U3CRayDistanceU3Ek__BackingField_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___U3CPointU3Ek__BackingField_1;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___U3CNormalU3Ek__BackingField_2;
GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * ___U3CObjectU3Ek__BackingField_3;
MixedRealityRaycastHit_tD69CF29AE572AB1F40DCAA41425AC72EC4031E48_marshaled_pinvoke ___U3CLastRaycastHitU3Ek__BackingField_4;
RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE_marshaled_pinvoke ___U3CLastGraphicsRaycastResultU3Ek__BackingField_5;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___U3CPointLocalSpaceU3Ek__BackingField_6;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___U3CNormalLocalSpaceU3Ek__BackingField_7;
};
// Native definition for COM marshalling of Microsoft.MixedReality.Toolkit.Physics.FocusDetails
struct FocusDetails_t9D9111B483D3807234CD405067A29099A79620DA_marshaled_com
{
float ___U3CRayDistanceU3Ek__BackingField_0;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___U3CPointU3Ek__BackingField_1;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___U3CNormalU3Ek__BackingField_2;
GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * ___U3CObjectU3Ek__BackingField_3;
MixedRealityRaycastHit_tD69CF29AE572AB1F40DCAA41425AC72EC4031E48_marshaled_com ___U3CLastRaycastHitU3Ek__BackingField_4;
RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE_marshaled_com ___U3CLastGraphicsRaycastResultU3Ek__BackingField_5;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___U3CPointLocalSpaceU3Ek__BackingField_6;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___U3CNormalLocalSpaceU3Ek__BackingField_7;
};
// UnityEngine.SceneManagement.LoadSceneParameters
struct LoadSceneParameters_t98D2B4FCF0184320590305D3F367834287C2CAA2
{
public:
// UnityEngine.SceneManagement.LoadSceneMode UnityEngine.SceneManagement.LoadSceneParameters::m_LoadSceneMode
int32_t ___m_LoadSceneMode_0;
// UnityEngine.SceneManagement.LocalPhysicsMode UnityEngine.SceneManagement.LoadSceneParameters::m_LocalPhysicsMode
int32_t ___m_LocalPhysicsMode_1;
public:
inline static int32_t get_offset_of_m_LoadSceneMode_0() { return static_cast<int32_t>(offsetof(LoadSceneParameters_t98D2B4FCF0184320590305D3F367834287C2CAA2, ___m_LoadSceneMode_0)); }
inline int32_t get_m_LoadSceneMode_0() const { return ___m_LoadSceneMode_0; }
inline int32_t* get_address_of_m_LoadSceneMode_0() { return &___m_LoadSceneMode_0; }
inline void set_m_LoadSceneMode_0(int32_t value)
{
___m_LoadSceneMode_0 = value;
}
inline static int32_t get_offset_of_m_LocalPhysicsMode_1() { return static_cast<int32_t>(offsetof(LoadSceneParameters_t98D2B4FCF0184320590305D3F367834287C2CAA2, ___m_LocalPhysicsMode_1)); }
inline int32_t get_m_LocalPhysicsMode_1() const { return ___m_LocalPhysicsMode_1; }
inline int32_t* get_address_of_m_LocalPhysicsMode_1() { return &___m_LocalPhysicsMode_1; }
inline void set_m_LocalPhysicsMode_1(int32_t value)
{
___m_LocalPhysicsMode_1 = value;
}
};
// UnityEngine.XR.MagicLeap.MLResult
struct MLResult_t16167FAD492D3A6F53116897898D23453C72B635
{
public:
// UnityEngine.XR.MagicLeap.MLResult/Code UnityEngine.XR.MagicLeap.MLResult::Result
int32_t ___Result_0;
// System.String UnityEngine.XR.MagicLeap.MLResult::message
String_t* ___message_2;
public:
inline static int32_t get_offset_of_Result_0() { return static_cast<int32_t>(offsetof(MLResult_t16167FAD492D3A6F53116897898D23453C72B635, ___Result_0)); }
inline int32_t get_Result_0() const { return ___Result_0; }
inline int32_t* get_address_of_Result_0() { return &___Result_0; }
inline void set_Result_0(int32_t value)
{
___Result_0 = value;
}
inline static int32_t get_offset_of_message_2() { return static_cast<int32_t>(offsetof(MLResult_t16167FAD492D3A6F53116897898D23453C72B635, ___message_2)); }
inline String_t* get_message_2() const { return ___message_2; }
inline String_t** get_address_of_message_2() { return &___message_2; }
inline void set_message_2(String_t* value)
{
___message_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___message_2), (void*)value);
}
};
struct MLResult_t16167FAD492D3A6F53116897898D23453C72B635_StaticFields
{
public:
// System.Collections.Generic.Dictionary`2<UnityEngine.XR.MagicLeap.MLResult/Code,UnityEngine.XR.MagicLeap.MLResult> UnityEngine.XR.MagicLeap.MLResult::existingResults
Dictionary_2_tD6F5BABC8E0815B66CB3FCE70A8A0FCF9837CBF1 * ___existingResults_1;
public:
inline static int32_t get_offset_of_existingResults_1() { return static_cast<int32_t>(offsetof(MLResult_t16167FAD492D3A6F53116897898D23453C72B635_StaticFields, ___existingResults_1)); }
inline Dictionary_2_tD6F5BABC8E0815B66CB3FCE70A8A0FCF9837CBF1 * get_existingResults_1() const { return ___existingResults_1; }
inline Dictionary_2_tD6F5BABC8E0815B66CB3FCE70A8A0FCF9837CBF1 ** get_address_of_existingResults_1() { return &___existingResults_1; }
inline void set_existingResults_1(Dictionary_2_tD6F5BABC8E0815B66CB3FCE70A8A0FCF9837CBF1 * value)
{
___existingResults_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___existingResults_1), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MagicLeap.MLResult
struct MLResult_t16167FAD492D3A6F53116897898D23453C72B635_marshaled_pinvoke
{
int32_t ___Result_0;
char* ___message_2;
};
// Native definition for COM marshalling of UnityEngine.XR.MagicLeap.MLResult
struct MLResult_t16167FAD492D3A6F53116897898D23453C72B635_marshaled_com
{
int32_t ___Result_0;
Il2CppChar* ___message_2;
};
// UnityEngine.XR.MagicLeap.MagicLeapKeyPoseGestureEvent
struct MagicLeapKeyPoseGestureEvent_t1DCE5B3073F1B16761D19D641DEDB85A3F64F0E2
{
public:
// UnityEngine.XR.InteractionSubsystems.GestureId UnityEngine.XR.MagicLeap.MagicLeapKeyPoseGestureEvent::m_Id
GestureId_tF3EFA115E02FC8A313B1019689130A09419B1EC7 ___m_Id_0;
// UnityEngine.XR.InteractionSubsystems.GestureState UnityEngine.XR.MagicLeap.MagicLeapKeyPoseGestureEvent::m_State
int32_t ___m_State_1;
// UnityEngine.XR.MagicLeap.MagicLeapKeyPose UnityEngine.XR.MagicLeap.MagicLeapKeyPoseGestureEvent::m_KeyPose
int32_t ___m_KeyPose_2;
// UnityEngine.XR.MagicLeap.MagicLeapHand UnityEngine.XR.MagicLeap.MagicLeapKeyPoseGestureEvent::m_Hand
int32_t ___m_Hand_3;
public:
inline static int32_t get_offset_of_m_Id_0() { return static_cast<int32_t>(offsetof(MagicLeapKeyPoseGestureEvent_t1DCE5B3073F1B16761D19D641DEDB85A3F64F0E2, ___m_Id_0)); }
inline GestureId_tF3EFA115E02FC8A313B1019689130A09419B1EC7 get_m_Id_0() const { return ___m_Id_0; }
inline GestureId_tF3EFA115E02FC8A313B1019689130A09419B1EC7 * get_address_of_m_Id_0() { return &___m_Id_0; }
inline void set_m_Id_0(GestureId_tF3EFA115E02FC8A313B1019689130A09419B1EC7 value)
{
___m_Id_0 = value;
}
inline static int32_t get_offset_of_m_State_1() { return static_cast<int32_t>(offsetof(MagicLeapKeyPoseGestureEvent_t1DCE5B3073F1B16761D19D641DEDB85A3F64F0E2, ___m_State_1)); }
inline int32_t get_m_State_1() const { return ___m_State_1; }
inline int32_t* get_address_of_m_State_1() { return &___m_State_1; }
inline void set_m_State_1(int32_t value)
{
___m_State_1 = value;
}
inline static int32_t get_offset_of_m_KeyPose_2() { return static_cast<int32_t>(offsetof(MagicLeapKeyPoseGestureEvent_t1DCE5B3073F1B16761D19D641DEDB85A3F64F0E2, ___m_KeyPose_2)); }
inline int32_t get_m_KeyPose_2() const { return ___m_KeyPose_2; }
inline int32_t* get_address_of_m_KeyPose_2() { return &___m_KeyPose_2; }
inline void set_m_KeyPose_2(int32_t value)
{
___m_KeyPose_2 = value;
}
inline static int32_t get_offset_of_m_Hand_3() { return static_cast<int32_t>(offsetof(MagicLeapKeyPoseGestureEvent_t1DCE5B3073F1B16761D19D641DEDB85A3F64F0E2, ___m_Hand_3)); }
inline int32_t get_m_Hand_3() const { return ___m_Hand_3; }
inline int32_t* get_address_of_m_Hand_3() { return &___m_Hand_3; }
inline void set_m_Hand_3(int32_t value)
{
___m_Hand_3 = value;
}
};
// UnityEngine.XR.MagicLeap.MagicLeapTouchpadGestureEvent
struct MagicLeapTouchpadGestureEvent_t81F61003445761DF336429222C1A5E8ED0E8A56A
{
public:
// UnityEngine.XR.InteractionSubsystems.GestureId UnityEngine.XR.MagicLeap.MagicLeapTouchpadGestureEvent::m_Id
GestureId_tF3EFA115E02FC8A313B1019689130A09419B1EC7 ___m_Id_0;
// UnityEngine.XR.InteractionSubsystems.GestureState UnityEngine.XR.MagicLeap.MagicLeapTouchpadGestureEvent::m_State
int32_t ___m_State_1;
// System.Byte UnityEngine.XR.MagicLeap.MagicLeapTouchpadGestureEvent::m_ControllerId
uint8_t ___m_ControllerId_2;
// System.Single UnityEngine.XR.MagicLeap.MagicLeapTouchpadGestureEvent::m_Angle
float ___m_Angle_3;
// UnityEngine.XR.MagicLeap.MagicLeapTouchpadGestureDirection UnityEngine.XR.MagicLeap.MagicLeapTouchpadGestureEvent::m_Direction
int32_t ___m_Direction_4;
// System.Single UnityEngine.XR.MagicLeap.MagicLeapTouchpadGestureEvent::m_Distance
float ___m_Distance_5;
// System.Single UnityEngine.XR.MagicLeap.MagicLeapTouchpadGestureEvent::m_FingerGap
float ___m_FingerGap_6;
// UnityEngine.Vector3 UnityEngine.XR.MagicLeap.MagicLeapTouchpadGestureEvent::m_PositionAndForce
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_PositionAndForce_7;
// System.Single UnityEngine.XR.MagicLeap.MagicLeapTouchpadGestureEvent::m_Radius
float ___m_Radius_8;
// System.Single UnityEngine.XR.MagicLeap.MagicLeapTouchpadGestureEvent::m_Speed
float ___m_Speed_9;
// UnityEngine.XR.MagicLeap.MagicLeapInputControllerTouchpadGestureType UnityEngine.XR.MagicLeap.MagicLeapTouchpadGestureEvent::m_Type
int32_t ___m_Type_10;
public:
inline static int32_t get_offset_of_m_Id_0() { return static_cast<int32_t>(offsetof(MagicLeapTouchpadGestureEvent_t81F61003445761DF336429222C1A5E8ED0E8A56A, ___m_Id_0)); }
inline GestureId_tF3EFA115E02FC8A313B1019689130A09419B1EC7 get_m_Id_0() const { return ___m_Id_0; }
inline GestureId_tF3EFA115E02FC8A313B1019689130A09419B1EC7 * get_address_of_m_Id_0() { return &___m_Id_0; }
inline void set_m_Id_0(GestureId_tF3EFA115E02FC8A313B1019689130A09419B1EC7 value)
{
___m_Id_0 = value;
}
inline static int32_t get_offset_of_m_State_1() { return static_cast<int32_t>(offsetof(MagicLeapTouchpadGestureEvent_t81F61003445761DF336429222C1A5E8ED0E8A56A, ___m_State_1)); }
inline int32_t get_m_State_1() const { return ___m_State_1; }
inline int32_t* get_address_of_m_State_1() { return &___m_State_1; }
inline void set_m_State_1(int32_t value)
{
___m_State_1 = value;
}
inline static int32_t get_offset_of_m_ControllerId_2() { return static_cast<int32_t>(offsetof(MagicLeapTouchpadGestureEvent_t81F61003445761DF336429222C1A5E8ED0E8A56A, ___m_ControllerId_2)); }
inline uint8_t get_m_ControllerId_2() const { return ___m_ControllerId_2; }
inline uint8_t* get_address_of_m_ControllerId_2() { return &___m_ControllerId_2; }
inline void set_m_ControllerId_2(uint8_t value)
{
___m_ControllerId_2 = value;
}
inline static int32_t get_offset_of_m_Angle_3() { return static_cast<int32_t>(offsetof(MagicLeapTouchpadGestureEvent_t81F61003445761DF336429222C1A5E8ED0E8A56A, ___m_Angle_3)); }
inline float get_m_Angle_3() const { return ___m_Angle_3; }
inline float* get_address_of_m_Angle_3() { return &___m_Angle_3; }
inline void set_m_Angle_3(float value)
{
___m_Angle_3 = value;
}
inline static int32_t get_offset_of_m_Direction_4() { return static_cast<int32_t>(offsetof(MagicLeapTouchpadGestureEvent_t81F61003445761DF336429222C1A5E8ED0E8A56A, ___m_Direction_4)); }
inline int32_t get_m_Direction_4() const { return ___m_Direction_4; }
inline int32_t* get_address_of_m_Direction_4() { return &___m_Direction_4; }
inline void set_m_Direction_4(int32_t value)
{
___m_Direction_4 = value;
}
inline static int32_t get_offset_of_m_Distance_5() { return static_cast<int32_t>(offsetof(MagicLeapTouchpadGestureEvent_t81F61003445761DF336429222C1A5E8ED0E8A56A, ___m_Distance_5)); }
inline float get_m_Distance_5() const { return ___m_Distance_5; }
inline float* get_address_of_m_Distance_5() { return &___m_Distance_5; }
inline void set_m_Distance_5(float value)
{
___m_Distance_5 = value;
}
inline static int32_t get_offset_of_m_FingerGap_6() { return static_cast<int32_t>(offsetof(MagicLeapTouchpadGestureEvent_t81F61003445761DF336429222C1A5E8ED0E8A56A, ___m_FingerGap_6)); }
inline float get_m_FingerGap_6() const { return ___m_FingerGap_6; }
inline float* get_address_of_m_FingerGap_6() { return &___m_FingerGap_6; }
inline void set_m_FingerGap_6(float value)
{
___m_FingerGap_6 = value;
}
inline static int32_t get_offset_of_m_PositionAndForce_7() { return static_cast<int32_t>(offsetof(MagicLeapTouchpadGestureEvent_t81F61003445761DF336429222C1A5E8ED0E8A56A, ___m_PositionAndForce_7)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_PositionAndForce_7() const { return ___m_PositionAndForce_7; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_PositionAndForce_7() { return &___m_PositionAndForce_7; }
inline void set_m_PositionAndForce_7(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_PositionAndForce_7 = value;
}
inline static int32_t get_offset_of_m_Radius_8() { return static_cast<int32_t>(offsetof(MagicLeapTouchpadGestureEvent_t81F61003445761DF336429222C1A5E8ED0E8A56A, ___m_Radius_8)); }
inline float get_m_Radius_8() const { return ___m_Radius_8; }
inline float* get_address_of_m_Radius_8() { return &___m_Radius_8; }
inline void set_m_Radius_8(float value)
{
___m_Radius_8 = value;
}
inline static int32_t get_offset_of_m_Speed_9() { return static_cast<int32_t>(offsetof(MagicLeapTouchpadGestureEvent_t81F61003445761DF336429222C1A5E8ED0E8A56A, ___m_Speed_9)); }
inline float get_m_Speed_9() const { return ___m_Speed_9; }
inline float* get_address_of_m_Speed_9() { return &___m_Speed_9; }
inline void set_m_Speed_9(float value)
{
___m_Speed_9 = value;
}
inline static int32_t get_offset_of_m_Type_10() { return static_cast<int32_t>(offsetof(MagicLeapTouchpadGestureEvent_t81F61003445761DF336429222C1A5E8ED0E8A56A, ___m_Type_10)); }
inline int32_t get_m_Type_10() const { return ___m_Type_10; }
inline int32_t* get_address_of_m_Type_10() { return &___m_Type_10; }
inline void set_m_Type_10(int32_t value)
{
___m_Type_10 = value;
}
};
// UnityEngine.XR.MeshGenerationResult
struct MeshGenerationResult_t081845588E8932BB4BA2D6F087D2F2F0EE3373CF
{
public:
// UnityEngine.XR.MeshId UnityEngine.XR.MeshGenerationResult::<MeshId>k__BackingField
MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 ___U3CMeshIdU3Ek__BackingField_0;
// UnityEngine.Mesh UnityEngine.XR.MeshGenerationResult::<Mesh>k__BackingField
Mesh_t2F5992DBA650D5862B43D3823ACD997132A57DA6 * ___U3CMeshU3Ek__BackingField_1;
// UnityEngine.MeshCollider UnityEngine.XR.MeshGenerationResult::<MeshCollider>k__BackingField
MeshCollider_t1983F4E7E53D8C6B65FE21A8B4E2345A84D57E98 * ___U3CMeshColliderU3Ek__BackingField_2;
// UnityEngine.XR.MeshGenerationStatus UnityEngine.XR.MeshGenerationResult::<Status>k__BackingField
int32_t ___U3CStatusU3Ek__BackingField_3;
// UnityEngine.XR.MeshVertexAttributes UnityEngine.XR.MeshGenerationResult::<Attributes>k__BackingField
int32_t ___U3CAttributesU3Ek__BackingField_4;
public:
inline static int32_t get_offset_of_U3CMeshIdU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(MeshGenerationResult_t081845588E8932BB4BA2D6F087D2F2F0EE3373CF, ___U3CMeshIdU3Ek__BackingField_0)); }
inline MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 get_U3CMeshIdU3Ek__BackingField_0() const { return ___U3CMeshIdU3Ek__BackingField_0; }
inline MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 * get_address_of_U3CMeshIdU3Ek__BackingField_0() { return &___U3CMeshIdU3Ek__BackingField_0; }
inline void set_U3CMeshIdU3Ek__BackingField_0(MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 value)
{
___U3CMeshIdU3Ek__BackingField_0 = value;
}
inline static int32_t get_offset_of_U3CMeshU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(MeshGenerationResult_t081845588E8932BB4BA2D6F087D2F2F0EE3373CF, ___U3CMeshU3Ek__BackingField_1)); }
inline Mesh_t2F5992DBA650D5862B43D3823ACD997132A57DA6 * get_U3CMeshU3Ek__BackingField_1() const { return ___U3CMeshU3Ek__BackingField_1; }
inline Mesh_t2F5992DBA650D5862B43D3823ACD997132A57DA6 ** get_address_of_U3CMeshU3Ek__BackingField_1() { return &___U3CMeshU3Ek__BackingField_1; }
inline void set_U3CMeshU3Ek__BackingField_1(Mesh_t2F5992DBA650D5862B43D3823ACD997132A57DA6 * value)
{
___U3CMeshU3Ek__BackingField_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CMeshU3Ek__BackingField_1), (void*)value);
}
inline static int32_t get_offset_of_U3CMeshColliderU3Ek__BackingField_2() { return static_cast<int32_t>(offsetof(MeshGenerationResult_t081845588E8932BB4BA2D6F087D2F2F0EE3373CF, ___U3CMeshColliderU3Ek__BackingField_2)); }
inline MeshCollider_t1983F4E7E53D8C6B65FE21A8B4E2345A84D57E98 * get_U3CMeshColliderU3Ek__BackingField_2() const { return ___U3CMeshColliderU3Ek__BackingField_2; }
inline MeshCollider_t1983F4E7E53D8C6B65FE21A8B4E2345A84D57E98 ** get_address_of_U3CMeshColliderU3Ek__BackingField_2() { return &___U3CMeshColliderU3Ek__BackingField_2; }
inline void set_U3CMeshColliderU3Ek__BackingField_2(MeshCollider_t1983F4E7E53D8C6B65FE21A8B4E2345A84D57E98 * value)
{
___U3CMeshColliderU3Ek__BackingField_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CMeshColliderU3Ek__BackingField_2), (void*)value);
}
inline static int32_t get_offset_of_U3CStatusU3Ek__BackingField_3() { return static_cast<int32_t>(offsetof(MeshGenerationResult_t081845588E8932BB4BA2D6F087D2F2F0EE3373CF, ___U3CStatusU3Ek__BackingField_3)); }
inline int32_t get_U3CStatusU3Ek__BackingField_3() const { return ___U3CStatusU3Ek__BackingField_3; }
inline int32_t* get_address_of_U3CStatusU3Ek__BackingField_3() { return &___U3CStatusU3Ek__BackingField_3; }
inline void set_U3CStatusU3Ek__BackingField_3(int32_t value)
{
___U3CStatusU3Ek__BackingField_3 = value;
}
inline static int32_t get_offset_of_U3CAttributesU3Ek__BackingField_4() { return static_cast<int32_t>(offsetof(MeshGenerationResult_t081845588E8932BB4BA2D6F087D2F2F0EE3373CF, ___U3CAttributesU3Ek__BackingField_4)); }
inline int32_t get_U3CAttributesU3Ek__BackingField_4() const { return ___U3CAttributesU3Ek__BackingField_4; }
inline int32_t* get_address_of_U3CAttributesU3Ek__BackingField_4() { return &___U3CAttributesU3Ek__BackingField_4; }
inline void set_U3CAttributesU3Ek__BackingField_4(int32_t value)
{
___U3CAttributesU3Ek__BackingField_4 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MeshGenerationResult
struct MeshGenerationResult_t081845588E8932BB4BA2D6F087D2F2F0EE3373CF_marshaled_pinvoke
{
MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 ___U3CMeshIdU3Ek__BackingField_0;
Mesh_t2F5992DBA650D5862B43D3823ACD997132A57DA6 * ___U3CMeshU3Ek__BackingField_1;
MeshCollider_t1983F4E7E53D8C6B65FE21A8B4E2345A84D57E98 * ___U3CMeshColliderU3Ek__BackingField_2;
int32_t ___U3CStatusU3Ek__BackingField_3;
int32_t ___U3CAttributesU3Ek__BackingField_4;
};
// Native definition for COM marshalling of UnityEngine.XR.MeshGenerationResult
struct MeshGenerationResult_t081845588E8932BB4BA2D6F087D2F2F0EE3373CF_marshaled_com
{
MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 ___U3CMeshIdU3Ek__BackingField_0;
Mesh_t2F5992DBA650D5862B43D3823ACD997132A57DA6 * ___U3CMeshU3Ek__BackingField_1;
MeshCollider_t1983F4E7E53D8C6B65FE21A8B4E2345A84D57E98 * ___U3CMeshColliderU3Ek__BackingField_2;
int32_t ___U3CStatusU3Ek__BackingField_3;
int32_t ___U3CAttributesU3Ek__BackingField_4;
};
// UnityEngine.XR.MeshInfo
struct MeshInfo_tD0E09CA3A2260A509C063BF0C8FDAC8D138FC611
{
public:
// UnityEngine.XR.MeshId UnityEngine.XR.MeshInfo::<MeshId>k__BackingField
MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 ___U3CMeshIdU3Ek__BackingField_0;
// UnityEngine.XR.MeshChangeState UnityEngine.XR.MeshInfo::<ChangeState>k__BackingField
int32_t ___U3CChangeStateU3Ek__BackingField_1;
// System.Int32 UnityEngine.XR.MeshInfo::<PriorityHint>k__BackingField
int32_t ___U3CPriorityHintU3Ek__BackingField_2;
public:
inline static int32_t get_offset_of_U3CMeshIdU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(MeshInfo_tD0E09CA3A2260A509C063BF0C8FDAC8D138FC611, ___U3CMeshIdU3Ek__BackingField_0)); }
inline MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 get_U3CMeshIdU3Ek__BackingField_0() const { return ___U3CMeshIdU3Ek__BackingField_0; }
inline MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 * get_address_of_U3CMeshIdU3Ek__BackingField_0() { return &___U3CMeshIdU3Ek__BackingField_0; }
inline void set_U3CMeshIdU3Ek__BackingField_0(MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 value)
{
___U3CMeshIdU3Ek__BackingField_0 = value;
}
inline static int32_t get_offset_of_U3CChangeStateU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(MeshInfo_tD0E09CA3A2260A509C063BF0C8FDAC8D138FC611, ___U3CChangeStateU3Ek__BackingField_1)); }
inline int32_t get_U3CChangeStateU3Ek__BackingField_1() const { return ___U3CChangeStateU3Ek__BackingField_1; }
inline int32_t* get_address_of_U3CChangeStateU3Ek__BackingField_1() { return &___U3CChangeStateU3Ek__BackingField_1; }
inline void set_U3CChangeStateU3Ek__BackingField_1(int32_t value)
{
___U3CChangeStateU3Ek__BackingField_1 = value;
}
inline static int32_t get_offset_of_U3CPriorityHintU3Ek__BackingField_2() { return static_cast<int32_t>(offsetof(MeshInfo_tD0E09CA3A2260A509C063BF0C8FDAC8D138FC611, ___U3CPriorityHintU3Ek__BackingField_2)); }
inline int32_t get_U3CPriorityHintU3Ek__BackingField_2() const { return ___U3CPriorityHintU3Ek__BackingField_2; }
inline int32_t* get_address_of_U3CPriorityHintU3Ek__BackingField_2() { return &___U3CPriorityHintU3Ek__BackingField_2; }
inline void set_U3CPriorityHintU3Ek__BackingField_2(int32_t value)
{
___U3CPriorityHintU3Ek__BackingField_2 = value;
}
};
// Microsoft.MixedReality.Toolkit.Input.MixedRealityInputAction
struct MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A
{
public:
// System.UInt32 Microsoft.MixedReality.Toolkit.Input.MixedRealityInputAction::id
uint32_t ___id_1;
// System.String Microsoft.MixedReality.Toolkit.Input.MixedRealityInputAction::description
String_t* ___description_2;
// Microsoft.MixedReality.Toolkit.Utilities.AxisType Microsoft.MixedReality.Toolkit.Input.MixedRealityInputAction::axisConstraint
int32_t ___axisConstraint_3;
public:
inline static int32_t get_offset_of_id_1() { return static_cast<int32_t>(offsetof(MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A, ___id_1)); }
inline uint32_t get_id_1() const { return ___id_1; }
inline uint32_t* get_address_of_id_1() { return &___id_1; }
inline void set_id_1(uint32_t value)
{
___id_1 = value;
}
inline static int32_t get_offset_of_description_2() { return static_cast<int32_t>(offsetof(MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A, ___description_2)); }
inline String_t* get_description_2() const { return ___description_2; }
inline String_t** get_address_of_description_2() { return &___description_2; }
inline void set_description_2(String_t* value)
{
___description_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___description_2), (void*)value);
}
inline static int32_t get_offset_of_axisConstraint_3() { return static_cast<int32_t>(offsetof(MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A, ___axisConstraint_3)); }
inline int32_t get_axisConstraint_3() const { return ___axisConstraint_3; }
inline int32_t* get_address_of_axisConstraint_3() { return &___axisConstraint_3; }
inline void set_axisConstraint_3(int32_t value)
{
___axisConstraint_3 = value;
}
};
struct MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A_StaticFields
{
public:
// Microsoft.MixedReality.Toolkit.Input.MixedRealityInputAction Microsoft.MixedReality.Toolkit.Input.MixedRealityInputAction::<None>k__BackingField
MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A ___U3CNoneU3Ek__BackingField_0;
public:
inline static int32_t get_offset_of_U3CNoneU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A_StaticFields, ___U3CNoneU3Ek__BackingField_0)); }
inline MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A get_U3CNoneU3Ek__BackingField_0() const { return ___U3CNoneU3Ek__BackingField_0; }
inline MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A * get_address_of_U3CNoneU3Ek__BackingField_0() { return &___U3CNoneU3Ek__BackingField_0; }
inline void set_U3CNoneU3Ek__BackingField_0(MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A value)
{
___U3CNoneU3Ek__BackingField_0 = value;
Il2CppCodeGenWriteBarrier((void**)&(((&___U3CNoneU3Ek__BackingField_0))->___description_2), (void*)NULL);
}
};
// Native definition for P/Invoke marshalling of Microsoft.MixedReality.Toolkit.Input.MixedRealityInputAction
struct MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A_marshaled_pinvoke
{
uint32_t ___id_1;
char* ___description_2;
int32_t ___axisConstraint_3;
};
// Native definition for COM marshalling of Microsoft.MixedReality.Toolkit.Input.MixedRealityInputAction
struct MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A_marshaled_com
{
uint32_t ___id_1;
Il2CppChar* ___description_2;
int32_t ___axisConstraint_3;
};
// Microsoft.MixedReality.Toolkit.Utilities.MixedRealityTransform
struct MixedRealityTransform_tB8BF0B2CCF0776ABB28C6356EEF0FC1C3CBACE95
{
public:
// Microsoft.MixedReality.Toolkit.Utilities.MixedRealityPose Microsoft.MixedReality.Toolkit.Utilities.MixedRealityTransform::pose
MixedRealityPose_t9A27AAE05672995793F76985CE167AA85B8DF5AF ___pose_1;
// UnityEngine.Vector3 Microsoft.MixedReality.Toolkit.Utilities.MixedRealityTransform::scale
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___scale_2;
public:
inline static int32_t get_offset_of_pose_1() { return static_cast<int32_t>(offsetof(MixedRealityTransform_tB8BF0B2CCF0776ABB28C6356EEF0FC1C3CBACE95, ___pose_1)); }
inline MixedRealityPose_t9A27AAE05672995793F76985CE167AA85B8DF5AF get_pose_1() const { return ___pose_1; }
inline MixedRealityPose_t9A27AAE05672995793F76985CE167AA85B8DF5AF * get_address_of_pose_1() { return &___pose_1; }
inline void set_pose_1(MixedRealityPose_t9A27AAE05672995793F76985CE167AA85B8DF5AF value)
{
___pose_1 = value;
}
inline static int32_t get_offset_of_scale_2() { return static_cast<int32_t>(offsetof(MixedRealityTransform_tB8BF0B2CCF0776ABB28C6356EEF0FC1C3CBACE95, ___scale_2)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_scale_2() const { return ___scale_2; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_scale_2() { return &___scale_2; }
inline void set_scale_2(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___scale_2 = value;
}
};
struct MixedRealityTransform_tB8BF0B2CCF0776ABB28C6356EEF0FC1C3CBACE95_StaticFields
{
public:
// Microsoft.MixedReality.Toolkit.Utilities.MixedRealityTransform Microsoft.MixedReality.Toolkit.Utilities.MixedRealityTransform::<Identity>k__BackingField
MixedRealityTransform_tB8BF0B2CCF0776ABB28C6356EEF0FC1C3CBACE95 ___U3CIdentityU3Ek__BackingField_0;
public:
inline static int32_t get_offset_of_U3CIdentityU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(MixedRealityTransform_tB8BF0B2CCF0776ABB28C6356EEF0FC1C3CBACE95_StaticFields, ___U3CIdentityU3Ek__BackingField_0)); }
inline MixedRealityTransform_tB8BF0B2CCF0776ABB28C6356EEF0FC1C3CBACE95 get_U3CIdentityU3Ek__BackingField_0() const { return ___U3CIdentityU3Ek__BackingField_0; }
inline MixedRealityTransform_tB8BF0B2CCF0776ABB28C6356EEF0FC1C3CBACE95 * get_address_of_U3CIdentityU3Ek__BackingField_0() { return &___U3CIdentityU3Ek__BackingField_0; }
inline void set_U3CIdentityU3Ek__BackingField_0(MixedRealityTransform_tB8BF0B2CCF0776ABB28C6356EEF0FC1C3CBACE95 value)
{
___U3CIdentityU3Ek__BackingField_0 = value;
}
};
// UnityEngine.UI.Navigation
struct Navigation_t1CF0FFB22C0357CD64714FB7A40A275F899D363A
{
public:
// UnityEngine.UI.Navigation/Mode UnityEngine.UI.Navigation::m_Mode
int32_t ___m_Mode_0;
// System.Boolean UnityEngine.UI.Navigation::m_WrapAround
bool ___m_WrapAround_1;
// UnityEngine.UI.Selectable UnityEngine.UI.Navigation::m_SelectOnUp
Selectable_t34088A3677CC9D344F81B0D91999D8C5963D7DBD * ___m_SelectOnUp_2;
// UnityEngine.UI.Selectable UnityEngine.UI.Navigation::m_SelectOnDown
Selectable_t34088A3677CC9D344F81B0D91999D8C5963D7DBD * ___m_SelectOnDown_3;
// UnityEngine.UI.Selectable UnityEngine.UI.Navigation::m_SelectOnLeft
Selectable_t34088A3677CC9D344F81B0D91999D8C5963D7DBD * ___m_SelectOnLeft_4;
// UnityEngine.UI.Selectable UnityEngine.UI.Navigation::m_SelectOnRight
Selectable_t34088A3677CC9D344F81B0D91999D8C5963D7DBD * ___m_SelectOnRight_5;
public:
inline static int32_t get_offset_of_m_Mode_0() { return static_cast<int32_t>(offsetof(Navigation_t1CF0FFB22C0357CD64714FB7A40A275F899D363A, ___m_Mode_0)); }
inline int32_t get_m_Mode_0() const { return ___m_Mode_0; }
inline int32_t* get_address_of_m_Mode_0() { return &___m_Mode_0; }
inline void set_m_Mode_0(int32_t value)
{
___m_Mode_0 = value;
}
inline static int32_t get_offset_of_m_WrapAround_1() { return static_cast<int32_t>(offsetof(Navigation_t1CF0FFB22C0357CD64714FB7A40A275F899D363A, ___m_WrapAround_1)); }
inline bool get_m_WrapAround_1() const { return ___m_WrapAround_1; }
inline bool* get_address_of_m_WrapAround_1() { return &___m_WrapAround_1; }
inline void set_m_WrapAround_1(bool value)
{
___m_WrapAround_1 = value;
}
inline static int32_t get_offset_of_m_SelectOnUp_2() { return static_cast<int32_t>(offsetof(Navigation_t1CF0FFB22C0357CD64714FB7A40A275F899D363A, ___m_SelectOnUp_2)); }
inline Selectable_t34088A3677CC9D344F81B0D91999D8C5963D7DBD * get_m_SelectOnUp_2() const { return ___m_SelectOnUp_2; }
inline Selectable_t34088A3677CC9D344F81B0D91999D8C5963D7DBD ** get_address_of_m_SelectOnUp_2() { return &___m_SelectOnUp_2; }
inline void set_m_SelectOnUp_2(Selectable_t34088A3677CC9D344F81B0D91999D8C5963D7DBD * value)
{
___m_SelectOnUp_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_SelectOnUp_2), (void*)value);
}
inline static int32_t get_offset_of_m_SelectOnDown_3() { return static_cast<int32_t>(offsetof(Navigation_t1CF0FFB22C0357CD64714FB7A40A275F899D363A, ___m_SelectOnDown_3)); }
inline Selectable_t34088A3677CC9D344F81B0D91999D8C5963D7DBD * get_m_SelectOnDown_3() const { return ___m_SelectOnDown_3; }
inline Selectable_t34088A3677CC9D344F81B0D91999D8C5963D7DBD ** get_address_of_m_SelectOnDown_3() { return &___m_SelectOnDown_3; }
inline void set_m_SelectOnDown_3(Selectable_t34088A3677CC9D344F81B0D91999D8C5963D7DBD * value)
{
___m_SelectOnDown_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_SelectOnDown_3), (void*)value);
}
inline static int32_t get_offset_of_m_SelectOnLeft_4() { return static_cast<int32_t>(offsetof(Navigation_t1CF0FFB22C0357CD64714FB7A40A275F899D363A, ___m_SelectOnLeft_4)); }
inline Selectable_t34088A3677CC9D344F81B0D91999D8C5963D7DBD * get_m_SelectOnLeft_4() const { return ___m_SelectOnLeft_4; }
inline Selectable_t34088A3677CC9D344F81B0D91999D8C5963D7DBD ** get_address_of_m_SelectOnLeft_4() { return &___m_SelectOnLeft_4; }
inline void set_m_SelectOnLeft_4(Selectable_t34088A3677CC9D344F81B0D91999D8C5963D7DBD * value)
{
___m_SelectOnLeft_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_SelectOnLeft_4), (void*)value);
}
inline static int32_t get_offset_of_m_SelectOnRight_5() { return static_cast<int32_t>(offsetof(Navigation_t1CF0FFB22C0357CD64714FB7A40A275F899D363A, ___m_SelectOnRight_5)); }
inline Selectable_t34088A3677CC9D344F81B0D91999D8C5963D7DBD * get_m_SelectOnRight_5() const { return ___m_SelectOnRight_5; }
inline Selectable_t34088A3677CC9D344F81B0D91999D8C5963D7DBD ** get_address_of_m_SelectOnRight_5() { return &___m_SelectOnRight_5; }
inline void set_m_SelectOnRight_5(Selectable_t34088A3677CC9D344F81B0D91999D8C5963D7DBD * value)
{
___m_SelectOnRight_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_SelectOnRight_5), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.UI.Navigation
struct Navigation_t1CF0FFB22C0357CD64714FB7A40A275F899D363A_marshaled_pinvoke
{
int32_t ___m_Mode_0;
int32_t ___m_WrapAround_1;
Selectable_t34088A3677CC9D344F81B0D91999D8C5963D7DBD * ___m_SelectOnUp_2;
Selectable_t34088A3677CC9D344F81B0D91999D8C5963D7DBD * ___m_SelectOnDown_3;
Selectable_t34088A3677CC9D344F81B0D91999D8C5963D7DBD * ___m_SelectOnLeft_4;
Selectable_t34088A3677CC9D344F81B0D91999D8C5963D7DBD * ___m_SelectOnRight_5;
};
// Native definition for COM marshalling of UnityEngine.UI.Navigation
struct Navigation_t1CF0FFB22C0357CD64714FB7A40A275F899D363A_marshaled_com
{
int32_t ___m_Mode_0;
int32_t ___m_WrapAround_1;
Selectable_t34088A3677CC9D344F81B0D91999D8C5963D7DBD * ___m_SelectOnUp_2;
Selectable_t34088A3677CC9D344F81B0D91999D8C5963D7DBD * ___m_SelectOnDown_3;
Selectable_t34088A3677CC9D344F81B0D91999D8C5963D7DBD * ___m_SelectOnLeft_4;
Selectable_t34088A3677CC9D344F81B0D91999D8C5963D7DBD * ___m_SelectOnRight_5;
};
// UnityEngine.Playables.Playable
struct Playable_tC24692CDD1DD8F1D5C646035A76D2830A70214E2
{
public:
// UnityEngine.Playables.PlayableHandle UnityEngine.Playables.Playable::m_Handle
PlayableHandle_t50DCD240B0400DDAD0822C13E5DBC7AD64DC027A ___m_Handle_0;
public:
inline static int32_t get_offset_of_m_Handle_0() { return static_cast<int32_t>(offsetof(Playable_tC24692CDD1DD8F1D5C646035A76D2830A70214E2, ___m_Handle_0)); }
inline PlayableHandle_t50DCD240B0400DDAD0822C13E5DBC7AD64DC027A get_m_Handle_0() const { return ___m_Handle_0; }
inline PlayableHandle_t50DCD240B0400DDAD0822C13E5DBC7AD64DC027A * get_address_of_m_Handle_0() { return &___m_Handle_0; }
inline void set_m_Handle_0(PlayableHandle_t50DCD240B0400DDAD0822C13E5DBC7AD64DC027A value)
{
___m_Handle_0 = value;
}
};
struct Playable_tC24692CDD1DD8F1D5C646035A76D2830A70214E2_StaticFields
{
public:
// UnityEngine.Playables.Playable UnityEngine.Playables.Playable::m_NullPlayable
Playable_tC24692CDD1DD8F1D5C646035A76D2830A70214E2 ___m_NullPlayable_1;
public:
inline static int32_t get_offset_of_m_NullPlayable_1() { return static_cast<int32_t>(offsetof(Playable_tC24692CDD1DD8F1D5C646035A76D2830A70214E2_StaticFields, ___m_NullPlayable_1)); }
inline Playable_tC24692CDD1DD8F1D5C646035A76D2830A70214E2 get_m_NullPlayable_1() const { return ___m_NullPlayable_1; }
inline Playable_tC24692CDD1DD8F1D5C646035A76D2830A70214E2 * get_address_of_m_NullPlayable_1() { return &___m_NullPlayable_1; }
inline void set_m_NullPlayable_1(Playable_tC24692CDD1DD8F1D5C646035A76D2830A70214E2 value)
{
___m_NullPlayable_1 = value;
}
};
// UnityEngine.Playables.PlayableOutput
struct PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82
{
public:
// UnityEngine.Playables.PlayableOutputHandle UnityEngine.Playables.PlayableOutput::m_Handle
PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1 ___m_Handle_0;
public:
inline static int32_t get_offset_of_m_Handle_0() { return static_cast<int32_t>(offsetof(PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82, ___m_Handle_0)); }
inline PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1 get_m_Handle_0() const { return ___m_Handle_0; }
inline PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1 * get_address_of_m_Handle_0() { return &___m_Handle_0; }
inline void set_m_Handle_0(PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1 value)
{
___m_Handle_0 = value;
}
};
struct PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82_StaticFields
{
public:
// UnityEngine.Playables.PlayableOutput UnityEngine.Playables.PlayableOutput::m_NullPlayableOutput
PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82 ___m_NullPlayableOutput_1;
public:
inline static int32_t get_offset_of_m_NullPlayableOutput_1() { return static_cast<int32_t>(offsetof(PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82_StaticFields, ___m_NullPlayableOutput_1)); }
inline PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82 get_m_NullPlayableOutput_1() const { return ___m_NullPlayableOutput_1; }
inline PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82 * get_address_of_m_NullPlayableOutput_1() { return &___m_NullPlayableOutput_1; }
inline void set_m_NullPlayableOutput_1(PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82 value)
{
___m_NullPlayableOutput_1 = value;
}
};
// UnityEngine.XR.MagicLeap.ReferenceFrame
struct ReferenceFrame_tBC495D5CFA603EF6EF00A76250162F12F4293A9D
{
public:
// UnityEngine.Pose UnityEngine.XR.MagicLeap.ReferenceFrame::m_AnchorFromCoordinateFrame
Pose_t9F30358E65733E60A1DC8682FDB7104F40C9434A ___m_AnchorFromCoordinateFrame_0;
// UnityEngine.XR.ARSubsystems.TrackableId UnityEngine.XR.MagicLeap.ReferenceFrame::<trackableId>k__BackingField
TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B ___U3CtrackableIdU3Ek__BackingField_1;
// UnityEngine.Pose UnityEngine.XR.MagicLeap.ReferenceFrame::<coordinateFrame>k__BackingField
Pose_t9F30358E65733E60A1DC8682FDB7104F40C9434A ___U3CcoordinateFrameU3Ek__BackingField_2;
// UnityEngine.XR.MagicLeap.MLCoordinateFrameUID UnityEngine.XR.MagicLeap.ReferenceFrame::<cfuid>k__BackingField
MLCoordinateFrameUID_tA8D0393E638F9B4C5B7EBB2A1073BF5CB5FB71F5 ___U3CcfuidU3Ek__BackingField_3;
// UnityEngine.XR.ARSubsystems.TrackingState UnityEngine.XR.MagicLeap.ReferenceFrame::<trackingState>k__BackingField
int32_t ___U3CtrackingStateU3Ek__BackingField_4;
public:
inline static int32_t get_offset_of_m_AnchorFromCoordinateFrame_0() { return static_cast<int32_t>(offsetof(ReferenceFrame_tBC495D5CFA603EF6EF00A76250162F12F4293A9D, ___m_AnchorFromCoordinateFrame_0)); }
inline Pose_t9F30358E65733E60A1DC8682FDB7104F40C9434A get_m_AnchorFromCoordinateFrame_0() const { return ___m_AnchorFromCoordinateFrame_0; }
inline Pose_t9F30358E65733E60A1DC8682FDB7104F40C9434A * get_address_of_m_AnchorFromCoordinateFrame_0() { return &___m_AnchorFromCoordinateFrame_0; }
inline void set_m_AnchorFromCoordinateFrame_0(Pose_t9F30358E65733E60A1DC8682FDB7104F40C9434A value)
{
___m_AnchorFromCoordinateFrame_0 = value;
}
inline static int32_t get_offset_of_U3CtrackableIdU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(ReferenceFrame_tBC495D5CFA603EF6EF00A76250162F12F4293A9D, ___U3CtrackableIdU3Ek__BackingField_1)); }
inline TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B get_U3CtrackableIdU3Ek__BackingField_1() const { return ___U3CtrackableIdU3Ek__BackingField_1; }
inline TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B * get_address_of_U3CtrackableIdU3Ek__BackingField_1() { return &___U3CtrackableIdU3Ek__BackingField_1; }
inline void set_U3CtrackableIdU3Ek__BackingField_1(TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B value)
{
___U3CtrackableIdU3Ek__BackingField_1 = value;
}
inline static int32_t get_offset_of_U3CcoordinateFrameU3Ek__BackingField_2() { return static_cast<int32_t>(offsetof(ReferenceFrame_tBC495D5CFA603EF6EF00A76250162F12F4293A9D, ___U3CcoordinateFrameU3Ek__BackingField_2)); }
inline Pose_t9F30358E65733E60A1DC8682FDB7104F40C9434A get_U3CcoordinateFrameU3Ek__BackingField_2() const { return ___U3CcoordinateFrameU3Ek__BackingField_2; }
inline Pose_t9F30358E65733E60A1DC8682FDB7104F40C9434A * get_address_of_U3CcoordinateFrameU3Ek__BackingField_2() { return &___U3CcoordinateFrameU3Ek__BackingField_2; }
inline void set_U3CcoordinateFrameU3Ek__BackingField_2(Pose_t9F30358E65733E60A1DC8682FDB7104F40C9434A value)
{
___U3CcoordinateFrameU3Ek__BackingField_2 = value;
}
inline static int32_t get_offset_of_U3CcfuidU3Ek__BackingField_3() { return static_cast<int32_t>(offsetof(ReferenceFrame_tBC495D5CFA603EF6EF00A76250162F12F4293A9D, ___U3CcfuidU3Ek__BackingField_3)); }
inline MLCoordinateFrameUID_tA8D0393E638F9B4C5B7EBB2A1073BF5CB5FB71F5 get_U3CcfuidU3Ek__BackingField_3() const { return ___U3CcfuidU3Ek__BackingField_3; }
inline MLCoordinateFrameUID_tA8D0393E638F9B4C5B7EBB2A1073BF5CB5FB71F5 * get_address_of_U3CcfuidU3Ek__BackingField_3() { return &___U3CcfuidU3Ek__BackingField_3; }
inline void set_U3CcfuidU3Ek__BackingField_3(MLCoordinateFrameUID_tA8D0393E638F9B4C5B7EBB2A1073BF5CB5FB71F5 value)
{
___U3CcfuidU3Ek__BackingField_3 = value;
}
inline static int32_t get_offset_of_U3CtrackingStateU3Ek__BackingField_4() { return static_cast<int32_t>(offsetof(ReferenceFrame_tBC495D5CFA603EF6EF00A76250162F12F4293A9D, ___U3CtrackingStateU3Ek__BackingField_4)); }
inline int32_t get_U3CtrackingStateU3Ek__BackingField_4() const { return ___U3CtrackingStateU3Ek__BackingField_4; }
inline int32_t* get_address_of_U3CtrackingStateU3Ek__BackingField_4() { return &___U3CtrackingStateU3Ek__BackingField_4; }
inline void set_U3CtrackingStateU3Ek__BackingField_4(int32_t value)
{
___U3CtrackingStateU3Ek__BackingField_4 = value;
}
};
// Microsoft.MixedReality.Toolkit.SceneSystem.SceneInfo
struct SceneInfo_t12CFA6F7D90C190B2C869FD43C885339A250C3FD
{
public:
// System.String Microsoft.MixedReality.Toolkit.SceneSystem.SceneInfo::Name
String_t* ___Name_1;
// System.String Microsoft.MixedReality.Toolkit.SceneSystem.SceneInfo::Path
String_t* ___Path_2;
// System.Boolean Microsoft.MixedReality.Toolkit.SceneSystem.SceneInfo::Included
bool ___Included_3;
// System.Int32 Microsoft.MixedReality.Toolkit.SceneSystem.SceneInfo::BuildIndex
int32_t ___BuildIndex_4;
// System.String Microsoft.MixedReality.Toolkit.SceneSystem.SceneInfo::Tag
String_t* ___Tag_5;
// UnityEngine.Object Microsoft.MixedReality.Toolkit.SceneSystem.SceneInfo::Asset
Object_tF2F3778131EFF286AF62B7B013A170F95A91571A * ___Asset_6;
public:
inline static int32_t get_offset_of_Name_1() { return static_cast<int32_t>(offsetof(SceneInfo_t12CFA6F7D90C190B2C869FD43C885339A250C3FD, ___Name_1)); }
inline String_t* get_Name_1() const { return ___Name_1; }
inline String_t** get_address_of_Name_1() { return &___Name_1; }
inline void set_Name_1(String_t* value)
{
___Name_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Name_1), (void*)value);
}
inline static int32_t get_offset_of_Path_2() { return static_cast<int32_t>(offsetof(SceneInfo_t12CFA6F7D90C190B2C869FD43C885339A250C3FD, ___Path_2)); }
inline String_t* get_Path_2() const { return ___Path_2; }
inline String_t** get_address_of_Path_2() { return &___Path_2; }
inline void set_Path_2(String_t* value)
{
___Path_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Path_2), (void*)value);
}
inline static int32_t get_offset_of_Included_3() { return static_cast<int32_t>(offsetof(SceneInfo_t12CFA6F7D90C190B2C869FD43C885339A250C3FD, ___Included_3)); }
inline bool get_Included_3() const { return ___Included_3; }
inline bool* get_address_of_Included_3() { return &___Included_3; }
inline void set_Included_3(bool value)
{
___Included_3 = value;
}
inline static int32_t get_offset_of_BuildIndex_4() { return static_cast<int32_t>(offsetof(SceneInfo_t12CFA6F7D90C190B2C869FD43C885339A250C3FD, ___BuildIndex_4)); }
inline int32_t get_BuildIndex_4() const { return ___BuildIndex_4; }
inline int32_t* get_address_of_BuildIndex_4() { return &___BuildIndex_4; }
inline void set_BuildIndex_4(int32_t value)
{
___BuildIndex_4 = value;
}
inline static int32_t get_offset_of_Tag_5() { return static_cast<int32_t>(offsetof(SceneInfo_t12CFA6F7D90C190B2C869FD43C885339A250C3FD, ___Tag_5)); }
inline String_t* get_Tag_5() const { return ___Tag_5; }
inline String_t** get_address_of_Tag_5() { return &___Tag_5; }
inline void set_Tag_5(String_t* value)
{
___Tag_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Tag_5), (void*)value);
}
inline static int32_t get_offset_of_Asset_6() { return static_cast<int32_t>(offsetof(SceneInfo_t12CFA6F7D90C190B2C869FD43C885339A250C3FD, ___Asset_6)); }
inline Object_tF2F3778131EFF286AF62B7B013A170F95A91571A * get_Asset_6() const { return ___Asset_6; }
inline Object_tF2F3778131EFF286AF62B7B013A170F95A91571A ** get_address_of_Asset_6() { return &___Asset_6; }
inline void set_Asset_6(Object_tF2F3778131EFF286AF62B7B013A170F95A91571A * value)
{
___Asset_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Asset_6), (void*)value);
}
};
struct SceneInfo_t12CFA6F7D90C190B2C869FD43C885339A250C3FD_StaticFields
{
public:
// Microsoft.MixedReality.Toolkit.SceneSystem.SceneInfo Microsoft.MixedReality.Toolkit.SceneSystem.SceneInfo::empty
SceneInfo_t12CFA6F7D90C190B2C869FD43C885339A250C3FD ___empty_0;
public:
inline static int32_t get_offset_of_empty_0() { return static_cast<int32_t>(offsetof(SceneInfo_t12CFA6F7D90C190B2C869FD43C885339A250C3FD_StaticFields, ___empty_0)); }
inline SceneInfo_t12CFA6F7D90C190B2C869FD43C885339A250C3FD get_empty_0() const { return ___empty_0; }
inline SceneInfo_t12CFA6F7D90C190B2C869FD43C885339A250C3FD * get_address_of_empty_0() { return &___empty_0; }
inline void set_empty_0(SceneInfo_t12CFA6F7D90C190B2C869FD43C885339A250C3FD value)
{
___empty_0 = value;
Il2CppCodeGenWriteBarrier((void**)&(((&___empty_0))->___Name_1), (void*)NULL);
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&(((&___empty_0))->___Path_2), (void*)NULL);
#endif
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&(((&___empty_0))->___Tag_5), (void*)NULL);
#endif
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&(((&___empty_0))->___Asset_6), (void*)NULL);
#endif
}
};
// Native definition for P/Invoke marshalling of Microsoft.MixedReality.Toolkit.SceneSystem.SceneInfo
struct SceneInfo_t12CFA6F7D90C190B2C869FD43C885339A250C3FD_marshaled_pinvoke
{
char* ___Name_1;
char* ___Path_2;
int32_t ___Included_3;
int32_t ___BuildIndex_4;
char* ___Tag_5;
Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_marshaled_pinvoke ___Asset_6;
};
// Native definition for COM marshalling of Microsoft.MixedReality.Toolkit.SceneSystem.SceneInfo
struct SceneInfo_t12CFA6F7D90C190B2C869FD43C885339A250C3FD_marshaled_com
{
Il2CppChar* ___Name_1;
Il2CppChar* ___Path_2;
int32_t ___Included_3;
int32_t ___BuildIndex_4;
Il2CppChar* ___Tag_5;
Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_marshaled_com* ___Asset_6;
};
// UnityEngine.ScriptableObject
struct ScriptableObject_t4361E08CEBF052C650D3666C7CEC37EB31DE116A : public Object_tF2F3778131EFF286AF62B7B013A170F95A91571A
{
public:
public:
};
// Native definition for P/Invoke marshalling of UnityEngine.ScriptableObject
struct ScriptableObject_t4361E08CEBF052C650D3666C7CEC37EB31DE116A_marshaled_pinvoke : public Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_marshaled_pinvoke
{
};
// Native definition for COM marshalling of UnityEngine.ScriptableObject
struct ScriptableObject_t4361E08CEBF052C650D3666C7CEC37EB31DE116A_marshaled_com : public Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_marshaled_com
{
};
// Microsoft.MixedReality.Toolkit.UI.ShaderProperties
struct ShaderProperties_t780424B677AA69C9E9434368B245AF8CF867FD44
{
public:
// System.String Microsoft.MixedReality.Toolkit.UI.ShaderProperties::Name
String_t* ___Name_0;
// Microsoft.MixedReality.Toolkit.UI.ShaderPropertyType Microsoft.MixedReality.Toolkit.UI.ShaderProperties::Type
int32_t ___Type_1;
// UnityEngine.Vector2 Microsoft.MixedReality.Toolkit.UI.ShaderProperties::Range
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___Range_2;
public:
inline static int32_t get_offset_of_Name_0() { return static_cast<int32_t>(offsetof(ShaderProperties_t780424B677AA69C9E9434368B245AF8CF867FD44, ___Name_0)); }
inline String_t* get_Name_0() const { return ___Name_0; }
inline String_t** get_address_of_Name_0() { return &___Name_0; }
inline void set_Name_0(String_t* value)
{
___Name_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Name_0), (void*)value);
}
inline static int32_t get_offset_of_Type_1() { return static_cast<int32_t>(offsetof(ShaderProperties_t780424B677AA69C9E9434368B245AF8CF867FD44, ___Type_1)); }
inline int32_t get_Type_1() const { return ___Type_1; }
inline int32_t* get_address_of_Type_1() { return &___Type_1; }
inline void set_Type_1(int32_t value)
{
___Type_1 = value;
}
inline static int32_t get_offset_of_Range_2() { return static_cast<int32_t>(offsetof(ShaderProperties_t780424B677AA69C9E9434368B245AF8CF867FD44, ___Range_2)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_Range_2() const { return ___Range_2; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_Range_2() { return &___Range_2; }
inline void set_Range_2(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___Range_2 = value;
}
};
// Native definition for P/Invoke marshalling of Microsoft.MixedReality.Toolkit.UI.ShaderProperties
struct ShaderProperties_t780424B677AA69C9E9434368B245AF8CF867FD44_marshaled_pinvoke
{
char* ___Name_0;
int32_t ___Type_1;
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___Range_2;
};
// Native definition for COM marshalling of Microsoft.MixedReality.Toolkit.UI.ShaderProperties
struct ShaderProperties_t780424B677AA69C9E9434368B245AF8CF867FD44_marshaled_com
{
Il2CppChar* ___Name_0;
int32_t ___Type_1;
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___Range_2;
};
// System.Runtime.Serialization.StreamingContext
struct StreamingContext_t5888E7E8C81AB6EF3B14FDDA6674F458076A8505
{
public:
// System.Object System.Runtime.Serialization.StreamingContext::m_additionalContext
RuntimeObject * ___m_additionalContext_0;
// System.Runtime.Serialization.StreamingContextStates System.Runtime.Serialization.StreamingContext::m_state
int32_t ___m_state_1;
public:
inline static int32_t get_offset_of_m_additionalContext_0() { return static_cast<int32_t>(offsetof(StreamingContext_t5888E7E8C81AB6EF3B14FDDA6674F458076A8505, ___m_additionalContext_0)); }
inline RuntimeObject * get_m_additionalContext_0() const { return ___m_additionalContext_0; }
inline RuntimeObject ** get_address_of_m_additionalContext_0() { return &___m_additionalContext_0; }
inline void set_m_additionalContext_0(RuntimeObject * value)
{
___m_additionalContext_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_additionalContext_0), (void*)value);
}
inline static int32_t get_offset_of_m_state_1() { return static_cast<int32_t>(offsetof(StreamingContext_t5888E7E8C81AB6EF3B14FDDA6674F458076A8505, ___m_state_1)); }
inline int32_t get_m_state_1() const { return ___m_state_1; }
inline int32_t* get_address_of_m_state_1() { return &___m_state_1; }
inline void set_m_state_1(int32_t value)
{
___m_state_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Runtime.Serialization.StreamingContext
struct StreamingContext_t5888E7E8C81AB6EF3B14FDDA6674F458076A8505_marshaled_pinvoke
{
Il2CppIUnknown* ___m_additionalContext_0;
int32_t ___m_state_1;
};
// Native definition for COM marshalling of System.Runtime.Serialization.StreamingContext
struct StreamingContext_t5888E7E8C81AB6EF3B14FDDA6674F458076A8505_marshaled_com
{
Il2CppIUnknown* ___m_additionalContext_0;
int32_t ___m_state_1;
};
// UnityEngine.Touch
struct Touch_tDEFED247540BCFA4AD452F1D37EEF4E09B4ACD8C
{
public:
// System.Int32 UnityEngine.Touch::m_FingerId
int32_t ___m_FingerId_0;
// UnityEngine.Vector2 UnityEngine.Touch::m_Position
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___m_Position_1;
// UnityEngine.Vector2 UnityEngine.Touch::m_RawPosition
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___m_RawPosition_2;
// UnityEngine.Vector2 UnityEngine.Touch::m_PositionDelta
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___m_PositionDelta_3;
// System.Single UnityEngine.Touch::m_TimeDelta
float ___m_TimeDelta_4;
// System.Int32 UnityEngine.Touch::m_TapCount
int32_t ___m_TapCount_5;
// UnityEngine.TouchPhase UnityEngine.Touch::m_Phase
int32_t ___m_Phase_6;
// UnityEngine.TouchType UnityEngine.Touch::m_Type
int32_t ___m_Type_7;
// System.Single UnityEngine.Touch::m_Pressure
float ___m_Pressure_8;
// System.Single UnityEngine.Touch::m_maximumPossiblePressure
float ___m_maximumPossiblePressure_9;
// System.Single UnityEngine.Touch::m_Radius
float ___m_Radius_10;
// System.Single UnityEngine.Touch::m_RadiusVariance
float ___m_RadiusVariance_11;
// System.Single UnityEngine.Touch::m_AltitudeAngle
float ___m_AltitudeAngle_12;
// System.Single UnityEngine.Touch::m_AzimuthAngle
float ___m_AzimuthAngle_13;
public:
inline static int32_t get_offset_of_m_FingerId_0() { return static_cast<int32_t>(offsetof(Touch_tDEFED247540BCFA4AD452F1D37EEF4E09B4ACD8C, ___m_FingerId_0)); }
inline int32_t get_m_FingerId_0() const { return ___m_FingerId_0; }
inline int32_t* get_address_of_m_FingerId_0() { return &___m_FingerId_0; }
inline void set_m_FingerId_0(int32_t value)
{
___m_FingerId_0 = value;
}
inline static int32_t get_offset_of_m_Position_1() { return static_cast<int32_t>(offsetof(Touch_tDEFED247540BCFA4AD452F1D37EEF4E09B4ACD8C, ___m_Position_1)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_m_Position_1() const { return ___m_Position_1; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_m_Position_1() { return &___m_Position_1; }
inline void set_m_Position_1(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___m_Position_1 = value;
}
inline static int32_t get_offset_of_m_RawPosition_2() { return static_cast<int32_t>(offsetof(Touch_tDEFED247540BCFA4AD452F1D37EEF4E09B4ACD8C, ___m_RawPosition_2)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_m_RawPosition_2() const { return ___m_RawPosition_2; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_m_RawPosition_2() { return &___m_RawPosition_2; }
inline void set_m_RawPosition_2(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___m_RawPosition_2 = value;
}
inline static int32_t get_offset_of_m_PositionDelta_3() { return static_cast<int32_t>(offsetof(Touch_tDEFED247540BCFA4AD452F1D37EEF4E09B4ACD8C, ___m_PositionDelta_3)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_m_PositionDelta_3() const { return ___m_PositionDelta_3; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_m_PositionDelta_3() { return &___m_PositionDelta_3; }
inline void set_m_PositionDelta_3(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___m_PositionDelta_3 = value;
}
inline static int32_t get_offset_of_m_TimeDelta_4() { return static_cast<int32_t>(offsetof(Touch_tDEFED247540BCFA4AD452F1D37EEF4E09B4ACD8C, ___m_TimeDelta_4)); }
inline float get_m_TimeDelta_4() const { return ___m_TimeDelta_4; }
inline float* get_address_of_m_TimeDelta_4() { return &___m_TimeDelta_4; }
inline void set_m_TimeDelta_4(float value)
{
___m_TimeDelta_4 = value;
}
inline static int32_t get_offset_of_m_TapCount_5() { return static_cast<int32_t>(offsetof(Touch_tDEFED247540BCFA4AD452F1D37EEF4E09B4ACD8C, ___m_TapCount_5)); }
inline int32_t get_m_TapCount_5() const { return ___m_TapCount_5; }
inline int32_t* get_address_of_m_TapCount_5() { return &___m_TapCount_5; }
inline void set_m_TapCount_5(int32_t value)
{
___m_TapCount_5 = value;
}
inline static int32_t get_offset_of_m_Phase_6() { return static_cast<int32_t>(offsetof(Touch_tDEFED247540BCFA4AD452F1D37EEF4E09B4ACD8C, ___m_Phase_6)); }
inline int32_t get_m_Phase_6() const { return ___m_Phase_6; }
inline int32_t* get_address_of_m_Phase_6() { return &___m_Phase_6; }
inline void set_m_Phase_6(int32_t value)
{
___m_Phase_6 = value;
}
inline static int32_t get_offset_of_m_Type_7() { return static_cast<int32_t>(offsetof(Touch_tDEFED247540BCFA4AD452F1D37EEF4E09B4ACD8C, ___m_Type_7)); }
inline int32_t get_m_Type_7() const { return ___m_Type_7; }
inline int32_t* get_address_of_m_Type_7() { return &___m_Type_7; }
inline void set_m_Type_7(int32_t value)
{
___m_Type_7 = value;
}
inline static int32_t get_offset_of_m_Pressure_8() { return static_cast<int32_t>(offsetof(Touch_tDEFED247540BCFA4AD452F1D37EEF4E09B4ACD8C, ___m_Pressure_8)); }
inline float get_m_Pressure_8() const { return ___m_Pressure_8; }
inline float* get_address_of_m_Pressure_8() { return &___m_Pressure_8; }
inline void set_m_Pressure_8(float value)
{
___m_Pressure_8 = value;
}
inline static int32_t get_offset_of_m_maximumPossiblePressure_9() { return static_cast<int32_t>(offsetof(Touch_tDEFED247540BCFA4AD452F1D37EEF4E09B4ACD8C, ___m_maximumPossiblePressure_9)); }
inline float get_m_maximumPossiblePressure_9() const { return ___m_maximumPossiblePressure_9; }
inline float* get_address_of_m_maximumPossiblePressure_9() { return &___m_maximumPossiblePressure_9; }
inline void set_m_maximumPossiblePressure_9(float value)
{
___m_maximumPossiblePressure_9 = value;
}
inline static int32_t get_offset_of_m_Radius_10() { return static_cast<int32_t>(offsetof(Touch_tDEFED247540BCFA4AD452F1D37EEF4E09B4ACD8C, ___m_Radius_10)); }
inline float get_m_Radius_10() const { return ___m_Radius_10; }
inline float* get_address_of_m_Radius_10() { return &___m_Radius_10; }
inline void set_m_Radius_10(float value)
{
___m_Radius_10 = value;
}
inline static int32_t get_offset_of_m_RadiusVariance_11() { return static_cast<int32_t>(offsetof(Touch_tDEFED247540BCFA4AD452F1D37EEF4E09B4ACD8C, ___m_RadiusVariance_11)); }
inline float get_m_RadiusVariance_11() const { return ___m_RadiusVariance_11; }
inline float* get_address_of_m_RadiusVariance_11() { return &___m_RadiusVariance_11; }
inline void set_m_RadiusVariance_11(float value)
{
___m_RadiusVariance_11 = value;
}
inline static int32_t get_offset_of_m_AltitudeAngle_12() { return static_cast<int32_t>(offsetof(Touch_tDEFED247540BCFA4AD452F1D37EEF4E09B4ACD8C, ___m_AltitudeAngle_12)); }
inline float get_m_AltitudeAngle_12() const { return ___m_AltitudeAngle_12; }
inline float* get_address_of_m_AltitudeAngle_12() { return &___m_AltitudeAngle_12; }
inline void set_m_AltitudeAngle_12(float value)
{
___m_AltitudeAngle_12 = value;
}
inline static int32_t get_offset_of_m_AzimuthAngle_13() { return static_cast<int32_t>(offsetof(Touch_tDEFED247540BCFA4AD452F1D37EEF4E09B4ACD8C, ___m_AzimuthAngle_13)); }
inline float get_m_AzimuthAngle_13() const { return ___m_AzimuthAngle_13; }
inline float* get_address_of_m_AzimuthAngle_13() { return &___m_AzimuthAngle_13; }
inline void set_m_AzimuthAngle_13(float value)
{
___m_AzimuthAngle_13 = value;
}
};
// System.TypedReference
struct TypedReference_tE1755FC30D207D9552DE27539E907EE92C8C073A
{
public:
// System.RuntimeTypeHandle System.TypedReference::type
RuntimeTypeHandle_tC33965ADA3E041E0C94AF05E5CB527B56482CEF9 ___type_0;
// System.IntPtr System.TypedReference::Value
intptr_t ___Value_1;
// System.IntPtr System.TypedReference::Type
intptr_t ___Type_2;
public:
inline static int32_t get_offset_of_type_0() { return static_cast<int32_t>(offsetof(TypedReference_tE1755FC30D207D9552DE27539E907EE92C8C073A, ___type_0)); }
inline RuntimeTypeHandle_tC33965ADA3E041E0C94AF05E5CB527B56482CEF9 get_type_0() const { return ___type_0; }
inline RuntimeTypeHandle_tC33965ADA3E041E0C94AF05E5CB527B56482CEF9 * get_address_of_type_0() { return &___type_0; }
inline void set_type_0(RuntimeTypeHandle_tC33965ADA3E041E0C94AF05E5CB527B56482CEF9 value)
{
___type_0 = value;
}
inline static int32_t get_offset_of_Value_1() { return static_cast<int32_t>(offsetof(TypedReference_tE1755FC30D207D9552DE27539E907EE92C8C073A, ___Value_1)); }
inline intptr_t get_Value_1() const { return ___Value_1; }
inline intptr_t* get_address_of_Value_1() { return &___Value_1; }
inline void set_Value_1(intptr_t value)
{
___Value_1 = value;
}
inline static int32_t get_offset_of_Type_2() { return static_cast<int32_t>(offsetof(TypedReference_tE1755FC30D207D9552DE27539E907EE92C8C073A, ___Type_2)); }
inline intptr_t get_Type_2() const { return ___Type_2; }
inline intptr_t* get_address_of_Type_2() { return &___Type_2; }
inline void set_Type_2(intptr_t value)
{
___Type_2 = value;
}
};
// UnityEngine.XR.XRNodeState
struct XRNodeState_t6DC58D0C1BF2C4323D16B3905FDBEE7C03E27D33
{
public:
// UnityEngine.XR.XRNode UnityEngine.XR.XRNodeState::m_Type
int32_t ___m_Type_0;
// UnityEngine.XR.AvailableTrackingData UnityEngine.XR.XRNodeState::m_AvailableFields
int32_t ___m_AvailableFields_1;
// UnityEngine.Vector3 UnityEngine.XR.XRNodeState::m_Position
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Position_2;
// UnityEngine.Quaternion UnityEngine.XR.XRNodeState::m_Rotation
Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___m_Rotation_3;
// UnityEngine.Vector3 UnityEngine.XR.XRNodeState::m_Velocity
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Velocity_4;
// UnityEngine.Vector3 UnityEngine.XR.XRNodeState::m_AngularVelocity
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_AngularVelocity_5;
// UnityEngine.Vector3 UnityEngine.XR.XRNodeState::m_Acceleration
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Acceleration_6;
// UnityEngine.Vector3 UnityEngine.XR.XRNodeState::m_AngularAcceleration
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_AngularAcceleration_7;
// System.Int32 UnityEngine.XR.XRNodeState::m_Tracked
int32_t ___m_Tracked_8;
// System.UInt64 UnityEngine.XR.XRNodeState::m_UniqueID
uint64_t ___m_UniqueID_9;
public:
inline static int32_t get_offset_of_m_Type_0() { return static_cast<int32_t>(offsetof(XRNodeState_t6DC58D0C1BF2C4323D16B3905FDBEE7C03E27D33, ___m_Type_0)); }
inline int32_t get_m_Type_0() const { return ___m_Type_0; }
inline int32_t* get_address_of_m_Type_0() { return &___m_Type_0; }
inline void set_m_Type_0(int32_t value)
{
___m_Type_0 = value;
}
inline static int32_t get_offset_of_m_AvailableFields_1() { return static_cast<int32_t>(offsetof(XRNodeState_t6DC58D0C1BF2C4323D16B3905FDBEE7C03E27D33, ___m_AvailableFields_1)); }
inline int32_t get_m_AvailableFields_1() const { return ___m_AvailableFields_1; }
inline int32_t* get_address_of_m_AvailableFields_1() { return &___m_AvailableFields_1; }
inline void set_m_AvailableFields_1(int32_t value)
{
___m_AvailableFields_1 = value;
}
inline static int32_t get_offset_of_m_Position_2() { return static_cast<int32_t>(offsetof(XRNodeState_t6DC58D0C1BF2C4323D16B3905FDBEE7C03E27D33, ___m_Position_2)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_Position_2() const { return ___m_Position_2; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_Position_2() { return &___m_Position_2; }
inline void set_m_Position_2(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_Position_2 = value;
}
inline static int32_t get_offset_of_m_Rotation_3() { return static_cast<int32_t>(offsetof(XRNodeState_t6DC58D0C1BF2C4323D16B3905FDBEE7C03E27D33, ___m_Rotation_3)); }
inline Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 get_m_Rotation_3() const { return ___m_Rotation_3; }
inline Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 * get_address_of_m_Rotation_3() { return &___m_Rotation_3; }
inline void set_m_Rotation_3(Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 value)
{
___m_Rotation_3 = value;
}
inline static int32_t get_offset_of_m_Velocity_4() { return static_cast<int32_t>(offsetof(XRNodeState_t6DC58D0C1BF2C4323D16B3905FDBEE7C03E27D33, ___m_Velocity_4)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_Velocity_4() const { return ___m_Velocity_4; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_Velocity_4() { return &___m_Velocity_4; }
inline void set_m_Velocity_4(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_Velocity_4 = value;
}
inline static int32_t get_offset_of_m_AngularVelocity_5() { return static_cast<int32_t>(offsetof(XRNodeState_t6DC58D0C1BF2C4323D16B3905FDBEE7C03E27D33, ___m_AngularVelocity_5)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_AngularVelocity_5() const { return ___m_AngularVelocity_5; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_AngularVelocity_5() { return &___m_AngularVelocity_5; }
inline void set_m_AngularVelocity_5(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_AngularVelocity_5 = value;
}
inline static int32_t get_offset_of_m_Acceleration_6() { return static_cast<int32_t>(offsetof(XRNodeState_t6DC58D0C1BF2C4323D16B3905FDBEE7C03E27D33, ___m_Acceleration_6)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_Acceleration_6() const { return ___m_Acceleration_6; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_Acceleration_6() { return &___m_Acceleration_6; }
inline void set_m_Acceleration_6(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_Acceleration_6 = value;
}
inline static int32_t get_offset_of_m_AngularAcceleration_7() { return static_cast<int32_t>(offsetof(XRNodeState_t6DC58D0C1BF2C4323D16B3905FDBEE7C03E27D33, ___m_AngularAcceleration_7)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_AngularAcceleration_7() const { return ___m_AngularAcceleration_7; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_AngularAcceleration_7() { return &___m_AngularAcceleration_7; }
inline void set_m_AngularAcceleration_7(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_AngularAcceleration_7 = value;
}
inline static int32_t get_offset_of_m_Tracked_8() { return static_cast<int32_t>(offsetof(XRNodeState_t6DC58D0C1BF2C4323D16B3905FDBEE7C03E27D33, ___m_Tracked_8)); }
inline int32_t get_m_Tracked_8() const { return ___m_Tracked_8; }
inline int32_t* get_address_of_m_Tracked_8() { return &___m_Tracked_8; }
inline void set_m_Tracked_8(int32_t value)
{
___m_Tracked_8 = value;
}
inline static int32_t get_offset_of_m_UniqueID_9() { return static_cast<int32_t>(offsetof(XRNodeState_t6DC58D0C1BF2C4323D16B3905FDBEE7C03E27D33, ___m_UniqueID_9)); }
inline uint64_t get_m_UniqueID_9() const { return ___m_UniqueID_9; }
inline uint64_t* get_address_of_m_UniqueID_9() { return &___m_UniqueID_9; }
inline void set_m_UniqueID_9(uint64_t value)
{
___m_UniqueID_9 = value;
}
};
// UnityEngine.Camera/RenderRequest
struct RenderRequest_t7DEDFA6AAA1C8D381280183054C328F26BBCCE94
{
public:
// UnityEngine.Camera/RenderRequestMode UnityEngine.Camera/RenderRequest::m_CameraRenderMode
int32_t ___m_CameraRenderMode_0;
// UnityEngine.RenderTexture UnityEngine.Camera/RenderRequest::m_ResultRT
RenderTexture_t5FE7A5B47EF962A0E8D7BEBA05E9FC87D49A1849 * ___m_ResultRT_1;
// UnityEngine.Camera/RenderRequestOutputSpace UnityEngine.Camera/RenderRequest::m_OutputSpace
int32_t ___m_OutputSpace_2;
public:
inline static int32_t get_offset_of_m_CameraRenderMode_0() { return static_cast<int32_t>(offsetof(RenderRequest_t7DEDFA6AAA1C8D381280183054C328F26BBCCE94, ___m_CameraRenderMode_0)); }
inline int32_t get_m_CameraRenderMode_0() const { return ___m_CameraRenderMode_0; }
inline int32_t* get_address_of_m_CameraRenderMode_0() { return &___m_CameraRenderMode_0; }
inline void set_m_CameraRenderMode_0(int32_t value)
{
___m_CameraRenderMode_0 = value;
}
inline static int32_t get_offset_of_m_ResultRT_1() { return static_cast<int32_t>(offsetof(RenderRequest_t7DEDFA6AAA1C8D381280183054C328F26BBCCE94, ___m_ResultRT_1)); }
inline RenderTexture_t5FE7A5B47EF962A0E8D7BEBA05E9FC87D49A1849 * get_m_ResultRT_1() const { return ___m_ResultRT_1; }
inline RenderTexture_t5FE7A5B47EF962A0E8D7BEBA05E9FC87D49A1849 ** get_address_of_m_ResultRT_1() { return &___m_ResultRT_1; }
inline void set_m_ResultRT_1(RenderTexture_t5FE7A5B47EF962A0E8D7BEBA05E9FC87D49A1849 * value)
{
___m_ResultRT_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_ResultRT_1), (void*)value);
}
inline static int32_t get_offset_of_m_OutputSpace_2() { return static_cast<int32_t>(offsetof(RenderRequest_t7DEDFA6AAA1C8D381280183054C328F26BBCCE94, ___m_OutputSpace_2)); }
inline int32_t get_m_OutputSpace_2() const { return ___m_OutputSpace_2; }
inline int32_t* get_address_of_m_OutputSpace_2() { return &___m_OutputSpace_2; }
inline void set_m_OutputSpace_2(int32_t value)
{
___m_OutputSpace_2 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.Camera/RenderRequest
struct RenderRequest_t7DEDFA6AAA1C8D381280183054C328F26BBCCE94_marshaled_pinvoke
{
int32_t ___m_CameraRenderMode_0;
RenderTexture_t5FE7A5B47EF962A0E8D7BEBA05E9FC87D49A1849 * ___m_ResultRT_1;
int32_t ___m_OutputSpace_2;
};
// Native definition for COM marshalling of UnityEngine.Camera/RenderRequest
struct RenderRequest_t7DEDFA6AAA1C8D381280183054C328F26BBCCE94_marshaled_com
{
int32_t ___m_CameraRenderMode_0;
RenderTexture_t5FE7A5B47EF962A0E8D7BEBA05E9FC87D49A1849 * ___m_ResultRT_1;
int32_t ___m_OutputSpace_2;
};
// UnityEngine.XR.MagicLeap.MLAppConnect/PipeEventInfo
struct PipeEventInfo_t8F415117730C2C258B5D9EBB95BEC982DFDB6FE5
{
public:
// System.UInt32 UnityEngine.XR.MagicLeap.MLAppConnect/PipeEventInfo::Version
uint32_t ___Version_0;
// System.String UnityEngine.XR.MagicLeap.MLAppConnect/PipeEventInfo::PipeName
String_t* ___PipeName_1;
// System.String UnityEngine.XR.MagicLeap.MLAppConnect/PipeEventInfo::PipeOwner
String_t* ___PipeOwner_2;
// UnityEngine.XR.MagicLeap.MLAppConnect/PipeType UnityEngine.XR.MagicLeap.MLAppConnect/PipeEventInfo::PipeType
int32_t ___PipeType_3;
// UnityEngine.XR.MagicLeap.MLAppConnect/PipeDirection UnityEngine.XR.MagicLeap.MLAppConnect/PipeEventInfo::PipeDirection
int32_t ___PipeDirection_4;
// System.String UnityEngine.XR.MagicLeap.MLAppConnect/PipeEventInfo::Status
String_t* ___Status_5;
public:
inline static int32_t get_offset_of_Version_0() { return static_cast<int32_t>(offsetof(PipeEventInfo_t8F415117730C2C258B5D9EBB95BEC982DFDB6FE5, ___Version_0)); }
inline uint32_t get_Version_0() const { return ___Version_0; }
inline uint32_t* get_address_of_Version_0() { return &___Version_0; }
inline void set_Version_0(uint32_t value)
{
___Version_0 = value;
}
inline static int32_t get_offset_of_PipeName_1() { return static_cast<int32_t>(offsetof(PipeEventInfo_t8F415117730C2C258B5D9EBB95BEC982DFDB6FE5, ___PipeName_1)); }
inline String_t* get_PipeName_1() const { return ___PipeName_1; }
inline String_t** get_address_of_PipeName_1() { return &___PipeName_1; }
inline void set_PipeName_1(String_t* value)
{
___PipeName_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___PipeName_1), (void*)value);
}
inline static int32_t get_offset_of_PipeOwner_2() { return static_cast<int32_t>(offsetof(PipeEventInfo_t8F415117730C2C258B5D9EBB95BEC982DFDB6FE5, ___PipeOwner_2)); }
inline String_t* get_PipeOwner_2() const { return ___PipeOwner_2; }
inline String_t** get_address_of_PipeOwner_2() { return &___PipeOwner_2; }
inline void set_PipeOwner_2(String_t* value)
{
___PipeOwner_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___PipeOwner_2), (void*)value);
}
inline static int32_t get_offset_of_PipeType_3() { return static_cast<int32_t>(offsetof(PipeEventInfo_t8F415117730C2C258B5D9EBB95BEC982DFDB6FE5, ___PipeType_3)); }
inline int32_t get_PipeType_3() const { return ___PipeType_3; }
inline int32_t* get_address_of_PipeType_3() { return &___PipeType_3; }
inline void set_PipeType_3(int32_t value)
{
___PipeType_3 = value;
}
inline static int32_t get_offset_of_PipeDirection_4() { return static_cast<int32_t>(offsetof(PipeEventInfo_t8F415117730C2C258B5D9EBB95BEC982DFDB6FE5, ___PipeDirection_4)); }
inline int32_t get_PipeDirection_4() const { return ___PipeDirection_4; }
inline int32_t* get_address_of_PipeDirection_4() { return &___PipeDirection_4; }
inline void set_PipeDirection_4(int32_t value)
{
___PipeDirection_4 = value;
}
inline static int32_t get_offset_of_Status_5() { return static_cast<int32_t>(offsetof(PipeEventInfo_t8F415117730C2C258B5D9EBB95BEC982DFDB6FE5, ___Status_5)); }
inline String_t* get_Status_5() const { return ___Status_5; }
inline String_t** get_address_of_Status_5() { return &___Status_5; }
inline void set_Status_5(String_t* value)
{
___Status_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Status_5), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MagicLeap.MLAppConnect/PipeEventInfo
struct PipeEventInfo_t8F415117730C2C258B5D9EBB95BEC982DFDB6FE5_marshaled_pinvoke
{
uint32_t ___Version_0;
char* ___PipeName_1;
char* ___PipeOwner_2;
int32_t ___PipeType_3;
int32_t ___PipeDirection_4;
char* ___Status_5;
};
// Native definition for COM marshalling of UnityEngine.XR.MagicLeap.MLAppConnect/PipeEventInfo
struct PipeEventInfo_t8F415117730C2C258B5D9EBB95BEC982DFDB6FE5_marshaled_com
{
uint32_t ___Version_0;
char* ___PipeName_1;
char* ___PipeOwner_2;
int32_t ___PipeType_3;
int32_t ___PipeDirection_4;
char* ___Status_5;
};
// UnityEngine.XR.MagicLeap.MLAudio/BufferFormat
struct BufferFormat_tE20F9A2217FC0F4787B114A37F0C6503F916FAE9
{
public:
// System.UInt32 UnityEngine.XR.MagicLeap.MLAudio/BufferFormat::<ChannelCount>k__BackingField
uint32_t ___U3CChannelCountU3Ek__BackingField_0;
// System.UInt32 UnityEngine.XR.MagicLeap.MLAudio/BufferFormat::<SamplesPerSecond>k__BackingField
uint32_t ___U3CSamplesPerSecondU3Ek__BackingField_1;
// System.UInt32 UnityEngine.XR.MagicLeap.MLAudio/BufferFormat::<BitsPerSample>k__BackingField
uint32_t ___U3CBitsPerSampleU3Ek__BackingField_2;
// System.UInt32 UnityEngine.XR.MagicLeap.MLAudio/BufferFormat::<ValidBitsPerSample>k__BackingField
uint32_t ___U3CValidBitsPerSampleU3Ek__BackingField_3;
// UnityEngine.XR.MagicLeap.MLAudio/SampleFormatType UnityEngine.XR.MagicLeap.MLAudio/BufferFormat::<SampleFormat>k__BackingField
uint32_t ___U3CSampleFormatU3Ek__BackingField_4;
public:
inline static int32_t get_offset_of_U3CChannelCountU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(BufferFormat_tE20F9A2217FC0F4787B114A37F0C6503F916FAE9, ___U3CChannelCountU3Ek__BackingField_0)); }
inline uint32_t get_U3CChannelCountU3Ek__BackingField_0() const { return ___U3CChannelCountU3Ek__BackingField_0; }
inline uint32_t* get_address_of_U3CChannelCountU3Ek__BackingField_0() { return &___U3CChannelCountU3Ek__BackingField_0; }
inline void set_U3CChannelCountU3Ek__BackingField_0(uint32_t value)
{
___U3CChannelCountU3Ek__BackingField_0 = value;
}
inline static int32_t get_offset_of_U3CSamplesPerSecondU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(BufferFormat_tE20F9A2217FC0F4787B114A37F0C6503F916FAE9, ___U3CSamplesPerSecondU3Ek__BackingField_1)); }
inline uint32_t get_U3CSamplesPerSecondU3Ek__BackingField_1() const { return ___U3CSamplesPerSecondU3Ek__BackingField_1; }
inline uint32_t* get_address_of_U3CSamplesPerSecondU3Ek__BackingField_1() { return &___U3CSamplesPerSecondU3Ek__BackingField_1; }
inline void set_U3CSamplesPerSecondU3Ek__BackingField_1(uint32_t value)
{
___U3CSamplesPerSecondU3Ek__BackingField_1 = value;
}
inline static int32_t get_offset_of_U3CBitsPerSampleU3Ek__BackingField_2() { return static_cast<int32_t>(offsetof(BufferFormat_tE20F9A2217FC0F4787B114A37F0C6503F916FAE9, ___U3CBitsPerSampleU3Ek__BackingField_2)); }
inline uint32_t get_U3CBitsPerSampleU3Ek__BackingField_2() const { return ___U3CBitsPerSampleU3Ek__BackingField_2; }
inline uint32_t* get_address_of_U3CBitsPerSampleU3Ek__BackingField_2() { return &___U3CBitsPerSampleU3Ek__BackingField_2; }
inline void set_U3CBitsPerSampleU3Ek__BackingField_2(uint32_t value)
{
___U3CBitsPerSampleU3Ek__BackingField_2 = value;
}
inline static int32_t get_offset_of_U3CValidBitsPerSampleU3Ek__BackingField_3() { return static_cast<int32_t>(offsetof(BufferFormat_tE20F9A2217FC0F4787B114A37F0C6503F916FAE9, ___U3CValidBitsPerSampleU3Ek__BackingField_3)); }
inline uint32_t get_U3CValidBitsPerSampleU3Ek__BackingField_3() const { return ___U3CValidBitsPerSampleU3Ek__BackingField_3; }
inline uint32_t* get_address_of_U3CValidBitsPerSampleU3Ek__BackingField_3() { return &___U3CValidBitsPerSampleU3Ek__BackingField_3; }
inline void set_U3CValidBitsPerSampleU3Ek__BackingField_3(uint32_t value)
{
___U3CValidBitsPerSampleU3Ek__BackingField_3 = value;
}
inline static int32_t get_offset_of_U3CSampleFormatU3Ek__BackingField_4() { return static_cast<int32_t>(offsetof(BufferFormat_tE20F9A2217FC0F4787B114A37F0C6503F916FAE9, ___U3CSampleFormatU3Ek__BackingField_4)); }
inline uint32_t get_U3CSampleFormatU3Ek__BackingField_4() const { return ___U3CSampleFormatU3Ek__BackingField_4; }
inline uint32_t* get_address_of_U3CSampleFormatU3Ek__BackingField_4() { return &___U3CSampleFormatU3Ek__BackingField_4; }
inline void set_U3CSampleFormatU3Ek__BackingField_4(uint32_t value)
{
___U3CSampleFormatU3Ek__BackingField_4 = value;
}
};
// UnityEngine.XR.MagicLeap.MLBluetoothLE/Characteristic
struct Characteristic_t4A3FC54AFB0C50F0303208C7E2A6A4453D2B9944
{
public:
// System.String UnityEngine.XR.MagicLeap.MLBluetoothLE/Characteristic::Uuid
String_t* ___Uuid_0;
// System.Int32 UnityEngine.XR.MagicLeap.MLBluetoothLE/Characteristic::InstanceId
int32_t ___InstanceId_1;
// UnityEngine.XR.MagicLeap.MLBluetoothLE/AttributePermissions UnityEngine.XR.MagicLeap.MLBluetoothLE/Characteristic::Permissions
int32_t ___Permissions_2;
// UnityEngine.XR.MagicLeap.MLBluetoothLE/CharacteristicProperties UnityEngine.XR.MagicLeap.MLBluetoothLE/Characteristic::Properties
int32_t ___Properties_3;
// UnityEngine.XR.MagicLeap.MLBluetoothLE/WriteType UnityEngine.XR.MagicLeap.MLBluetoothLE/Characteristic::WriteType
int32_t ___WriteType_4;
// System.Byte[] UnityEngine.XR.MagicLeap.MLBluetoothLE/Characteristic::Buffer
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* ___Buffer_5;
// UnityEngine.XR.MagicLeap.MLBluetoothLE/Descriptor[] UnityEngine.XR.MagicLeap.MLBluetoothLE/Characteristic::Descriptors
DescriptorU5BU5D_tD7F5ECF9C146C84AF8669CB04F50DAFB8BE8E5F8* ___Descriptors_6;
public:
inline static int32_t get_offset_of_Uuid_0() { return static_cast<int32_t>(offsetof(Characteristic_t4A3FC54AFB0C50F0303208C7E2A6A4453D2B9944, ___Uuid_0)); }
inline String_t* get_Uuid_0() const { return ___Uuid_0; }
inline String_t** get_address_of_Uuid_0() { return &___Uuid_0; }
inline void set_Uuid_0(String_t* value)
{
___Uuid_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Uuid_0), (void*)value);
}
inline static int32_t get_offset_of_InstanceId_1() { return static_cast<int32_t>(offsetof(Characteristic_t4A3FC54AFB0C50F0303208C7E2A6A4453D2B9944, ___InstanceId_1)); }
inline int32_t get_InstanceId_1() const { return ___InstanceId_1; }
inline int32_t* get_address_of_InstanceId_1() { return &___InstanceId_1; }
inline void set_InstanceId_1(int32_t value)
{
___InstanceId_1 = value;
}
inline static int32_t get_offset_of_Permissions_2() { return static_cast<int32_t>(offsetof(Characteristic_t4A3FC54AFB0C50F0303208C7E2A6A4453D2B9944, ___Permissions_2)); }
inline int32_t get_Permissions_2() const { return ___Permissions_2; }
inline int32_t* get_address_of_Permissions_2() { return &___Permissions_2; }
inline void set_Permissions_2(int32_t value)
{
___Permissions_2 = value;
}
inline static int32_t get_offset_of_Properties_3() { return static_cast<int32_t>(offsetof(Characteristic_t4A3FC54AFB0C50F0303208C7E2A6A4453D2B9944, ___Properties_3)); }
inline int32_t get_Properties_3() const { return ___Properties_3; }
inline int32_t* get_address_of_Properties_3() { return &___Properties_3; }
inline void set_Properties_3(int32_t value)
{
___Properties_3 = value;
}
inline static int32_t get_offset_of_WriteType_4() { return static_cast<int32_t>(offsetof(Characteristic_t4A3FC54AFB0C50F0303208C7E2A6A4453D2B9944, ___WriteType_4)); }
inline int32_t get_WriteType_4() const { return ___WriteType_4; }
inline int32_t* get_address_of_WriteType_4() { return &___WriteType_4; }
inline void set_WriteType_4(int32_t value)
{
___WriteType_4 = value;
}
inline static int32_t get_offset_of_Buffer_5() { return static_cast<int32_t>(offsetof(Characteristic_t4A3FC54AFB0C50F0303208C7E2A6A4453D2B9944, ___Buffer_5)); }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* get_Buffer_5() const { return ___Buffer_5; }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726** get_address_of_Buffer_5() { return &___Buffer_5; }
inline void set_Buffer_5(ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* value)
{
___Buffer_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Buffer_5), (void*)value);
}
inline static int32_t get_offset_of_Descriptors_6() { return static_cast<int32_t>(offsetof(Characteristic_t4A3FC54AFB0C50F0303208C7E2A6A4453D2B9944, ___Descriptors_6)); }
inline DescriptorU5BU5D_tD7F5ECF9C146C84AF8669CB04F50DAFB8BE8E5F8* get_Descriptors_6() const { return ___Descriptors_6; }
inline DescriptorU5BU5D_tD7F5ECF9C146C84AF8669CB04F50DAFB8BE8E5F8** get_address_of_Descriptors_6() { return &___Descriptors_6; }
inline void set_Descriptors_6(DescriptorU5BU5D_tD7F5ECF9C146C84AF8669CB04F50DAFB8BE8E5F8* value)
{
___Descriptors_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Descriptors_6), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MagicLeap.MLBluetoothLE/Characteristic
struct Characteristic_t4A3FC54AFB0C50F0303208C7E2A6A4453D2B9944_marshaled_pinvoke
{
char* ___Uuid_0;
int32_t ___InstanceId_1;
int32_t ___Permissions_2;
int32_t ___Properties_3;
int32_t ___WriteType_4;
Il2CppSafeArray/*NONE*/* ___Buffer_5;
Descriptor_t369955C9D183FE09E69BB860543789ACE71BFBF3_marshaled_pinvoke* ___Descriptors_6;
};
// Native definition for COM marshalling of UnityEngine.XR.MagicLeap.MLBluetoothLE/Characteristic
struct Characteristic_t4A3FC54AFB0C50F0303208C7E2A6A4453D2B9944_marshaled_com
{
Il2CppChar* ___Uuid_0;
int32_t ___InstanceId_1;
int32_t ___Permissions_2;
int32_t ___Properties_3;
int32_t ___WriteType_4;
Il2CppSafeArray/*NONE*/* ___Buffer_5;
Descriptor_t369955C9D183FE09E69BB860543789ACE71BFBF3_marshaled_com* ___Descriptors_6;
};
// UnityEngine.XR.MagicLeap.MLBluetoothLE/Descriptor
struct Descriptor_t369955C9D183FE09E69BB860543789ACE71BFBF3
{
public:
// System.String UnityEngine.XR.MagicLeap.MLBluetoothLE/Descriptor::Uuid
String_t* ___Uuid_0;
// System.Int32 UnityEngine.XR.MagicLeap.MLBluetoothLE/Descriptor::InstanceId
int32_t ___InstanceId_1;
// UnityEngine.XR.MagicLeap.MLBluetoothLE/AttributePermissions UnityEngine.XR.MagicLeap.MLBluetoothLE/Descriptor::Permissions
int32_t ___Permissions_2;
// System.Byte[] UnityEngine.XR.MagicLeap.MLBluetoothLE/Descriptor::Buffer
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* ___Buffer_3;
public:
inline static int32_t get_offset_of_Uuid_0() { return static_cast<int32_t>(offsetof(Descriptor_t369955C9D183FE09E69BB860543789ACE71BFBF3, ___Uuid_0)); }
inline String_t* get_Uuid_0() const { return ___Uuid_0; }
inline String_t** get_address_of_Uuid_0() { return &___Uuid_0; }
inline void set_Uuid_0(String_t* value)
{
___Uuid_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Uuid_0), (void*)value);
}
inline static int32_t get_offset_of_InstanceId_1() { return static_cast<int32_t>(offsetof(Descriptor_t369955C9D183FE09E69BB860543789ACE71BFBF3, ___InstanceId_1)); }
inline int32_t get_InstanceId_1() const { return ___InstanceId_1; }
inline int32_t* get_address_of_InstanceId_1() { return &___InstanceId_1; }
inline void set_InstanceId_1(int32_t value)
{
___InstanceId_1 = value;
}
inline static int32_t get_offset_of_Permissions_2() { return static_cast<int32_t>(offsetof(Descriptor_t369955C9D183FE09E69BB860543789ACE71BFBF3, ___Permissions_2)); }
inline int32_t get_Permissions_2() const { return ___Permissions_2; }
inline int32_t* get_address_of_Permissions_2() { return &___Permissions_2; }
inline void set_Permissions_2(int32_t value)
{
___Permissions_2 = value;
}
inline static int32_t get_offset_of_Buffer_3() { return static_cast<int32_t>(offsetof(Descriptor_t369955C9D183FE09E69BB860543789ACE71BFBF3, ___Buffer_3)); }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* get_Buffer_3() const { return ___Buffer_3; }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726** get_address_of_Buffer_3() { return &___Buffer_3; }
inline void set_Buffer_3(ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* value)
{
___Buffer_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Buffer_3), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MagicLeap.MLBluetoothLE/Descriptor
struct Descriptor_t369955C9D183FE09E69BB860543789ACE71BFBF3_marshaled_pinvoke
{
char* ___Uuid_0;
int32_t ___InstanceId_1;
int32_t ___Permissions_2;
Il2CppSafeArray/*NONE*/* ___Buffer_3;
};
// Native definition for COM marshalling of UnityEngine.XR.MagicLeap.MLBluetoothLE/Descriptor
struct Descriptor_t369955C9D183FE09E69BB860543789ACE71BFBF3_marshaled_com
{
Il2CppChar* ___Uuid_0;
int32_t ___InstanceId_1;
int32_t ___Permissions_2;
Il2CppSafeArray/*NONE*/* ___Buffer_3;
};
// UnityEngine.XR.MagicLeap.MLBluetoothLE/Device
struct Device_t8D9EA5FF748FD67329425ACE40F7EA51FAB2F7FC
{
public:
// System.String UnityEngine.XR.MagicLeap.MLBluetoothLE/Device::Address
String_t* ___Address_0;
// System.String UnityEngine.XR.MagicLeap.MLBluetoothLE/Device::Name
String_t* ___Name_1;
// System.Byte UnityEngine.XR.MagicLeap.MLBluetoothLE/Device::Rssi
uint8_t ___Rssi_2;
// UnityEngine.XR.MagicLeap.MLBluetoothLE/DeviceType UnityEngine.XR.MagicLeap.MLBluetoothLE/Device::DeviceType
uint32_t ___DeviceType_3;
public:
inline static int32_t get_offset_of_Address_0() { return static_cast<int32_t>(offsetof(Device_t8D9EA5FF748FD67329425ACE40F7EA51FAB2F7FC, ___Address_0)); }
inline String_t* get_Address_0() const { return ___Address_0; }
inline String_t** get_address_of_Address_0() { return &___Address_0; }
inline void set_Address_0(String_t* value)
{
___Address_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Address_0), (void*)value);
}
inline static int32_t get_offset_of_Name_1() { return static_cast<int32_t>(offsetof(Device_t8D9EA5FF748FD67329425ACE40F7EA51FAB2F7FC, ___Name_1)); }
inline String_t* get_Name_1() const { return ___Name_1; }
inline String_t** get_address_of_Name_1() { return &___Name_1; }
inline void set_Name_1(String_t* value)
{
___Name_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Name_1), (void*)value);
}
inline static int32_t get_offset_of_Rssi_2() { return static_cast<int32_t>(offsetof(Device_t8D9EA5FF748FD67329425ACE40F7EA51FAB2F7FC, ___Rssi_2)); }
inline uint8_t get_Rssi_2() const { return ___Rssi_2; }
inline uint8_t* get_address_of_Rssi_2() { return &___Rssi_2; }
inline void set_Rssi_2(uint8_t value)
{
___Rssi_2 = value;
}
inline static int32_t get_offset_of_DeviceType_3() { return static_cast<int32_t>(offsetof(Device_t8D9EA5FF748FD67329425ACE40F7EA51FAB2F7FC, ___DeviceType_3)); }
inline uint32_t get_DeviceType_3() const { return ___DeviceType_3; }
inline uint32_t* get_address_of_DeviceType_3() { return &___DeviceType_3; }
inline void set_DeviceType_3(uint32_t value)
{
___DeviceType_3 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MagicLeap.MLBluetoothLE/Device
struct Device_t8D9EA5FF748FD67329425ACE40F7EA51FAB2F7FC_marshaled_pinvoke
{
char* ___Address_0;
char* ___Name_1;
uint8_t ___Rssi_2;
uint32_t ___DeviceType_3;
};
// Native definition for COM marshalling of UnityEngine.XR.MagicLeap.MLBluetoothLE/Device
struct Device_t8D9EA5FF748FD67329425ACE40F7EA51FAB2F7FC_marshaled_com
{
Il2CppChar* ___Address_0;
Il2CppChar* ___Name_1;
uint8_t ___Rssi_2;
uint32_t ___DeviceType_3;
};
// UnityEngine.XR.MagicLeap.MLConnections/InvitationResult
struct InvitationResult_tB8CDBC566B12CF9FB043FB42722767032338E7C1
{
public:
// UnityEngine.XR.MagicLeap.MLConnections/InviteStatus UnityEngine.XR.MagicLeap.MLConnections/InvitationResult::InvitationStatus
uint32_t ___InvitationStatus_0;
// System.String UnityEngine.XR.MagicLeap.MLConnections/InvitationResult::JoinCode
String_t* ___JoinCode_1;
public:
inline static int32_t get_offset_of_InvitationStatus_0() { return static_cast<int32_t>(offsetof(InvitationResult_tB8CDBC566B12CF9FB043FB42722767032338E7C1, ___InvitationStatus_0)); }
inline uint32_t get_InvitationStatus_0() const { return ___InvitationStatus_0; }
inline uint32_t* get_address_of_InvitationStatus_0() { return &___InvitationStatus_0; }
inline void set_InvitationStatus_0(uint32_t value)
{
___InvitationStatus_0 = value;
}
inline static int32_t get_offset_of_JoinCode_1() { return static_cast<int32_t>(offsetof(InvitationResult_tB8CDBC566B12CF9FB043FB42722767032338E7C1, ___JoinCode_1)); }
inline String_t* get_JoinCode_1() const { return ___JoinCode_1; }
inline String_t** get_address_of_JoinCode_1() { return &___JoinCode_1; }
inline void set_JoinCode_1(String_t* value)
{
___JoinCode_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___JoinCode_1), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MagicLeap.MLConnections/InvitationResult
struct InvitationResult_tB8CDBC566B12CF9FB043FB42722767032338E7C1_marshaled_pinvoke
{
uint32_t ___InvitationStatus_0;
char* ___JoinCode_1;
};
// Native definition for COM marshalling of UnityEngine.XR.MagicLeap.MLConnections/InvitationResult
struct InvitationResult_tB8CDBC566B12CF9FB043FB42722767032338E7C1_marshaled_com
{
uint32_t ___InvitationStatus_0;
Il2CppChar* ___JoinCode_1;
};
// UnityEngine.XR.MagicLeap.MLConnections/InviteeStatus
struct InviteeStatus_tE06F11EB1070D277A0B594E817717DF224E2854B
{
public:
// System.String UnityEngine.XR.MagicLeap.MLConnections/InviteeStatus::Id
String_t* ___Id_0;
// System.String UnityEngine.XR.MagicLeap.MLConnections/InviteeStatus::Username
String_t* ___Username_1;
// System.String UnityEngine.XR.MagicLeap.MLConnections/InviteeStatus::AvatarPersonalization
String_t* ___AvatarPersonalization_2;
// UnityEngine.XR.MagicLeap.MLConnections/InvitationDeliveryStatus UnityEngine.XR.MagicLeap.MLConnections/InviteeStatus::InvitationDeliveryStatus
uint32_t ___InvitationDeliveryStatus_3;
public:
inline static int32_t get_offset_of_Id_0() { return static_cast<int32_t>(offsetof(InviteeStatus_tE06F11EB1070D277A0B594E817717DF224E2854B, ___Id_0)); }
inline String_t* get_Id_0() const { return ___Id_0; }
inline String_t** get_address_of_Id_0() { return &___Id_0; }
inline void set_Id_0(String_t* value)
{
___Id_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Id_0), (void*)value);
}
inline static int32_t get_offset_of_Username_1() { return static_cast<int32_t>(offsetof(InviteeStatus_tE06F11EB1070D277A0B594E817717DF224E2854B, ___Username_1)); }
inline String_t* get_Username_1() const { return ___Username_1; }
inline String_t** get_address_of_Username_1() { return &___Username_1; }
inline void set_Username_1(String_t* value)
{
___Username_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Username_1), (void*)value);
}
inline static int32_t get_offset_of_AvatarPersonalization_2() { return static_cast<int32_t>(offsetof(InviteeStatus_tE06F11EB1070D277A0B594E817717DF224E2854B, ___AvatarPersonalization_2)); }
inline String_t* get_AvatarPersonalization_2() const { return ___AvatarPersonalization_2; }
inline String_t** get_address_of_AvatarPersonalization_2() { return &___AvatarPersonalization_2; }
inline void set_AvatarPersonalization_2(String_t* value)
{
___AvatarPersonalization_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___AvatarPersonalization_2), (void*)value);
}
inline static int32_t get_offset_of_InvitationDeliveryStatus_3() { return static_cast<int32_t>(offsetof(InviteeStatus_tE06F11EB1070D277A0B594E817717DF224E2854B, ___InvitationDeliveryStatus_3)); }
inline uint32_t get_InvitationDeliveryStatus_3() const { return ___InvitationDeliveryStatus_3; }
inline uint32_t* get_address_of_InvitationDeliveryStatus_3() { return &___InvitationDeliveryStatus_3; }
inline void set_InvitationDeliveryStatus_3(uint32_t value)
{
___InvitationDeliveryStatus_3 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MagicLeap.MLConnections/InviteeStatus
struct InviteeStatus_tE06F11EB1070D277A0B594E817717DF224E2854B_marshaled_pinvoke
{
char* ___Id_0;
char* ___Username_1;
char* ___AvatarPersonalization_2;
uint32_t ___InvitationDeliveryStatus_3;
};
// Native definition for COM marshalling of UnityEngine.XR.MagicLeap.MLConnections/InviteeStatus
struct InviteeStatus_tE06F11EB1070D277A0B594E817717DF224E2854B_marshaled_com
{
Il2CppChar* ___Id_0;
Il2CppChar* ___Username_1;
Il2CppChar* ___AvatarPersonalization_2;
uint32_t ___InvitationDeliveryStatus_3;
};
// UnityEngine.XR.MagicLeap.MLContacts/OperationResult
struct OperationResult_t04D393B6206909328F53832764C577C5A9284748
{
public:
// UnityEngine.XR.MagicLeap.MLContacts/OperationStatus UnityEngine.XR.MagicLeap.MLContacts/OperationResult::Status
int32_t ___Status_0;
// UnityEngine.XR.MagicLeap.MLContacts/Contact UnityEngine.XR.MagicLeap.MLContacts/OperationResult::Contact
Contact_t857FE58A25A2CDF327C7C5F7F3A6946AEC210DFE * ___Contact_1;
public:
inline static int32_t get_offset_of_Status_0() { return static_cast<int32_t>(offsetof(OperationResult_t04D393B6206909328F53832764C577C5A9284748, ___Status_0)); }
inline int32_t get_Status_0() const { return ___Status_0; }
inline int32_t* get_address_of_Status_0() { return &___Status_0; }
inline void set_Status_0(int32_t value)
{
___Status_0 = value;
}
inline static int32_t get_offset_of_Contact_1() { return static_cast<int32_t>(offsetof(OperationResult_t04D393B6206909328F53832764C577C5A9284748, ___Contact_1)); }
inline Contact_t857FE58A25A2CDF327C7C5F7F3A6946AEC210DFE * get_Contact_1() const { return ___Contact_1; }
inline Contact_t857FE58A25A2CDF327C7C5F7F3A6946AEC210DFE ** get_address_of_Contact_1() { return &___Contact_1; }
inline void set_Contact_1(Contact_t857FE58A25A2CDF327C7C5F7F3A6946AEC210DFE * value)
{
___Contact_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Contact_1), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MagicLeap.MLContacts/OperationResult
struct OperationResult_t04D393B6206909328F53832764C577C5A9284748_marshaled_pinvoke
{
int32_t ___Status_0;
Contact_t857FE58A25A2CDF327C7C5F7F3A6946AEC210DFE * ___Contact_1;
};
// Native definition for COM marshalling of UnityEngine.XR.MagicLeap.MLContacts/OperationResult
struct OperationResult_t04D393B6206909328F53832764C577C5A9284748_marshaled_com
{
int32_t ___Status_0;
Contact_t857FE58A25A2CDF327C7C5F7F3A6946AEC210DFE * ___Contact_1;
};
// UnityEngine.XR.MagicLeap.MLInput/TabletState
struct TabletState_tFA5C8B491DBCEDA17A7378618C952F0BA393AE4A
{
public:
// UnityEngine.XR.MagicLeap.MLInput/TabletDeviceType UnityEngine.XR.MagicLeap.MLInput/TabletState::Type
uint32_t ___Type_0;
// UnityEngine.XR.MagicLeap.MLInput/TabletDeviceToolType UnityEngine.XR.MagicLeap.MLInput/TabletState::ToolType
uint32_t ___ToolType_1;
// UnityEngine.Vector3 UnityEngine.XR.MagicLeap.MLInput/TabletState::PenTouchPosAndForce
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___PenTouchPosAndForce_2;
// System.Int32[] UnityEngine.XR.MagicLeap.MLInput/TabletState::AdditionalPenTouchData
Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* ___AdditionalPenTouchData_3;
// System.Boolean UnityEngine.XR.MagicLeap.MLInput/TabletState::IsPenTouchActive
bool ___IsPenTouchActive_4;
// System.Boolean UnityEngine.XR.MagicLeap.MLInput/TabletState::IsConnected
bool ___IsConnected_5;
// System.Single UnityEngine.XR.MagicLeap.MLInput/TabletState::PenDistance
float ___PenDistance_6;
// System.UInt64 UnityEngine.XR.MagicLeap.MLInput/TabletState::TimeStamp
uint64_t ___TimeStamp_7;
// UnityEngine.XR.MagicLeap.MLInput/TabletDeviceStateMask UnityEngine.XR.MagicLeap.MLInput/TabletState::ValidityCheck
uint32_t ___ValidityCheck_8;
public:
inline static int32_t get_offset_of_Type_0() { return static_cast<int32_t>(offsetof(TabletState_tFA5C8B491DBCEDA17A7378618C952F0BA393AE4A, ___Type_0)); }
inline uint32_t get_Type_0() const { return ___Type_0; }
inline uint32_t* get_address_of_Type_0() { return &___Type_0; }
inline void set_Type_0(uint32_t value)
{
___Type_0 = value;
}
inline static int32_t get_offset_of_ToolType_1() { return static_cast<int32_t>(offsetof(TabletState_tFA5C8B491DBCEDA17A7378618C952F0BA393AE4A, ___ToolType_1)); }
inline uint32_t get_ToolType_1() const { return ___ToolType_1; }
inline uint32_t* get_address_of_ToolType_1() { return &___ToolType_1; }
inline void set_ToolType_1(uint32_t value)
{
___ToolType_1 = value;
}
inline static int32_t get_offset_of_PenTouchPosAndForce_2() { return static_cast<int32_t>(offsetof(TabletState_tFA5C8B491DBCEDA17A7378618C952F0BA393AE4A, ___PenTouchPosAndForce_2)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_PenTouchPosAndForce_2() const { return ___PenTouchPosAndForce_2; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_PenTouchPosAndForce_2() { return &___PenTouchPosAndForce_2; }
inline void set_PenTouchPosAndForce_2(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___PenTouchPosAndForce_2 = value;
}
inline static int32_t get_offset_of_AdditionalPenTouchData_3() { return static_cast<int32_t>(offsetof(TabletState_tFA5C8B491DBCEDA17A7378618C952F0BA393AE4A, ___AdditionalPenTouchData_3)); }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* get_AdditionalPenTouchData_3() const { return ___AdditionalPenTouchData_3; }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32** get_address_of_AdditionalPenTouchData_3() { return &___AdditionalPenTouchData_3; }
inline void set_AdditionalPenTouchData_3(Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* value)
{
___AdditionalPenTouchData_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___AdditionalPenTouchData_3), (void*)value);
}
inline static int32_t get_offset_of_IsPenTouchActive_4() { return static_cast<int32_t>(offsetof(TabletState_tFA5C8B491DBCEDA17A7378618C952F0BA393AE4A, ___IsPenTouchActive_4)); }
inline bool get_IsPenTouchActive_4() const { return ___IsPenTouchActive_4; }
inline bool* get_address_of_IsPenTouchActive_4() { return &___IsPenTouchActive_4; }
inline void set_IsPenTouchActive_4(bool value)
{
___IsPenTouchActive_4 = value;
}
inline static int32_t get_offset_of_IsConnected_5() { return static_cast<int32_t>(offsetof(TabletState_tFA5C8B491DBCEDA17A7378618C952F0BA393AE4A, ___IsConnected_5)); }
inline bool get_IsConnected_5() const { return ___IsConnected_5; }
inline bool* get_address_of_IsConnected_5() { return &___IsConnected_5; }
inline void set_IsConnected_5(bool value)
{
___IsConnected_5 = value;
}
inline static int32_t get_offset_of_PenDistance_6() { return static_cast<int32_t>(offsetof(TabletState_tFA5C8B491DBCEDA17A7378618C952F0BA393AE4A, ___PenDistance_6)); }
inline float get_PenDistance_6() const { return ___PenDistance_6; }
inline float* get_address_of_PenDistance_6() { return &___PenDistance_6; }
inline void set_PenDistance_6(float value)
{
___PenDistance_6 = value;
}
inline static int32_t get_offset_of_TimeStamp_7() { return static_cast<int32_t>(offsetof(TabletState_tFA5C8B491DBCEDA17A7378618C952F0BA393AE4A, ___TimeStamp_7)); }
inline uint64_t get_TimeStamp_7() const { return ___TimeStamp_7; }
inline uint64_t* get_address_of_TimeStamp_7() { return &___TimeStamp_7; }
inline void set_TimeStamp_7(uint64_t value)
{
___TimeStamp_7 = value;
}
inline static int32_t get_offset_of_ValidityCheck_8() { return static_cast<int32_t>(offsetof(TabletState_tFA5C8B491DBCEDA17A7378618C952F0BA393AE4A, ___ValidityCheck_8)); }
inline uint32_t get_ValidityCheck_8() const { return ___ValidityCheck_8; }
inline uint32_t* get_address_of_ValidityCheck_8() { return &___ValidityCheck_8; }
inline void set_ValidityCheck_8(uint32_t value)
{
___ValidityCheck_8 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MagicLeap.MLInput/TabletState
struct TabletState_tFA5C8B491DBCEDA17A7378618C952F0BA393AE4A_marshaled_pinvoke
{
uint32_t ___Type_0;
uint32_t ___ToolType_1;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___PenTouchPosAndForce_2;
Il2CppSafeArray/*NONE*/* ___AdditionalPenTouchData_3;
int32_t ___IsPenTouchActive_4;
int32_t ___IsConnected_5;
float ___PenDistance_6;
uint64_t ___TimeStamp_7;
uint32_t ___ValidityCheck_8;
};
// Native definition for COM marshalling of UnityEngine.XR.MagicLeap.MLInput/TabletState
struct TabletState_tFA5C8B491DBCEDA17A7378618C952F0BA393AE4A_marshaled_com
{
uint32_t ___Type_0;
uint32_t ___ToolType_1;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___PenTouchPosAndForce_2;
Il2CppSafeArray/*NONE*/* ___AdditionalPenTouchData_3;
int32_t ___IsPenTouchActive_4;
int32_t ___IsConnected_5;
float ___PenDistance_6;
uint64_t ___TimeStamp_7;
uint32_t ___ValidityCheck_8;
};
// UnityEngine.XR.MagicLeap.MLMRCamera/Frame
struct Frame_t128A1C20EE2DB6FC213BFFC7698397A2335E6804
{
public:
// System.UInt64 UnityEngine.XR.MagicLeap.MLMRCamera/Frame::<Id>k__BackingField
uint64_t ___U3CIdU3Ek__BackingField_0;
// System.UInt64 UnityEngine.XR.MagicLeap.MLMRCamera/Frame::<TimeStampNs>k__BackingField
uint64_t ___U3CTimeStampNsU3Ek__BackingField_1;
// UnityEngine.XR.MagicLeap.MLMRCamera/Frame/ImagePlane[] UnityEngine.XR.MagicLeap.MLMRCamera/Frame::<ImagePlanes>k__BackingField
ImagePlaneU5BU5D_tB00DBE0C67553311B758AA016D527AAEC57CA334* ___U3CImagePlanesU3Ek__BackingField_2;
// UnityEngine.XR.MagicLeap.MLMRCamera/OutputFormat UnityEngine.XR.MagicLeap.MLMRCamera/Frame::<Format>k__BackingField
int32_t ___U3CFormatU3Ek__BackingField_3;
public:
inline static int32_t get_offset_of_U3CIdU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(Frame_t128A1C20EE2DB6FC213BFFC7698397A2335E6804, ___U3CIdU3Ek__BackingField_0)); }
inline uint64_t get_U3CIdU3Ek__BackingField_0() const { return ___U3CIdU3Ek__BackingField_0; }
inline uint64_t* get_address_of_U3CIdU3Ek__BackingField_0() { return &___U3CIdU3Ek__BackingField_0; }
inline void set_U3CIdU3Ek__BackingField_0(uint64_t value)
{
___U3CIdU3Ek__BackingField_0 = value;
}
inline static int32_t get_offset_of_U3CTimeStampNsU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(Frame_t128A1C20EE2DB6FC213BFFC7698397A2335E6804, ___U3CTimeStampNsU3Ek__BackingField_1)); }
inline uint64_t get_U3CTimeStampNsU3Ek__BackingField_1() const { return ___U3CTimeStampNsU3Ek__BackingField_1; }
inline uint64_t* get_address_of_U3CTimeStampNsU3Ek__BackingField_1() { return &___U3CTimeStampNsU3Ek__BackingField_1; }
inline void set_U3CTimeStampNsU3Ek__BackingField_1(uint64_t value)
{
___U3CTimeStampNsU3Ek__BackingField_1 = value;
}
inline static int32_t get_offset_of_U3CImagePlanesU3Ek__BackingField_2() { return static_cast<int32_t>(offsetof(Frame_t128A1C20EE2DB6FC213BFFC7698397A2335E6804, ___U3CImagePlanesU3Ek__BackingField_2)); }
inline ImagePlaneU5BU5D_tB00DBE0C67553311B758AA016D527AAEC57CA334* get_U3CImagePlanesU3Ek__BackingField_2() const { return ___U3CImagePlanesU3Ek__BackingField_2; }
inline ImagePlaneU5BU5D_tB00DBE0C67553311B758AA016D527AAEC57CA334** get_address_of_U3CImagePlanesU3Ek__BackingField_2() { return &___U3CImagePlanesU3Ek__BackingField_2; }
inline void set_U3CImagePlanesU3Ek__BackingField_2(ImagePlaneU5BU5D_tB00DBE0C67553311B758AA016D527AAEC57CA334* value)
{
___U3CImagePlanesU3Ek__BackingField_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CImagePlanesU3Ek__BackingField_2), (void*)value);
}
inline static int32_t get_offset_of_U3CFormatU3Ek__BackingField_3() { return static_cast<int32_t>(offsetof(Frame_t128A1C20EE2DB6FC213BFFC7698397A2335E6804, ___U3CFormatU3Ek__BackingField_3)); }
inline int32_t get_U3CFormatU3Ek__BackingField_3() const { return ___U3CFormatU3Ek__BackingField_3; }
inline int32_t* get_address_of_U3CFormatU3Ek__BackingField_3() { return &___U3CFormatU3Ek__BackingField_3; }
inline void set_U3CFormatU3Ek__BackingField_3(int32_t value)
{
___U3CFormatU3Ek__BackingField_3 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MagicLeap.MLMRCamera/Frame
struct Frame_t128A1C20EE2DB6FC213BFFC7698397A2335E6804_marshaled_pinvoke
{
uint64_t ___U3CIdU3Ek__BackingField_0;
uint64_t ___U3CTimeStampNsU3Ek__BackingField_1;
ImagePlane_t2D929496EA001719A11E4DF9B11BD09B7B538D46_marshaled_pinvoke* ___U3CImagePlanesU3Ek__BackingField_2;
int32_t ___U3CFormatU3Ek__BackingField_3;
};
// Native definition for COM marshalling of UnityEngine.XR.MagicLeap.MLMRCamera/Frame
struct Frame_t128A1C20EE2DB6FC213BFFC7698397A2335E6804_marshaled_com
{
uint64_t ___U3CIdU3Ek__BackingField_0;
uint64_t ___U3CTimeStampNsU3Ek__BackingField_1;
ImagePlane_t2D929496EA001719A11E4DF9B11BD09B7B538D46_marshaled_com* ___U3CImagePlanesU3Ek__BackingField_2;
int32_t ___U3CFormatU3Ek__BackingField_3;
};
// UnityEngine.XR.MagicLeap.MLMediaPlayer/Cea708CaptionEvent
struct Cea708CaptionEvent_t56C4405243D5B580CBC687605BE9A3B15E1D06F6
{
public:
// UnityEngine.XR.MagicLeap.MLMediaPlayer/Cea708CaptionEmitCommand UnityEngine.XR.MagicLeap.MLMediaPlayer/Cea708CaptionEvent::Type
int32_t ___Type_0;
// System.Object UnityEngine.XR.MagicLeap.MLMediaPlayer/Cea708CaptionEvent::Object
RuntimeObject * ___Object_1;
public:
inline static int32_t get_offset_of_Type_0() { return static_cast<int32_t>(offsetof(Cea708CaptionEvent_t56C4405243D5B580CBC687605BE9A3B15E1D06F6, ___Type_0)); }
inline int32_t get_Type_0() const { return ___Type_0; }
inline int32_t* get_address_of_Type_0() { return &___Type_0; }
inline void set_Type_0(int32_t value)
{
___Type_0 = value;
}
inline static int32_t get_offset_of_Object_1() { return static_cast<int32_t>(offsetof(Cea708CaptionEvent_t56C4405243D5B580CBC687605BE9A3B15E1D06F6, ___Object_1)); }
inline RuntimeObject * get_Object_1() const { return ___Object_1; }
inline RuntimeObject ** get_address_of_Object_1() { return &___Object_1; }
inline void set_Object_1(RuntimeObject * value)
{
___Object_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Object_1), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MagicLeap.MLMediaPlayer/Cea708CaptionEvent
struct Cea708CaptionEvent_t56C4405243D5B580CBC687605BE9A3B15E1D06F6_marshaled_pinvoke
{
int32_t ___Type_0;
Il2CppIUnknown* ___Object_1;
};
// Native definition for COM marshalling of UnityEngine.XR.MagicLeap.MLMediaPlayer/Cea708CaptionEvent
struct Cea708CaptionEvent_t56C4405243D5B580CBC687605BE9A3B15E1D06F6_marshaled_com
{
int32_t ___Type_0;
Il2CppIUnknown* ___Object_1;
};
// UnityEngine.XR.MagicLeap.MLMediaPlayer/TrackData
struct TrackData_tDCFE71C8D16AD063EF76BBC09C03F3FB3FD1B7BF
{
public:
// System.UInt32 UnityEngine.XR.MagicLeap.MLMediaPlayer/TrackData::ID
uint32_t ___ID_0;
// System.String UnityEngine.XR.MagicLeap.MLMediaPlayer/TrackData::Language
String_t* ___Language_1;
// UnityEngine.XR.MagicLeap.MLMediaPlayer/PlayerTrackType UnityEngine.XR.MagicLeap.MLMediaPlayer/TrackData::Type
uint32_t ___Type_2;
// System.String UnityEngine.XR.MagicLeap.MLMediaPlayer/TrackData::MimeType
String_t* ___MimeType_3;
public:
inline static int32_t get_offset_of_ID_0() { return static_cast<int32_t>(offsetof(TrackData_tDCFE71C8D16AD063EF76BBC09C03F3FB3FD1B7BF, ___ID_0)); }
inline uint32_t get_ID_0() const { return ___ID_0; }
inline uint32_t* get_address_of_ID_0() { return &___ID_0; }
inline void set_ID_0(uint32_t value)
{
___ID_0 = value;
}
inline static int32_t get_offset_of_Language_1() { return static_cast<int32_t>(offsetof(TrackData_tDCFE71C8D16AD063EF76BBC09C03F3FB3FD1B7BF, ___Language_1)); }
inline String_t* get_Language_1() const { return ___Language_1; }
inline String_t** get_address_of_Language_1() { return &___Language_1; }
inline void set_Language_1(String_t* value)
{
___Language_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Language_1), (void*)value);
}
inline static int32_t get_offset_of_Type_2() { return static_cast<int32_t>(offsetof(TrackData_tDCFE71C8D16AD063EF76BBC09C03F3FB3FD1B7BF, ___Type_2)); }
inline uint32_t get_Type_2() const { return ___Type_2; }
inline uint32_t* get_address_of_Type_2() { return &___Type_2; }
inline void set_Type_2(uint32_t value)
{
___Type_2 = value;
}
inline static int32_t get_offset_of_MimeType_3() { return static_cast<int32_t>(offsetof(TrackData_tDCFE71C8D16AD063EF76BBC09C03F3FB3FD1B7BF, ___MimeType_3)); }
inline String_t* get_MimeType_3() const { return ___MimeType_3; }
inline String_t** get_address_of_MimeType_3() { return &___MimeType_3; }
inline void set_MimeType_3(String_t* value)
{
___MimeType_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___MimeType_3), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MagicLeap.MLMediaPlayer/TrackData
struct TrackData_tDCFE71C8D16AD063EF76BBC09C03F3FB3FD1B7BF_marshaled_pinvoke
{
uint32_t ___ID_0;
char* ___Language_1;
uint32_t ___Type_2;
char* ___MimeType_3;
};
// Native definition for COM marshalling of UnityEngine.XR.MagicLeap.MLMediaPlayer/TrackData
struct TrackData_tDCFE71C8D16AD063EF76BBC09C03F3FB3FD1B7BF_marshaled_com
{
uint32_t ___ID_0;
Il2CppChar* ___Language_1;
uint32_t ___Type_2;
Il2CppChar* ___MimeType_3;
};
// UnityEngine.XR.MagicLeap.MLMusicService/Error
struct Error_t4662C50A5F672241D3965F14B24F4E2F9983353B
{
public:
// UnityEngine.XR.MagicLeap.MLMusicService/ErrorType UnityEngine.XR.MagicLeap.MLMusicService/Error::Type
uint32_t ___Type_0;
// System.Int32 UnityEngine.XR.MagicLeap.MLMusicService/Error::Code
int32_t ___Code_1;
public:
inline static int32_t get_offset_of_Type_0() { return static_cast<int32_t>(offsetof(Error_t4662C50A5F672241D3965F14B24F4E2F9983353B, ___Type_0)); }
inline uint32_t get_Type_0() const { return ___Type_0; }
inline uint32_t* get_address_of_Type_0() { return &___Type_0; }
inline void set_Type_0(uint32_t value)
{
___Type_0 = value;
}
inline static int32_t get_offset_of_Code_1() { return static_cast<int32_t>(offsetof(Error_t4662C50A5F672241D3965F14B24F4E2F9983353B, ___Code_1)); }
inline int32_t get_Code_1() const { return ___Code_1; }
inline int32_t* get_address_of_Code_1() { return &___Code_1; }
inline void set_Code_1(int32_t value)
{
___Code_1 = value;
}
};
// UnityEngine.XR.MagicLeap.MLImageTracker/Target/Result
struct Result_t62DDE919B95F6BFDE1DD6E480F0225B7912290A2
{
public:
// UnityEngine.Vector3 UnityEngine.XR.MagicLeap.MLImageTracker/Target/Result::Position
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Position_0;
// UnityEngine.Quaternion UnityEngine.XR.MagicLeap.MLImageTracker/Target/Result::Rotation
Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___Rotation_1;
// UnityEngine.XR.MagicLeap.MLImageTracker/Target/TrackingStatus UnityEngine.XR.MagicLeap.MLImageTracker/Target/Result::Status
int32_t ___Status_2;
public:
inline static int32_t get_offset_of_Position_0() { return static_cast<int32_t>(offsetof(Result_t62DDE919B95F6BFDE1DD6E480F0225B7912290A2, ___Position_0)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_Position_0() const { return ___Position_0; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_Position_0() { return &___Position_0; }
inline void set_Position_0(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___Position_0 = value;
}
inline static int32_t get_offset_of_Rotation_1() { return static_cast<int32_t>(offsetof(Result_t62DDE919B95F6BFDE1DD6E480F0225B7912290A2, ___Rotation_1)); }
inline Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 get_Rotation_1() const { return ___Rotation_1; }
inline Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 * get_address_of_Rotation_1() { return &___Rotation_1; }
inline void set_Rotation_1(Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 value)
{
___Rotation_1 = value;
}
inline static int32_t get_offset_of_Status_2() { return static_cast<int32_t>(offsetof(Result_t62DDE919B95F6BFDE1DD6E480F0225B7912290A2, ___Status_2)); }
inline int32_t get_Status_2() const { return ___Status_2; }
inline int32_t* get_address_of_Status_2() { return &___Status_2; }
inline void set_Status_2(int32_t value)
{
___Status_2 = value;
}
};
// UnityEngine.XR.MagicLeap.MLRaycast/NativeBindings/MLRaycastResultNative
struct MLRaycastResultNative_tDA46F1834D203F71E2FC259B44817E02F85FCA90
{
public:
// UnityEngine.XR.MagicLeap.Native.MagicLeapNativeBindings/MLVec3f UnityEngine.XR.MagicLeap.MLRaycast/NativeBindings/MLRaycastResultNative::Hitpoint
MLVec3f_tABDB2B7D293736251D00845A7551060DB2CB1952 ___Hitpoint_0;
// UnityEngine.XR.MagicLeap.Native.MagicLeapNativeBindings/MLVec3f UnityEngine.XR.MagicLeap.MLRaycast/NativeBindings/MLRaycastResultNative::Normal
MLVec3f_tABDB2B7D293736251D00845A7551060DB2CB1952 ___Normal_1;
// System.Single UnityEngine.XR.MagicLeap.MLRaycast/NativeBindings/MLRaycastResultNative::Confidence
float ___Confidence_2;
// UnityEngine.XR.MagicLeap.MLRaycast/ResultState UnityEngine.XR.MagicLeap.MLRaycast/NativeBindings/MLRaycastResultNative::State
int32_t ___State_3;
public:
inline static int32_t get_offset_of_Hitpoint_0() { return static_cast<int32_t>(offsetof(MLRaycastResultNative_tDA46F1834D203F71E2FC259B44817E02F85FCA90, ___Hitpoint_0)); }
inline MLVec3f_tABDB2B7D293736251D00845A7551060DB2CB1952 get_Hitpoint_0() const { return ___Hitpoint_0; }
inline MLVec3f_tABDB2B7D293736251D00845A7551060DB2CB1952 * get_address_of_Hitpoint_0() { return &___Hitpoint_0; }
inline void set_Hitpoint_0(MLVec3f_tABDB2B7D293736251D00845A7551060DB2CB1952 value)
{
___Hitpoint_0 = value;
}
inline static int32_t get_offset_of_Normal_1() { return static_cast<int32_t>(offsetof(MLRaycastResultNative_tDA46F1834D203F71E2FC259B44817E02F85FCA90, ___Normal_1)); }
inline MLVec3f_tABDB2B7D293736251D00845A7551060DB2CB1952 get_Normal_1() const { return ___Normal_1; }
inline MLVec3f_tABDB2B7D293736251D00845A7551060DB2CB1952 * get_address_of_Normal_1() { return &___Normal_1; }
inline void set_Normal_1(MLVec3f_tABDB2B7D293736251D00845A7551060DB2CB1952 value)
{
___Normal_1 = value;
}
inline static int32_t get_offset_of_Confidence_2() { return static_cast<int32_t>(offsetof(MLRaycastResultNative_tDA46F1834D203F71E2FC259B44817E02F85FCA90, ___Confidence_2)); }
inline float get_Confidence_2() const { return ___Confidence_2; }
inline float* get_address_of_Confidence_2() { return &___Confidence_2; }
inline void set_Confidence_2(float value)
{
___Confidence_2 = value;
}
inline static int32_t get_offset_of_State_3() { return static_cast<int32_t>(offsetof(MLRaycastResultNative_tDA46F1834D203F71E2FC259B44817E02F85FCA90, ___State_3)); }
inline int32_t get_State_3() const { return ___State_3; }
inline int32_t* get_address_of_State_3() { return &___State_3; }
inline void set_State_3(int32_t value)
{
___State_3 = value;
}
};
// UnityEngine.XR.MagicLeap.MLWebRTC/VideoSink/Frame
struct Frame_t90194D91C0FAD483165FD830882EB3151D67BAA4
{
public:
// System.UInt64 UnityEngine.XR.MagicLeap.MLWebRTC/VideoSink/Frame::<Id>k__BackingField
uint64_t ___U3CIdU3Ek__BackingField_0;
// System.UInt64 UnityEngine.XR.MagicLeap.MLWebRTC/VideoSink/Frame::<TimeStampUs>k__BackingField
uint64_t ___U3CTimeStampUsU3Ek__BackingField_1;
// UnityEngine.XR.MagicLeap.MLWebRTC/VideoSink/Frame/ImagePlane[] UnityEngine.XR.MagicLeap.MLWebRTC/VideoSink/Frame::<ImagePlanes>k__BackingField
ImagePlaneU5BU5D_t7E88C21096FFC2D5885B1B4DB4B91918F52C4383* ___U3CImagePlanesU3Ek__BackingField_2;
// UnityEngine.XR.MagicLeap.MLWebRTC/VideoSink/Frame/OutputFormat UnityEngine.XR.MagicLeap.MLWebRTC/VideoSink/Frame::<Format>k__BackingField
int32_t ___U3CFormatU3Ek__BackingField_3;
public:
inline static int32_t get_offset_of_U3CIdU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(Frame_t90194D91C0FAD483165FD830882EB3151D67BAA4, ___U3CIdU3Ek__BackingField_0)); }
inline uint64_t get_U3CIdU3Ek__BackingField_0() const { return ___U3CIdU3Ek__BackingField_0; }
inline uint64_t* get_address_of_U3CIdU3Ek__BackingField_0() { return &___U3CIdU3Ek__BackingField_0; }
inline void set_U3CIdU3Ek__BackingField_0(uint64_t value)
{
___U3CIdU3Ek__BackingField_0 = value;
}
inline static int32_t get_offset_of_U3CTimeStampUsU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(Frame_t90194D91C0FAD483165FD830882EB3151D67BAA4, ___U3CTimeStampUsU3Ek__BackingField_1)); }
inline uint64_t get_U3CTimeStampUsU3Ek__BackingField_1() const { return ___U3CTimeStampUsU3Ek__BackingField_1; }
inline uint64_t* get_address_of_U3CTimeStampUsU3Ek__BackingField_1() { return &___U3CTimeStampUsU3Ek__BackingField_1; }
inline void set_U3CTimeStampUsU3Ek__BackingField_1(uint64_t value)
{
___U3CTimeStampUsU3Ek__BackingField_1 = value;
}
inline static int32_t get_offset_of_U3CImagePlanesU3Ek__BackingField_2() { return static_cast<int32_t>(offsetof(Frame_t90194D91C0FAD483165FD830882EB3151D67BAA4, ___U3CImagePlanesU3Ek__BackingField_2)); }
inline ImagePlaneU5BU5D_t7E88C21096FFC2D5885B1B4DB4B91918F52C4383* get_U3CImagePlanesU3Ek__BackingField_2() const { return ___U3CImagePlanesU3Ek__BackingField_2; }
inline ImagePlaneU5BU5D_t7E88C21096FFC2D5885B1B4DB4B91918F52C4383** get_address_of_U3CImagePlanesU3Ek__BackingField_2() { return &___U3CImagePlanesU3Ek__BackingField_2; }
inline void set_U3CImagePlanesU3Ek__BackingField_2(ImagePlaneU5BU5D_t7E88C21096FFC2D5885B1B4DB4B91918F52C4383* value)
{
___U3CImagePlanesU3Ek__BackingField_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CImagePlanesU3Ek__BackingField_2), (void*)value);
}
inline static int32_t get_offset_of_U3CFormatU3Ek__BackingField_3() { return static_cast<int32_t>(offsetof(Frame_t90194D91C0FAD483165FD830882EB3151D67BAA4, ___U3CFormatU3Ek__BackingField_3)); }
inline int32_t get_U3CFormatU3Ek__BackingField_3() const { return ___U3CFormatU3Ek__BackingField_3; }
inline int32_t* get_address_of_U3CFormatU3Ek__BackingField_3() { return &___U3CFormatU3Ek__BackingField_3; }
inline void set_U3CFormatU3Ek__BackingField_3(int32_t value)
{
___U3CFormatU3Ek__BackingField_3 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MagicLeap.MLWebRTC/VideoSink/Frame
struct Frame_t90194D91C0FAD483165FD830882EB3151D67BAA4_marshaled_pinvoke
{
uint64_t ___U3CIdU3Ek__BackingField_0;
uint64_t ___U3CTimeStampUsU3Ek__BackingField_1;
ImagePlane_t91027FEA4D694BC1810C3A63484BBC6DDA7C44DF * ___U3CImagePlanesU3Ek__BackingField_2;
int32_t ___U3CFormatU3Ek__BackingField_3;
};
// Native definition for COM marshalling of UnityEngine.XR.MagicLeap.MLWebRTC/VideoSink/Frame
struct Frame_t90194D91C0FAD483165FD830882EB3151D67BAA4_marshaled_com
{
uint64_t ___U3CIdU3Ek__BackingField_0;
uint64_t ___U3CTimeStampUsU3Ek__BackingField_1;
ImagePlane_t91027FEA4D694BC1810C3A63484BBC6DDA7C44DF * ___U3CImagePlanesU3Ek__BackingField_2;
int32_t ___U3CFormatU3Ek__BackingField_3;
};
// System.Collections.Generic.KeyValuePair`2<System.Int32Enum,UnityEngine.XR.MagicLeap.MLResult>
struct KeyValuePair_2_tB66ECE31A5BAEA562A3BC1EA1A3743D178A5C5D5
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
int32_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
MLResult_t16167FAD492D3A6F53116897898D23453C72B635 ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tB66ECE31A5BAEA562A3BC1EA1A3743D178A5C5D5, ___key_0)); }
inline int32_t get_key_0() const { return ___key_0; }
inline int32_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(int32_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tB66ECE31A5BAEA562A3BC1EA1A3743D178A5C5D5, ___value_1)); }
inline MLResult_t16167FAD492D3A6F53116897898D23453C72B635 get_value_1() const { return ___value_1; }
inline MLResult_t16167FAD492D3A6F53116897898D23453C72B635 * get_address_of_value_1() { return &___value_1; }
inline void set_value_1(MLResult_t16167FAD492D3A6F53116897898D23453C72B635 value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)&(((&___value_1))->___message_2), (void*)NULL);
}
};
// System.Collections.Generic.KeyValuePair`2<System.Int64,UnityEngine.XR.MagicLeap.MLMediaPlayer/TrackData>
struct KeyValuePair_2_tFA1E33986669B6C16376F3660D38C9BF819BEC55
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
int64_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
TrackData_tDCFE71C8D16AD063EF76BBC09C03F3FB3FD1B7BF ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tFA1E33986669B6C16376F3660D38C9BF819BEC55, ___key_0)); }
inline int64_t get_key_0() const { return ___key_0; }
inline int64_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(int64_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tFA1E33986669B6C16376F3660D38C9BF819BEC55, ___value_1)); }
inline TrackData_tDCFE71C8D16AD063EF76BBC09C03F3FB3FD1B7BF get_value_1() const { return ___value_1; }
inline TrackData_tDCFE71C8D16AD063EF76BBC09C03F3FB3FD1B7BF * get_address_of_value_1() { return &___value_1; }
inline void set_value_1(TrackData_tDCFE71C8D16AD063EF76BBC09C03F3FB3FD1B7BF value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)&(((&___value_1))->___Language_1), (void*)NULL);
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&(((&___value_1))->___MimeType_3), (void*)NULL);
#endif
}
};
// System.Collections.Generic.KeyValuePair`2<UnityEngine.XR.MeshId,UnityEngine.XR.MeshInfo>
struct KeyValuePair_2_t3BC076473466AB05F302E530F4A4392A6E94A7BC
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
MeshInfo_tD0E09CA3A2260A509C063BF0C8FDAC8D138FC611 ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t3BC076473466AB05F302E530F4A4392A6E94A7BC, ___key_0)); }
inline MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 get_key_0() const { return ___key_0; }
inline MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 * get_address_of_key_0() { return &___key_0; }
inline void set_key_0(MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t3BC076473466AB05F302E530F4A4392A6E94A7BC, ___value_1)); }
inline MeshInfo_tD0E09CA3A2260A509C063BF0C8FDAC8D138FC611 get_value_1() const { return ___value_1; }
inline MeshInfo_tD0E09CA3A2260A509C063BF0C8FDAC8D138FC611 * get_address_of_value_1() { return &___value_1; }
inline void set_value_1(MeshInfo_tD0E09CA3A2260A509C063BF0C8FDAC8D138FC611 value)
{
___value_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<UnityEngine.XR.ARSubsystems.TrackableId,UnityEngine.XR.ARSubsystems.BoundedPlane>
struct KeyValuePair_2_t8DD96E477F1D2D68A18ABD57FEB017DFFF8A58B2
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
BoundedPlane_t9001963C43ACDF4CDEA8BBF97CD783B7969B79C5 ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t8DD96E477F1D2D68A18ABD57FEB017DFFF8A58B2, ___key_0)); }
inline TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B get_key_0() const { return ___key_0; }
inline TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B * get_address_of_key_0() { return &___key_0; }
inline void set_key_0(TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t8DD96E477F1D2D68A18ABD57FEB017DFFF8A58B2, ___value_1)); }
inline BoundedPlane_t9001963C43ACDF4CDEA8BBF97CD783B7969B79C5 get_value_1() const { return ___value_1; }
inline BoundedPlane_t9001963C43ACDF4CDEA8BBF97CD783B7969B79C5 * get_address_of_value_1() { return &___value_1; }
inline void set_value_1(BoundedPlane_t9001963C43ACDF4CDEA8BBF97CD783B7969B79C5 value)
{
___value_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.UInt64,UnityEngine.XR.MagicLeap.MLRaycast/NativeBindings/MLRaycastResultNative>
struct KeyValuePair_2_tA9C4AF92A1B6458C47F72B185C784D3A4801B345
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
uint64_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
MLRaycastResultNative_tDA46F1834D203F71E2FC259B44817E02F85FCA90 ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tA9C4AF92A1B6458C47F72B185C784D3A4801B345, ___key_0)); }
inline uint64_t get_key_0() const { return ___key_0; }
inline uint64_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(uint64_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tA9C4AF92A1B6458C47F72B185C784D3A4801B345, ___value_1)); }
inline MLRaycastResultNative_tDA46F1834D203F71E2FC259B44817E02F85FCA90 get_value_1() const { return ___value_1; }
inline MLRaycastResultNative_tDA46F1834D203F71E2FC259B44817E02F85FCA90 * get_address_of_value_1() { return &___value_1; }
inline void set_value_1(MLRaycastResultNative_tDA46F1834D203F71E2FC259B44817E02F85FCA90 value)
{
___value_1 = value;
}
};
// UnityEngine.Rendering.BatchCullingContext
struct BatchCullingContext_t26E634F354C4F3915108C34A32FD32118FFE1F66
{
public:
// Unity.Collections.NativeArray`1<UnityEngine.Plane> UnityEngine.Rendering.BatchCullingContext::cullingPlanes
NativeArray_1_t527C586787ACD1AD75E3C78BFB024FFA9925662E ___cullingPlanes_0;
// Unity.Collections.NativeArray`1<UnityEngine.Rendering.BatchVisibility> UnityEngine.Rendering.BatchCullingContext::batchVisibility
NativeArray_1_t18D233A2E30E28048C1252473AFD0799557294DA ___batchVisibility_1;
// Unity.Collections.NativeArray`1<System.Int32> UnityEngine.Rendering.BatchCullingContext::visibleIndices
NativeArray_1_tD60079F06B473C85CF6C2BB4F2D203F38191AE99 ___visibleIndices_2;
// Unity.Collections.NativeArray`1<System.Int32> UnityEngine.Rendering.BatchCullingContext::visibleIndicesY
NativeArray_1_tD60079F06B473C85CF6C2BB4F2D203F38191AE99 ___visibleIndicesY_3;
// UnityEngine.Rendering.LODParameters UnityEngine.Rendering.BatchCullingContext::lodParameters
LODParameters_tA41D06C4BDB03138144BE9DCC4BC6B37963DC5CD ___lodParameters_4;
// UnityEngine.Matrix4x4 UnityEngine.Rendering.BatchCullingContext::cullingMatrix
Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461 ___cullingMatrix_5;
// System.Single UnityEngine.Rendering.BatchCullingContext::nearPlane
float ___nearPlane_6;
public:
inline static int32_t get_offset_of_cullingPlanes_0() { return static_cast<int32_t>(offsetof(BatchCullingContext_t26E634F354C4F3915108C34A32FD32118FFE1F66, ___cullingPlanes_0)); }
inline NativeArray_1_t527C586787ACD1AD75E3C78BFB024FFA9925662E get_cullingPlanes_0() const { return ___cullingPlanes_0; }
inline NativeArray_1_t527C586787ACD1AD75E3C78BFB024FFA9925662E * get_address_of_cullingPlanes_0() { return &___cullingPlanes_0; }
inline void set_cullingPlanes_0(NativeArray_1_t527C586787ACD1AD75E3C78BFB024FFA9925662E value)
{
___cullingPlanes_0 = value;
}
inline static int32_t get_offset_of_batchVisibility_1() { return static_cast<int32_t>(offsetof(BatchCullingContext_t26E634F354C4F3915108C34A32FD32118FFE1F66, ___batchVisibility_1)); }
inline NativeArray_1_t18D233A2E30E28048C1252473AFD0799557294DA get_batchVisibility_1() const { return ___batchVisibility_1; }
inline NativeArray_1_t18D233A2E30E28048C1252473AFD0799557294DA * get_address_of_batchVisibility_1() { return &___batchVisibility_1; }
inline void set_batchVisibility_1(NativeArray_1_t18D233A2E30E28048C1252473AFD0799557294DA value)
{
___batchVisibility_1 = value;
}
inline static int32_t get_offset_of_visibleIndices_2() { return static_cast<int32_t>(offsetof(BatchCullingContext_t26E634F354C4F3915108C34A32FD32118FFE1F66, ___visibleIndices_2)); }
inline NativeArray_1_tD60079F06B473C85CF6C2BB4F2D203F38191AE99 get_visibleIndices_2() const { return ___visibleIndices_2; }
inline NativeArray_1_tD60079F06B473C85CF6C2BB4F2D203F38191AE99 * get_address_of_visibleIndices_2() { return &___visibleIndices_2; }
inline void set_visibleIndices_2(NativeArray_1_tD60079F06B473C85CF6C2BB4F2D203F38191AE99 value)
{
___visibleIndices_2 = value;
}
inline static int32_t get_offset_of_visibleIndicesY_3() { return static_cast<int32_t>(offsetof(BatchCullingContext_t26E634F354C4F3915108C34A32FD32118FFE1F66, ___visibleIndicesY_3)); }
inline NativeArray_1_tD60079F06B473C85CF6C2BB4F2D203F38191AE99 get_visibleIndicesY_3() const { return ___visibleIndicesY_3; }
inline NativeArray_1_tD60079F06B473C85CF6C2BB4F2D203F38191AE99 * get_address_of_visibleIndicesY_3() { return &___visibleIndicesY_3; }
inline void set_visibleIndicesY_3(NativeArray_1_tD60079F06B473C85CF6C2BB4F2D203F38191AE99 value)
{
___visibleIndicesY_3 = value;
}
inline static int32_t get_offset_of_lodParameters_4() { return static_cast<int32_t>(offsetof(BatchCullingContext_t26E634F354C4F3915108C34A32FD32118FFE1F66, ___lodParameters_4)); }
inline LODParameters_tA41D06C4BDB03138144BE9DCC4BC6B37963DC5CD get_lodParameters_4() const { return ___lodParameters_4; }
inline LODParameters_tA41D06C4BDB03138144BE9DCC4BC6B37963DC5CD * get_address_of_lodParameters_4() { return &___lodParameters_4; }
inline void set_lodParameters_4(LODParameters_tA41D06C4BDB03138144BE9DCC4BC6B37963DC5CD value)
{
___lodParameters_4 = value;
}
inline static int32_t get_offset_of_cullingMatrix_5() { return static_cast<int32_t>(offsetof(BatchCullingContext_t26E634F354C4F3915108C34A32FD32118FFE1F66, ___cullingMatrix_5)); }
inline Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461 get_cullingMatrix_5() const { return ___cullingMatrix_5; }
inline Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461 * get_address_of_cullingMatrix_5() { return &___cullingMatrix_5; }
inline void set_cullingMatrix_5(Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461 value)
{
___cullingMatrix_5 = value;
}
inline static int32_t get_offset_of_nearPlane_6() { return static_cast<int32_t>(offsetof(BatchCullingContext_t26E634F354C4F3915108C34A32FD32118FFE1F66, ___nearPlane_6)); }
inline float get_nearPlane_6() const { return ___nearPlane_6; }
inline float* get_address_of_nearPlane_6() { return &___nearPlane_6; }
inline void set_nearPlane_6(float value)
{
___nearPlane_6 = value;
}
};
// UnityEngine.Profiling.Experimental.DebugScreenCapture
struct DebugScreenCapture_t82C35632EAE92C143A87097DC34C70EFADB750B1
{
public:
// Unity.Collections.NativeArray`1<System.Byte> UnityEngine.Profiling.Experimental.DebugScreenCapture::<rawImageDataReference>k__BackingField
NativeArray_1_t3C2855C5B238E8C6739D4C17833F244B95C0F785 ___U3CrawImageDataReferenceU3Ek__BackingField_0;
// UnityEngine.TextureFormat UnityEngine.Profiling.Experimental.DebugScreenCapture::<imageFormat>k__BackingField
int32_t ___U3CimageFormatU3Ek__BackingField_1;
// System.Int32 UnityEngine.Profiling.Experimental.DebugScreenCapture::<width>k__BackingField
int32_t ___U3CwidthU3Ek__BackingField_2;
// System.Int32 UnityEngine.Profiling.Experimental.DebugScreenCapture::<height>k__BackingField
int32_t ___U3CheightU3Ek__BackingField_3;
public:
inline static int32_t get_offset_of_U3CrawImageDataReferenceU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(DebugScreenCapture_t82C35632EAE92C143A87097DC34C70EFADB750B1, ___U3CrawImageDataReferenceU3Ek__BackingField_0)); }
inline NativeArray_1_t3C2855C5B238E8C6739D4C17833F244B95C0F785 get_U3CrawImageDataReferenceU3Ek__BackingField_0() const { return ___U3CrawImageDataReferenceU3Ek__BackingField_0; }
inline NativeArray_1_t3C2855C5B238E8C6739D4C17833F244B95C0F785 * get_address_of_U3CrawImageDataReferenceU3Ek__BackingField_0() { return &___U3CrawImageDataReferenceU3Ek__BackingField_0; }
inline void set_U3CrawImageDataReferenceU3Ek__BackingField_0(NativeArray_1_t3C2855C5B238E8C6739D4C17833F244B95C0F785 value)
{
___U3CrawImageDataReferenceU3Ek__BackingField_0 = value;
}
inline static int32_t get_offset_of_U3CimageFormatU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(DebugScreenCapture_t82C35632EAE92C143A87097DC34C70EFADB750B1, ___U3CimageFormatU3Ek__BackingField_1)); }
inline int32_t get_U3CimageFormatU3Ek__BackingField_1() const { return ___U3CimageFormatU3Ek__BackingField_1; }
inline int32_t* get_address_of_U3CimageFormatU3Ek__BackingField_1() { return &___U3CimageFormatU3Ek__BackingField_1; }
inline void set_U3CimageFormatU3Ek__BackingField_1(int32_t value)
{
___U3CimageFormatU3Ek__BackingField_1 = value;
}
inline static int32_t get_offset_of_U3CwidthU3Ek__BackingField_2() { return static_cast<int32_t>(offsetof(DebugScreenCapture_t82C35632EAE92C143A87097DC34C70EFADB750B1, ___U3CwidthU3Ek__BackingField_2)); }
inline int32_t get_U3CwidthU3Ek__BackingField_2() const { return ___U3CwidthU3Ek__BackingField_2; }
inline int32_t* get_address_of_U3CwidthU3Ek__BackingField_2() { return &___U3CwidthU3Ek__BackingField_2; }
inline void set_U3CwidthU3Ek__BackingField_2(int32_t value)
{
___U3CwidthU3Ek__BackingField_2 = value;
}
inline static int32_t get_offset_of_U3CheightU3Ek__BackingField_3() { return static_cast<int32_t>(offsetof(DebugScreenCapture_t82C35632EAE92C143A87097DC34C70EFADB750B1, ___U3CheightU3Ek__BackingField_3)); }
inline int32_t get_U3CheightU3Ek__BackingField_3() const { return ___U3CheightU3Ek__BackingField_3; }
inline int32_t* get_address_of_U3CheightU3Ek__BackingField_3() { return &___U3CheightU3Ek__BackingField_3; }
inline void set_U3CheightU3Ek__BackingField_3(int32_t value)
{
___U3CheightU3Ek__BackingField_3 = value;
}
};
// Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorPropertySetting
struct InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032
{
public:
// Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorField/FieldTypes Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorPropertySetting::Type
int32_t ___Type_0;
// System.String Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorPropertySetting::Label
String_t* ___Label_1;
// System.String Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorPropertySetting::Name
String_t* ___Name_2;
// System.String Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorPropertySetting::Tooltip
String_t* ___Tooltip_3;
// System.Int32 Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorPropertySetting::IntValue
int32_t ___IntValue_4;
// System.String Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorPropertySetting::StringValue
String_t* ___StringValue_5;
// System.Single Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorPropertySetting::FloatValue
float ___FloatValue_6;
// System.Boolean Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorPropertySetting::BoolValue
bool ___BoolValue_7;
// UnityEngine.GameObject Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorPropertySetting::GameObjectValue
GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * ___GameObjectValue_8;
// UnityEngine.ScriptableObject Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorPropertySetting::ScriptableObjectValue
ScriptableObject_t4361E08CEBF052C650D3666C7CEC37EB31DE116A * ___ScriptableObjectValue_9;
// UnityEngine.Object Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorPropertySetting::ObjectValue
Object_tF2F3778131EFF286AF62B7B013A170F95A91571A * ___ObjectValue_10;
// UnityEngine.Material Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorPropertySetting::MaterialValue
Material_t8927C00353A72755313F046D0CE85178AE8218EE * ___MaterialValue_11;
// UnityEngine.Texture Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorPropertySetting::TextureValue
Texture_t9FE0218A1EEDF266E8C85879FE123265CACC95AE * ___TextureValue_12;
// UnityEngine.Color Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorPropertySetting::ColorValue
Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 ___ColorValue_13;
// UnityEngine.Vector2 Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorPropertySetting::Vector2Value
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___Vector2Value_14;
// UnityEngine.Vector3 Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorPropertySetting::Vector3Value
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector3Value_15;
// UnityEngine.Vector4 Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorPropertySetting::Vector4Value
Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 ___Vector4Value_16;
// UnityEngine.AnimationCurve Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorPropertySetting::CurveValue
AnimationCurve_t2D452A14820CEDB83BFF2C911682A4E59001AD03 * ___CurveValue_17;
// UnityEngine.AudioClip Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorPropertySetting::AudioClipValue
AudioClip_t16D2E573E7CC1C5118D8EE0F0692D46866A1C0EE * ___AudioClipValue_18;
// UnityEngine.Quaternion Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorPropertySetting::QuaternionValue
Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___QuaternionValue_19;
// UnityEngine.Events.UnityEvent Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorPropertySetting::EventValue
UnityEvent_tA0EA9BC49FD7D5185E7A238EF2E0E6F5D0EE27F4 * ___EventValue_20;
// System.String[] Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorPropertySetting::Options
StringU5BU5D_tACEBFEDE350025B554CD507C9AE8FFE49359549A* ___Options_21;
public:
inline static int32_t get_offset_of_Type_0() { return static_cast<int32_t>(offsetof(InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032, ___Type_0)); }
inline int32_t get_Type_0() const { return ___Type_0; }
inline int32_t* get_address_of_Type_0() { return &___Type_0; }
inline void set_Type_0(int32_t value)
{
___Type_0 = value;
}
inline static int32_t get_offset_of_Label_1() { return static_cast<int32_t>(offsetof(InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032, ___Label_1)); }
inline String_t* get_Label_1() const { return ___Label_1; }
inline String_t** get_address_of_Label_1() { return &___Label_1; }
inline void set_Label_1(String_t* value)
{
___Label_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Label_1), (void*)value);
}
inline static int32_t get_offset_of_Name_2() { return static_cast<int32_t>(offsetof(InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032, ___Name_2)); }
inline String_t* get_Name_2() const { return ___Name_2; }
inline String_t** get_address_of_Name_2() { return &___Name_2; }
inline void set_Name_2(String_t* value)
{
___Name_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Name_2), (void*)value);
}
inline static int32_t get_offset_of_Tooltip_3() { return static_cast<int32_t>(offsetof(InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032, ___Tooltip_3)); }
inline String_t* get_Tooltip_3() const { return ___Tooltip_3; }
inline String_t** get_address_of_Tooltip_3() { return &___Tooltip_3; }
inline void set_Tooltip_3(String_t* value)
{
___Tooltip_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Tooltip_3), (void*)value);
}
inline static int32_t get_offset_of_IntValue_4() { return static_cast<int32_t>(offsetof(InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032, ___IntValue_4)); }
inline int32_t get_IntValue_4() const { return ___IntValue_4; }
inline int32_t* get_address_of_IntValue_4() { return &___IntValue_4; }
inline void set_IntValue_4(int32_t value)
{
___IntValue_4 = value;
}
inline static int32_t get_offset_of_StringValue_5() { return static_cast<int32_t>(offsetof(InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032, ___StringValue_5)); }
inline String_t* get_StringValue_5() const { return ___StringValue_5; }
inline String_t** get_address_of_StringValue_5() { return &___StringValue_5; }
inline void set_StringValue_5(String_t* value)
{
___StringValue_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___StringValue_5), (void*)value);
}
inline static int32_t get_offset_of_FloatValue_6() { return static_cast<int32_t>(offsetof(InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032, ___FloatValue_6)); }
inline float get_FloatValue_6() const { return ___FloatValue_6; }
inline float* get_address_of_FloatValue_6() { return &___FloatValue_6; }
inline void set_FloatValue_6(float value)
{
___FloatValue_6 = value;
}
inline static int32_t get_offset_of_BoolValue_7() { return static_cast<int32_t>(offsetof(InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032, ___BoolValue_7)); }
inline bool get_BoolValue_7() const { return ___BoolValue_7; }
inline bool* get_address_of_BoolValue_7() { return &___BoolValue_7; }
inline void set_BoolValue_7(bool value)
{
___BoolValue_7 = value;
}
inline static int32_t get_offset_of_GameObjectValue_8() { return static_cast<int32_t>(offsetof(InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032, ___GameObjectValue_8)); }
inline GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * get_GameObjectValue_8() const { return ___GameObjectValue_8; }
inline GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 ** get_address_of_GameObjectValue_8() { return &___GameObjectValue_8; }
inline void set_GameObjectValue_8(GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * value)
{
___GameObjectValue_8 = value;
Il2CppCodeGenWriteBarrier((void**)(&___GameObjectValue_8), (void*)value);
}
inline static int32_t get_offset_of_ScriptableObjectValue_9() { return static_cast<int32_t>(offsetof(InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032, ___ScriptableObjectValue_9)); }
inline ScriptableObject_t4361E08CEBF052C650D3666C7CEC37EB31DE116A * get_ScriptableObjectValue_9() const { return ___ScriptableObjectValue_9; }
inline ScriptableObject_t4361E08CEBF052C650D3666C7CEC37EB31DE116A ** get_address_of_ScriptableObjectValue_9() { return &___ScriptableObjectValue_9; }
inline void set_ScriptableObjectValue_9(ScriptableObject_t4361E08CEBF052C650D3666C7CEC37EB31DE116A * value)
{
___ScriptableObjectValue_9 = value;
Il2CppCodeGenWriteBarrier((void**)(&___ScriptableObjectValue_9), (void*)value);
}
inline static int32_t get_offset_of_ObjectValue_10() { return static_cast<int32_t>(offsetof(InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032, ___ObjectValue_10)); }
inline Object_tF2F3778131EFF286AF62B7B013A170F95A91571A * get_ObjectValue_10() const { return ___ObjectValue_10; }
inline Object_tF2F3778131EFF286AF62B7B013A170F95A91571A ** get_address_of_ObjectValue_10() { return &___ObjectValue_10; }
inline void set_ObjectValue_10(Object_tF2F3778131EFF286AF62B7B013A170F95A91571A * value)
{
___ObjectValue_10 = value;
Il2CppCodeGenWriteBarrier((void**)(&___ObjectValue_10), (void*)value);
}
inline static int32_t get_offset_of_MaterialValue_11() { return static_cast<int32_t>(offsetof(InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032, ___MaterialValue_11)); }
inline Material_t8927C00353A72755313F046D0CE85178AE8218EE * get_MaterialValue_11() const { return ___MaterialValue_11; }
inline Material_t8927C00353A72755313F046D0CE85178AE8218EE ** get_address_of_MaterialValue_11() { return &___MaterialValue_11; }
inline void set_MaterialValue_11(Material_t8927C00353A72755313F046D0CE85178AE8218EE * value)
{
___MaterialValue_11 = value;
Il2CppCodeGenWriteBarrier((void**)(&___MaterialValue_11), (void*)value);
}
inline static int32_t get_offset_of_TextureValue_12() { return static_cast<int32_t>(offsetof(InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032, ___TextureValue_12)); }
inline Texture_t9FE0218A1EEDF266E8C85879FE123265CACC95AE * get_TextureValue_12() const { return ___TextureValue_12; }
inline Texture_t9FE0218A1EEDF266E8C85879FE123265CACC95AE ** get_address_of_TextureValue_12() { return &___TextureValue_12; }
inline void set_TextureValue_12(Texture_t9FE0218A1EEDF266E8C85879FE123265CACC95AE * value)
{
___TextureValue_12 = value;
Il2CppCodeGenWriteBarrier((void**)(&___TextureValue_12), (void*)value);
}
inline static int32_t get_offset_of_ColorValue_13() { return static_cast<int32_t>(offsetof(InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032, ___ColorValue_13)); }
inline Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 get_ColorValue_13() const { return ___ColorValue_13; }
inline Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 * get_address_of_ColorValue_13() { return &___ColorValue_13; }
inline void set_ColorValue_13(Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 value)
{
___ColorValue_13 = value;
}
inline static int32_t get_offset_of_Vector2Value_14() { return static_cast<int32_t>(offsetof(InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032, ___Vector2Value_14)); }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 get_Vector2Value_14() const { return ___Vector2Value_14; }
inline Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 * get_address_of_Vector2Value_14() { return &___Vector2Value_14; }
inline void set_Vector2Value_14(Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 value)
{
___Vector2Value_14 = value;
}
inline static int32_t get_offset_of_Vector3Value_15() { return static_cast<int32_t>(offsetof(InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032, ___Vector3Value_15)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_Vector3Value_15() const { return ___Vector3Value_15; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_Vector3Value_15() { return &___Vector3Value_15; }
inline void set_Vector3Value_15(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___Vector3Value_15 = value;
}
inline static int32_t get_offset_of_Vector4Value_16() { return static_cast<int32_t>(offsetof(InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032, ___Vector4Value_16)); }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 get_Vector4Value_16() const { return ___Vector4Value_16; }
inline Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 * get_address_of_Vector4Value_16() { return &___Vector4Value_16; }
inline void set_Vector4Value_16(Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 value)
{
___Vector4Value_16 = value;
}
inline static int32_t get_offset_of_CurveValue_17() { return static_cast<int32_t>(offsetof(InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032, ___CurveValue_17)); }
inline AnimationCurve_t2D452A14820CEDB83BFF2C911682A4E59001AD03 * get_CurveValue_17() const { return ___CurveValue_17; }
inline AnimationCurve_t2D452A14820CEDB83BFF2C911682A4E59001AD03 ** get_address_of_CurveValue_17() { return &___CurveValue_17; }
inline void set_CurveValue_17(AnimationCurve_t2D452A14820CEDB83BFF2C911682A4E59001AD03 * value)
{
___CurveValue_17 = value;
Il2CppCodeGenWriteBarrier((void**)(&___CurveValue_17), (void*)value);
}
inline static int32_t get_offset_of_AudioClipValue_18() { return static_cast<int32_t>(offsetof(InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032, ___AudioClipValue_18)); }
inline AudioClip_t16D2E573E7CC1C5118D8EE0F0692D46866A1C0EE * get_AudioClipValue_18() const { return ___AudioClipValue_18; }
inline AudioClip_t16D2E573E7CC1C5118D8EE0F0692D46866A1C0EE ** get_address_of_AudioClipValue_18() { return &___AudioClipValue_18; }
inline void set_AudioClipValue_18(AudioClip_t16D2E573E7CC1C5118D8EE0F0692D46866A1C0EE * value)
{
___AudioClipValue_18 = value;
Il2CppCodeGenWriteBarrier((void**)(&___AudioClipValue_18), (void*)value);
}
inline static int32_t get_offset_of_QuaternionValue_19() { return static_cast<int32_t>(offsetof(InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032, ___QuaternionValue_19)); }
inline Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 get_QuaternionValue_19() const { return ___QuaternionValue_19; }
inline Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 * get_address_of_QuaternionValue_19() { return &___QuaternionValue_19; }
inline void set_QuaternionValue_19(Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 value)
{
___QuaternionValue_19 = value;
}
inline static int32_t get_offset_of_EventValue_20() { return static_cast<int32_t>(offsetof(InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032, ___EventValue_20)); }
inline UnityEvent_tA0EA9BC49FD7D5185E7A238EF2E0E6F5D0EE27F4 * get_EventValue_20() const { return ___EventValue_20; }
inline UnityEvent_tA0EA9BC49FD7D5185E7A238EF2E0E6F5D0EE27F4 ** get_address_of_EventValue_20() { return &___EventValue_20; }
inline void set_EventValue_20(UnityEvent_tA0EA9BC49FD7D5185E7A238EF2E0E6F5D0EE27F4 * value)
{
___EventValue_20 = value;
Il2CppCodeGenWriteBarrier((void**)(&___EventValue_20), (void*)value);
}
inline static int32_t get_offset_of_Options_21() { return static_cast<int32_t>(offsetof(InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032, ___Options_21)); }
inline StringU5BU5D_tACEBFEDE350025B554CD507C9AE8FFE49359549A* get_Options_21() const { return ___Options_21; }
inline StringU5BU5D_tACEBFEDE350025B554CD507C9AE8FFE49359549A** get_address_of_Options_21() { return &___Options_21; }
inline void set_Options_21(StringU5BU5D_tACEBFEDE350025B554CD507C9AE8FFE49359549A* value)
{
___Options_21 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Options_21), (void*)value);
}
};
// Native definition for P/Invoke marshalling of Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorPropertySetting
struct InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032_marshaled_pinvoke
{
int32_t ___Type_0;
char* ___Label_1;
char* ___Name_2;
char* ___Tooltip_3;
int32_t ___IntValue_4;
char* ___StringValue_5;
float ___FloatValue_6;
int32_t ___BoolValue_7;
GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * ___GameObjectValue_8;
ScriptableObject_t4361E08CEBF052C650D3666C7CEC37EB31DE116A_marshaled_pinvoke ___ScriptableObjectValue_9;
Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_marshaled_pinvoke ___ObjectValue_10;
Material_t8927C00353A72755313F046D0CE85178AE8218EE * ___MaterialValue_11;
Texture_t9FE0218A1EEDF266E8C85879FE123265CACC95AE * ___TextureValue_12;
Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 ___ColorValue_13;
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___Vector2Value_14;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector3Value_15;
Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 ___Vector4Value_16;
AnimationCurve_t2D452A14820CEDB83BFF2C911682A4E59001AD03_marshaled_pinvoke ___CurveValue_17;
AudioClip_t16D2E573E7CC1C5118D8EE0F0692D46866A1C0EE * ___AudioClipValue_18;
Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___QuaternionValue_19;
UnityEvent_tA0EA9BC49FD7D5185E7A238EF2E0E6F5D0EE27F4 * ___EventValue_20;
char** ___Options_21;
};
// Native definition for COM marshalling of Microsoft.MixedReality.Toolkit.Utilities.Editor.InspectorPropertySetting
struct InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032_marshaled_com
{
int32_t ___Type_0;
Il2CppChar* ___Label_1;
Il2CppChar* ___Name_2;
Il2CppChar* ___Tooltip_3;
int32_t ___IntValue_4;
Il2CppChar* ___StringValue_5;
float ___FloatValue_6;
int32_t ___BoolValue_7;
GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * ___GameObjectValue_8;
ScriptableObject_t4361E08CEBF052C650D3666C7CEC37EB31DE116A_marshaled_com* ___ScriptableObjectValue_9;
Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_marshaled_com* ___ObjectValue_10;
Material_t8927C00353A72755313F046D0CE85178AE8218EE * ___MaterialValue_11;
Texture_t9FE0218A1EEDF266E8C85879FE123265CACC95AE * ___TextureValue_12;
Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 ___ColorValue_13;
Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___Vector2Value_14;
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector3Value_15;
Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 ___Vector4Value_16;
AnimationCurve_t2D452A14820CEDB83BFF2C911682A4E59001AD03_marshaled_com* ___CurveValue_17;
AudioClip_t16D2E573E7CC1C5118D8EE0F0692D46866A1C0EE * ___AudioClipValue_18;
Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___QuaternionValue_19;
UnityEvent_tA0EA9BC49FD7D5185E7A238EF2E0E6F5D0EE27F4 * ___EventValue_20;
Il2CppChar** ___Options_21;
};
// Microsoft.MixedReality.Toolkit.Input.SpeechCommands
struct SpeechCommands_tB5EB0ECFA6A91657370C348F8F7862ADC9AE44EB
{
public:
// System.String Microsoft.MixedReality.Toolkit.Input.SpeechCommands::localizationKey
String_t* ___localizationKey_0;
// System.String Microsoft.MixedReality.Toolkit.Input.SpeechCommands::localizedKeyword
String_t* ___localizedKeyword_1;
// System.String Microsoft.MixedReality.Toolkit.Input.SpeechCommands::keyword
String_t* ___keyword_2;
// UnityEngine.KeyCode Microsoft.MixedReality.Toolkit.Input.SpeechCommands::keyCode
int32_t ___keyCode_3;
// Microsoft.MixedReality.Toolkit.Input.MixedRealityInputAction Microsoft.MixedReality.Toolkit.Input.SpeechCommands::action
MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A ___action_4;
public:
inline static int32_t get_offset_of_localizationKey_0() { return static_cast<int32_t>(offsetof(SpeechCommands_tB5EB0ECFA6A91657370C348F8F7862ADC9AE44EB, ___localizationKey_0)); }
inline String_t* get_localizationKey_0() const { return ___localizationKey_0; }
inline String_t** get_address_of_localizationKey_0() { return &___localizationKey_0; }
inline void set_localizationKey_0(String_t* value)
{
___localizationKey_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___localizationKey_0), (void*)value);
}
inline static int32_t get_offset_of_localizedKeyword_1() { return static_cast<int32_t>(offsetof(SpeechCommands_tB5EB0ECFA6A91657370C348F8F7862ADC9AE44EB, ___localizedKeyword_1)); }
inline String_t* get_localizedKeyword_1() const { return ___localizedKeyword_1; }
inline String_t** get_address_of_localizedKeyword_1() { return &___localizedKeyword_1; }
inline void set_localizedKeyword_1(String_t* value)
{
___localizedKeyword_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___localizedKeyword_1), (void*)value);
}
inline static int32_t get_offset_of_keyword_2() { return static_cast<int32_t>(offsetof(SpeechCommands_tB5EB0ECFA6A91657370C348F8F7862ADC9AE44EB, ___keyword_2)); }
inline String_t* get_keyword_2() const { return ___keyword_2; }
inline String_t** get_address_of_keyword_2() { return &___keyword_2; }
inline void set_keyword_2(String_t* value)
{
___keyword_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___keyword_2), (void*)value);
}
inline static int32_t get_offset_of_keyCode_3() { return static_cast<int32_t>(offsetof(SpeechCommands_tB5EB0ECFA6A91657370C348F8F7862ADC9AE44EB, ___keyCode_3)); }
inline int32_t get_keyCode_3() const { return ___keyCode_3; }
inline int32_t* get_address_of_keyCode_3() { return &___keyCode_3; }
inline void set_keyCode_3(int32_t value)
{
___keyCode_3 = value;
}
inline static int32_t get_offset_of_action_4() { return static_cast<int32_t>(offsetof(SpeechCommands_tB5EB0ECFA6A91657370C348F8F7862ADC9AE44EB, ___action_4)); }
inline MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A get_action_4() const { return ___action_4; }
inline MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A * get_address_of_action_4() { return &___action_4; }
inline void set_action_4(MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A value)
{
___action_4 = value;
Il2CppCodeGenWriteBarrier((void**)&(((&___action_4))->___description_2), (void*)NULL);
}
};
// Native definition for P/Invoke marshalling of Microsoft.MixedReality.Toolkit.Input.SpeechCommands
struct SpeechCommands_tB5EB0ECFA6A91657370C348F8F7862ADC9AE44EB_marshaled_pinvoke
{
char* ___localizationKey_0;
char* ___localizedKeyword_1;
char* ___keyword_2;
int32_t ___keyCode_3;
MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A_marshaled_pinvoke ___action_4;
};
// Native definition for COM marshalling of Microsoft.MixedReality.Toolkit.Input.SpeechCommands
struct SpeechCommands_tB5EB0ECFA6A91657370C348F8F7862ADC9AE44EB_marshaled_com
{
Il2CppChar* ___localizationKey_0;
Il2CppChar* ___localizedKeyword_1;
Il2CppChar* ___keyword_2;
int32_t ___keyCode_3;
MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A_marshaled_com ___action_4;
};
// UnityEngine.XR.MagicLeap.MLAudio/Buffer
struct Buffer_t6C6476ADA463C6E32C9089029FA9EEBD44F0B2B8
{
public:
// System.IntPtr UnityEngine.XR.MagicLeap.MLAudio/Buffer::NativeDataPtr
intptr_t ___NativeDataPtr_0;
// System.UInt32 UnityEngine.XR.MagicLeap.MLAudio/Buffer::Size
uint32_t ___Size_1;
// System.Single[] UnityEngine.XR.MagicLeap.MLAudio/Buffer::Samples
SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA* ___Samples_2;
// UnityEngine.XR.MagicLeap.MLAudio/BufferFormat UnityEngine.XR.MagicLeap.MLAudio/Buffer::Format
BufferFormat_tE20F9A2217FC0F4787B114A37F0C6503F916FAE9 ___Format_3;
public:
inline static int32_t get_offset_of_NativeDataPtr_0() { return static_cast<int32_t>(offsetof(Buffer_t6C6476ADA463C6E32C9089029FA9EEBD44F0B2B8, ___NativeDataPtr_0)); }
inline intptr_t get_NativeDataPtr_0() const { return ___NativeDataPtr_0; }
inline intptr_t* get_address_of_NativeDataPtr_0() { return &___NativeDataPtr_0; }
inline void set_NativeDataPtr_0(intptr_t value)
{
___NativeDataPtr_0 = value;
}
inline static int32_t get_offset_of_Size_1() { return static_cast<int32_t>(offsetof(Buffer_t6C6476ADA463C6E32C9089029FA9EEBD44F0B2B8, ___Size_1)); }
inline uint32_t get_Size_1() const { return ___Size_1; }
inline uint32_t* get_address_of_Size_1() { return &___Size_1; }
inline void set_Size_1(uint32_t value)
{
___Size_1 = value;
}
inline static int32_t get_offset_of_Samples_2() { return static_cast<int32_t>(offsetof(Buffer_t6C6476ADA463C6E32C9089029FA9EEBD44F0B2B8, ___Samples_2)); }
inline SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA* get_Samples_2() const { return ___Samples_2; }
inline SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA** get_address_of_Samples_2() { return &___Samples_2; }
inline void set_Samples_2(SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA* value)
{
___Samples_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Samples_2), (void*)value);
}
inline static int32_t get_offset_of_Format_3() { return static_cast<int32_t>(offsetof(Buffer_t6C6476ADA463C6E32C9089029FA9EEBD44F0B2B8, ___Format_3)); }
inline BufferFormat_tE20F9A2217FC0F4787B114A37F0C6503F916FAE9 get_Format_3() const { return ___Format_3; }
inline BufferFormat_tE20F9A2217FC0F4787B114A37F0C6503F916FAE9 * get_address_of_Format_3() { return &___Format_3; }
inline void set_Format_3(BufferFormat_tE20F9A2217FC0F4787B114A37F0C6503F916FAE9 value)
{
___Format_3 = value;
}
};
struct Buffer_t6C6476ADA463C6E32C9089029FA9EEBD44F0B2B8_StaticFields
{
public:
// System.Collections.Generic.Dictionary`2<System.UInt32,System.Func`2<System.IntPtr,System.Single>> UnityEngine.XR.MagicLeap.MLAudio/Buffer::UnmanagedToFloat
Dictionary_2_t178D95092ECF265C706E3FC09C95B1DF57EFA43C * ___UnmanagedToFloat_4;
public:
inline static int32_t get_offset_of_UnmanagedToFloat_4() { return static_cast<int32_t>(offsetof(Buffer_t6C6476ADA463C6E32C9089029FA9EEBD44F0B2B8_StaticFields, ___UnmanagedToFloat_4)); }
inline Dictionary_2_t178D95092ECF265C706E3FC09C95B1DF57EFA43C * get_UnmanagedToFloat_4() const { return ___UnmanagedToFloat_4; }
inline Dictionary_2_t178D95092ECF265C706E3FC09C95B1DF57EFA43C ** get_address_of_UnmanagedToFloat_4() { return &___UnmanagedToFloat_4; }
inline void set_UnmanagedToFloat_4(Dictionary_2_t178D95092ECF265C706E3FC09C95B1DF57EFA43C * value)
{
___UnmanagedToFloat_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___UnmanagedToFloat_4), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MagicLeap.MLAudio/Buffer
struct Buffer_t6C6476ADA463C6E32C9089029FA9EEBD44F0B2B8_marshaled_pinvoke
{
intptr_t ___NativeDataPtr_0;
uint32_t ___Size_1;
Il2CppSafeArray/*NONE*/* ___Samples_2;
BufferFormat_tE20F9A2217FC0F4787B114A37F0C6503F916FAE9 ___Format_3;
};
// Native definition for COM marshalling of UnityEngine.XR.MagicLeap.MLAudio/Buffer
struct Buffer_t6C6476ADA463C6E32C9089029FA9EEBD44F0B2B8_marshaled_com
{
intptr_t ___NativeDataPtr_0;
uint32_t ___Size_1;
Il2CppSafeArray/*NONE*/* ___Samples_2;
BufferFormat_tE20F9A2217FC0F4787B114A37F0C6503F916FAE9 ___Format_3;
};
// UnityEngine.XR.MagicLeap.MLPlanes/NativeBindings/Query
struct Query_t81D4EF187177B9BBAA39D5798E5369A176FFA3E3
{
public:
// UnityEngine.XR.MagicLeap.MLPlanes/QueryResultsDelegate UnityEngine.XR.MagicLeap.MLPlanes/NativeBindings/Query::Callback
QueryResultsDelegate_t195F1788456C85C6008A57CA5D8806BB6C819599 * ___Callback_0;
// System.UInt32 UnityEngine.XR.MagicLeap.MLPlanes/NativeBindings/Query::MaxResults
uint32_t ___MaxResults_1;
// System.IntPtr UnityEngine.XR.MagicLeap.MLPlanes/NativeBindings/Query::PlanesResultsUnmanaged
intptr_t ___PlanesResultsUnmanaged_2;
// UnityEngine.XR.MagicLeap.MLPlanes/Plane[] UnityEngine.XR.MagicLeap.MLPlanes/NativeBindings/Query::Planes
PlaneU5BU5D_tDA0004DD30CE85D4657F29D2F513A9D13DBA5CC4* ___Planes_3;
// UnityEngine.XR.MagicLeap.MLPlanes/NativeBindings/BoundariesListNative UnityEngine.XR.MagicLeap.MLPlanes/NativeBindings/Query::PlaneBoundariesList
BoundariesListNative_t993026976BA61E4DBFE13483C88853F226856CA4 ___PlaneBoundariesList_4;
// UnityEngine.XR.MagicLeap.MLPlanes/Boundaries[] UnityEngine.XR.MagicLeap.MLPlanes/NativeBindings/Query::PlaneBoundaries
BoundariesU5BU5D_t0531CA96D172062A97850316ECA6C164BF6BBDE3* ___PlaneBoundaries_5;
// UnityEngine.XR.MagicLeap.MLResult UnityEngine.XR.MagicLeap.MLPlanes/NativeBindings/Query::Result
MLResult_t16167FAD492D3A6F53116897898D23453C72B635 ___Result_6;
// System.Boolean UnityEngine.XR.MagicLeap.MLPlanes/NativeBindings/Query::<IsRequestingBoundaries>k__BackingField
bool ___U3CIsRequestingBoundariesU3Ek__BackingField_7;
public:
inline static int32_t get_offset_of_Callback_0() { return static_cast<int32_t>(offsetof(Query_t81D4EF187177B9BBAA39D5798E5369A176FFA3E3, ___Callback_0)); }
inline QueryResultsDelegate_t195F1788456C85C6008A57CA5D8806BB6C819599 * get_Callback_0() const { return ___Callback_0; }
inline QueryResultsDelegate_t195F1788456C85C6008A57CA5D8806BB6C819599 ** get_address_of_Callback_0() { return &___Callback_0; }
inline void set_Callback_0(QueryResultsDelegate_t195F1788456C85C6008A57CA5D8806BB6C819599 * value)
{
___Callback_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Callback_0), (void*)value);
}
inline static int32_t get_offset_of_MaxResults_1() { return static_cast<int32_t>(offsetof(Query_t81D4EF187177B9BBAA39D5798E5369A176FFA3E3, ___MaxResults_1)); }
inline uint32_t get_MaxResults_1() const { return ___MaxResults_1; }
inline uint32_t* get_address_of_MaxResults_1() { return &___MaxResults_1; }
inline void set_MaxResults_1(uint32_t value)
{
___MaxResults_1 = value;
}
inline static int32_t get_offset_of_PlanesResultsUnmanaged_2() { return static_cast<int32_t>(offsetof(Query_t81D4EF187177B9BBAA39D5798E5369A176FFA3E3, ___PlanesResultsUnmanaged_2)); }
inline intptr_t get_PlanesResultsUnmanaged_2() const { return ___PlanesResultsUnmanaged_2; }
inline intptr_t* get_address_of_PlanesResultsUnmanaged_2() { return &___PlanesResultsUnmanaged_2; }
inline void set_PlanesResultsUnmanaged_2(intptr_t value)
{
___PlanesResultsUnmanaged_2 = value;
}
inline static int32_t get_offset_of_Planes_3() { return static_cast<int32_t>(offsetof(Query_t81D4EF187177B9BBAA39D5798E5369A176FFA3E3, ___Planes_3)); }
inline PlaneU5BU5D_tDA0004DD30CE85D4657F29D2F513A9D13DBA5CC4* get_Planes_3() const { return ___Planes_3; }
inline PlaneU5BU5D_tDA0004DD30CE85D4657F29D2F513A9D13DBA5CC4** get_address_of_Planes_3() { return &___Planes_3; }
inline void set_Planes_3(PlaneU5BU5D_tDA0004DD30CE85D4657F29D2F513A9D13DBA5CC4* value)
{
___Planes_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Planes_3), (void*)value);
}
inline static int32_t get_offset_of_PlaneBoundariesList_4() { return static_cast<int32_t>(offsetof(Query_t81D4EF187177B9BBAA39D5798E5369A176FFA3E3, ___PlaneBoundariesList_4)); }
inline BoundariesListNative_t993026976BA61E4DBFE13483C88853F226856CA4 get_PlaneBoundariesList_4() const { return ___PlaneBoundariesList_4; }
inline BoundariesListNative_t993026976BA61E4DBFE13483C88853F226856CA4 * get_address_of_PlaneBoundariesList_4() { return &___PlaneBoundariesList_4; }
inline void set_PlaneBoundariesList_4(BoundariesListNative_t993026976BA61E4DBFE13483C88853F226856CA4 value)
{
___PlaneBoundariesList_4 = value;
}
inline static int32_t get_offset_of_PlaneBoundaries_5() { return static_cast<int32_t>(offsetof(Query_t81D4EF187177B9BBAA39D5798E5369A176FFA3E3, ___PlaneBoundaries_5)); }
inline BoundariesU5BU5D_t0531CA96D172062A97850316ECA6C164BF6BBDE3* get_PlaneBoundaries_5() const { return ___PlaneBoundaries_5; }
inline BoundariesU5BU5D_t0531CA96D172062A97850316ECA6C164BF6BBDE3** get_address_of_PlaneBoundaries_5() { return &___PlaneBoundaries_5; }
inline void set_PlaneBoundaries_5(BoundariesU5BU5D_t0531CA96D172062A97850316ECA6C164BF6BBDE3* value)
{
___PlaneBoundaries_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___PlaneBoundaries_5), (void*)value);
}
inline static int32_t get_offset_of_Result_6() { return static_cast<int32_t>(offsetof(Query_t81D4EF187177B9BBAA39D5798E5369A176FFA3E3, ___Result_6)); }
inline MLResult_t16167FAD492D3A6F53116897898D23453C72B635 get_Result_6() const { return ___Result_6; }
inline MLResult_t16167FAD492D3A6F53116897898D23453C72B635 * get_address_of_Result_6() { return &___Result_6; }
inline void set_Result_6(MLResult_t16167FAD492D3A6F53116897898D23453C72B635 value)
{
___Result_6 = value;
Il2CppCodeGenWriteBarrier((void**)&(((&___Result_6))->___message_2), (void*)NULL);
}
inline static int32_t get_offset_of_U3CIsRequestingBoundariesU3Ek__BackingField_7() { return static_cast<int32_t>(offsetof(Query_t81D4EF187177B9BBAA39D5798E5369A176FFA3E3, ___U3CIsRequestingBoundariesU3Ek__BackingField_7)); }
inline bool get_U3CIsRequestingBoundariesU3Ek__BackingField_7() const { return ___U3CIsRequestingBoundariesU3Ek__BackingField_7; }
inline bool* get_address_of_U3CIsRequestingBoundariesU3Ek__BackingField_7() { return &___U3CIsRequestingBoundariesU3Ek__BackingField_7; }
inline void set_U3CIsRequestingBoundariesU3Ek__BackingField_7(bool value)
{
___U3CIsRequestingBoundariesU3Ek__BackingField_7 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.MagicLeap.MLPlanes/NativeBindings/Query
struct Query_t81D4EF187177B9BBAA39D5798E5369A176FFA3E3_marshaled_pinvoke
{
Il2CppMethodPointer ___Callback_0;
uint32_t ___MaxResults_1;
intptr_t ___PlanesResultsUnmanaged_2;
Plane_tC3C9B3B2357B4E474F4DBA0AB9E2E0A40E766287 * ___Planes_3;
BoundariesListNative_t993026976BA61E4DBFE13483C88853F226856CA4 ___PlaneBoundariesList_4;
Boundaries_t9D05C3A6C63A9D441F79E0E47B2E536E4A049694_marshaled_pinvoke* ___PlaneBoundaries_5;
MLResult_t16167FAD492D3A6F53116897898D23453C72B635_marshaled_pinvoke ___Result_6;
int32_t ___U3CIsRequestingBoundariesU3Ek__BackingField_7;
};
// Native definition for COM marshalling of UnityEngine.XR.MagicLeap.MLPlanes/NativeBindings/Query
struct Query_t81D4EF187177B9BBAA39D5798E5369A176FFA3E3_marshaled_com
{
Il2CppMethodPointer ___Callback_0;
uint32_t ___MaxResults_1;
intptr_t ___PlanesResultsUnmanaged_2;
Plane_tC3C9B3B2357B4E474F4DBA0AB9E2E0A40E766287 * ___Planes_3;
BoundariesListNative_t993026976BA61E4DBFE13483C88853F226856CA4 ___PlaneBoundariesList_4;
Boundaries_t9D05C3A6C63A9D441F79E0E47B2E536E4A049694_marshaled_com* ___PlaneBoundaries_5;
MLResult_t16167FAD492D3A6F53116897898D23453C72B635_marshaled_com ___Result_6;
int32_t ___U3CIsRequestingBoundariesU3Ek__BackingField_7;
};
// System.Collections.Generic.KeyValuePair`2<System.UInt64,UnityEngine.XR.MagicLeap.MLPlanes/NativeBindings/Query>
struct KeyValuePair_2_t026384B6AE08711321907CB77A1A7F9AC49EC053
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
uint64_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
Query_t81D4EF187177B9BBAA39D5798E5369A176FFA3E3 ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t026384B6AE08711321907CB77A1A7F9AC49EC053, ___key_0)); }
inline uint64_t get_key_0() const { return ___key_0; }
inline uint64_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(uint64_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t026384B6AE08711321907CB77A1A7F9AC49EC053, ___value_1)); }
inline Query_t81D4EF187177B9BBAA39D5798E5369A176FFA3E3 get_value_1() const { return ___value_1; }
inline Query_t81D4EF187177B9BBAA39D5798E5369A176FFA3E3 * get_address_of_value_1() { return &___value_1; }
inline void set_value_1(Query_t81D4EF187177B9BBAA39D5798E5369A176FFA3E3 value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)&(((&___value_1))->___Callback_0), (void*)NULL);
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&(((&___value_1))->___Planes_3), (void*)NULL);
#endif
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&(((&___value_1))->___PlaneBoundaries_5), (void*)NULL);
#endif
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&((&(((&___value_1))->___Result_6))->___message_2), (void*)NULL);
#endif
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
static KeyValuePair_2_t174DCFB8AAA63D8A6758035BD4B81EDA4A4A7957 UnresolvedVirtualCall_0 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t4C06AD7A4B066AA7DEB169481DEE9B0F19B74AF4 UnresolvedVirtualCall_1 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t199D25DC5B4AEC9DE9D3DF1C79A0E1EC4FC9D750 UnresolvedVirtualCall_2 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t7DD7DA129ACC317FEC6BA4C4AFB8531E3BD44B8F UnresolvedVirtualCall_3 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_tB6ECB423D6D4B3D2F916E061DDF9A7C3F0958D57 UnresolvedVirtualCall_4 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_tB6ECB423D6D4B3D2F916E061DDF9A7C3F0958D57 UnresolvedVirtualCall_5 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_tCD5866451146985D9716EA94548482C8AC3F7569 UnresolvedVirtualCall_6 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_tCD5866451146985D9716EA94548482C8AC3F7569 UnresolvedVirtualCall_7 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t239694BB713649B9F5326D1A5BC3143EA54316B3 UnresolvedVirtualCall_8 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t1E4C4AAA2E07F40196F2EBEC29A6D137D0A9D265 UnresolvedVirtualCall_9 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_tE78AD78874BCE1BC993F92EF8CBBDC3B30E44CBB UnresolvedVirtualCall_10 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_tE8FA5EF9EFE23FF7AB54968FA25D3487B37D4D28 UnresolvedVirtualCall_11 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t56E20A5489EE435FD8BBE3EFACF6219A626E04C0 UnresolvedVirtualCall_12 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_tDD55E6C6020C20298FD24189CC4023F8D8751975 UnresolvedVirtualCall_13 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_tAD021667BA62C6C3CEE28B2A5D24AF5111FC8095 UnresolvedVirtualCall_14 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t35D22D0A0BCEE8A48032CF74DA9E44BEA074DC19 UnresolvedVirtualCall_15 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t35D22D0A0BCEE8A48032CF74DA9E44BEA074DC19 UnresolvedVirtualCall_16 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_tF35DAECB86CC92713433F8BD088E96D5A05E579D UnresolvedVirtualCall_17 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_tB857CDE0014FDA4A1BC9392C7A05FC222849182C UnresolvedVirtualCall_18 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_tB66ECE31A5BAEA562A3BC1EA1A3743D178A5C5D5 UnresolvedVirtualCall_19 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t9CFCF96A7E2633151295BA93C1343297C5B91BAF UnresolvedVirtualCall_20 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t83B2885C02C836E233B38F12A0F13CDC8DBE3ED1 UnresolvedVirtualCall_21 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t981AE20097B6314BF8A205CF34ECF3A7E18B66DA UnresolvedVirtualCall_22 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_tDEBAC4204942613BBD810AE61B8879E16B16BE22 UnresolvedVirtualCall_23 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t8EB09BF4DD251CCCBB6F85C46B29153BF9822DA2 UnresolvedVirtualCall_24 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_tFA1E33986669B6C16376F3660D38C9BF819BEC55 UnresolvedVirtualCall_25 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t3BC076473466AB05F302E530F4A4392A6E94A7BC UnresolvedVirtualCall_26 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t8E89E9D1B769A568C239665DE81AF65F368CE31D UnresolvedVirtualCall_27 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_tF48C056DF83BF9AF3BAE277B149EC5E4E436BD1A UnresolvedVirtualCall_28 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t95507C2A8401F2191EE3D308B1B00E3729AE41B5 UnresolvedVirtualCall_29 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_tB240266E51130B1787D14A384667BB023D3E2BE8 UnresolvedVirtualCall_30 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625 UnresolvedVirtualCall_31 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625 UnresolvedVirtualCall_32 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t6A417393575389EF0D895B62580FBC33E95066EF UnresolvedVirtualCall_33 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t2FBC235D01262BC0B3F17DADD97D977EFD0AE4D1 UnresolvedVirtualCall_34 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t0BDEBB7E26082FCC604A0CE9B29AB0FCE1140700 UnresolvedVirtualCall_35 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t08B9657641C90B74353E46A763B776CE57CCE823 UnresolvedVirtualCall_36 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t8DD96E477F1D2D68A18ABD57FEB017DFFF8A58B2 UnresolvedVirtualCall_37 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t504EC26DD47F99A8C06286072D44FAA1ABD0CD93 UnresolvedVirtualCall_38 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t1C899E1D384EB1A82B398076E49CE2B74F0CE329 UnresolvedVirtualCall_39 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_tCEEEA2545C9572EC331DBB69871921A5B01E60DA UnresolvedVirtualCall_40 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_tD4BF07211CB64F83F284ECDF1B2D43A7CA28E512 UnresolvedVirtualCall_41 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_tE732F29FAAE8258AADE79971F5F981B5A975E69F UnresolvedVirtualCall_42 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t3099483093B475AC1712E315486784320D93D045 UnresolvedVirtualCall_43 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t78B694E8342E86089FB515D21C3CB9F12838A5CB UnresolvedVirtualCall_44 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_tB8C085DAB5BB6A37255E0F93DBDCB70456DA2703 UnresolvedVirtualCall_45 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t026384B6AE08711321907CB77A1A7F9AC49EC053 UnresolvedVirtualCall_46 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_tA9C4AF92A1B6458C47F72B185C784D3A4801B345 UnresolvedVirtualCall_47 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t7C40DFD3E4598A1814263BCC6543EBD170B7664D UnresolvedVirtualCall_48 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_t4EFD7904997EA402D1CAF1AF8E029EEDF23B8E5E UnresolvedVirtualCall_49 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static KeyValuePair_2_tCBAAE4FBE6091373C1916EE17527311382CF4551 UnresolvedVirtualCall_50 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Nullable_1_t1D1CD146BFCBDC2E53E1F700889F8C5C21063EF3 UnresolvedVirtualCall_51 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Nullable_1_t864FD0051A05D37F91C857AB496BFCB3FE756103 UnresolvedVirtualCall_52 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Bone_t8EDF2FA2139528015195AF2EA866A28947C3F070 UnresolvedVirtualCall_53 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Bone_t8EDF2FA2139528015195AF2EA866A28947C3F070 UnresolvedVirtualCall_54 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Bounds_t0F1F36D4F7AF49524B3C2A2259594412A3D3AE37 UnresolvedVirtualCall_55 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static uint8_t UnresolvedVirtualCall_56 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static uint8_t UnresolvedVirtualCall_57 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static uint8_t UnresolvedVirtualCall_58 (RuntimeObject * __this, RuntimeObject * ___Object1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 UnresolvedVirtualCall_59 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 UnresolvedVirtualCall_60 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 UnresolvedVirtualCall_61 (RuntimeObject * __this, float ___Single1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D UnresolvedVirtualCall_62 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D UnresolvedVirtualCall_63 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static ConsoleKeyInfo_tDA8AC07839288484FCB167A81B4FBA92ECCEAF88 UnresolvedVirtualCall_64 (RuntimeObject * __this, int8_t ___SByte1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static CustomAttributeNamedArgument_t618778691CF7F5B44F7177210A817A29D3DAEDDA UnresolvedVirtualCall_65 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static CustomAttributeTypedArgument_tE7152E8FACDD29A8E0040E151C86F436FA8E6910 UnresolvedVirtualCall_66 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 UnresolvedVirtualCall_67 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 UnresolvedVirtualCall_68 (RuntimeObject * __this, int32_t ___Int321, int32_t ___Int322, int32_t ___Int323, int32_t ___Int324, int32_t ___Int325, int32_t ___Int326, int32_t ___Int327, int32_t ___Int328, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 UnresolvedVirtualCall_69 (RuntimeObject * __this, RuntimeObject * ___Object1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 UnresolvedVirtualCall_70 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Decimal_t2978B229CA86D3B7BA66A0AEEE014E0DE4F940D7 UnresolvedVirtualCall_71 (RuntimeObject * __this, RuntimeObject * ___Object1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static DictionaryEntry_tF60471FAB430320A9C7D4382BF966EAAC06D7A90 UnresolvedVirtualCall_72 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static double UnresolvedVirtualCall_73 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static double UnresolvedVirtualCall_74 (RuntimeObject * __this, RuntimeObject * ___Object1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Edge_t9E8220DAC70F321BE68E4872C23B5F4AC8A5E2EE UnresolvedVirtualCall_75 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Edge_t9E8220DAC70F321BE68E4872C23B5F4AC8A5E2EE UnresolvedVirtualCall_76 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static FocusDetails_t9D9111B483D3807234CD405067A29099A79620DA UnresolvedVirtualCall_77 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static GlyphRect_t4F6A791326A28C2CEC6B13B0BD50A4F78280289D UnresolvedVirtualCall_78 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static GlyphRect_t4F6A791326A28C2CEC6B13B0BD50A4F78280289D UnresolvedVirtualCall_79 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Guid_t UnresolvedVirtualCall_80 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E UnresolvedVirtualCall_81 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E UnresolvedVirtualCall_82 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032 UnresolvedVirtualCall_83 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032 UnresolvedVirtualCall_84 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int16_t UnresolvedVirtualCall_85 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int16_t UnresolvedVirtualCall_86 (RuntimeObject * __this, int16_t ___Int161, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int16_t UnresolvedVirtualCall_87 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int16_t UnresolvedVirtualCall_88 (RuntimeObject * __this, RuntimeObject * ___Object1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int16_t UnresolvedVirtualCall_89 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, int16_t ___Int163, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int16_t UnresolvedVirtualCall_90 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, int16_t ___Int163, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int16_t UnresolvedVirtualCall_91 (RuntimeObject * __this, uint16_t ___UInt161, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_92 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_93 (RuntimeObject * __this, KeyValuePair_2_tB6ECB423D6D4B3D2F916E061DDF9A7C3F0958D57 ___KeyValuePair_21, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_94 (RuntimeObject * __this, KeyValuePair_2_tB6ECB423D6D4B3D2F916E061DDF9A7C3F0958D57 ___KeyValuePair_21, KeyValuePair_2_tB6ECB423D6D4B3D2F916E061DDF9A7C3F0958D57 ___KeyValuePair_22, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_95 (RuntimeObject * __this, KeyValuePair_2_tCD5866451146985D9716EA94548482C8AC3F7569 ___KeyValuePair_21, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_96 (RuntimeObject * __this, KeyValuePair_2_t35D22D0A0BCEE8A48032CF74DA9E44BEA074DC19 ___KeyValuePair_21, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_97 (RuntimeObject * __this, KeyValuePair_2_t35D22D0A0BCEE8A48032CF74DA9E44BEA074DC19 ___KeyValuePair_21, KeyValuePair_2_t35D22D0A0BCEE8A48032CF74DA9E44BEA074DC19 ___KeyValuePair_22, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_98 (RuntimeObject * __this, KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625 ___KeyValuePair_21, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_99 (RuntimeObject * __this, KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625 ___KeyValuePair_21, KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625 ___KeyValuePair_22, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_100 (RuntimeObject * __this, Nullable_1_t1829213F3538788DF79B4659AFC9D6A9C90C3258 ___Nullable_11, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_101 (RuntimeObject * __this, Bone_t8EDF2FA2139528015195AF2EA866A28947C3F070 ___Bone1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_102 (RuntimeObject * __this, Bone_t8EDF2FA2139528015195AF2EA866A28947C3F070 ___Bone1, Bone_t8EDF2FA2139528015195AF2EA866A28947C3F070 ___Bone2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_103 (RuntimeObject * __this, BoundedPlane_t9001963C43ACDF4CDEA8BBF97CD783B7969B79C5 ___BoundedPlane1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_104 (RuntimeObject * __this, Bounds_t0F1F36D4F7AF49524B3C2A2259594412A3D3AE37 ___Bounds1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_105 (RuntimeObject * __this, uint8_t ___Byte1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_106 (RuntimeObject * __this, uint8_t ___Byte1, uint8_t ___Byte2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_107 (RuntimeObject * __this, Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 ___Color1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_108 (RuntimeObject * __this, Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 ___Color1, Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 ___Color2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_109 (RuntimeObject * __this, Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D ___Color321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_110 (RuntimeObject * __this, Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D ___Color321, Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D ___Color322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_111 (RuntimeObject * __this, ColorBlock_t04DFBB97B4772D2E00FD17ED2E3E6590E6916955 ___ColorBlock1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_112 (RuntimeObject * __this, ComparableRaycastResult_tACF79BA2E300399251DFA7C2D1E633E8F0C3062D ___ComparableRaycastResult1, ComparableRaycastResult_tACF79BA2E300399251DFA7C2D1E633E8F0C3062D ___ComparableRaycastResult2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_113 (RuntimeObject * __this, CustomAttributeNamedArgument_t618778691CF7F5B44F7177210A817A29D3DAEDDA ___CustomAttributeNamedArgument1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_114 (RuntimeObject * __this, CustomAttributeTypedArgument_tE7152E8FACDD29A8E0040E151C86F436FA8E6910 ___CustomAttributeTypedArgument1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_115 (RuntimeObject * __this, DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 ___DateTime1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_116 (RuntimeObject * __this, DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 ___DateTime1, int32_t ___Int322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_117 (RuntimeObject * __this, Edge_t9E8220DAC70F321BE68E4872C23B5F4AC8A5E2EE ___Edge1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_118 (RuntimeObject * __this, Edge_t9E8220DAC70F321BE68E4872C23B5F4AC8A5E2EE ___Edge1, Edge_t9E8220DAC70F321BE68E4872C23B5F4AC8A5E2EE ___Edge2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_119 (RuntimeObject * __this, GlyphRect_t4F6A791326A28C2CEC6B13B0BD50A4F78280289D ___GlyphRect1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_120 (RuntimeObject * __this, GlyphRect_t4F6A791326A28C2CEC6B13B0BD50A4F78280289D ___GlyphRect1, GlyphRect_t4F6A791326A28C2CEC6B13B0BD50A4F78280289D ___GlyphRect2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_121 (RuntimeObject * __this, InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E ___InputDevice1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_122 (RuntimeObject * __this, InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E ___InputDevice1, InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E ___InputDevice2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_123 (RuntimeObject * __this, InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032 ___InspectorPropertySetting1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_124 (RuntimeObject * __this, InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032 ___InspectorPropertySetting1, InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032 ___InspectorPropertySetting2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_125 (RuntimeObject * __this, int16_t ___Int161, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_126 (RuntimeObject * __this, int16_t ___Int161, int16_t ___Int162, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_127 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_128 (RuntimeObject * __this, int32_t ___Int321, int32_t ___Int322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_129 (RuntimeObject * __this, int32_t ___Int321, int32_t ___Int322, int32_t ___Int323, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_130 (RuntimeObject * __this, int64_t ___Int641, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_131 (RuntimeObject * __this, int64_t ___Int641, int32_t ___Int322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_132 (RuntimeObject * __this, intptr_t ___IntPtr1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_133 (RuntimeObject * __this, MLResult_t16167FAD492D3A6F53116897898D23453C72B635 ___MLResult1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_134 (RuntimeObject * __this, Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461 ___Matrix4x41, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_135 (RuntimeObject * __this, Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461 ___Matrix4x41, Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461 ___Matrix4x42, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_136 (RuntimeObject * __this, MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 ___MeshId1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_137 (RuntimeObject * __this, MeshInfo_tD0E09CA3A2260A509C063BF0C8FDAC8D138FC611 ___MeshInfo1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_138 (RuntimeObject * __this, MeshInfo_tD0E09CA3A2260A509C063BF0C8FDAC8D138FC611 ___MeshInfo1, MeshInfo_tD0E09CA3A2260A509C063BF0C8FDAC8D138FC611 ___MeshInfo2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_139 (RuntimeObject * __this, MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A ___MixedRealityInputAction1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_140 (RuntimeObject * __this, MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A ___MixedRealityInputAction1, MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A ___MixedRealityInputAction2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_141 (RuntimeObject * __this, MixedRealityPose_t9A27AAE05672995793F76985CE167AA85B8DF5AF ___MixedRealityPose1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_142 (RuntimeObject * __this, Navigation_t1CF0FFB22C0357CD64714FB7A40A275F899D363A ___Navigation1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_143 (RuntimeObject * __this, RuntimeObject * ___Object1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_144 (RuntimeObject * __this, RuntimeObject * ___Object1, KeyValuePair_2_tB6ECB423D6D4B3D2F916E061DDF9A7C3F0958D57 ___KeyValuePair_22, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_145 (RuntimeObject * __this, RuntimeObject * ___Object1, KeyValuePair_2_t35D22D0A0BCEE8A48032CF74DA9E44BEA074DC19 ___KeyValuePair_22, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_146 (RuntimeObject * __this, RuntimeObject * ___Object1, KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625 ___KeyValuePair_22, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_147 (RuntimeObject * __this, RuntimeObject * ___Object1, Bone_t8EDF2FA2139528015195AF2EA866A28947C3F070 ___Bone2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_148 (RuntimeObject * __this, RuntimeObject * ___Object1, uint8_t ___Byte2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_149 (RuntimeObject * __this, RuntimeObject * ___Object1, Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 ___Color2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_150 (RuntimeObject * __this, RuntimeObject * ___Object1, Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D ___Color322, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_151 (RuntimeObject * __this, RuntimeObject * ___Object1, Edge_t9E8220DAC70F321BE68E4872C23B5F4AC8A5E2EE ___Edge2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_152 (RuntimeObject * __this, RuntimeObject * ___Object1, GlyphRect_t4F6A791326A28C2CEC6B13B0BD50A4F78280289D ___GlyphRect2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_153 (RuntimeObject * __this, RuntimeObject * ___Object1, InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E ___InputDevice2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_154 (RuntimeObject * __this, RuntimeObject * ___Object1, InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032 ___InspectorPropertySetting2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_155 (RuntimeObject * __this, RuntimeObject * ___Object1, int16_t ___Int162, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_156 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_157 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, int32_t ___Int323, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_158 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_159 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, int32_t ___Int323, RuntimeObject * ___Object4, int32_t ___Int325, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_160 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, int32_t ___Int323, RuntimeObject * ___Object4, int32_t ___Int325, int32_t ___Int326, int32_t ___Int327, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_161 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, int32_t ___Int323, RuntimeObject * ___Object4, int32_t ___Int325, int8_t ___SByte6, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_162 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, int32_t ___Int323, int8_t ___SByte4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_163 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, RuntimeObject * ___Object3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_164 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, RuntimeObject * ___Object3, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_165 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, RuntimeObject * ___Object3, int32_t ___Int324, RuntimeObject * ___Object5, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_166 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, RuntimeObject * ___Object3, int32_t ___Int324, int8_t ___SByte5, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_167 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, int8_t ___SByte3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_168 (RuntimeObject * __this, RuntimeObject * ___Object1, Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461 ___Matrix4x42, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_169 (RuntimeObject * __this, RuntimeObject * ___Object1, MeshInfo_tD0E09CA3A2260A509C063BF0C8FDAC8D138FC611 ___MeshInfo2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_170 (RuntimeObject * __this, RuntimeObject * ___Object1, MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A ___MixedRealityInputAction2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_171 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_172 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, int32_t ___Int323, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_173 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_174 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, int32_t ___Int323, int32_t ___Int324, int32_t ___Int325, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_175 (RuntimeObject * __this, RuntimeObject * ___Object1, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___Ray2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_176 (RuntimeObject * __this, RuntimeObject * ___Object1, RaycastHit2D_t210878DAEBC96C1F69DF9883C454758724A106A4 ___RaycastHit2D2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_177 (RuntimeObject * __this, RuntimeObject * ___Object1, RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE ___RaycastResult2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_178 (RuntimeObject * __this, RuntimeObject * ___Object1, ReferenceFrame_tBC495D5CFA603EF6EF00A76250162F12F4293A9D ___ReferenceFrame2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_179 (RuntimeObject * __this, RuntimeObject * ___Object1, Scene_t5495AD2FDC587DB2E94D9BDE2B85868BFB9A92EE ___Scene2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_180 (RuntimeObject * __this, RuntimeObject * ___Object1, SceneInfo_t12CFA6F7D90C190B2C869FD43C885339A250C3FD ___SceneInfo2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_181 (RuntimeObject * __this, RuntimeObject * ___Object1, ShaderProperties_t780424B677AA69C9E9434368B245AF8CF867FD44 ___ShaderProperties2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_182 (RuntimeObject * __this, RuntimeObject * ___Object1, float ___Single2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_183 (RuntimeObject * __this, RuntimeObject * ___Object1, ThemeDefinition_tDC1C1DE1B953BC552C4A4D956F12537CC94E400E ___ThemeDefinition2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_184 (RuntimeObject * __this, RuntimeObject * ___Object1, TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B ___TrackableId2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_185 (RuntimeObject * __this, RuntimeObject * ___Object1, UICharInfo_tDEA65B831FAD06D1E9B10A6088E05C6D615B089A ___UICharInfo2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_186 (RuntimeObject * __this, RuntimeObject * ___Object1, UILineInfo_tD082FF4894030AD4EBF57ACF6A997135E4B8B67C ___UILineInfo2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_187 (RuntimeObject * __this, RuntimeObject * ___Object1, UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A ___UIVertex2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_188 (RuntimeObject * __this, RuntimeObject * ___Object1, uint32_t ___UInt322, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_189 (RuntimeObject * __this, RuntimeObject * ___Object1, uint64_t ___UInt642, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_190 (RuntimeObject * __this, RuntimeObject * ___Object1, Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___Vector22, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_191 (RuntimeObject * __this, RuntimeObject * ___Object1, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector32, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_192 (RuntimeObject * __this, RuntimeObject * ___Object1, Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 ___Vector42, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_193 (RuntimeObject * __this, RuntimeObject * ___Object1, XRNodeState_t6DC58D0C1BF2C4323D16B3905FDBEE7C03E27D33 ___XRNodeState2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_194 (RuntimeObject * __this, RuntimeObject * ___Object1, XRReferenceImage_tB1803A72EB581FB35B2CA944973679132A1D4467 ___XRReferenceImage2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_195 (RuntimeObject * __this, RuntimeObject * ___Object1, EventHandlerEntry_tD4B30F35FCE99CEB4F1BFF88A3F5FA0407C3C927 ___EventHandlerEntry2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_196 (RuntimeObject * __this, RuntimeObject * ___Object1, OrderBlock_t0B106828F588BC2F0B9895425E6FD39EDA45C1E2 ___OrderBlock2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_197 (RuntimeObject * __this, RuntimeObject * ___Object1, RenderRequest_t7DEDFA6AAA1C8D381280183054C328F26BBCCE94 ___RenderRequest2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_198 (RuntimeObject * __this, RuntimeObject * ___Object1, BlocksAndRenderer_tF583D143167DBC0C9BA5575BCE054D11CD059F0C ___BlocksAndRenderer2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_199 (RuntimeObject * __this, RuntimeObject * ___Object1, Descriptor_t369955C9D183FE09E69BB860543789ACE71BFBF3 ___Descriptor2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_200 (RuntimeObject * __this, RuntimeObject * ___Object1, RaycastHitData_tC9D839911FFA6A7160E7E0DBD8DF17D78FCEBA6F ___RaycastHitData2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_201 (RuntimeObject * __this, RuntimeObject * ___Object1, Frame_t277B57D2C572A3B179CEA0357869DB245F52128D ___Frame2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_202 (RuntimeObject * __this, RuntimeObject * ___Object1, PoseData_t3F5C8C74C50A6ECAE42890BBEF683882DB4E97C3 ___PoseData2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_203 (RuntimeObject * __this, RuntimeObject * ___Object1, WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393 ___WorkRequest2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_204 (RuntimeObject * __this, RuntimeObject * ___Object1, QueuedCallback_tEF82DE1B0127F3722835BFB0ABC1D2280C6278D2 ___QueuedCallback2, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_205 (RuntimeObject * __this, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___Ray1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_206 (RuntimeObject * __this, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___Ray1, RuntimeObject * ___Object2, float ___Single3, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_207 (RuntimeObject * __this, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___Ray1, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___Ray2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_208 (RuntimeObject * __this, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 ___RaycastHit1, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 ___RaycastHit2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_209 (RuntimeObject * __this, RaycastHit2D_t210878DAEBC96C1F69DF9883C454758724A106A4 ___RaycastHit2D1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_210 (RuntimeObject * __this, RaycastHit2D_t210878DAEBC96C1F69DF9883C454758724A106A4 ___RaycastHit2D1, RaycastHit2D_t210878DAEBC96C1F69DF9883C454758724A106A4 ___RaycastHit2D2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_211 (RuntimeObject * __this, RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE ___RaycastResult1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_212 (RuntimeObject * __this, RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE ___RaycastResult1, RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE ___RaycastResult2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_213 (RuntimeObject * __this, ReferenceFrame_tBC495D5CFA603EF6EF00A76250162F12F4293A9D ___ReferenceFrame1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_214 (RuntimeObject * __this, ReferenceFrame_tBC495D5CFA603EF6EF00A76250162F12F4293A9D ___ReferenceFrame1, ReferenceFrame_tBC495D5CFA603EF6EF00A76250162F12F4293A9D ___ReferenceFrame2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_215 (RuntimeObject * __this, ResourceLocator_t3D496606F94367D5D6B24DA9DC0A3B46E6B53B11 ___ResourceLocator1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_216 (RuntimeObject * __this, int8_t ___SByte1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_217 (RuntimeObject * __this, Scene_t5495AD2FDC587DB2E94D9BDE2B85868BFB9A92EE ___Scene1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_218 (RuntimeObject * __this, Scene_t5495AD2FDC587DB2E94D9BDE2B85868BFB9A92EE ___Scene1, Scene_t5495AD2FDC587DB2E94D9BDE2B85868BFB9A92EE ___Scene2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_219 (RuntimeObject * __this, SceneInfo_t12CFA6F7D90C190B2C869FD43C885339A250C3FD ___SceneInfo1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_220 (RuntimeObject * __this, SceneInfo_t12CFA6F7D90C190B2C869FD43C885339A250C3FD ___SceneInfo1, SceneInfo_t12CFA6F7D90C190B2C869FD43C885339A250C3FD ___SceneInfo2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_221 (RuntimeObject * __this, ShaderProperties_t780424B677AA69C9E9434368B245AF8CF867FD44 ___ShaderProperties1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_222 (RuntimeObject * __this, ShaderProperties_t780424B677AA69C9E9434368B245AF8CF867FD44 ___ShaderProperties1, ShaderProperties_t780424B677AA69C9E9434368B245AF8CF867FD44 ___ShaderProperties2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_223 (RuntimeObject * __this, float ___Single1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_224 (RuntimeObject * __this, float ___Single1, float ___Single2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_225 (RuntimeObject * __this, SpriteState_t9024961148433175CE2F3D9E8E9239A8B1CAB15E ___SpriteState1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_226 (RuntimeObject * __this, ThemeDefinition_tDC1C1DE1B953BC552C4A4D956F12537CC94E400E ___ThemeDefinition1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_227 (RuntimeObject * __this, ThemeDefinition_tDC1C1DE1B953BC552C4A4D956F12537CC94E400E ___ThemeDefinition1, ThemeDefinition_tDC1C1DE1B953BC552C4A4D956F12537CC94E400E ___ThemeDefinition2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_228 (RuntimeObject * __this, TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B ___TrackableId1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_229 (RuntimeObject * __this, TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B ___TrackableId1, TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B ___TrackableId2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_230 (RuntimeObject * __this, UICharInfo_tDEA65B831FAD06D1E9B10A6088E05C6D615B089A ___UICharInfo1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_231 (RuntimeObject * __this, UICharInfo_tDEA65B831FAD06D1E9B10A6088E05C6D615B089A ___UICharInfo1, UICharInfo_tDEA65B831FAD06D1E9B10A6088E05C6D615B089A ___UICharInfo2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_232 (RuntimeObject * __this, UILineInfo_tD082FF4894030AD4EBF57ACF6A997135E4B8B67C ___UILineInfo1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_233 (RuntimeObject * __this, UILineInfo_tD082FF4894030AD4EBF57ACF6A997135E4B8B67C ___UILineInfo1, UILineInfo_tD082FF4894030AD4EBF57ACF6A997135E4B8B67C ___UILineInfo2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_234 (RuntimeObject * __this, UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A ___UIVertex1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_235 (RuntimeObject * __this, UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A ___UIVertex1, UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A ___UIVertex2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_236 (RuntimeObject * __this, uint32_t ___UInt321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_237 (RuntimeObject * __this, uint32_t ___UInt321, uint32_t ___UInt322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_238 (RuntimeObject * __this, uint64_t ___UInt641, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_239 (RuntimeObject * __this, uint64_t ___UInt641, uint64_t ___UInt642, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_240 (RuntimeObject * __this, Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___Vector21, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_241 (RuntimeObject * __this, Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___Vector21, Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___Vector22, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_242 (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector31, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_243 (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector31, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector32, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_244 (RuntimeObject * __this, Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 ___Vector41, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_245 (RuntimeObject * __this, Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 ___Vector41, Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 ___Vector42, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_246 (RuntimeObject * __this, XRNodeState_t6DC58D0C1BF2C4323D16B3905FDBEE7C03E27D33 ___XRNodeState1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_247 (RuntimeObject * __this, XRNodeState_t6DC58D0C1BF2C4323D16B3905FDBEE7C03E27D33 ___XRNodeState1, XRNodeState_t6DC58D0C1BF2C4323D16B3905FDBEE7C03E27D33 ___XRNodeState2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_248 (RuntimeObject * __this, XRReferenceImage_tB1803A72EB581FB35B2CA944973679132A1D4467 ___XRReferenceImage1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_249 (RuntimeObject * __this, XRReferenceImage_tB1803A72EB581FB35B2CA944973679132A1D4467 ___XRReferenceImage1, XRReferenceImage_tB1803A72EB581FB35B2CA944973679132A1D4467 ___XRReferenceImage2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_250 (RuntimeObject * __this, AudioLoFiFilterSettings_t5EC9A0E1CF4DFFC4BA58E1DF6D4E880F9404B0A8 ___AudioLoFiFilterSettings1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_251 (RuntimeObject * __this, EventHandlerEntry_tD4B30F35FCE99CEB4F1BFF88A3F5FA0407C3C927 ___EventHandlerEntry1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_252 (RuntimeObject * __this, EventHandlerEntry_tD4B30F35FCE99CEB4F1BFF88A3F5FA0407C3C927 ___EventHandlerEntry1, EventHandlerEntry_tD4B30F35FCE99CEB4F1BFF88A3F5FA0407C3C927 ___EventHandlerEntry2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_253 (RuntimeObject * __this, OrderBlock_t0B106828F588BC2F0B9895425E6FD39EDA45C1E2 ___OrderBlock1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_254 (RuntimeObject * __this, OrderBlock_t0B106828F588BC2F0B9895425E6FD39EDA45C1E2 ___OrderBlock1, OrderBlock_t0B106828F588BC2F0B9895425E6FD39EDA45C1E2 ___OrderBlock2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_255 (RuntimeObject * __this, RenderRequest_t7DEDFA6AAA1C8D381280183054C328F26BBCCE94 ___RenderRequest1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_256 (RuntimeObject * __this, RenderRequest_t7DEDFA6AAA1C8D381280183054C328F26BBCCE94 ___RenderRequest1, RenderRequest_t7DEDFA6AAA1C8D381280183054C328F26BBCCE94 ___RenderRequest2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_257 (RuntimeObject * __this, BlocksAndRenderer_tF583D143167DBC0C9BA5575BCE054D11CD059F0C ___BlocksAndRenderer1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_258 (RuntimeObject * __this, BlocksAndRenderer_tF583D143167DBC0C9BA5575BCE054D11CD059F0C ___BlocksAndRenderer1, BlocksAndRenderer_tF583D143167DBC0C9BA5575BCE054D11CD059F0C ___BlocksAndRenderer2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_259 (RuntimeObject * __this, Descriptor_t369955C9D183FE09E69BB860543789ACE71BFBF3 ___Descriptor1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_260 (RuntimeObject * __this, Descriptor_t369955C9D183FE09E69BB860543789ACE71BFBF3 ___Descriptor1, Descriptor_t369955C9D183FE09E69BB860543789ACE71BFBF3 ___Descriptor2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_261 (RuntimeObject * __this, OAuthPair_t6862D91D872AA10E48A8FFB13C4B2D677ACE6FC0 ___OAuthPair1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_262 (RuntimeObject * __this, RaycastHitData_tC9D839911FFA6A7160E7E0DBD8DF17D78FCEBA6F ___RaycastHitData1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_263 (RuntimeObject * __this, RaycastHitData_tC9D839911FFA6A7160E7E0DBD8DF17D78FCEBA6F ___RaycastHitData1, RaycastHitData_tC9D839911FFA6A7160E7E0DBD8DF17D78FCEBA6F ___RaycastHitData2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_264 (RuntimeObject * __this, TrackData_tDCFE71C8D16AD063EF76BBC09C03F3FB3FD1B7BF ___TrackData1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_265 (RuntimeObject * __this, MLCoordinateFrameUID_t7ADFCEC93CA8B3DDFB41EC8157D03B51D0611AC9 ___MLCoordinateFrameUID1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_266 (RuntimeObject * __this, PointerData_tC90DB32A4F2EF1FC975FEAE81DE66BC21FE1351F ___PointerData1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_267 (RuntimeObject * __this, PointerData_t217FAEE1441F0ADC5F7B08E3987B1C08E48B7DD4 ___PointerData1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_268 (RuntimeObject * __this, Frame_t277B57D2C572A3B179CEA0357869DB245F52128D ___Frame1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_269 (RuntimeObject * __this, Frame_t277B57D2C572A3B179CEA0357869DB245F52128D ___Frame1, Frame_t277B57D2C572A3B179CEA0357869DB245F52128D ___Frame2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_270 (RuntimeObject * __this, PoseData_t3F5C8C74C50A6ECAE42890BBEF683882DB4E97C3 ___PoseData1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_271 (RuntimeObject * __this, PoseData_t3F5C8C74C50A6ECAE42890BBEF683882DB4E97C3 ___PoseData1, PoseData_t3F5C8C74C50A6ECAE42890BBEF683882DB4E97C3 ___PoseData2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_272 (RuntimeObject * __this, WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393 ___WorkRequest1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_273 (RuntimeObject * __this, WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393 ___WorkRequest1, WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393 ___WorkRequest2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_274 (RuntimeObject * __this, MLArucoTrackerResultNative_t6B156A863352A63682C2FE6AA83A77F9B36435CA ___MLArucoTrackerResultNative1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_275 (RuntimeObject * __this, QueuedCallback_tEF82DE1B0127F3722835BFB0ABC1D2280C6278D2 ___QueuedCallback1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_276 (RuntimeObject * __this, QueuedCallback_tEF82DE1B0127F3722835BFB0ABC1D2280C6278D2 ___QueuedCallback1, QueuedCallback_tEF82DE1B0127F3722835BFB0ABC1D2280C6278D2 ___QueuedCallback2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_277 (RuntimeObject * __this, Query_t81D4EF187177B9BBAA39D5798E5369A176FFA3E3 ___Query1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_278 (RuntimeObject * __this, MLRaycastResultNative_tDA46F1834D203F71E2FC259B44817E02F85FCA90 ___MLRaycastResultNative1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int32_t UnresolvedVirtualCall_279 (RuntimeObject * __this, TileCoord_t491EABF2B90DFB255C8F7624FF5528F2DE2CC901 ___TileCoord1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int64_t UnresolvedVirtualCall_280 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int64_t UnresolvedVirtualCall_281 (RuntimeObject * __this, int64_t ___Int641, int32_t ___Int322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int64_t UnresolvedVirtualCall_282 (RuntimeObject * __this, RuntimeObject * ___Object1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int64_t UnresolvedVirtualCall_283 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static intptr_t UnresolvedVirtualCall_284 (RuntimeObject * __this, RuntimeObject * ___Object1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static JobHandle_t8AEB8D31C25D7774C71D62B0C662525E6E36D847 UnresolvedVirtualCall_285 (RuntimeObject * __this, RuntimeObject * ___Object1, BatchCullingContext_t26E634F354C4F3915108C34A32FD32118FFE1F66 ___BatchCullingContext2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static MLResult_t16167FAD492D3A6F53116897898D23453C72B635 UnresolvedVirtualCall_286 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static MLResult_t16167FAD492D3A6F53116897898D23453C72B635 UnresolvedVirtualCall_287 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static MLResult_t16167FAD492D3A6F53116897898D23453C72B635 UnresolvedVirtualCall_288 (RuntimeObject * __this, int32_t ___Int321, int32_t ___Int322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static MLResult_t16167FAD492D3A6F53116897898D23453C72B635 UnresolvedVirtualCall_289 (RuntimeObject * __this, int32_t ___Int321, int32_t ___Int322, RuntimeObject * ___Object3, int8_t ___SByte4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static MLResult_t16167FAD492D3A6F53116897898D23453C72B635 UnresolvedVirtualCall_290 (RuntimeObject * __this, int32_t ___Int321, RuntimeObject * ___Object2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static MLResult_t16167FAD492D3A6F53116897898D23453C72B635 UnresolvedVirtualCall_291 (RuntimeObject * __this, int32_t ___Int321, int8_t ___SByte2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static MLResult_t16167FAD492D3A6F53116897898D23453C72B635 UnresolvedVirtualCall_292 (RuntimeObject * __this, int32_t ___Int321, uint32_t ___UInt322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static MLResult_t16167FAD492D3A6F53116897898D23453C72B635 UnresolvedVirtualCall_293 (RuntimeObject * __this, int32_t ___Int321, uint32_t ___UInt322, RuntimeObject * ___Object3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static MLResult_t16167FAD492D3A6F53116897898D23453C72B635 UnresolvedVirtualCall_294 (RuntimeObject * __this, int32_t ___Int321, uint32_t ___UInt322, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector33, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static MLResult_t16167FAD492D3A6F53116897898D23453C72B635 UnresolvedVirtualCall_295 (RuntimeObject * __this, RuntimeObject * ___Object1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static MLResult_t16167FAD492D3A6F53116897898D23453C72B635 UnresolvedVirtualCall_296 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, int32_t ___Int323, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static MLResult_t16167FAD492D3A6F53116897898D23453C72B635 UnresolvedVirtualCall_297 (RuntimeObject * __this, int8_t ___SByte1, int32_t ___Int322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static MLResult_t16167FAD492D3A6F53116897898D23453C72B635 UnresolvedVirtualCall_298 (RuntimeObject * __this, float ___Single1, int32_t ___Int322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static MLResult_t16167FAD492D3A6F53116897898D23453C72B635 UnresolvedVirtualCall_299 (RuntimeObject * __this, uint32_t ___UInt321, RuntimeObject * ___Object2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461 UnresolvedVirtualCall_300 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461 UnresolvedVirtualCall_301 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static MeshInfo_tD0E09CA3A2260A509C063BF0C8FDAC8D138FC611 UnresolvedVirtualCall_302 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static MeshInfo_tD0E09CA3A2260A509C063BF0C8FDAC8D138FC611 UnresolvedVirtualCall_303 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A UnresolvedVirtualCall_304 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A UnresolvedVirtualCall_305 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static MixedRealityPose_t9A27AAE05672995793F76985CE167AA85B8DF5AF UnresolvedVirtualCall_306 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static MixedRealityPose_t9A27AAE05672995793F76985CE167AA85B8DF5AF UnresolvedVirtualCall_307 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static MixedRealityRaycastHit_tD69CF29AE572AB1F40DCAA41425AC72EC4031E48 UnresolvedVirtualCall_308 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_309 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_310 (RuntimeObject * __this, KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625 ___KeyValuePair_21, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_311 (RuntimeObject * __this, uint8_t ___Byte1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_312 (RuntimeObject * __this, CancellationToken_tC9D68381C9164A4BA10397257E87ADC832AF5FFD ___CancellationToken1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_313 (RuntimeObject * __this, InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E ___InputDevice1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_314 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_315 (RuntimeObject * __this, int32_t ___Int321, uint8_t ___Byte2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_316 (RuntimeObject * __this, int32_t ___Int321, RuntimeObject * ___Object2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_317 (RuntimeObject * __this, int32_t ___Int321, RuntimeObject * ___Object2, int32_t ___Int323, RuntimeObject * ___Object4, RuntimeObject * ___Object5, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_318 (RuntimeObject * __this, int32_t ___Int321, RuntimeObject * ___Object2, RuntimeObject * ___Object3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_319 (RuntimeObject * __this, int32_t ___Int321, RuntimeObject * ___Object2, RuntimeObject * ___Object3, RuntimeObject * ___Object4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_320 (RuntimeObject * __this, int32_t ___Int321, RuntimeObject * ___Object2, RuntimeObject * ___Object3, RuntimeObject * ___Object4, RuntimeObject * ___Object5, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_321 (RuntimeObject * __this, int32_t ___Int321, RuntimeObject * ___Object2, RuntimeObject * ___Object3, RuntimeObject * ___Object4, RuntimeObject * ___Object5, RuntimeObject * ___Object6, RuntimeObject * ___Object7, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_322 (RuntimeObject * __this, int64_t ___Int641, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_323 (RuntimeObject * __this, RuntimeObject * ___Object1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_324 (RuntimeObject * __this, RuntimeObject * ___Object1, KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625 ___KeyValuePair_22, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_325 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_326 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, int32_t ___Int323, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_327 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, int32_t ___Int323, CancellationToken_tC9D68381C9164A4BA10397257E87ADC832AF5FFD ___CancellationToken4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_328 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, int32_t ___Int323, RuntimeObject * ___Object4, RuntimeObject * ___Object5, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_329 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, LoadSceneParameters_t98D2B4FCF0184320590305D3F367834287C2CAA2 ___LoadSceneParameters3, int8_t ___SByte4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_330 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, RuntimeObject * ___Object3, int32_t ___Int324, RuntimeObject * ___Object5, RuntimeObject * ___Object6, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_331 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, RuntimeObject * ___Object3, RuntimeObject * ___Object4, RuntimeObject * ___Object5, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_332 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, RuntimeObject * ___Object3, RuntimeObject * ___Object4, RuntimeObject * ___Object5, RuntimeObject * ___Object6, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_333 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, RuntimeObject * ___Object3, RuntimeObject * ___Object4, RuntimeObject * ___Object5, RuntimeObject * ___Object6, RuntimeObject * ___Object7, RuntimeObject * ___Object8, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_334 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, int8_t ___SByte3, int32_t ___Int324, RuntimeObject * ___Object5, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_335 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_336 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, int32_t ___Int323, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_337 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, int64_t ___Int643, RuntimeObject * ___Object4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_338 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, RuntimeObject * ___Object3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_339 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, RuntimeObject * ___Object3, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_340 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, RuntimeObject * ___Object3, RuntimeObject * ___Object4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_341 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, RuntimeObject * ___Object3, RuntimeObject * ___Object4, int32_t ___Int325, int32_t ___Int326, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_342 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, int8_t ___SByte3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_343 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, StreamingContext_t5888E7E8C81AB6EF3B14FDDA6674F458076A8505 ___StreamingContext3, RuntimeObject * ___Object4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_344 (RuntimeObject * __this, RuntimeObject * ___Object1, int8_t ___SByte2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_345 (RuntimeObject * __this, RuntimeObject * ___Object1, int8_t ___SByte2, int8_t ___SByte3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_346 (RuntimeObject * __this, RuntimeObject * ___Object1, StreamingContext_t5888E7E8C81AB6EF3B14FDDA6674F458076A8505 ___StreamingContext2, RuntimeObject * ___Object3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_347 (RuntimeObject * __this, RuntimeObject * ___Object1, ReadWriteParameters_tA71BF6299932C54DB368B7F5A9BDD9C70908BC47 ___ReadWriteParameters2, RuntimeObject * ___Object3, RuntimeObject * ___Object4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_348 (RuntimeObject * __this, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___Ray1, float ___Single2, int32_t ___Int323, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_349 (RuntimeObject * __this, int8_t ___SByte1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_350 (RuntimeObject * __this, float ___Single1, float ___Single2, float ___Single3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_351 (RuntimeObject * __this, StreamingContext_t5888E7E8C81AB6EF3B14FDDA6674F458076A8505 ___StreamingContext1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_352 (RuntimeObject * __this, uint32_t ___UInt321, RuntimeObject * ___Object2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeObject * UnresolvedVirtualCall_353 (RuntimeObject * __this, uint64_t ___UInt641, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Playable_tC24692CDD1DD8F1D5C646035A76D2830A70214E2 UnresolvedVirtualCall_354 (RuntimeObject * __this, PlayableGraph_t2D5083CFACB413FA1BB13FF054BE09A5A55A205A ___PlayableGraph1, RuntimeObject * ___Object2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82 UnresolvedVirtualCall_355 (RuntimeObject * __this, PlayableGraph_t2D5083CFACB413FA1BB13FF054BE09A5A55A205A ___PlayableGraph1, RuntimeObject * ___Object2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static ProcessResult_tCDC0BFAF5E3ED595F750AA1D99F9864CCB168523 UnresolvedVirtualCall_356 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static ProcessResult_tCDC0BFAF5E3ED595F750AA1D99F9864CCB168523 UnresolvedVirtualCall_357 (RuntimeObject * __this, RuntimeObject * ___Object1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 UnresolvedVirtualCall_358 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 UnresolvedVirtualCall_359 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 UnresolvedVirtualCall_360 (RuntimeObject * __this, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___Quaternion1, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___Quaternion2, float ___Single3, float ___Single4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 UnresolvedVirtualCall_361 (RuntimeObject * __this, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___Quaternion1, float ___Single2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 UnresolvedVirtualCall_362 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 UnresolvedVirtualCall_363 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RaycastHit2D_t210878DAEBC96C1F69DF9883C454758724A106A4 UnresolvedVirtualCall_364 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RaycastHit2D_t210878DAEBC96C1F69DF9883C454758724A106A4 UnresolvedVirtualCall_365 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RaycastHit2D_t210878DAEBC96C1F69DF9883C454758724A106A4 UnresolvedVirtualCall_366 (RuntimeObject * __this, Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___Vector21, Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___Vector22, float ___Single3, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE UnresolvedVirtualCall_367 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE UnresolvedVirtualCall_368 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE UnresolvedVirtualCall_369 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, RuntimeObject * ___Object3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Rect_t7D9187DB6339DBA5741C09B6CCEF2F54F1966878 UnresolvedVirtualCall_370 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Rect_t7D9187DB6339DBA5741C09B6CCEF2F54F1966878 UnresolvedVirtualCall_371 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static ReferenceFrame_tBC495D5CFA603EF6EF00A76250162F12F4293A9D UnresolvedVirtualCall_372 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static ReferenceFrame_tBC495D5CFA603EF6EF00A76250162F12F4293A9D UnresolvedVirtualCall_373 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Response_t6299078D176E4C83778DF09816E38C75EFE60512 UnresolvedVirtualCall_374 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Response_t6299078D176E4C83778DF09816E38C75EFE60512 UnresolvedVirtualCall_375 (RuntimeObject * __this, RuntimeObject * ___Object1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeFieldHandle_t7BE65FC857501059EBAC9772C93B02CD413D9C96 UnresolvedVirtualCall_376 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeMethodHandle_t8974037C4FE5F6C3AE7D3731057CDB2891A21C9A UnresolvedVirtualCall_377 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RuntimeTypeHandle_tC33965ADA3E041E0C94AF05E5CB527B56482CEF9 UnresolvedVirtualCall_378 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_379 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_380 (RuntimeObject * __this, KeyValuePair_2_tB6ECB423D6D4B3D2F916E061DDF9A7C3F0958D57 ___KeyValuePair_21, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_381 (RuntimeObject * __this, KeyValuePair_2_tB6ECB423D6D4B3D2F916E061DDF9A7C3F0958D57 ___KeyValuePair_21, KeyValuePair_2_tB6ECB423D6D4B3D2F916E061DDF9A7C3F0958D57 ___KeyValuePair_22, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_382 (RuntimeObject * __this, KeyValuePair_2_tCD5866451146985D9716EA94548482C8AC3F7569 ___KeyValuePair_21, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_383 (RuntimeObject * __this, KeyValuePair_2_t35D22D0A0BCEE8A48032CF74DA9E44BEA074DC19 ___KeyValuePair_21, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_384 (RuntimeObject * __this, KeyValuePair_2_t35D22D0A0BCEE8A48032CF74DA9E44BEA074DC19 ___KeyValuePair_21, KeyValuePair_2_t35D22D0A0BCEE8A48032CF74DA9E44BEA074DC19 ___KeyValuePair_22, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_385 (RuntimeObject * __this, KeyValuePair_2_t95507C2A8401F2191EE3D308B1B00E3729AE41B5 ___KeyValuePair_21, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_386 (RuntimeObject * __this, KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625 ___KeyValuePair_21, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_387 (RuntimeObject * __this, KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625 ___KeyValuePair_21, KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625 ___KeyValuePair_22, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_388 (RuntimeObject * __this, Nullable_1_t1829213F3538788DF79B4659AFC9D6A9C90C3258 ___Nullable_11, Nullable_1_t1829213F3538788DF79B4659AFC9D6A9C90C3258 ___Nullable_12, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_389 (RuntimeObject * __this, Bone_t8EDF2FA2139528015195AF2EA866A28947C3F070 ___Bone1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_390 (RuntimeObject * __this, Bone_t8EDF2FA2139528015195AF2EA866A28947C3F070 ___Bone1, Bone_t8EDF2FA2139528015195AF2EA866A28947C3F070 ___Bone2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_391 (RuntimeObject * __this, BoundedPlane_t9001963C43ACDF4CDEA8BBF97CD783B7969B79C5 ___BoundedPlane1, BoundedPlane_t9001963C43ACDF4CDEA8BBF97CD783B7969B79C5 ___BoundedPlane2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_392 (RuntimeObject * __this, Bounds_t0F1F36D4F7AF49524B3C2A2259594412A3D3AE37 ___Bounds1, Bounds_t0F1F36D4F7AF49524B3C2A2259594412A3D3AE37 ___Bounds2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_393 (RuntimeObject * __this, uint8_t ___Byte1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_394 (RuntimeObject * __this, uint8_t ___Byte1, uint8_t ___Byte2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_395 (RuntimeObject * __this, Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 ___Color1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_396 (RuntimeObject * __this, Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 ___Color1, Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 ___Color2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_397 (RuntimeObject * __this, Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 ___Color1, RuntimeObject * ___Object2, int32_t ___Int323, float ___Single4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_398 (RuntimeObject * __this, Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D ___Color321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_399 (RuntimeObject * __this, Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D ___Color321, Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D ___Color322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_400 (RuntimeObject * __this, ColorBlock_t04DFBB97B4772D2E00FD17ED2E3E6590E6916955 ___ColorBlock1, ColorBlock_t04DFBB97B4772D2E00FD17ED2E3E6590E6916955 ___ColorBlock2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_401 (RuntimeObject * __this, CustomAttributeNamedArgument_t618778691CF7F5B44F7177210A817A29D3DAEDDA ___CustomAttributeNamedArgument1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_402 (RuntimeObject * __this, CustomAttributeTypedArgument_tE7152E8FACDD29A8E0040E151C86F436FA8E6910 ___CustomAttributeTypedArgument1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_403 (RuntimeObject * __this, Edge_t9E8220DAC70F321BE68E4872C23B5F4AC8A5E2EE ___Edge1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_404 (RuntimeObject * __this, Edge_t9E8220DAC70F321BE68E4872C23B5F4AC8A5E2EE ___Edge1, Edge_t9E8220DAC70F321BE68E4872C23B5F4AC8A5E2EE ___Edge2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_405 (RuntimeObject * __this, GlyphRect_t4F6A791326A28C2CEC6B13B0BD50A4F78280289D ___GlyphRect1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_406 (RuntimeObject * __this, GlyphRect_t4F6A791326A28C2CEC6B13B0BD50A4F78280289D ___GlyphRect1, GlyphRect_t4F6A791326A28C2CEC6B13B0BD50A4F78280289D ___GlyphRect2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_407 (RuntimeObject * __this, Guid_t ___Guid1, RuntimeObject * ___Object2, int32_t ___Int323, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_408 (RuntimeObject * __this, InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E ___InputDevice1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_409 (RuntimeObject * __this, InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E ___InputDevice1, InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E ___InputDevice2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_410 (RuntimeObject * __this, InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032 ___InspectorPropertySetting1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_411 (RuntimeObject * __this, InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032 ___InspectorPropertySetting1, InspectorPropertySetting_t2202251463FFE0BC800FFE8BC7B7BCB683AB7032 ___InspectorPropertySetting2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_412 (RuntimeObject * __this, int16_t ___Int161, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_413 (RuntimeObject * __this, int16_t ___Int161, int16_t ___Int162, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_414 (RuntimeObject * __this, int16_t ___Int161, int16_t ___Int162, int32_t ___Int323, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_415 (RuntimeObject * __this, int16_t ___Int161, int32_t ___Int322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_416 (RuntimeObject * __this, int16_t ___Int161, RuntimeObject * ___Object2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_417 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_418 (RuntimeObject * __this, int32_t ___Int321, int32_t ___Int322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_419 (RuntimeObject * __this, int32_t ___Int321, int32_t ___Int322, int32_t ___Int323, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_420 (RuntimeObject * __this, int32_t ___Int321, int32_t ___Int322, int32_t ___Int323, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_421 (RuntimeObject * __this, int32_t ___Int321, int32_t ___Int322, int32_t ___Int323, int32_t ___Int324, int32_t ___Int325, int32_t ___Int326, int32_t ___Int327, int32_t ___Int328, RuntimeObject * ___Object9, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_422 (RuntimeObject * __this, int32_t ___Int321, intptr_t ___IntPtr2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_423 (RuntimeObject * __this, int32_t ___Int321, RuntimeObject * ___Object2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_424 (RuntimeObject * __this, int32_t ___Int321, int8_t ___SByte2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_425 (RuntimeObject * __this, int64_t ___Int641, int64_t ___Int642, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_426 (RuntimeObject * __this, intptr_t ___IntPtr1, intptr_t ___IntPtr2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_427 (RuntimeObject * __this, MLResult_t16167FAD492D3A6F53116897898D23453C72B635 ___MLResult1, MLResult_t16167FAD492D3A6F53116897898D23453C72B635 ___MLResult2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_428 (RuntimeObject * __this, Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461 ___Matrix4x41, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_429 (RuntimeObject * __this, Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461 ___Matrix4x41, Matrix4x4_tDE7FF4F2E2EA284F6EFE00D627789D0E5B8B4461 ___Matrix4x42, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_430 (RuntimeObject * __this, MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 ___MeshId1, MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 ___MeshId2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_431 (RuntimeObject * __this, MeshInfo_tD0E09CA3A2260A509C063BF0C8FDAC8D138FC611 ___MeshInfo1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_432 (RuntimeObject * __this, MeshInfo_tD0E09CA3A2260A509C063BF0C8FDAC8D138FC611 ___MeshInfo1, MeshInfo_tD0E09CA3A2260A509C063BF0C8FDAC8D138FC611 ___MeshInfo2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_433 (RuntimeObject * __this, MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A ___MixedRealityInputAction1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_434 (RuntimeObject * __this, MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A ___MixedRealityInputAction1, MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A ___MixedRealityInputAction2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_435 (RuntimeObject * __this, MixedRealityPose_t9A27AAE05672995793F76985CE167AA85B8DF5AF ___MixedRealityPose1, MixedRealityPose_t9A27AAE05672995793F76985CE167AA85B8DF5AF ___MixedRealityPose2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_436 (RuntimeObject * __this, Navigation_t1CF0FFB22C0357CD64714FB7A40A275F899D363A ___Navigation1, Navigation_t1CF0FFB22C0357CD64714FB7A40A275F899D363A ___Navigation2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_437 (RuntimeObject * __this, RuntimeObject * ___Object1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_438 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_439 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, RuntimeObject * ___Object3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_440 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_441 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, int32_t ___Int323, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_442 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, RuntimeObject * ___Object3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_443 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, RuntimeObject * ___Object3, RuntimeObject * ___Object4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_444 (RuntimeObject * __this, RuntimeObject * ___Object1, int8_t ___SByte2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_445 (RuntimeObject * __this, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___Ray1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_446 (RuntimeObject * __this, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___Ray1, RuntimeObject * ___Object2, float ___Single3, int32_t ___Int324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_447 (RuntimeObject * __this, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___Ray1, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___Ray2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_448 (RuntimeObject * __this, RayStep_t1BDD462CBD5B96D20141BF5AF5E2F93D60E317BF ___RayStep1, RuntimeObject * ___Object2, int8_t ___SByte3, RuntimeObject * ___Object4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_449 (RuntimeObject * __this, RayStep_t1BDD462CBD5B96D20141BF5AF5E2F93D60E317BF ___RayStep1, float ___Single2, RuntimeObject * ___Object3, int8_t ___SByte4, RuntimeObject * ___Object5, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_450 (RuntimeObject * __this, RaycastHit2D_t210878DAEBC96C1F69DF9883C454758724A106A4 ___RaycastHit2D1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_451 (RuntimeObject * __this, RaycastHit2D_t210878DAEBC96C1F69DF9883C454758724A106A4 ___RaycastHit2D1, RaycastHit2D_t210878DAEBC96C1F69DF9883C454758724A106A4 ___RaycastHit2D2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_452 (RuntimeObject * __this, RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE ___RaycastResult1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_453 (RuntimeObject * __this, RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE ___RaycastResult1, RaycastResult_t9EFDE24B29650BD6DC8A49D954A3769E17146BCE ___RaycastResult2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_454 (RuntimeObject * __this, ReferenceFrame_tBC495D5CFA603EF6EF00A76250162F12F4293A9D ___ReferenceFrame1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_455 (RuntimeObject * __this, ReferenceFrame_tBC495D5CFA603EF6EF00A76250162F12F4293A9D ___ReferenceFrame1, ReferenceFrame_tBC495D5CFA603EF6EF00A76250162F12F4293A9D ___ReferenceFrame2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_456 (RuntimeObject * __this, ResourceLocator_t3D496606F94367D5D6B24DA9DC0A3B46E6B53B11 ___ResourceLocator1, ResourceLocator_t3D496606F94367D5D6B24DA9DC0A3B46E6B53B11 ___ResourceLocator2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_457 (RuntimeObject * __this, int8_t ___SByte1, int8_t ___SByte2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_458 (RuntimeObject * __this, Scene_t5495AD2FDC587DB2E94D9BDE2B85868BFB9A92EE ___Scene1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_459 (RuntimeObject * __this, Scene_t5495AD2FDC587DB2E94D9BDE2B85868BFB9A92EE ___Scene1, Scene_t5495AD2FDC587DB2E94D9BDE2B85868BFB9A92EE ___Scene2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_460 (RuntimeObject * __this, SceneInfo_t12CFA6F7D90C190B2C869FD43C885339A250C3FD ___SceneInfo1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_461 (RuntimeObject * __this, SceneInfo_t12CFA6F7D90C190B2C869FD43C885339A250C3FD ___SceneInfo1, SceneInfo_t12CFA6F7D90C190B2C869FD43C885339A250C3FD ___SceneInfo2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_462 (RuntimeObject * __this, ShaderProperties_t780424B677AA69C9E9434368B245AF8CF867FD44 ___ShaderProperties1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_463 (RuntimeObject * __this, ShaderProperties_t780424B677AA69C9E9434368B245AF8CF867FD44 ___ShaderProperties1, ShaderProperties_t780424B677AA69C9E9434368B245AF8CF867FD44 ___ShaderProperties2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_464 (RuntimeObject * __this, float ___Single1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_465 (RuntimeObject * __this, float ___Single1, float ___Single2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_466 (RuntimeObject * __this, SpriteState_t9024961148433175CE2F3D9E8E9239A8B1CAB15E ___SpriteState1, SpriteState_t9024961148433175CE2F3D9E8E9239A8B1CAB15E ___SpriteState2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_467 (RuntimeObject * __this, ThemeDefinition_tDC1C1DE1B953BC552C4A4D956F12537CC94E400E ___ThemeDefinition1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_468 (RuntimeObject * __this, ThemeDefinition_tDC1C1DE1B953BC552C4A4D956F12537CC94E400E ___ThemeDefinition1, ThemeDefinition_tDC1C1DE1B953BC552C4A4D956F12537CC94E400E ___ThemeDefinition2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_469 (RuntimeObject * __this, TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B ___TrackableId1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_470 (RuntimeObject * __this, TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B ___TrackableId1, TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B ___TrackableId2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_471 (RuntimeObject * __this, UICharInfo_tDEA65B831FAD06D1E9B10A6088E05C6D615B089A ___UICharInfo1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_472 (RuntimeObject * __this, UICharInfo_tDEA65B831FAD06D1E9B10A6088E05C6D615B089A ___UICharInfo1, UICharInfo_tDEA65B831FAD06D1E9B10A6088E05C6D615B089A ___UICharInfo2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_473 (RuntimeObject * __this, UILineInfo_tD082FF4894030AD4EBF57ACF6A997135E4B8B67C ___UILineInfo1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_474 (RuntimeObject * __this, UILineInfo_tD082FF4894030AD4EBF57ACF6A997135E4B8B67C ___UILineInfo1, UILineInfo_tD082FF4894030AD4EBF57ACF6A997135E4B8B67C ___UILineInfo2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_475 (RuntimeObject * __this, UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A ___UIVertex1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_476 (RuntimeObject * __this, UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A ___UIVertex1, UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A ___UIVertex2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_477 (RuntimeObject * __this, uint32_t ___UInt321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_478 (RuntimeObject * __this, uint32_t ___UInt321, uint32_t ___UInt322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_479 (RuntimeObject * __this, uint64_t ___UInt641, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_480 (RuntimeObject * __this, uint64_t ___UInt641, uint64_t ___UInt642, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_481 (RuntimeObject * __this, Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___Vector21, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_482 (RuntimeObject * __this, Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___Vector21, RuntimeObject * ___Object2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_483 (RuntimeObject * __this, Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___Vector21, Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___Vector22, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_484 (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector31, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_485 (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector31, int32_t ___Int322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_486 (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector31, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector32, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_487 (RuntimeObject * __this, Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA ___Vector3Int1, RuntimeObject * ___Object2, RuntimeObject * ___Object3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_488 (RuntimeObject * __this, Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 ___Vector41, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_489 (RuntimeObject * __this, Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 ___Vector41, Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 ___Vector42, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_490 (RuntimeObject * __this, XRNodeState_t6DC58D0C1BF2C4323D16B3905FDBEE7C03E27D33 ___XRNodeState1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_491 (RuntimeObject * __this, XRNodeState_t6DC58D0C1BF2C4323D16B3905FDBEE7C03E27D33 ___XRNodeState1, XRNodeState_t6DC58D0C1BF2C4323D16B3905FDBEE7C03E27D33 ___XRNodeState2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_492 (RuntimeObject * __this, XRReferenceImage_tB1803A72EB581FB35B2CA944973679132A1D4467 ___XRReferenceImage1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_493 (RuntimeObject * __this, XRReferenceImage_tB1803A72EB581FB35B2CA944973679132A1D4467 ___XRReferenceImage1, XRReferenceImage_tB1803A72EB581FB35B2CA944973679132A1D4467 ___XRReferenceImage2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_494 (RuntimeObject * __this, AudioLoFiFilterSettings_t5EC9A0E1CF4DFFC4BA58E1DF6D4E880F9404B0A8 ___AudioLoFiFilterSettings1, AudioLoFiFilterSettings_t5EC9A0E1CF4DFFC4BA58E1DF6D4E880F9404B0A8 ___AudioLoFiFilterSettings2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_495 (RuntimeObject * __this, EventHandlerEntry_tD4B30F35FCE99CEB4F1BFF88A3F5FA0407C3C927 ___EventHandlerEntry1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_496 (RuntimeObject * __this, EventHandlerEntry_tD4B30F35FCE99CEB4F1BFF88A3F5FA0407C3C927 ___EventHandlerEntry1, EventHandlerEntry_tD4B30F35FCE99CEB4F1BFF88A3F5FA0407C3C927 ___EventHandlerEntry2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_497 (RuntimeObject * __this, OrderBlock_t0B106828F588BC2F0B9895425E6FD39EDA45C1E2 ___OrderBlock1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_498 (RuntimeObject * __this, OrderBlock_t0B106828F588BC2F0B9895425E6FD39EDA45C1E2 ___OrderBlock1, OrderBlock_t0B106828F588BC2F0B9895425E6FD39EDA45C1E2 ___OrderBlock2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_499 (RuntimeObject * __this, RenderRequest_t7DEDFA6AAA1C8D381280183054C328F26BBCCE94 ___RenderRequest1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_500 (RuntimeObject * __this, RenderRequest_t7DEDFA6AAA1C8D381280183054C328F26BBCCE94 ___RenderRequest1, RenderRequest_t7DEDFA6AAA1C8D381280183054C328F26BBCCE94 ___RenderRequest2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_501 (RuntimeObject * __this, BlocksAndRenderer_tF583D143167DBC0C9BA5575BCE054D11CD059F0C ___BlocksAndRenderer1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_502 (RuntimeObject * __this, BlocksAndRenderer_tF583D143167DBC0C9BA5575BCE054D11CD059F0C ___BlocksAndRenderer1, BlocksAndRenderer_tF583D143167DBC0C9BA5575BCE054D11CD059F0C ___BlocksAndRenderer2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_503 (RuntimeObject * __this, Descriptor_t369955C9D183FE09E69BB860543789ACE71BFBF3 ___Descriptor1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_504 (RuntimeObject * __this, Descriptor_t369955C9D183FE09E69BB860543789ACE71BFBF3 ___Descriptor1, Descriptor_t369955C9D183FE09E69BB860543789ACE71BFBF3 ___Descriptor2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_505 (RuntimeObject * __this, OAuthPair_t6862D91D872AA10E48A8FFB13C4B2D677ACE6FC0 ___OAuthPair1, OAuthPair_t6862D91D872AA10E48A8FFB13C4B2D677ACE6FC0 ___OAuthPair2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_506 (RuntimeObject * __this, RaycastHitData_tC9D839911FFA6A7160E7E0DBD8DF17D78FCEBA6F ___RaycastHitData1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_507 (RuntimeObject * __this, RaycastHitData_tC9D839911FFA6A7160E7E0DBD8DF17D78FCEBA6F ___RaycastHitData1, RaycastHitData_tC9D839911FFA6A7160E7E0DBD8DF17D78FCEBA6F ___RaycastHitData2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_508 (RuntimeObject * __this, TrackData_tDCFE71C8D16AD063EF76BBC09C03F3FB3FD1B7BF ___TrackData1, TrackData_tDCFE71C8D16AD063EF76BBC09C03F3FB3FD1B7BF ___TrackData2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_509 (RuntimeObject * __this, MLCoordinateFrameUID_t7ADFCEC93CA8B3DDFB41EC8157D03B51D0611AC9 ___MLCoordinateFrameUID1, MLCoordinateFrameUID_t7ADFCEC93CA8B3DDFB41EC8157D03B51D0611AC9 ___MLCoordinateFrameUID2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_510 (RuntimeObject * __this, PointerData_tC90DB32A4F2EF1FC975FEAE81DE66BC21FE1351F ___PointerData1, PointerData_tC90DB32A4F2EF1FC975FEAE81DE66BC21FE1351F ___PointerData2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_511 (RuntimeObject * __this, PointerData_t217FAEE1441F0ADC5F7B08E3987B1C08E48B7DD4 ___PointerData1, PointerData_t217FAEE1441F0ADC5F7B08E3987B1C08E48B7DD4 ___PointerData2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_512 (RuntimeObject * __this, Frame_t277B57D2C572A3B179CEA0357869DB245F52128D ___Frame1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_513 (RuntimeObject * __this, Frame_t277B57D2C572A3B179CEA0357869DB245F52128D ___Frame1, Frame_t277B57D2C572A3B179CEA0357869DB245F52128D ___Frame2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_514 (RuntimeObject * __this, PoseData_t3F5C8C74C50A6ECAE42890BBEF683882DB4E97C3 ___PoseData1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_515 (RuntimeObject * __this, PoseData_t3F5C8C74C50A6ECAE42890BBEF683882DB4E97C3 ___PoseData1, PoseData_t3F5C8C74C50A6ECAE42890BBEF683882DB4E97C3 ___PoseData2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_516 (RuntimeObject * __this, WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393 ___WorkRequest1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_517 (RuntimeObject * __this, WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393 ___WorkRequest1, WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393 ___WorkRequest2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_518 (RuntimeObject * __this, MLArucoTrackerResultNative_t6B156A863352A63682C2FE6AA83A77F9B36435CA ___MLArucoTrackerResultNative1, MLArucoTrackerResultNative_t6B156A863352A63682C2FE6AA83A77F9B36435CA ___MLArucoTrackerResultNative2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_519 (RuntimeObject * __this, QueuedCallback_tEF82DE1B0127F3722835BFB0ABC1D2280C6278D2 ___QueuedCallback1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_520 (RuntimeObject * __this, QueuedCallback_tEF82DE1B0127F3722835BFB0ABC1D2280C6278D2 ___QueuedCallback1, QueuedCallback_tEF82DE1B0127F3722835BFB0ABC1D2280C6278D2 ___QueuedCallback2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_521 (RuntimeObject * __this, Query_t81D4EF187177B9BBAA39D5798E5369A176FFA3E3 ___Query1, Query_t81D4EF187177B9BBAA39D5798E5369A176FFA3E3 ___Query2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_522 (RuntimeObject * __this, MLRaycastResultNative_tDA46F1834D203F71E2FC259B44817E02F85FCA90 ___MLRaycastResultNative1, MLRaycastResultNative_tDA46F1834D203F71E2FC259B44817E02F85FCA90 ___MLRaycastResultNative2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static int8_t UnresolvedVirtualCall_523 (RuntimeObject * __this, TileCoord_t491EABF2B90DFB255C8F7624FF5528F2DE2CC901 ___TileCoord1, TileCoord_t491EABF2B90DFB255C8F7624FF5528F2DE2CC901 ___TileCoord2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Scene_t5495AD2FDC587DB2E94D9BDE2B85868BFB9A92EE UnresolvedVirtualCall_524 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Scene_t5495AD2FDC587DB2E94D9BDE2B85868BFB9A92EE UnresolvedVirtualCall_525 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static SceneInfo_t12CFA6F7D90C190B2C869FD43C885339A250C3FD UnresolvedVirtualCall_526 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static SceneInfo_t12CFA6F7D90C190B2C869FD43C885339A250C3FD UnresolvedVirtualCall_527 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static ShaderProperties_t780424B677AA69C9E9434368B245AF8CF867FD44 UnresolvedVirtualCall_528 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static ShaderProperties_t780424B677AA69C9E9434368B245AF8CF867FD44 UnresolvedVirtualCall_529 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static float UnresolvedVirtualCall_530 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static float UnresolvedVirtualCall_531 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static float UnresolvedVirtualCall_532 (RuntimeObject * __this, intptr_t ___IntPtr1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static float UnresolvedVirtualCall_533 (RuntimeObject * __this, RuntimeObject * ___Object1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static float UnresolvedVirtualCall_534 (RuntimeObject * __this, RuntimeObject * ___Object1, float ___Single2, float ___Single3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static float UnresolvedVirtualCall_535 (RuntimeObject * __this, float ___Single1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static float UnresolvedVirtualCall_536 (RuntimeObject * __this, float ___Single1, int32_t ___Int322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static float UnresolvedVirtualCall_537 (RuntimeObject * __this, float ___Single1, float ___Single2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static float UnresolvedVirtualCall_538 (RuntimeObject * __this, float ___Single1, float ___Single2, float ___Single3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static float UnresolvedVirtualCall_539 (RuntimeObject * __this, Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___Vector21, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static float UnresolvedVirtualCall_540 (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector31, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static float UnresolvedVirtualCall_541 (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector31, RuntimeObject * ___Object2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static ThemeDefinition_tDC1C1DE1B953BC552C4A4D956F12537CC94E400E UnresolvedVirtualCall_542 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static ThemeDefinition_tDC1C1DE1B953BC552C4A4D956F12537CC94E400E UnresolvedVirtualCall_543 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 UnresolvedVirtualCall_544 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 UnresolvedVirtualCall_545 (RuntimeObject * __this, RuntimeObject * ___Object1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 UnresolvedVirtualCall_546 (RuntimeObject * __this, TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ___TimeSpan1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Touch_tDEFED247540BCFA4AD452F1D37EEF4E09B4ACD8C UnresolvedVirtualCall_547 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B UnresolvedVirtualCall_548 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static TrackableId_t17A59B04292038BB1B77BEACD41221D2700BE90B UnresolvedVirtualCall_549 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static UICharInfo_tDEA65B831FAD06D1E9B10A6088E05C6D615B089A UnresolvedVirtualCall_550 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static UICharInfo_tDEA65B831FAD06D1E9B10A6088E05C6D615B089A UnresolvedVirtualCall_551 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static UILineInfo_tD082FF4894030AD4EBF57ACF6A997135E4B8B67C UnresolvedVirtualCall_552 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static UILineInfo_tD082FF4894030AD4EBF57ACF6A997135E4B8B67C UnresolvedVirtualCall_553 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A UnresolvedVirtualCall_554 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static UIVertex_tD94AAC5F0B42DBC441AAA8ADBFCFF9E5C320C03A UnresolvedVirtualCall_555 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static uint16_t UnresolvedVirtualCall_556 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static uint16_t UnresolvedVirtualCall_557 (RuntimeObject * __this, RuntimeObject * ___Object1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static uint32_t UnresolvedVirtualCall_558 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static uint32_t UnresolvedVirtualCall_559 (RuntimeObject * __this, KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625 ___KeyValuePair_21, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static uint32_t UnresolvedVirtualCall_560 (RuntimeObject * __this, KeyValuePair_2_t78B694E8342E86089FB515D21C3CB9F12838A5CB ___KeyValuePair_21, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static uint32_t UnresolvedVirtualCall_561 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static uint32_t UnresolvedVirtualCall_562 (RuntimeObject * __this, RuntimeObject * ___Object1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static uint32_t UnresolvedVirtualCall_563 (RuntimeObject * __this, uint32_t ___UInt321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static uint64_t UnresolvedVirtualCall_564 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static uint64_t UnresolvedVirtualCall_565 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static uint64_t UnresolvedVirtualCall_566 (RuntimeObject * __this, RuntimeObject * ___Object1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 UnresolvedVirtualCall_567 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 UnresolvedVirtualCall_568 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 UnresolvedVirtualCall_569 (RuntimeObject * __this, RuntimeObject * ___Object1, Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___Vector22, int8_t ___SByte3, int8_t ___SByte4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E UnresolvedVirtualCall_570 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E UnresolvedVirtualCall_571 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E UnresolvedVirtualCall_572 (RuntimeObject * __this, RuntimeObject * ___Object1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E UnresolvedVirtualCall_573 (RuntimeObject * __this, float ___Single1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E UnresolvedVirtualCall_574 (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector31, int32_t ___Int322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E UnresolvedVirtualCall_575 (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector31, float ___Single2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E UnresolvedVirtualCall_576 (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector31, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector32, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E UnresolvedVirtualCall_577 (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector31, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector32, float ___Single3, float ___Single4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 UnresolvedVirtualCall_578 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 UnresolvedVirtualCall_579 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_580 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_581 (RuntimeObject * __this, ActivateGestureEvent_tE62B374FD7C61FB39DBE074BAC40308F033D4337 ___ActivateGestureEvent1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_582 (RuntimeObject * __this, uint8_t ___Byte1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_583 (RuntimeObject * __this, uint8_t ___Byte1, int32_t ___Int322, uint64_t ___UInt643, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_584 (RuntimeObject * __this, uint8_t ___Byte1, int32_t ___Int322, uint64_t ___UInt643, intptr_t ___IntPtr4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_585 (RuntimeObject * __this, uint8_t ___Byte1, intptr_t ___IntPtr2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_586 (RuntimeObject * __this, uint8_t ___Byte1, RuntimeObject * ___Object2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_587 (RuntimeObject * __this, uint8_t ___Byte1, RuntimeObject * ___Object2, intptr_t ___IntPtr3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_588 (RuntimeObject * __this, uint8_t ___Byte1, float ___Single2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_589 (RuntimeObject * __this, uint8_t ___Byte1, uint32_t ___UInt322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_590 (RuntimeObject * __this, uint8_t ___Byte1, uint32_t ___UInt322, intptr_t ___IntPtr3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_591 (RuntimeObject * __this, uint8_t ___Byte1, uint32_t ___UInt322, uint64_t ___UInt643, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_592 (RuntimeObject * __this, uint8_t ___Byte1, uint32_t ___UInt322, uint64_t ___UInt643, intptr_t ___IntPtr4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_593 (RuntimeObject * __this, uint8_t ___Byte1, TabletState_tFA5C8B491DBCEDA17A7378618C952F0BA393AE4A ___TabletState2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_594 (RuntimeObject * __this, Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 ___Color1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_595 (RuntimeObject * __this, Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 ___Color1, float ___Single2, int8_t ___SByte3, int8_t ___SByte4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_596 (RuntimeObject * __this, Color_tF40DAF76C04FFECF3FE6024F85A294741C9CC659 ___Color1, float ___Single2, int8_t ___SByte3, int8_t ___SByte4, int8_t ___SByte5, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_597 (RuntimeObject * __this, Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D ___Color321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_598 (RuntimeObject * __this, CullingGroupEvent_t58E1718FD0A5FC5037538BD223DCF1385014185C ___CullingGroupEvent1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_599 (RuntimeObject * __this, double ___Double1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_600 (RuntimeObject * __this, Guid_t ___Guid1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_601 (RuntimeObject * __this, Guid_t ___Guid1, RuntimeObject * ___Object2, int32_t ___Int323, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_602 (RuntimeObject * __this, InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E ___InputDevice1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_603 (RuntimeObject * __this, int16_t ___Int161, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_604 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_605 (RuntimeObject * __this, int32_t ___Int321, int32_t ___Int322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_606 (RuntimeObject * __this, int32_t ___Int321, int32_t ___Int322, int32_t ___Int323, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_607 (RuntimeObject * __this, int32_t ___Int321, int32_t ___Int322, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___Ray3, RaycastHit_t59E5AEC8FE13BFA2ACBB6FFBDB7585FFB7288F89 ___RaycastHit4, float ___Single5, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_608 (RuntimeObject * __this, int32_t ___Int321, int64_t ___Int642, int64_t ___Int643, int8_t ___SByte4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_609 (RuntimeObject * __this, int32_t ___Int321, intptr_t ___IntPtr2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_610 (RuntimeObject * __this, int32_t ___Int321, intptr_t ___IntPtr2, int32_t ___Int323, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_611 (RuntimeObject * __this, int32_t ___Int321, intptr_t ___IntPtr2, int64_t ___Int643, int64_t ___Int644, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_612 (RuntimeObject * __this, int32_t ___Int321, RuntimeObject * ___Object2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_613 (RuntimeObject * __this, int32_t ___Int321, RuntimeObject * ___Object2, intptr_t ___IntPtr3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_614 (RuntimeObject * __this, int32_t ___Int321, RuntimeObject * ___Object2, RuntimeObject * ___Object3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_615 (RuntimeObject * __this, int32_t ___Int321, RuntimeObject * ___Object2, RuntimeObject * ___Object3, RuntimeObject * ___Object4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_616 (RuntimeObject * __this, int32_t ___Int321, int8_t ___SByte2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_617 (RuntimeObject * __this, int32_t ___Int321, uint64_t ___UInt642, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_618 (RuntimeObject * __this, int32_t ___Int321, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector32, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_619 (RuntimeObject * __this, int32_t ___Int321, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector32, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector33, float ___Single4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_620 (RuntimeObject * __this, int32_t ___Int321, MicrophoneEventInfo_t436D3A8AC50B8EA7F08628301510BA2CCD3BCD42 ___MicrophoneEventInfo2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_621 (RuntimeObject * __this, int32_t ___Int321, PipeEventInfo_t8F415117730C2C258B5D9EBB95BEC982DFDB6FE5 ___PipeEventInfo2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_622 (RuntimeObject * __this, int32_t ___Int321, UserEventInfo_tFC25DD77EA4674A99AA0D54F2A5772E796437777 ___UserEventInfo2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_623 (RuntimeObject * __this, int32_t ___Int321, MediaPlayerTracks_tEAC176EC77BB5617A82189EC66BC4AAEAF613CF7 ___MediaPlayerTracks2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_624 (RuntimeObject * __this, int64_t ___Int641, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_625 (RuntimeObject * __this, int64_t ___Int641, RuntimeObject * ___Object2, int64_t ___Int643, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_626 (RuntimeObject * __this, intptr_t ___IntPtr1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_627 (RuntimeObject * __this, intptr_t ___IntPtr1, intptr_t ___IntPtr2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_628 (RuntimeObject * __this, MLResult_t16167FAD492D3A6F53116897898D23453C72B635 ___MLResult1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_629 (RuntimeObject * __this, MLResult_t16167FAD492D3A6F53116897898D23453C72B635 ___MLResult1, RuntimeObject * ___Object2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_630 (RuntimeObject * __this, MLResult_t16167FAD492D3A6F53116897898D23453C72B635 ___MLResult1, RuntimeObject * ___Object2, RuntimeObject * ___Object3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_631 (RuntimeObject * __this, MLResult_t16167FAD492D3A6F53116897898D23453C72B635 ___MLResult1, uint32_t ___UInt322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_632 (RuntimeObject * __this, MLResult_t16167FAD492D3A6F53116897898D23453C72B635 ___MLResult1, Mesh_t2F73AAA4971480C39E8BC56781D08C22A7DC5F0C ___Mesh2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_633 (RuntimeObject * __this, MagicLeapKeyPoseGestureEvent_t1DCE5B3073F1B16761D19D641DEDB85A3F64F0E2 ___MagicLeapKeyPoseGestureEvent1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_634 (RuntimeObject * __this, MagicLeapTouchpadGestureEvent_t81F61003445761DF336429222C1A5E8ED0E8A56A ___MagicLeapTouchpadGestureEvent1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_635 (RuntimeObject * __this, MeshGenerationResult_t081845588E8932BB4BA2D6F087D2F2F0EE3373CF ___MeshGenerationResult1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_636 (RuntimeObject * __this, MeshId_t583996FC9E6BA652AA2C6B0D0F60D88E4498D767 ___MeshId1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_637 (RuntimeObject * __this, MixedRealityRaycastHit_tD69CF29AE572AB1F40DCAA41425AC72EC4031E48 ___MixedRealityRaycastHit1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_638 (RuntimeObject * __this, MixedRealityTransform_tB8BF0B2CCF0776ABB28C6356EEF0FC1C3CBACE95 ___MixedRealityTransform1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_639 (RuntimeObject * __this, RuntimeObject * ___Object1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_640 (RuntimeObject * __this, RuntimeObject * ___Object1, NativeArray_1_tF6A10DD2511425342F2B1B19CF0EA313D4F300D2 ___NativeArray_12, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_641 (RuntimeObject * __this, RuntimeObject * ___Object1, uint8_t ___Byte2, MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A ___MixedRealityInputAction3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_642 (RuntimeObject * __this, RuntimeObject * ___Object1, uint8_t ___Byte2, MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A ___MixedRealityInputAction3, MixedRealityPose_t9A27AAE05672995793F76985CE167AA85B8DF5AF ___MixedRealityPose4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_643 (RuntimeObject * __this, RuntimeObject * ___Object1, uint8_t ___Byte2, MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A ___MixedRealityInputAction3, float ___Single4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_644 (RuntimeObject * __this, RuntimeObject * ___Object1, uint8_t ___Byte2, MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A ___MixedRealityInputAction3, Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___Vector24, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_645 (RuntimeObject * __this, RuntimeObject * ___Object1, uint8_t ___Byte2, RuntimeObject * ___Object3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_646 (RuntimeObject * __this, RuntimeObject * ___Object1, double ___Double2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_647 (RuntimeObject * __this, RuntimeObject * ___Object1, InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E ___InputDevice2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_648 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_649 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, int32_t ___Int323, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_650 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, float ___Single3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_651 (RuntimeObject * __this, RuntimeObject * ___Object1, int32_t ___Int322, TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ___TimeSpan3, DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 ___DateTime4, SpeechCommands_tB5EB0ECFA6A91657370C348F8F7862ADC9AE44EB ___SpeechCommands5, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_652 (RuntimeObject * __this, RuntimeObject * ___Object1, int64_t ___Int642, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_653 (RuntimeObject * __this, RuntimeObject * ___Object1, int64_t ___Int642, int64_t ___Int643, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_654 (RuntimeObject * __this, RuntimeObject * ___Object1, intptr_t ___IntPtr2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_655 (RuntimeObject * __this, RuntimeObject * ___Object1, intptr_t ___IntPtr2, intptr_t ___IntPtr3, RuntimeObject * ___Object4, int32_t ___Int325, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_656 (RuntimeObject * __this, RuntimeObject * ___Object1, MLResult_t16167FAD492D3A6F53116897898D23453C72B635 ___MLResult2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_657 (RuntimeObject * __this, RuntimeObject * ___Object1, MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A ___MixedRealityInputAction2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_658 (RuntimeObject * __this, RuntimeObject * ___Object1, MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A ___MixedRealityInputAction2, uint8_t ___Byte3, RuntimeObject * ___Object4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_659 (RuntimeObject * __this, RuntimeObject * ___Object1, MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A ___MixedRealityInputAction2, int32_t ___Int323, uint8_t ___Byte4, RuntimeObject * ___Object5, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_660 (RuntimeObject * __this, RuntimeObject * ___Object1, MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A ___MixedRealityInputAction2, Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___Vector23, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_661 (RuntimeObject * __this, RuntimeObject * ___Object1, MixedRealityInputAction_tBA06471AA738A1132A3FFEF7494C5AE06EFFF54A ___MixedRealityInputAction2, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector33, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_662 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_663 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, uint8_t ___Byte3, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector34, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_664 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, int32_t ___Int323, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_665 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, int32_t ___Int323, int32_t ___Int324, int32_t ___Int325, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_666 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, int32_t ___Int323, RuntimeObject * ___Object4, RuntimeObject * ___Object5, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_667 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, int32_t ___Int323, RuntimeObject * ___Object4, RuntimeObject * ___Object5, RuntimeObject * ___Object6, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_668 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, int64_t ___Int643, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_669 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, intptr_t ___IntPtr3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_670 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, MixedRealityPose_t9A27AAE05672995793F76985CE167AA85B8DF5AF ___MixedRealityPose3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_671 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, RuntimeObject * ___Object3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_672 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, RuntimeObject * ___Object3, int32_t ___Int324, int32_t ___Int325, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_673 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, RuntimeObject * ___Object3, RuntimeObject * ___Object4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_674 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___Quaternion3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_675 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, RectInt_tE7B8105A280C1AC73A4157ED41F9B86C9BD91E49 ___RectInt3, int8_t ___SByte4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_676 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, int8_t ___SByte3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_677 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, int8_t ___SByte3, int8_t ___SByte4, RuntimeObject * ___Object5, int8_t ___SByte6, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_678 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, StreamingContext_t5888E7E8C81AB6EF3B14FDDA6674F458076A8505 ___StreamingContext3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_679 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, uint32_t ___UInt323, intptr_t ___IntPtr4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_680 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector33, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_681 (RuntimeObject * __this, RuntimeObject * ___Object1, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___Ray2, DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 ___DateTime3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_682 (RuntimeObject * __this, RuntimeObject * ___Object1, RectInt_tE7B8105A280C1AC73A4157ED41F9B86C9BD91E49 ___RectInt2, int8_t ___SByte3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_683 (RuntimeObject * __this, RuntimeObject * ___Object1, int8_t ___SByte2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_684 (RuntimeObject * __this, RuntimeObject * ___Object1, int8_t ___SByte2, DebugScreenCapture_t82C35632EAE92C143A87097DC34C70EFADB750B1 ___DebugScreenCapture3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_685 (RuntimeObject * __this, RuntimeObject * ___Object1, int8_t ___SByte2, int8_t ___SByte3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_686 (RuntimeObject * __this, RuntimeObject * ___Object1, float ___Single2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_687 (RuntimeObject * __this, RuntimeObject * ___Object1, float ___Single2, int8_t ___SByte3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_688 (RuntimeObject * __this, RuntimeObject * ___Object1, float ___Single2, float ___Single3, int32_t ___Int324, RuntimeObject * ___Object5, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_689 (RuntimeObject * __this, RuntimeObject * ___Object1, StreamingContext_t5888E7E8C81AB6EF3B14FDDA6674F458076A8505 ___StreamingContext2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_690 (RuntimeObject * __this, RuntimeObject * ___Object1, ThemeDefinition_tDC1C1DE1B953BC552C4A4D956F12537CC94E400E ___ThemeDefinition2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_691 (RuntimeObject * __this, RuntimeObject * ___Object1, uint32_t ___UInt322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_692 (RuntimeObject * __this, RuntimeObject * ___Object1, uint32_t ___UInt322, intptr_t ___IntPtr3, intptr_t ___IntPtr4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_693 (RuntimeObject * __this, RuntimeObject * ___Object1, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector32, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_694 (RuntimeObject * __this, RuntimeObject * ___Object1, IceCandidate_tB24683852F651BE72764839BCB14E52F11411253 ___IceCandidate2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_695 (RuntimeObject * __this, RuntimeObject * ___Object1, Result_t62DDE919B95F6BFDE1DD6E480F0225B7912290A2 ___Result2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_696 (RuntimeObject * __this, Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___Ray1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_697 (RuntimeObject * __this, Rect_t7D9187DB6339DBA5741C09B6CCEF2F54F1966878 ___Rect1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_698 (RuntimeObject * __this, Rect_t7D9187DB6339DBA5741C09B6CCEF2F54F1966878 ___Rect1, int8_t ___SByte2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_699 (RuntimeObject * __this, int8_t ___SByte1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_700 (RuntimeObject * __this, int8_t ___SByte1, intptr_t ___IntPtr2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_701 (RuntimeObject * __this, int8_t ___SByte1, intptr_t ___IntPtr2, intptr_t ___IntPtr3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_702 (RuntimeObject * __this, int8_t ___SByte1, RuntimeObject * ___Object2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_703 (RuntimeObject * __this, int8_t ___SByte1, int8_t ___SByte2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_704 (RuntimeObject * __this, int8_t ___SByte1, int8_t ___SByte2, int32_t ___Int323, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_705 (RuntimeObject * __this, Scene_t5495AD2FDC587DB2E94D9BDE2B85868BFB9A92EE ___Scene1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_706 (RuntimeObject * __this, Scene_t5495AD2FDC587DB2E94D9BDE2B85868BFB9A92EE ___Scene1, int32_t ___Int322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_707 (RuntimeObject * __this, Scene_t5495AD2FDC587DB2E94D9BDE2B85868BFB9A92EE ___Scene1, Scene_t5495AD2FDC587DB2E94D9BDE2B85868BFB9A92EE ___Scene2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_708 (RuntimeObject * __this, ScriptableRenderContext_tEDDDFFA7401E6860E1D82DFD779B7A101939F52D ___ScriptableRenderContext1, RuntimeObject * ___Object2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_709 (RuntimeObject * __this, ScriptableRenderContext_tEDDDFFA7401E6860E1D82DFD779B7A101939F52D ___ScriptableRenderContext1, RuntimeObject * ___Object2, RuntimeObject * ___Object3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_710 (RuntimeObject * __this, float ___Single1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_711 (RuntimeObject * __this, float ___Single1, int32_t ___Int322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_712 (RuntimeObject * __this, float ___Single1, intptr_t ___IntPtr2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_713 (RuntimeObject * __this, float ___Single1, RuntimeObject * ___Object2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_714 (RuntimeObject * __this, float ___Single1, int8_t ___SByte2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_715 (RuntimeObject * __this, float ___Single1, float ___Single2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_716 (RuntimeObject * __this, float ___Single1, float ___Single2, Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D ___Color323, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_717 (RuntimeObject * __this, float ___Single1, float ___Single2, int8_t ___SByte3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_718 (RuntimeObject * __this, StreamingContext_t5888E7E8C81AB6EF3B14FDDA6674F458076A8505 ___StreamingContext1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_719 (RuntimeObject * __this, TypedReference_tE1755FC30D207D9552DE27539E907EE92C8C073A ___TypedReference1, RuntimeObject * ___Object2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_720 (RuntimeObject * __this, uint16_t ___UInt161, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_721 (RuntimeObject * __this, uint32_t ___UInt321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_722 (RuntimeObject * __this, uint32_t ___UInt321, int32_t ___Int322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_723 (RuntimeObject * __this, uint32_t ___UInt321, int32_t ___Int322, intptr_t ___IntPtr3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_724 (RuntimeObject * __this, uint32_t ___UInt321, intptr_t ___IntPtr2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_725 (RuntimeObject * __this, uint32_t ___UInt321, RuntimeObject * ___Object2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_726 (RuntimeObject * __this, uint32_t ___UInt321, RuntimeObject * ___Object2, intptr_t ___IntPtr3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_727 (RuntimeObject * __this, uint64_t ___UInt641, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_728 (RuntimeObject * __this, uint64_t ___UInt641, intptr_t ___IntPtr2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_729 (RuntimeObject * __this, uint64_t ___UInt641, RuntimeObject * ___Object2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_730 (RuntimeObject * __this, VFXOutputEventArgs_tE7E97EDFD67E4561E4412D2E4B1C999F95850BF5 ___VFXOutputEventArgs1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_731 (RuntimeObject * __this, Vector2_tBB32F2736AEC229A7BFBCE18197EC0F6AC7EC2D9 ___Vector21, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_732 (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector31, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_733 (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector31, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___Quaternion2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_734 (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector31, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___Quaternion2, int32_t ___Int323, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_735 (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector31, Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___Quaternion2, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector33, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_736 (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector31, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector32, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_737 (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector31, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector32, RuntimeObject * ___Object3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_738 (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector31, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector32, RuntimeObject * ___Object3, uint8_t ___Byte4, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_739 (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector31, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector32, RuntimeObject * ___Object3, Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D ___Color324, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_740 (RuntimeObject * __this, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector31, Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___Vector32, RuntimeObject * ___Object3, float ___Single4, float ___Single5, float ___Single6, float ___Single7, Color32_tDB54A78627878A7D2DE42BB028D64306A18E858D ___Color328, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_741 (RuntimeObject * __this, Vector3Int_t197C3BA05CF19F1A22D40F8AE64CD4102AFB77EA ___Vector3Int1, RuntimeObject * ___Object2, RuntimeObject * ___Object3, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_742 (RuntimeObject * __this, Vector4_tA56A37FC5661BCC89C3DDC24BE12BA5BCB6A02C7 ___Vector41, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_743 (RuntimeObject * __this, XRNodeState_t6DC58D0C1BF2C4323D16B3905FDBEE7C03E27D33 ___XRNodeState1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_744 (RuntimeObject * __this, Buffer_t6C6476ADA463C6E32C9089029FA9EEBD44F0B2B8 ___Buffer1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_745 (RuntimeObject * __this, Characteristic_t4A3FC54AFB0C50F0303208C7E2A6A4453D2B9944 ___Characteristic1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_746 (RuntimeObject * __this, Characteristic_t4A3FC54AFB0C50F0303208C7E2A6A4453D2B9944 ___Characteristic1, int32_t ___Int322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_747 (RuntimeObject * __this, Descriptor_t369955C9D183FE09E69BB860543789ACE71BFBF3 ___Descriptor1, int32_t ___Int322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_748 (RuntimeObject * __this, Device_t8D9EA5FF748FD67329425ACE40F7EA51FAB2F7FC ___Device1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_749 (RuntimeObject * __this, Device_t8D9EA5FF748FD67329425ACE40F7EA51FAB2F7FC ___Device1, int32_t ___Int322, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_750 (RuntimeObject * __this, InvitationResult_tB8CDBC566B12CF9FB043FB42722767032338E7C1 ___InvitationResult1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_751 (RuntimeObject * __this, InviteeStatus_tE06F11EB1070D277A0B594E817717DF224E2854B ___InviteeStatus1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_752 (RuntimeObject * __this, OperationResult_t04D393B6206909328F53832764C577C5A9284748 ___OperationResult1, uint64_t ___UInt642, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_753 (RuntimeObject * __this, Frame_t128A1C20EE2DB6FC213BFFC7698397A2335E6804 ___Frame1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_754 (RuntimeObject * __this, Cea608CaptionSegment_t6F927E35AC06808226EFA60FE3824A954CCC70EE ___Cea608CaptionSegment1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_755 (RuntimeObject * __this, Cea708CaptionEvent_t56C4405243D5B580CBC687605BE9A3B15E1D06F6 ___Cea708CaptionEvent1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_756 (RuntimeObject * __this, Error_t4662C50A5F672241D3965F14B24F4E2F9983353B ___Error1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_757 (RuntimeObject * __this, Metadata_t07980C3F5037AD27F0828FC795343DBB860E7AD4 ___Metadata1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_758 (RuntimeObject * __this, ImagePlane_t2D929496EA001719A11E4DF9B11BD09B7B538D46 ___ImagePlane1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static void UnresolvedVirtualCall_759 (RuntimeObject * __this, Frame_t90194D91C0FAD483165FD830882EB3151D67BAA4 ___Frame1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static VoidTaskResult_t28D1A323545DE024749196472558F49F1AAF0004 UnresolvedVirtualCall_760 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static VoidTaskResult_t28D1A323545DE024749196472558F49F1AAF0004 UnresolvedVirtualCall_761 (RuntimeObject * __this, RuntimeObject * ___Object1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static VoidTaskResult_t28D1A323545DE024749196472558F49F1AAF0004 UnresolvedVirtualCall_762 (RuntimeObject * __this, RuntimeObject * ___Object1, RuntimeObject * ___Object2, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static XRNodeState_t6DC58D0C1BF2C4323D16B3905FDBEE7C03E27D33 UnresolvedVirtualCall_763 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static XRNodeState_t6DC58D0C1BF2C4323D16B3905FDBEE7C03E27D33 UnresolvedVirtualCall_764 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static XRReferenceImage_tB1803A72EB581FB35B2CA944973679132A1D4467 UnresolvedVirtualCall_765 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static XRReferenceImage_tB1803A72EB581FB35B2CA944973679132A1D4467 UnresolvedVirtualCall_766 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static YogaSize_tC805BF63DE9A9E4B9984B964AB0A1CFA04ADC1FD UnresolvedVirtualCall_767 (RuntimeObject * __this, RuntimeObject * ___Object1, float ___Single2, int32_t ___Int323, float ___Single4, int32_t ___Int325, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static EventHandlerEntry_tD4B30F35FCE99CEB4F1BFF88A3F5FA0407C3C927 UnresolvedVirtualCall_768 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static EventHandlerEntry_tD4B30F35FCE99CEB4F1BFF88A3F5FA0407C3C927 UnresolvedVirtualCall_769 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static OrderBlock_t0B106828F588BC2F0B9895425E6FD39EDA45C1E2 UnresolvedVirtualCall_770 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static OrderBlock_t0B106828F588BC2F0B9895425E6FD39EDA45C1E2 UnresolvedVirtualCall_771 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RenderRequest_t7DEDFA6AAA1C8D381280183054C328F26BBCCE94 UnresolvedVirtualCall_772 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RenderRequest_t7DEDFA6AAA1C8D381280183054C328F26BBCCE94 UnresolvedVirtualCall_773 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static BlocksAndRenderer_tF583D143167DBC0C9BA5575BCE054D11CD059F0C UnresolvedVirtualCall_774 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static BlocksAndRenderer_tF583D143167DBC0C9BA5575BCE054D11CD059F0C UnresolvedVirtualCall_775 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Descriptor_t369955C9D183FE09E69BB860543789ACE71BFBF3 UnresolvedVirtualCall_776 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Descriptor_t369955C9D183FE09E69BB860543789ACE71BFBF3 UnresolvedVirtualCall_777 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RaycastHitData_tC9D839911FFA6A7160E7E0DBD8DF17D78FCEBA6F UnresolvedVirtualCall_778 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static RaycastHitData_tC9D839911FFA6A7160E7E0DBD8DF17D78FCEBA6F UnresolvedVirtualCall_779 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static PointerData_tC90DB32A4F2EF1FC975FEAE81DE66BC21FE1351F UnresolvedVirtualCall_780 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static PointerData_tC90DB32A4F2EF1FC975FEAE81DE66BC21FE1351F UnresolvedVirtualCall_781 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static PointerData_t217FAEE1441F0ADC5F7B08E3987B1C08E48B7DD4 UnresolvedVirtualCall_782 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static PointerData_t217FAEE1441F0ADC5F7B08E3987B1C08E48B7DD4 UnresolvedVirtualCall_783 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Frame_t277B57D2C572A3B179CEA0357869DB245F52128D UnresolvedVirtualCall_784 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static Frame_t277B57D2C572A3B179CEA0357869DB245F52128D UnresolvedVirtualCall_785 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static PoseData_t3F5C8C74C50A6ECAE42890BBEF683882DB4E97C3 UnresolvedVirtualCall_786 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static PoseData_t3F5C8C74C50A6ECAE42890BBEF683882DB4E97C3 UnresolvedVirtualCall_787 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393 UnresolvedVirtualCall_788 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393 UnresolvedVirtualCall_789 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static QueuedCallback_tEF82DE1B0127F3722835BFB0ABC1D2280C6278D2 UnresolvedVirtualCall_790 (RuntimeObject * __this, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
static QueuedCallback_tEF82DE1B0127F3722835BFB0ABC1D2280C6278D2 UnresolvedVirtualCall_791 (RuntimeObject * __this, int32_t ___Int321, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception(method);
il2cpp_codegen_no_return();
}
IL2CPP_EXTERN_C const Il2CppMethodPointer g_UnresolvedVirtualMethodPointers[];
const Il2CppMethodPointer g_UnresolvedVirtualMethodPointers[792] =
{
(const Il2CppMethodPointer) UnresolvedVirtualCall_0,
(const Il2CppMethodPointer) UnresolvedVirtualCall_1,
(const Il2CppMethodPointer) UnresolvedVirtualCall_2,
(const Il2CppMethodPointer) UnresolvedVirtualCall_3,
(const Il2CppMethodPointer) UnresolvedVirtualCall_4,
(const Il2CppMethodPointer) UnresolvedVirtualCall_5,
(const Il2CppMethodPointer) UnresolvedVirtualCall_6,
(const Il2CppMethodPointer) UnresolvedVirtualCall_7,
(const Il2CppMethodPointer) UnresolvedVirtualCall_8,
(const Il2CppMethodPointer) UnresolvedVirtualCall_9,
(const Il2CppMethodPointer) UnresolvedVirtualCall_10,
(const Il2CppMethodPointer) UnresolvedVirtualCall_11,
(const Il2CppMethodPointer) UnresolvedVirtualCall_12,
(const Il2CppMethodPointer) UnresolvedVirtualCall_13,
(const Il2CppMethodPointer) UnresolvedVirtualCall_14,
(const Il2CppMethodPointer) UnresolvedVirtualCall_15,
(const Il2CppMethodPointer) UnresolvedVirtualCall_16,
(const Il2CppMethodPointer) UnresolvedVirtualCall_17,
(const Il2CppMethodPointer) UnresolvedVirtualCall_18,
(const Il2CppMethodPointer) UnresolvedVirtualCall_19,
(const Il2CppMethodPointer) UnresolvedVirtualCall_20,
(const Il2CppMethodPointer) UnresolvedVirtualCall_21,
(const Il2CppMethodPointer) UnresolvedVirtualCall_22,
(const Il2CppMethodPointer) UnresolvedVirtualCall_23,
(const Il2CppMethodPointer) UnresolvedVirtualCall_24,
(const Il2CppMethodPointer) UnresolvedVirtualCall_25,
(const Il2CppMethodPointer) UnresolvedVirtualCall_26,
(const Il2CppMethodPointer) UnresolvedVirtualCall_27,
(const Il2CppMethodPointer) UnresolvedVirtualCall_28,
(const Il2CppMethodPointer) UnresolvedVirtualCall_29,
(const Il2CppMethodPointer) UnresolvedVirtualCall_30,
(const Il2CppMethodPointer) UnresolvedVirtualCall_31,
(const Il2CppMethodPointer) UnresolvedVirtualCall_32,
(const Il2CppMethodPointer) UnresolvedVirtualCall_33,
(const Il2CppMethodPointer) UnresolvedVirtualCall_34,
(const Il2CppMethodPointer) UnresolvedVirtualCall_35,
(const Il2CppMethodPointer) UnresolvedVirtualCall_36,
(const Il2CppMethodPointer) UnresolvedVirtualCall_37,
(const Il2CppMethodPointer) UnresolvedVirtualCall_38,
(const Il2CppMethodPointer) UnresolvedVirtualCall_39,
(const Il2CppMethodPointer) UnresolvedVirtualCall_40,
(const Il2CppMethodPointer) UnresolvedVirtualCall_41,
(const Il2CppMethodPointer) UnresolvedVirtualCall_42,
(const Il2CppMethodPointer) UnresolvedVirtualCall_43,
(const Il2CppMethodPointer) UnresolvedVirtualCall_44,
(const Il2CppMethodPointer) UnresolvedVirtualCall_45,
(const Il2CppMethodPointer) UnresolvedVirtualCall_46,
(const Il2CppMethodPointer) UnresolvedVirtualCall_47,
(const Il2CppMethodPointer) UnresolvedVirtualCall_48,
(const Il2CppMethodPointer) UnresolvedVirtualCall_49,
(const Il2CppMethodPointer) UnresolvedVirtualCall_50,
(const Il2CppMethodPointer) UnresolvedVirtualCall_51,
(const Il2CppMethodPointer) UnresolvedVirtualCall_52,
(const Il2CppMethodPointer) UnresolvedVirtualCall_53,
(const Il2CppMethodPointer) UnresolvedVirtualCall_54,
(const Il2CppMethodPointer) UnresolvedVirtualCall_55,
(const Il2CppMethodPointer) UnresolvedVirtualCall_56,
(const Il2CppMethodPointer) UnresolvedVirtualCall_57,
(const Il2CppMethodPointer) UnresolvedVirtualCall_58,
(const Il2CppMethodPointer) UnresolvedVirtualCall_59,
(const Il2CppMethodPointer) UnresolvedVirtualCall_60,
(const Il2CppMethodPointer) UnresolvedVirtualCall_61,
(const Il2CppMethodPointer) UnresolvedVirtualCall_62,
(const Il2CppMethodPointer) UnresolvedVirtualCall_63,
(const Il2CppMethodPointer) UnresolvedVirtualCall_64,
(const Il2CppMethodPointer) UnresolvedVirtualCall_65,
(const Il2CppMethodPointer) UnresolvedVirtualCall_66,
(const Il2CppMethodPointer) UnresolvedVirtualCall_67,
(const Il2CppMethodPointer) UnresolvedVirtualCall_68,
(const Il2CppMethodPointer) UnresolvedVirtualCall_69,
(const Il2CppMethodPointer) UnresolvedVirtualCall_70,
(const Il2CppMethodPointer) UnresolvedVirtualCall_71,
(const Il2CppMethodPointer) UnresolvedVirtualCall_72,
(const Il2CppMethodPointer) UnresolvedVirtualCall_73,
(const Il2CppMethodPointer) UnresolvedVirtualCall_74,
(const Il2CppMethodPointer) UnresolvedVirtualCall_75,
(const Il2CppMethodPointer) UnresolvedVirtualCall_76,
(const Il2CppMethodPointer) UnresolvedVirtualCall_77,
(const Il2CppMethodPointer) UnresolvedVirtualCall_78,
(const Il2CppMethodPointer) UnresolvedVirtualCall_79,
(const Il2CppMethodPointer) UnresolvedVirtualCall_80,
(const Il2CppMethodPointer) UnresolvedVirtualCall_81,
(const Il2CppMethodPointer) UnresolvedVirtualCall_82,
(const Il2CppMethodPointer) UnresolvedVirtualCall_83,
(const Il2CppMethodPointer) UnresolvedVirtualCall_84,
(const Il2CppMethodPointer) UnresolvedVirtualCall_85,
(const Il2CppMethodPointer) UnresolvedVirtualCall_86,
(const Il2CppMethodPointer) UnresolvedVirtualCall_87,
(const Il2CppMethodPointer) UnresolvedVirtualCall_88,
(const Il2CppMethodPointer) UnresolvedVirtualCall_89,
(const Il2CppMethodPointer) UnresolvedVirtualCall_90,
(const Il2CppMethodPointer) UnresolvedVirtualCall_91,
(const Il2CppMethodPointer) UnresolvedVirtualCall_92,
(const Il2CppMethodPointer) UnresolvedVirtualCall_93,
(const Il2CppMethodPointer) UnresolvedVirtualCall_94,
(const Il2CppMethodPointer) UnresolvedVirtualCall_95,
(const Il2CppMethodPointer) UnresolvedVirtualCall_96,
(const Il2CppMethodPointer) UnresolvedVirtualCall_97,
(const Il2CppMethodPointer) UnresolvedVirtualCall_98,
(const Il2CppMethodPointer) UnresolvedVirtualCall_99,
(const Il2CppMethodPointer) UnresolvedVirtualCall_100,
(const Il2CppMethodPointer) UnresolvedVirtualCall_101,
(const Il2CppMethodPointer) UnresolvedVirtualCall_102,
(const Il2CppMethodPointer) UnresolvedVirtualCall_103,
(const Il2CppMethodPointer) UnresolvedVirtualCall_104,
(const Il2CppMethodPointer) UnresolvedVirtualCall_105,
(const Il2CppMethodPointer) UnresolvedVirtualCall_106,
(const Il2CppMethodPointer) UnresolvedVirtualCall_107,
(const Il2CppMethodPointer) UnresolvedVirtualCall_108,
(const Il2CppMethodPointer) UnresolvedVirtualCall_109,
(const Il2CppMethodPointer) UnresolvedVirtualCall_110,
(const Il2CppMethodPointer) UnresolvedVirtualCall_111,
(const Il2CppMethodPointer) UnresolvedVirtualCall_112,
(const Il2CppMethodPointer) UnresolvedVirtualCall_113,
(const Il2CppMethodPointer) UnresolvedVirtualCall_114,
(const Il2CppMethodPointer) UnresolvedVirtualCall_115,
(const Il2CppMethodPointer) UnresolvedVirtualCall_116,
(const Il2CppMethodPointer) UnresolvedVirtualCall_117,
(const Il2CppMethodPointer) UnresolvedVirtualCall_118,
(const Il2CppMethodPointer) UnresolvedVirtualCall_119,
(const Il2CppMethodPointer) UnresolvedVirtualCall_120,
(const Il2CppMethodPointer) UnresolvedVirtualCall_121,
(const Il2CppMethodPointer) UnresolvedVirtualCall_122,
(const Il2CppMethodPointer) UnresolvedVirtualCall_123,
(const Il2CppMethodPointer) UnresolvedVirtualCall_124,
(const Il2CppMethodPointer) UnresolvedVirtualCall_125,
(const Il2CppMethodPointer) UnresolvedVirtualCall_126,
(const Il2CppMethodPointer) UnresolvedVirtualCall_127,
(const Il2CppMethodPointer) UnresolvedVirtualCall_128,
(const Il2CppMethodPointer) UnresolvedVirtualCall_129,
(const Il2CppMethodPointer) UnresolvedVirtualCall_130,
(const Il2CppMethodPointer) UnresolvedVirtualCall_131,
(const Il2CppMethodPointer) UnresolvedVirtualCall_132,
(const Il2CppMethodPointer) UnresolvedVirtualCall_133,
(const Il2CppMethodPointer) UnresolvedVirtualCall_134,
(const Il2CppMethodPointer) UnresolvedVirtualCall_135,
(const Il2CppMethodPointer) UnresolvedVirtualCall_136,
(const Il2CppMethodPointer) UnresolvedVirtualCall_137,
(const Il2CppMethodPointer) UnresolvedVirtualCall_138,
(const Il2CppMethodPointer) UnresolvedVirtualCall_139,
(const Il2CppMethodPointer) UnresolvedVirtualCall_140,
(const Il2CppMethodPointer) UnresolvedVirtualCall_141,
(const Il2CppMethodPointer) UnresolvedVirtualCall_142,
(const Il2CppMethodPointer) UnresolvedVirtualCall_143,
(const Il2CppMethodPointer) UnresolvedVirtualCall_144,
(const Il2CppMethodPointer) UnresolvedVirtualCall_145,
(const Il2CppMethodPointer) UnresolvedVirtualCall_146,
(const Il2CppMethodPointer) UnresolvedVirtualCall_147,
(const Il2CppMethodPointer) UnresolvedVirtualCall_148,
(const Il2CppMethodPointer) UnresolvedVirtualCall_149,
(const Il2CppMethodPointer) UnresolvedVirtualCall_150,
(const Il2CppMethodPointer) UnresolvedVirtualCall_151,
(const Il2CppMethodPointer) UnresolvedVirtualCall_152,
(const Il2CppMethodPointer) UnresolvedVirtualCall_153,
(const Il2CppMethodPointer) UnresolvedVirtualCall_154,
(const Il2CppMethodPointer) UnresolvedVirtualCall_155,
(const Il2CppMethodPointer) UnresolvedVirtualCall_156,
(const Il2CppMethodPointer) UnresolvedVirtualCall_157,
(const Il2CppMethodPointer) UnresolvedVirtualCall_158,
(const Il2CppMethodPointer) UnresolvedVirtualCall_159,
(const Il2CppMethodPointer) UnresolvedVirtualCall_160,
(const Il2CppMethodPointer) UnresolvedVirtualCall_161,
(const Il2CppMethodPointer) UnresolvedVirtualCall_162,
(const Il2CppMethodPointer) UnresolvedVirtualCall_163,
(const Il2CppMethodPointer) UnresolvedVirtualCall_164,
(const Il2CppMethodPointer) UnresolvedVirtualCall_165,
(const Il2CppMethodPointer) UnresolvedVirtualCall_166,
(const Il2CppMethodPointer) UnresolvedVirtualCall_167,
(const Il2CppMethodPointer) UnresolvedVirtualCall_168,
(const Il2CppMethodPointer) UnresolvedVirtualCall_169,
(const Il2CppMethodPointer) UnresolvedVirtualCall_170,
(const Il2CppMethodPointer) UnresolvedVirtualCall_171,
(const Il2CppMethodPointer) UnresolvedVirtualCall_172,
(const Il2CppMethodPointer) UnresolvedVirtualCall_173,
(const Il2CppMethodPointer) UnresolvedVirtualCall_174,
(const Il2CppMethodPointer) UnresolvedVirtualCall_175,
(const Il2CppMethodPointer) UnresolvedVirtualCall_176,
(const Il2CppMethodPointer) UnresolvedVirtualCall_177,
(const Il2CppMethodPointer) UnresolvedVirtualCall_178,
(const Il2CppMethodPointer) UnresolvedVirtualCall_179,
(const Il2CppMethodPointer) UnresolvedVirtualCall_180,
(const Il2CppMethodPointer) UnresolvedVirtualCall_181,
(const Il2CppMethodPointer) UnresolvedVirtualCall_182,
(const Il2CppMethodPointer) UnresolvedVirtualCall_183,
(const Il2CppMethodPointer) UnresolvedVirtualCall_184,
(const Il2CppMethodPointer) UnresolvedVirtualCall_185,
(const Il2CppMethodPointer) UnresolvedVirtualCall_186,
(const Il2CppMethodPointer) UnresolvedVirtualCall_187,
(const Il2CppMethodPointer) UnresolvedVirtualCall_188,
(const Il2CppMethodPointer) UnresolvedVirtualCall_189,
(const Il2CppMethodPointer) UnresolvedVirtualCall_190,
(const Il2CppMethodPointer) UnresolvedVirtualCall_191,
(const Il2CppMethodPointer) UnresolvedVirtualCall_192,
(const Il2CppMethodPointer) UnresolvedVirtualCall_193,
(const Il2CppMethodPointer) UnresolvedVirtualCall_194,
(const Il2CppMethodPointer) UnresolvedVirtualCall_195,
(const Il2CppMethodPointer) UnresolvedVirtualCall_196,
(const Il2CppMethodPointer) UnresolvedVirtualCall_197,
(const Il2CppMethodPointer) UnresolvedVirtualCall_198,
(const Il2CppMethodPointer) UnresolvedVirtualCall_199,
(const Il2CppMethodPointer) UnresolvedVirtualCall_200,
(const Il2CppMethodPointer) UnresolvedVirtualCall_201,
(const Il2CppMethodPointer) UnresolvedVirtualCall_202,
(const Il2CppMethodPointer) UnresolvedVirtualCall_203,
(const Il2CppMethodPointer) UnresolvedVirtualCall_204,
(const Il2CppMethodPointer) UnresolvedVirtualCall_205,
(const Il2CppMethodPointer) UnresolvedVirtualCall_206,
(const Il2CppMethodPointer) UnresolvedVirtualCall_207,
(const Il2CppMethodPointer) UnresolvedVirtualCall_208,
(const Il2CppMethodPointer) UnresolvedVirtualCall_209,
(const Il2CppMethodPointer) UnresolvedVirtualCall_210,
(const Il2CppMethodPointer) UnresolvedVirtualCall_211,
(const Il2CppMethodPointer) UnresolvedVirtualCall_212,
(const Il2CppMethodPointer) UnresolvedVirtualCall_213,
(const Il2CppMethodPointer) UnresolvedVirtualCall_214,
(const Il2CppMethodPointer) UnresolvedVirtualCall_215,
(const Il2CppMethodPointer) UnresolvedVirtualCall_216,
(const Il2CppMethodPointer) UnresolvedVirtualCall_217,
(const Il2CppMethodPointer) UnresolvedVirtualCall_218,
(const Il2CppMethodPointer) UnresolvedVirtualCall_219,
(const Il2CppMethodPointer) UnresolvedVirtualCall_220,
(const Il2CppMethodPointer) UnresolvedVirtualCall_221,
(const Il2CppMethodPointer) UnresolvedVirtualCall_222,
(const Il2CppMethodPointer) UnresolvedVirtualCall_223,
(const Il2CppMethodPointer) UnresolvedVirtualCall_224,
(const Il2CppMethodPointer) UnresolvedVirtualCall_225,
(const Il2CppMethodPointer) UnresolvedVirtualCall_226,
(const Il2CppMethodPointer) UnresolvedVirtualCall_227,
(const Il2CppMethodPointer) UnresolvedVirtualCall_228,
(const Il2CppMethodPointer) UnresolvedVirtualCall_229,
(const Il2CppMethodPointer) UnresolvedVirtualCall_230,
(const Il2CppMethodPointer) UnresolvedVirtualCall_231,
(const Il2CppMethodPointer) UnresolvedVirtualCall_232,
(const Il2CppMethodPointer) UnresolvedVirtualCall_233,
(const Il2CppMethodPointer) UnresolvedVirtualCall_234,
(const Il2CppMethodPointer) UnresolvedVirtualCall_235,
(const Il2CppMethodPointer) UnresolvedVirtualCall_236,
(const Il2CppMethodPointer) UnresolvedVirtualCall_237,
(const Il2CppMethodPointer) UnresolvedVirtualCall_238,
(const Il2CppMethodPointer) UnresolvedVirtualCall_239,
(const Il2CppMethodPointer) UnresolvedVirtualCall_240,
(const Il2CppMethodPointer) UnresolvedVirtualCall_241,
(const Il2CppMethodPointer) UnresolvedVirtualCall_242,
(const Il2CppMethodPointer) UnresolvedVirtualCall_243,
(const Il2CppMethodPointer) UnresolvedVirtualCall_244,
(const Il2CppMethodPointer) UnresolvedVirtualCall_245,
(const Il2CppMethodPointer) UnresolvedVirtualCall_246,
(const Il2CppMethodPointer) UnresolvedVirtualCall_247,
(const Il2CppMethodPointer) UnresolvedVirtualCall_248,
(const Il2CppMethodPointer) UnresolvedVirtualCall_249,
(const Il2CppMethodPointer) UnresolvedVirtualCall_250,
(const Il2CppMethodPointer) UnresolvedVirtualCall_251,
(const Il2CppMethodPointer) UnresolvedVirtualCall_252,
(const Il2CppMethodPointer) UnresolvedVirtualCall_253,
(const Il2CppMethodPointer) UnresolvedVirtualCall_254,
(const Il2CppMethodPointer) UnresolvedVirtualCall_255,
(const Il2CppMethodPointer) UnresolvedVirtualCall_256,
(const Il2CppMethodPointer) UnresolvedVirtualCall_257,
(const Il2CppMethodPointer) UnresolvedVirtualCall_258,
(const Il2CppMethodPointer) UnresolvedVirtualCall_259,
(const Il2CppMethodPointer) UnresolvedVirtualCall_260,
(const Il2CppMethodPointer) UnresolvedVirtualCall_261,
(const Il2CppMethodPointer) UnresolvedVirtualCall_262,
(const Il2CppMethodPointer) UnresolvedVirtualCall_263,
(const Il2CppMethodPointer) UnresolvedVirtualCall_264,
(const Il2CppMethodPointer) UnresolvedVirtualCall_265,
(const Il2CppMethodPointer) UnresolvedVirtualCall_266,
(const Il2CppMethodPointer) UnresolvedVirtualCall_267,
(const Il2CppMethodPointer) UnresolvedVirtualCall_268,
(const Il2CppMethodPointer) UnresolvedVirtualCall_269,
(const Il2CppMethodPointer) UnresolvedVirtualCall_270,
(const Il2CppMethodPointer) UnresolvedVirtualCall_271,
(const Il2CppMethodPointer) UnresolvedVirtualCall_272,
(const Il2CppMethodPointer) UnresolvedVirtualCall_273,
(const Il2CppMethodPointer) UnresolvedVirtualCall_274,
(const Il2CppMethodPointer) UnresolvedVirtualCall_275,
(const Il2CppMethodPointer) UnresolvedVirtualCall_276,
(const Il2CppMethodPointer) UnresolvedVirtualCall_277,
(const Il2CppMethodPointer) UnresolvedVirtualCall_278,
(const Il2CppMethodPointer) UnresolvedVirtualCall_279,
(const Il2CppMethodPointer) UnresolvedVirtualCall_280,
(const Il2CppMethodPointer) UnresolvedVirtualCall_281,
(const Il2CppMethodPointer) UnresolvedVirtualCall_282,
(const Il2CppMethodPointer) UnresolvedVirtualCall_283,
(const Il2CppMethodPointer) UnresolvedVirtualCall_284,
(const Il2CppMethodPointer) UnresolvedVirtualCall_285,
(const Il2CppMethodPointer) UnresolvedVirtualCall_286,
(const Il2CppMethodPointer) UnresolvedVirtualCall_287,
(const Il2CppMethodPointer) UnresolvedVirtualCall_288,
(const Il2CppMethodPointer) UnresolvedVirtualCall_289,
(const Il2CppMethodPointer) UnresolvedVirtualCall_290,
(const Il2CppMethodPointer) UnresolvedVirtualCall_291,
(const Il2CppMethodPointer) UnresolvedVirtualCall_292,
(const Il2CppMethodPointer) UnresolvedVirtualCall_293,
(const Il2CppMethodPointer) UnresolvedVirtualCall_294,
(const Il2CppMethodPointer) UnresolvedVirtualCall_295,
(const Il2CppMethodPointer) UnresolvedVirtualCall_296,
(const Il2CppMethodPointer) UnresolvedVirtualCall_297,
(const Il2CppMethodPointer) UnresolvedVirtualCall_298,
(const Il2CppMethodPointer) UnresolvedVirtualCall_299,
(const Il2CppMethodPointer) UnresolvedVirtualCall_300,
(const Il2CppMethodPointer) UnresolvedVirtualCall_301,
(const Il2CppMethodPointer) UnresolvedVirtualCall_302,
(const Il2CppMethodPointer) UnresolvedVirtualCall_303,
(const Il2CppMethodPointer) UnresolvedVirtualCall_304,
(const Il2CppMethodPointer) UnresolvedVirtualCall_305,
(const Il2CppMethodPointer) UnresolvedVirtualCall_306,
(const Il2CppMethodPointer) UnresolvedVirtualCall_307,
(const Il2CppMethodPointer) UnresolvedVirtualCall_308,
(const Il2CppMethodPointer) UnresolvedVirtualCall_309,
(const Il2CppMethodPointer) UnresolvedVirtualCall_310,
(const Il2CppMethodPointer) UnresolvedVirtualCall_311,
(const Il2CppMethodPointer) UnresolvedVirtualCall_312,
(const Il2CppMethodPointer) UnresolvedVirtualCall_313,
(const Il2CppMethodPointer) UnresolvedVirtualCall_314,
(const Il2CppMethodPointer) UnresolvedVirtualCall_315,
(const Il2CppMethodPointer) UnresolvedVirtualCall_316,
(const Il2CppMethodPointer) UnresolvedVirtualCall_317,
(const Il2CppMethodPointer) UnresolvedVirtualCall_318,
(const Il2CppMethodPointer) UnresolvedVirtualCall_319,
(const Il2CppMethodPointer) UnresolvedVirtualCall_320,
(const Il2CppMethodPointer) UnresolvedVirtualCall_321,
(const Il2CppMethodPointer) UnresolvedVirtualCall_322,
(const Il2CppMethodPointer) UnresolvedVirtualCall_323,
(const Il2CppMethodPointer) UnresolvedVirtualCall_324,
(const Il2CppMethodPointer) UnresolvedVirtualCall_325,
(const Il2CppMethodPointer) UnresolvedVirtualCall_326,
(const Il2CppMethodPointer) UnresolvedVirtualCall_327,
(const Il2CppMethodPointer) UnresolvedVirtualCall_328,
(const Il2CppMethodPointer) UnresolvedVirtualCall_329,
(const Il2CppMethodPointer) UnresolvedVirtualCall_330,
(const Il2CppMethodPointer) UnresolvedVirtualCall_331,
(const Il2CppMethodPointer) UnresolvedVirtualCall_332,
(const Il2CppMethodPointer) UnresolvedVirtualCall_333,
(const Il2CppMethodPointer) UnresolvedVirtualCall_334,
(const Il2CppMethodPointer) UnresolvedVirtualCall_335,
(const Il2CppMethodPointer) UnresolvedVirtualCall_336,
(const Il2CppMethodPointer) UnresolvedVirtualCall_337,
(const Il2CppMethodPointer) UnresolvedVirtualCall_338,
(const Il2CppMethodPointer) UnresolvedVirtualCall_339,
(const Il2CppMethodPointer) UnresolvedVirtualCall_340,
(const Il2CppMethodPointer) UnresolvedVirtualCall_341,
(const Il2CppMethodPointer) UnresolvedVirtualCall_342,
(const Il2CppMethodPointer) UnresolvedVirtualCall_343,
(const Il2CppMethodPointer) UnresolvedVirtualCall_344,
(const Il2CppMethodPointer) UnresolvedVirtualCall_345,
(const Il2CppMethodPointer) UnresolvedVirtualCall_346,
(const Il2CppMethodPointer) UnresolvedVirtualCall_347,
(const Il2CppMethodPointer) UnresolvedVirtualCall_348,
(const Il2CppMethodPointer) UnresolvedVirtualCall_349,
(const Il2CppMethodPointer) UnresolvedVirtualCall_350,
(const Il2CppMethodPointer) UnresolvedVirtualCall_351,
(const Il2CppMethodPointer) UnresolvedVirtualCall_352,
(const Il2CppMethodPointer) UnresolvedVirtualCall_353,
(const Il2CppMethodPointer) UnresolvedVirtualCall_354,
(const Il2CppMethodPointer) UnresolvedVirtualCall_355,
(const Il2CppMethodPointer) UnresolvedVirtualCall_356,
(const Il2CppMethodPointer) UnresolvedVirtualCall_357,
(const Il2CppMethodPointer) UnresolvedVirtualCall_358,
(const Il2CppMethodPointer) UnresolvedVirtualCall_359,
(const Il2CppMethodPointer) UnresolvedVirtualCall_360,
(const Il2CppMethodPointer) UnresolvedVirtualCall_361,
(const Il2CppMethodPointer) UnresolvedVirtualCall_362,
(const Il2CppMethodPointer) UnresolvedVirtualCall_363,
(const Il2CppMethodPointer) UnresolvedVirtualCall_364,
(const Il2CppMethodPointer) UnresolvedVirtualCall_365,
(const Il2CppMethodPointer) UnresolvedVirtualCall_366,
(const Il2CppMethodPointer) UnresolvedVirtualCall_367,
(const Il2CppMethodPointer) UnresolvedVirtualCall_368,
(const Il2CppMethodPointer) UnresolvedVirtualCall_369,
(const Il2CppMethodPointer) UnresolvedVirtualCall_370,
(const Il2CppMethodPointer) UnresolvedVirtualCall_371,
(const Il2CppMethodPointer) UnresolvedVirtualCall_372,
(const Il2CppMethodPointer) UnresolvedVirtualCall_373,
(const Il2CppMethodPointer) UnresolvedVirtualCall_374,
(const Il2CppMethodPointer) UnresolvedVirtualCall_375,
(const Il2CppMethodPointer) UnresolvedVirtualCall_376,
(const Il2CppMethodPointer) UnresolvedVirtualCall_377,
(const Il2CppMethodPointer) UnresolvedVirtualCall_378,
(const Il2CppMethodPointer) UnresolvedVirtualCall_379,
(const Il2CppMethodPointer) UnresolvedVirtualCall_380,
(const Il2CppMethodPointer) UnresolvedVirtualCall_381,
(const Il2CppMethodPointer) UnresolvedVirtualCall_382,
(const Il2CppMethodPointer) UnresolvedVirtualCall_383,
(const Il2CppMethodPointer) UnresolvedVirtualCall_384,
(const Il2CppMethodPointer) UnresolvedVirtualCall_385,
(const Il2CppMethodPointer) UnresolvedVirtualCall_386,
(const Il2CppMethodPointer) UnresolvedVirtualCall_387,
(const Il2CppMethodPointer) UnresolvedVirtualCall_388,
(const Il2CppMethodPointer) UnresolvedVirtualCall_389,
(const Il2CppMethodPointer) UnresolvedVirtualCall_390,
(const Il2CppMethodPointer) UnresolvedVirtualCall_391,
(const Il2CppMethodPointer) UnresolvedVirtualCall_392,
(const Il2CppMethodPointer) UnresolvedVirtualCall_393,
(const Il2CppMethodPointer) UnresolvedVirtualCall_394,
(const Il2CppMethodPointer) UnresolvedVirtualCall_395,
(const Il2CppMethodPointer) UnresolvedVirtualCall_396,
(const Il2CppMethodPointer) UnresolvedVirtualCall_397,
(const Il2CppMethodPointer) UnresolvedVirtualCall_398,
(const Il2CppMethodPointer) UnresolvedVirtualCall_399,
(const Il2CppMethodPointer) UnresolvedVirtualCall_400,
(const Il2CppMethodPointer) UnresolvedVirtualCall_401,
(const Il2CppMethodPointer) UnresolvedVirtualCall_402,
(const Il2CppMethodPointer) UnresolvedVirtualCall_403,
(const Il2CppMethodPointer) UnresolvedVirtualCall_404,
(const Il2CppMethodPointer) UnresolvedVirtualCall_405,
(const Il2CppMethodPointer) UnresolvedVirtualCall_406,
(const Il2CppMethodPointer) UnresolvedVirtualCall_407,
(const Il2CppMethodPointer) UnresolvedVirtualCall_408,
(const Il2CppMethodPointer) UnresolvedVirtualCall_409,
(const Il2CppMethodPointer) UnresolvedVirtualCall_410,
(const Il2CppMethodPointer) UnresolvedVirtualCall_411,
(const Il2CppMethodPointer) UnresolvedVirtualCall_412,
(const Il2CppMethodPointer) UnresolvedVirtualCall_413,
(const Il2CppMethodPointer) UnresolvedVirtualCall_414,
(const Il2CppMethodPointer) UnresolvedVirtualCall_415,
(const Il2CppMethodPointer) UnresolvedVirtualCall_416,
(const Il2CppMethodPointer) UnresolvedVirtualCall_417,
(const Il2CppMethodPointer) UnresolvedVirtualCall_418,
(const Il2CppMethodPointer) UnresolvedVirtualCall_419,
(const Il2CppMethodPointer) UnresolvedVirtualCall_420,
(const Il2CppMethodPointer) UnresolvedVirtualCall_421,
(const Il2CppMethodPointer) UnresolvedVirtualCall_422,
(const Il2CppMethodPointer) UnresolvedVirtualCall_423,
(const Il2CppMethodPointer) UnresolvedVirtualCall_424,
(const Il2CppMethodPointer) UnresolvedVirtualCall_425,
(const Il2CppMethodPointer) UnresolvedVirtualCall_426,
(const Il2CppMethodPointer) UnresolvedVirtualCall_427,
(const Il2CppMethodPointer) UnresolvedVirtualCall_428,
(const Il2CppMethodPointer) UnresolvedVirtualCall_429,
(const Il2CppMethodPointer) UnresolvedVirtualCall_430,
(const Il2CppMethodPointer) UnresolvedVirtualCall_431,
(const Il2CppMethodPointer) UnresolvedVirtualCall_432,
(const Il2CppMethodPointer) UnresolvedVirtualCall_433,
(const Il2CppMethodPointer) UnresolvedVirtualCall_434,
(const Il2CppMethodPointer) UnresolvedVirtualCall_435,
(const Il2CppMethodPointer) UnresolvedVirtualCall_436,
(const Il2CppMethodPointer) UnresolvedVirtualCall_437,
(const Il2CppMethodPointer) UnresolvedVirtualCall_438,
(const Il2CppMethodPointer) UnresolvedVirtualCall_439,
(const Il2CppMethodPointer) UnresolvedVirtualCall_440,
(const Il2CppMethodPointer) UnresolvedVirtualCall_441,
(const Il2CppMethodPointer) UnresolvedVirtualCall_442,
(const Il2CppMethodPointer) UnresolvedVirtualCall_443,
(const Il2CppMethodPointer) UnresolvedVirtualCall_444,
(const Il2CppMethodPointer) UnresolvedVirtualCall_445,
(const Il2CppMethodPointer) UnresolvedVirtualCall_446,
(const Il2CppMethodPointer) UnresolvedVirtualCall_447,
(const Il2CppMethodPointer) UnresolvedVirtualCall_448,
(const Il2CppMethodPointer) UnresolvedVirtualCall_449,
(const Il2CppMethodPointer) UnresolvedVirtualCall_450,
(const Il2CppMethodPointer) UnresolvedVirtualCall_451,
(const Il2CppMethodPointer) UnresolvedVirtualCall_452,
(const Il2CppMethodPointer) UnresolvedVirtualCall_453,
(const Il2CppMethodPointer) UnresolvedVirtualCall_454,
(const Il2CppMethodPointer) UnresolvedVirtualCall_455,
(const Il2CppMethodPointer) UnresolvedVirtualCall_456,
(const Il2CppMethodPointer) UnresolvedVirtualCall_457,
(const Il2CppMethodPointer) UnresolvedVirtualCall_458,
(const Il2CppMethodPointer) UnresolvedVirtualCall_459,
(const Il2CppMethodPointer) UnresolvedVirtualCall_460,
(const Il2CppMethodPointer) UnresolvedVirtualCall_461,
(const Il2CppMethodPointer) UnresolvedVirtualCall_462,
(const Il2CppMethodPointer) UnresolvedVirtualCall_463,
(const Il2CppMethodPointer) UnresolvedVirtualCall_464,
(const Il2CppMethodPointer) UnresolvedVirtualCall_465,
(const Il2CppMethodPointer) UnresolvedVirtualCall_466,
(const Il2CppMethodPointer) UnresolvedVirtualCall_467,
(const Il2CppMethodPointer) UnresolvedVirtualCall_468,
(const Il2CppMethodPointer) UnresolvedVirtualCall_469,
(const Il2CppMethodPointer) UnresolvedVirtualCall_470,
(const Il2CppMethodPointer) UnresolvedVirtualCall_471,
(const Il2CppMethodPointer) UnresolvedVirtualCall_472,
(const Il2CppMethodPointer) UnresolvedVirtualCall_473,
(const Il2CppMethodPointer) UnresolvedVirtualCall_474,
(const Il2CppMethodPointer) UnresolvedVirtualCall_475,
(const Il2CppMethodPointer) UnresolvedVirtualCall_476,
(const Il2CppMethodPointer) UnresolvedVirtualCall_477,
(const Il2CppMethodPointer) UnresolvedVirtualCall_478,
(const Il2CppMethodPointer) UnresolvedVirtualCall_479,
(const Il2CppMethodPointer) UnresolvedVirtualCall_480,
(const Il2CppMethodPointer) UnresolvedVirtualCall_481,
(const Il2CppMethodPointer) UnresolvedVirtualCall_482,
(const Il2CppMethodPointer) UnresolvedVirtualCall_483,
(const Il2CppMethodPointer) UnresolvedVirtualCall_484,
(const Il2CppMethodPointer) UnresolvedVirtualCall_485,
(const Il2CppMethodPointer) UnresolvedVirtualCall_486,
(const Il2CppMethodPointer) UnresolvedVirtualCall_487,
(const Il2CppMethodPointer) UnresolvedVirtualCall_488,
(const Il2CppMethodPointer) UnresolvedVirtualCall_489,
(const Il2CppMethodPointer) UnresolvedVirtualCall_490,
(const Il2CppMethodPointer) UnresolvedVirtualCall_491,
(const Il2CppMethodPointer) UnresolvedVirtualCall_492,
(const Il2CppMethodPointer) UnresolvedVirtualCall_493,
(const Il2CppMethodPointer) UnresolvedVirtualCall_494,
(const Il2CppMethodPointer) UnresolvedVirtualCall_495,
(const Il2CppMethodPointer) UnresolvedVirtualCall_496,
(const Il2CppMethodPointer) UnresolvedVirtualCall_497,
(const Il2CppMethodPointer) UnresolvedVirtualCall_498,
(const Il2CppMethodPointer) UnresolvedVirtualCall_499,
(const Il2CppMethodPointer) UnresolvedVirtualCall_500,
(const Il2CppMethodPointer) UnresolvedVirtualCall_501,
(const Il2CppMethodPointer) UnresolvedVirtualCall_502,
(const Il2CppMethodPointer) UnresolvedVirtualCall_503,
(const Il2CppMethodPointer) UnresolvedVirtualCall_504,
(const Il2CppMethodPointer) UnresolvedVirtualCall_505,
(const Il2CppMethodPointer) UnresolvedVirtualCall_506,
(const Il2CppMethodPointer) UnresolvedVirtualCall_507,
(const Il2CppMethodPointer) UnresolvedVirtualCall_508,
(const Il2CppMethodPointer) UnresolvedVirtualCall_509,
(const Il2CppMethodPointer) UnresolvedVirtualCall_510,
(const Il2CppMethodPointer) UnresolvedVirtualCall_511,
(const Il2CppMethodPointer) UnresolvedVirtualCall_512,
(const Il2CppMethodPointer) UnresolvedVirtualCall_513,
(const Il2CppMethodPointer) UnresolvedVirtualCall_514,
(const Il2CppMethodPointer) UnresolvedVirtualCall_515,
(const Il2CppMethodPointer) UnresolvedVirtualCall_516,
(const Il2CppMethodPointer) UnresolvedVirtualCall_517,
(const Il2CppMethodPointer) UnresolvedVirtualCall_518,
(const Il2CppMethodPointer) UnresolvedVirtualCall_519,
(const Il2CppMethodPointer) UnresolvedVirtualCall_520,
(const Il2CppMethodPointer) UnresolvedVirtualCall_521,
(const Il2CppMethodPointer) UnresolvedVirtualCall_522,
(const Il2CppMethodPointer) UnresolvedVirtualCall_523,
(const Il2CppMethodPointer) UnresolvedVirtualCall_524,
(const Il2CppMethodPointer) UnresolvedVirtualCall_525,
(const Il2CppMethodPointer) UnresolvedVirtualCall_526,
(const Il2CppMethodPointer) UnresolvedVirtualCall_527,
(const Il2CppMethodPointer) UnresolvedVirtualCall_528,
(const Il2CppMethodPointer) UnresolvedVirtualCall_529,
(const Il2CppMethodPointer) UnresolvedVirtualCall_530,
(const Il2CppMethodPointer) UnresolvedVirtualCall_531,
(const Il2CppMethodPointer) UnresolvedVirtualCall_532,
(const Il2CppMethodPointer) UnresolvedVirtualCall_533,
(const Il2CppMethodPointer) UnresolvedVirtualCall_534,
(const Il2CppMethodPointer) UnresolvedVirtualCall_535,
(const Il2CppMethodPointer) UnresolvedVirtualCall_536,
(const Il2CppMethodPointer) UnresolvedVirtualCall_537,
(const Il2CppMethodPointer) UnresolvedVirtualCall_538,
(const Il2CppMethodPointer) UnresolvedVirtualCall_539,
(const Il2CppMethodPointer) UnresolvedVirtualCall_540,
(const Il2CppMethodPointer) UnresolvedVirtualCall_541,
(const Il2CppMethodPointer) UnresolvedVirtualCall_542,
(const Il2CppMethodPointer) UnresolvedVirtualCall_543,
(const Il2CppMethodPointer) UnresolvedVirtualCall_544,
(const Il2CppMethodPointer) UnresolvedVirtualCall_545,
(const Il2CppMethodPointer) UnresolvedVirtualCall_546,
(const Il2CppMethodPointer) UnresolvedVirtualCall_547,
(const Il2CppMethodPointer) UnresolvedVirtualCall_548,
(const Il2CppMethodPointer) UnresolvedVirtualCall_549,
(const Il2CppMethodPointer) UnresolvedVirtualCall_550,
(const Il2CppMethodPointer) UnresolvedVirtualCall_551,
(const Il2CppMethodPointer) UnresolvedVirtualCall_552,
(const Il2CppMethodPointer) UnresolvedVirtualCall_553,
(const Il2CppMethodPointer) UnresolvedVirtualCall_554,
(const Il2CppMethodPointer) UnresolvedVirtualCall_555,
(const Il2CppMethodPointer) UnresolvedVirtualCall_556,
(const Il2CppMethodPointer) UnresolvedVirtualCall_557,
(const Il2CppMethodPointer) UnresolvedVirtualCall_558,
(const Il2CppMethodPointer) UnresolvedVirtualCall_559,
(const Il2CppMethodPointer) UnresolvedVirtualCall_560,
(const Il2CppMethodPointer) UnresolvedVirtualCall_561,
(const Il2CppMethodPointer) UnresolvedVirtualCall_562,
(const Il2CppMethodPointer) UnresolvedVirtualCall_563,
(const Il2CppMethodPointer) UnresolvedVirtualCall_564,
(const Il2CppMethodPointer) UnresolvedVirtualCall_565,
(const Il2CppMethodPointer) UnresolvedVirtualCall_566,
(const Il2CppMethodPointer) UnresolvedVirtualCall_567,
(const Il2CppMethodPointer) UnresolvedVirtualCall_568,
(const Il2CppMethodPointer) UnresolvedVirtualCall_569,
(const Il2CppMethodPointer) UnresolvedVirtualCall_570,
(const Il2CppMethodPointer) UnresolvedVirtualCall_571,
(const Il2CppMethodPointer) UnresolvedVirtualCall_572,
(const Il2CppMethodPointer) UnresolvedVirtualCall_573,
(const Il2CppMethodPointer) UnresolvedVirtualCall_574,
(const Il2CppMethodPointer) UnresolvedVirtualCall_575,
(const Il2CppMethodPointer) UnresolvedVirtualCall_576,
(const Il2CppMethodPointer) UnresolvedVirtualCall_577,
(const Il2CppMethodPointer) UnresolvedVirtualCall_578,
(const Il2CppMethodPointer) UnresolvedVirtualCall_579,
(const Il2CppMethodPointer) UnresolvedVirtualCall_580,
(const Il2CppMethodPointer) UnresolvedVirtualCall_581,
(const Il2CppMethodPointer) UnresolvedVirtualCall_582,
(const Il2CppMethodPointer) UnresolvedVirtualCall_583,
(const Il2CppMethodPointer) UnresolvedVirtualCall_584,
(const Il2CppMethodPointer) UnresolvedVirtualCall_585,
(const Il2CppMethodPointer) UnresolvedVirtualCall_586,
(const Il2CppMethodPointer) UnresolvedVirtualCall_587,
(const Il2CppMethodPointer) UnresolvedVirtualCall_588,
(const Il2CppMethodPointer) UnresolvedVirtualCall_589,
(const Il2CppMethodPointer) UnresolvedVirtualCall_590,
(const Il2CppMethodPointer) UnresolvedVirtualCall_591,
(const Il2CppMethodPointer) UnresolvedVirtualCall_592,
(const Il2CppMethodPointer) UnresolvedVirtualCall_593,
(const Il2CppMethodPointer) UnresolvedVirtualCall_594,
(const Il2CppMethodPointer) UnresolvedVirtualCall_595,
(const Il2CppMethodPointer) UnresolvedVirtualCall_596,
(const Il2CppMethodPointer) UnresolvedVirtualCall_597,
(const Il2CppMethodPointer) UnresolvedVirtualCall_598,
(const Il2CppMethodPointer) UnresolvedVirtualCall_599,
(const Il2CppMethodPointer) UnresolvedVirtualCall_600,
(const Il2CppMethodPointer) UnresolvedVirtualCall_601,
(const Il2CppMethodPointer) UnresolvedVirtualCall_602,
(const Il2CppMethodPointer) UnresolvedVirtualCall_603,
(const Il2CppMethodPointer) UnresolvedVirtualCall_604,
(const Il2CppMethodPointer) UnresolvedVirtualCall_605,
(const Il2CppMethodPointer) UnresolvedVirtualCall_606,
(const Il2CppMethodPointer) UnresolvedVirtualCall_607,
(const Il2CppMethodPointer) UnresolvedVirtualCall_608,
(const Il2CppMethodPointer) UnresolvedVirtualCall_609,
(const Il2CppMethodPointer) UnresolvedVirtualCall_610,
(const Il2CppMethodPointer) UnresolvedVirtualCall_611,
(const Il2CppMethodPointer) UnresolvedVirtualCall_612,
(const Il2CppMethodPointer) UnresolvedVirtualCall_613,
(const Il2CppMethodPointer) UnresolvedVirtualCall_614,
(const Il2CppMethodPointer) UnresolvedVirtualCall_615,
(const Il2CppMethodPointer) UnresolvedVirtualCall_616,
(const Il2CppMethodPointer) UnresolvedVirtualCall_617,
(const Il2CppMethodPointer) UnresolvedVirtualCall_618,
(const Il2CppMethodPointer) UnresolvedVirtualCall_619,
(const Il2CppMethodPointer) UnresolvedVirtualCall_620,
(const Il2CppMethodPointer) UnresolvedVirtualCall_621,
(const Il2CppMethodPointer) UnresolvedVirtualCall_622,
(const Il2CppMethodPointer) UnresolvedVirtualCall_623,
(const Il2CppMethodPointer) UnresolvedVirtualCall_624,
(const Il2CppMethodPointer) UnresolvedVirtualCall_625,
(const Il2CppMethodPointer) UnresolvedVirtualCall_626,
(const Il2CppMethodPointer) UnresolvedVirtualCall_627,
(const Il2CppMethodPointer) UnresolvedVirtualCall_628,
(const Il2CppMethodPointer) UnresolvedVirtualCall_629,
(const Il2CppMethodPointer) UnresolvedVirtualCall_630,
(const Il2CppMethodPointer) UnresolvedVirtualCall_631,
(const Il2CppMethodPointer) UnresolvedVirtualCall_632,
(const Il2CppMethodPointer) UnresolvedVirtualCall_633,
(const Il2CppMethodPointer) UnresolvedVirtualCall_634,
(const Il2CppMethodPointer) UnresolvedVirtualCall_635,
(const Il2CppMethodPointer) UnresolvedVirtualCall_636,
(const Il2CppMethodPointer) UnresolvedVirtualCall_637,
(const Il2CppMethodPointer) UnresolvedVirtualCall_638,
(const Il2CppMethodPointer) UnresolvedVirtualCall_639,
(const Il2CppMethodPointer) UnresolvedVirtualCall_640,
(const Il2CppMethodPointer) UnresolvedVirtualCall_641,
(const Il2CppMethodPointer) UnresolvedVirtualCall_642,
(const Il2CppMethodPointer) UnresolvedVirtualCall_643,
(const Il2CppMethodPointer) UnresolvedVirtualCall_644,
(const Il2CppMethodPointer) UnresolvedVirtualCall_645,
(const Il2CppMethodPointer) UnresolvedVirtualCall_646,
(const Il2CppMethodPointer) UnresolvedVirtualCall_647,
(const Il2CppMethodPointer) UnresolvedVirtualCall_648,
(const Il2CppMethodPointer) UnresolvedVirtualCall_649,
(const Il2CppMethodPointer) UnresolvedVirtualCall_650,
(const Il2CppMethodPointer) UnresolvedVirtualCall_651,
(const Il2CppMethodPointer) UnresolvedVirtualCall_652,
(const Il2CppMethodPointer) UnresolvedVirtualCall_653,
(const Il2CppMethodPointer) UnresolvedVirtualCall_654,
(const Il2CppMethodPointer) UnresolvedVirtualCall_655,
(const Il2CppMethodPointer) UnresolvedVirtualCall_656,
(const Il2CppMethodPointer) UnresolvedVirtualCall_657,
(const Il2CppMethodPointer) UnresolvedVirtualCall_658,
(const Il2CppMethodPointer) UnresolvedVirtualCall_659,
(const Il2CppMethodPointer) UnresolvedVirtualCall_660,
(const Il2CppMethodPointer) UnresolvedVirtualCall_661,
(const Il2CppMethodPointer) UnresolvedVirtualCall_662,
(const Il2CppMethodPointer) UnresolvedVirtualCall_663,
(const Il2CppMethodPointer) UnresolvedVirtualCall_664,
(const Il2CppMethodPointer) UnresolvedVirtualCall_665,
(const Il2CppMethodPointer) UnresolvedVirtualCall_666,
(const Il2CppMethodPointer) UnresolvedVirtualCall_667,
(const Il2CppMethodPointer) UnresolvedVirtualCall_668,
(const Il2CppMethodPointer) UnresolvedVirtualCall_669,
(const Il2CppMethodPointer) UnresolvedVirtualCall_670,
(const Il2CppMethodPointer) UnresolvedVirtualCall_671,
(const Il2CppMethodPointer) UnresolvedVirtualCall_672,
(const Il2CppMethodPointer) UnresolvedVirtualCall_673,
(const Il2CppMethodPointer) UnresolvedVirtualCall_674,
(const Il2CppMethodPointer) UnresolvedVirtualCall_675,
(const Il2CppMethodPointer) UnresolvedVirtualCall_676,
(const Il2CppMethodPointer) UnresolvedVirtualCall_677,
(const Il2CppMethodPointer) UnresolvedVirtualCall_678,
(const Il2CppMethodPointer) UnresolvedVirtualCall_679,
(const Il2CppMethodPointer) UnresolvedVirtualCall_680,
(const Il2CppMethodPointer) UnresolvedVirtualCall_681,
(const Il2CppMethodPointer) UnresolvedVirtualCall_682,
(const Il2CppMethodPointer) UnresolvedVirtualCall_683,
(const Il2CppMethodPointer) UnresolvedVirtualCall_684,
(const Il2CppMethodPointer) UnresolvedVirtualCall_685,
(const Il2CppMethodPointer) UnresolvedVirtualCall_686,
(const Il2CppMethodPointer) UnresolvedVirtualCall_687,
(const Il2CppMethodPointer) UnresolvedVirtualCall_688,
(const Il2CppMethodPointer) UnresolvedVirtualCall_689,
(const Il2CppMethodPointer) UnresolvedVirtualCall_690,
(const Il2CppMethodPointer) UnresolvedVirtualCall_691,
(const Il2CppMethodPointer) UnresolvedVirtualCall_692,
(const Il2CppMethodPointer) UnresolvedVirtualCall_693,
(const Il2CppMethodPointer) UnresolvedVirtualCall_694,
(const Il2CppMethodPointer) UnresolvedVirtualCall_695,
(const Il2CppMethodPointer) UnresolvedVirtualCall_696,
(const Il2CppMethodPointer) UnresolvedVirtualCall_697,
(const Il2CppMethodPointer) UnresolvedVirtualCall_698,
(const Il2CppMethodPointer) UnresolvedVirtualCall_699,
(const Il2CppMethodPointer) UnresolvedVirtualCall_700,
(const Il2CppMethodPointer) UnresolvedVirtualCall_701,
(const Il2CppMethodPointer) UnresolvedVirtualCall_702,
(const Il2CppMethodPointer) UnresolvedVirtualCall_703,
(const Il2CppMethodPointer) UnresolvedVirtualCall_704,
(const Il2CppMethodPointer) UnresolvedVirtualCall_705,
(const Il2CppMethodPointer) UnresolvedVirtualCall_706,
(const Il2CppMethodPointer) UnresolvedVirtualCall_707,
(const Il2CppMethodPointer) UnresolvedVirtualCall_708,
(const Il2CppMethodPointer) UnresolvedVirtualCall_709,
(const Il2CppMethodPointer) UnresolvedVirtualCall_710,
(const Il2CppMethodPointer) UnresolvedVirtualCall_711,
(const Il2CppMethodPointer) UnresolvedVirtualCall_712,
(const Il2CppMethodPointer) UnresolvedVirtualCall_713,
(const Il2CppMethodPointer) UnresolvedVirtualCall_714,
(const Il2CppMethodPointer) UnresolvedVirtualCall_715,
(const Il2CppMethodPointer) UnresolvedVirtualCall_716,
(const Il2CppMethodPointer) UnresolvedVirtualCall_717,
(const Il2CppMethodPointer) UnresolvedVirtualCall_718,
(const Il2CppMethodPointer) UnresolvedVirtualCall_719,
(const Il2CppMethodPointer) UnresolvedVirtualCall_720,
(const Il2CppMethodPointer) UnresolvedVirtualCall_721,
(const Il2CppMethodPointer) UnresolvedVirtualCall_722,
(const Il2CppMethodPointer) UnresolvedVirtualCall_723,
(const Il2CppMethodPointer) UnresolvedVirtualCall_724,
(const Il2CppMethodPointer) UnresolvedVirtualCall_725,
(const Il2CppMethodPointer) UnresolvedVirtualCall_726,
(const Il2CppMethodPointer) UnresolvedVirtualCall_727,
(const Il2CppMethodPointer) UnresolvedVirtualCall_728,
(const Il2CppMethodPointer) UnresolvedVirtualCall_729,
(const Il2CppMethodPointer) UnresolvedVirtualCall_730,
(const Il2CppMethodPointer) UnresolvedVirtualCall_731,
(const Il2CppMethodPointer) UnresolvedVirtualCall_732,
(const Il2CppMethodPointer) UnresolvedVirtualCall_733,
(const Il2CppMethodPointer) UnresolvedVirtualCall_734,
(const Il2CppMethodPointer) UnresolvedVirtualCall_735,
(const Il2CppMethodPointer) UnresolvedVirtualCall_736,
(const Il2CppMethodPointer) UnresolvedVirtualCall_737,
(const Il2CppMethodPointer) UnresolvedVirtualCall_738,
(const Il2CppMethodPointer) UnresolvedVirtualCall_739,
(const Il2CppMethodPointer) UnresolvedVirtualCall_740,
(const Il2CppMethodPointer) UnresolvedVirtualCall_741,
(const Il2CppMethodPointer) UnresolvedVirtualCall_742,
(const Il2CppMethodPointer) UnresolvedVirtualCall_743,
(const Il2CppMethodPointer) UnresolvedVirtualCall_744,
(const Il2CppMethodPointer) UnresolvedVirtualCall_745,
(const Il2CppMethodPointer) UnresolvedVirtualCall_746,
(const Il2CppMethodPointer) UnresolvedVirtualCall_747,
(const Il2CppMethodPointer) UnresolvedVirtualCall_748,
(const Il2CppMethodPointer) UnresolvedVirtualCall_749,
(const Il2CppMethodPointer) UnresolvedVirtualCall_750,
(const Il2CppMethodPointer) UnresolvedVirtualCall_751,
(const Il2CppMethodPointer) UnresolvedVirtualCall_752,
(const Il2CppMethodPointer) UnresolvedVirtualCall_753,
(const Il2CppMethodPointer) UnresolvedVirtualCall_754,
(const Il2CppMethodPointer) UnresolvedVirtualCall_755,
(const Il2CppMethodPointer) UnresolvedVirtualCall_756,
(const Il2CppMethodPointer) UnresolvedVirtualCall_757,
(const Il2CppMethodPointer) UnresolvedVirtualCall_758,
(const Il2CppMethodPointer) UnresolvedVirtualCall_759,
(const Il2CppMethodPointer) UnresolvedVirtualCall_760,
(const Il2CppMethodPointer) UnresolvedVirtualCall_761,
(const Il2CppMethodPointer) UnresolvedVirtualCall_762,
(const Il2CppMethodPointer) UnresolvedVirtualCall_763,
(const Il2CppMethodPointer) UnresolvedVirtualCall_764,
(const Il2CppMethodPointer) UnresolvedVirtualCall_765,
(const Il2CppMethodPointer) UnresolvedVirtualCall_766,
(const Il2CppMethodPointer) UnresolvedVirtualCall_767,
(const Il2CppMethodPointer) UnresolvedVirtualCall_768,
(const Il2CppMethodPointer) UnresolvedVirtualCall_769,
(const Il2CppMethodPointer) UnresolvedVirtualCall_770,
(const Il2CppMethodPointer) UnresolvedVirtualCall_771,
(const Il2CppMethodPointer) UnresolvedVirtualCall_772,
(const Il2CppMethodPointer) UnresolvedVirtualCall_773,
(const Il2CppMethodPointer) UnresolvedVirtualCall_774,
(const Il2CppMethodPointer) UnresolvedVirtualCall_775,
(const Il2CppMethodPointer) UnresolvedVirtualCall_776,
(const Il2CppMethodPointer) UnresolvedVirtualCall_777,
(const Il2CppMethodPointer) UnresolvedVirtualCall_778,
(const Il2CppMethodPointer) UnresolvedVirtualCall_779,
(const Il2CppMethodPointer) UnresolvedVirtualCall_780,
(const Il2CppMethodPointer) UnresolvedVirtualCall_781,
(const Il2CppMethodPointer) UnresolvedVirtualCall_782,
(const Il2CppMethodPointer) UnresolvedVirtualCall_783,
(const Il2CppMethodPointer) UnresolvedVirtualCall_784,
(const Il2CppMethodPointer) UnresolvedVirtualCall_785,
(const Il2CppMethodPointer) UnresolvedVirtualCall_786,
(const Il2CppMethodPointer) UnresolvedVirtualCall_787,
(const Il2CppMethodPointer) UnresolvedVirtualCall_788,
(const Il2CppMethodPointer) UnresolvedVirtualCall_789,
(const Il2CppMethodPointer) UnresolvedVirtualCall_790,
(const Il2CppMethodPointer) UnresolvedVirtualCall_791,
};
| 47.518642 | 384 | 0.849346 | [
"mesh",
"object",
"transform"
] |
476aaea30a97da287f04943434c5c110ee14a1af | 2,795 | cc | C++ | pmlc/util/strides.cc | hfp/plaidml | c86852a910e68181781b3045f5a306d2f41a775f | [
"Apache-2.0"
] | null | null | null | pmlc/util/strides.cc | hfp/plaidml | c86852a910e68181781b3045f5a306d2f41a775f | [
"Apache-2.0"
] | 65 | 2020-08-24T07:41:09.000Z | 2021-07-19T09:13:49.000Z | pmlc/util/strides.cc | Flex-plaidml-team/plaidml | 1070411a87b3eb3d94674d4d041ed904be3e7d87 | [
"Apache-2.0"
] | null | null | null | // Copyright 2020 Intel Corporation
#include "pmlc/util/strides.h"
#include <vector>
#include "mlir/Analysis/AffineStructures.h"
#include "pmlc/util/logging.h"
namespace pmlc::util {
StrideArray::StrideArray(unsigned numDims, int64_t offset)
: offset(offset), strides(numDims) {}
StrideArray &StrideArray::operator*=(int64_t factor) {
offset *= factor;
for (auto &dim : strides)
dim *= factor;
return *this;
}
StrideArray &StrideArray::operator+=(const StrideArray &rhs) {
assert(strides.size() == rhs.strides.size() && "strides sizes much match");
offset += rhs.offset;
for (unsigned i = 0, e = strides.size(); i < e; ++i) {
strides[i] += rhs.strides[i];
}
return *this;
}
std::ostream &operator<<(std::ostream &os, const StrideArray &val) {
os << val.offset << ":[";
for (auto item : llvm::enumerate(val.strides)) {
if (item.index())
os << ", ";
os << item.value();
}
os << ']';
return os;
}
llvm::Optional<StrideArray> computeStrideArray(mlir::AffineMap map) {
assert(map.getNumResults() == 1);
std::vector<llvm::SmallVector<int64_t, 8>> flat;
if (failed(getFlattenedAffineExprs(map, &flat, nullptr)))
return llvm::None;
StrideArray ret(map.getNumDims(), flat.front().back());
for (unsigned i = 0, e = map.getNumDims(); i < e; i++) {
ret.strides[i] = flat.front()[i];
}
return ret;
}
mlir::Optional<StrideArray> computeStrideArray(mlir::MemRefType memRefType,
mlir::AffineMap map) {
assert(map.getNumResults() == memRefType.getRank());
// MLIR doesnt' corrently handle rank 0 in some places, early exit
if (memRefType.getRank() == 0) {
return StrideArray(map.getNumDims(), 0);
}
// Get the memref strides
int64_t offset;
llvm::SmallVector<int64_t, 4> strides;
if (failed(getStridesAndOffset(memRefType, strides, offset)))
return llvm::None;
// Get the dimensionalized map multipliers
std::vector<llvm::SmallVector<int64_t, 8>> flat;
if (failed(getFlattenedAffineExprs(map, &flat, nullptr))) {
return llvm::None;
}
// Flatten the per-dimension data via memory order
StrideArray ret(map.getNumDims(), offset);
for (unsigned d = 0; d < memRefType.getRank(); d++) {
StrideArray perDim(map.getNumDims(), flat[d].back());
for (unsigned i = 0, e = map.getNumDims(); i < e; i++) {
perDim.strides[i] = flat[d][i];
}
perDim *= strides[d];
ret += perDim;
}
return ret;
}
mlir::Optional<StrideArray> computeStrideArray(mlir::TensorType tensorType,
mlir::AffineMap map) {
auto memRefType =
mlir::MemRefType::get(tensorType.getShape(), tensorType.getElementType());
return computeStrideArray(memRefType, map);
}
} // namespace pmlc::util
| 28.520408 | 80 | 0.642576 | [
"vector"
] |
476f96e6ef8fe4395e0a28a1ffc9fde3c01cdc67 | 3,804 | hpp | C++ | src/Application.hpp | tomas-krupa/ansi_iso_accuracy_test | a87600c1ff8997cd689539432e5badaa1bf8a776 | [
"Apache-2.0"
] | null | null | null | src/Application.hpp | tomas-krupa/ansi_iso_accuracy_test | a87600c1ff8997cd689539432e5badaa1bf8a776 | [
"Apache-2.0"
] | null | null | null | src/Application.hpp | tomas-krupa/ansi_iso_accuracy_test | a87600c1ff8997cd689539432e5badaa1bf8a776 | [
"Apache-2.0"
] | null | null | null | /**
* @file Application.hpp
*
* @copyright Copyright (c) 2020 Innovatrics s.r.o. All rights reserved.
*
* @maintainer Tomas Krupa <tomas.krupa@innovatrics.com>
* @created 10.08.2020
*
*/
#pragma once
#include <AnsiIso/AnsiIso.hpp>
#include <Configuration/ProgramConfiguration.hpp>
#include <Filesystem/BoostDirectory.hpp>
#include <Filesystem/BoostFilesystem.hpp>
#include <Logger/Logger.hpp>
#include <Biometric/AnsiIsoBiometric.hpp>
#include <Storage/BiometricStorage.hpp>
#include <Storage/OutputStorageFactory.hpp>
class AnsiIso;
class AnsiIsoNativeInterface;
/**
* @brief Application
*
* Facade class covering the core logic of the application.
*
*/
class Application
{
public:
using TPath = boost::filesystem::path;
using TFile = BoostMMFile<TPath>;
using TFilesystem = BoostFilesystem<BoostDirectory<TPath>, TFile>;
using TOptions = Options<boost::program_options::options_description>;
using TConfiguration = ProgramConfiguration<TFilesystem, TOptions>;
using TBiometricStorage = BiometricStorage<TFile>;
using TFileStorage = FileStorage<TFile>;
using TOutputStorageFactory = OutputStorageFactory<TFilesystem, TConfiguration, TFileStorage>;
using TStorageFactory = StorageFactory<TOutputStorageFactory,TFileStorage>;
using TBiometric = AnsiIsoBiometric<TBiometricStorage,BoostLogger,TConfiguration>;
Application(const TConfiguration &configuration,
const TFilesystem &filesystem,
const BoostLogger &logger,
const TStorageFactory& storageFactory,
const TBiometric &biometric );
/**
* @brief Run
*
* Application's core function. Initializes filesystem handler, reads program
* configuration, prepares native library and run Application's main function.
*
* @param ansiIsoNative instance of native library tested by the application
* @param logger instance of a Boost-derived logger
*/
void Run();
private:
const TFilesystem& _filesystem;
const TConfiguration& _configuration;
const BoostLogger& _logger;
const TBiometric& _biometric;
const std::unique_ptr<TBiometricStorage> _biometricStorage;
const std::unique_ptr<TFileStorage> _templateListStorage;
const std::unique_ptr<TFileStorage> _genuinesStorage;
const std::unique_ptr<TFileStorage> _impostorsStorage;
const CSVReader<TFileStorage,int,std::string> _templateListReader;
const CSVReader<TFileStorage,int,int> _genuinesReader;
const CSVReader<TFileStorage,int,int> _impostorsReader;
std::map<int,std::string> _templatesMap;
std::map<int,int> _genuinesPairs;
std::map<int,int> _impostorsPairs;
using TBiometricResult = BiometricResult<BiometricRecord>;
std::vector<TBiometricResult> _genuinesResults;
std::vector<TBiometricResult> _impostorsResults;
/**
* @brief measureMatches
*
* Match all input pairs and assigns them matching score.
*
* @return vector of match results
*/
static std::vector<Application::TBiometricResult> measureMatches(const std::map<int,int>& pairs);
/**
* @brief loadStorage
*
* Load input text files and templates from filesystem to storage.
*/
void loadStorages();
/**
* @brief measureResults
*
* Performs test scenario with recording accuracy and performance.
*/
void measureResults();
/**
* @brief storeResults
*
* Stores raw accuracy scores and API call performace in the filesystem.
*/
void storeResults();
/**
* @brief generateStatistics
*
* Generates various accuracy statistics (FARatFRR, ERR, DET) and performance
* summary.
*/
void generateStatistics();
/**
* @brief storeStatistics
*
* Stores accuracy and performance summary in the filesystem.
*/
void storeStatistics();
}; | 30.190476 | 99 | 0.727655 | [
"vector"
] |
47801c175ae441392865d81c8bfaba51e82656ef | 67,869 | cxx | C++ | osprey/kg++fe/tree_symtab.cxx | sharugupta/OpenUH | daddd76858a53035f5d713f648d13373c22506e8 | [
"BSD-2-Clause"
] | null | null | null | osprey/kg++fe/tree_symtab.cxx | sharugupta/OpenUH | daddd76858a53035f5d713f648d13373c22506e8 | [
"BSD-2-Clause"
] | null | null | null | osprey/kg++fe/tree_symtab.cxx | sharugupta/OpenUH | daddd76858a53035f5d713f648d13373c22506e8 | [
"BSD-2-Clause"
] | null | null | null | /*
* Copyright (C) 2009 Advanced Micro Devices, Inc. All Rights Reserved.
*/
/*
* Copyright (C) 2006. QLogic Corporation. All Rights Reserved.
*/
/*
Copyright 2003, 2004, 2005, 2006 PathScale, Inc. All Rights Reserved.
File modified October 9, 2003 by PathScale, Inc. to update Open64 C/C++
front-ends to GNU 3.3.1 release.
*/
/*
Copyright (C) 2002 Tensilica, Inc. All Rights Reserved.
Revised to support Tensilica processors and to improve overall performance
*/
/*
Copyright (C) 2000, 2001 Silicon Graphics, Inc. All Rights Reserved.
This program is free software; you can redistribute it and/or modify it
under the terms of version 2 of the GNU General Public License as
published by the Free Software Foundation.
This program is distributed in the hope that it would be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
Further, this software is distributed without any warranty that it is
free of the rightful claim of any third person regarding infringement
or the like. Any license provided herein, whether implied or
otherwise, applies only to this software file. Patent licenses, if
any, provided herein do not apply to combinations of this program with
other software, or any other product whatsoever.
You should have received a copy of the GNU General Public License along
with this program; if not, write the Free Software Foundation, Inc., 59
Temple Place - Suite 330, Boston MA 02111-1307, USA.
Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pky,
Mountain View, CA 94043, or:
http://www.sgi.com
For further information regarding this notice, see:
http://oss.sgi.com/projects/GenInfo/NoticeExplan
*/
/* translate gnu decl trees to symtab references */
#include <values.h>
#include "defs.h"
#include "errors.h"
extern "C" {
#include "gnu_config.h"
}
#ifdef KEY // get HW_WIDE_INT for flags.h
#include "gnu/hwint.h"
#endif /* KEY */
extern "C" {
#include "gnu/flags.h"
#include "gnu/system.h"
#include "gnu/tree.h"
#include "cp-tree.h"
}
#undef TARGET_PENTIUM // hack around macro definition in gnu
#if defined(TARG_PPC32)
#undef TARGET_POWERPC
#endif /* TARG_PPC32 */
#include "symtab.h"
#include "strtab.h"
#include "wn.h"
#include "wfe_expr.h"
#include "wfe_decl.h"
#include "wfe_misc.h"
#include "wfe_dst.h"
#include "ir_reader.h"
#include "tree_symtab.h"
#ifdef KEY
#include "wfe_stmt.h"
#include <map>
#endif
#include "tree_cmp.h"
#include <ext/hash_map>
using __gnu_cxx::hash_map;
typedef struct {
size_t operator()(void* p) const { return reinterpret_cast<size_t>(p); }
} void_ptr_hash;
extern INT pstatic_as_global;
extern FILE *tree_dump_file; /* for debugging */
extern void Push_Deferred_Function(tree);
#ifdef KEY
extern void WFE_add_pragma_to_enclosing_regions (WN_PRAGMA_ID, ST *);
// Map duplicate gcc nodes that refer to the same function.
std::multimap<tree, tree> duplicate_of;
void
add_duplicates (tree newdecl, tree olddecl)
{
duplicate_of.insert (pair<tree, tree>(newdecl, olddecl));
duplicate_of.insert (pair<tree, tree>(olddecl, newdecl));
}
// Remove all references to DECL from the map.
void
erase_duplicates (tree decl)
{
int i, j;
int count = duplicate_of.count (decl);
for (i=0; i<count; i++) {
std::multimap<tree, tree>::iterator iter = duplicate_of.find(decl);
tree t = (*iter).second;
// Erase entries with DECL as the data, i.e., <..., DECL>.
int count2 = duplicate_of.count(t);
for (j=0; j<count2; j++) {
std::multimap<tree, tree>::iterator iter2 = duplicate_of.find(t);
tree t2 = (*iter2).second;
if (t2 == decl) {
duplicate_of.erase (iter2);
}
}
// Erase entry with DECL as the key, i.e., <DECL, ...>.
duplicate_of.erase (iter);
}
}
static ST*
get_duplicate_st (tree decl)
{
int count = duplicate_of.count (decl);
for (int i=0; i<count; ++i) {
std::multimap<tree, tree>::iterator iter = duplicate_of.find(decl);
tree t = (*iter).second;
// The node t could have been garbage-collected by gcc. This is a crude
// test to see if t is still valid.
if (TREE_CODE(t) == FUNCTION_DECL &&
DECL_NAME(t) == DECL_NAME(decl) &&
DECL_ASSEMBLER_NAME_SET_P(t) == DECL_ASSEMBLER_NAME_SET_P(decl) &&
(!DECL_ASSEMBLER_NAME_SET_P(t) ||
DECL_ASSEMBLER_NAME(t) == DECL_ASSEMBLER_NAME(decl))) {
// Return the ST previously allocated, if any.
ST *st = DECL_ST(t);
if (st != NULL)
return st;
}
duplicate_of.erase (iter);
}
return NULL;
}
#endif
static char*
Get_Name (tree node)
{
static UINT anon_num = 0;
static char buf[64];
if (node == NULL) {
++anon_num;
sprintf(buf, ".anonymous.%d", anon_num);
return buf;
}
else if (TREE_CODE (node) == IDENTIFIER_NODE)
return ((char *) IDENTIFIER_POINTER (node));
else if (TREE_CODE (node) == TYPE_DECL)
// If type has a typedef-name, the TYPE_NAME is a TYPE_DECL.
return ((char *) IDENTIFIER_POINTER (DECL_NAME (node)));
else
FmtAssert(FALSE, ("Get_Name unexpected tree"));
return NULL;
}
#ifdef TARG_SL
/* this function only return signed mtype and the function MTYPE_complement will do
* conversion from signed type to unsigned type if current type is unsigned type */
TYPE_ID
Get_Mtype_For_Integer_Type(tree type_tree, INT64 tsize)
{
TYPE_ID mtype;
switch(tsize) {
case 1:
/*
if(TYPE_VBUF_P(type_tree)) {
if(TYPE_VBUF1(type_tree)) {
mtype = MTYPE_VBUF1;
}
else if(TYPE_VBUF2(type_tree))
{
mtype = MTYPE_VBUF2;
}
else if(TYPE_VBUF4(type_tree))
{
mtype = MTYPE_VBUF4;
}
}
else if(TYPE_SBUF(type_tree)) {
mtype = MTYPE_SB1;
}
else if(TYPE_SDRAM(type_tree)){
mtype = MTYPE_SD1;
}
else {
mtype = MTYPE_I1;
}
*/
/* we will use above code when mtype is ready */
mtype = MTYPE_I1;
break;
case 2:
/*
if(TYPE_SBUF(type_tree)) {
mtype = MTYPE_SB2;
}
else if(TYPE_SDRAM(type_tree)) {
mtype = MTYPE_SD2;
}
else {
mtype = MTYPE_I2;
}
*/
mtype = MTYPE_I2;
break;
case 4:
/*
if(TYPE_SBUF(type_tree)) {
mtype = MTYPE_SB4;
}
else if(TYPE_SDRAM(type_tree)){
mtype = MTYPE_SD4;
}
else {
mtype = MTYPE_I4;
}
*/
mtype = MTYPE_I4;
break;
case 8:
DevWarn("8 byte types being used");
mtype = MTYPE_I8;
/*
if(TYPE_SBUF(type_tree)) {
mtype = MTYPE_SB8;
}
else if(TYPE_SDRAM(type_tree)){
mtype = MTYPE_SD8;
}
else {
mtype = MTYPE_I8;
}
*/
break;
}
return mtype;
}
#endif
static void
dump_field(tree field)
{
printf("%s: ", Get_Name(DECL_NAME(field)));
printf("%d\n", DECL_FIELD_ID(field));
}
tree
next_real_or_virtual_field (tree type_tree, tree field)
{
static bool real_field = true;
#ifdef KEY
static tree prev_field = NULL_TREE;
// If FIELD is not the same as the previously returned field, then we are
// being called to traverse a new list or to traverse the same list over
// again. In either case, begin with the real fields.
if (field != prev_field)
real_field = true;
if (field == TYPE_VFIELD(type_tree))
real_field = false;
if (TREE_CHAIN(field))
return (prev_field = TREE_CHAIN(field));
if (real_field && TYPE_VFIELD(type_tree)) {
real_field = false;
return (prev_field = TYPE_VFIELD(type_tree));
}
real_field = true;
return (prev_field = NULL_TREE);
#else
if (field == TYPE_VFIELD(type_tree))
real_field = false;
if (TREE_CHAIN(field))
return TREE_CHAIN(field);
if (real_field && TYPE_VFIELD(type_tree)) {
real_field = false;
return TYPE_VFIELD(type_tree);
}
real_field = true;
return NULL_TREE;
#endif // KEY
}
static void
Do_Base_Types (tree type_tree)
{
tree binfo = TYPE_BINFO(type_tree);
tree basetypes = binfo ? BINFO_BASETYPES(binfo) : 0;
INT32 i;
if (basetypes)
for (i = 0; i < TREE_VEC_LENGTH(basetypes); ++i)
(void) Get_TY (BINFO_TYPE(TREE_VEC_ELT(basetypes, i)));
}
size_t
Roundup (size_t offset, int alignment)
{
return (offset % alignment) ? offset + alignment - offset % alignment
: offset;
}
size_t
Type_Size_Without_Vbases (tree type_tree)
{
tree field;
tree last_field_decl = 0;
for (field = TYPE_FIELDS(type_tree);
field;
field = next_real_or_virtual_field (type_tree, field)) {
if (TREE_CODE(field) == FIELD_DECL)
last_field_decl = field;
}
if (last_field_decl == 0)
return 0;
return
Get_Integer_Value (DECL_FIELD_OFFSET(last_field_decl)) +
Get_Integer_Value (DECL_FIELD_BIT_OFFSET(last_field_decl)) / BITSPERBYTE +
Get_Integer_Value (DECL_SIZE(last_field_decl)) / BITSPERBYTE;
}
bool
is_empty_base_class (tree type_tree)
{
tree field = TYPE_FIELDS(type_tree);
return TREE_CODE(field) == TYPE_DECL && TREE_CHAIN(field) == 0;
}
// idx is non-zero only for RECORD and UNION, when there is forward declaration
extern TY_IDX
Create_TY_For_Tree (tree type_tree, TY_IDX idx)
{
if(TREE_CODE(type_tree) == ERROR_MARK)
return idx;
TY_IDX orig_idx = idx;
if(TREE_CODE_CLASS(TREE_CODE(type_tree)) != 't') {
DevWarn("Bad tree class passed to Create_TY_For_Tree %c",
TREE_CODE_CLASS(TREE_CODE(type_tree)));
return idx;
}
#ifdef KEY
UINT align = TYPE_ALIGN(type_tree) / BITSPERBYTE;
#endif
// for typedefs get the information from the base type
if (TYPE_NAME(type_tree) &&
idx == 0 &&
(TREE_CODE(type_tree) == RECORD_TYPE ||
TREE_CODE(type_tree) == UNION_TYPE) &&
TREE_CODE(TYPE_NAME(type_tree)) == TYPE_DECL &&
TYPE_MAIN_VARIANT(type_tree) != type_tree) {
idx = Get_TY (TYPE_MAIN_VARIANT(type_tree));
if (TYPE_READONLY(type_tree))
Set_TY_is_const (idx);
if (TYPE_VOLATILE(type_tree))
Set_TY_is_volatile (idx);
#ifdef KEY
if (TYPE_RESTRICT(type_tree))
Set_TY_is_restrict (idx);
Set_TY_align (idx, align); // bug 10533
#endif
TYPE_TY_IDX(type_tree) = idx;
if(Debug_Level >= 2) {
DST_INFO_IDX dst = Create_DST_type_For_Tree(type_tree,
idx,orig_idx);
TYPE_DST_IDX(type_tree) = dst;
}
TYPE_FIELD_IDS_USED(type_tree) =
TYPE_FIELD_IDS_USED(TYPE_MAIN_VARIANT(type_tree));
return idx;
}
TYPE_ID mtype;
INT64 tsize;
BOOL variable_size = FALSE;
tree type_size = TYPE_SIZE(type_tree);
#ifndef KEY
UINT align = TYPE_ALIGN(type_tree) / BITSPERBYTE;
#endif
if (type_size == NULL) {
// incomplete structs have 0 size. Similarly, 'void' is
// an incomplete type that can never be completed.
FmtAssert(TREE_CODE(type_tree) == ARRAY_TYPE
|| TREE_CODE(type_tree) == ENUMERAL_TYPE
|| TREE_CODE(type_tree) == UNION_TYPE
|| TREE_CODE(type_tree) == RECORD_TYPE
|| TREE_CODE(type_tree) == LANG_TYPE
|| TREE_CODE(type_tree) == VOID_TYPE,
("Create_TY_For_Tree: type_size NULL for non ARRAY/RECORD/VOID, type is %d",
(int) TREE_CODE(type_tree)));
tsize = 0;
}
else {
if (TREE_CODE(type_size) != INTEGER_CST) {
if (TREE_CODE(type_tree) == ARRAY_TYPE)
DevWarn ("Encountered VLA at line %d", lineno);
else
Fail_FmtAssertion ("VLA at line %d not currently implemented", lineno);
variable_size = TRUE;
tsize = 0;
}
else
#ifdef KEY // bug 3045
tsize = (Get_Integer_Value(type_size) + BITSPERBYTE - 1)
/ BITSPERBYTE;
#else
tsize = Get_Integer_Value(type_size) / BITSPERBYTE;
#endif
}
switch (TREE_CODE(type_tree)) {
case VOID_TYPE:
case LANG_TYPE: // unknown type
idx = MTYPE_To_TY (MTYPE_V); // use predefined type
break;
case BOOLEAN_TYPE:
case INTEGER_TYPE:
switch (tsize) {
case 1:
#ifdef TARG_SL
mtype = Get_Mtype_For_Integer_Type(type_tree, tsize);
#else
mtype = MTYPE_I1;
#endif
break;
case 2:
#ifdef TARG_SL
mtype = Get_Mtype_For_Integer_Type(type_tree, tsize);
#else
mtype = MTYPE_I2;
#endif
break;
case 4:
#ifdef TARG_SL
mtype = Get_Mtype_For_Integer_Type(type_tree, tsize);
#else
mtype = MTYPE_I4;
#endif
break;
case 8:
#ifdef TARG_SL
mtype = Get_Mtype_For_Integer_Type(type_tree, tsize);
#else
mtype = MTYPE_I8;
#endif
break;
#if !defined(TARG_X8664) && !defined(TARG_MIPS) && !defined(TARG_IA64) && !defined(TARG_LOONGSON) || defined(TARG_SL)
#ifdef _LP64
case 16: mtype = MTYPE_I8; break;
#endif /* _LP64 */
#else
// needed for compiling variable length array
// as in gcc.c-torture/execute/920929-1.c
// we need to fix the rest of the compiler
// with _LP64 but seems to work fine without.
case 16: mtype = MTYPE_I8; break;
#endif /* KEY */
default: FmtAssert(FALSE,
("Get_TY unexpected size %d", tsize));
}
if (TREE_UNSIGNED(type_tree)) {
mtype = MTYPE_complement(mtype);
}
#ifdef KEY
if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (type_tree)))
{
// bug 9975: Handle may_alias attribute, we need to cr eate
// a new type to which we can attach the flag.
TY &ty = New_TY (idx);
TY_Init (ty, tsize, KIND_SCALAR, mtype,
Save_Str(Get_Name(TYPE_NAME(type_tree))) );
Set_TY_no_ansi_alias (ty);
#if defined(TARG_SL)
// for -m32, it is not the predefined type, alignment shoule be set.
// Corresponding to following code about bug#2932.
if (!TARGET_64BIT)
Set_TY_align (idx, align);
#endif
} else
#endif
idx = MTYPE_To_TY (mtype); // use predefined type
#if defined(TARG_X8664) || defined(TARG_SL)
/* At least for -m32, the alignment is not the same as the data
type's natural size. (bug#2932)
*/
if( TARGET_64BIT )
#endif // TARG_X8664
Set_TY_align (idx, align);
break;
case CHAR_TYPE:
mtype = (TREE_UNSIGNED(type_tree) ? MTYPE_U1 : MTYPE_I1);
idx = MTYPE_To_TY (mtype); // use predefined type
break;
case ENUMERAL_TYPE:
mtype = (TREE_UNSIGNED(type_tree) ? MTYPE_U4 : MTYPE_I4);
#ifdef KEY
/* bug#500 */
if( tsize == 8 ){
mtype = (TREE_UNSIGNED(type_tree) ? MTYPE_U8 : MTYPE_I8);
}
#endif
idx = MTYPE_To_TY (mtype); // use predefined type
break;
case REAL_TYPE:
switch (tsize) {
case 4: mtype = MTYPE_F4; break;
case 8: mtype = MTYPE_F8; break;
#if defined(TARG_IA64)
case 12:
case 16: mtype = MTYPE_F10; break;
#elif defined(TARG_MIPS) || defined(TARG_IA32) || defined(TARG_X8664) || defined(TARG_LOONGSON)
case 12:
case 16: mtype = MTYPE_FQ; break;
#else
case 16: mtype = MTYPE_F16; break;
#endif
default: FmtAssert(FALSE, ("Get_TY unexpected size"));
}
idx = MTYPE_To_TY (mtype); // use predefined type
break;
case COMPLEX_TYPE:
switch (tsize) {
case 8: mtype = MTYPE_C4; break;
case 16: mtype = MTYPE_C8; break;
#if defined(TARG_IA32) || defined(TARG_X8664)
case 24: mtype = MTYPE_CQ; break;
#endif
#if defined(TARG_IA64)
case 32: mtype = MTYPE_C10; break;
#else
case 32: mtype = MTYPE_CQ; break;
#endif
default: FmtAssert(FALSE, ("Get_TY unexpected size"));
}
idx = MTYPE_To_TY (mtype); // use predefined type
break;
case POINTER_TYPE:
if (TYPE_PTRMEM_P(type_tree)) {
// pointer to member
idx = Be_Type_Tbl(Pointer_Size == 8 ? MTYPE_I8 : MTYPE_I4);
break;
}
/* FALLTHRU */
case REFERENCE_TYPE:
idx = Make_Pointer_Type (Get_TY (TREE_TYPE(type_tree)));
Set_TY_align (idx, align);
break;
case ARRAY_TYPE:
{ // new scope for local vars
TY &ty = New_TY (idx);
TY_Init (ty, tsize, KIND_ARRAY, MTYPE_M,
Save_Str(Get_Name(TYPE_NAME(type_tree))) );
Set_TY_etype (ty, Get_TY (TREE_TYPE(type_tree)));
Set_TY_align (idx, TY_align(TY_etype(ty)));
if (TYPE_ANONYMOUS_P(type_tree) || TYPE_NAME(type_tree) == NULL)
Set_TY_anonymous(ty);
// assumes 1 dimension
// nested arrays are treated as arrays of arrays
ARB_HANDLE arb = New_ARB ();
ARB_Init (arb, 0, 0, 0);
Set_TY_arb (ty, arb);
Set_ARB_first_dimen (arb);
Set_ARB_last_dimen (arb);
Set_ARB_dimension (arb, 1);
if (TYPE_SIZE(TREE_TYPE(type_tree)) == 0)
break; // anomaly: type will never be needed
if (TREE_CODE(TYPE_SIZE(TREE_TYPE(type_tree))) == INTEGER_CST) {
Set_ARB_const_stride (arb);
Set_ARB_stride_val (arb,
Get_Integer_Value (TYPE_SIZE_UNIT(TREE_TYPE(type_tree))));
}
else {
WN *swn;
swn = WFE_Expand_Expr (TYPE_SIZE_UNIT(TREE_TYPE(type_tree)));
if (WN_opcode (swn) == OPC_U4I4CVT ||
WN_opcode (swn) == OPC_U8I8CVT) {
swn = WN_kid0 (swn);
}
#ifdef KEY
// In the event that swn operator is not
// OPR_LDID, save expr node swn
// and use LDID of that stored address as swn.
// Copied from Wfe_Save_Expr in wfe_expr.cxx
if (WN_operator (swn) != OPR_LDID) {
TYPE_ID mtype = WN_rtype(swn);
TY_IDX ty_idx = MTYPE_To_TY(mtype);
ST *st;
st = Gen_Temp_Symbol (ty_idx, "__save_expr");
WFE_add_pragma_to_enclosing_regions (WN_PRAGMA_LOCAL, st);
WFE_Set_ST_Addr_Saved (swn);
swn = WN_Stid (mtype, 0, st, ty_idx, swn);
WFE_Stmt_Append (swn, Get_Srcpos());
swn = WN_Ldid (mtype, 0, st, ty_idx);
}
#endif /* KEY */
FmtAssert (WN_operator (swn) == OPR_LDID,
("stride operator for VLA not LDID"));
ST *st = WN_st (swn);
TY_IDX ty_idx = ST_type (st);
WN *wn = WN_CreateXpragma (WN_PRAGMA_COPYIN_BOUND,
(ST_IDX) NULL, 1);
WN_kid0 (wn) = WN_Ldid (TY_mtype (ty_idx), 0, st, ty_idx);
WFE_Stmt_Append (wn, Get_Srcpos());
Clear_ARB_const_stride (arb);
Set_ARB_stride_var (arb, (ST_IDX) ST_st_idx (st));
}
Set_ARB_const_lbnd (arb);
Set_ARB_lbnd_val (arb, 0);
if (type_size) {
#ifdef KEY
// For Zero-length arrays, TYPE_MAX_VALUE tree is NULL
if (!TYPE_MAX_VALUE (TYPE_DOMAIN (type_tree))) {
Set_ARB_const_ubnd (arb);
Set_ARB_ubnd_val (arb, 0xffffffff);
} else
#endif /* KEY */
if (TREE_CODE(TYPE_MAX_VALUE (TYPE_DOMAIN (type_tree))) ==
INTEGER_CST) {
Set_ARB_const_ubnd (arb);
Set_ARB_ubnd_val (arb, Get_Integer_Value (
TYPE_MAX_VALUE (TYPE_DOMAIN (type_tree)) ));
}
else {
WN *uwn = WFE_Expand_Expr (TYPE_MAX_VALUE (TYPE_DOMAIN (type_tree)) );
if (WN_opcode (uwn) == OPC_U4I4CVT ||
WN_opcode (uwn) == OPC_U8I8CVT) {
uwn = WN_kid0 (uwn);
}
ST *st;
TY_IDX ty_idx;
WN *wn;
if (WN_operator (uwn) != OPR_LDID) {
ty_idx = MTYPE_To_TY(WN_rtype(uwn));
st = Gen_Temp_Symbol (ty_idx, "__vla_bound");
#ifdef KEY
WFE_add_pragma_to_enclosing_regions (WN_PRAGMA_LOCAL, st);
#endif
wn = WN_Stid (TY_mtype (ty_idx), 0, st, ty_idx, uwn);
WFE_Stmt_Append (wn, Get_Srcpos());
}
else {
st = WN_st (uwn);
ty_idx = ST_type (st);
}
wn = WN_CreateXpragma (WN_PRAGMA_COPYIN_BOUND, (ST_IDX) NULL, 1);
WN_kid0 (wn) = WN_Ldid (TY_mtype (ty_idx), 0, st, ty_idx);
WFE_Stmt_Append (wn, Get_Srcpos());
Clear_ARB_const_ubnd (arb);
Set_ARB_ubnd_var (arb, ST_st_idx (st));
}
}
else {
Clear_ARB_const_ubnd (arb);
Set_ARB_ubnd_val (arb, 0);
}
if (variable_size) {
WN *swn, *wn;
swn = WFE_Expand_Expr (TYPE_SIZE_UNIT(type_tree));
if (TY_size(TY_etype(ty))) {
if (WN_opcode (swn) == OPC_U4I4CVT ||
WN_opcode (swn) == OPC_U8I8CVT) {
swn = WN_kid0 (swn);
}
#ifdef KEY
// In the event that swn operator is not
// OPR_LDID, save expr node swn
// and use LDID of that stored address as swn.
// Copied from Wfe_Save_Expr in wfe_expr.cxx
if (WN_operator (swn) != OPR_LDID) {
TYPE_ID mtype = WN_rtype(swn);
TY_IDX ty_idx = MTYPE_To_TY(mtype);
ST *st;
st = Gen_Temp_Symbol (ty_idx, "__save_expr");
WFE_add_pragma_to_enclosing_regions (WN_PRAGMA_LOCAL, st);
WFE_Set_ST_Addr_Saved (swn);
swn = WN_Stid (mtype, 0, st, ty_idx, swn);
WFE_Stmt_Append (swn, Get_Srcpos());
swn = WN_Ldid (mtype, 0, st, ty_idx);
}
#endif /* KEY */
FmtAssert (WN_operator (swn) == OPR_LDID,
("size operator for VLA not LDID"));
ST *st = WN_st (swn);
TY_IDX ty_idx = ST_type (st);
TYPE_ID mtype = TY_mtype (ty_idx);
wn = WN_Stid (mtype, 0, st, ty_idx, swn);
WFE_Stmt_Append (wn, Get_Srcpos());
}
}
} // end array scope
break;
case RECORD_TYPE:
case UNION_TYPE:
{ // new scope for local vars
TY &ty = (idx == TY_IDX_ZERO) ? New_TY(idx) : Ty_Table[idx];
#ifdef KEY
// Must create DSTs in the order that the records are declared,
// in order to preserve their scope. Bug 4168.
if (Debug_Level >= 2)
defer_DST_type(type_tree, idx, orig_idx);
// GCC 3.2 pads empty structures with a fake 1-byte field.
// These structures should have tsize = 0.
if (tsize != 0 &&
// is_empty_class assumes non-null CLASSTYPE_SIZE
// check if it has lang-specific data
TYPE_LANG_SPECIFIC(type_tree) &&
// check if it has its base version set
CLASSTYPE_AS_BASE(type_tree) &&
CLASSTYPE_SIZE(type_tree) &&
is_empty_class(type_tree))
tsize = 0;
#endif // KEY
// For typedef A B, tree A and tree B link to the same TY C
// When parsing A, C's name is set to A
// When parsing B, C's name is set to B
// It makes C's name be random in different object files so that TY merge will fail
// So the name of this TY must be fixed to the main variant name.
if (TYPE_MAIN_VARIANT(type_tree) != type_tree)
TY_Init(ty, tsize, KIND_STRUCT, MTYPE_M,
Save_Str(Get_Name(TYPE_NAME(TYPE_MAIN_VARIANT(type_tree)))));
else
TY_Init (ty, tsize, KIND_STRUCT, MTYPE_M,
Save_Str(Get_Name(TYPE_NAME(type_tree))) );
if (TYPE_ANONYMOUS_P(type_tree) || TYPE_NAME(type_tree) == NULL)
Set_TY_anonymous(ty);
if (TREE_CODE(type_tree) == UNION_TYPE) {
Set_TY_is_union(idx);
}
#ifdef KEY
if (aggregate_value_p(type_tree)) {
Set_TY_return_in_mem(idx);
}
#endif
if (align == 0) align = 1; // in case incomplete type
Set_TY_align (idx, align);
// set idx now in case recurse thru fields
TYPE_TY_IDX(type_tree) = idx;
Do_Base_Types (type_tree);
// Process nested structs and static data members first
for (tree field = TYPE_FIELDS (type_tree);
field;
field = next_real_or_virtual_field(type_tree, field))
if (TREE_CODE(field) == TYPE_DECL ||
TREE_CODE(field) == FIELD_DECL) {
tree field_type = TREE_TYPE(field);
if ((TREE_CODE(field_type) == RECORD_TYPE ||
TREE_CODE(field_type) == UNION_TYPE) &&
field_type != type_tree) {
#ifdef KEY
// Defer typedefs within class
// declarations to avoid circular
// declaration dependences. See
// example in bug 5134.
if (TREE_CODE(field) == TYPE_DECL)
defer_decl(field_type);
else
#endif
Get_TY(field_type);
}
}
#ifdef KEY // Defer expansion of static vars until all the fields in
// _every_ struct are laid out. Consider this code (see
// bug 3044):
// struct A
// struct B *p
// struct B
// static struct A *q = ... // static data member with
// // initializer
// We cannot expand static member vars while expanding the
// enclosing stuct, for the following reason: Expansion of
// struct A leads to expansion of p, which leads to the
// expansion of struct B, which leads to the expansion of q and
// q's initializer. The code that expands the initializer goes
// through the fields of struct A, but these fields are not yet
// completely defined, and this will cause kg++fe to die.
//
// The solution is the delay all static var expansions until
// the very end.
else if (TREE_CODE(field) == VAR_DECL)
defer_decl(field);
#else
else if (TREE_CODE(field) == VAR_DECL)
WFE_Expand_Decl(field);
#endif
else if (TREE_CODE(field) == TEMPLATE_DECL)
WFE_Expand_Decl(field);
Set_TY_fld (ty, FLD_HANDLE());
FLD_IDX first_field_idx = Fld_Table.Size ();
tree field;
tree method = TYPE_METHODS(type_tree);
FLD_HANDLE fld;
INT32 next_field_id = 1;
hash_map <tree, tree, void_ptr_hash> anonymous_base;
// Generate an anonymous field for every direct, nonempty,
// nonvirtual base class.
INT32 offset = 0;
INT32 anonymous_fields = 0;
#ifndef KEY // g++'s class.c already laid out the base types. Bug 11622.
if (TYPE_BINFO(type_tree) &&
BINFO_BASETYPES(TYPE_BINFO(type_tree))) {
tree basetypes = BINFO_BASETYPES(TYPE_BINFO(type_tree));
INT32 i;
for (i = 0; i < TREE_VEC_LENGTH(basetypes); ++i) {
tree binfo = TREE_VEC_ELT(basetypes, i);
tree basetype = BINFO_TYPE(binfo);
offset = Roundup (offset,
TYPE_ALIGN(basetype) / BITSPERBYTE);
if (!is_empty_base_class(basetype) ||
!TREE_VIA_VIRTUAL(binfo)) {
++next_field_id;
++anonymous_fields;
next_field_id += TYPE_FIELD_IDS_USED(basetype);
fld = New_FLD();
FLD_Init (fld, Save_Str(Get_Name(0)),
Get_TY(basetype), offset);
offset += Type_Size_Without_Vbases (basetype);
// For the field with base class type,
// set it to anonymous and base class,
// and add it into anonymous_base set
// to avoid create the anonymous field twice in the TY
Set_FLD_is_anonymous(fld);
Set_FLD_is_base_class(fld);
anonymous_base.insert(CLASSTYPE_AS_BASE(basetype));
#ifdef KEY
// temporary hack for a bug in gcc
// Details: From layout_class_type(), it turns out that for this
// type, gcc is apparently sending wrong type info, they have 2 fields
// each 8 bytes in a 'record', with the type size == 8 bytes also!
// So we take care of it here...
if (offset > tsize)
{
tsize = offset;
Set_TY_size (ty, tsize);
}
#endif // KEY
}
}
}
#endif
// find all base classes
if (TYPE_BINFO(type_tree) && BINFO_BASETYPES(TYPE_BINFO(type_tree))) {
tree basetypes = BINFO_BASETYPES(TYPE_BINFO(type_tree));
INT32 i;
for (i = 0; i < TREE_VEC_LENGTH(basetypes); ++i) {
tree basetype = BINFO_TYPE(TREE_VEC_ELT(basetypes, i));
anonymous_base[CLASSTYPE_AS_BASE(basetype)] = basetype;
}
}
for (field = TYPE_FIELDS(type_tree);
field;
field = next_real_or_virtual_field(type_tree, field) )
{
if (TREE_CODE(field) == TYPE_DECL) {
continue;
}
if (TREE_CODE(field) == CONST_DECL) {
// Just for the time being, we need to investigate
// whether this criteria is reasonable.
static BOOL once_is_enough=FALSE;
if (!once_is_enough) {
DevWarn ("got CONST_DECL in field list");
once_is_enough=TRUE;
}
continue;
}
if (TREE_CODE(field) == VAR_DECL) {
continue;
}
if (TREE_CODE(field) == TEMPLATE_DECL) {
continue;
}
DECL_FIELD_ID(field) = next_field_id;
next_field_id +=
TYPE_FIELD_IDS_USED(TREE_TYPE(field)) + 1;
fld = New_FLD ();
FLD_Init (fld, Save_Str(Get_Name(DECL_NAME(field))),
0, // type
Get_Integer_Value(DECL_FIELD_OFFSET(field)) +
Get_Integer_Value(DECL_FIELD_BIT_OFFSET(field))
/ BITSPERBYTE);
if (DECL_NAME(field) == NULL)
Set_FLD_is_anonymous(fld);
if (anonymous_base.find(TREE_TYPE(field)) != anonymous_base.end()) {
Set_FLD_is_base_class(fld);
// set the base class type;
tree base_class = anonymous_base[TREE_TYPE(field)];
Set_FLD_type(fld, Get_TY(base_class));
}
}
TYPE_FIELD_IDS_USED(type_tree) = next_field_id - 1;
FLD_IDX last_field_idx = Fld_Table.Size () - 1;
if (last_field_idx >= first_field_idx) {
Set_TY_fld (ty, FLD_HANDLE (first_field_idx));
Set_FLD_last_field (FLD_HANDLE (last_field_idx));
}
// now set the fld types.
// first skip the anonymous fields, whose types are already
// set.
fld = TY_fld(ty);
while (anonymous_fields--)
fld = FLD_next(fld);
for (field = TYPE_FIELDS(type_tree);
/* ugly hack follows; traversing the fields isn't
the same from run-to-run. fwa? */
field && fld.Entry();
field = next_real_or_virtual_field(type_tree, field))
{
#ifdef KEY
const int FLD_BIT_FIELD_SIZE = 64;
#endif
if (TREE_CODE(field) == TYPE_DECL)
continue;
if (TREE_CODE(field) == CONST_DECL)
continue;
if (TREE_CODE(field) == VAR_DECL)
continue;
if (TREE_CODE(field) == TEMPLATE_DECL)
continue;
#ifdef KEY
// Don't expand the field's type if it's a pointer
// type, in order to avoid circular dependences
// involving member object types and base types. See
// example in bug 4954.
if (TREE_CODE(TREE_TYPE(field)) == POINTER_TYPE) {
// Defer expanding the field's type. Put in a
// generic pointer type for now.
TY_IDX p_idx =
Make_Pointer_Type(MTYPE_To_TY(MTYPE_U8),
FALSE);
Set_FLD_type(fld, p_idx);
defer_field(field, fld);
fld = FLD_next(fld);
continue;
}
#endif
if (anonymous_base.find(TREE_TYPE(field)) == anonymous_base.end()) {
TY_IDX fty_idx = Get_TY(TREE_TYPE(field));
if ((TY_align (fty_idx) > align) || (TY_is_packed (fty_idx)))
Set_TY_is_packed (ty);
Set_FLD_type(fld, fty_idx);
}
if ( ! DECL_BIT_FIELD(field)
&& Get_Integer_Value(DECL_SIZE(field)) > 0
#ifdef KEY
// We don't handle bit-fields > 64 bits. For an INT field of 128 bits, we
// make it 64 bits. But then don't set it as FLD_IS_BIT_FIELD.
&& Get_Integer_Value(DECL_SIZE(field)) <=
FLD_BIT_FIELD_SIZE
// bug 2401
&& TY_size(Get_TY(TREE_TYPE(field))) != 0
#endif
&& Get_Integer_Value(DECL_SIZE(field))
!= (TY_size(Get_TY(TREE_TYPE(field)))
* BITSPERBYTE) )
{
#ifdef KEY
FmtAssert( Get_Integer_Value(DECL_SIZE(field)) <=
FLD_BIT_FIELD_SIZE,
("field size too big") );
#endif
// for some reason gnu doesn't set bit field
// when have bit-field of standard size
// (e.g. int f: 16;). But we need it set
// so we know how to pack it, because
// otherwise the field type is wrong.
DevWarn("field size %lld doesn't match type size %lld",
Get_Integer_Value(DECL_SIZE(field)),
TY_size(Get_TY(TREE_TYPE(field)))
* BITSPERBYTE );
DECL_BIT_FIELD(field) = 1;
}
if (DECL_BIT_FIELD(field)) {
Set_FLD_is_bit_field (fld);
// bofst is remaining bits from byte offset
Set_FLD_bofst (fld,
Get_Integer_Value(
DECL_FIELD_BIT_OFFSET(field))
% BITSPERBYTE);
Set_FLD_bsize (fld, Get_Integer_Value(
DECL_SIZE(field)));
}
fld = FLD_next(fld);
}
#ifndef KEY // Don't expand methods by going through TYPE_METHODS,
// because:
// 1) It is incorrect to translate all methods in
// TYPE_METHODS to WHIRL because some of the methods are
// never used, and generating the assembly code for them
// might lead to undefined symbol references. Instead,
// consult the gxx_emitted_decls list, which has all the
// functions (including methods) that g++ has ever emitted
// to assembly.
// 2) Expanding the methods here will cause error when the
// methods are for a class B that appears as a field in an
// enclosing class A. When Get_TY is run for A, it will
// call Get_TY for B in order to calculate A's field ID's.
// (Need Get_TY to find B's TYPE_FIELD_IDS_USED.) If
// Get_TY uses the code below to expand B's methods, it
// will lead to error because the expansion requires the
// field ID's of the enclosing record (A), and these field
// ID's are not yet defined.
// process methods
if (!Enable_WFE_DFE) {
if (cp_type_quals(type_tree) == TYPE_UNQUALIFIED) {
while (method != NULL_TREE) {
WFE_Expand_Decl (method);
method = TREE_CHAIN(method);
}
}
}
#endif // KEY
} //end record scope
break;
case METHOD_TYPE:
//DevWarn ("Encountered METHOD_TYPE at line %d", lineno);
case FUNCTION_TYPE:
{ // new scope for local vars
tree arg;
INT32 num_args;
TY &ty = New_TY (idx);
TY_Init (ty, 0, KIND_FUNCTION, MTYPE_UNKNOWN, 0);
Set_TY_align (idx, 1);
TY_IDX ret_ty_idx;
TY_IDX arg_ty_idx;
TYLIST tylist_idx;
// allocate TYs for return as well as parameters
// this is needed to avoid mixing TYLISTs if one
// of the parameters is a pointer to a function
ret_ty_idx = Get_TY(TREE_TYPE(type_tree));
for (arg = TYPE_ARG_TYPES(type_tree);
arg;
arg = TREE_CHAIN(arg))
arg_ty_idx = Get_TY(TREE_VALUE(arg));
// if return type is pointer to a zero length struct
// convert it to void
if (!WFE_Keep_Zero_Length_Structs &&
TY_mtype (ret_ty_idx) == MTYPE_M &&
TY_size (ret_ty_idx) == 0) {
// zero length struct being returned
DevWarn ("function returning zero length struct at line %d", lineno);
ret_ty_idx = Be_Type_Tbl (MTYPE_V);
}
#ifdef KEY
// If the front-end adds the fake first param, then convert the
// function to return void.
if (TY_return_in_mem(ret_ty_idx)) {
ret_ty_idx = Be_Type_Tbl (MTYPE_V);
Set_TY_return_to_param(idx); // bugs 2423 2424
}
#endif
Set_TYLIST_type (New_TYLIST (tylist_idx), ret_ty_idx);
Set_TY_tylist (ty, tylist_idx);
for (num_args = 0, arg = TYPE_ARG_TYPES(type_tree);
arg;
num_args++, arg = TREE_CHAIN(arg))
{
arg_ty_idx = Get_TY(TREE_VALUE(arg));
if (!WFE_Keep_Zero_Length_Structs &&
TY_mtype (arg_ty_idx) == MTYPE_M &&
TY_size (arg_ty_idx) == 0) {
// zero length struct passed as parameter
DevWarn ("zero length struct encountered in function prototype at line %d", lineno);
}
else
Set_TYLIST_type (New_TYLIST (tylist_idx), arg_ty_idx);
}
if (num_args)
{
Set_TY_has_prototype(idx);
if (arg_ty_idx != Be_Type_Tbl(MTYPE_V))
{
Set_TYLIST_type (New_TYLIST (tylist_idx), 0);
Set_TY_is_varargs(idx);
}
else
Set_TYLIST_type (Tylist_Table [tylist_idx], 0);
}
else
Set_TYLIST_type (New_TYLIST (tylist_idx), 0);
} // end FUNCTION_TYPE scope
break;
#ifdef TARG_X8664
// x86 gcc vector types
case VECTOR_TYPE:
{
switch (GET_MODE_SIZE (TYPE_MODE (type_tree)))
{
case 8:
switch (GET_MODE_UNIT_SIZE (TYPE_MODE (type_tree)))
{
case 1:
idx = MTYPE_To_TY (MTYPE_M8I1);
break;
case 2:
idx = MTYPE_To_TY (MTYPE_M8I2);
break;
case 4:
if (TREE_CODE (TREE_TYPE (type_tree)) == INTEGER_TYPE)
idx = MTYPE_To_TY (MTYPE_V8I4);
else
idx = MTYPE_To_TY (MTYPE_M8F4);
break;
default: Fail_FmtAssertion ("Get_TY: NYI");
}
break;
case 16:
switch (GET_MODE_UNIT_SIZE (TYPE_MODE (type_tree)))
{
case 1:
idx = MTYPE_To_TY (MTYPE_V16I1);
break;
case 2:
idx = MTYPE_To_TY (MTYPE_V16I2);
break;
case 4:
if (TREE_CODE (TREE_TYPE (type_tree)) == INTEGER_TYPE)
idx = MTYPE_To_TY (MTYPE_V16I4);
else
idx = MTYPE_To_TY (MTYPE_V16F4);
break;
case 8:
if (TREE_CODE (TREE_TYPE (type_tree)) == INTEGER_TYPE)
idx = MTYPE_To_TY (MTYPE_V16I8);
else
idx = MTYPE_To_TY (MTYPE_V16F8);
break;
default: Fail_FmtAssertion ("Get_TY: NYI");
}
break;
default:
Fail_FmtAssertion ("Get_TY: Unexpected vector type");
}
}
break;
#endif // TARG_X8664
default:
FmtAssert(FALSE, ("Get_TY unexpected tree_type"));
}
if (TYPE_READONLY(type_tree))
Set_TY_is_const (idx);
if (TYPE_VOLATILE(type_tree))
Set_TY_is_volatile (idx);
#ifdef KEY
if (TYPE_RESTRICT(type_tree))
Set_TY_is_restrict (idx);
#endif
TYPE_TY_IDX(type_tree) = idx;
if(Debug_Level >= 2) {
#ifdef KEY
// DSTs for records were entered into the defer list in the order
// that the records are declared, in order to preserve their scope.
// Bug 4168.
if (TREE_CODE(type_tree) != RECORD_TYPE &&
TREE_CODE(type_tree) != UNION_TYPE) {
// Defer creating DST info until there are no partially constructed
// types, in order to prevent Create_DST_type_For_Tree from calling
// Get_TY, which in turn may use field IDs from partially created
// structs. Such fields IDs are wrong. Bug 5658.
defer_DST_type(type_tree, idx, orig_idx);
}
#else
DST_INFO_IDX dst =
Create_DST_type_For_Tree(type_tree,
idx,orig_idx);
TYPE_DST_IDX(type_tree) = dst;
#endif
}
return idx;
}
ST*
Create_ST_For_Tree (tree decl_node)
{
TY_IDX ty_idx;
ST* st;
char *name;
char tempname[32];
ST_SCLASS sclass;
ST_EXPORT eclass;
SYMTAB_IDX level;
static INT anon_count = 0;
#ifdef KEY
BOOL anon_st = FALSE;
#endif
if(TREE_CODE(decl_node) == ERROR_MARK) {
Fail_FmtAssertion ("Unable to handle ERROR_MARK. internal error");
}
#ifdef KEY
// If the decl is a function decl, and there are duplicate decls for the
// function, then use a ST already allocated for the function, if such ST
// exists.
if (TREE_CODE (decl_node) == FUNCTION_DECL) {
st = get_duplicate_st (decl_node);
if (st) {
set_DECL_ST(decl_node, st);
return st;
}
}
#endif
#ifdef KEY
// For variables with asm register assignments, don't use the assembler
// names because they are of the form "%rbx".
if (TREE_CODE(decl_node) == VAR_DECL &&
DECL_ASMREG(decl_node) != 0) {
FmtAssert (DECL_NAME (decl_node),
("Create_ST_For_Tree: DECL_NAME null"));
name = (char *) IDENTIFIER_POINTER (DECL_NAME (decl_node));
} else
#endif
if (DECL_NAME (decl_node) && DECL_ASSEMBLER_NAME (decl_node))
name = (char *) IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl_node));
else {
sprintf(tempname, "anon%d", ++anon_count);
name = tempname;
#ifdef KEY
anon_st = TRUE;
#endif
}
#ifdef KEY
BOOL guard_var = FALSE;
// See if variable is a guard variable.
if (strncmp("_ZGV", name, 4) == 0) {
guard_var = TRUE;
}
#endif
switch (TREE_CODE(decl_node)) {
case FUNCTION_DECL:
{
if (Enable_WFE_DFE) {
tree body = DECL_SAVED_TREE(decl_node);
if (DECL_THUNK_P(decl_node) &&
TREE_CODE(CP_DECL_CONTEXT(decl_node)) != NAMESPACE_DECL)
Push_Deferred_Function (decl_node);
/*
else
if (DECL_TINFO_FN_P(decl_node))
Push_Deferred_Function (decl_node);
*/
else
if (body != NULL_TREE && !DECL_EXTERNAL(decl_node) &&
(DECL_TEMPLATE_INFO(decl_node) == NULL ||
DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION(decl_node) ||
DECL_TEMPLATE_INSTANTIATED(decl_node) ||
DECL_TEMPLATE_SPECIALIZATION(decl_node))) {
Push_Deferred_Function (decl_node);
}
}
TY_IDX func_ty_idx = Get_TY(TREE_TYPE(decl_node));
sclass = SCLASS_EXTERN;
eclass = TREE_PUBLIC(decl_node) || DECL_WEAK(decl_node) ?
EXPORT_PREEMPTIBLE :
EXPORT_LOCAL;
level = GLOBAL_SYMTAB+1;
PU_IDX pu_idx;
PU& pu = New_PU (pu_idx);
PU_Init (pu, func_ty_idx, level);
st = New_ST (GLOBAL_SYMTAB);
#ifdef KEY // Fix bug # 34, 3356
char *p = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl_node));
if (*p == '*')
p++;
ST_Init (st, Save_Str(p),
CLASS_FUNC, sclass, eclass, TY_IDX (pu_idx));
// St is a constructor
if (DECL_CONSTRUCTOR_P(decl_node) && !DECL_COPY_CONSTRUCTOR_P(decl_node))
Set_PU_is_constructor(pu);
// St is a pure virual function
if (DECL_PURE_VIRTUAL_P(decl_node) || strncmp(p, "__cxa_pure_virtual", 18) == 0)
Set_ST_is_pure_vfunc(st);
p = IDENTIFIER_POINTER (DECL_NAME (decl_node));
if (!strncmp(p,"operator",8))
Set_PU_is_operator(pu);
#else
ST_Init (st,
Save_Str ( IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl_node))),
CLASS_FUNC, sclass, eclass, TY_IDX (pu_idx));
#endif
if (TREE_CODE(TREE_TYPE(decl_node)) == METHOD_TYPE) {
Set_ST_is_method_func(st);
TY_IDX base = Get_TY(TYPE_METHOD_BASETYPE(TREE_TYPE(decl_node)));
Set_PU_base_class(pu, base);
}
if (DECL_THUNK_P(decl_node) &&
TREE_CODE(CP_DECL_CONTEXT(decl_node)) != NAMESPACE_DECL)
Set_ST_is_weak_symbol(st);
}
break;
case PARM_DECL:
case VAR_DECL:
#ifdef KEY
case RESULT_DECL: // bug 3878
#endif
{
if (TREE_CODE(decl_node) == PARM_DECL) {
sclass = SCLASS_FORMAL;
eclass = EXPORT_LOCAL;
level = CURRENT_SYMTAB;
}
else {
if (DECL_CONTEXT (decl_node) == 0 ||
TREE_CODE (DECL_CONTEXT (decl_node)) == NAMESPACE_DECL ||
TREE_CODE (DECL_CONTEXT (decl_node)) == RECORD_TYPE ) {
if (TREE_PUBLIC (decl_node)) {
#ifdef KEY
// GCC 3.2
if (DECL_EXTERNAL(decl_node) ||
(DECL_LANG_SPECIFIC(decl_node) &&
DECL_REALLY_EXTERN(decl_node)))
#else
if (DECL_EXTERNAL(decl_node))
#endif /* KEY */
sclass = SCLASS_EXTERN;
else
if (DECL_INITIAL(decl_node))
sclass = SCLASS_UGLOBAL;
else if (TREE_STATIC(decl_node)) {
#ifdef KEY
// bugs 340, 3717
if (flag_no_common || !DECL_COMMON (decl_node))
#else
if (flag_no_common)
#endif
sclass = SCLASS_UGLOBAL;
else
sclass = SCLASS_COMMON;
}
else
sclass = SCLASS_EXTERN;
#ifdef TARG_IA64
// bug fix for OSP_89 && OSP_173 && OSP_169
if (!flag_pic) {
if (Use_Call_Shared_Link && Gp_Rel_Aggresive_Opt &&
sclass != SCLASS_EXTERN && sclass != SCLASS_COMMON)
eclass = EXPORT_PROTECTED;
else
eclass = EXPORT_PREEMPTIBLE;
}
else {
eclass = EXPORT_PREEMPTIBLE;
}
}
#else
eclass = EXPORT_PREEMPTIBLE;
}
#endif
else {
sclass = SCLASS_FSTATIC;
eclass = EXPORT_LOCAL;
}
level = GLOBAL_SYMTAB;
}
else {
if (DECL_EXTERNAL(decl_node) || DECL_WEAK (decl_node)) {
sclass = SCLASS_EXTERN;
level = GLOBAL_SYMTAB;
eclass = EXPORT_PREEMPTIBLE;
}
#ifdef KEY
// Bug 8652: If GNU marks it as COMMON, we should the same.
else if (!flag_no_common && TREE_STATIC (decl_node) &&
DECL_COMMON (decl_node) &&
TREE_PUBLIC (decl_node)) {
sclass = SCLASS_COMMON;
level = GLOBAL_SYMTAB;
eclass = EXPORT_PREEMPTIBLE;
}
#endif
else {
if (TREE_STATIC (decl_node)) {
sclass = SCLASS_PSTATIC;
if (pstatic_as_global)
level = GLOBAL_SYMTAB;
else
level = CURRENT_SYMTAB;
}
else {
sclass = SCLASS_AUTO;
level = DECL_SYMTAB_IDX(decl_node) ?
DECL_SYMTAB_IDX(decl_node) : CURRENT_SYMTAB;
}
eclass = EXPORT_LOCAL;
}
}
}
#ifdef KEY
// Make g++ guard variables global in order to make them weak. Ideally
// guard variables should be "common", but for some reason the back-end
// currently can't handle C++ commons. As a work around, make the
// guard variables weak. Since symtab_verify.cxx don't like weak
// locals, make the guard variables global.
if (guard_var) {
level = GLOBAL_SYMTAB;
sclass = SCLASS_UGLOBAL;
eclass = EXPORT_PREEMPTIBLE;
}
// The tree under TREE_TYPE(decl_node) could reference also decl_node.
// If that's the case, the Get_TY would create the ST for decl_node.
// As a result, call GET_TY first, then check if the ST is already
// created, and create ST only if it isn't created.
ty_idx = Get_TY (TREE_TYPE(decl_node));
st = DECL_ST(decl_node);
if (st)
return st;
st = New_ST (level);
#else
st = New_ST (level);
ty_idx = Get_TY (TREE_TYPE(decl_node));
#endif
if (TY_kind (ty_idx) == KIND_ARRAY &&
TREE_STATIC (decl_node) &&
DECL_INITIAL (decl_node) == FALSE &&
TY_size (ty_idx) == 0) {
Set_TY_size (ty_idx, TY_size (Get_TY (TREE_TYPE (TREE_TYPE (decl_node)))));
}
#ifndef KEY
// bug 3735: the compiler cannot arbitrarily change the alignment of
// individual structures
if (TY_mtype (ty_idx) == MTYPE_M &&
Aggregate_Alignment > 0 &&
Aggregate_Alignment > TY_align (ty_idx))
Set_TY_align (ty_idx, Aggregate_Alignment);
#endif // !KEY
// qualifiers are set on decl nodes
if (TREE_READONLY(decl_node))
Set_TY_is_const (ty_idx);
if (TREE_THIS_VOLATILE(decl_node))
Set_TY_is_volatile (ty_idx);
#ifdef KEY
// Handle aligned attribute (bug 7331)
if (DECL_USER_ALIGN (decl_node))
Set_TY_align (ty_idx, DECL_ALIGN_UNIT (decl_node));
// NOTE: we do not update the ty_idx value in the TYPE_TREE. So
// if any of the above properties are set, the next time we get into
// Get_ST, the ty_idx in the TYPE_TREE != ty_idx in st. The solution
// is either to update TYPE_TREE now, or compare the ty_idx_index
// in Get_ST (instead of ty_idx). Currently we do the latter
#endif // KEY
ST_Init (st, Save_Str(name), CLASS_VAR, sclass, eclass, ty_idx);
#ifdef KEY
if (TREE_CODE (decl_node) == VAR_DECL && DECL_THREADPRIVATE (decl_node))
Set_ST_is_thread_private (st);
if (TREE_CODE (decl_node) == VAR_DECL && anon_st)
WFE_add_pragma_to_enclosing_regions (WN_PRAGMA_LOCAL, st);
if (TREE_CODE (decl_node) == VAR_DECL && DECL_THREAD_LOCAL (decl_node))
Set_ST_is_thread_local (st);
if (DECL_SIZE_UNIT (decl_node) &&
TREE_CODE (DECL_SIZE_UNIT (decl_node)) != INTEGER_CST)
{
// if this is the first alloca, save sp.
int idx;
if (!Set_Current_Scope_Has_Alloca (idx))
{
ST * save_st = WFE_Alloca_0 ();
Set_Current_Scope_Alloca_St (save_st, idx);
}
WN * size = WFE_Expand_Expr (DECL_SIZE_UNIT (decl_node));
// mimic WFE_Alloca_ST
ST * alloca_st = New_ST (CURRENT_SYMTAB);
ST_Init (alloca_st, Save_Str (name),
CLASS_VAR, SCLASS_AUTO, EXPORT_LOCAL,
Make_Pointer_Type (ty_idx, FALSE));
Set_ST_is_temp_var (alloca_st);
Set_ST_pt_to_unique_mem (alloca_st);
Set_ST_base_idx (st, ST_st_idx (alloca_st));
WN *wn = WN_CreateAlloca (size);
wn = WN_Stid (Pointer_Mtype, 0, alloca_st, ST_type (alloca_st), wn);
WFE_Stmt_Append (wn, Get_Srcpos());
Set_PU_has_alloca (Get_Current_PU());
// For kids 1..n of DEALLOCA
Add_Current_Scope_Alloca_St (alloca_st, idx);
}
#endif // KEY
if (TREE_CODE(decl_node) == PARM_DECL) {
Set_ST_is_value_parm(st);
}
}
break;
default:
{
Fail_FmtAssertion ("Create_ST_For_Tree: unexpected tree type");
}
break;
}
#ifdef KEY
set_DECL_ST(decl_node, st);
#else
DECL_ST(decl_node) = st;
#endif
#ifdef KEY
// For an anonymous union, all the members must be expanded together (cf.
// expand_anon_union_decl() in GNU), the members will actually just point
// to the ST for the union itself, so that whenever we access a member,
// we access the same variable.
//
// We may need to do the following for anonymous aggregates also
// (ANON_AGGR_TYPE_P), for the time being let us support anon unions.
if (TREE_CODE (decl_node) == VAR_DECL &&
TYPE_LANG_SPECIFIC (TREE_TYPE (decl_node)) &&
ANON_UNION_TYPE_P (TREE_TYPE (decl_node)))
{
tree members = DECL_ANON_UNION_ELEMS (decl_node);
for (tree t = members; t; t = TREE_CHAIN (t))
{
tree var = TREE_VALUE (t);
FmtAssert (TREE_CODE (var) == VAR_DECL,
("Unexpected member type in anonymous union"));
set_DECL_ST (var, st);
}
}
// If VAR_DECL has a non-zero DECL_ASMREG, then DECL_ASMREG-1 is the register
// number assigned by an "asm".
if (TREE_CODE(decl_node) == VAR_DECL &&
DECL_ASMREG(decl_node) != 0) {
extern PREG_NUM Map_Reg_To_Preg []; // defined in common/com/arch/config_targ.cxx
int reg = DECL_ASMREG(decl_node) - 1;
PREG_NUM preg = Map_Reg_To_Preg [reg];
FmtAssert (preg >= 0,
("mapping register %d to preg failed\n", reg));
TY_IDX ty_idx = ST_type (st);
Set_TY_is_volatile (ty_idx);
Set_ST_type (st, ty_idx);
Set_ST_assigned_to_dedicated_preg (st);
ST_ATTR_IDX st_attr_idx;
ST_ATTR& st_attr = New_ST_ATTR (CURRENT_SYMTAB, st_attr_idx);
ST_ATTR_Init (st_attr, ST_st_idx (st), ST_ATTR_DEDICATED_REGISTER, preg);
}
#endif
if (TREE_CODE(decl_node) == VAR_DECL &&
DECL_CONTEXT(decl_node) &&
TREE_CODE(DECL_CONTEXT(decl_node)) == RECORD_TYPE)
Get_TY(DECL_CONTEXT(decl_node));
if (Enable_WFE_DFE) {
if (TREE_CODE(decl_node) == VAR_DECL &&
level == GLOBAL_SYMTAB &&
!DECL_EXTERNAL (decl_node) &&
DECL_INITIAL (decl_node)) {
Push_Deferred_Function (decl_node);
}
}
if (DECL_WEAK (decl_node) &&
(!DECL_EXTERNAL (decl_node)
#ifdef KEY
// Make weak symbols for:
// extern "C" int bar() __attribute__ ((weak, alias("foo")))
// Bug 3841.
|| DECL_ALIAS_TARGET(decl_node))
#endif
) {
Set_ST_is_weak_symbol (st);
}
#ifdef KEY
// Make all symbols referenced in cleanup code and try handler code weak.
// This is to work around an implementation issue where kg++fe always emit
// the code in a cleanup or try handler, regardless of whether such code is
// emitted by g++. If the code calls a function foo that isn't emitted by
// g++ into the RTL, then foo won't be tagged as needed, and the WHIRL for
// foo won't be genterated. This leads to undefined symbol at link-time.
//
// The correct solution is to mimick g++ and generate the cleanup/handler
// code only if the region can generate an exception. g++ does this in
// except.c by checking for "(flag_non_call_exceptions ||
// region->may_contain_throw)". This checking isn't done in kg++fe because
// the equivalent of "region->may_contain_throw" isn't (yet) implemented.
// For now, work around the problem by making all symbols refereced in
// cleanups and try handlers as weak.
if (make_symbols_weak) {
if (eclass != EXPORT_LOCAL &&
eclass != EXPORT_LOCAL_INTERNAL &&
// Don't make symbol weak if it is defined in current file. Workaround
// for SLES 8 linker. Bug 3758.
WEAK_WORKAROUND(st) != WEAK_WORKAROUND_dont_make_weak &&
// Don't make builtin functions weak. Bug 9534.
!(TREE_CODE(decl_node) == FUNCTION_DECL &&
DECL_BUILT_IN(decl_node))) {
Set_ST_is_weak_symbol (st);
WEAK_WORKAROUND(st) = WEAK_WORKAROUND_made_weak;
}
}
// See comment above about guard variables.
else if (guard_var) {
Set_ST_is_weak_symbol (st);
Set_ST_init_value_zero (st);
Set_ST_is_initialized (st);
}
#endif
if (DECL_SECTION_NAME (decl_node)) {
if (strncmp(TREE_STRING_POINTER (DECL_SECTION_NAME (decl_node)),
".gnu.linkonce.",
14) != 0 ) {
// OSP, only handle non-.gnu.linkonce.* section name
DevWarn ("section %s specified for %s",
TREE_STRING_POINTER (DECL_SECTION_NAME (decl_node)),
ST_name (st));
if (TREE_CODE (decl_node) == FUNCTION_DECL)
level = GLOBAL_SYMTAB;
ST_ATTR_IDX st_attr_idx;
ST_ATTR& st_attr = New_ST_ATTR (level, st_attr_idx);
ST_ATTR_Init (st_attr, ST_st_idx (st), ST_ATTR_SECTION_NAME,
Save_Str (TREE_STRING_POINTER (DECL_SECTION_NAME (decl_node))));
Set_ST_has_named_section (st);
}
else {
// OSP. Ignore .gnu.linkonce.* section name
DevWarn ("Ignore %s specified for %s",
TREE_STRING_POINTER (DECL_SECTION_NAME (decl_node)),
ST_name (st));
}
}
/*
if (DECL_SYSCALL_LINKAGE (decl_node)) {
Set_PU_has_syscall_linkage (Pu_Table [ST_pu(st)]);
}
*/
#if defined(TARG_SL)
if(DECL_SL_MODEL_NAME(decl_node)) {
if(TREE_CODE(decl_node) == VAR_DECL &&
TREE_CODE(DECL_SL_MODEL_NAME(decl_node)) == STRING_CST)
{
if(!strcmp(TREE_STRING_POINTER(DECL_SL_MODEL_NAME(decl_node)), "small"))
Set_ST_gprel(st);
else if(!strcmp(TREE_STRING_POINTER(DECL_SL_MODEL_NAME(decl_node)), "large"))
Set_ST_not_gprel(st);
else
Fail_FmtAssertion("incorrect model type for sl data model");
}
}
#endif
if(Debug_Level >= 2) {
#ifdef KEY
// Bug 559
if (ST_sclass(st) != SCLASS_EXTERN) {
// Add DSTs for all types seen so far.
add_deferred_DST_types();
DST_INFO_IDX dst = Create_DST_decl_For_Tree(decl_node,st);
DECL_DST_IDX(decl_node) = dst;
}
#else
DST_INFO_IDX dst = Create_DST_decl_For_Tree(decl_node,st);
DECL_DST_IDX(decl_node) = dst;
#endif
}
/* NOTES:
* Following code is temporarily used since mtype isn't
* ready for now. After mtype handling has been finished we will
* use new normal method to handle section assignment. */
/* Description:
* Set ST Flags for variant internal buffer type
* VBUF is only to be file scope variable and gp-relative
* SBUF need to decide if SBUF is explicitly declared. If
* declared the flag Set_ST_in_sbuf need to be set to indicate
* the variable will be processed by CP2. */
#ifdef TARG_SL
const char* section_name;
int has_assigned_section = 0;
if(DECL_VBUF(decl_node)) // || DECL_SBUF(decl_node))
{
if(DECL_V1BUF(decl_node) && TREE_CODE(decl_node) != FUNCTION_DECL
&& !POINTER_TYPE_P(TREE_TYPE(decl_node)))
{
Set_ST_in_v1buf(st);
Set_ST_gprel(st);
}
else if(DECL_V2BUF(decl_node) && TREE_CODE(decl_node) != FUNCTION_DECL
&& !POINTER_TYPE_P(TREE_TYPE(decl_node)))
{
Set_ST_in_v2buf(st);
Set_ST_gprel(st);
TY_IDX st_ty_idx=ST_type(st);
Set_TY_size (st_ty_idx, TY_size(st_ty_idx)*2);
}
else if(DECL_V4BUF(decl_node) && TREE_CODE(decl_node) != FUNCTION_DECL
&& !POINTER_TYPE_P(TREE_TYPE(decl_node)))
{
Set_ST_in_v4buf(st);
Set_ST_gprel(st);
TY_IDX st_ty_idx=ST_type(st);
Set_TY_size (st_ty_idx, TY_size(st_ty_idx)*4);
}
}
else if(DECL_SBUF(decl_node) && TREE_CODE(decl_node) != FUNCTION_DECL
&& !POINTER_TYPE_P(TREE_TYPE(decl_node))) {
if(TREE_CODE(TREE_TYPE(decl_node)) == ARRAY_TYPE)
{
tree element_type = TREE_TYPE(decl_node);
while(TREE_CODE(element_type) == ARRAY_TYPE)
element_type = TREE_TYPE(element_type);
if(!POINTER_TYPE_P(element_type))
{
Set_ST_in_sbuf(st);
Set_ST_gprel(st);
}
}
else
{
Set_ST_in_sbuf(st);
Set_ST_gprel(st);
}
}
else if(DECL_SDRAM(decl_node) && TREE_CODE(decl_node) != FUNCTION_DECL
&& !POINTER_TYPE_P(TREE_TYPE(decl_node))) {
Set_ST_in_sdram(st);
}
#endif // TARG_SL
return st;
}
#ifndef EXTRA_WORD_IN_TREE_NODES
#include <ext/hash_map>
namespace {
using __gnu_cxx::hash_map;
struct ptrhash {
size_t operator()(void* p) const { return reinterpret_cast<size_t>(p); }
};
hash_map<tree, TY_IDX, ptrhash> ty_idx_map;
hash_map<tree, ST*, ptrhash> st_map;
hash_map<tree, SYMTAB_IDX, ptrhash> symtab_idx_map;
hash_map<tree, LABEL_IDX, ptrhash> label_idx_map;
hash_map<tree, ST*, ptrhash> string_st_map;
hash_map<tree, BOOL, ptrhash> bool_map;
hash_map<tree, INT32, ptrhash> field_id_map;
hash_map<tree, INT32, ptrhash> type_field_ids_used_map;
hash_map<tree, INT32, ptrhash> scope_number_map;
hash_map<tree, tree, ptrhash> label_scope_map;
hash_map<tree, DST_INFO_IDX,ptrhash> decl_idx_map;
hash_map<tree, DST_INFO_IDX,ptrhash> decl_field_idx_map;
hash_map<tree, DST_INFO_IDX,ptrhash> decl_specification_idx_map;
hash_map<tree, DST_INFO_IDX,ptrhash> type_idx_map;
hash_map<tree, LABEL_IDX, ptrhash> handler_label_map;
hash_map<tree, DST_INFO_IDX,ptrhash> abstract_root_map;
#ifdef KEY
// Map PU to the PU-specific st_map.
hash_map<PU*, hash_map<tree, ST*, ptrhash>*, ptrhash> pu_map;
// TRUE if ST is a decl that is being/already been expanded.
hash_map<tree, BOOL, ptrhash> expanded_decl_map;
// TRUE if TREE is a DECL_FUNCTION whose PU should have PU_uplevel set.
hash_map<tree, BOOL, ptrhash> func_PU_uplevel_map;
hash_map<tree, tree, ptrhash> parent_scope_map;
// Record whether a symbol referenced in a cleanup should be marked weak as a
// workaround to the fact that kg++fe may emit cleanups that g++ won't emit
// because g++ knows that are not needed. The linker will complain if these
// symbols are not defined.
hash_map<ST*, INT32, ptrhash> weak_workaround_map;
#endif
}
TY_IDX& TYPE_TY_IDX(tree t) { return ty_idx_map[t]; }
#ifdef KEY
BOOL& expanded_decl(tree t) {
FmtAssert (DECL_CHECK(t), ("func_expanded: not a decl"));
return expanded_decl_map[t];
}
// Put ST in a map based on the tree node T and the current PU.
void
set_DECL_ST(tree t, ST* st) {
// Find the tree node to use as index into st_map.
tree t_index;
if (TREE_CODE(t) == VAR_DECL &&
(DECL_CONTEXT(t) == 0 ||
TREE_CODE(DECL_CONTEXT(t)) == NAMESPACE_DECL) &&
DECL_NAME (t) && DECL_ASSEMBLER_NAME(t))
t_index = DECL_ASSEMBLER_NAME(t);
else
t_index = t;
// If ST is 1, then the caller only wants to pretend that there is a symbol
// for T. Later on, the caller will reset the ST to NULL and assign a real
// symbol to T.
if (st == (ST *) 1) {
st_map[t_index] = st;
return;
}
// If ST is a symbol that should be shared across functions, then put ST in
// the st_map, which maps T directly to ST. Otherwise, put ST in the
// PU-specific st_map.
//
// It is observed that g++ uses the same tree for different functions, such
// as inline functions. As a result, we cannot attach PU-specific ST's
// directly to the tree nodes.
//
// If Current_scope is 0, then the symbol table has not been initialized, and
// we are being called by WFE_Add_Weak to handle a weak symbol. In that
// case, use the non-PU-specific st_map.
if (Current_scope != 0 &&
(TREE_CODE(t) == PARM_DECL ||
(TREE_CODE(t) == VAR_DECL &&
(ST_sclass(st) == SCLASS_AUTO ||
(! pstatic_as_global &&
ST_sclass(st) == SCLASS_PSTATIC))))) {
// ST is PU-specific. Use pu_map[pu] to get the PU-specific st_map, then
// use st_map[t] to get the ST for the tree node t.
//
// We can access pu_map[pu] only if Scope_tab[Current_scope].st is valid
// because we need to get the current PU, but Get_Current_PU requires a
// valid Scope_tab[Current_scope].st. If Scope_tab[Current_scope].st is
// not set, then this means the caller is trying to create the ST for the
// function symbol.
if (Scope_tab[Current_scope].st != NULL) {
// ok to call Get_Current_PU.
PU *pu = &Get_Current_PU();
hash_map<PU*, hash_map<tree, ST*, ptrhash>*, ptrhash>::iterator it =
pu_map.find(pu);
if (it == pu_map.end()) {
// Create new PU-specific map.
pu_map[pu] = new hash_map<tree, ST*, ptrhash>;
}
// Put the ST in the PU-specific st_map.
(*(pu_map[pu]))[t_index] = st;
}
} else {
#ifdef Is_True_On
if (st_map[t_index]) {
// The st_map is already set. This is ok only for weak ST.
FmtAssert (ST_is_weak_symbol(st_map[t_index]),
("set_DECL_ST: st_map already set"));
}
#endif
// Put the ST in the non-PU-specific st_map.
st_map[t_index] = st;
}
}
// Get ST associated with the tree node T.
ST*&
get_DECL_ST(tree t) {
static ST *null_ST = (ST *) NULL;
// Find the tree node to use as index into st_map.
tree t_index;
if (TREE_CODE(t) == VAR_DECL &&
(DECL_CONTEXT(t) == 0 ||
TREE_CODE(DECL_CONTEXT(t)) == NAMESPACE_DECL) &&
DECL_NAME (t) && DECL_ASSEMBLER_NAME(t))
t_index = DECL_ASSEMBLER_NAME(t);
else
t_index = t;
// If Current_scope is 0, then the symbol table has not been initialized, and
// we are being called by WFE_Add_Weak to handle a weak symbol. Use the
// non-PU-specific st_map.
if (Current_scope == 0)
return st_map[t_index];
// See if the ST is in the non-PU-specific st_map.
if (st_map[t_index]) {
return st_map[t_index];
}
// The ST is not in the non-PU-specific map. Look in the PU-specific map.
// If Scope_tab[Current_scope].st is NULL, then the function ST has not
// been set yet, and there is no PU-specific map.
if (Scope_tab[Current_scope].st == NULL)
return null_ST;
// See if there is a PU-specific map.
PU *pu = &Get_Current_PU(); // needs Scope_tab[Current_scope].st
hash_map<PU*, hash_map<tree, ST*, ptrhash>*, ptrhash>::iterator pu_map_it =
pu_map.find(pu);
if (pu_map_it == pu_map.end())
return null_ST;
// There is a PU-specific map. Get the ST from the map.
hash_map<tree, ST*, ptrhash> *st_map = pu_map[pu];
return (*st_map)[t_index];
}
BOOL&
func_PU_uplevel(tree t) {
FmtAssert (TREE_CODE(t) == FUNCTION_DECL,
("func_PU_uplevel: not a FUNCTION_DECL tree node"));
return func_PU_uplevel_map[t];
}
INT32& WEAK_WORKAROUND(ST *st) { return weak_workaround_map[st]; }
#else
ST*& DECL_ST(tree t) {
if (TREE_CODE(t) == VAR_DECL &&
(DECL_CONTEXT(t) == 0 ||
TREE_CODE(DECL_CONTEXT(t)) == NAMESPACE_DECL) &&
DECL_NAME (t) && DECL_ASSEMBLER_NAME(t))
return st_map[DECL_ASSEMBLER_NAME(t)];
else
return st_map[t];
}
#endif
SYMTAB_IDX& DECL_SYMTAB_IDX(tree t) { return symtab_idx_map[t]; }
LABEL_IDX& DECL_LABEL_IDX(tree t) { return label_idx_map[t]; }
ST*& TREE_STRING_ST(tree t) { return string_st_map[t]; }
BOOL& DECL_LABEL_DEFINED(tree t) { return bool_map[t]; }
INT32& DECL_FIELD_ID(tree t) { return field_id_map[t]; }
INT32 & TYPE_FIELD_IDS_USED(tree t) { return type_field_ids_used_map[t]; }
INT32 & SCOPE_NUMBER(tree t) { return scope_number_map[t]; }
#ifdef KEY
tree & PARENT_SCOPE(tree t) { return parent_scope_map[t]; }
#endif
tree & LABEL_SCOPE(tree t) { return label_scope_map[t]; }
// This is for normal declarations.
// We do not know if the DST entry is filled in.
// So check and ensure a real entry exists.
DST_INFO_IDX & DECL_DST_IDX(tree t)
{
hash_map<tree, DST_INFO_IDX,ptrhash>::iterator it =
decl_idx_map.find(t);
if(it == decl_idx_map.end()) {
// substitute for lack of default constructor
DST_INFO_IDX dsti = DST_INVALID_IDX;
decl_idx_map[t] = dsti;
}
return decl_idx_map[t];
}
// This is for static class members and member functions.
// We need a distinct DST record for a single ST.
// Note that only the main record actually need be linked
// to ST as only that one gets an address/location.
// We do not know if the DST entry is filled in.
// So check and ensure a real entry exists.
DST_INFO_IDX & DECL_DST_SPECIFICATION_IDX(tree t)
{
hash_map<tree, DST_INFO_IDX,ptrhash>::iterator it =
decl_specification_idx_map.find(t);
if(it == decl_specification_idx_map.end()) {
// substitute for lack of default constructor
DST_INFO_IDX dsti = DST_INVALID_IDX;
decl_specification_idx_map[t] = dsti;
}
return decl_specification_idx_map[t];
}
// This is for static class members and member functions.
// We need a distinct DST record for a single ST.
// Note that only the main record actually need be linked
// to ST as only that one gets an address/location.
// We do not know if the DST entry is filled in.
// So check and ensure a real entry exists.
DST_INFO_IDX & DECL_DST_FIELD_IDX(tree t)
{
hash_map<tree, DST_INFO_IDX,ptrhash>::iterator it =
decl_field_idx_map.find(t);
if(it == decl_idx_map.end()) {
// substitute for lack of default constructor
DST_INFO_IDX dsti = DST_INVALID_IDX;
decl_field_idx_map[t] = dsti;
}
return decl_field_idx_map[t];
}
// We do not know if the DST entry is filled in.
// So check and ensure a real entry exists.
DST_INFO_IDX & TYPE_DST_IDX(tree t)
{
hash_map<tree, DST_INFO_IDX,ptrhash>::iterator it =
type_idx_map.find(t);
if(it == type_idx_map.end()) {
// substitute for lack of default constructor
DST_INFO_IDX dsti = DST_INVALID_IDX;
type_idx_map[t] = dsti;
}
return type_idx_map[t];
}
// We do not know if the DST entry is filled in.
// So check and ensure a real entry exists.
DST_INFO_IDX & DECL_DST_ABSTRACT_ROOT_IDX(tree t)
{
hash_map<tree, DST_INFO_IDX,ptrhash>::iterator it =
abstract_root_map.find(t);
if(it == abstract_root_map.end()) {
// substitute for lack of default constructor
DST_INFO_IDX dsti = DST_INVALID_IDX;
abstract_root_map[t] = dsti;
}
return abstract_root_map[t];
}
LABEL_IDX& HANDLER_LABEL(tree t) { return handler_label_map[t]; }
#endif
| 32.318571 | 118 | 0.628269 | [
"object",
"vector",
"model"
] |
478ae1ee2a836b0b803e442d61bf0b83d97b32b7 | 1,715 | cpp | C++ | devdc187.cpp | vidit1999/coding_problems | b6c9fa7fda37d9424cd11bcd54b385fd8cf1ee0a | [
"BSD-2-Clause"
] | 1 | 2020-02-24T18:28:48.000Z | 2020-02-24T18:28:48.000Z | devdc187.cpp | vidit1999/coding_problems | b6c9fa7fda37d9424cd11bcd54b385fd8cf1ee0a | [
"BSD-2-Clause"
] | null | null | null | devdc187.cpp | vidit1999/coding_problems | b6c9fa7fda37d9424cd11bcd54b385fd8cf1ee0a | [
"BSD-2-Clause"
] | null | null | null | #include <bits/stdc++.h>
using namespace std;
/*
You work in the best consumer electronics company around.
Your boss asked you to find out which products generate the most revenue.
You'll be given lists of products, amounts, and prices. Given these three
lists of same length, return the product name(s) with the highest revenue (amount * price).
If multiple products have the same revenue, order them according to their original positions.
Example
products: ["Computer", "Cell Phones", "Vacuum Cleaner"]
amounts: [8, 24, 8]
prices: [198, 9, 198]
return: Cell Phones
Test
products: ["Cell Phones", "Vacuum Cleaner", "Computer", "Autos", "Gold", "Fishing Rods", "Lego", " Speakers"]
amounts: [0, 12, 24, 17, 19, 23, 120, 8]
prices: [9, 24, 29, 31, 51, 8, 120, 14]
*/
vector<string> highestRevenue(vector<string> products, vector<int> amounts, vector<int> prices){
vector<int> revenue; // holds the revenue of all products
for(int i=0; i<amounts.size();i++){
revenue.push_back(amounts[i]*prices[i]);
}
int max_revenue = *max_element(revenue.begin(),revenue.end()); // maximum revenue
if(max_revenue == 0)
return vector<string>(); // if maximum revenue is zero then there is no need to return any product
vector<string> highestRevProducts; // vector storing the products with maximum revenue
for(int i=0;i<revenue.size();i++)
if(revenue[i] == max_revenue)
highestRevProducts.push_back(products[i]);
return highestRevProducts;
}
// main function
int main(){
vector<string> maxRev = highestRevenue({"Computer", "Cell Phones", "Vacuum Cleaner"},{8, 24, 8},{198, 9, 198});
for(auto s : maxRev)
cout << s << "\n";
return 0;
} | 35 | 115 | 0.68105 | [
"vector"
] |
478dc52d7d796a96ad8bd7cecc19802e2e216a7e | 1,556 | cc | C++ | src/inputs/geometries/square/square.cc | marissachanlatte/EmbeddedBoundary | 949bf8680317277950077874a5e5924af0003b00 | [
"MIT"
] | 1 | 2021-06-14T13:39:14.000Z | 2021-06-14T13:39:14.000Z | src/inputs/geometries/square/square.cc | marissachanlatte/EmbeddedBoundary | 949bf8680317277950077874a5e5924af0003b00 | [
"MIT"
] | null | null | null | src/inputs/geometries/square/square.cc | marissachanlatte/EmbeddedBoundary | 949bf8680317277950077874a5e5924af0003b00 | [
"MIT"
] | 3 | 2019-10-03T12:30:29.000Z | 2020-10-29T18:44:37.000Z | #include "inputs/geometries/square/square.h"
#include "helpers/geometry_objects.h"
#include <vector>
namespace boundary {
namespace inputs {
std::vector<double> SquareGeometry::BoundaryFunction(double x_value){
std::vector<double> y_values;
y_values.push_back(0.0);
return y_values;
};
double SquareGeometry::BoundaryDerivatives(helpers::Point a_point,
std::vector<int> degree){
return 0;
};
std::vector<double> SquareGeometry::BoundaryInverse(double y_value){
std::vector<double> x_values;
x_values.push_back(0.0);
return x_values;
};
int SquareGeometry::Inside(std::array<double, 2> point){
if (point[0] < 1.0 && point[0] > -1.0 && point[1] < 1.0 && point[1] > -1.0){
return 1;
}
else if ((point[0] == 1.0 && point[1] <= 1.0 && point[1] >= -1.0) ||
(point[1] == 1.0 && point[0] <= 1.0 && point[0] >= -1.0) ||
(point[1] == -1.0 && point[0] <= 1.0 && point[0] >= -1.0) ||
(point[0] == -1.0 && point[1] <= 1.0 && point[1] >= -1.0)){
return 2;
}
else {
return 0;
}
};
double SquareGeometry::XMin(){
return -1.0; // domain min
};
double SquareGeometry::XMax(){
return 1.0; // domain max
};
double SquareGeometry::YMin(){
return -1.0; // domain min
};
double SquareGeometry::YMax(){
return 1.0; // domain max
};
int SquareGeometry::MaxDepth(){
return 4;
};
int SquareGeometry::MaxSolverDepth(){
return 4;
}
int SquareGeometry::QOrder(){
return 1; // Q order
}
} // namespace inputs
} // namespace boundary
| 18.746988 | 78 | 0.596401 | [
"vector"
] |
478e1f10a5a33e123d46b67cdf23e425b436f4fd | 2,147 | hh | C++ | tests/netcode/common.hh | ahamez/netcode | aee7eeca8081831574dfb82edf3450ee03be36a1 | [
"BSD-2-Clause"
] | 7 | 2016-10-11T12:12:42.000Z | 2022-02-16T09:54:05.000Z | tests/netcode/common.hh | ahamez/netcode | aee7eeca8081831574dfb82edf3450ee03be36a1 | [
"BSD-2-Clause"
] | 1 | 2021-01-13T17:31:11.000Z | 2021-01-13T17:32:16.000Z | tests/netcode/common.hh | ahamez/netcode | aee7eeca8081831574dfb82edf3450ee03be36a1 | [
"BSD-2-Clause"
] | 4 | 2016-04-25T21:26:18.000Z | 2020-11-20T21:31:38.000Z | #pragma once
#include "netcode/detail/repair.hh"
#include "netcode/detail/source_list.hh"
#include "netcode/packet.hh"
namespace /* unnamed */ {
/*------------------------------------------------------------------------------------------------*/
using namespace ntc;
/*------------------------------------------------------------------------------------------------*/
// Convert an encoder repair to a decoder repair
inline
detail::decoder_repair
mk_decoder_repair(const detail::encoder_repair& r)
{
return { r.id(), r.encoded_size(), detail::source_id_list{r.source_ids()}
, r.symbol(), r.symbol().size()};
}
/*------------------------------------------------------------------------------------------------*/
inline
const detail::encoder_source&
add_source(detail::source_list& sl,std::uint32_t id, detail::byte_buffer&& buf)
{
return sl.emplace(id, std::move(buf));
}
/*------------------------------------------------------------------------------------------------*/
class packet_handler
{
public:
packet_handler()
: m_vec(1)
{}
void
operator()(const char* src, std::size_t len)
{
std::copy_n(src, len, std::back_inserter(m_vec.back()));
}
void
operator()()
{
m_vec.emplace_back();
}
const packet&
operator[](std::size_t pos)
const noexcept
{
return m_vec[pos];
}
std::size_t
nb_packets()
const noexcept
{
return m_vec.size() - 1;
}
private:
// Stores all packets.
std::vector<packet> m_vec;
};
/*------------------------------------------------------------------------------------------------*/
class data_handler
{
public:
data_handler()
: m_vec()
{}
void
operator()(const char* src, std::size_t len)
{
m_vec.emplace_back(src, src + len);
}
std::vector<char>
operator[](std::size_t pos)
const noexcept
{
return m_vec[pos];
}
std::size_t
nb_data()
const noexcept
{
return m_vec.size();
}
private:
// Stores all symbols.
std::vector<std::vector<char>> m_vec;
};
/*------------------------------------------------------------------------------------------------*/
} // namespace unnamed
| 18.833333 | 100 | 0.463437 | [
"vector"
] |
47a8e96cba8a030cab63ea7ecfabaa599c37a8d9 | 13,967 | cpp | C++ | DataSpec/SpecMP2.cpp | jackoalan/urde | 413483a996805a870f002324ee46cfc123f4df06 | [
"MIT"
] | null | null | null | DataSpec/SpecMP2.cpp | jackoalan/urde | 413483a996805a870f002324ee46cfc123f4df06 | [
"MIT"
] | null | null | null | DataSpec/SpecMP2.cpp | jackoalan/urde | 413483a996805a870f002324ee46cfc123f4df06 | [
"MIT"
] | null | null | null | #include <utility>
#include "SpecBase.hpp"
#include "DNAMP2/DNAMP2.hpp"
#include "DNAMP2/MLVL.hpp"
#include "DNAMP2/STRG.hpp"
#include "DNAMP2/AGSC.hpp"
#include "DNAMP2/MAPA.hpp"
#include "DNAMP1/CSNG.hpp"
#include "DNACommon/MAPU.hpp"
#include "hecl/ClientProcess.hpp"
#include "hecl/Blender/Connection.hpp"
#include "hecl/MultiProgressPrinter.hpp"
#include "Runtime/RetroTypes.hpp"
#include "nod/nod.hpp"
namespace DataSpec {
using namespace std::literals;
static logvisor::Module Log("urde::SpecMP2");
extern hecl::Database::DataSpecEntry SpecEntMP2;
extern hecl::Database::DataSpecEntry SpecEntMP2ORIG;
struct SpecMP2 : SpecBase {
bool checkStandaloneID(const char* id) const override {
if (!memcmp(id, "G2M", 3))
return true;
return false;
}
std::vector<const nod::Node*> m_nonPaks;
std::vector<DNAMP2::PAKBridge> m_paks;
std::map<std::string, DNAMP2::PAKBridge*, hecl::CaseInsensitiveCompare> m_orderedPaks;
hecl::ProjectPath m_workPath;
hecl::ProjectPath m_cookPath;
PAKRouter<DNAMP2::PAKBridge> m_pakRouter;
SpecMP2(const hecl::Database::DataSpecEntry* specEntry, hecl::Database::Project& project, bool pc)
: SpecBase(specEntry, project, pc)
, m_workPath(project.getProjectWorkingPath(), _SYS_STR("MP2"))
, m_cookPath(project.getProjectCookedPath(SpecEntMP2), _SYS_STR("MP2"))
, m_pakRouter(*this, m_workPath, m_cookPath) {
setThreadProject();
}
void buildPaks(nod::Node& root, const std::vector<hecl::SystemString>& args, ExtractReport& rep) {
m_nonPaks.clear();
m_paks.clear();
for (const nod::Node& child : root) {
bool isPak = false;
auto name = child.getName();
std::string lowerName(name);
std::transform(lowerName.begin(), lowerName.end(), lowerName.begin(), tolower);
if (name.size() > 4) {
std::string::iterator extit = lowerName.end() - 4;
if (std::string(extit, lowerName.end()) == ".pak") {
/* This is a pak */
isPak = true;
std::string lowerBase(lowerName.begin(), extit);
/* Needs filter */
bool good = true;
if (args.size()) {
good = false;
if (!lowerName.compare(0, 7, "metroid")) {
hecl::SystemChar idxChar = lowerName[7];
for (const hecl::SystemString& arg : args) {
if (arg.size() == 1 && iswdigit(arg[0]))
if (arg[0] == idxChar)
good = true;
}
} else
good = true;
if (!good) {
for (const hecl::SystemString& arg : args) {
std::string lowerArg(hecl::SystemUTF8Conv(arg).str());
std::transform(lowerArg.begin(), lowerArg.end(), lowerArg.begin(), tolower);
if (!lowerArg.compare(0, lowerBase.size(), lowerBase))
good = true;
}
}
}
m_paks.emplace_back(child, good);
}
}
if (!isPak)
m_nonPaks.push_back(&child);
}
/* Sort PAKs alphabetically */
m_orderedPaks.clear();
for (DNAMP2::PAKBridge& dpak : m_paks)
m_orderedPaks[std::string(dpak.getName())] = &dpak;
/* Assemble extract report */
for (const std::pair<std::string, DNAMP2::PAKBridge*>& item : m_orderedPaks) {
if (!item.second->m_doExtract)
continue;
rep.childOpts.emplace_back();
ExtractReport& childRep = rep.childOpts.back();
hecl::SystemStringConv nameView(item.first);
childRep.name = hecl::SystemString(nameView.sys_str());
childRep.desc = item.second->getLevelString();
}
}
bool checkFromStandaloneDisc(nod::DiscBase& disc, const hecl::SystemString& regstr,
const std::vector<hecl::SystemString>& args, std::vector<ExtractReport>& reps) override {
nod::IPartition* partition = disc.getDataPartition();
std::unique_ptr<uint8_t[]> dolBuf = partition->getDOLBuf();
const char* buildInfo = (char*)memmem(dolBuf.get(), partition->getDOLSize(), "MetroidBuildInfo", 16) + 19;
if (!buildInfo)
return false;
/* Root Report */
reps.emplace_back();
ExtractReport& rep = reps.back();
rep.name = _SYS_STR("MP2");
rep.desc = _SYS_STR("Metroid Prime 2 ") + regstr;
std::string buildStr(buildInfo);
hecl::SystemStringConv buildView(buildStr);
rep.desc += _SYS_STR(" (") + buildView + _SYS_STR(")");
/* Iterate PAKs and build level options */
nod::Node& root = partition->getFSTRoot();
buildPaks(root, args, rep);
return true;
}
bool checkFromTrilogyDisc(nod::DiscBase& disc, const hecl::SystemString& regstr,
const std::vector<hecl::SystemString>& args, std::vector<ExtractReport>& reps) override {
std::vector<hecl::SystemString> mp2args;
bool doExtract = false;
if (args.size()) {
/* Needs filter */
for (const hecl::SystemString& arg : args) {
hecl::SystemString lowerArg = arg;
hecl::ToLower(lowerArg);
if (!lowerArg.compare(0, 3, _SYS_STR("mp2"))) {
doExtract = true;
mp2args.reserve(args.size());
size_t slashPos = arg.find(_SYS_STR('/'));
if (slashPos == hecl::SystemString::npos)
slashPos = arg.find(_SYS_STR('\\'));
if (slashPos != hecl::SystemString::npos)
mp2args.emplace_back(hecl::SystemString(arg.begin() + slashPos + 1, arg.end()));
}
}
} else
doExtract = true;
if (!doExtract)
return false;
nod::IPartition* partition = disc.getDataPartition();
nod::Node& root = partition->getFSTRoot();
nod::Node::DirectoryIterator dolIt = root.find("rs5mp2_p.dol");
if (dolIt == root.end()) {
dolIt = root.find("rs5mp2jpn_p.dol");
if (dolIt == root.end())
return false;
}
std::unique_ptr<uint8_t[]> dolBuf = dolIt->getBuf();
const char* buildInfo = (char*)memmem(dolBuf.get(), dolIt->size(), "MetroidBuildInfo", 16) + 19;
/* Root Report */
reps.emplace_back();
ExtractReport& rep = reps.back();
rep.name = _SYS_STR("MP2");
rep.desc = _SYS_STR("Metroid Prime 2 ") + regstr;
if (buildInfo) {
std::string buildStr(buildInfo);
hecl::SystemStringConv buildView(buildStr);
rep.desc += _SYS_STR(" (") + buildView + _SYS_STR(")");
}
/* Iterate PAKs and build level options */
nod::Node::DirectoryIterator mp2It = root.find("MP2");
if (mp2It == root.end()) {
mp2It = root.find("MP2JPN");
if (mp2It == root.end())
return false;
}
buildPaks(*mp2It, mp2args, rep);
return true;
}
bool extractFromDisc(nod::DiscBase& disc, bool force, const hecl::MultiProgressPrinter& progress) override {
nod::ExtractionContext ctx = {force, nullptr};
m_workPath.makeDir();
progress.startNewLine();
progress.print(_SYS_STR("Indexing PAKs"), _SYS_STR(""), 0.0);
m_pakRouter.build(m_paks,
[&progress](float factor) { progress.print(_SYS_STR("Indexing PAKs"), _SYS_STR(""), factor); });
progress.print(_SYS_STR("Indexing PAKs"), _SYS_STR(""), 1.0);
hecl::ProjectPath outPath(m_project.getProjectWorkingPath(), _SYS_STR("out"));
outPath.makeDir();
disc.getDataPartition()->extractSysFiles(outPath.getAbsolutePath(), ctx);
hecl::ProjectPath mp2OutPath(outPath, m_standalone ? _SYS_STR("files") : _SYS_STR("files/MP2"));
mp2OutPath.makeDirChain(true);
progress.startNewLine();
progress.print(_SYS_STR("MP2 Root"), _SYS_STR(""), 0.0);
int prog = 0;
ctx.progressCB = [&prog, &progress](std::string_view name, float) {
hecl::SystemStringConv nameView(name);
progress.print(_SYS_STR("MP2 Root"), nameView.c_str(), prog);
};
for (const nod::Node* node : m_nonPaks) {
node->extractToDirectory(mp2OutPath.getAbsolutePath(), ctx);
prog++;
}
progress.print(_SYS_STR("MP2 Root"), _SYS_STR(""), 1.0);
hecl::ClientProcess process;
progress.startNewLine();
for (std::pair<const std::string, DNAMP2::PAKBridge*>& pair : m_orderedPaks) {
DNAMP2::PAKBridge& pak = *pair.second;
if (!pak.m_doExtract)
continue;
auto name = pak.getName();
hecl::SystemStringConv sysName(name);
auto pakName = hecl::SystemString(sysName.sys_str());
process.addLambdaTransaction([this, &progress, &pak, pakName, force](hecl::blender::Token& btok) {
int threadIdx = hecl::ClientProcess::GetThreadWorkerIdx();
m_pakRouter.extractResources(pak, force, btok,
[&progress, &pakName, threadIdx](const hecl::SystemChar* substr, float factor) {
progress.print(pakName.c_str(), substr, factor, threadIdx);
});
});
}
process.waitUntilComplete();
return true;
}
const hecl::Database::DataSpecEntry& getOriginalSpec() const override { return SpecEntMP2; }
const hecl::Database::DataSpecEntry& getUnmodifiedSpec() const override { return SpecEntMP2ORIG; }
hecl::ProjectPath getWorking(class UniqueID32& id) override { return m_pakRouter.getWorking(id); }
bool checkPathPrefix(const hecl::ProjectPath& path) const override {
return path.getRelativePath().compare(0, 4, _SYS_STR("MP2/")) == 0;
}
bool validateYAMLDNAType(athena::io::IStreamReader& fp) const override {
athena::io::YAMLDocReader reader;
yaml_parser_set_input(reader.getParser(), (yaml_read_handler_t*)athena::io::YAMLAthenaReader, &fp);
return reader.ClassTypeOperation([](std::string_view classType) {
if (classType == DNAMP2::MLVL::DNAType())
return true;
else if (classType == DNAMP2::STRG::DNAType())
return true;
else if (classType == "ATBL")
return true;
return false;
});
}
urde::SObjectTag buildTagFromPath(const hecl::ProjectPath& path) const override { return {}; }
void cookMesh(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds, bool fast,
hecl::blender::Token& btok, FCookProgress progress) override {}
void cookColMesh(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds, bool fast,
hecl::blender::Token& btok, FCookProgress progress) override {}
void cookArmature(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds, bool fast,
hecl::blender::Token& btok, FCookProgress progress) override {}
void cookPathMesh(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds, bool fast,
hecl::blender::Token& btok, FCookProgress progress) override {}
void cookActor(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds, bool fast,
hecl::blender::Token& btok, FCookProgress progress) override {}
void cookArea(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds, bool fast,
hecl::blender::Token& btok, FCookProgress progress) override {}
void cookWorld(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds, bool fast,
hecl::blender::Token& btok, FCookProgress progress) override {}
void cookGuiFrame(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds,
hecl::blender::Token& btok, FCookProgress progress) override {}
void cookYAML(const hecl::ProjectPath& out, const hecl::ProjectPath& in, athena::io::IStreamReader& fin,
hecl::blender::Token& btok, FCookProgress progress) override {}
void flattenDependenciesYAML(athena::io::IStreamReader& fin, std::vector<hecl::ProjectPath>& pathsOut) override {}
void flattenDependenciesANCSYAML(athena::io::IStreamReader& fin, std::vector<hecl::ProjectPath>& pathsOut,
int charIdx) override {}
void cookAudioGroup(const hecl::ProjectPath& out, const hecl::ProjectPath& in, FCookProgress progress) override {
DNAMP2::AGSC::Cook(in, out);
progress(_SYS_STR("Done"));
}
void cookSong(const hecl::ProjectPath& out, const hecl::ProjectPath& in, FCookProgress progress) override {
DNAMP1::CSNG::Cook(in, out);
progress(_SYS_STR("Done"));
}
void cookMapArea(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds,
hecl::blender::Token& btok, FCookProgress progress) override {
hecl::blender::MapArea mapa = ds.compileMapArea();
ds.close();
DNAMP2::MAPA::Cook(mapa, out);
progress(_SYS_STR("Done"));
}
void cookMapUniverse(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds,
hecl::blender::Token& btok, FCookProgress progress) override {
hecl::blender::MapUniverse mapu = ds.compileMapUniverse();
ds.close();
DNAMAPU::MAPU::Cook(mapu, out);
progress(_SYS_STR("Done"));
}
};
hecl::Database::DataSpecEntry SpecEntMP2(
_SYS_STR("MP2"sv), _SYS_STR("Data specification for original Metroid Prime 2 engine"sv), _SYS_STR(".pak"sv),
[](hecl::Database::Project& project, hecl::Database::DataSpecTool) -> std::unique_ptr<hecl::Database::IDataSpec> {
return std::make_unique<SpecMP2>(&SpecEntMP2, project, false);
});
hecl::Database::DataSpecEntry SpecEntMP2PC = {
_SYS_STR("MP2-PC"sv), _SYS_STR("Data specification for PC-optimized Metroid Prime 2 engine"sv), _SYS_STR(".upak"sv),
[](hecl::Database::Project& project,
hecl::Database::DataSpecTool tool) -> std::unique_ptr<hecl::Database::IDataSpec> {
if (tool != hecl::Database::DataSpecTool::Extract)
return std::make_unique<SpecMP2>(&SpecEntMP2PC, project, true);
return {};
}};
hecl::Database::DataSpecEntry SpecEntMP2ORIG = {
_SYS_STR("MP2-ORIG"sv), _SYS_STR("Data specification for unmodified Metroid Prime 2 resources"sv), {}, {}};
} // namespace DataSpec
| 39.013966 | 120 | 0.641655 | [
"vector",
"transform"
] |
47a9bfb41dc9abf4e0293e9f1b610e2a2bebb2b0 | 12,221 | cpp | C++ | src/core/macro_impl.cpp | DorianRudolph/cLaTeXMath | 04631b758228521819a47e6c7b53bf2ef75143dc | [
"Unlicense",
"MIT"
] | 178 | 2016-06-27T08:21:01.000Z | 2022-03-10T09:18:10.000Z | src/core/macro_impl.cpp | DorianRudolph/cLaTeXMath | 04631b758228521819a47e6c7b53bf2ef75143dc | [
"Unlicense",
"MIT"
] | 69 | 2018-08-07T09:07:53.000Z | 2022-03-07T16:53:05.000Z | src/core/macro_impl.cpp | DorianRudolph/cLaTeXMath | 04631b758228521819a47e6c7b53bf2ef75143dc | [
"Unlicense",
"MIT"
] | 39 | 2016-06-27T08:28:42.000Z | 2022-03-09T01:27:51.000Z | #include "core/macro_impl.h"
#include <memory>
#include "graphic/graphic.h"
using namespace tex;
using namespace std;
namespace tex {
macro(kern) {
auto[unit, value] = tp.getLength();
return sptrOf<SpaceAtom>(unit, value, 0.f, 0.f);
}
macro(hvspace) {
auto[unit, value] = SpaceAtom::getLength(args[1]);
return (
args[0][0] == L'h'
? sptrOf<SpaceAtom>(unit, value, 0.f, 0.f)
: sptrOf<SpaceAtom>(unit, 0.f, value, 0.f)
);
}
macro(rule) {
auto[wu, w] = SpaceAtom::getLength(args[1]);
auto[hu, h] = SpaceAtom::getLength(args[2]);
auto[ru, r] = SpaceAtom::getLength(args[3]);
return sptrOf<RuleAtom>(wu, w, hu, h, ru, -r);
}
macro(cfrac) {
Alignment numAlign = Alignment::center;
if (args[3] == L"r") {
numAlign = Alignment::right;
} else if (args[3] == L"l") {
numAlign = Alignment::left;
}
Formula num(tp, args[1], false);
Formula denom(tp, args[2], false);
if (num._root == nullptr || denom._root == nullptr)
throw ex_parse("Both numerator and denominator of a fraction can't be empty!");
auto f = sptrOf<FractionAtom>(num._root, denom._root, true, numAlign, Alignment::center);
f->_useKern = false;
f->_type = AtomType::inner;
auto* r = new RowAtom();
r->add(sptrOf<StyleAtom>(TexStyle::display, f));
return sptr<Atom>(r);
}
macro(sfrac) {
Formula num(tp, args[1], false);
Formula den(tp, args[2], false);
if (num._root == nullptr || den._root == nullptr)
throw ex_parse("Both numerator and denominator of a fraction can't be empty!");
float sx = 0.75f, sy = 0.75f, r = 0.45f, sL = -0.13f, sR = -0.065f;
sptr<Atom> slash = SymbolAtom::get("slash");
if (!tp.isMathMode()) {
sx = 0.6f;
sy = 0.5f;
r = 0.75f;
sL = -0.24f;
sR = -0.24f;
auto in = sptrOf<ScaleAtom>(SymbolAtom::get("textfractionsolidus"), 1.25f, 0.65f);
auto* vr = new VRowAtom(in);
vr->setRaise(UnitType::ex, 0.4f);
slash = sptr<Atom>(vr);
}
auto* snum = new VRowAtom(sptrOf<ScaleAtom>(num._root, sx, sy));
snum->setRaise(UnitType::ex, r);
auto* ra = new RowAtom(sptr<Atom>(snum));
ra->add(sptrOf<SpaceAtom>(UnitType::em, sL, 0.f, 0.f));
ra->add(slash);
ra->add(sptrOf<SpaceAtom>(UnitType::em, sR, 0.f, 0.f));
ra->add(sptrOf<ScaleAtom>(den._root, sx, sy));
return sptr<Atom>(ra);
}
macro(genfrac) {
sptr<SymbolAtom> L, R;
Formula left(tp, args[1], false);
L = dynamic_pointer_cast<SymbolAtom>(left._root);
Formula right(tp, args[2], false);
R = dynamic_pointer_cast<SymbolAtom>(right._root);
bool rule = true;
auto[unit, value] = SpaceAtom::getLength(args[3]);
if (args[3].empty()) {
unit = UnitType::em;
value = 0.f;
rule = false;
}
int style = 0;
if (!args[4].empty()) valueof(args[4], style);
Formula num(tp, args[5], false);
Formula den(tp, args[6], false);
if (num._root == nullptr || den._root == nullptr) {
throw ex_parse("Both numerator and denominator of a fraction can't be empty!");
}
auto fa = sptrOf<FractionAtom>(num._root, den._root, rule, unit, value);
auto* ra = new RowAtom();
const auto texStyle = static_cast<TexStyle>(style * 2);
ra->add(sptrOf<StyleAtom>(texStyle, sptrOf<FencedAtom>(fa, L, R)));
return sptr<Atom>(ra);
}
sptr<Atom> _frac_with_delims(TeXParser& tp, Args& args, bool rule, bool hasLength) {
auto num = tp.popFormulaAtom();
pair<UnitType, float> l;
if (hasLength) l = tp.getLength();
auto[unit, value] = l;
auto den = Formula(tp, tp.getOverArgument(), false)._root;
if (num == nullptr || den == nullptr)
throw ex_parse("Both numerator and denominator of a fraction can't be empty!");
auto left = Formula(tp, args[1], false)._root;
auto bigl = dynamic_cast<BigDelimiterAtom*>(left.get());
if (bigl != nullptr) left = bigl->_delim;
auto right = Formula(tp, args[2], false)._root;
auto bigr = dynamic_cast<BigDelimiterAtom*>(right.get());
if (bigr != nullptr) right = bigr->_delim;
auto sl = dynamic_pointer_cast<SymbolAtom>(left);
auto sr = dynamic_pointer_cast<SymbolAtom>(right);
if (sl != nullptr && sr != nullptr) {
auto f = (
hasLength
? sptrOf<FractionAtom>(num, den, unit, value)
: sptrOf<FractionAtom>(num, den, rule)
);
return sptrOf<FencedAtom>(f, sl, sr);
}
auto ra = new RowAtom();
ra->add(left);
ra->add(
hasLength
? sptrOf<FractionAtom>(num, den, unit, value)
: sptrOf<FractionAtom>(num, den, rule)
);
ra->add(right);
return sptr<Atom>(ra);
}
macro(overwithdelims) {
return _frac_with_delims(tp, args, true, false);
}
macro(atopwithdelims) {
return _frac_with_delims(tp, args, false, false);
}
macro(abovewithdelims) {
return _frac_with_delims(tp, args, true, true);
}
macro(textstyles) {
wstring style(args[0]);
if (style == L"frak") style = L"mathfrak";
else if (style == L"Bbb") style = L"mathbb";
else if (style == L"bold") return sptrOf<BoldAtom>(Formula(tp, args[1], false)._root);
else if (style == L"cal") style = L"mathcal";
FontInfos* info = nullptr;
auto it = Formula::_externalFontMap.find(UnicodeBlock::BASIC_LATIN);
if (it != Formula::_externalFontMap.end()) {
info = it->second;
Formula::_externalFontMap[UnicodeBlock::BASIC_LATIN] = nullptr;
}
auto atom = Formula(tp, args[1], false)._root;
if (info != nullptr) {
Formula::_externalFontMap[UnicodeBlock::BASIC_LATIN] = info;
}
string s = wide2utf8(style);
return sptrOf<TextStyleAtom>(atom, s);
}
macro(accentbiss) {
string acc;
switch (args[0][0]) {
case '~':
acc = "tilde";
break;
case '\'':
acc = "acute";
break;
case '^':
acc = "hat";
break;
case '\"':
acc = "ddot";
break;
case '`':
acc = "grave";
break;
case '=':
acc = "bar";
break;
case '.':
acc = "dot";
break;
case 'u':
acc = "breve";
break;
case 'v':
acc = "check";
break;
case 'H':
acc = "doubleacute";
break;
case 't':
acc = "tie";
break;
case 'r':
acc = "mathring";
break;
case 'U':
acc = "cyrbreve";
break;
}
return sptrOf<AccentedAtom>(Formula(tp, args[1], false)._root, acc);
}
macro(left) {
wstring grep = tp.getGroup(L"\\left", L"\\right");
auto left = Formula(tp, args[1], false)._root;
auto* big = dynamic_cast<BigDelimiterAtom*>(left.get());
if (big != nullptr) left = big->_delim;
auto right = tp.getArgument();
big = dynamic_cast<BigDelimiterAtom*>(right.get());
if (big != nullptr) right = big->_delim;
auto sl = dynamic_pointer_cast<SymbolAtom>(left);
auto sr = dynamic_pointer_cast<SymbolAtom>(right);
if (sl != nullptr && sr != nullptr) {
Formula tf(tp, grep, false);
return sptrOf<FencedAtom>(tf._root, sl, tf._middle, sr);
}
auto* ra = new RowAtom();
ra->add(left);
ra->add(Formula(tp, grep, false)._root);
ra->add(right);
return sptr<Atom>(ra);
}
macro(intertext) {
if (!tp.isArrayMode())
throw ex_parse("Command \\intertext must used in array environment!");
wstring str(args[1]);
replaceall(str, L"^{\\prime}", L"\'");
replaceall(str, L"^{\\prime\\prime}", L"\'\'");
auto ra = sptrOf<RomanAtom>(Formula(tp, str, "mathnormal", false, false)._root);
ra->_type = AtomType::interText;
tp.addAtom(ra);
tp.addRow();
return nullptr;
}
macro(newcommand) {
wstring newcmd(args[1]);
int nbArgs = 0;
if (!tp.isValidName(newcmd))
throw ex_parse("Invalid name for the command '" + wide2utf8(newcmd));
if (!args[3].empty()) valueof(args[3], nbArgs);
if (args[4].empty()) {
NewCommandMacro::addNewCommand(newcmd.substr(1), args[2], nbArgs);
} else {
NewCommandMacro::addNewCommand(newcmd.substr(1), args[2], nbArgs, args[4]);
}
return nullptr;
}
macro(renewcommand) {
wstring newcmd(args[1]);
int nbArgs = 0;
if (!tp.isValidName(newcmd))
throw ex_parse("Invalid name for the command: " + wide2utf8(newcmd));
if (!args[3].empty()) valueof(args[3], nbArgs);
if (args[4].empty()) {
NewCommandMacro::addRenewCommand(newcmd.substr(1), args[2], nbArgs);
} else {
NewCommandMacro::addRenewCommand(newcmd.substr(1), args[2], nbArgs, args[4]);
}
return nullptr;
}
macro(raisebox) {
auto[ru, r] = SpaceAtom::getLength(args[1]);
auto[hu, h] = SpaceAtom::getLength(args[3]);
auto[du, d] = SpaceAtom::getLength(args[4]);
return sptrOf<RaiseAtom>(Formula(tp, args[2])._root, ru, r, hu, h, du, d);
}
macro(definecolor) {
color c = TRANSPARENT;
string cs = wide2utf8(args[3]);
if (args[2] == L"gray") {
float f = 0;
valueof(args[3], f);
c = rgb(f, f, f);
} else if (args[2] == L"rgb") {
StrTokenizer stok(cs, ":,");
if (stok.count() != 3)
throw ex_parse("The color definition must have three components!");
float r, g, b;
string R = stok.next(), G = stok.next(), B = stok.next();
valueof(trim(R), r);
valueof(trim(G), g);
valueof(trim(B), b);
c = rgb(r, g, b);
} else if (args[2] == L"cmyk") {
StrTokenizer stok(cs, ":,");
if (stok.count() != 4)
throw ex_parse("The color definition must have four components!");
float cmyk[4];
for (float& i : cmyk) {
string X = stok.next();
valueof(trim(X), i);
}
float k = 1 - cmyk[3];
c = rgb(k * (1 - cmyk[0]), k * (1 - cmyk[1]), k * (1 - cmyk[2]));
} else {
throw ex_parse("Color model is incorrect!");
}
ColorAtom::defineColor(wide2utf8(args[1]), c);
return nullptr;
}
macro(sizes) {
float f = 1;
if (args[0] == L"tiny")
f = 0.5f;
else if (args[0] == L"scriptsize")
f = 0.7f;
else if (args[0] == L"footnotesize")
f = 0.8f;
else if (args[0] == L"small")
f = 0.9f;
else if (args[0] == L"normalsize")
f = 1.f;
else if (args[0] == L"large")
f = 1.2f;
else if (args[0] == L"Large")
f = 1.4f;
else if (args[0] == L"LARGE")
f = 1.8f;
else if (args[0] == L"huge")
f = 2.f;
else if (args[0] == L"Huge")
f = 2.5f;
auto a = Formula(tp, tp.getOverArgument(), "", false, tp.isMathMode())._root;
return sptrOf<MonoScaleAtom>(a, f);
}
macro(romannumeral) {
int numbers[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
string letters[] = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
string roman;
int num;
string x = wide2utf8(args[1]);
valueof(trim(x), num);
for (int i = 0; i < 13; i++) {
while (num >= numbers[i]) {
roman += letters[i];
num -= numbers[i];
}
}
if (args[0][0] == 'r') {
tolower(roman);
}
const wstring str = utf82wide(roman);
return Formula(str, false)._root;
}
macro(muskips) {
SpaceType type = SpaceType::none;
if (args[0] == L",")
type = SpaceType::thinMuSkip;
else if (args[0] == L":")
type = SpaceType::medMuSkip;
else if (args[0] == L";")
type = SpaceType::thickMuSkip;
else if (args[0] == L"thinspace")
type = SpaceType::thinMuSkip;
else if (args[0] == L"medspace")
type = SpaceType::medMuSkip;
else if (args[0] == L"thickspace")
type = SpaceType::thickMuSkip;
else if (args[0] == L"!")
type = SpaceType::negThinMuSkip;
else if (args[0] == L"negthinspace")
type = SpaceType::negThinMuSkip;
else if (args[0] == L"negmedspace")
type = SpaceType::negMedMuSkip;
else if (args[0] == L"negthickspace")
type = SpaceType::negThickMuSkip;
return sptrOf<SpaceAtom>(type);
}
macro(xml) {
map<string, string>& m = tp._formula->_xmlMap;
wstring str(args[1]);
wstring buf;
size_t start = 0;
size_t pos;
while ((pos = str.find(L'$')) != wstring::npos) {
if (pos < str.length() - 1) {
start = pos;
while (++start < str.length() && isalpha(str[start]));
wstring key = str.substr(pos + 1, start - pos - 1);
string x = wide2utf8(key);
auto it = m.find(x);
if (it != m.end()) {
buf.append(str.substr(0, pos));
wstring x = utf82wide(it->second.c_str());
buf.append(x);
} else {
buf.append(str.substr(0, start));
}
str = str.substr(start);
} else {
buf.append(str);
str = L"";
}
}
buf.append(str);
str = buf;
return Formula(tp, str)._root;
}
} // namespace tex
| 26.169165 | 93 | 0.597987 | [
"model"
] |
47aa6089f92e088054103d52d75ee9ab2951ddd5 | 1,980 | cpp | C++ | examples/example1.cpp | HongqiangWei/octree | 095e88b417c22fcfc3ba46706c85122460b1d636 | [
"MIT"
] | 216 | 2015-05-15T16:40:13.000Z | 2022-03-22T23:53:42.000Z | examples/example1.cpp | HongqiangWei/octree | 095e88b417c22fcfc3ba46706c85122460b1d636 | [
"MIT"
] | 13 | 2015-09-15T03:07:56.000Z | 2020-03-12T06:36:33.000Z | examples/example1.cpp | HongqiangWei/octree | 095e88b417c22fcfc3ba46706c85122460b1d636 | [
"MIT"
] | 68 | 2015-10-28T07:03:40.000Z | 2022-03-04T08:37:22.000Z | #include <iostream>
#include <cstdlib>
#include <time.h>
#include "../Octree.hpp"
#include "utils.h"
/** Example 1: Searching radius neighbors with default access by public x,y,z variables.
*
* \author behley
*/
class Point3f
{
public:
Point3f(float x, float y, float z) : x(x), y(y), z(z)
{
}
float x, y, z;
};
int main(int argc, char** argv)
{
if (argc < 2)
{
std::cerr << "filename of point cloud missing." << std::endl;
return -1;
}
std::string filename = argv[1];
std::vector<Point3f> points;
readPoints<Point3f>(filename, points);
std::cout << "Read " << points.size() << " points." << std::endl;
if (points.size() == 0)
{
std::cerr << "Empty point cloud." << std::endl;
return -1;
}
int64_t begin, end;
// initializing the Octree with points from point cloud.
unibn::Octree<Point3f> octree;
unibn::OctreeParams params;
octree.initialize(points);
// radiusNeighbors returns indexes to neighboring points.
std::vector<uint32_t> results;
const Point3f& q = points[0];
octree.radiusNeighbors<unibn::L2Distance<Point3f> >(q, 0.2f, results);
std::cout << results.size() << " radius neighbors (r = 0.2m) found for (" << q.x << ", " << q.y << "," << q.z << ")"
<< std::endl;
for (uint32_t i = 0; i < results.size(); ++i)
{
const Point3f& p = points[results[i]];
std::cout << " " << results[i] << ": (" << p.x << ", " << p.y << ", " << p.z << ") => "
<< std::sqrt(unibn::L2Distance<Point3f>::compute(p, q)) << std::endl;
}
// performing queries for each point in point cloud
begin = clock();
for (uint32_t i = 0; i < points.size(); ++i)
{
octree.radiusNeighbors<unibn::L2Distance<Point3f> >(points[i], 0.5f, results);
}
end = clock();
double search_time = ((double)(end - begin) / CLOCKS_PER_SEC);
std::cout << "Searching for all radius neighbors (r = 0.5m) took " << search_time << " seconds." << std::endl;
octree.clear();
return 0;
}
| 26.4 | 118 | 0.591919 | [
"vector"
] |
47ae75350d7ccb2508485516afaef0e8623e8197 | 6,360 | cpp | C++ | src/company/Company.cpp | Dewyer/nahfstocks | 3e095e7737de510d0268a94b0296d88b28d242ec | [
"MIT"
] | null | null | null | src/company/Company.cpp | Dewyer/nahfstocks | 3e095e7737de510d0268a94b0296d88b28d242ec | [
"MIT"
] | null | null | null | src/company/Company.cpp | Dewyer/nahfstocks | 3e095e7737de510d0268a94b0296d88b28d242ec | [
"MIT"
] | null | null | null | #include "../../lib/prelude.h"
#include "Company.h"
#include "../../lib/string/String.h"
#include "../../lib/types.h"
#include "../utils/format_money.h"
#include "../cli/CliQuestioner.h"
using nhflib::Vector;
using nhflib::String;
using exchange::Order;
const String &company::Company::get_name() const noexcept {
return this->name;
}
f64 company::Company::get_sector() const noexcept {
return this->sector;
}
const String &company::Company::get_symbol() const noexcept {
return this->symbol;
}
company::Company::Company(usize id, const String &_name, const String &_sym, f64 _financial_standing, f64 _sector,
f64 _leadership_bias,
usize _earnings_offset, usize _outstanding_shares, f64 _dividend_percentage) {
this->id = id;
this->name = _name;
this->symbol = _sym;
this->financial_standing = _financial_standing;
this->sector = _sector;
this->leadership_bias = _leadership_bias;
this->earnings_offset = _earnings_offset;
this->cached_ask = Option<usize>();
this->cached_bid = Option<usize>();
this->bid = Option<usize>();
this->ask = Option<usize>();
this->outstanding_shares = _outstanding_shares;
this->orders = Vector<Order>();
this->price_records = Vector<CompanyPriceRecord>();
this->dividend_percentage = _dividend_percentage;
}
void company::Company::print_to(Rc<CliHelper> cli) const {
auto cap_str = utils::format_money(this->get_market_cap());
auto price_str = utils::format_money(this->get_stock_price());
cli->os() << "=[" << this->id << "]= " << this->get_name().c_str() << " - [" << this->get_symbol().c_str()
<< "] Cap: " << cap_str << ", Price: " << price_str;
cli->print_ln();
cli->os() << "Sector: " << this->get_sector() << ", Financials: " << this->financial_standing << ", Leadership: "
<< this->leadership_bias;
cli->print_ln();
}
usize company::Company::get_id() const noexcept {
return this->id;
}
void company::Company::add_order(nhflib::Rc<exchange::Order> ord_rc) {
this->orders.sorted_push_back(ord_rc, [](const Rc<exchange::Order> &then, Rc<exchange::Order> that) {
if (then->target_price == that->target_price) {
return then->amount > that->amount;
}
return then->target_price < that->target_price;
});
if (ord_rc->type == exchange::OrderType::Buy) {
if (!this->cached_bid.is_some() || this->cached_bid.unwrap() < ord_rc->target_price) {
this->cached_bid.swap(ord_rc->target_price);
}
this->cached_buy_vol += ord_rc->amount;
}
if (ord_rc->type == exchange::OrderType::Sell) {
if (!this->cached_ask.is_some() || this->cached_ask.unwrap() > ord_rc->target_price) {
this->cached_ask.swap(ord_rc->target_price);
}
this->cached_sell_vol += ord_rc->amount;
}
}
void company::Company::recalculate_details() {
this->bid = this->cached_bid;
this->ask = this->cached_ask;
this->buy_vol = this->cached_buy_vol;
this->sell_vol = this->cached_sell_vol;
}
const Option<usize> &company::Company::get_bid() const {
return this->bid;
}
const Option<usize> &company::Company::get_ask() const {
return this->ask;
}
usize company::Company::get_outstanding_shares() const noexcept {
return this->outstanding_shares;
}
usize company::Company::get_market_cap() const {
auto price = this->get_stock_price();
return this->outstanding_shares * price;
}
usize company::Company::get_stock_price() const {
auto ask_pr = this->get_ask().unwrap_or(0);
auto bid_pr = this->get_bid().unwrap_or(0);
auto price_mid = ask_pr + bid_pr / 2;
return price_mid;
}
void company::Company::detailed_print_to(Rc<CliHelper> cli) {
this->print_to(cli);
cli->os() << "Bid: " << utils::format_money(this->bid.unwrap_or(0))
<< ", Ask: " << utils::format_money(this->ask.unwrap_or(0));
cli->print_ln();
this->view_price_table(cli);
}
void company::Company::take_price_sample(usize cycle) {
this->price_records.push_back(CompanyPriceRecord{
cycle,
this->bid.unwrap_or(0),
this->ask.unwrap_or(0),
});
}
void company::Company::view_price_table(Rc<CliHelper> cli) {
if (this->price_records.size() == 0) {
cli->print_ln("No pricing records to show.");
return;
}
auto last_record_idx = this->price_records.size() - 1;
const usize step = 50;
usize from = 0;
usize to = std::min(step, last_record_idx);
while (true) {
this->view_price_table_in_range(cli, from, to);
if (to == last_record_idx) {
break;
}
auto qst = cli->build_question()
.question("Do you want to view the next page?")
.option("Yes")
.option("No")
.ask();
if (qst.unwrap_or(2) != 1) {
break;
}
auto next_to = std::min(to + step, last_record_idx);
from += next_to - to;
to = next_to;
}
}
void company::Company::view_price_table_in_range(Rc<CliHelper> cli, usize from_idx, usize to_idx) {
auto record_count = this->price_records.size();
if (record_count == 0) {
throw std::runtime_error("No pricing records to show.");
}
auto range_ok = record_count - 1 >= from_idx && to_idx >= from_idx && to_idx <= record_count - 1;
if (!range_ok) {
throw std::runtime_error("Invalid view for price table.");
}
auto price_table = cli->build_table();
price_table
.padding(1)
.add_column("Cycle")
.add_column("Bid")
.add_column("Ask");
for (usize ii = from_idx; ii <= to_idx; ii++) {
auto pr_el = this->price_records.at(record_count - ii - 1);
price_table
.add_cell(pr_el->cycle)
.add_cell(pr_el->bid)
.add_cell(pr_el->ask);
}
price_table.print();
}
f64 company::Company::get_leadership() const noexcept {
return this->leadership_bias;
}
f64 company::Company::get_financials() const noexcept {
return this->financial_standing;
}
bool company::Company::get_had_an_ipo() const noexcept {
return this->had_an_ipo;
}
usize company::Company::get_buy_vol() const {
return this->buy_vol;
}
usize company::Company::get_sel_vol() const {
return this->sell_vol;
}
void company::Company::dump_json(Rc<CliHelper> cli) {
cli->os() << "{ symbol: \"" << this->get_symbol() << "\" ,prices: [";
for (usize ii = 0; ii < this->price_records.size(); ii++) {
auto pr = this->price_records.at(ii);
cli->os() << "{ ask:" << pr->ask << ", bid: " << pr->bid << "}";
if (ii != this->price_records.size() - 1) {
cli->print(",");
}
}
cli->print("]}");
}
usize company::Company::dividend_per_share() const {
return (usize)std::floor(this->dividend_percentage * this->get_stock_price());
}
| 26.949153 | 114 | 0.676887 | [
"vector"
] |
47bd3e6707f006f93caa54686fc382f1421be25b | 4,348 | cc | C++ | ecs/src/model/DescribeManagedInstancesRequest.cc | aliyun/aliyun-openapi-cpp-sdk | 0cf5861ece17dfb0bb251f13bf3fbdb39c0c6e36 | [
"Apache-2.0"
] | 89 | 2018-02-02T03:54:39.000Z | 2021-12-13T01:32:55.000Z | ecs/src/model/DescribeManagedInstancesRequest.cc | aliyun/aliyun-openapi-cpp-sdk | 0cf5861ece17dfb0bb251f13bf3fbdb39c0c6e36 | [
"Apache-2.0"
] | 89 | 2018-03-14T07:44:54.000Z | 2021-11-26T07:43:25.000Z | ecs/src/model/DescribeManagedInstancesRequest.cc | aliyun/aliyun-openapi-cpp-sdk | 0cf5861ece17dfb0bb251f13bf3fbdb39c0c6e36 | [
"Apache-2.0"
] | 69 | 2018-01-22T09:45:52.000Z | 2022-03-28T07:58:38.000Z | /*
* Copyright 2009-2017 Alibaba Cloud 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 <alibabacloud/ecs/model/DescribeManagedInstancesRequest.h>
using AlibabaCloud::Ecs::Model::DescribeManagedInstancesRequest;
DescribeManagedInstancesRequest::DescribeManagedInstancesRequest()
: RpcServiceRequest("ecs", "2014-05-26", "DescribeManagedInstances") {
setMethod(HttpRequest::Method::Post);
}
DescribeManagedInstancesRequest::~DescribeManagedInstancesRequest() {}
long DescribeManagedInstancesRequest::getResourceOwnerId() const {
return resourceOwnerId_;
}
void DescribeManagedInstancesRequest::setResourceOwnerId(long resourceOwnerId) {
resourceOwnerId_ = resourceOwnerId;
setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
}
long DescribeManagedInstancesRequest::getPageNumber() const {
return pageNumber_;
}
void DescribeManagedInstancesRequest::setPageNumber(long pageNumber) {
pageNumber_ = pageNumber;
setParameter(std::string("PageNumber"), std::to_string(pageNumber));
}
std::string DescribeManagedInstancesRequest::getRegionId() const {
return regionId_;
}
void DescribeManagedInstancesRequest::setRegionId(const std::string ®ionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
long DescribeManagedInstancesRequest::getPageSize() const {
return pageSize_;
}
void DescribeManagedInstancesRequest::setPageSize(long pageSize) {
pageSize_ = pageSize;
setParameter(std::string("PageSize"), std::to_string(pageSize));
}
std::string DescribeManagedInstancesRequest::getResourceOwnerAccount() const {
return resourceOwnerAccount_;
}
void DescribeManagedInstancesRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
}
std::string DescribeManagedInstancesRequest::getOwnerAccount() const {
return ownerAccount_;
}
void DescribeManagedInstancesRequest::setOwnerAccount(const std::string &ownerAccount) {
ownerAccount_ = ownerAccount;
setParameter(std::string("OwnerAccount"), ownerAccount);
}
std::string DescribeManagedInstancesRequest::getOsType() const {
return osType_;
}
void DescribeManagedInstancesRequest::setOsType(const std::string &osType) {
osType_ = osType;
setParameter(std::string("OsType"), osType);
}
long DescribeManagedInstancesRequest::getOwnerId() const {
return ownerId_;
}
void DescribeManagedInstancesRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
std::string DescribeManagedInstancesRequest::getInstanceName() const {
return instanceName_;
}
void DescribeManagedInstancesRequest::setInstanceName(const std::string &instanceName) {
instanceName_ = instanceName;
setParameter(std::string("InstanceName"), instanceName);
}
std::vector<std::string> DescribeManagedInstancesRequest::getInstanceId() const {
return instanceId_;
}
void DescribeManagedInstancesRequest::setInstanceId(const std::vector<std::string> &instanceId) {
instanceId_ = instanceId;
}
std::string DescribeManagedInstancesRequest::getInstanceIp() const {
return instanceIp_;
}
void DescribeManagedInstancesRequest::setInstanceIp(const std::string &instanceIp) {
instanceIp_ = instanceIp;
setParameter(std::string("InstanceIp"), instanceIp);
}
std::string DescribeManagedInstancesRequest::getActivationId() const {
return activationId_;
}
void DescribeManagedInstancesRequest::setActivationId(const std::string &activationId) {
activationId_ = activationId;
setParameter(std::string("ActivationId"), activationId);
}
| 32.207407 | 105 | 0.767249 | [
"vector",
"model"
] |
47c1f3b7930144c142d26c3010276ea81508836a | 2,188 | hpp | C++ | src/io/iter_mem_buffer-inl.hpp | zhenglab/cxxnet | fef5cb06338a832d817ebd7ea636db708b49d35c | [
"Apache-2.0"
] | 1 | 2018-12-19T09:11:48.000Z | 2018-12-19T09:11:48.000Z | src/io/iter_mem_buffer-inl.hpp | toooocode/cxxnet | fef5cb06338a832d817ebd7ea636db708b49d35c | [
"Apache-2.0"
] | null | null | null | src/io/iter_mem_buffer-inl.hpp | toooocode/cxxnet | fef5cb06338a832d817ebd7ea636db708b49d35c | [
"Apache-2.0"
] | null | null | null | #ifndef CXXNET_ITER_MEM_BUFFER_INL_HPP_
#define CXXNET_ITER_MEM_BUFFER_INL_HPP_
/*!
* \file iter_mem_buffer-inl.hpp
* \brief iterator that gets limited number of batch into memory,
* and only return these data
* \author Tianqi Chen
*/
#include <mshadow/tensor.h>
#include "./data.h"
#include "../utils/utils.h"
#include "../utils/io.h"
namespace cxxnet {
/*! \brief iterator that gets limitted number of batch into memory */
class DenseBufferIterator : public IIterator<DataBatch> {
public:
DenseBufferIterator(IIterator<DataBatch> *base)
: base_(base) {
max_nbatch_ = 100;
data_index_ = 0;
silent_ = 0;
}
virtual void SetParam(const char *name, const char *val) {
base_->SetParam(name, val);
if (!strcmp(name, "max_nbatch")) {
max_nbatch_ = static_cast<size_t>(atol(val));
}
if (!strcmp(name, "silent")) silent_ = atoi(val);
}
virtual void Init(void) {
base_->Init();
while (base_->Next()) {
const DataBatch &batch = base_->Value();
utils::Assert(batch.label.dptr_ != NULL, "need dense");
DataBatch v;
v.AllocSpaceDense(batch.data.shape_, batch.batch_size, batch.label.size(1));
v.CopyFromDense(batch);
buffer_.push_back(v);
if (buffer_.size() >= max_nbatch_) break;
}
if (silent_ == 0) {
printf("DenseBufferIterator: load %d batches\n",
static_cast<int>(buffer_.size()));
}
}
virtual void BeforeFirst(void) {
data_index_ = 0;
}
virtual bool Next(void) {
if (data_index_ < buffer_.size()) {
data_index_ += 1;
return true;
} else {
return false;
}
}
virtual const DataBatch &Value(void) const {
utils::Assert(data_index_ > 0,
"Iterator.Value: at beginning of iterator");
return buffer_[data_index_ - 1];
}
private:
/*! \brief silent */
int silent_;
/*! \brief maximum number of batch in buffer */
size_t max_nbatch_;
/*! \brief data index */
size_t data_index_;
/*! \brief base iterator */
IIterator<DataBatch> *base_;
/*! \brief data content */
std::vector<DataBatch> buffer_;
};
} // namespace cxxnet
#endif // CXXNET_ITER_BATCH_PROC_INL_HPP_
| 28.051282 | 82 | 0.643053 | [
"vector"
] |
47cbbb01a4820b0ee6c72a0c597c7a49f2294265 | 19,310 | cpp | C++ | node.cpp | orkzking/openxfem | 66889ea05ec108332ab8566b510124ee1a3f334d | [
"FTL"
] | null | null | null | node.cpp | orkzking/openxfem | 66889ea05ec108332ab8566b510124ee1a3f334d | [
"FTL"
] | null | null | null | node.cpp | orkzking/openxfem | 66889ea05ec108332ab8566b510124ee1a3f334d | [
"FTL"
] | null | null | null | // file NODE.CPP
#include "node.h"
#include "dof.h"
#include "nodload.h"
#include "timestep.h"
#include "linsyst.h"
#include "flotarry.h"
#include "intarray.h"
#include "enrichmentitem.h"
#include "element.h"
#include "tri_u.h"
#include "geometryentity.h"
#include "geometry_2D.h"
#include "functors.h"
#include "crackinterior.h"
#include "cracktip.h"
#include "crackjunction.h"
#include "materialinterface.h"
#include <stdlib.h>
#include <list>
#include <map>
#include <vector>
#include <algorithm>
using namespace std;
Node :: Node (int n, Domain* aDomain)
: FEMComponent (n,aDomain)
// Constructor. Creates a node with number n, belonging to aDomain.
{
numberOfDofs = 0 ;
coordinates = NULL ;
dofArray = NULL ;
loadArray = NULL ;
locationArray = NULL ;
isEnriched = 0 ;
enrichmentItemListOfNode = NULL ;
isUpdated = false ;
}
Node :: ~Node()
// Destructor.
{
delete coordinates ;
size_t i = numberOfDofs ;
if (dofArray)
{
while (i--)
delete dofArray[i] ;
delete dofArray ;
}
delete loadArray ;
delete locationArray ;
delete enrichmentItemListOfNode ;
}
void Node :: assembleYourLoadsAt (TimeStep* stepN)
// Forms at stepN the vector of the concentrated loads of the receiver ;
// then, if it exists, assembles it to the system's right-hand side.
{
LinearSystem *system ;
FloatArray *loadVector,*rhs ;
IntArray *loc ;
# ifdef VERBOSE
printf ("assembling loads of node %d\n",number) ;
# endif
loadVector = this -> ComputeLoadVectorAt(stepN) ;
if (loadVector)
{
system = (LinearSystem*) (domain->giveNLSolver()->giveLinearSystem()) ;
rhs = system -> giveRhs() ;
loc = this -> giveLocationArray() ;
rhs -> assemble(loadVector,loc) ;
delete loadVector ;
}
}
FloatArray* Node :: ComputeLoadVectorAt (TimeStep* stepN)
// Computes the vector of the nodal loads of the receiver.
{
int i,n,nLoads ;
NodalLoad *loadN ;
FloatArray *answer,*contribution ;
if (this -> giveLoadArray() -> isEmpty())
return NULL ;
else
{
answer = new FloatArray(0) ;
nLoads = loadArray->giveSize() ; // the node may be subjected
for (i = 1 ; i <= nLoads ; i++) // to more than one load
{
n = loadArray -> at(i) ;
loadN = (NodalLoad*) domain->giveLoad(n) ;
contribution = loadN -> ComputeValueAt(stepN) ; // can be NULL
answer -> add(contribution) ;
delete contribution ;
}
if (answer->giveSize())
return answer ;
else
{
delete answer ;
return NULL ;
}
}
}
void Node :: getCoordinates ()
// Get from the data file all of the coordinates of the receiver.
{
int numberOfCoordinates = this->readInteger("coord") ;
coordinates = new FloatArray(numberOfCoordinates) ;
for (size_t i = 1 ; i <= numberOfCoordinates ; i++)
coordinates->at(i) = this->read("coord",i+1) ;
}
double Node :: giveCoordinate (int i)
// Returns the i-th coordinate of the receiver.
{
if (! coordinates)
this -> getCoordinates() ;
return coordinates->at(i) ;
}
FloatArray* Node :: giveCoordinates()
{
if (! coordinates)
this->getCoordinates();
return coordinates ;
}
Dof* Node :: giveDof (int i)
// Returns the i-th degree of freedom of the receiver. Creates the array
// containing the dofs of the receiver, if such array does not exist yet.
{
if (! dofArray)
{
dofArray = new Dof* [this->giveNumberOfDofs()] ;
for (size_t j = 0 ; j < numberOfDofs ; j++)
dofArray[j] = new Dof(j+1,this) ;
}
return dofArray[i-1] ;
}
IntArray* Node :: giveLoadArray ()
// Returns the list containing the number of every nodal loads that act on
// the receiver. If this list does not exist yet, constructs it. This list
// is not to be confused with the load vector.
{
int nLoads ;
if (! loadArray) // the list does not exist yet
{
nLoads = this->readIfHas("loads") ;
loadArray = new IntArray(nLoads) ;
for (size_t i = 1 ; i <= nLoads ; i++)
loadArray->at(i) = this->readInteger("loads",i+1) ;
}
return loadArray ;
}
int Node :: computeNumberOfDofs ()
// ********************************
// Computes the number of degrees of freedom of the receiver.
// Need to include the additional Dofs of enriched nodes (XFEM implementation)
// NVP 2005
{
numberOfDofs = this->readInteger("nDofs") ; // real Dofs ( standard ones )
// if the receiver is a non-enriched node, stop. Otherwise it has
// ( NSD * number_of_enrichmentfunctions ) additional Dofs for each enrichment item.
if ( isEnriched == 0 )
return numberOfDofs ;
size_t enrichedDofs = 0 ;
list<EnrichmentItem*>* enrItemList = this->giveEnrItemListOfNode();
list<EnrichmentItem*>::iterator iter ;
for(iter = enrItemList->begin(); iter != enrItemList->end(); iter++)
{
vector<EnrichmentFunction*>* enrFnVector = (*iter)->giveEnrFuncVector();
enrichedDofs += 2 * enrFnVector->size();
}
numberOfDofs += enrichedDofs ;
return numberOfDofs ;
}
size_t Node :: giveNumberOfTrueDofs ()
// *************************************
// True Dofs are displacement Dofs, just read from input file
{
size_t nDofs = this->readInteger("nDofs") ;
return nDofs ;
}
int Node :: giveNumberOfDofs ()
// *****************************
// Returns the number of degrees of freedom of the receiver.
{
if (numberOfDofs == 0)
this->computeNumberOfDofs() ;
else if(isUpdated)
{
this->computeNumberOfDofs() ; // recompute number of Dofs !!!
}
return numberOfDofs ;
}
void Node :: instanciateYourself ()
// Gets from the data file all the data of the receiver.
{
int i ;
# ifdef VERBOSE
printf ("instanciating node %d\n",number) ;
# endif
this -> getCoordinates() ;
this -> giveLocationArray () ;
this -> giveLoadArray() ;
numberOfDofs = this -> readInteger("nDofs") ;
for (i=1 ; i<=numberOfDofs ; i++)
this -> giveDof(i) -> hasBc() ;
}
void Node :: printOutputAt (TimeStep* stepN, FILE* disFile, FILE* s00File)
{
# ifdef VERBOSE
printf ("node %d printing output\n",number) ;
# endif
for (size_t i= 1 ; i <= numberOfDofs ; i++)
this -> giveDof(i) -> printOutputAt(stepN, disFile) ;
this->printBinaryResults(stepN, s00File);
}
void Node :: printBinaryResults (TimeStep* stepN, FILE* s00File)
// Prints the strains and stresses on the data file.
// Modified by NVP ( for XFEM ), additional Dofs !!!
{
float a[3]; // Why 3 ??? Is this a limitation of the code?
if (s00File != NULL) {
//to put it at the end of the file
int pos = fseek(s00File, 0L, SEEK_END);
//writing
this->getBinaryRecord(stepN, a);
fwrite(a, sizeof(a), 1, s00File);
}
}
void Node :: getBinaryRecord (TimeStep* stepN, float* a)
// ******************************************************
// Modified by NVP ( for XFEM ), additional Dofs !!!
{
size_t numberOfDofs = this->readInteger("nDofs") ; // just need "actual" displacement field
for (size_t i = 1 ; i <= numberOfDofs ; i++) {
a[i-1] = (float)(this -> giveDof(i) -> giveUnknown('d',stepN));
}
//water-pressure = 0
a[2] = (float)0;
}
void Node :: printYourself ()
// Prints the receiver on screen.
{
double x = this->giveCoordinate(1) ;
double y = this->giveCoordinate(2) ;
printf ("Node %d coord : x %f y %f\n",number,x,y) ;
for ( size_t i = 0 ; i < numberOfDofs ; i++) {
if (dofArray[i])
dofArray[i] -> printYourself() ;
else
printf ("dof %d is nil \n",i+1) ;
}
if (locationArray)
locationArray->printYourself() ;
else
printf ("locationArray = nil \n") ;
if (loadArray)
loadArray->printYourself() ;
else
printf ("loadArray = nil \n") ;
printf ("\n") ;
}
void Node :: updateYourself()
// ***************************
// Updates the receiver at end of step.
// Modification made by NVP for XFEM. 2005-09-05
{
# ifdef VERBOSE
printf ("updating node %d\n",number) ;
# endif
if(this->domain->isXFEMorFEM() == false) // FEM problems
{
for (size_t i = 0 ; i < numberOfDofs ; i++)
this -> giveDof(i+1) -> updateYourself() ;
}
else // XFEM problems
{
for (size_t i = 0 ; i < numberOfDofs ; i++)
delete dofArray[i] ;
delete dofArray ;
dofArray = NULL ;
//numberOfDofs = 0 ;
delete locationArray ;
locationArray = NULL ;
delete loadArray ;
loadArray = NULL ;
}
}
IntArray* Node :: giveLocationArray ()
// ************************************
// Returns the location array of the receiver.
// The location array contains the equation number of
// every degree of freedom of the receiver.
{
if (!locationArray)
this -> computeLocationArray() ;
return locationArray ;
}
IntArray* Node :: computeLocationArray()
// **************************************
// compute the location array of the receiver.
// Having form : u = [u1 u2 a1 a2 ] where u1,u2 are displacement DOFs
// and a1,a2 are enriched DOFs( assuming that this node is enriched by 1 function)
{
locationArray = new IntArray(this->giveNumberOfDofs()) ;
for (size_t i = 1 ; i <= numberOfDofs ; i++)
locationArray->at(i) = this->giveDof(i)->giveEquationNumber() ;
/*// DEBUG ...
if(isEnriched)
{
std::cout << " location array of node " << this->giveNumber()<< endl ;
for(size_t i = 0 ; i < locationArray->giveSize() ; i++)
std::cout << (*locationArray)[i] << " " ;
std::cout << std::endl ;
}
// ----------------------------------------------------------------------*/
return locationArray ;
}
IntArray* Node :: giveStandardLocationArray()
// *******************************************
// return the location of standard DOFs, i.e., displacement DOFs
{
if(isEnriched == 0) // standard nodes ( non-enriched)
return this->giveLocationArray();
IntArray *temp = this->giveLocationArray();
IntArray *ret = new IntArray(2) ;
ret->at(1) = temp->at(1);
ret->at(2) = temp->at(2);
return ret;
}
IntArray* Node :: giveEnrichedLocationArray ()
// ********************************************
{
// standard nodes ( non-enriched)
if(isEnriched == 0)
return NULL ;
// enriched nodes
IntArray *temp = this->giveLocationArray();
IntArray *ret = new IntArray(temp->giveSize()-2) ;
for(size_t i = 1 ; i <= ret->giveSize() ; i++)
{
ret->at(i) = temp->at(i+2);
}
return ret;
}
list<EnrichmentItem*>* Node::giveEnrItemListOfNode()
// *************************************************
// before give the list of enrichment items, make sure there
// is no conflicts in this !
{
//this->resolveConflictsInEnrichment();
return enrichmentItemListOfNode;
}
void Node :: isEnrichedWith(EnrichmentItem* enrItem)
// *************************************************
// If node is enriched with enrichment item enrItem, then insert
// enrItem into the list of enrichment items
// also sets member isEnriched equals to 1.
{
if(enrichmentItemListOfNode == NULL)
enrichmentItemListOfNode = new std::list<EnrichmentItem*>;
if( find(enrichmentItemListOfNode->begin(),enrichmentItemListOfNode->end(),enrItem)
== enrichmentItemListOfNode->end())
enrichmentItemListOfNode->push_back(enrItem);
isEnriched = 1 ; // this node is now enriched
this->domain->setEnrichedNodesList(this);
}
void Node :: addNewEnrichmentItem(EnrichmentItem *enrItem)
{
enrichmentItemListOfNode->push_back(enrItem);
}
void Node :: deleteEnrichmentItem(EnrichmentItem *enrItem)
{
enrichmentItemListOfNode->remove(enrItem);
}
void Node :: resolveConflictsInEnrichment()
// ****************************************
// check if this list contains both a CrackTip and a CrackInterior
// then remove the CrackInterior from the list.
// functor IsType<CrackTip,EnrichmentItem>() defined generically in file "functors.h"
{
list<EnrichmentItem*> ::iterator iter1,iter2;
iter1=find_if(enrichmentItemListOfNode->begin(),enrichmentItemListOfNode->end(),IsType<CrackTip,EnrichmentItem>());
iter2=find_if(enrichmentItemListOfNode->begin(),enrichmentItemListOfNode->end(),IsType<CrackInterior,EnrichmentItem>());
if (iter1 != enrichmentItemListOfNode->end() && iter2 != enrichmentItemListOfNode->end())
enrichmentItemListOfNode->remove(*iter2);
/*
// debug: check the list after being removed
// ----------------------------------------------------------------------------------
list<EnrichmentItem*> ::iterator it;
for(it = enrichmentItemListOfNode->begin();it!=enrichmentItemListOfNode->end();it++)
{
(*it)->printYourSelf();
}
// ----------------------------------------------------------------------------------
*/
}
void Node :: resolveConflictsInEnrichment2()
// *****************************************
{
list<EnrichmentItem*> ::iterator it1,it2;
it1 = find_if(enrichmentItemListOfNode->begin(),enrichmentItemListOfNode->end(),IsType<CrackInterior,EnrichmentItem>());
it2 = find_if(enrichmentItemListOfNode->begin(),enrichmentItemListOfNode->end(),IsType<MaterialInterface,EnrichmentItem>());
if (it1 != enrichmentItemListOfNode->end() && it2 != enrichmentItemListOfNode->end())
enrichmentItemListOfNode->remove(*it2);
}
void Node :: resolveLinearDependency(EnrichmentItem *enrItem)
// **********************************************************
// Using the area inclusion criterion to remove Heaviside enriched nodes
// NVP 2005-06-04
{
// This tolerance is not constant, but depends on the mesh size h !!!
// how to implement this?
double eps = 0.0001 ;
// get the support of this Node from the Domain
map<Node*,vector<Element*> > nodeElemMap = this->domain->giveNodalSupports();
vector<Element*> mySupport = nodeElemMap[this] ;
double A = 0.0 ; // A is the area of the support
double A1 = 0.0 ; // the area above the CrackInterior
double temp = 0.0 ;
vector<Element*>* elemList = enrItem->giveElementsInteractWithMe();
vector<Element*> :: iterator iter ;
// Loop on elements in nodal support, say e. If e intersects with enrItem, then
// compute the area of e above enrItem by e->giveAreaAboveEnrItem() ;
for(size_t i = 0 ; i < mySupport.size() ; i++)
{
A += mySupport[i]->area();
iter = find(elemList->begin(),elemList->end(),mySupport[i]);
if (iter != elemList->end())
{
A1 += mySupport[i]->computeAreaAboveEnrItem(enrItem); // area of part of element above the enrItem
temp += mySupport[i]->area() ; // area of elements in nodal support which are split by the crack
}
}
GeometryEntity *geoOfEnrItem = enrItem->giveMyGeo() ;
Mu::Point *p = this->makePoint() ;
int check = geoOfEnrItem->givePositionComparedTo(p);
if(check == 1) // node is above the crack
A1 += A - temp ;
double A2 = A - A1 ; // the area below the Crack
// finally the area inclusion criteria is applied
if ((A1/A < eps) || (A2/A < eps))
{
enrichmentItemListOfNode->remove(enrItem); //do not enrich this node with H(x) any more
// after being removed enrichment, if enrichmentItemListOfNode does not contain any
// enrichment item, then this node is a classical node !!! NVP 2005-07-12
if(enrichmentItemListOfNode->size() == 0 )
{
isEnriched = 0 ;
// update the enriched-nodes-list of DOMAIN !!!
this->domain->removeNodeFromEnrichedNodesList(this);
}
}
delete p ;
/*
// ------------------------- DEBUG --------------------------------------------
std::cout<< " checking node " << number << " " << std::endl ;
std::cout<< " The first ratio : " << A1/A << std::endl;
std::cout<< " The second ratio : " << A2/A << std::endl;
// ----------------------------------------------------------------------------
*/
}
bool Node :: isTipEnriched()
//**************************
// return true if the receiver enriched by the asymptotic functions
// just for plot :)
{
if( isEnriched == 0 )
return false ;
list<EnrichmentItem*> ::iterator it;
it =
find_if(enrichmentItemListOfNode->begin(),enrichmentItemListOfNode->end(),IsType<CrackTip,EnrichmentItem>());
return (it != enrichmentItemListOfNode->end()) ? true : false ;
}
bool Node :: isStepEnriched()
//***************************
// return true if the receiver enriched by the step function
// just for plot :)
{
if( isEnriched == 0 )
return false ;
list<EnrichmentItem*> ::iterator it;
it =
find_if(enrichmentItemListOfNode->begin(),enrichmentItemListOfNode->end(),IsType<CrackInterior,EnrichmentItem>());
return (it != enrichmentItemListOfNode->end()) ? true : false ;
}
bool Node :: isJunctionEnriched()
//*******************************
// return true if the receiver enriched by the junction function
// just for plot :)
{
if( isEnriched == 0 )
return false ;
list<EnrichmentItem*> ::iterator it;
it =
find_if(enrichmentItemListOfNode->begin(),enrichmentItemListOfNode->end(),IsType<CrackJunction,EnrichmentItem>());
return (it != enrichmentItemListOfNode->end()) ? true : false ;
}
bool Node :: isInterfaceEnriched()
//********************************
// return true if the receiver enriched by the material interface
// just for plot :)
{
if( isEnriched == 0 )
return false ;
list<EnrichmentItem*> ::iterator it;
it =
find_if(enrichmentItemListOfNode->begin(),enrichmentItemListOfNode->end(),IsType<MaterialInterface,EnrichmentItem>());
return (it != enrichmentItemListOfNode->end()) ? true : false ;
}
Mu::Point* Node::makePoint()
//**************************
{
double x1 = this->giveCoordinate(1);
double y1 = this->giveCoordinate(2);
Mu::Point *result = new Mu::Point(x1,y1) ;
return result ;
}
void Node :: printNodalSupport()
//******************************
// Only for debugging
{
std::map<Node*,std::vector<Element*> > nodeElemMap = this->domain->giveNodalSupports();
std::vector<Element*> mySupport = nodeElemMap[this] ;
std::cout << " Support of node " << number << " : " ;
for(size_t i = 0 ; i < mySupport.size() ; i++)
std::cout << mySupport[i]->giveNumber() << " " ;
std::cout << std::endl;
}
void Node :: printEnrichedNode()
//******************************
// only for debugging
{
if(isEnriched)
{
std::cout<< " Node " << number << " is enriched by: " << endl ;
list<EnrichmentItem*> ::iterator it;
for(it = enrichmentItemListOfNode->begin() ; it != enrichmentItemListOfNode->end() ; it++)
(*it)->printYourSelf();
std::cout << std::endl ;
std::cout<< " Number of Dofs " << this->giveNumberOfDofs() << std::endl ;
}
}
void Node::setLevelSets(EnrichmentItem* enrItem, double ls)
{
pair<EnrichmentItem*,double> a_pair;
a_pair = make_pair(enrItem,ls);
levelSet.insert(a_pair);
}
double Node::giveLevelSet(EnrichmentItem *enrItem)
{
return levelSet[enrItem];
} | 28.735119 | 127 | 0.598654 | [
"mesh",
"vector"
] |
47d104469de3c861e393da7a0964a19f015bde01 | 1,817 | cpp | C++ | ModSource/breakingpoint_server/config.cpp | nrailuj/breakingpointmod | e102e106b849ca78deb3cb299f3ae18c91c3bfe9 | [
"Naumen",
"Condor-1.1",
"MS-PL"
] | 70 | 2017-06-23T21:25:05.000Z | 2022-03-27T02:39:33.000Z | ModSource/breakingpoint_server/config.cpp | nrailuj/breakingpointmod | e102e106b849ca78deb3cb299f3ae18c91c3bfe9 | [
"Naumen",
"Condor-1.1",
"MS-PL"
] | 84 | 2017-08-26T22:06:28.000Z | 2021-09-09T15:32:56.000Z | ModSource/breakingpoint_server/config.cpp | nrailuj/breakingpointmod | e102e106b849ca78deb3cb299f3ae18c91c3bfe9 | [
"Naumen",
"Condor-1.1",
"MS-PL"
] | 71 | 2017-06-24T01:10:42.000Z | 2022-03-18T23:02:00.000Z | /*
Breaking Point Mod for Arma 3
Released under Arma Public Share Like Licence (APL-SA)
https://www.bistudio.com/community/licenses/arma-public-license-share-alike
Alderon Games Pty Ltd
*/
#define VSoft 0
#define VArmor 1
#define VAir 2
#define private 0
#define protected 1
#define public 2
#define ReadAndWrite 0
#define ReadAndCreate 1
#define ReadOnly 2
#define ReadOnlyVerified 3
class CfgPatches {
class breakingpoint_server {
units[] = {};
weapons[] = {};
requiredVersion = 0.1;
requiredAddons[] = {"breakingpoint_code"};
};
};
#include "CfgFunctions.hpp"
#include "CfgHelicrash.hpp"
#include "CfgCargocrash.hpp"
#include "CfgVehicleSpawns.hpp"
#include "CfgTime.hpp"
class CfgBreakingPointServerSettings
{
class StorageObjects
{
storageLimit = 7; // Storage object Limit
immortalHavens = 0; // make havens immortal 0 = Off 1 = On
};
class CustomLoot
{
customLootSetting = 1; // 0 = SC off 1 = SC on (default) 2 = ghosthotel weapon insted of SC
};
class MixedGroupPointsGain
{
disableMixedGroupPointsGain = 1; //turns point gain for mixed group off, point lose still on 0 = off , 1 = on
};
class groupLeaveTimer
{
groupLeaveTimeOut = 600; //time in seconds between leaving group and joining new/old one if 0 => Off
};
class applyMedicine
{
medicalCooldown = 900; //time in seconds for point gain on medical assistance
};
class BreakingPointExt
{
//Do not change this number unless you really know what you are doing!!!
version = "0.002";
};
};
class CfgDifficultyPresets
{
class Regular
{
class Options
{
waypoints=0; // Waypoints Regular(3PP) (0 = never, 1 = fade out, 2 = always)
};
};
class Veteran
{
class Options
{
waypoints=0; // Waypoints Veteran(1PP) (0 = never, 1 = fade out, 2 = always)
};
};
};
| 21.127907 | 111 | 0.694551 | [
"object"
] |
47d436928b16ee0090af3896ba221423a3246d3a | 1,584 | hpp | C++ | modules/core/settings/include/nt2/core/settings/forward/storage_scheme.hpp | pbrunet/nt2 | 2aeca0f6a315725b335efd5d9dc95d72e10a7fb7 | [
"BSL-1.0"
] | 2 | 2016-09-14T00:23:53.000Z | 2018-01-14T12:51:18.000Z | modules/core/settings/include/nt2/core/settings/forward/storage_scheme.hpp | pbrunet/nt2 | 2aeca0f6a315725b335efd5d9dc95d72e10a7fb7 | [
"BSL-1.0"
] | null | null | null | modules/core/settings/include/nt2/core/settings/forward/storage_scheme.hpp | pbrunet/nt2 | 2aeca0f6a315725b335efd5d9dc95d72e10a7fb7 | [
"BSL-1.0"
] | null | null | null | //==============================================================================
// Copyright 2003 - 2011 LASMEA UMR 6602 CNRS/Univ. Clermont II
// Copyright 2009 - 2011 LRI UMR 8623 CNRS/Univ Paris Sud XI
//
// Distributed under the Boost Software License, Version 1.0.
// See accompanying file LICENSE.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt
//==============================================================================
#ifndef NT2_CORE_SETTINGS_FORWARD_STORAGE_SCHEME_HPP_INCLUDED
#define NT2_CORE_SETTINGS_FORWARD_STORAGE_SCHEME_HPP_INCLUDED
namespace nt2
{
//============================================================================
/*! The default scheme for storing containers is the obvious contiguous,
* dense storage scheme.
**/
//============================================================================
struct conventional_;
//============================================================================
/*! Packed storage infers from the container Shape which elements to store
* and which to regenerate. Usually, packed storage reduces memory usage.
**/
//============================================================================
struct packed_;
namespace tag
{
//==========================================================================
/*!
* Option tag for storage_scheme options
**/
//==========================================================================
struct storage_scheme_ {};
}
}
#endif
| 36.837209 | 80 | 0.400253 | [
"shape"
] |
47d74e8da746dfcb6c24e0b9d4ba0dc641471b33 | 705,629 | cpp | C++ | cisco-nx-os/ydk/models/cisco_nx_os/fragmented/Cisco_NX_OS_device_25.cpp | CiscoDevNet/ydk-cpp | ef7d75970f2ef1154100e0f7b0a2ee823609b481 | [
"ECL-2.0",
"Apache-2.0"
] | 17 | 2016-12-02T05:45:49.000Z | 2022-02-10T19:32:54.000Z | cisco-nx-os/ydk/models/cisco_nx_os/fragmented/Cisco_NX_OS_device_25.cpp | CiscoDevNet/ydk-cpp | ef7d75970f2ef1154100e0f7b0a2ee823609b481 | [
"ECL-2.0",
"Apache-2.0"
] | 2 | 2017-03-27T15:22:38.000Z | 2019-11-05T08:30:16.000Z | cisco-nx-os/ydk/models/cisco_nx_os/fragmented/Cisco_NX_OS_device_25.cpp | CiscoDevNet/ydk-cpp | ef7d75970f2ef1154100e0f7b0a2ee823609b481 | [
"ECL-2.0",
"Apache-2.0"
] | 11 | 2016-12-02T05:45:52.000Z | 2019-11-07T08:28:17.000Z |
#include <sstream>
#include <iostream>
#include <ydk/entity_util.hpp>
#include "bundle_info.hpp"
#include "generated_entity_lookup.hpp"
#include "Cisco_NX_OS_device_25.hpp"
#include "Cisco_NX_OS_device_26.hpp"
using namespace ydk;
namespace cisco_nx_os {
namespace Cisco_NX_OS_device {
System::AclItems::Ipv4Items::PolicyItems::EgressItems::VtyItems::AclItems_::AclItems_()
:
name{YType::str, "name"},
configstatus{YType::uint32, "configStatus"},
upid{YType::uint32, "upid"}
{
yang_name = "acl-items"; yang_parent_name = "vty-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::AclItems::Ipv4Items::PolicyItems::EgressItems::VtyItems::AclItems_::~AclItems_()
{
}
bool System::AclItems::Ipv4Items::PolicyItems::EgressItems::VtyItems::AclItems_::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| configstatus.is_set
|| upid.is_set;
}
bool System::AclItems::Ipv4Items::PolicyItems::EgressItems::VtyItems::AclItems_::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(configstatus.yfilter)
|| ydk::is_set(upid.yfilter);
}
std::string System::AclItems::Ipv4Items::PolicyItems::EgressItems::VtyItems::AclItems_::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/acl-items/ipv4-items/policy-items/egress-items/vty-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::AclItems::Ipv4Items::PolicyItems::EgressItems::VtyItems::AclItems_::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "acl-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv4Items::PolicyItems::EgressItems::VtyItems::AclItems_::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (configstatus.is_set || is_set(configstatus.yfilter)) leaf_name_data.push_back(configstatus.get_name_leafdata());
if (upid.is_set || is_set(upid.yfilter)) leaf_name_data.push_back(upid.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv4Items::PolicyItems::EgressItems::VtyItems::AclItems_::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv4Items::PolicyItems::EgressItems::VtyItems::AclItems_::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AclItems::Ipv4Items::PolicyItems::EgressItems::VtyItems::AclItems_::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "configStatus")
{
configstatus = value;
configstatus.value_namespace = name_space;
configstatus.value_namespace_prefix = name_space_prefix;
}
if(value_path == "upid")
{
upid = value;
upid.value_namespace = name_space;
upid.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv4Items::PolicyItems::EgressItems::VtyItems::AclItems_::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "configStatus")
{
configstatus.yfilter = yfilter;
}
if(value_path == "upid")
{
upid.yfilter = yfilter;
}
}
bool System::AclItems::Ipv4Items::PolicyItems::EgressItems::VtyItems::AclItems_::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "name" || name == "configStatus" || name == "upid")
return true;
return false;
}
System::AclItems::Ipv4Items::NameItems::NameItems()
:
acl_list(this, {"name"})
{
yang_name = "name-items"; yang_parent_name = "ipv4-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::AclItems::Ipv4Items::NameItems::~NameItems()
{
}
bool System::AclItems::Ipv4Items::NameItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<acl_list.len(); index++)
{
if(acl_list[index]->has_data())
return true;
}
return false;
}
bool System::AclItems::Ipv4Items::NameItems::has_operation() const
{
for (std::size_t index=0; index<acl_list.len(); index++)
{
if(acl_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AclItems::Ipv4Items::NameItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/acl-items/ipv4-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::AclItems::Ipv4Items::NameItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "name-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv4Items::NameItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv4Items::NameItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "ACL-list")
{
auto ent_ = std::make_shared<System::AclItems::Ipv4Items::NameItems::ACLList>();
ent_->parent = this;
acl_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv4Items::NameItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : acl_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AclItems::Ipv4Items::NameItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AclItems::Ipv4Items::NameItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AclItems::Ipv4Items::NameItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "ACL-list")
return true;
return false;
}
System::AclItems::Ipv4Items::NameItems::ACLList::ACLList()
:
name{YType::str, "name"},
upid{YType::uint32, "upid"},
peracestatistics{YType::uint8, "perACEStatistics"},
configstatus{YType::uint32, "configStatus"}
,
reseq_items(std::make_shared<System::AclItems::Ipv4Items::NameItems::ACLList::ReseqItems>())
, seq_items(std::make_shared<System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems>())
{
reseq_items->parent = this;
seq_items->parent = this;
yang_name = "ACL-list"; yang_parent_name = "name-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::AclItems::Ipv4Items::NameItems::ACLList::~ACLList()
{
}
bool System::AclItems::Ipv4Items::NameItems::ACLList::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| upid.is_set
|| peracestatistics.is_set
|| configstatus.is_set
|| (reseq_items != nullptr && reseq_items->has_data())
|| (seq_items != nullptr && seq_items->has_data());
}
bool System::AclItems::Ipv4Items::NameItems::ACLList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(upid.yfilter)
|| ydk::is_set(peracestatistics.yfilter)
|| ydk::is_set(configstatus.yfilter)
|| (reseq_items != nullptr && reseq_items->has_operation())
|| (seq_items != nullptr && seq_items->has_operation());
}
std::string System::AclItems::Ipv4Items::NameItems::ACLList::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/acl-items/ipv4-items/name-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::AclItems::Ipv4Items::NameItems::ACLList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "ACL-list";
ADD_KEY_TOKEN(name, "name");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv4Items::NameItems::ACLList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (upid.is_set || is_set(upid.yfilter)) leaf_name_data.push_back(upid.get_name_leafdata());
if (peracestatistics.is_set || is_set(peracestatistics.yfilter)) leaf_name_data.push_back(peracestatistics.get_name_leafdata());
if (configstatus.is_set || is_set(configstatus.yfilter)) leaf_name_data.push_back(configstatus.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv4Items::NameItems::ACLList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "reseq-items")
{
if(reseq_items == nullptr)
{
reseq_items = std::make_shared<System::AclItems::Ipv4Items::NameItems::ACLList::ReseqItems>();
}
return reseq_items;
}
if(child_yang_name == "seq-items")
{
if(seq_items == nullptr)
{
seq_items = std::make_shared<System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems>();
}
return seq_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv4Items::NameItems::ACLList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(reseq_items != nullptr)
{
_children["reseq-items"] = reseq_items;
}
if(seq_items != nullptr)
{
_children["seq-items"] = seq_items;
}
return _children;
}
void System::AclItems::Ipv4Items::NameItems::ACLList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "upid")
{
upid = value;
upid.value_namespace = name_space;
upid.value_namespace_prefix = name_space_prefix;
}
if(value_path == "perACEStatistics")
{
peracestatistics = value;
peracestatistics.value_namespace = name_space;
peracestatistics.value_namespace_prefix = name_space_prefix;
}
if(value_path == "configStatus")
{
configstatus = value;
configstatus.value_namespace = name_space;
configstatus.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv4Items::NameItems::ACLList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "upid")
{
upid.yfilter = yfilter;
}
if(value_path == "perACEStatistics")
{
peracestatistics.yfilter = yfilter;
}
if(value_path == "configStatus")
{
configstatus.yfilter = yfilter;
}
}
bool System::AclItems::Ipv4Items::NameItems::ACLList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "reseq-items" || name == "seq-items" || name == "name" || name == "upid" || name == "perACEStatistics" || name == "configStatus")
return true;
return false;
}
System::AclItems::Ipv4Items::NameItems::ACLList::ReseqItems::ReseqItems()
:
start{YType::uint32, "start"},
step{YType::uint32, "step"}
{
yang_name = "reseq-items"; yang_parent_name = "ACL-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AclItems::Ipv4Items::NameItems::ACLList::ReseqItems::~ReseqItems()
{
}
bool System::AclItems::Ipv4Items::NameItems::ACLList::ReseqItems::has_data() const
{
if (is_presence_container) return true;
return start.is_set
|| step.is_set;
}
bool System::AclItems::Ipv4Items::NameItems::ACLList::ReseqItems::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(start.yfilter)
|| ydk::is_set(step.yfilter);
}
std::string System::AclItems::Ipv4Items::NameItems::ACLList::ReseqItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "reseq-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv4Items::NameItems::ACLList::ReseqItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (start.is_set || is_set(start.yfilter)) leaf_name_data.push_back(start.get_name_leafdata());
if (step.is_set || is_set(step.yfilter)) leaf_name_data.push_back(step.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv4Items::NameItems::ACLList::ReseqItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv4Items::NameItems::ACLList::ReseqItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AclItems::Ipv4Items::NameItems::ACLList::ReseqItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "start")
{
start = value;
start.value_namespace = name_space;
start.value_namespace_prefix = name_space_prefix;
}
if(value_path == "step")
{
step = value;
step.value_namespace = name_space;
step.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv4Items::NameItems::ACLList::ReseqItems::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "start")
{
start.yfilter = yfilter;
}
if(value_path == "step")
{
step.yfilter = yfilter;
}
}
bool System::AclItems::Ipv4Items::NameItems::ACLList::ReseqItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "start" || name == "step")
return true;
return false;
}
System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::SeqItems()
:
ace_list(this, {"seqnum"})
{
yang_name = "seq-items"; yang_parent_name = "ACL-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::~SeqItems()
{
}
bool System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<ace_list.len(); index++)
{
if(ace_list[index]->has_data())
return true;
}
return false;
}
bool System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::has_operation() const
{
for (std::size_t index=0; index<ace_list.len(); index++)
{
if(ace_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "seq-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "ACE-list")
{
auto ent_ = std::make_shared<System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::ACEList>();
ent_->parent = this;
ace_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : ace_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "ACE-list")
return true;
return false;
}
System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::ACEList::ACEList()
:
seqnum{YType::uint32, "seqNum"},
protocol{YType::uint8, "protocol"},
protocolmask{YType::uint8, "protocolMask"},
srcprefix{YType::str, "srcPrefix"},
srcprefixmask{YType::str, "srcPrefixMask"},
srcprefixlength{YType::uint8, "srcPrefixLength"},
dstprefix{YType::str, "dstPrefix"},
dstprefixmask{YType::str, "dstPrefixMask"},
dstprefixlength{YType::uint8, "dstPrefixLength"},
precedence{YType::uint8, "precedence"},
ttl{YType::uint8, "ttl"},
icmpstr{YType::uint16, "icmpStr"},
icmptype{YType::uint16, "icmpType"},
icmpcode{YType::uint16, "icmpCode"},
tos{YType::uint8, "tos"},
configstatus{YType::uint8, "configStatus"},
upid{YType::uint32, "upid"},
remark{YType::str, "remark"},
action{YType::enumeration, "action"},
srcportop{YType::uint8, "srcPortOp"},
srcport1{YType::uint16, "srcPort1"},
srcport2{YType::uint16, "srcPort2"},
srcportmask{YType::uint16, "srcPortMask"},
dstportop{YType::uint8, "dstPortOp"},
dstport1{YType::uint16, "dstPort1"},
dstport2{YType::uint16, "dstPort2"},
dstportmask{YType::uint16, "dstPortMask"},
logging{YType::boolean, "logging"},
dscp{YType::uint8, "dscp"},
pktlenop{YType::uint8, "pktLenOp"},
pktlen1{YType::uint16, "pktLen1"},
pktlen2{YType::uint16, "pktLen2"},
urg{YType::boolean, "urg"},
ack{YType::boolean, "ack"},
psh{YType::boolean, "psh"},
rst{YType::boolean, "rst"},
syn{YType::boolean, "syn"},
fin{YType::boolean, "fin"},
est{YType::boolean, "est"},
rev{YType::boolean, "rev"},
tcpflagsmask{YType::uint8, "tcpFlagsMask"},
packets{YType::uint64, "packets"},
fragment{YType::boolean, "fragment"},
capturesession{YType::uint16, "captureSession"},
httpoption{YType::enumeration, "httpOption"},
vni{YType::uint32, "vni"},
vlan{YType::uint32, "vlan"},
tcpoptionlength{YType::uint32, "tcpOptionLength"},
timerange{YType::str, "timeRange"},
srcaddrgroup{YType::str, "srcAddrGroup"},
dstaddrgroup{YType::str, "dstAddrGroup"},
srcportgroup{YType::str, "srcPortGroup"},
dstportgroup{YType::str, "dstPortGroup"},
redirect{YType::str, "redirect"}
,
udf_items(std::make_shared<System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::ACEList::UdfItems>())
{
udf_items->parent = this;
yang_name = "ACE-list"; yang_parent_name = "seq-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::ACEList::~ACEList()
{
}
bool System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::ACEList::has_data() const
{
if (is_presence_container) return true;
return seqnum.is_set
|| protocol.is_set
|| protocolmask.is_set
|| srcprefix.is_set
|| srcprefixmask.is_set
|| srcprefixlength.is_set
|| dstprefix.is_set
|| dstprefixmask.is_set
|| dstprefixlength.is_set
|| precedence.is_set
|| ttl.is_set
|| icmpstr.is_set
|| icmptype.is_set
|| icmpcode.is_set
|| tos.is_set
|| configstatus.is_set
|| upid.is_set
|| remark.is_set
|| action.is_set
|| srcportop.is_set
|| srcport1.is_set
|| srcport2.is_set
|| srcportmask.is_set
|| dstportop.is_set
|| dstport1.is_set
|| dstport2.is_set
|| dstportmask.is_set
|| logging.is_set
|| dscp.is_set
|| pktlenop.is_set
|| pktlen1.is_set
|| pktlen2.is_set
|| urg.is_set
|| ack.is_set
|| psh.is_set
|| rst.is_set
|| syn.is_set
|| fin.is_set
|| est.is_set
|| rev.is_set
|| tcpflagsmask.is_set
|| packets.is_set
|| fragment.is_set
|| capturesession.is_set
|| httpoption.is_set
|| vni.is_set
|| vlan.is_set
|| tcpoptionlength.is_set
|| timerange.is_set
|| srcaddrgroup.is_set
|| dstaddrgroup.is_set
|| srcportgroup.is_set
|| dstportgroup.is_set
|| redirect.is_set
|| (udf_items != nullptr && udf_items->has_data());
}
bool System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::ACEList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(seqnum.yfilter)
|| ydk::is_set(protocol.yfilter)
|| ydk::is_set(protocolmask.yfilter)
|| ydk::is_set(srcprefix.yfilter)
|| ydk::is_set(srcprefixmask.yfilter)
|| ydk::is_set(srcprefixlength.yfilter)
|| ydk::is_set(dstprefix.yfilter)
|| ydk::is_set(dstprefixmask.yfilter)
|| ydk::is_set(dstprefixlength.yfilter)
|| ydk::is_set(precedence.yfilter)
|| ydk::is_set(ttl.yfilter)
|| ydk::is_set(icmpstr.yfilter)
|| ydk::is_set(icmptype.yfilter)
|| ydk::is_set(icmpcode.yfilter)
|| ydk::is_set(tos.yfilter)
|| ydk::is_set(configstatus.yfilter)
|| ydk::is_set(upid.yfilter)
|| ydk::is_set(remark.yfilter)
|| ydk::is_set(action.yfilter)
|| ydk::is_set(srcportop.yfilter)
|| ydk::is_set(srcport1.yfilter)
|| ydk::is_set(srcport2.yfilter)
|| ydk::is_set(srcportmask.yfilter)
|| ydk::is_set(dstportop.yfilter)
|| ydk::is_set(dstport1.yfilter)
|| ydk::is_set(dstport2.yfilter)
|| ydk::is_set(dstportmask.yfilter)
|| ydk::is_set(logging.yfilter)
|| ydk::is_set(dscp.yfilter)
|| ydk::is_set(pktlenop.yfilter)
|| ydk::is_set(pktlen1.yfilter)
|| ydk::is_set(pktlen2.yfilter)
|| ydk::is_set(urg.yfilter)
|| ydk::is_set(ack.yfilter)
|| ydk::is_set(psh.yfilter)
|| ydk::is_set(rst.yfilter)
|| ydk::is_set(syn.yfilter)
|| ydk::is_set(fin.yfilter)
|| ydk::is_set(est.yfilter)
|| ydk::is_set(rev.yfilter)
|| ydk::is_set(tcpflagsmask.yfilter)
|| ydk::is_set(packets.yfilter)
|| ydk::is_set(fragment.yfilter)
|| ydk::is_set(capturesession.yfilter)
|| ydk::is_set(httpoption.yfilter)
|| ydk::is_set(vni.yfilter)
|| ydk::is_set(vlan.yfilter)
|| ydk::is_set(tcpoptionlength.yfilter)
|| ydk::is_set(timerange.yfilter)
|| ydk::is_set(srcaddrgroup.yfilter)
|| ydk::is_set(dstaddrgroup.yfilter)
|| ydk::is_set(srcportgroup.yfilter)
|| ydk::is_set(dstportgroup.yfilter)
|| ydk::is_set(redirect.yfilter)
|| (udf_items != nullptr && udf_items->has_operation());
}
std::string System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::ACEList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "ACE-list";
ADD_KEY_TOKEN(seqnum, "seqNum");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::ACEList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (seqnum.is_set || is_set(seqnum.yfilter)) leaf_name_data.push_back(seqnum.get_name_leafdata());
if (protocol.is_set || is_set(protocol.yfilter)) leaf_name_data.push_back(protocol.get_name_leafdata());
if (protocolmask.is_set || is_set(protocolmask.yfilter)) leaf_name_data.push_back(protocolmask.get_name_leafdata());
if (srcprefix.is_set || is_set(srcprefix.yfilter)) leaf_name_data.push_back(srcprefix.get_name_leafdata());
if (srcprefixmask.is_set || is_set(srcprefixmask.yfilter)) leaf_name_data.push_back(srcprefixmask.get_name_leafdata());
if (srcprefixlength.is_set || is_set(srcprefixlength.yfilter)) leaf_name_data.push_back(srcprefixlength.get_name_leafdata());
if (dstprefix.is_set || is_set(dstprefix.yfilter)) leaf_name_data.push_back(dstprefix.get_name_leafdata());
if (dstprefixmask.is_set || is_set(dstprefixmask.yfilter)) leaf_name_data.push_back(dstprefixmask.get_name_leafdata());
if (dstprefixlength.is_set || is_set(dstprefixlength.yfilter)) leaf_name_data.push_back(dstprefixlength.get_name_leafdata());
if (precedence.is_set || is_set(precedence.yfilter)) leaf_name_data.push_back(precedence.get_name_leafdata());
if (ttl.is_set || is_set(ttl.yfilter)) leaf_name_data.push_back(ttl.get_name_leafdata());
if (icmpstr.is_set || is_set(icmpstr.yfilter)) leaf_name_data.push_back(icmpstr.get_name_leafdata());
if (icmptype.is_set || is_set(icmptype.yfilter)) leaf_name_data.push_back(icmptype.get_name_leafdata());
if (icmpcode.is_set || is_set(icmpcode.yfilter)) leaf_name_data.push_back(icmpcode.get_name_leafdata());
if (tos.is_set || is_set(tos.yfilter)) leaf_name_data.push_back(tos.get_name_leafdata());
if (configstatus.is_set || is_set(configstatus.yfilter)) leaf_name_data.push_back(configstatus.get_name_leafdata());
if (upid.is_set || is_set(upid.yfilter)) leaf_name_data.push_back(upid.get_name_leafdata());
if (remark.is_set || is_set(remark.yfilter)) leaf_name_data.push_back(remark.get_name_leafdata());
if (action.is_set || is_set(action.yfilter)) leaf_name_data.push_back(action.get_name_leafdata());
if (srcportop.is_set || is_set(srcportop.yfilter)) leaf_name_data.push_back(srcportop.get_name_leafdata());
if (srcport1.is_set || is_set(srcport1.yfilter)) leaf_name_data.push_back(srcport1.get_name_leafdata());
if (srcport2.is_set || is_set(srcport2.yfilter)) leaf_name_data.push_back(srcport2.get_name_leafdata());
if (srcportmask.is_set || is_set(srcportmask.yfilter)) leaf_name_data.push_back(srcportmask.get_name_leafdata());
if (dstportop.is_set || is_set(dstportop.yfilter)) leaf_name_data.push_back(dstportop.get_name_leafdata());
if (dstport1.is_set || is_set(dstport1.yfilter)) leaf_name_data.push_back(dstport1.get_name_leafdata());
if (dstport2.is_set || is_set(dstport2.yfilter)) leaf_name_data.push_back(dstport2.get_name_leafdata());
if (dstportmask.is_set || is_set(dstportmask.yfilter)) leaf_name_data.push_back(dstportmask.get_name_leafdata());
if (logging.is_set || is_set(logging.yfilter)) leaf_name_data.push_back(logging.get_name_leafdata());
if (dscp.is_set || is_set(dscp.yfilter)) leaf_name_data.push_back(dscp.get_name_leafdata());
if (pktlenop.is_set || is_set(pktlenop.yfilter)) leaf_name_data.push_back(pktlenop.get_name_leafdata());
if (pktlen1.is_set || is_set(pktlen1.yfilter)) leaf_name_data.push_back(pktlen1.get_name_leafdata());
if (pktlen2.is_set || is_set(pktlen2.yfilter)) leaf_name_data.push_back(pktlen2.get_name_leafdata());
if (urg.is_set || is_set(urg.yfilter)) leaf_name_data.push_back(urg.get_name_leafdata());
if (ack.is_set || is_set(ack.yfilter)) leaf_name_data.push_back(ack.get_name_leafdata());
if (psh.is_set || is_set(psh.yfilter)) leaf_name_data.push_back(psh.get_name_leafdata());
if (rst.is_set || is_set(rst.yfilter)) leaf_name_data.push_back(rst.get_name_leafdata());
if (syn.is_set || is_set(syn.yfilter)) leaf_name_data.push_back(syn.get_name_leafdata());
if (fin.is_set || is_set(fin.yfilter)) leaf_name_data.push_back(fin.get_name_leafdata());
if (est.is_set || is_set(est.yfilter)) leaf_name_data.push_back(est.get_name_leafdata());
if (rev.is_set || is_set(rev.yfilter)) leaf_name_data.push_back(rev.get_name_leafdata());
if (tcpflagsmask.is_set || is_set(tcpflagsmask.yfilter)) leaf_name_data.push_back(tcpflagsmask.get_name_leafdata());
if (packets.is_set || is_set(packets.yfilter)) leaf_name_data.push_back(packets.get_name_leafdata());
if (fragment.is_set || is_set(fragment.yfilter)) leaf_name_data.push_back(fragment.get_name_leafdata());
if (capturesession.is_set || is_set(capturesession.yfilter)) leaf_name_data.push_back(capturesession.get_name_leafdata());
if (httpoption.is_set || is_set(httpoption.yfilter)) leaf_name_data.push_back(httpoption.get_name_leafdata());
if (vni.is_set || is_set(vni.yfilter)) leaf_name_data.push_back(vni.get_name_leafdata());
if (vlan.is_set || is_set(vlan.yfilter)) leaf_name_data.push_back(vlan.get_name_leafdata());
if (tcpoptionlength.is_set || is_set(tcpoptionlength.yfilter)) leaf_name_data.push_back(tcpoptionlength.get_name_leafdata());
if (timerange.is_set || is_set(timerange.yfilter)) leaf_name_data.push_back(timerange.get_name_leafdata());
if (srcaddrgroup.is_set || is_set(srcaddrgroup.yfilter)) leaf_name_data.push_back(srcaddrgroup.get_name_leafdata());
if (dstaddrgroup.is_set || is_set(dstaddrgroup.yfilter)) leaf_name_data.push_back(dstaddrgroup.get_name_leafdata());
if (srcportgroup.is_set || is_set(srcportgroup.yfilter)) leaf_name_data.push_back(srcportgroup.get_name_leafdata());
if (dstportgroup.is_set || is_set(dstportgroup.yfilter)) leaf_name_data.push_back(dstportgroup.get_name_leafdata());
if (redirect.is_set || is_set(redirect.yfilter)) leaf_name_data.push_back(redirect.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::ACEList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "udf-items")
{
if(udf_items == nullptr)
{
udf_items = std::make_shared<System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::ACEList::UdfItems>();
}
return udf_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::ACEList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(udf_items != nullptr)
{
_children["udf-items"] = udf_items;
}
return _children;
}
void System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::ACEList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "seqNum")
{
seqnum = value;
seqnum.value_namespace = name_space;
seqnum.value_namespace_prefix = name_space_prefix;
}
if(value_path == "protocol")
{
protocol = value;
protocol.value_namespace = name_space;
protocol.value_namespace_prefix = name_space_prefix;
}
if(value_path == "protocolMask")
{
protocolmask = value;
protocolmask.value_namespace = name_space;
protocolmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPrefix")
{
srcprefix = value;
srcprefix.value_namespace = name_space;
srcprefix.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPrefixMask")
{
srcprefixmask = value;
srcprefixmask.value_namespace = name_space;
srcprefixmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPrefixLength")
{
srcprefixlength = value;
srcprefixlength.value_namespace = name_space;
srcprefixlength.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPrefix")
{
dstprefix = value;
dstprefix.value_namespace = name_space;
dstprefix.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPrefixMask")
{
dstprefixmask = value;
dstprefixmask.value_namespace = name_space;
dstprefixmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPrefixLength")
{
dstprefixlength = value;
dstprefixlength.value_namespace = name_space;
dstprefixlength.value_namespace_prefix = name_space_prefix;
}
if(value_path == "precedence")
{
precedence = value;
precedence.value_namespace = name_space;
precedence.value_namespace_prefix = name_space_prefix;
}
if(value_path == "ttl")
{
ttl = value;
ttl.value_namespace = name_space;
ttl.value_namespace_prefix = name_space_prefix;
}
if(value_path == "icmpStr")
{
icmpstr = value;
icmpstr.value_namespace = name_space;
icmpstr.value_namespace_prefix = name_space_prefix;
}
if(value_path == "icmpType")
{
icmptype = value;
icmptype.value_namespace = name_space;
icmptype.value_namespace_prefix = name_space_prefix;
}
if(value_path == "icmpCode")
{
icmpcode = value;
icmpcode.value_namespace = name_space;
icmpcode.value_namespace_prefix = name_space_prefix;
}
if(value_path == "tos")
{
tos = value;
tos.value_namespace = name_space;
tos.value_namespace_prefix = name_space_prefix;
}
if(value_path == "configStatus")
{
configstatus = value;
configstatus.value_namespace = name_space;
configstatus.value_namespace_prefix = name_space_prefix;
}
if(value_path == "upid")
{
upid = value;
upid.value_namespace = name_space;
upid.value_namespace_prefix = name_space_prefix;
}
if(value_path == "remark")
{
remark = value;
remark.value_namespace = name_space;
remark.value_namespace_prefix = name_space_prefix;
}
if(value_path == "action")
{
action = value;
action.value_namespace = name_space;
action.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPortOp")
{
srcportop = value;
srcportop.value_namespace = name_space;
srcportop.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPort1")
{
srcport1 = value;
srcport1.value_namespace = name_space;
srcport1.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPort2")
{
srcport2 = value;
srcport2.value_namespace = name_space;
srcport2.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPortMask")
{
srcportmask = value;
srcportmask.value_namespace = name_space;
srcportmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPortOp")
{
dstportop = value;
dstportop.value_namespace = name_space;
dstportop.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPort1")
{
dstport1 = value;
dstport1.value_namespace = name_space;
dstport1.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPort2")
{
dstport2 = value;
dstport2.value_namespace = name_space;
dstport2.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPortMask")
{
dstportmask = value;
dstportmask.value_namespace = name_space;
dstportmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "logging")
{
logging = value;
logging.value_namespace = name_space;
logging.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dscp")
{
dscp = value;
dscp.value_namespace = name_space;
dscp.value_namespace_prefix = name_space_prefix;
}
if(value_path == "pktLenOp")
{
pktlenop = value;
pktlenop.value_namespace = name_space;
pktlenop.value_namespace_prefix = name_space_prefix;
}
if(value_path == "pktLen1")
{
pktlen1 = value;
pktlen1.value_namespace = name_space;
pktlen1.value_namespace_prefix = name_space_prefix;
}
if(value_path == "pktLen2")
{
pktlen2 = value;
pktlen2.value_namespace = name_space;
pktlen2.value_namespace_prefix = name_space_prefix;
}
if(value_path == "urg")
{
urg = value;
urg.value_namespace = name_space;
urg.value_namespace_prefix = name_space_prefix;
}
if(value_path == "ack")
{
ack = value;
ack.value_namespace = name_space;
ack.value_namespace_prefix = name_space_prefix;
}
if(value_path == "psh")
{
psh = value;
psh.value_namespace = name_space;
psh.value_namespace_prefix = name_space_prefix;
}
if(value_path == "rst")
{
rst = value;
rst.value_namespace = name_space;
rst.value_namespace_prefix = name_space_prefix;
}
if(value_path == "syn")
{
syn = value;
syn.value_namespace = name_space;
syn.value_namespace_prefix = name_space_prefix;
}
if(value_path == "fin")
{
fin = value;
fin.value_namespace = name_space;
fin.value_namespace_prefix = name_space_prefix;
}
if(value_path == "est")
{
est = value;
est.value_namespace = name_space;
est.value_namespace_prefix = name_space_prefix;
}
if(value_path == "rev")
{
rev = value;
rev.value_namespace = name_space;
rev.value_namespace_prefix = name_space_prefix;
}
if(value_path == "tcpFlagsMask")
{
tcpflagsmask = value;
tcpflagsmask.value_namespace = name_space;
tcpflagsmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "packets")
{
packets = value;
packets.value_namespace = name_space;
packets.value_namespace_prefix = name_space_prefix;
}
if(value_path == "fragment")
{
fragment = value;
fragment.value_namespace = name_space;
fragment.value_namespace_prefix = name_space_prefix;
}
if(value_path == "captureSession")
{
capturesession = value;
capturesession.value_namespace = name_space;
capturesession.value_namespace_prefix = name_space_prefix;
}
if(value_path == "httpOption")
{
httpoption = value;
httpoption.value_namespace = name_space;
httpoption.value_namespace_prefix = name_space_prefix;
}
if(value_path == "vni")
{
vni = value;
vni.value_namespace = name_space;
vni.value_namespace_prefix = name_space_prefix;
}
if(value_path == "vlan")
{
vlan = value;
vlan.value_namespace = name_space;
vlan.value_namespace_prefix = name_space_prefix;
}
if(value_path == "tcpOptionLength")
{
tcpoptionlength = value;
tcpoptionlength.value_namespace = name_space;
tcpoptionlength.value_namespace_prefix = name_space_prefix;
}
if(value_path == "timeRange")
{
timerange = value;
timerange.value_namespace = name_space;
timerange.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcAddrGroup")
{
srcaddrgroup = value;
srcaddrgroup.value_namespace = name_space;
srcaddrgroup.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstAddrGroup")
{
dstaddrgroup = value;
dstaddrgroup.value_namespace = name_space;
dstaddrgroup.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPortGroup")
{
srcportgroup = value;
srcportgroup.value_namespace = name_space;
srcportgroup.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPortGroup")
{
dstportgroup = value;
dstportgroup.value_namespace = name_space;
dstportgroup.value_namespace_prefix = name_space_prefix;
}
if(value_path == "redirect")
{
redirect = value;
redirect.value_namespace = name_space;
redirect.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::ACEList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "seqNum")
{
seqnum.yfilter = yfilter;
}
if(value_path == "protocol")
{
protocol.yfilter = yfilter;
}
if(value_path == "protocolMask")
{
protocolmask.yfilter = yfilter;
}
if(value_path == "srcPrefix")
{
srcprefix.yfilter = yfilter;
}
if(value_path == "srcPrefixMask")
{
srcprefixmask.yfilter = yfilter;
}
if(value_path == "srcPrefixLength")
{
srcprefixlength.yfilter = yfilter;
}
if(value_path == "dstPrefix")
{
dstprefix.yfilter = yfilter;
}
if(value_path == "dstPrefixMask")
{
dstprefixmask.yfilter = yfilter;
}
if(value_path == "dstPrefixLength")
{
dstprefixlength.yfilter = yfilter;
}
if(value_path == "precedence")
{
precedence.yfilter = yfilter;
}
if(value_path == "ttl")
{
ttl.yfilter = yfilter;
}
if(value_path == "icmpStr")
{
icmpstr.yfilter = yfilter;
}
if(value_path == "icmpType")
{
icmptype.yfilter = yfilter;
}
if(value_path == "icmpCode")
{
icmpcode.yfilter = yfilter;
}
if(value_path == "tos")
{
tos.yfilter = yfilter;
}
if(value_path == "configStatus")
{
configstatus.yfilter = yfilter;
}
if(value_path == "upid")
{
upid.yfilter = yfilter;
}
if(value_path == "remark")
{
remark.yfilter = yfilter;
}
if(value_path == "action")
{
action.yfilter = yfilter;
}
if(value_path == "srcPortOp")
{
srcportop.yfilter = yfilter;
}
if(value_path == "srcPort1")
{
srcport1.yfilter = yfilter;
}
if(value_path == "srcPort2")
{
srcport2.yfilter = yfilter;
}
if(value_path == "srcPortMask")
{
srcportmask.yfilter = yfilter;
}
if(value_path == "dstPortOp")
{
dstportop.yfilter = yfilter;
}
if(value_path == "dstPort1")
{
dstport1.yfilter = yfilter;
}
if(value_path == "dstPort2")
{
dstport2.yfilter = yfilter;
}
if(value_path == "dstPortMask")
{
dstportmask.yfilter = yfilter;
}
if(value_path == "logging")
{
logging.yfilter = yfilter;
}
if(value_path == "dscp")
{
dscp.yfilter = yfilter;
}
if(value_path == "pktLenOp")
{
pktlenop.yfilter = yfilter;
}
if(value_path == "pktLen1")
{
pktlen1.yfilter = yfilter;
}
if(value_path == "pktLen2")
{
pktlen2.yfilter = yfilter;
}
if(value_path == "urg")
{
urg.yfilter = yfilter;
}
if(value_path == "ack")
{
ack.yfilter = yfilter;
}
if(value_path == "psh")
{
psh.yfilter = yfilter;
}
if(value_path == "rst")
{
rst.yfilter = yfilter;
}
if(value_path == "syn")
{
syn.yfilter = yfilter;
}
if(value_path == "fin")
{
fin.yfilter = yfilter;
}
if(value_path == "est")
{
est.yfilter = yfilter;
}
if(value_path == "rev")
{
rev.yfilter = yfilter;
}
if(value_path == "tcpFlagsMask")
{
tcpflagsmask.yfilter = yfilter;
}
if(value_path == "packets")
{
packets.yfilter = yfilter;
}
if(value_path == "fragment")
{
fragment.yfilter = yfilter;
}
if(value_path == "captureSession")
{
capturesession.yfilter = yfilter;
}
if(value_path == "httpOption")
{
httpoption.yfilter = yfilter;
}
if(value_path == "vni")
{
vni.yfilter = yfilter;
}
if(value_path == "vlan")
{
vlan.yfilter = yfilter;
}
if(value_path == "tcpOptionLength")
{
tcpoptionlength.yfilter = yfilter;
}
if(value_path == "timeRange")
{
timerange.yfilter = yfilter;
}
if(value_path == "srcAddrGroup")
{
srcaddrgroup.yfilter = yfilter;
}
if(value_path == "dstAddrGroup")
{
dstaddrgroup.yfilter = yfilter;
}
if(value_path == "srcPortGroup")
{
srcportgroup.yfilter = yfilter;
}
if(value_path == "dstPortGroup")
{
dstportgroup.yfilter = yfilter;
}
if(value_path == "redirect")
{
redirect.yfilter = yfilter;
}
}
bool System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::ACEList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "udf-items" || name == "seqNum" || name == "protocol" || name == "protocolMask" || name == "srcPrefix" || name == "srcPrefixMask" || name == "srcPrefixLength" || name == "dstPrefix" || name == "dstPrefixMask" || name == "dstPrefixLength" || name == "precedence" || name == "ttl" || name == "icmpStr" || name == "icmpType" || name == "icmpCode" || name == "tos" || name == "configStatus" || name == "upid" || name == "remark" || name == "action" || name == "srcPortOp" || name == "srcPort1" || name == "srcPort2" || name == "srcPortMask" || name == "dstPortOp" || name == "dstPort1" || name == "dstPort2" || name == "dstPortMask" || name == "logging" || name == "dscp" || name == "pktLenOp" || name == "pktLen1" || name == "pktLen2" || name == "urg" || name == "ack" || name == "psh" || name == "rst" || name == "syn" || name == "fin" || name == "est" || name == "rev" || name == "tcpFlagsMask" || name == "packets" || name == "fragment" || name == "captureSession" || name == "httpOption" || name == "vni" || name == "vlan" || name == "tcpOptionLength" || name == "timeRange" || name == "srcAddrGroup" || name == "dstAddrGroup" || name == "srcPortGroup" || name == "dstPortGroup" || name == "redirect")
return true;
return false;
}
System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::ACEList::UdfItems::UdfItems()
:
udf1name{YType::str, "udf1Name"},
udf1val{YType::uint16, "udf1Val"},
udf1mask{YType::uint16, "udf1Mask"},
udf2name{YType::str, "udf2Name"},
udf2val{YType::uint16, "udf2Val"},
udf2mask{YType::uint16, "udf2Mask"},
udf3name{YType::str, "udf3Name"},
udf3val{YType::uint16, "udf3Val"},
udf3mask{YType::uint16, "udf3Mask"},
udf4name{YType::str, "udf4Name"},
udf4val{YType::uint16, "udf4Val"},
udf4mask{YType::uint16, "udf4Mask"},
udf5name{YType::str, "udf5Name"},
udf5val{YType::uint16, "udf5Val"},
udf5mask{YType::uint16, "udf5Mask"},
udf6name{YType::str, "udf6Name"},
udf6val{YType::uint16, "udf6Val"},
udf6mask{YType::uint16, "udf6Mask"},
udf7name{YType::str, "udf7Name"},
udf7val{YType::uint16, "udf7Val"},
udf7mask{YType::uint16, "udf7Mask"},
udf8name{YType::str, "udf8Name"},
udf8val{YType::uint16, "udf8Val"},
udf8mask{YType::uint16, "udf8Mask"},
udf9name{YType::str, "udf9Name"},
udf9val{YType::uint16, "udf9Val"},
udf9mask{YType::uint16, "udf9Mask"},
udf10name{YType::str, "udf10Name"},
udf10val{YType::uint16, "udf10Val"},
udf10mask{YType::uint16, "udf10Mask"},
udf11name{YType::str, "udf11Name"},
udf11val{YType::uint16, "udf11Val"},
udf11mask{YType::uint16, "udf11Mask"},
udf12name{YType::str, "udf12Name"},
udf12val{YType::uint16, "udf12Val"},
udf12mask{YType::uint16, "udf12Mask"},
udf13name{YType::str, "udf13Name"},
udf13val{YType::uint16, "udf13Val"},
udf13mask{YType::uint16, "udf13Mask"},
udf14name{YType::str, "udf14Name"},
udf14val{YType::uint16, "udf14Val"},
udf14mask{YType::uint16, "udf14Mask"},
udf15name{YType::str, "udf15Name"},
udf15val{YType::uint16, "udf15Val"},
udf15mask{YType::uint16, "udf15Mask"},
udf16name{YType::str, "udf16Name"},
udf16val{YType::uint16, "udf16Val"},
udf16mask{YType::uint16, "udf16Mask"},
udf17name{YType::str, "udf17Name"},
udf17val{YType::uint16, "udf17Val"},
udf17mask{YType::uint16, "udf17Mask"},
udf18name{YType::str, "udf18Name"},
udf18val{YType::uint16, "udf18Val"},
udf18mask{YType::uint16, "udf18Mask"},
upid{YType::uint32, "upid"}
{
yang_name = "udf-items"; yang_parent_name = "ACE-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::ACEList::UdfItems::~UdfItems()
{
}
bool System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::ACEList::UdfItems::has_data() const
{
if (is_presence_container) return true;
return udf1name.is_set
|| udf1val.is_set
|| udf1mask.is_set
|| udf2name.is_set
|| udf2val.is_set
|| udf2mask.is_set
|| udf3name.is_set
|| udf3val.is_set
|| udf3mask.is_set
|| udf4name.is_set
|| udf4val.is_set
|| udf4mask.is_set
|| udf5name.is_set
|| udf5val.is_set
|| udf5mask.is_set
|| udf6name.is_set
|| udf6val.is_set
|| udf6mask.is_set
|| udf7name.is_set
|| udf7val.is_set
|| udf7mask.is_set
|| udf8name.is_set
|| udf8val.is_set
|| udf8mask.is_set
|| udf9name.is_set
|| udf9val.is_set
|| udf9mask.is_set
|| udf10name.is_set
|| udf10val.is_set
|| udf10mask.is_set
|| udf11name.is_set
|| udf11val.is_set
|| udf11mask.is_set
|| udf12name.is_set
|| udf12val.is_set
|| udf12mask.is_set
|| udf13name.is_set
|| udf13val.is_set
|| udf13mask.is_set
|| udf14name.is_set
|| udf14val.is_set
|| udf14mask.is_set
|| udf15name.is_set
|| udf15val.is_set
|| udf15mask.is_set
|| udf16name.is_set
|| udf16val.is_set
|| udf16mask.is_set
|| udf17name.is_set
|| udf17val.is_set
|| udf17mask.is_set
|| udf18name.is_set
|| udf18val.is_set
|| udf18mask.is_set
|| upid.is_set;
}
bool System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::ACEList::UdfItems::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(udf1name.yfilter)
|| ydk::is_set(udf1val.yfilter)
|| ydk::is_set(udf1mask.yfilter)
|| ydk::is_set(udf2name.yfilter)
|| ydk::is_set(udf2val.yfilter)
|| ydk::is_set(udf2mask.yfilter)
|| ydk::is_set(udf3name.yfilter)
|| ydk::is_set(udf3val.yfilter)
|| ydk::is_set(udf3mask.yfilter)
|| ydk::is_set(udf4name.yfilter)
|| ydk::is_set(udf4val.yfilter)
|| ydk::is_set(udf4mask.yfilter)
|| ydk::is_set(udf5name.yfilter)
|| ydk::is_set(udf5val.yfilter)
|| ydk::is_set(udf5mask.yfilter)
|| ydk::is_set(udf6name.yfilter)
|| ydk::is_set(udf6val.yfilter)
|| ydk::is_set(udf6mask.yfilter)
|| ydk::is_set(udf7name.yfilter)
|| ydk::is_set(udf7val.yfilter)
|| ydk::is_set(udf7mask.yfilter)
|| ydk::is_set(udf8name.yfilter)
|| ydk::is_set(udf8val.yfilter)
|| ydk::is_set(udf8mask.yfilter)
|| ydk::is_set(udf9name.yfilter)
|| ydk::is_set(udf9val.yfilter)
|| ydk::is_set(udf9mask.yfilter)
|| ydk::is_set(udf10name.yfilter)
|| ydk::is_set(udf10val.yfilter)
|| ydk::is_set(udf10mask.yfilter)
|| ydk::is_set(udf11name.yfilter)
|| ydk::is_set(udf11val.yfilter)
|| ydk::is_set(udf11mask.yfilter)
|| ydk::is_set(udf12name.yfilter)
|| ydk::is_set(udf12val.yfilter)
|| ydk::is_set(udf12mask.yfilter)
|| ydk::is_set(udf13name.yfilter)
|| ydk::is_set(udf13val.yfilter)
|| ydk::is_set(udf13mask.yfilter)
|| ydk::is_set(udf14name.yfilter)
|| ydk::is_set(udf14val.yfilter)
|| ydk::is_set(udf14mask.yfilter)
|| ydk::is_set(udf15name.yfilter)
|| ydk::is_set(udf15val.yfilter)
|| ydk::is_set(udf15mask.yfilter)
|| ydk::is_set(udf16name.yfilter)
|| ydk::is_set(udf16val.yfilter)
|| ydk::is_set(udf16mask.yfilter)
|| ydk::is_set(udf17name.yfilter)
|| ydk::is_set(udf17val.yfilter)
|| ydk::is_set(udf17mask.yfilter)
|| ydk::is_set(udf18name.yfilter)
|| ydk::is_set(udf18val.yfilter)
|| ydk::is_set(udf18mask.yfilter)
|| ydk::is_set(upid.yfilter);
}
std::string System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::ACEList::UdfItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "udf-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::ACEList::UdfItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (udf1name.is_set || is_set(udf1name.yfilter)) leaf_name_data.push_back(udf1name.get_name_leafdata());
if (udf1val.is_set || is_set(udf1val.yfilter)) leaf_name_data.push_back(udf1val.get_name_leafdata());
if (udf1mask.is_set || is_set(udf1mask.yfilter)) leaf_name_data.push_back(udf1mask.get_name_leafdata());
if (udf2name.is_set || is_set(udf2name.yfilter)) leaf_name_data.push_back(udf2name.get_name_leafdata());
if (udf2val.is_set || is_set(udf2val.yfilter)) leaf_name_data.push_back(udf2val.get_name_leafdata());
if (udf2mask.is_set || is_set(udf2mask.yfilter)) leaf_name_data.push_back(udf2mask.get_name_leafdata());
if (udf3name.is_set || is_set(udf3name.yfilter)) leaf_name_data.push_back(udf3name.get_name_leafdata());
if (udf3val.is_set || is_set(udf3val.yfilter)) leaf_name_data.push_back(udf3val.get_name_leafdata());
if (udf3mask.is_set || is_set(udf3mask.yfilter)) leaf_name_data.push_back(udf3mask.get_name_leafdata());
if (udf4name.is_set || is_set(udf4name.yfilter)) leaf_name_data.push_back(udf4name.get_name_leafdata());
if (udf4val.is_set || is_set(udf4val.yfilter)) leaf_name_data.push_back(udf4val.get_name_leafdata());
if (udf4mask.is_set || is_set(udf4mask.yfilter)) leaf_name_data.push_back(udf4mask.get_name_leafdata());
if (udf5name.is_set || is_set(udf5name.yfilter)) leaf_name_data.push_back(udf5name.get_name_leafdata());
if (udf5val.is_set || is_set(udf5val.yfilter)) leaf_name_data.push_back(udf5val.get_name_leafdata());
if (udf5mask.is_set || is_set(udf5mask.yfilter)) leaf_name_data.push_back(udf5mask.get_name_leafdata());
if (udf6name.is_set || is_set(udf6name.yfilter)) leaf_name_data.push_back(udf6name.get_name_leafdata());
if (udf6val.is_set || is_set(udf6val.yfilter)) leaf_name_data.push_back(udf6val.get_name_leafdata());
if (udf6mask.is_set || is_set(udf6mask.yfilter)) leaf_name_data.push_back(udf6mask.get_name_leafdata());
if (udf7name.is_set || is_set(udf7name.yfilter)) leaf_name_data.push_back(udf7name.get_name_leafdata());
if (udf7val.is_set || is_set(udf7val.yfilter)) leaf_name_data.push_back(udf7val.get_name_leafdata());
if (udf7mask.is_set || is_set(udf7mask.yfilter)) leaf_name_data.push_back(udf7mask.get_name_leafdata());
if (udf8name.is_set || is_set(udf8name.yfilter)) leaf_name_data.push_back(udf8name.get_name_leafdata());
if (udf8val.is_set || is_set(udf8val.yfilter)) leaf_name_data.push_back(udf8val.get_name_leafdata());
if (udf8mask.is_set || is_set(udf8mask.yfilter)) leaf_name_data.push_back(udf8mask.get_name_leafdata());
if (udf9name.is_set || is_set(udf9name.yfilter)) leaf_name_data.push_back(udf9name.get_name_leafdata());
if (udf9val.is_set || is_set(udf9val.yfilter)) leaf_name_data.push_back(udf9val.get_name_leafdata());
if (udf9mask.is_set || is_set(udf9mask.yfilter)) leaf_name_data.push_back(udf9mask.get_name_leafdata());
if (udf10name.is_set || is_set(udf10name.yfilter)) leaf_name_data.push_back(udf10name.get_name_leafdata());
if (udf10val.is_set || is_set(udf10val.yfilter)) leaf_name_data.push_back(udf10val.get_name_leafdata());
if (udf10mask.is_set || is_set(udf10mask.yfilter)) leaf_name_data.push_back(udf10mask.get_name_leafdata());
if (udf11name.is_set || is_set(udf11name.yfilter)) leaf_name_data.push_back(udf11name.get_name_leafdata());
if (udf11val.is_set || is_set(udf11val.yfilter)) leaf_name_data.push_back(udf11val.get_name_leafdata());
if (udf11mask.is_set || is_set(udf11mask.yfilter)) leaf_name_data.push_back(udf11mask.get_name_leafdata());
if (udf12name.is_set || is_set(udf12name.yfilter)) leaf_name_data.push_back(udf12name.get_name_leafdata());
if (udf12val.is_set || is_set(udf12val.yfilter)) leaf_name_data.push_back(udf12val.get_name_leafdata());
if (udf12mask.is_set || is_set(udf12mask.yfilter)) leaf_name_data.push_back(udf12mask.get_name_leafdata());
if (udf13name.is_set || is_set(udf13name.yfilter)) leaf_name_data.push_back(udf13name.get_name_leafdata());
if (udf13val.is_set || is_set(udf13val.yfilter)) leaf_name_data.push_back(udf13val.get_name_leafdata());
if (udf13mask.is_set || is_set(udf13mask.yfilter)) leaf_name_data.push_back(udf13mask.get_name_leafdata());
if (udf14name.is_set || is_set(udf14name.yfilter)) leaf_name_data.push_back(udf14name.get_name_leafdata());
if (udf14val.is_set || is_set(udf14val.yfilter)) leaf_name_data.push_back(udf14val.get_name_leafdata());
if (udf14mask.is_set || is_set(udf14mask.yfilter)) leaf_name_data.push_back(udf14mask.get_name_leafdata());
if (udf15name.is_set || is_set(udf15name.yfilter)) leaf_name_data.push_back(udf15name.get_name_leafdata());
if (udf15val.is_set || is_set(udf15val.yfilter)) leaf_name_data.push_back(udf15val.get_name_leafdata());
if (udf15mask.is_set || is_set(udf15mask.yfilter)) leaf_name_data.push_back(udf15mask.get_name_leafdata());
if (udf16name.is_set || is_set(udf16name.yfilter)) leaf_name_data.push_back(udf16name.get_name_leafdata());
if (udf16val.is_set || is_set(udf16val.yfilter)) leaf_name_data.push_back(udf16val.get_name_leafdata());
if (udf16mask.is_set || is_set(udf16mask.yfilter)) leaf_name_data.push_back(udf16mask.get_name_leafdata());
if (udf17name.is_set || is_set(udf17name.yfilter)) leaf_name_data.push_back(udf17name.get_name_leafdata());
if (udf17val.is_set || is_set(udf17val.yfilter)) leaf_name_data.push_back(udf17val.get_name_leafdata());
if (udf17mask.is_set || is_set(udf17mask.yfilter)) leaf_name_data.push_back(udf17mask.get_name_leafdata());
if (udf18name.is_set || is_set(udf18name.yfilter)) leaf_name_data.push_back(udf18name.get_name_leafdata());
if (udf18val.is_set || is_set(udf18val.yfilter)) leaf_name_data.push_back(udf18val.get_name_leafdata());
if (udf18mask.is_set || is_set(udf18mask.yfilter)) leaf_name_data.push_back(udf18mask.get_name_leafdata());
if (upid.is_set || is_set(upid.yfilter)) leaf_name_data.push_back(upid.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::ACEList::UdfItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::ACEList::UdfItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::ACEList::UdfItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "udf1Name")
{
udf1name = value;
udf1name.value_namespace = name_space;
udf1name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf1Val")
{
udf1val = value;
udf1val.value_namespace = name_space;
udf1val.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf1Mask")
{
udf1mask = value;
udf1mask.value_namespace = name_space;
udf1mask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf2Name")
{
udf2name = value;
udf2name.value_namespace = name_space;
udf2name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf2Val")
{
udf2val = value;
udf2val.value_namespace = name_space;
udf2val.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf2Mask")
{
udf2mask = value;
udf2mask.value_namespace = name_space;
udf2mask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf3Name")
{
udf3name = value;
udf3name.value_namespace = name_space;
udf3name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf3Val")
{
udf3val = value;
udf3val.value_namespace = name_space;
udf3val.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf3Mask")
{
udf3mask = value;
udf3mask.value_namespace = name_space;
udf3mask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf4Name")
{
udf4name = value;
udf4name.value_namespace = name_space;
udf4name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf4Val")
{
udf4val = value;
udf4val.value_namespace = name_space;
udf4val.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf4Mask")
{
udf4mask = value;
udf4mask.value_namespace = name_space;
udf4mask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf5Name")
{
udf5name = value;
udf5name.value_namespace = name_space;
udf5name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf5Val")
{
udf5val = value;
udf5val.value_namespace = name_space;
udf5val.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf5Mask")
{
udf5mask = value;
udf5mask.value_namespace = name_space;
udf5mask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf6Name")
{
udf6name = value;
udf6name.value_namespace = name_space;
udf6name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf6Val")
{
udf6val = value;
udf6val.value_namespace = name_space;
udf6val.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf6Mask")
{
udf6mask = value;
udf6mask.value_namespace = name_space;
udf6mask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf7Name")
{
udf7name = value;
udf7name.value_namespace = name_space;
udf7name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf7Val")
{
udf7val = value;
udf7val.value_namespace = name_space;
udf7val.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf7Mask")
{
udf7mask = value;
udf7mask.value_namespace = name_space;
udf7mask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf8Name")
{
udf8name = value;
udf8name.value_namespace = name_space;
udf8name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf8Val")
{
udf8val = value;
udf8val.value_namespace = name_space;
udf8val.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf8Mask")
{
udf8mask = value;
udf8mask.value_namespace = name_space;
udf8mask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf9Name")
{
udf9name = value;
udf9name.value_namespace = name_space;
udf9name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf9Val")
{
udf9val = value;
udf9val.value_namespace = name_space;
udf9val.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf9Mask")
{
udf9mask = value;
udf9mask.value_namespace = name_space;
udf9mask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf10Name")
{
udf10name = value;
udf10name.value_namespace = name_space;
udf10name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf10Val")
{
udf10val = value;
udf10val.value_namespace = name_space;
udf10val.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf10Mask")
{
udf10mask = value;
udf10mask.value_namespace = name_space;
udf10mask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf11Name")
{
udf11name = value;
udf11name.value_namespace = name_space;
udf11name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf11Val")
{
udf11val = value;
udf11val.value_namespace = name_space;
udf11val.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf11Mask")
{
udf11mask = value;
udf11mask.value_namespace = name_space;
udf11mask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf12Name")
{
udf12name = value;
udf12name.value_namespace = name_space;
udf12name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf12Val")
{
udf12val = value;
udf12val.value_namespace = name_space;
udf12val.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf12Mask")
{
udf12mask = value;
udf12mask.value_namespace = name_space;
udf12mask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf13Name")
{
udf13name = value;
udf13name.value_namespace = name_space;
udf13name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf13Val")
{
udf13val = value;
udf13val.value_namespace = name_space;
udf13val.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf13Mask")
{
udf13mask = value;
udf13mask.value_namespace = name_space;
udf13mask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf14Name")
{
udf14name = value;
udf14name.value_namespace = name_space;
udf14name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf14Val")
{
udf14val = value;
udf14val.value_namespace = name_space;
udf14val.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf14Mask")
{
udf14mask = value;
udf14mask.value_namespace = name_space;
udf14mask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf15Name")
{
udf15name = value;
udf15name.value_namespace = name_space;
udf15name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf15Val")
{
udf15val = value;
udf15val.value_namespace = name_space;
udf15val.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf15Mask")
{
udf15mask = value;
udf15mask.value_namespace = name_space;
udf15mask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf16Name")
{
udf16name = value;
udf16name.value_namespace = name_space;
udf16name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf16Val")
{
udf16val = value;
udf16val.value_namespace = name_space;
udf16val.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf16Mask")
{
udf16mask = value;
udf16mask.value_namespace = name_space;
udf16mask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf17Name")
{
udf17name = value;
udf17name.value_namespace = name_space;
udf17name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf17Val")
{
udf17val = value;
udf17val.value_namespace = name_space;
udf17val.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf17Mask")
{
udf17mask = value;
udf17mask.value_namespace = name_space;
udf17mask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf18Name")
{
udf18name = value;
udf18name.value_namespace = name_space;
udf18name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf18Val")
{
udf18val = value;
udf18val.value_namespace = name_space;
udf18val.value_namespace_prefix = name_space_prefix;
}
if(value_path == "udf18Mask")
{
udf18mask = value;
udf18mask.value_namespace = name_space;
udf18mask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "upid")
{
upid = value;
upid.value_namespace = name_space;
upid.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::ACEList::UdfItems::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "udf1Name")
{
udf1name.yfilter = yfilter;
}
if(value_path == "udf1Val")
{
udf1val.yfilter = yfilter;
}
if(value_path == "udf1Mask")
{
udf1mask.yfilter = yfilter;
}
if(value_path == "udf2Name")
{
udf2name.yfilter = yfilter;
}
if(value_path == "udf2Val")
{
udf2val.yfilter = yfilter;
}
if(value_path == "udf2Mask")
{
udf2mask.yfilter = yfilter;
}
if(value_path == "udf3Name")
{
udf3name.yfilter = yfilter;
}
if(value_path == "udf3Val")
{
udf3val.yfilter = yfilter;
}
if(value_path == "udf3Mask")
{
udf3mask.yfilter = yfilter;
}
if(value_path == "udf4Name")
{
udf4name.yfilter = yfilter;
}
if(value_path == "udf4Val")
{
udf4val.yfilter = yfilter;
}
if(value_path == "udf4Mask")
{
udf4mask.yfilter = yfilter;
}
if(value_path == "udf5Name")
{
udf5name.yfilter = yfilter;
}
if(value_path == "udf5Val")
{
udf5val.yfilter = yfilter;
}
if(value_path == "udf5Mask")
{
udf5mask.yfilter = yfilter;
}
if(value_path == "udf6Name")
{
udf6name.yfilter = yfilter;
}
if(value_path == "udf6Val")
{
udf6val.yfilter = yfilter;
}
if(value_path == "udf6Mask")
{
udf6mask.yfilter = yfilter;
}
if(value_path == "udf7Name")
{
udf7name.yfilter = yfilter;
}
if(value_path == "udf7Val")
{
udf7val.yfilter = yfilter;
}
if(value_path == "udf7Mask")
{
udf7mask.yfilter = yfilter;
}
if(value_path == "udf8Name")
{
udf8name.yfilter = yfilter;
}
if(value_path == "udf8Val")
{
udf8val.yfilter = yfilter;
}
if(value_path == "udf8Mask")
{
udf8mask.yfilter = yfilter;
}
if(value_path == "udf9Name")
{
udf9name.yfilter = yfilter;
}
if(value_path == "udf9Val")
{
udf9val.yfilter = yfilter;
}
if(value_path == "udf9Mask")
{
udf9mask.yfilter = yfilter;
}
if(value_path == "udf10Name")
{
udf10name.yfilter = yfilter;
}
if(value_path == "udf10Val")
{
udf10val.yfilter = yfilter;
}
if(value_path == "udf10Mask")
{
udf10mask.yfilter = yfilter;
}
if(value_path == "udf11Name")
{
udf11name.yfilter = yfilter;
}
if(value_path == "udf11Val")
{
udf11val.yfilter = yfilter;
}
if(value_path == "udf11Mask")
{
udf11mask.yfilter = yfilter;
}
if(value_path == "udf12Name")
{
udf12name.yfilter = yfilter;
}
if(value_path == "udf12Val")
{
udf12val.yfilter = yfilter;
}
if(value_path == "udf12Mask")
{
udf12mask.yfilter = yfilter;
}
if(value_path == "udf13Name")
{
udf13name.yfilter = yfilter;
}
if(value_path == "udf13Val")
{
udf13val.yfilter = yfilter;
}
if(value_path == "udf13Mask")
{
udf13mask.yfilter = yfilter;
}
if(value_path == "udf14Name")
{
udf14name.yfilter = yfilter;
}
if(value_path == "udf14Val")
{
udf14val.yfilter = yfilter;
}
if(value_path == "udf14Mask")
{
udf14mask.yfilter = yfilter;
}
if(value_path == "udf15Name")
{
udf15name.yfilter = yfilter;
}
if(value_path == "udf15Val")
{
udf15val.yfilter = yfilter;
}
if(value_path == "udf15Mask")
{
udf15mask.yfilter = yfilter;
}
if(value_path == "udf16Name")
{
udf16name.yfilter = yfilter;
}
if(value_path == "udf16Val")
{
udf16val.yfilter = yfilter;
}
if(value_path == "udf16Mask")
{
udf16mask.yfilter = yfilter;
}
if(value_path == "udf17Name")
{
udf17name.yfilter = yfilter;
}
if(value_path == "udf17Val")
{
udf17val.yfilter = yfilter;
}
if(value_path == "udf17Mask")
{
udf17mask.yfilter = yfilter;
}
if(value_path == "udf18Name")
{
udf18name.yfilter = yfilter;
}
if(value_path == "udf18Val")
{
udf18val.yfilter = yfilter;
}
if(value_path == "udf18Mask")
{
udf18mask.yfilter = yfilter;
}
if(value_path == "upid")
{
upid.yfilter = yfilter;
}
}
bool System::AclItems::Ipv4Items::NameItems::ACLList::SeqItems::ACEList::UdfItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "udf1Name" || name == "udf1Val" || name == "udf1Mask" || name == "udf2Name" || name == "udf2Val" || name == "udf2Mask" || name == "udf3Name" || name == "udf3Val" || name == "udf3Mask" || name == "udf4Name" || name == "udf4Val" || name == "udf4Mask" || name == "udf5Name" || name == "udf5Val" || name == "udf5Mask" || name == "udf6Name" || name == "udf6Val" || name == "udf6Mask" || name == "udf7Name" || name == "udf7Val" || name == "udf7Mask" || name == "udf8Name" || name == "udf8Val" || name == "udf8Mask" || name == "udf9Name" || name == "udf9Val" || name == "udf9Mask" || name == "udf10Name" || name == "udf10Val" || name == "udf10Mask" || name == "udf11Name" || name == "udf11Val" || name == "udf11Mask" || name == "udf12Name" || name == "udf12Val" || name == "udf12Mask" || name == "udf13Name" || name == "udf13Val" || name == "udf13Mask" || name == "udf14Name" || name == "udf14Val" || name == "udf14Mask" || name == "udf15Name" || name == "udf15Val" || name == "udf15Mask" || name == "udf16Name" || name == "udf16Val" || name == "udf16Mask" || name == "udf17Name" || name == "udf17Val" || name == "udf17Mask" || name == "udf18Name" || name == "udf18Val" || name == "udf18Mask" || name == "upid")
return true;
return false;
}
System::AclItems::Ipv4Items::ONameItems::ONameItems()
:
addrgroup_list(this, {"name"})
{
yang_name = "oName-items"; yang_parent_name = "ipv4-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::AclItems::Ipv4Items::ONameItems::~ONameItems()
{
}
bool System::AclItems::Ipv4Items::ONameItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<addrgroup_list.len(); index++)
{
if(addrgroup_list[index]->has_data())
return true;
}
return false;
}
bool System::AclItems::Ipv4Items::ONameItems::has_operation() const
{
for (std::size_t index=0; index<addrgroup_list.len(); index++)
{
if(addrgroup_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AclItems::Ipv4Items::ONameItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/acl-items/ipv4-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::AclItems::Ipv4Items::ONameItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "oName-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv4Items::ONameItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv4Items::ONameItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "AddrGroup-list")
{
auto ent_ = std::make_shared<System::AclItems::Ipv4Items::ONameItems::AddrGroupList>();
ent_->parent = this;
addrgroup_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv4Items::ONameItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : addrgroup_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AclItems::Ipv4Items::ONameItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AclItems::Ipv4Items::ONameItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AclItems::Ipv4Items::ONameItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "AddrGroup-list")
return true;
return false;
}
System::AclItems::Ipv4Items::ONameItems::AddrGroupList::AddrGroupList()
:
name{YType::str, "name"},
upid{YType::uint32, "upid"}
,
seq_items(std::make_shared<System::AclItems::Ipv4Items::ONameItems::AddrGroupList::SeqItems>())
{
seq_items->parent = this;
yang_name = "AddrGroup-list"; yang_parent_name = "oName-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::AclItems::Ipv4Items::ONameItems::AddrGroupList::~AddrGroupList()
{
}
bool System::AclItems::Ipv4Items::ONameItems::AddrGroupList::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| upid.is_set
|| (seq_items != nullptr && seq_items->has_data());
}
bool System::AclItems::Ipv4Items::ONameItems::AddrGroupList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(upid.yfilter)
|| (seq_items != nullptr && seq_items->has_operation());
}
std::string System::AclItems::Ipv4Items::ONameItems::AddrGroupList::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/acl-items/ipv4-items/oName-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::AclItems::Ipv4Items::ONameItems::AddrGroupList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "AddrGroup-list";
ADD_KEY_TOKEN(name, "name");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv4Items::ONameItems::AddrGroupList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (upid.is_set || is_set(upid.yfilter)) leaf_name_data.push_back(upid.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv4Items::ONameItems::AddrGroupList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "seq-items")
{
if(seq_items == nullptr)
{
seq_items = std::make_shared<System::AclItems::Ipv4Items::ONameItems::AddrGroupList::SeqItems>();
}
return seq_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv4Items::ONameItems::AddrGroupList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(seq_items != nullptr)
{
_children["seq-items"] = seq_items;
}
return _children;
}
void System::AclItems::Ipv4Items::ONameItems::AddrGroupList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "upid")
{
upid = value;
upid.value_namespace = name_space;
upid.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv4Items::ONameItems::AddrGroupList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "upid")
{
upid.yfilter = yfilter;
}
}
bool System::AclItems::Ipv4Items::ONameItems::AddrGroupList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "seq-items" || name == "name" || name == "upid")
return true;
return false;
}
System::AclItems::Ipv4Items::ONameItems::AddrGroupList::SeqItems::SeqItems()
:
addrmember_list(this, {"seqnum"})
{
yang_name = "seq-items"; yang_parent_name = "AddrGroup-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AclItems::Ipv4Items::ONameItems::AddrGroupList::SeqItems::~SeqItems()
{
}
bool System::AclItems::Ipv4Items::ONameItems::AddrGroupList::SeqItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<addrmember_list.len(); index++)
{
if(addrmember_list[index]->has_data())
return true;
}
return false;
}
bool System::AclItems::Ipv4Items::ONameItems::AddrGroupList::SeqItems::has_operation() const
{
for (std::size_t index=0; index<addrmember_list.len(); index++)
{
if(addrmember_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AclItems::Ipv4Items::ONameItems::AddrGroupList::SeqItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "seq-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv4Items::ONameItems::AddrGroupList::SeqItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv4Items::ONameItems::AddrGroupList::SeqItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "AddrMember-list")
{
auto ent_ = std::make_shared<System::AclItems::Ipv4Items::ONameItems::AddrGroupList::SeqItems::AddrMemberList>();
ent_->parent = this;
addrmember_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv4Items::ONameItems::AddrGroupList::SeqItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : addrmember_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AclItems::Ipv4Items::ONameItems::AddrGroupList::SeqItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AclItems::Ipv4Items::ONameItems::AddrGroupList::SeqItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AclItems::Ipv4Items::ONameItems::AddrGroupList::SeqItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "AddrMember-list")
return true;
return false;
}
System::AclItems::Ipv4Items::ONameItems::AddrGroupList::SeqItems::AddrMemberList::AddrMemberList()
:
seqnum{YType::uint32, "seqNum"},
prefix{YType::str, "prefix"},
prefixmask{YType::str, "prefixMask"},
prefixlength{YType::uint8, "prefixLength"},
configstatus{YType::uint8, "configStatus"},
upid{YType::uint32, "upid"}
{
yang_name = "AddrMember-list"; yang_parent_name = "seq-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::AclItems::Ipv4Items::ONameItems::AddrGroupList::SeqItems::AddrMemberList::~AddrMemberList()
{
}
bool System::AclItems::Ipv4Items::ONameItems::AddrGroupList::SeqItems::AddrMemberList::has_data() const
{
if (is_presence_container) return true;
return seqnum.is_set
|| prefix.is_set
|| prefixmask.is_set
|| prefixlength.is_set
|| configstatus.is_set
|| upid.is_set;
}
bool System::AclItems::Ipv4Items::ONameItems::AddrGroupList::SeqItems::AddrMemberList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(seqnum.yfilter)
|| ydk::is_set(prefix.yfilter)
|| ydk::is_set(prefixmask.yfilter)
|| ydk::is_set(prefixlength.yfilter)
|| ydk::is_set(configstatus.yfilter)
|| ydk::is_set(upid.yfilter);
}
std::string System::AclItems::Ipv4Items::ONameItems::AddrGroupList::SeqItems::AddrMemberList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "AddrMember-list";
ADD_KEY_TOKEN(seqnum, "seqNum");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv4Items::ONameItems::AddrGroupList::SeqItems::AddrMemberList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (seqnum.is_set || is_set(seqnum.yfilter)) leaf_name_data.push_back(seqnum.get_name_leafdata());
if (prefix.is_set || is_set(prefix.yfilter)) leaf_name_data.push_back(prefix.get_name_leafdata());
if (prefixmask.is_set || is_set(prefixmask.yfilter)) leaf_name_data.push_back(prefixmask.get_name_leafdata());
if (prefixlength.is_set || is_set(prefixlength.yfilter)) leaf_name_data.push_back(prefixlength.get_name_leafdata());
if (configstatus.is_set || is_set(configstatus.yfilter)) leaf_name_data.push_back(configstatus.get_name_leafdata());
if (upid.is_set || is_set(upid.yfilter)) leaf_name_data.push_back(upid.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv4Items::ONameItems::AddrGroupList::SeqItems::AddrMemberList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv4Items::ONameItems::AddrGroupList::SeqItems::AddrMemberList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AclItems::Ipv4Items::ONameItems::AddrGroupList::SeqItems::AddrMemberList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "seqNum")
{
seqnum = value;
seqnum.value_namespace = name_space;
seqnum.value_namespace_prefix = name_space_prefix;
}
if(value_path == "prefix")
{
prefix = value;
prefix.value_namespace = name_space;
prefix.value_namespace_prefix = name_space_prefix;
}
if(value_path == "prefixMask")
{
prefixmask = value;
prefixmask.value_namespace = name_space;
prefixmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "prefixLength")
{
prefixlength = value;
prefixlength.value_namespace = name_space;
prefixlength.value_namespace_prefix = name_space_prefix;
}
if(value_path == "configStatus")
{
configstatus = value;
configstatus.value_namespace = name_space;
configstatus.value_namespace_prefix = name_space_prefix;
}
if(value_path == "upid")
{
upid = value;
upid.value_namespace = name_space;
upid.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv4Items::ONameItems::AddrGroupList::SeqItems::AddrMemberList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "seqNum")
{
seqnum.yfilter = yfilter;
}
if(value_path == "prefix")
{
prefix.yfilter = yfilter;
}
if(value_path == "prefixMask")
{
prefixmask.yfilter = yfilter;
}
if(value_path == "prefixLength")
{
prefixlength.yfilter = yfilter;
}
if(value_path == "configStatus")
{
configstatus.yfilter = yfilter;
}
if(value_path == "upid")
{
upid.yfilter = yfilter;
}
}
bool System::AclItems::Ipv4Items::ONameItems::AddrGroupList::SeqItems::AddrMemberList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "seqNum" || name == "prefix" || name == "prefixMask" || name == "prefixLength" || name == "configStatus" || name == "upid")
return true;
return false;
}
System::AclItems::Ipv6Items::Ipv6Items()
:
upid{YType::uint32, "upid"}
,
statclear_items(std::make_shared<System::AclItems::Ipv6Items::StatClearItems>())
, policy_items(std::make_shared<System::AclItems::Ipv6Items::PolicyItems>())
, name_items(std::make_shared<System::AclItems::Ipv6Items::NameItems>())
, oname_items(std::make_shared<System::AclItems::Ipv6Items::ONameItems>())
{
statclear_items->parent = this;
policy_items->parent = this;
name_items->parent = this;
oname_items->parent = this;
yang_name = "ipv6-items"; yang_parent_name = "acl-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::AclItems::Ipv6Items::~Ipv6Items()
{
}
bool System::AclItems::Ipv6Items::has_data() const
{
if (is_presence_container) return true;
return upid.is_set
|| (statclear_items != nullptr && statclear_items->has_data())
|| (policy_items != nullptr && policy_items->has_data())
|| (name_items != nullptr && name_items->has_data())
|| (oname_items != nullptr && oname_items->has_data());
}
bool System::AclItems::Ipv6Items::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(upid.yfilter)
|| (statclear_items != nullptr && statclear_items->has_operation())
|| (policy_items != nullptr && policy_items->has_operation())
|| (name_items != nullptr && name_items->has_operation())
|| (oname_items != nullptr && oname_items->has_operation());
}
std::string System::AclItems::Ipv6Items::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/acl-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::AclItems::Ipv6Items::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "ipv6-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (upid.is_set || is_set(upid.yfilter)) leaf_name_data.push_back(upid.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "statClear-items")
{
if(statclear_items == nullptr)
{
statclear_items = std::make_shared<System::AclItems::Ipv6Items::StatClearItems>();
}
return statclear_items;
}
if(child_yang_name == "policy-items")
{
if(policy_items == nullptr)
{
policy_items = std::make_shared<System::AclItems::Ipv6Items::PolicyItems>();
}
return policy_items;
}
if(child_yang_name == "name-items")
{
if(name_items == nullptr)
{
name_items = std::make_shared<System::AclItems::Ipv6Items::NameItems>();
}
return name_items;
}
if(child_yang_name == "oName-items")
{
if(oname_items == nullptr)
{
oname_items = std::make_shared<System::AclItems::Ipv6Items::ONameItems>();
}
return oname_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(statclear_items != nullptr)
{
_children["statClear-items"] = statclear_items;
}
if(policy_items != nullptr)
{
_children["policy-items"] = policy_items;
}
if(name_items != nullptr)
{
_children["name-items"] = name_items;
}
if(oname_items != nullptr)
{
_children["oName-items"] = oname_items;
}
return _children;
}
void System::AclItems::Ipv6Items::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "upid")
{
upid = value;
upid.value_namespace = name_space;
upid.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv6Items::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "upid")
{
upid.yfilter = yfilter;
}
}
bool System::AclItems::Ipv6Items::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "statClear-items" || name == "policy-items" || name == "name-items" || name == "oName-items" || name == "upid")
return true;
return false;
}
System::AclItems::Ipv6Items::StatClearItems::StatClearItems()
:
name{YType::str, "name"},
timestamp{YType::str, "timeStamp"}
{
yang_name = "statClear-items"; yang_parent_name = "ipv6-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::AclItems::Ipv6Items::StatClearItems::~StatClearItems()
{
}
bool System::AclItems::Ipv6Items::StatClearItems::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| timestamp.is_set;
}
bool System::AclItems::Ipv6Items::StatClearItems::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(timestamp.yfilter);
}
std::string System::AclItems::Ipv6Items::StatClearItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/acl-items/ipv6-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::AclItems::Ipv6Items::StatClearItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "statClear-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::StatClearItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (timestamp.is_set || is_set(timestamp.yfilter)) leaf_name_data.push_back(timestamp.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::StatClearItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::StatClearItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AclItems::Ipv6Items::StatClearItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "timeStamp")
{
timestamp = value;
timestamp.value_namespace = name_space;
timestamp.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv6Items::StatClearItems::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "timeStamp")
{
timestamp.yfilter = yfilter;
}
}
bool System::AclItems::Ipv6Items::StatClearItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "name" || name == "timeStamp")
return true;
return false;
}
System::AclItems::Ipv6Items::PolicyItems::PolicyItems()
:
upid{YType::uint32, "upid"}
,
ingress_items(std::make_shared<System::AclItems::Ipv6Items::PolicyItems::IngressItems>())
, egress_items(std::make_shared<System::AclItems::Ipv6Items::PolicyItems::EgressItems>())
{
ingress_items->parent = this;
egress_items->parent = this;
yang_name = "policy-items"; yang_parent_name = "ipv6-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::AclItems::Ipv6Items::PolicyItems::~PolicyItems()
{
}
bool System::AclItems::Ipv6Items::PolicyItems::has_data() const
{
if (is_presence_container) return true;
return upid.is_set
|| (ingress_items != nullptr && ingress_items->has_data())
|| (egress_items != nullptr && egress_items->has_data());
}
bool System::AclItems::Ipv6Items::PolicyItems::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(upid.yfilter)
|| (ingress_items != nullptr && ingress_items->has_operation())
|| (egress_items != nullptr && egress_items->has_operation());
}
std::string System::AclItems::Ipv6Items::PolicyItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/acl-items/ipv6-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::AclItems::Ipv6Items::PolicyItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "policy-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::PolicyItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (upid.is_set || is_set(upid.yfilter)) leaf_name_data.push_back(upid.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::PolicyItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "ingress-items")
{
if(ingress_items == nullptr)
{
ingress_items = std::make_shared<System::AclItems::Ipv6Items::PolicyItems::IngressItems>();
}
return ingress_items;
}
if(child_yang_name == "egress-items")
{
if(egress_items == nullptr)
{
egress_items = std::make_shared<System::AclItems::Ipv6Items::PolicyItems::EgressItems>();
}
return egress_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::PolicyItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(ingress_items != nullptr)
{
_children["ingress-items"] = ingress_items;
}
if(egress_items != nullptr)
{
_children["egress-items"] = egress_items;
}
return _children;
}
void System::AclItems::Ipv6Items::PolicyItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "upid")
{
upid = value;
upid.value_namespace = name_space;
upid.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv6Items::PolicyItems::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "upid")
{
upid.yfilter = yfilter;
}
}
bool System::AclItems::Ipv6Items::PolicyItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "ingress-items" || name == "egress-items" || name == "upid")
return true;
return false;
}
System::AclItems::Ipv6Items::PolicyItems::IngressItems::IngressItems()
:
upid{YType::uint32, "upid"}
,
intf_items(std::make_shared<System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems>())
, vty_items(std::make_shared<System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems>())
{
intf_items->parent = this;
vty_items->parent = this;
yang_name = "ingress-items"; yang_parent_name = "policy-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::AclItems::Ipv6Items::PolicyItems::IngressItems::~IngressItems()
{
}
bool System::AclItems::Ipv6Items::PolicyItems::IngressItems::has_data() const
{
if (is_presence_container) return true;
return upid.is_set
|| (intf_items != nullptr && intf_items->has_data())
|| (vty_items != nullptr && vty_items->has_data());
}
bool System::AclItems::Ipv6Items::PolicyItems::IngressItems::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(upid.yfilter)
|| (intf_items != nullptr && intf_items->has_operation())
|| (vty_items != nullptr && vty_items->has_operation());
}
std::string System::AclItems::Ipv6Items::PolicyItems::IngressItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/acl-items/ipv6-items/policy-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::AclItems::Ipv6Items::PolicyItems::IngressItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "ingress-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::PolicyItems::IngressItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (upid.is_set || is_set(upid.yfilter)) leaf_name_data.push_back(upid.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::PolicyItems::IngressItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "intf-items")
{
if(intf_items == nullptr)
{
intf_items = std::make_shared<System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems>();
}
return intf_items;
}
if(child_yang_name == "vty-items")
{
if(vty_items == nullptr)
{
vty_items = std::make_shared<System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems>();
}
return vty_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::PolicyItems::IngressItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(intf_items != nullptr)
{
_children["intf-items"] = intf_items;
}
if(vty_items != nullptr)
{
_children["vty-items"] = vty_items;
}
return _children;
}
void System::AclItems::Ipv6Items::PolicyItems::IngressItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "upid")
{
upid = value;
upid.value_namespace = name_space;
upid.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv6Items::PolicyItems::IngressItems::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "upid")
{
upid.yfilter = yfilter;
}
}
bool System::AclItems::Ipv6Items::PolicyItems::IngressItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "intf-items" || name == "vty-items" || name == "upid")
return true;
return false;
}
System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IntfItems()
:
if_list(this, {"name"})
{
yang_name = "intf-items"; yang_parent_name = "ingress-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::~IntfItems()
{
}
bool System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<if_list.len(); index++)
{
if(if_list[index]->has_data())
return true;
}
return false;
}
bool System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::has_operation() const
{
for (std::size_t index=0; index<if_list.len(); index++)
{
if(if_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/acl-items/ipv6-items/policy-items/ingress-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "intf-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "If-list")
{
auto ent_ = std::make_shared<System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList>();
ent_->parent = this;
if_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : if_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "If-list")
return true;
return false;
}
System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::IfList()
:
name{YType::str, "name"},
upid{YType::uint32, "upid"}
,
acl_items(std::make_shared<System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::AclItems_>())
, portacl_items(std::make_shared<System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::PortaclItems>())
{
acl_items->parent = this;
portacl_items->parent = this;
yang_name = "If-list"; yang_parent_name = "intf-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::~IfList()
{
}
bool System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| upid.is_set
|| (acl_items != nullptr && acl_items->has_data())
|| (portacl_items != nullptr && portacl_items->has_data());
}
bool System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(upid.yfilter)
|| (acl_items != nullptr && acl_items->has_operation())
|| (portacl_items != nullptr && portacl_items->has_operation());
}
std::string System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/acl-items/ipv6-items/policy-items/ingress-items/intf-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "If-list";
ADD_KEY_TOKEN(name, "name");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (upid.is_set || is_set(upid.yfilter)) leaf_name_data.push_back(upid.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "acl-items")
{
if(acl_items == nullptr)
{
acl_items = std::make_shared<System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::AclItems_>();
}
return acl_items;
}
if(child_yang_name == "portacl-items")
{
if(portacl_items == nullptr)
{
portacl_items = std::make_shared<System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::PortaclItems>();
}
return portacl_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(acl_items != nullptr)
{
_children["acl-items"] = acl_items;
}
if(portacl_items != nullptr)
{
_children["portacl-items"] = portacl_items;
}
return _children;
}
void System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "upid")
{
upid = value;
upid.value_namespace = name_space;
upid.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "upid")
{
upid.yfilter = yfilter;
}
}
bool System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "acl-items" || name == "portacl-items" || name == "name" || name == "upid")
return true;
return false;
}
System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::AclItems_::AclItems_()
:
name{YType::str, "name"},
configstatus{YType::uint32, "configStatus"},
upid{YType::uint32, "upid"}
{
yang_name = "acl-items"; yang_parent_name = "If-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::AclItems_::~AclItems_()
{
}
bool System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::AclItems_::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| configstatus.is_set
|| upid.is_set;
}
bool System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::AclItems_::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(configstatus.yfilter)
|| ydk::is_set(upid.yfilter);
}
std::string System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::AclItems_::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "acl-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::AclItems_::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (configstatus.is_set || is_set(configstatus.yfilter)) leaf_name_data.push_back(configstatus.get_name_leafdata());
if (upid.is_set || is_set(upid.yfilter)) leaf_name_data.push_back(upid.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::AclItems_::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::AclItems_::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::AclItems_::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "configStatus")
{
configstatus = value;
configstatus.value_namespace = name_space;
configstatus.value_namespace_prefix = name_space_prefix;
}
if(value_path == "upid")
{
upid = value;
upid.value_namespace = name_space;
upid.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::AclItems_::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "configStatus")
{
configstatus.yfilter = yfilter;
}
if(value_path == "upid")
{
upid.yfilter = yfilter;
}
}
bool System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::AclItems_::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "name" || name == "configStatus" || name == "upid")
return true;
return false;
}
System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::PortaclItems::PortaclItems()
:
name{YType::str, "name"},
configstatus{YType::uint32, "configStatus"},
upid{YType::uint32, "upid"}
{
yang_name = "portacl-items"; yang_parent_name = "If-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::PortaclItems::~PortaclItems()
{
}
bool System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::PortaclItems::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| configstatus.is_set
|| upid.is_set;
}
bool System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::PortaclItems::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(configstatus.yfilter)
|| ydk::is_set(upid.yfilter);
}
std::string System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::PortaclItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "portacl-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::PortaclItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (configstatus.is_set || is_set(configstatus.yfilter)) leaf_name_data.push_back(configstatus.get_name_leafdata());
if (upid.is_set || is_set(upid.yfilter)) leaf_name_data.push_back(upid.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::PortaclItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::PortaclItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::PortaclItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "configStatus")
{
configstatus = value;
configstatus.value_namespace = name_space;
configstatus.value_namespace_prefix = name_space_prefix;
}
if(value_path == "upid")
{
upid = value;
upid.value_namespace = name_space;
upid.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::PortaclItems::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "configStatus")
{
configstatus.yfilter = yfilter;
}
if(value_path == "upid")
{
upid.yfilter = yfilter;
}
}
bool System::AclItems::Ipv6Items::PolicyItems::IngressItems::IntfItems::IfList::PortaclItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "name" || name == "configStatus" || name == "upid")
return true;
return false;
}
System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::VtyItems()
:
upid{YType::uint32, "upid"}
,
acl_items(std::make_shared<System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::AclItems_>())
{
acl_items->parent = this;
yang_name = "vty-items"; yang_parent_name = "ingress-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::~VtyItems()
{
}
bool System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::has_data() const
{
if (is_presence_container) return true;
return upid.is_set
|| (acl_items != nullptr && acl_items->has_data());
}
bool System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(upid.yfilter)
|| (acl_items != nullptr && acl_items->has_operation());
}
std::string System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/acl-items/ipv6-items/policy-items/ingress-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "vty-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (upid.is_set || is_set(upid.yfilter)) leaf_name_data.push_back(upid.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "acl-items")
{
if(acl_items == nullptr)
{
acl_items = std::make_shared<System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::AclItems_>();
}
return acl_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(acl_items != nullptr)
{
_children["acl-items"] = acl_items;
}
return _children;
}
void System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "upid")
{
upid = value;
upid.value_namespace = name_space;
upid.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "upid")
{
upid.yfilter = yfilter;
}
}
bool System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "acl-items" || name == "upid")
return true;
return false;
}
System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::AclItems_::AclItems_()
:
name{YType::str, "name"},
configstatus{YType::uint32, "configStatus"},
upid{YType::uint32, "upid"}
{
yang_name = "acl-items"; yang_parent_name = "vty-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::AclItems_::~AclItems_()
{
}
bool System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::AclItems_::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| configstatus.is_set
|| upid.is_set;
}
bool System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::AclItems_::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(configstatus.yfilter)
|| ydk::is_set(upid.yfilter);
}
std::string System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::AclItems_::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/acl-items/ipv6-items/policy-items/ingress-items/vty-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::AclItems_::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "acl-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::AclItems_::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (configstatus.is_set || is_set(configstatus.yfilter)) leaf_name_data.push_back(configstatus.get_name_leafdata());
if (upid.is_set || is_set(upid.yfilter)) leaf_name_data.push_back(upid.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::AclItems_::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::AclItems_::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::AclItems_::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "configStatus")
{
configstatus = value;
configstatus.value_namespace = name_space;
configstatus.value_namespace_prefix = name_space_prefix;
}
if(value_path == "upid")
{
upid = value;
upid.value_namespace = name_space;
upid.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::AclItems_::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "configStatus")
{
configstatus.yfilter = yfilter;
}
if(value_path == "upid")
{
upid.yfilter = yfilter;
}
}
bool System::AclItems::Ipv6Items::PolicyItems::IngressItems::VtyItems::AclItems_::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "name" || name == "configStatus" || name == "upid")
return true;
return false;
}
System::AclItems::Ipv6Items::PolicyItems::EgressItems::EgressItems()
:
upid{YType::uint32, "upid"}
,
intf_items(std::make_shared<System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems>())
, vty_items(std::make_shared<System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems>())
{
intf_items->parent = this;
vty_items->parent = this;
yang_name = "egress-items"; yang_parent_name = "policy-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::AclItems::Ipv6Items::PolicyItems::EgressItems::~EgressItems()
{
}
bool System::AclItems::Ipv6Items::PolicyItems::EgressItems::has_data() const
{
if (is_presence_container) return true;
return upid.is_set
|| (intf_items != nullptr && intf_items->has_data())
|| (vty_items != nullptr && vty_items->has_data());
}
bool System::AclItems::Ipv6Items::PolicyItems::EgressItems::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(upid.yfilter)
|| (intf_items != nullptr && intf_items->has_operation())
|| (vty_items != nullptr && vty_items->has_operation());
}
std::string System::AclItems::Ipv6Items::PolicyItems::EgressItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/acl-items/ipv6-items/policy-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::AclItems::Ipv6Items::PolicyItems::EgressItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "egress-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::PolicyItems::EgressItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (upid.is_set || is_set(upid.yfilter)) leaf_name_data.push_back(upid.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::PolicyItems::EgressItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "intf-items")
{
if(intf_items == nullptr)
{
intf_items = std::make_shared<System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems>();
}
return intf_items;
}
if(child_yang_name == "vty-items")
{
if(vty_items == nullptr)
{
vty_items = std::make_shared<System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems>();
}
return vty_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::PolicyItems::EgressItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(intf_items != nullptr)
{
_children["intf-items"] = intf_items;
}
if(vty_items != nullptr)
{
_children["vty-items"] = vty_items;
}
return _children;
}
void System::AclItems::Ipv6Items::PolicyItems::EgressItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "upid")
{
upid = value;
upid.value_namespace = name_space;
upid.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv6Items::PolicyItems::EgressItems::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "upid")
{
upid.yfilter = yfilter;
}
}
bool System::AclItems::Ipv6Items::PolicyItems::EgressItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "intf-items" || name == "vty-items" || name == "upid")
return true;
return false;
}
System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IntfItems()
:
if_list(this, {"name"})
{
yang_name = "intf-items"; yang_parent_name = "egress-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::~IntfItems()
{
}
bool System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<if_list.len(); index++)
{
if(if_list[index]->has_data())
return true;
}
return false;
}
bool System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::has_operation() const
{
for (std::size_t index=0; index<if_list.len(); index++)
{
if(if_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/acl-items/ipv6-items/policy-items/egress-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "intf-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "If-list")
{
auto ent_ = std::make_shared<System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList>();
ent_->parent = this;
if_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : if_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "If-list")
return true;
return false;
}
System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::IfList()
:
name{YType::str, "name"},
upid{YType::uint32, "upid"}
,
acl_items(std::make_shared<System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::AclItems_>())
, portacl_items(std::make_shared<System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::PortaclItems>())
{
acl_items->parent = this;
portacl_items->parent = this;
yang_name = "If-list"; yang_parent_name = "intf-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::~IfList()
{
}
bool System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| upid.is_set
|| (acl_items != nullptr && acl_items->has_data())
|| (portacl_items != nullptr && portacl_items->has_data());
}
bool System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(upid.yfilter)
|| (acl_items != nullptr && acl_items->has_operation())
|| (portacl_items != nullptr && portacl_items->has_operation());
}
std::string System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/acl-items/ipv6-items/policy-items/egress-items/intf-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "If-list";
ADD_KEY_TOKEN(name, "name");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (upid.is_set || is_set(upid.yfilter)) leaf_name_data.push_back(upid.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "acl-items")
{
if(acl_items == nullptr)
{
acl_items = std::make_shared<System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::AclItems_>();
}
return acl_items;
}
if(child_yang_name == "portacl-items")
{
if(portacl_items == nullptr)
{
portacl_items = std::make_shared<System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::PortaclItems>();
}
return portacl_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(acl_items != nullptr)
{
_children["acl-items"] = acl_items;
}
if(portacl_items != nullptr)
{
_children["portacl-items"] = portacl_items;
}
return _children;
}
void System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "upid")
{
upid = value;
upid.value_namespace = name_space;
upid.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "upid")
{
upid.yfilter = yfilter;
}
}
bool System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "acl-items" || name == "portacl-items" || name == "name" || name == "upid")
return true;
return false;
}
System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::AclItems_::AclItems_()
:
name{YType::str, "name"},
configstatus{YType::uint32, "configStatus"},
upid{YType::uint32, "upid"}
{
yang_name = "acl-items"; yang_parent_name = "If-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::AclItems_::~AclItems_()
{
}
bool System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::AclItems_::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| configstatus.is_set
|| upid.is_set;
}
bool System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::AclItems_::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(configstatus.yfilter)
|| ydk::is_set(upid.yfilter);
}
std::string System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::AclItems_::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "acl-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::AclItems_::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (configstatus.is_set || is_set(configstatus.yfilter)) leaf_name_data.push_back(configstatus.get_name_leafdata());
if (upid.is_set || is_set(upid.yfilter)) leaf_name_data.push_back(upid.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::AclItems_::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::AclItems_::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::AclItems_::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "configStatus")
{
configstatus = value;
configstatus.value_namespace = name_space;
configstatus.value_namespace_prefix = name_space_prefix;
}
if(value_path == "upid")
{
upid = value;
upid.value_namespace = name_space;
upid.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::AclItems_::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "configStatus")
{
configstatus.yfilter = yfilter;
}
if(value_path == "upid")
{
upid.yfilter = yfilter;
}
}
bool System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::AclItems_::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "name" || name == "configStatus" || name == "upid")
return true;
return false;
}
System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::PortaclItems::PortaclItems()
:
name{YType::str, "name"},
configstatus{YType::uint32, "configStatus"},
upid{YType::uint32, "upid"}
{
yang_name = "portacl-items"; yang_parent_name = "If-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::PortaclItems::~PortaclItems()
{
}
bool System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::PortaclItems::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| configstatus.is_set
|| upid.is_set;
}
bool System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::PortaclItems::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(configstatus.yfilter)
|| ydk::is_set(upid.yfilter);
}
std::string System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::PortaclItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "portacl-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::PortaclItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (configstatus.is_set || is_set(configstatus.yfilter)) leaf_name_data.push_back(configstatus.get_name_leafdata());
if (upid.is_set || is_set(upid.yfilter)) leaf_name_data.push_back(upid.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::PortaclItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::PortaclItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::PortaclItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "configStatus")
{
configstatus = value;
configstatus.value_namespace = name_space;
configstatus.value_namespace_prefix = name_space_prefix;
}
if(value_path == "upid")
{
upid = value;
upid.value_namespace = name_space;
upid.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::PortaclItems::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "configStatus")
{
configstatus.yfilter = yfilter;
}
if(value_path == "upid")
{
upid.yfilter = yfilter;
}
}
bool System::AclItems::Ipv6Items::PolicyItems::EgressItems::IntfItems::IfList::PortaclItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "name" || name == "configStatus" || name == "upid")
return true;
return false;
}
System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::VtyItems()
:
upid{YType::uint32, "upid"}
,
acl_items(std::make_shared<System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::AclItems_>())
{
acl_items->parent = this;
yang_name = "vty-items"; yang_parent_name = "egress-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::~VtyItems()
{
}
bool System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::has_data() const
{
if (is_presence_container) return true;
return upid.is_set
|| (acl_items != nullptr && acl_items->has_data());
}
bool System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(upid.yfilter)
|| (acl_items != nullptr && acl_items->has_operation());
}
std::string System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/acl-items/ipv6-items/policy-items/egress-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "vty-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (upid.is_set || is_set(upid.yfilter)) leaf_name_data.push_back(upid.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "acl-items")
{
if(acl_items == nullptr)
{
acl_items = std::make_shared<System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::AclItems_>();
}
return acl_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(acl_items != nullptr)
{
_children["acl-items"] = acl_items;
}
return _children;
}
void System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "upid")
{
upid = value;
upid.value_namespace = name_space;
upid.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "upid")
{
upid.yfilter = yfilter;
}
}
bool System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "acl-items" || name == "upid")
return true;
return false;
}
System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::AclItems_::AclItems_()
:
name{YType::str, "name"},
configstatus{YType::uint32, "configStatus"},
upid{YType::uint32, "upid"}
{
yang_name = "acl-items"; yang_parent_name = "vty-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::AclItems_::~AclItems_()
{
}
bool System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::AclItems_::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| configstatus.is_set
|| upid.is_set;
}
bool System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::AclItems_::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(configstatus.yfilter)
|| ydk::is_set(upid.yfilter);
}
std::string System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::AclItems_::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/acl-items/ipv6-items/policy-items/egress-items/vty-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::AclItems_::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "acl-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::AclItems_::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (configstatus.is_set || is_set(configstatus.yfilter)) leaf_name_data.push_back(configstatus.get_name_leafdata());
if (upid.is_set || is_set(upid.yfilter)) leaf_name_data.push_back(upid.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::AclItems_::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::AclItems_::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::AclItems_::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "configStatus")
{
configstatus = value;
configstatus.value_namespace = name_space;
configstatus.value_namespace_prefix = name_space_prefix;
}
if(value_path == "upid")
{
upid = value;
upid.value_namespace = name_space;
upid.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::AclItems_::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "configStatus")
{
configstatus.yfilter = yfilter;
}
if(value_path == "upid")
{
upid.yfilter = yfilter;
}
}
bool System::AclItems::Ipv6Items::PolicyItems::EgressItems::VtyItems::AclItems_::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "name" || name == "configStatus" || name == "upid")
return true;
return false;
}
System::AclItems::Ipv6Items::NameItems::NameItems()
:
acl_list(this, {"name"})
{
yang_name = "name-items"; yang_parent_name = "ipv6-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::AclItems::Ipv6Items::NameItems::~NameItems()
{
}
bool System::AclItems::Ipv6Items::NameItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<acl_list.len(); index++)
{
if(acl_list[index]->has_data())
return true;
}
return false;
}
bool System::AclItems::Ipv6Items::NameItems::has_operation() const
{
for (std::size_t index=0; index<acl_list.len(); index++)
{
if(acl_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AclItems::Ipv6Items::NameItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/acl-items/ipv6-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::AclItems::Ipv6Items::NameItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "name-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::NameItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::NameItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "ACL-list")
{
auto ent_ = std::make_shared<System::AclItems::Ipv6Items::NameItems::ACLList>();
ent_->parent = this;
acl_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::NameItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : acl_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AclItems::Ipv6Items::NameItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AclItems::Ipv6Items::NameItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AclItems::Ipv6Items::NameItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "ACL-list")
return true;
return false;
}
System::AclItems::Ipv6Items::NameItems::ACLList::ACLList()
:
name{YType::str, "name"},
upid{YType::uint32, "upid"},
peracestatistics{YType::uint8, "perACEStatistics"},
configstatus{YType::uint32, "configStatus"}
,
reseq_items(std::make_shared<System::AclItems::Ipv6Items::NameItems::ACLList::ReseqItems>())
, seq_items(std::make_shared<System::AclItems::Ipv6Items::NameItems::ACLList::SeqItems>())
{
reseq_items->parent = this;
seq_items->parent = this;
yang_name = "ACL-list"; yang_parent_name = "name-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::AclItems::Ipv6Items::NameItems::ACLList::~ACLList()
{
}
bool System::AclItems::Ipv6Items::NameItems::ACLList::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| upid.is_set
|| peracestatistics.is_set
|| configstatus.is_set
|| (reseq_items != nullptr && reseq_items->has_data())
|| (seq_items != nullptr && seq_items->has_data());
}
bool System::AclItems::Ipv6Items::NameItems::ACLList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(upid.yfilter)
|| ydk::is_set(peracestatistics.yfilter)
|| ydk::is_set(configstatus.yfilter)
|| (reseq_items != nullptr && reseq_items->has_operation())
|| (seq_items != nullptr && seq_items->has_operation());
}
std::string System::AclItems::Ipv6Items::NameItems::ACLList::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/acl-items/ipv6-items/name-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::AclItems::Ipv6Items::NameItems::ACLList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "ACL-list";
ADD_KEY_TOKEN(name, "name");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::NameItems::ACLList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (upid.is_set || is_set(upid.yfilter)) leaf_name_data.push_back(upid.get_name_leafdata());
if (peracestatistics.is_set || is_set(peracestatistics.yfilter)) leaf_name_data.push_back(peracestatistics.get_name_leafdata());
if (configstatus.is_set || is_set(configstatus.yfilter)) leaf_name_data.push_back(configstatus.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::NameItems::ACLList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "reseq-items")
{
if(reseq_items == nullptr)
{
reseq_items = std::make_shared<System::AclItems::Ipv6Items::NameItems::ACLList::ReseqItems>();
}
return reseq_items;
}
if(child_yang_name == "seq-items")
{
if(seq_items == nullptr)
{
seq_items = std::make_shared<System::AclItems::Ipv6Items::NameItems::ACLList::SeqItems>();
}
return seq_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::NameItems::ACLList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(reseq_items != nullptr)
{
_children["reseq-items"] = reseq_items;
}
if(seq_items != nullptr)
{
_children["seq-items"] = seq_items;
}
return _children;
}
void System::AclItems::Ipv6Items::NameItems::ACLList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "upid")
{
upid = value;
upid.value_namespace = name_space;
upid.value_namespace_prefix = name_space_prefix;
}
if(value_path == "perACEStatistics")
{
peracestatistics = value;
peracestatistics.value_namespace = name_space;
peracestatistics.value_namespace_prefix = name_space_prefix;
}
if(value_path == "configStatus")
{
configstatus = value;
configstatus.value_namespace = name_space;
configstatus.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv6Items::NameItems::ACLList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "upid")
{
upid.yfilter = yfilter;
}
if(value_path == "perACEStatistics")
{
peracestatistics.yfilter = yfilter;
}
if(value_path == "configStatus")
{
configstatus.yfilter = yfilter;
}
}
bool System::AclItems::Ipv6Items::NameItems::ACLList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "reseq-items" || name == "seq-items" || name == "name" || name == "upid" || name == "perACEStatistics" || name == "configStatus")
return true;
return false;
}
System::AclItems::Ipv6Items::NameItems::ACLList::ReseqItems::ReseqItems()
:
start{YType::uint32, "start"},
step{YType::uint32, "step"}
{
yang_name = "reseq-items"; yang_parent_name = "ACL-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AclItems::Ipv6Items::NameItems::ACLList::ReseqItems::~ReseqItems()
{
}
bool System::AclItems::Ipv6Items::NameItems::ACLList::ReseqItems::has_data() const
{
if (is_presence_container) return true;
return start.is_set
|| step.is_set;
}
bool System::AclItems::Ipv6Items::NameItems::ACLList::ReseqItems::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(start.yfilter)
|| ydk::is_set(step.yfilter);
}
std::string System::AclItems::Ipv6Items::NameItems::ACLList::ReseqItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "reseq-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::NameItems::ACLList::ReseqItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (start.is_set || is_set(start.yfilter)) leaf_name_data.push_back(start.get_name_leafdata());
if (step.is_set || is_set(step.yfilter)) leaf_name_data.push_back(step.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::NameItems::ACLList::ReseqItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::NameItems::ACLList::ReseqItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AclItems::Ipv6Items::NameItems::ACLList::ReseqItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "start")
{
start = value;
start.value_namespace = name_space;
start.value_namespace_prefix = name_space_prefix;
}
if(value_path == "step")
{
step = value;
step.value_namespace = name_space;
step.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv6Items::NameItems::ACLList::ReseqItems::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "start")
{
start.yfilter = yfilter;
}
if(value_path == "step")
{
step.yfilter = yfilter;
}
}
bool System::AclItems::Ipv6Items::NameItems::ACLList::ReseqItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "start" || name == "step")
return true;
return false;
}
System::AclItems::Ipv6Items::NameItems::ACLList::SeqItems::SeqItems()
:
ace_list(this, {"seqnum"})
{
yang_name = "seq-items"; yang_parent_name = "ACL-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AclItems::Ipv6Items::NameItems::ACLList::SeqItems::~SeqItems()
{
}
bool System::AclItems::Ipv6Items::NameItems::ACLList::SeqItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<ace_list.len(); index++)
{
if(ace_list[index]->has_data())
return true;
}
return false;
}
bool System::AclItems::Ipv6Items::NameItems::ACLList::SeqItems::has_operation() const
{
for (std::size_t index=0; index<ace_list.len(); index++)
{
if(ace_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AclItems::Ipv6Items::NameItems::ACLList::SeqItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "seq-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::NameItems::ACLList::SeqItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::NameItems::ACLList::SeqItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "ACE-list")
{
auto ent_ = std::make_shared<System::AclItems::Ipv6Items::NameItems::ACLList::SeqItems::ACEList>();
ent_->parent = this;
ace_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::NameItems::ACLList::SeqItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : ace_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AclItems::Ipv6Items::NameItems::ACLList::SeqItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AclItems::Ipv6Items::NameItems::ACLList::SeqItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AclItems::Ipv6Items::NameItems::ACLList::SeqItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "ACE-list")
return true;
return false;
}
System::AclItems::Ipv6Items::NameItems::ACLList::SeqItems::ACEList::ACEList()
:
seqnum{YType::uint32, "seqNum"},
protocol{YType::uint8, "protocol"},
protocolmask{YType::uint8, "protocolMask"},
srcprefix{YType::str, "srcPrefix"},
srcprefixmask{YType::str, "srcPrefixMask"},
srcprefixlength{YType::uint8, "srcPrefixLength"},
dstprefix{YType::str, "dstPrefix"},
dstprefixmask{YType::str, "dstPrefixMask"},
dstprefixlength{YType::uint8, "dstPrefixLength"},
flowlabel{YType::uint32, "flowLabel"},
icmpstr{YType::uint16, "icmpStr"},
icmptype{YType::uint16, "icmpType"},
icmpcode{YType::uint16, "icmpCode"},
configstatus{YType::uint8, "configStatus"},
upid{YType::uint32, "upid"},
remark{YType::str, "remark"},
action{YType::enumeration, "action"},
srcportop{YType::uint8, "srcPortOp"},
srcport1{YType::uint16, "srcPort1"},
srcport2{YType::uint16, "srcPort2"},
srcportmask{YType::uint16, "srcPortMask"},
dstportop{YType::uint8, "dstPortOp"},
dstport1{YType::uint16, "dstPort1"},
dstport2{YType::uint16, "dstPort2"},
dstportmask{YType::uint16, "dstPortMask"},
logging{YType::boolean, "logging"},
dscp{YType::uint8, "dscp"},
pktlenop{YType::uint8, "pktLenOp"},
pktlen1{YType::uint16, "pktLen1"},
pktlen2{YType::uint16, "pktLen2"},
urg{YType::boolean, "urg"},
ack{YType::boolean, "ack"},
psh{YType::boolean, "psh"},
rst{YType::boolean, "rst"},
syn{YType::boolean, "syn"},
fin{YType::boolean, "fin"},
est{YType::boolean, "est"},
rev{YType::boolean, "rev"},
tcpflagsmask{YType::uint8, "tcpFlagsMask"},
packets{YType::uint64, "packets"},
fragment{YType::boolean, "fragment"},
capturesession{YType::uint16, "captureSession"},
httpoption{YType::enumeration, "httpOption"},
vni{YType::uint32, "vni"},
vlan{YType::uint32, "vlan"},
tcpoptionlength{YType::uint32, "tcpOptionLength"},
timerange{YType::str, "timeRange"},
srcaddrgroup{YType::str, "srcAddrGroup"},
dstaddrgroup{YType::str, "dstAddrGroup"},
srcportgroup{YType::str, "srcPortGroup"},
dstportgroup{YType::str, "dstPortGroup"},
redirect{YType::str, "redirect"}
{
yang_name = "ACE-list"; yang_parent_name = "seq-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::AclItems::Ipv6Items::NameItems::ACLList::SeqItems::ACEList::~ACEList()
{
}
bool System::AclItems::Ipv6Items::NameItems::ACLList::SeqItems::ACEList::has_data() const
{
if (is_presence_container) return true;
return seqnum.is_set
|| protocol.is_set
|| protocolmask.is_set
|| srcprefix.is_set
|| srcprefixmask.is_set
|| srcprefixlength.is_set
|| dstprefix.is_set
|| dstprefixmask.is_set
|| dstprefixlength.is_set
|| flowlabel.is_set
|| icmpstr.is_set
|| icmptype.is_set
|| icmpcode.is_set
|| configstatus.is_set
|| upid.is_set
|| remark.is_set
|| action.is_set
|| srcportop.is_set
|| srcport1.is_set
|| srcport2.is_set
|| srcportmask.is_set
|| dstportop.is_set
|| dstport1.is_set
|| dstport2.is_set
|| dstportmask.is_set
|| logging.is_set
|| dscp.is_set
|| pktlenop.is_set
|| pktlen1.is_set
|| pktlen2.is_set
|| urg.is_set
|| ack.is_set
|| psh.is_set
|| rst.is_set
|| syn.is_set
|| fin.is_set
|| est.is_set
|| rev.is_set
|| tcpflagsmask.is_set
|| packets.is_set
|| fragment.is_set
|| capturesession.is_set
|| httpoption.is_set
|| vni.is_set
|| vlan.is_set
|| tcpoptionlength.is_set
|| timerange.is_set
|| srcaddrgroup.is_set
|| dstaddrgroup.is_set
|| srcportgroup.is_set
|| dstportgroup.is_set
|| redirect.is_set;
}
bool System::AclItems::Ipv6Items::NameItems::ACLList::SeqItems::ACEList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(seqnum.yfilter)
|| ydk::is_set(protocol.yfilter)
|| ydk::is_set(protocolmask.yfilter)
|| ydk::is_set(srcprefix.yfilter)
|| ydk::is_set(srcprefixmask.yfilter)
|| ydk::is_set(srcprefixlength.yfilter)
|| ydk::is_set(dstprefix.yfilter)
|| ydk::is_set(dstprefixmask.yfilter)
|| ydk::is_set(dstprefixlength.yfilter)
|| ydk::is_set(flowlabel.yfilter)
|| ydk::is_set(icmpstr.yfilter)
|| ydk::is_set(icmptype.yfilter)
|| ydk::is_set(icmpcode.yfilter)
|| ydk::is_set(configstatus.yfilter)
|| ydk::is_set(upid.yfilter)
|| ydk::is_set(remark.yfilter)
|| ydk::is_set(action.yfilter)
|| ydk::is_set(srcportop.yfilter)
|| ydk::is_set(srcport1.yfilter)
|| ydk::is_set(srcport2.yfilter)
|| ydk::is_set(srcportmask.yfilter)
|| ydk::is_set(dstportop.yfilter)
|| ydk::is_set(dstport1.yfilter)
|| ydk::is_set(dstport2.yfilter)
|| ydk::is_set(dstportmask.yfilter)
|| ydk::is_set(logging.yfilter)
|| ydk::is_set(dscp.yfilter)
|| ydk::is_set(pktlenop.yfilter)
|| ydk::is_set(pktlen1.yfilter)
|| ydk::is_set(pktlen2.yfilter)
|| ydk::is_set(urg.yfilter)
|| ydk::is_set(ack.yfilter)
|| ydk::is_set(psh.yfilter)
|| ydk::is_set(rst.yfilter)
|| ydk::is_set(syn.yfilter)
|| ydk::is_set(fin.yfilter)
|| ydk::is_set(est.yfilter)
|| ydk::is_set(rev.yfilter)
|| ydk::is_set(tcpflagsmask.yfilter)
|| ydk::is_set(packets.yfilter)
|| ydk::is_set(fragment.yfilter)
|| ydk::is_set(capturesession.yfilter)
|| ydk::is_set(httpoption.yfilter)
|| ydk::is_set(vni.yfilter)
|| ydk::is_set(vlan.yfilter)
|| ydk::is_set(tcpoptionlength.yfilter)
|| ydk::is_set(timerange.yfilter)
|| ydk::is_set(srcaddrgroup.yfilter)
|| ydk::is_set(dstaddrgroup.yfilter)
|| ydk::is_set(srcportgroup.yfilter)
|| ydk::is_set(dstportgroup.yfilter)
|| ydk::is_set(redirect.yfilter);
}
std::string System::AclItems::Ipv6Items::NameItems::ACLList::SeqItems::ACEList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "ACE-list";
ADD_KEY_TOKEN(seqnum, "seqNum");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::NameItems::ACLList::SeqItems::ACEList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (seqnum.is_set || is_set(seqnum.yfilter)) leaf_name_data.push_back(seqnum.get_name_leafdata());
if (protocol.is_set || is_set(protocol.yfilter)) leaf_name_data.push_back(protocol.get_name_leafdata());
if (protocolmask.is_set || is_set(protocolmask.yfilter)) leaf_name_data.push_back(protocolmask.get_name_leafdata());
if (srcprefix.is_set || is_set(srcprefix.yfilter)) leaf_name_data.push_back(srcprefix.get_name_leafdata());
if (srcprefixmask.is_set || is_set(srcprefixmask.yfilter)) leaf_name_data.push_back(srcprefixmask.get_name_leafdata());
if (srcprefixlength.is_set || is_set(srcprefixlength.yfilter)) leaf_name_data.push_back(srcprefixlength.get_name_leafdata());
if (dstprefix.is_set || is_set(dstprefix.yfilter)) leaf_name_data.push_back(dstprefix.get_name_leafdata());
if (dstprefixmask.is_set || is_set(dstprefixmask.yfilter)) leaf_name_data.push_back(dstprefixmask.get_name_leafdata());
if (dstprefixlength.is_set || is_set(dstprefixlength.yfilter)) leaf_name_data.push_back(dstprefixlength.get_name_leafdata());
if (flowlabel.is_set || is_set(flowlabel.yfilter)) leaf_name_data.push_back(flowlabel.get_name_leafdata());
if (icmpstr.is_set || is_set(icmpstr.yfilter)) leaf_name_data.push_back(icmpstr.get_name_leafdata());
if (icmptype.is_set || is_set(icmptype.yfilter)) leaf_name_data.push_back(icmptype.get_name_leafdata());
if (icmpcode.is_set || is_set(icmpcode.yfilter)) leaf_name_data.push_back(icmpcode.get_name_leafdata());
if (configstatus.is_set || is_set(configstatus.yfilter)) leaf_name_data.push_back(configstatus.get_name_leafdata());
if (upid.is_set || is_set(upid.yfilter)) leaf_name_data.push_back(upid.get_name_leafdata());
if (remark.is_set || is_set(remark.yfilter)) leaf_name_data.push_back(remark.get_name_leafdata());
if (action.is_set || is_set(action.yfilter)) leaf_name_data.push_back(action.get_name_leafdata());
if (srcportop.is_set || is_set(srcportop.yfilter)) leaf_name_data.push_back(srcportop.get_name_leafdata());
if (srcport1.is_set || is_set(srcport1.yfilter)) leaf_name_data.push_back(srcport1.get_name_leafdata());
if (srcport2.is_set || is_set(srcport2.yfilter)) leaf_name_data.push_back(srcport2.get_name_leafdata());
if (srcportmask.is_set || is_set(srcportmask.yfilter)) leaf_name_data.push_back(srcportmask.get_name_leafdata());
if (dstportop.is_set || is_set(dstportop.yfilter)) leaf_name_data.push_back(dstportop.get_name_leafdata());
if (dstport1.is_set || is_set(dstport1.yfilter)) leaf_name_data.push_back(dstport1.get_name_leafdata());
if (dstport2.is_set || is_set(dstport2.yfilter)) leaf_name_data.push_back(dstport2.get_name_leafdata());
if (dstportmask.is_set || is_set(dstportmask.yfilter)) leaf_name_data.push_back(dstportmask.get_name_leafdata());
if (logging.is_set || is_set(logging.yfilter)) leaf_name_data.push_back(logging.get_name_leafdata());
if (dscp.is_set || is_set(dscp.yfilter)) leaf_name_data.push_back(dscp.get_name_leafdata());
if (pktlenop.is_set || is_set(pktlenop.yfilter)) leaf_name_data.push_back(pktlenop.get_name_leafdata());
if (pktlen1.is_set || is_set(pktlen1.yfilter)) leaf_name_data.push_back(pktlen1.get_name_leafdata());
if (pktlen2.is_set || is_set(pktlen2.yfilter)) leaf_name_data.push_back(pktlen2.get_name_leafdata());
if (urg.is_set || is_set(urg.yfilter)) leaf_name_data.push_back(urg.get_name_leafdata());
if (ack.is_set || is_set(ack.yfilter)) leaf_name_data.push_back(ack.get_name_leafdata());
if (psh.is_set || is_set(psh.yfilter)) leaf_name_data.push_back(psh.get_name_leafdata());
if (rst.is_set || is_set(rst.yfilter)) leaf_name_data.push_back(rst.get_name_leafdata());
if (syn.is_set || is_set(syn.yfilter)) leaf_name_data.push_back(syn.get_name_leafdata());
if (fin.is_set || is_set(fin.yfilter)) leaf_name_data.push_back(fin.get_name_leafdata());
if (est.is_set || is_set(est.yfilter)) leaf_name_data.push_back(est.get_name_leafdata());
if (rev.is_set || is_set(rev.yfilter)) leaf_name_data.push_back(rev.get_name_leafdata());
if (tcpflagsmask.is_set || is_set(tcpflagsmask.yfilter)) leaf_name_data.push_back(tcpflagsmask.get_name_leafdata());
if (packets.is_set || is_set(packets.yfilter)) leaf_name_data.push_back(packets.get_name_leafdata());
if (fragment.is_set || is_set(fragment.yfilter)) leaf_name_data.push_back(fragment.get_name_leafdata());
if (capturesession.is_set || is_set(capturesession.yfilter)) leaf_name_data.push_back(capturesession.get_name_leafdata());
if (httpoption.is_set || is_set(httpoption.yfilter)) leaf_name_data.push_back(httpoption.get_name_leafdata());
if (vni.is_set || is_set(vni.yfilter)) leaf_name_data.push_back(vni.get_name_leafdata());
if (vlan.is_set || is_set(vlan.yfilter)) leaf_name_data.push_back(vlan.get_name_leafdata());
if (tcpoptionlength.is_set || is_set(tcpoptionlength.yfilter)) leaf_name_data.push_back(tcpoptionlength.get_name_leafdata());
if (timerange.is_set || is_set(timerange.yfilter)) leaf_name_data.push_back(timerange.get_name_leafdata());
if (srcaddrgroup.is_set || is_set(srcaddrgroup.yfilter)) leaf_name_data.push_back(srcaddrgroup.get_name_leafdata());
if (dstaddrgroup.is_set || is_set(dstaddrgroup.yfilter)) leaf_name_data.push_back(dstaddrgroup.get_name_leafdata());
if (srcportgroup.is_set || is_set(srcportgroup.yfilter)) leaf_name_data.push_back(srcportgroup.get_name_leafdata());
if (dstportgroup.is_set || is_set(dstportgroup.yfilter)) leaf_name_data.push_back(dstportgroup.get_name_leafdata());
if (redirect.is_set || is_set(redirect.yfilter)) leaf_name_data.push_back(redirect.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::NameItems::ACLList::SeqItems::ACEList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::NameItems::ACLList::SeqItems::ACEList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AclItems::Ipv6Items::NameItems::ACLList::SeqItems::ACEList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "seqNum")
{
seqnum = value;
seqnum.value_namespace = name_space;
seqnum.value_namespace_prefix = name_space_prefix;
}
if(value_path == "protocol")
{
protocol = value;
protocol.value_namespace = name_space;
protocol.value_namespace_prefix = name_space_prefix;
}
if(value_path == "protocolMask")
{
protocolmask = value;
protocolmask.value_namespace = name_space;
protocolmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPrefix")
{
srcprefix = value;
srcprefix.value_namespace = name_space;
srcprefix.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPrefixMask")
{
srcprefixmask = value;
srcprefixmask.value_namespace = name_space;
srcprefixmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPrefixLength")
{
srcprefixlength = value;
srcprefixlength.value_namespace = name_space;
srcprefixlength.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPrefix")
{
dstprefix = value;
dstprefix.value_namespace = name_space;
dstprefix.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPrefixMask")
{
dstprefixmask = value;
dstprefixmask.value_namespace = name_space;
dstprefixmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPrefixLength")
{
dstprefixlength = value;
dstprefixlength.value_namespace = name_space;
dstprefixlength.value_namespace_prefix = name_space_prefix;
}
if(value_path == "flowLabel")
{
flowlabel = value;
flowlabel.value_namespace = name_space;
flowlabel.value_namespace_prefix = name_space_prefix;
}
if(value_path == "icmpStr")
{
icmpstr = value;
icmpstr.value_namespace = name_space;
icmpstr.value_namespace_prefix = name_space_prefix;
}
if(value_path == "icmpType")
{
icmptype = value;
icmptype.value_namespace = name_space;
icmptype.value_namespace_prefix = name_space_prefix;
}
if(value_path == "icmpCode")
{
icmpcode = value;
icmpcode.value_namespace = name_space;
icmpcode.value_namespace_prefix = name_space_prefix;
}
if(value_path == "configStatus")
{
configstatus = value;
configstatus.value_namespace = name_space;
configstatus.value_namespace_prefix = name_space_prefix;
}
if(value_path == "upid")
{
upid = value;
upid.value_namespace = name_space;
upid.value_namespace_prefix = name_space_prefix;
}
if(value_path == "remark")
{
remark = value;
remark.value_namespace = name_space;
remark.value_namespace_prefix = name_space_prefix;
}
if(value_path == "action")
{
action = value;
action.value_namespace = name_space;
action.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPortOp")
{
srcportop = value;
srcportop.value_namespace = name_space;
srcportop.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPort1")
{
srcport1 = value;
srcport1.value_namespace = name_space;
srcport1.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPort2")
{
srcport2 = value;
srcport2.value_namespace = name_space;
srcport2.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPortMask")
{
srcportmask = value;
srcportmask.value_namespace = name_space;
srcportmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPortOp")
{
dstportop = value;
dstportop.value_namespace = name_space;
dstportop.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPort1")
{
dstport1 = value;
dstport1.value_namespace = name_space;
dstport1.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPort2")
{
dstport2 = value;
dstport2.value_namespace = name_space;
dstport2.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPortMask")
{
dstportmask = value;
dstportmask.value_namespace = name_space;
dstportmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "logging")
{
logging = value;
logging.value_namespace = name_space;
logging.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dscp")
{
dscp = value;
dscp.value_namespace = name_space;
dscp.value_namespace_prefix = name_space_prefix;
}
if(value_path == "pktLenOp")
{
pktlenop = value;
pktlenop.value_namespace = name_space;
pktlenop.value_namespace_prefix = name_space_prefix;
}
if(value_path == "pktLen1")
{
pktlen1 = value;
pktlen1.value_namespace = name_space;
pktlen1.value_namespace_prefix = name_space_prefix;
}
if(value_path == "pktLen2")
{
pktlen2 = value;
pktlen2.value_namespace = name_space;
pktlen2.value_namespace_prefix = name_space_prefix;
}
if(value_path == "urg")
{
urg = value;
urg.value_namespace = name_space;
urg.value_namespace_prefix = name_space_prefix;
}
if(value_path == "ack")
{
ack = value;
ack.value_namespace = name_space;
ack.value_namespace_prefix = name_space_prefix;
}
if(value_path == "psh")
{
psh = value;
psh.value_namespace = name_space;
psh.value_namespace_prefix = name_space_prefix;
}
if(value_path == "rst")
{
rst = value;
rst.value_namespace = name_space;
rst.value_namespace_prefix = name_space_prefix;
}
if(value_path == "syn")
{
syn = value;
syn.value_namespace = name_space;
syn.value_namespace_prefix = name_space_prefix;
}
if(value_path == "fin")
{
fin = value;
fin.value_namespace = name_space;
fin.value_namespace_prefix = name_space_prefix;
}
if(value_path == "est")
{
est = value;
est.value_namespace = name_space;
est.value_namespace_prefix = name_space_prefix;
}
if(value_path == "rev")
{
rev = value;
rev.value_namespace = name_space;
rev.value_namespace_prefix = name_space_prefix;
}
if(value_path == "tcpFlagsMask")
{
tcpflagsmask = value;
tcpflagsmask.value_namespace = name_space;
tcpflagsmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "packets")
{
packets = value;
packets.value_namespace = name_space;
packets.value_namespace_prefix = name_space_prefix;
}
if(value_path == "fragment")
{
fragment = value;
fragment.value_namespace = name_space;
fragment.value_namespace_prefix = name_space_prefix;
}
if(value_path == "captureSession")
{
capturesession = value;
capturesession.value_namespace = name_space;
capturesession.value_namespace_prefix = name_space_prefix;
}
if(value_path == "httpOption")
{
httpoption = value;
httpoption.value_namespace = name_space;
httpoption.value_namespace_prefix = name_space_prefix;
}
if(value_path == "vni")
{
vni = value;
vni.value_namespace = name_space;
vni.value_namespace_prefix = name_space_prefix;
}
if(value_path == "vlan")
{
vlan = value;
vlan.value_namespace = name_space;
vlan.value_namespace_prefix = name_space_prefix;
}
if(value_path == "tcpOptionLength")
{
tcpoptionlength = value;
tcpoptionlength.value_namespace = name_space;
tcpoptionlength.value_namespace_prefix = name_space_prefix;
}
if(value_path == "timeRange")
{
timerange = value;
timerange.value_namespace = name_space;
timerange.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcAddrGroup")
{
srcaddrgroup = value;
srcaddrgroup.value_namespace = name_space;
srcaddrgroup.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstAddrGroup")
{
dstaddrgroup = value;
dstaddrgroup.value_namespace = name_space;
dstaddrgroup.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPortGroup")
{
srcportgroup = value;
srcportgroup.value_namespace = name_space;
srcportgroup.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPortGroup")
{
dstportgroup = value;
dstportgroup.value_namespace = name_space;
dstportgroup.value_namespace_prefix = name_space_prefix;
}
if(value_path == "redirect")
{
redirect = value;
redirect.value_namespace = name_space;
redirect.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv6Items::NameItems::ACLList::SeqItems::ACEList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "seqNum")
{
seqnum.yfilter = yfilter;
}
if(value_path == "protocol")
{
protocol.yfilter = yfilter;
}
if(value_path == "protocolMask")
{
protocolmask.yfilter = yfilter;
}
if(value_path == "srcPrefix")
{
srcprefix.yfilter = yfilter;
}
if(value_path == "srcPrefixMask")
{
srcprefixmask.yfilter = yfilter;
}
if(value_path == "srcPrefixLength")
{
srcprefixlength.yfilter = yfilter;
}
if(value_path == "dstPrefix")
{
dstprefix.yfilter = yfilter;
}
if(value_path == "dstPrefixMask")
{
dstprefixmask.yfilter = yfilter;
}
if(value_path == "dstPrefixLength")
{
dstprefixlength.yfilter = yfilter;
}
if(value_path == "flowLabel")
{
flowlabel.yfilter = yfilter;
}
if(value_path == "icmpStr")
{
icmpstr.yfilter = yfilter;
}
if(value_path == "icmpType")
{
icmptype.yfilter = yfilter;
}
if(value_path == "icmpCode")
{
icmpcode.yfilter = yfilter;
}
if(value_path == "configStatus")
{
configstatus.yfilter = yfilter;
}
if(value_path == "upid")
{
upid.yfilter = yfilter;
}
if(value_path == "remark")
{
remark.yfilter = yfilter;
}
if(value_path == "action")
{
action.yfilter = yfilter;
}
if(value_path == "srcPortOp")
{
srcportop.yfilter = yfilter;
}
if(value_path == "srcPort1")
{
srcport1.yfilter = yfilter;
}
if(value_path == "srcPort2")
{
srcport2.yfilter = yfilter;
}
if(value_path == "srcPortMask")
{
srcportmask.yfilter = yfilter;
}
if(value_path == "dstPortOp")
{
dstportop.yfilter = yfilter;
}
if(value_path == "dstPort1")
{
dstport1.yfilter = yfilter;
}
if(value_path == "dstPort2")
{
dstport2.yfilter = yfilter;
}
if(value_path == "dstPortMask")
{
dstportmask.yfilter = yfilter;
}
if(value_path == "logging")
{
logging.yfilter = yfilter;
}
if(value_path == "dscp")
{
dscp.yfilter = yfilter;
}
if(value_path == "pktLenOp")
{
pktlenop.yfilter = yfilter;
}
if(value_path == "pktLen1")
{
pktlen1.yfilter = yfilter;
}
if(value_path == "pktLen2")
{
pktlen2.yfilter = yfilter;
}
if(value_path == "urg")
{
urg.yfilter = yfilter;
}
if(value_path == "ack")
{
ack.yfilter = yfilter;
}
if(value_path == "psh")
{
psh.yfilter = yfilter;
}
if(value_path == "rst")
{
rst.yfilter = yfilter;
}
if(value_path == "syn")
{
syn.yfilter = yfilter;
}
if(value_path == "fin")
{
fin.yfilter = yfilter;
}
if(value_path == "est")
{
est.yfilter = yfilter;
}
if(value_path == "rev")
{
rev.yfilter = yfilter;
}
if(value_path == "tcpFlagsMask")
{
tcpflagsmask.yfilter = yfilter;
}
if(value_path == "packets")
{
packets.yfilter = yfilter;
}
if(value_path == "fragment")
{
fragment.yfilter = yfilter;
}
if(value_path == "captureSession")
{
capturesession.yfilter = yfilter;
}
if(value_path == "httpOption")
{
httpoption.yfilter = yfilter;
}
if(value_path == "vni")
{
vni.yfilter = yfilter;
}
if(value_path == "vlan")
{
vlan.yfilter = yfilter;
}
if(value_path == "tcpOptionLength")
{
tcpoptionlength.yfilter = yfilter;
}
if(value_path == "timeRange")
{
timerange.yfilter = yfilter;
}
if(value_path == "srcAddrGroup")
{
srcaddrgroup.yfilter = yfilter;
}
if(value_path == "dstAddrGroup")
{
dstaddrgroup.yfilter = yfilter;
}
if(value_path == "srcPortGroup")
{
srcportgroup.yfilter = yfilter;
}
if(value_path == "dstPortGroup")
{
dstportgroup.yfilter = yfilter;
}
if(value_path == "redirect")
{
redirect.yfilter = yfilter;
}
}
bool System::AclItems::Ipv6Items::NameItems::ACLList::SeqItems::ACEList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "seqNum" || name == "protocol" || name == "protocolMask" || name == "srcPrefix" || name == "srcPrefixMask" || name == "srcPrefixLength" || name == "dstPrefix" || name == "dstPrefixMask" || name == "dstPrefixLength" || name == "flowLabel" || name == "icmpStr" || name == "icmpType" || name == "icmpCode" || name == "configStatus" || name == "upid" || name == "remark" || name == "action" || name == "srcPortOp" || name == "srcPort1" || name == "srcPort2" || name == "srcPortMask" || name == "dstPortOp" || name == "dstPort1" || name == "dstPort2" || name == "dstPortMask" || name == "logging" || name == "dscp" || name == "pktLenOp" || name == "pktLen1" || name == "pktLen2" || name == "urg" || name == "ack" || name == "psh" || name == "rst" || name == "syn" || name == "fin" || name == "est" || name == "rev" || name == "tcpFlagsMask" || name == "packets" || name == "fragment" || name == "captureSession" || name == "httpOption" || name == "vni" || name == "vlan" || name == "tcpOptionLength" || name == "timeRange" || name == "srcAddrGroup" || name == "dstAddrGroup" || name == "srcPortGroup" || name == "dstPortGroup" || name == "redirect")
return true;
return false;
}
System::AclItems::Ipv6Items::ONameItems::ONameItems()
:
addrgroup_list(this, {"name"})
{
yang_name = "oName-items"; yang_parent_name = "ipv6-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::AclItems::Ipv6Items::ONameItems::~ONameItems()
{
}
bool System::AclItems::Ipv6Items::ONameItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<addrgroup_list.len(); index++)
{
if(addrgroup_list[index]->has_data())
return true;
}
return false;
}
bool System::AclItems::Ipv6Items::ONameItems::has_operation() const
{
for (std::size_t index=0; index<addrgroup_list.len(); index++)
{
if(addrgroup_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AclItems::Ipv6Items::ONameItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/acl-items/ipv6-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::AclItems::Ipv6Items::ONameItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "oName-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::ONameItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::ONameItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "AddrGroup-list")
{
auto ent_ = std::make_shared<System::AclItems::Ipv6Items::ONameItems::AddrGroupList>();
ent_->parent = this;
addrgroup_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::ONameItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : addrgroup_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AclItems::Ipv6Items::ONameItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AclItems::Ipv6Items::ONameItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AclItems::Ipv6Items::ONameItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "AddrGroup-list")
return true;
return false;
}
System::AclItems::Ipv6Items::ONameItems::AddrGroupList::AddrGroupList()
:
name{YType::str, "name"},
upid{YType::uint32, "upid"}
,
seq_items(std::make_shared<System::AclItems::Ipv6Items::ONameItems::AddrGroupList::SeqItems>())
{
seq_items->parent = this;
yang_name = "AddrGroup-list"; yang_parent_name = "oName-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::AclItems::Ipv6Items::ONameItems::AddrGroupList::~AddrGroupList()
{
}
bool System::AclItems::Ipv6Items::ONameItems::AddrGroupList::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| upid.is_set
|| (seq_items != nullptr && seq_items->has_data());
}
bool System::AclItems::Ipv6Items::ONameItems::AddrGroupList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(upid.yfilter)
|| (seq_items != nullptr && seq_items->has_operation());
}
std::string System::AclItems::Ipv6Items::ONameItems::AddrGroupList::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/acl-items/ipv6-items/oName-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::AclItems::Ipv6Items::ONameItems::AddrGroupList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "AddrGroup-list";
ADD_KEY_TOKEN(name, "name");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::ONameItems::AddrGroupList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (upid.is_set || is_set(upid.yfilter)) leaf_name_data.push_back(upid.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::ONameItems::AddrGroupList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "seq-items")
{
if(seq_items == nullptr)
{
seq_items = std::make_shared<System::AclItems::Ipv6Items::ONameItems::AddrGroupList::SeqItems>();
}
return seq_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::ONameItems::AddrGroupList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(seq_items != nullptr)
{
_children["seq-items"] = seq_items;
}
return _children;
}
void System::AclItems::Ipv6Items::ONameItems::AddrGroupList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "upid")
{
upid = value;
upid.value_namespace = name_space;
upid.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv6Items::ONameItems::AddrGroupList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "upid")
{
upid.yfilter = yfilter;
}
}
bool System::AclItems::Ipv6Items::ONameItems::AddrGroupList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "seq-items" || name == "name" || name == "upid")
return true;
return false;
}
System::AclItems::Ipv6Items::ONameItems::AddrGroupList::SeqItems::SeqItems()
:
addrmember_list(this, {"seqnum"})
{
yang_name = "seq-items"; yang_parent_name = "AddrGroup-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AclItems::Ipv6Items::ONameItems::AddrGroupList::SeqItems::~SeqItems()
{
}
bool System::AclItems::Ipv6Items::ONameItems::AddrGroupList::SeqItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<addrmember_list.len(); index++)
{
if(addrmember_list[index]->has_data())
return true;
}
return false;
}
bool System::AclItems::Ipv6Items::ONameItems::AddrGroupList::SeqItems::has_operation() const
{
for (std::size_t index=0; index<addrmember_list.len(); index++)
{
if(addrmember_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AclItems::Ipv6Items::ONameItems::AddrGroupList::SeqItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "seq-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::ONameItems::AddrGroupList::SeqItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::ONameItems::AddrGroupList::SeqItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "AddrMember-list")
{
auto ent_ = std::make_shared<System::AclItems::Ipv6Items::ONameItems::AddrGroupList::SeqItems::AddrMemberList>();
ent_->parent = this;
addrmember_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::ONameItems::AddrGroupList::SeqItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : addrmember_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AclItems::Ipv6Items::ONameItems::AddrGroupList::SeqItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AclItems::Ipv6Items::ONameItems::AddrGroupList::SeqItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AclItems::Ipv6Items::ONameItems::AddrGroupList::SeqItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "AddrMember-list")
return true;
return false;
}
System::AclItems::Ipv6Items::ONameItems::AddrGroupList::SeqItems::AddrMemberList::AddrMemberList()
:
seqnum{YType::uint32, "seqNum"},
prefix{YType::str, "prefix"},
prefixmask{YType::str, "prefixMask"},
prefixlength{YType::uint8, "prefixLength"},
configstatus{YType::uint8, "configStatus"},
upid{YType::uint32, "upid"}
{
yang_name = "AddrMember-list"; yang_parent_name = "seq-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::AclItems::Ipv6Items::ONameItems::AddrGroupList::SeqItems::AddrMemberList::~AddrMemberList()
{
}
bool System::AclItems::Ipv6Items::ONameItems::AddrGroupList::SeqItems::AddrMemberList::has_data() const
{
if (is_presence_container) return true;
return seqnum.is_set
|| prefix.is_set
|| prefixmask.is_set
|| prefixlength.is_set
|| configstatus.is_set
|| upid.is_set;
}
bool System::AclItems::Ipv6Items::ONameItems::AddrGroupList::SeqItems::AddrMemberList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(seqnum.yfilter)
|| ydk::is_set(prefix.yfilter)
|| ydk::is_set(prefixmask.yfilter)
|| ydk::is_set(prefixlength.yfilter)
|| ydk::is_set(configstatus.yfilter)
|| ydk::is_set(upid.yfilter);
}
std::string System::AclItems::Ipv6Items::ONameItems::AddrGroupList::SeqItems::AddrMemberList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "AddrMember-list";
ADD_KEY_TOKEN(seqnum, "seqNum");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AclItems::Ipv6Items::ONameItems::AddrGroupList::SeqItems::AddrMemberList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (seqnum.is_set || is_set(seqnum.yfilter)) leaf_name_data.push_back(seqnum.get_name_leafdata());
if (prefix.is_set || is_set(prefix.yfilter)) leaf_name_data.push_back(prefix.get_name_leafdata());
if (prefixmask.is_set || is_set(prefixmask.yfilter)) leaf_name_data.push_back(prefixmask.get_name_leafdata());
if (prefixlength.is_set || is_set(prefixlength.yfilter)) leaf_name_data.push_back(prefixlength.get_name_leafdata());
if (configstatus.is_set || is_set(configstatus.yfilter)) leaf_name_data.push_back(configstatus.get_name_leafdata());
if (upid.is_set || is_set(upid.yfilter)) leaf_name_data.push_back(upid.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AclItems::Ipv6Items::ONameItems::AddrGroupList::SeqItems::AddrMemberList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AclItems::Ipv6Items::ONameItems::AddrGroupList::SeqItems::AddrMemberList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AclItems::Ipv6Items::ONameItems::AddrGroupList::SeqItems::AddrMemberList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "seqNum")
{
seqnum = value;
seqnum.value_namespace = name_space;
seqnum.value_namespace_prefix = name_space_prefix;
}
if(value_path == "prefix")
{
prefix = value;
prefix.value_namespace = name_space;
prefix.value_namespace_prefix = name_space_prefix;
}
if(value_path == "prefixMask")
{
prefixmask = value;
prefixmask.value_namespace = name_space;
prefixmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "prefixLength")
{
prefixlength = value;
prefixlength.value_namespace = name_space;
prefixlength.value_namespace_prefix = name_space_prefix;
}
if(value_path == "configStatus")
{
configstatus = value;
configstatus.value_namespace = name_space;
configstatus.value_namespace_prefix = name_space_prefix;
}
if(value_path == "upid")
{
upid = value;
upid.value_namespace = name_space;
upid.value_namespace_prefix = name_space_prefix;
}
}
void System::AclItems::Ipv6Items::ONameItems::AddrGroupList::SeqItems::AddrMemberList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "seqNum")
{
seqnum.yfilter = yfilter;
}
if(value_path == "prefix")
{
prefix.yfilter = yfilter;
}
if(value_path == "prefixMask")
{
prefixmask.yfilter = yfilter;
}
if(value_path == "prefixLength")
{
prefixlength.yfilter = yfilter;
}
if(value_path == "configStatus")
{
configstatus.yfilter = yfilter;
}
if(value_path == "upid")
{
upid.yfilter = yfilter;
}
}
bool System::AclItems::Ipv6Items::ONameItems::AddrGroupList::SeqItems::AddrMemberList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "seqNum" || name == "prefix" || name == "prefixMask" || name == "prefixLength" || name == "configStatus" || name == "upid")
return true;
return false;
}
System::ActrlItems::ActrlItems()
:
name{YType::str, "name"},
adminst{YType::enumeration, "adminSt"},
operst{YType::enumeration, "operSt"}
,
aux_items(std::make_shared<System::ActrlItems::AuxItems>())
, filt_items(std::make_shared<System::ActrlItems::FiltItems>())
, inst_items(std::make_shared<System::ActrlItems::InstItems>())
, scope_items(std::make_shared<System::ActrlItems::ScopeItems>())
{
aux_items->parent = this;
filt_items->parent = this;
inst_items->parent = this;
scope_items->parent = this;
yang_name = "actrl-items"; yang_parent_name = "System"; is_top_level_class = false; has_list_ancestor = false;
}
System::ActrlItems::~ActrlItems()
{
}
bool System::ActrlItems::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| adminst.is_set
|| operst.is_set
|| (aux_items != nullptr && aux_items->has_data())
|| (filt_items != nullptr && filt_items->has_data())
|| (inst_items != nullptr && inst_items->has_data())
|| (scope_items != nullptr && scope_items->has_data());
}
bool System::ActrlItems::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(adminst.yfilter)
|| ydk::is_set(operst.yfilter)
|| (aux_items != nullptr && aux_items->has_operation())
|| (filt_items != nullptr && filt_items->has_operation())
|| (inst_items != nullptr && inst_items->has_operation())
|| (scope_items != nullptr && scope_items->has_operation());
}
std::string System::ActrlItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/" << get_segment_path();
return path_buffer.str();
}
std::string System::ActrlItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "actrl-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (adminst.is_set || is_set(adminst.yfilter)) leaf_name_data.push_back(adminst.get_name_leafdata());
if (operst.is_set || is_set(operst.yfilter)) leaf_name_data.push_back(operst.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "aux-items")
{
if(aux_items == nullptr)
{
aux_items = std::make_shared<System::ActrlItems::AuxItems>();
}
return aux_items;
}
if(child_yang_name == "filt-items")
{
if(filt_items == nullptr)
{
filt_items = std::make_shared<System::ActrlItems::FiltItems>();
}
return filt_items;
}
if(child_yang_name == "inst-items")
{
if(inst_items == nullptr)
{
inst_items = std::make_shared<System::ActrlItems::InstItems>();
}
return inst_items;
}
if(child_yang_name == "scope-items")
{
if(scope_items == nullptr)
{
scope_items = std::make_shared<System::ActrlItems::ScopeItems>();
}
return scope_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(aux_items != nullptr)
{
_children["aux-items"] = aux_items;
}
if(filt_items != nullptr)
{
_children["filt-items"] = filt_items;
}
if(inst_items != nullptr)
{
_children["inst-items"] = inst_items;
}
if(scope_items != nullptr)
{
_children["scope-items"] = scope_items;
}
return _children;
}
void System::ActrlItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "adminSt")
{
adminst = value;
adminst.value_namespace = name_space;
adminst.value_namespace_prefix = name_space_prefix;
}
if(value_path == "operSt")
{
operst = value;
operst.value_namespace = name_space;
operst.value_namespace_prefix = name_space_prefix;
}
}
void System::ActrlItems::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "adminSt")
{
adminst.yfilter = yfilter;
}
if(value_path == "operSt")
{
operst.yfilter = yfilter;
}
}
bool System::ActrlItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "aux-items" || name == "filt-items" || name == "inst-items" || name == "scope-items" || name == "name" || name == "adminSt" || name == "operSt")
return true;
return false;
}
System::ActrlItems::AuxItems::AuxItems()
:
name{YType::str, "name"}
,
scope_items(std::make_shared<System::ActrlItems::AuxItems::ScopeItems>())
, rule_items(std::make_shared<System::ActrlItems::AuxItems::RuleItems>())
, flt_items(std::make_shared<System::ActrlItems::AuxItems::FltItems>())
, mgmtrule_items(std::make_shared<System::ActrlItems::AuxItems::MgmtruleItems>())
, mgmtauxflt_items(std::make_shared<System::ActrlItems::AuxItems::MgmtauxfltItems>())
{
scope_items->parent = this;
rule_items->parent = this;
flt_items->parent = this;
mgmtrule_items->parent = this;
mgmtauxflt_items->parent = this;
yang_name = "aux-items"; yang_parent_name = "actrl-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::ActrlItems::AuxItems::~AuxItems()
{
}
bool System::ActrlItems::AuxItems::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| (scope_items != nullptr && scope_items->has_data())
|| (rule_items != nullptr && rule_items->has_data())
|| (flt_items != nullptr && flt_items->has_data())
|| (mgmtrule_items != nullptr && mgmtrule_items->has_data())
|| (mgmtauxflt_items != nullptr && mgmtauxflt_items->has_data());
}
bool System::ActrlItems::AuxItems::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| (scope_items != nullptr && scope_items->has_operation())
|| (rule_items != nullptr && rule_items->has_operation())
|| (flt_items != nullptr && flt_items->has_operation())
|| (mgmtrule_items != nullptr && mgmtrule_items->has_operation())
|| (mgmtauxflt_items != nullptr && mgmtauxflt_items->has_operation());
}
std::string System::ActrlItems::AuxItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/actrl-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::ActrlItems::AuxItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "aux-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::AuxItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::AuxItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "scope-items")
{
if(scope_items == nullptr)
{
scope_items = std::make_shared<System::ActrlItems::AuxItems::ScopeItems>();
}
return scope_items;
}
if(child_yang_name == "rule-items")
{
if(rule_items == nullptr)
{
rule_items = std::make_shared<System::ActrlItems::AuxItems::RuleItems>();
}
return rule_items;
}
if(child_yang_name == "flt-items")
{
if(flt_items == nullptr)
{
flt_items = std::make_shared<System::ActrlItems::AuxItems::FltItems>();
}
return flt_items;
}
if(child_yang_name == "mgmtrule-items")
{
if(mgmtrule_items == nullptr)
{
mgmtrule_items = std::make_shared<System::ActrlItems::AuxItems::MgmtruleItems>();
}
return mgmtrule_items;
}
if(child_yang_name == "mgmtauxflt-items")
{
if(mgmtauxflt_items == nullptr)
{
mgmtauxflt_items = std::make_shared<System::ActrlItems::AuxItems::MgmtauxfltItems>();
}
return mgmtauxflt_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::AuxItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(scope_items != nullptr)
{
_children["scope-items"] = scope_items;
}
if(rule_items != nullptr)
{
_children["rule-items"] = rule_items;
}
if(flt_items != nullptr)
{
_children["flt-items"] = flt_items;
}
if(mgmtrule_items != nullptr)
{
_children["mgmtrule-items"] = mgmtrule_items;
}
if(mgmtauxflt_items != nullptr)
{
_children["mgmtauxflt-items"] = mgmtauxflt_items;
}
return _children;
}
void System::ActrlItems::AuxItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
}
void System::ActrlItems::AuxItems::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
}
bool System::ActrlItems::AuxItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "scope-items" || name == "rule-items" || name == "flt-items" || name == "mgmtrule-items" || name == "mgmtauxflt-items" || name == "name")
return true;
return false;
}
System::ActrlItems::AuxItems::ScopeItems::ScopeItems()
:
auxscope_list(this, {"id"})
{
yang_name = "scope-items"; yang_parent_name = "aux-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::ActrlItems::AuxItems::ScopeItems::~ScopeItems()
{
}
bool System::ActrlItems::AuxItems::ScopeItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<auxscope_list.len(); index++)
{
if(auxscope_list[index]->has_data())
return true;
}
return false;
}
bool System::ActrlItems::AuxItems::ScopeItems::has_operation() const
{
for (std::size_t index=0; index<auxscope_list.len(); index++)
{
if(auxscope_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::ActrlItems::AuxItems::ScopeItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/actrl-items/aux-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::ActrlItems::AuxItems::ScopeItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "scope-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::AuxItems::ScopeItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::AuxItems::ScopeItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "AuxScope-list")
{
auto ent_ = std::make_shared<System::ActrlItems::AuxItems::ScopeItems::AuxScopeList>();
ent_->parent = this;
auxscope_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::AuxItems::ScopeItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : auxscope_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::ActrlItems::AuxItems::ScopeItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::ActrlItems::AuxItems::ScopeItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::ActrlItems::AuxItems::ScopeItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "AuxScope-list")
return true;
return false;
}
System::ActrlItems::AuxItems::ScopeItems::AuxScopeList::AuxScopeList()
:
id{YType::uint32, "id"},
name{YType::str, "name"}
{
yang_name = "AuxScope-list"; yang_parent_name = "scope-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::ActrlItems::AuxItems::ScopeItems::AuxScopeList::~AuxScopeList()
{
}
bool System::ActrlItems::AuxItems::ScopeItems::AuxScopeList::has_data() const
{
if (is_presence_container) return true;
return id.is_set
|| name.is_set;
}
bool System::ActrlItems::AuxItems::ScopeItems::AuxScopeList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(id.yfilter)
|| ydk::is_set(name.yfilter);
}
std::string System::ActrlItems::AuxItems::ScopeItems::AuxScopeList::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/actrl-items/aux-items/scope-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::ActrlItems::AuxItems::ScopeItems::AuxScopeList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "AuxScope-list";
ADD_KEY_TOKEN(id, "id");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::AuxItems::ScopeItems::AuxScopeList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (id.is_set || is_set(id.yfilter)) leaf_name_data.push_back(id.get_name_leafdata());
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::AuxItems::ScopeItems::AuxScopeList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::AuxItems::ScopeItems::AuxScopeList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::ActrlItems::AuxItems::ScopeItems::AuxScopeList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "id")
{
id = value;
id.value_namespace = name_space;
id.value_namespace_prefix = name_space_prefix;
}
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
}
void System::ActrlItems::AuxItems::ScopeItems::AuxScopeList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "id")
{
id.yfilter = yfilter;
}
if(value_path == "name")
{
name.yfilter = yfilter;
}
}
bool System::ActrlItems::AuxItems::ScopeItems::AuxScopeList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "id" || name == "name")
return true;
return false;
}
System::ActrlItems::AuxItems::RuleItems::RuleItems()
:
auxrule_list(this, {"id"})
{
yang_name = "rule-items"; yang_parent_name = "aux-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::ActrlItems::AuxItems::RuleItems::~RuleItems()
{
}
bool System::ActrlItems::AuxItems::RuleItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<auxrule_list.len(); index++)
{
if(auxrule_list[index]->has_data())
return true;
}
return false;
}
bool System::ActrlItems::AuxItems::RuleItems::has_operation() const
{
for (std::size_t index=0; index<auxrule_list.len(); index++)
{
if(auxrule_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::ActrlItems::AuxItems::RuleItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/actrl-items/aux-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::ActrlItems::AuxItems::RuleItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "rule-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::AuxItems::RuleItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::AuxItems::RuleItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "AuxRule-list")
{
auto ent_ = std::make_shared<System::ActrlItems::AuxItems::RuleItems::AuxRuleList>();
ent_->parent = this;
auxrule_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::AuxItems::RuleItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : auxrule_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::ActrlItems::AuxItems::RuleItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::ActrlItems::AuxItems::RuleItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::ActrlItems::AuxItems::RuleItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "AuxRule-list")
return true;
return false;
}
System::ActrlItems::AuxItems::RuleItems::AuxRuleList::AuxRuleList()
:
id{YType::uint32, "id"},
fltid{YType::uint32, "fltid"},
prio{YType::uint8, "prio"},
scopeid{YType::uint32, "scopeId"},
direction{YType::enumeration, "direction"},
name{YType::str, "name"}
{
yang_name = "AuxRule-list"; yang_parent_name = "rule-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::ActrlItems::AuxItems::RuleItems::AuxRuleList::~AuxRuleList()
{
}
bool System::ActrlItems::AuxItems::RuleItems::AuxRuleList::has_data() const
{
if (is_presence_container) return true;
return id.is_set
|| fltid.is_set
|| prio.is_set
|| scopeid.is_set
|| direction.is_set
|| name.is_set;
}
bool System::ActrlItems::AuxItems::RuleItems::AuxRuleList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(id.yfilter)
|| ydk::is_set(fltid.yfilter)
|| ydk::is_set(prio.yfilter)
|| ydk::is_set(scopeid.yfilter)
|| ydk::is_set(direction.yfilter)
|| ydk::is_set(name.yfilter);
}
std::string System::ActrlItems::AuxItems::RuleItems::AuxRuleList::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/actrl-items/aux-items/rule-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::ActrlItems::AuxItems::RuleItems::AuxRuleList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "AuxRule-list";
ADD_KEY_TOKEN(id, "id");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::AuxItems::RuleItems::AuxRuleList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (id.is_set || is_set(id.yfilter)) leaf_name_data.push_back(id.get_name_leafdata());
if (fltid.is_set || is_set(fltid.yfilter)) leaf_name_data.push_back(fltid.get_name_leafdata());
if (prio.is_set || is_set(prio.yfilter)) leaf_name_data.push_back(prio.get_name_leafdata());
if (scopeid.is_set || is_set(scopeid.yfilter)) leaf_name_data.push_back(scopeid.get_name_leafdata());
if (direction.is_set || is_set(direction.yfilter)) leaf_name_data.push_back(direction.get_name_leafdata());
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::AuxItems::RuleItems::AuxRuleList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::AuxItems::RuleItems::AuxRuleList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::ActrlItems::AuxItems::RuleItems::AuxRuleList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "id")
{
id = value;
id.value_namespace = name_space;
id.value_namespace_prefix = name_space_prefix;
}
if(value_path == "fltid")
{
fltid = value;
fltid.value_namespace = name_space;
fltid.value_namespace_prefix = name_space_prefix;
}
if(value_path == "prio")
{
prio = value;
prio.value_namespace = name_space;
prio.value_namespace_prefix = name_space_prefix;
}
if(value_path == "scopeId")
{
scopeid = value;
scopeid.value_namespace = name_space;
scopeid.value_namespace_prefix = name_space_prefix;
}
if(value_path == "direction")
{
direction = value;
direction.value_namespace = name_space;
direction.value_namespace_prefix = name_space_prefix;
}
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
}
void System::ActrlItems::AuxItems::RuleItems::AuxRuleList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "id")
{
id.yfilter = yfilter;
}
if(value_path == "fltid")
{
fltid.yfilter = yfilter;
}
if(value_path == "prio")
{
prio.yfilter = yfilter;
}
if(value_path == "scopeId")
{
scopeid.yfilter = yfilter;
}
if(value_path == "direction")
{
direction.yfilter = yfilter;
}
if(value_path == "name")
{
name.yfilter = yfilter;
}
}
bool System::ActrlItems::AuxItems::RuleItems::AuxRuleList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "id" || name == "fltid" || name == "prio" || name == "scopeId" || name == "direction" || name == "name")
return true;
return false;
}
System::ActrlItems::AuxItems::FltItems::FltItems()
:
auxflt_list(this, {"id"})
{
yang_name = "flt-items"; yang_parent_name = "aux-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::ActrlItems::AuxItems::FltItems::~FltItems()
{
}
bool System::ActrlItems::AuxItems::FltItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<auxflt_list.len(); index++)
{
if(auxflt_list[index]->has_data())
return true;
}
return false;
}
bool System::ActrlItems::AuxItems::FltItems::has_operation() const
{
for (std::size_t index=0; index<auxflt_list.len(); index++)
{
if(auxflt_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::ActrlItems::AuxItems::FltItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/actrl-items/aux-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::ActrlItems::AuxItems::FltItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "flt-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::AuxItems::FltItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::AuxItems::FltItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "AuxFlt-list")
{
auto ent_ = std::make_shared<System::ActrlItems::AuxItems::FltItems::AuxFltList>();
ent_->parent = this;
auxflt_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::AuxItems::FltItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : auxflt_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::ActrlItems::AuxItems::FltItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::ActrlItems::AuxItems::FltItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::ActrlItems::AuxItems::FltItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "AuxFlt-list")
return true;
return false;
}
System::ActrlItems::AuxItems::FltItems::AuxFltList::AuxFltList()
:
id{YType::uint32, "id"},
ruleidarr{YType::str, "ruleidArr"},
ruleindex{YType::uint16, "ruleIndex"},
name{YType::str, "name"}
,
ent_items(std::make_shared<System::ActrlItems::AuxItems::FltItems::AuxFltList::EntItems>())
{
ent_items->parent = this;
yang_name = "AuxFlt-list"; yang_parent_name = "flt-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::ActrlItems::AuxItems::FltItems::AuxFltList::~AuxFltList()
{
}
bool System::ActrlItems::AuxItems::FltItems::AuxFltList::has_data() const
{
if (is_presence_container) return true;
return id.is_set
|| ruleidarr.is_set
|| ruleindex.is_set
|| name.is_set
|| (ent_items != nullptr && ent_items->has_data());
}
bool System::ActrlItems::AuxItems::FltItems::AuxFltList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(id.yfilter)
|| ydk::is_set(ruleidarr.yfilter)
|| ydk::is_set(ruleindex.yfilter)
|| ydk::is_set(name.yfilter)
|| (ent_items != nullptr && ent_items->has_operation());
}
std::string System::ActrlItems::AuxItems::FltItems::AuxFltList::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/actrl-items/aux-items/flt-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::ActrlItems::AuxItems::FltItems::AuxFltList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "AuxFlt-list";
ADD_KEY_TOKEN(id, "id");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::AuxItems::FltItems::AuxFltList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (id.is_set || is_set(id.yfilter)) leaf_name_data.push_back(id.get_name_leafdata());
if (ruleidarr.is_set || is_set(ruleidarr.yfilter)) leaf_name_data.push_back(ruleidarr.get_name_leafdata());
if (ruleindex.is_set || is_set(ruleindex.yfilter)) leaf_name_data.push_back(ruleindex.get_name_leafdata());
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::AuxItems::FltItems::AuxFltList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "ent-items")
{
if(ent_items == nullptr)
{
ent_items = std::make_shared<System::ActrlItems::AuxItems::FltItems::AuxFltList::EntItems>();
}
return ent_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::AuxItems::FltItems::AuxFltList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(ent_items != nullptr)
{
_children["ent-items"] = ent_items;
}
return _children;
}
void System::ActrlItems::AuxItems::FltItems::AuxFltList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "id")
{
id = value;
id.value_namespace = name_space;
id.value_namespace_prefix = name_space_prefix;
}
if(value_path == "ruleidArr")
{
ruleidarr = value;
ruleidarr.value_namespace = name_space;
ruleidarr.value_namespace_prefix = name_space_prefix;
}
if(value_path == "ruleIndex")
{
ruleindex = value;
ruleindex.value_namespace = name_space;
ruleindex.value_namespace_prefix = name_space_prefix;
}
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
}
void System::ActrlItems::AuxItems::FltItems::AuxFltList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "id")
{
id.yfilter = yfilter;
}
if(value_path == "ruleidArr")
{
ruleidarr.yfilter = yfilter;
}
if(value_path == "ruleIndex")
{
ruleindex.yfilter = yfilter;
}
if(value_path == "name")
{
name.yfilter = yfilter;
}
}
bool System::ActrlItems::AuxItems::FltItems::AuxFltList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "ent-items" || name == "id" || name == "ruleidArr" || name == "ruleIndex" || name == "name")
return true;
return false;
}
System::ActrlItems::AuxItems::FltItems::AuxFltList::EntItems::EntItems()
:
auxentry_list(this, {"name"})
{
yang_name = "ent-items"; yang_parent_name = "AuxFlt-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::AuxItems::FltItems::AuxFltList::EntItems::~EntItems()
{
}
bool System::ActrlItems::AuxItems::FltItems::AuxFltList::EntItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<auxentry_list.len(); index++)
{
if(auxentry_list[index]->has_data())
return true;
}
return false;
}
bool System::ActrlItems::AuxItems::FltItems::AuxFltList::EntItems::has_operation() const
{
for (std::size_t index=0; index<auxentry_list.len(); index++)
{
if(auxentry_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::ActrlItems::AuxItems::FltItems::AuxFltList::EntItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "ent-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::AuxItems::FltItems::AuxFltList::EntItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::AuxItems::FltItems::AuxFltList::EntItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "AuxEntry-list")
{
auto ent_ = std::make_shared<System::ActrlItems::AuxItems::FltItems::AuxFltList::EntItems::AuxEntryList>();
ent_->parent = this;
auxentry_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::AuxItems::FltItems::AuxFltList::EntItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : auxentry_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::ActrlItems::AuxItems::FltItems::AuxFltList::EntItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::ActrlItems::AuxItems::FltItems::AuxFltList::EntItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::ActrlItems::AuxItems::FltItems::AuxFltList::EntItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "AuxEntry-list")
return true;
return false;
}
System::ActrlItems::AuxItems::FltItems::AuxFltList::EntItems::AuxEntryList::AuxEntryList()
:
name{YType::str, "name"}
{
yang_name = "AuxEntry-list"; yang_parent_name = "ent-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::AuxItems::FltItems::AuxFltList::EntItems::AuxEntryList::~AuxEntryList()
{
}
bool System::ActrlItems::AuxItems::FltItems::AuxFltList::EntItems::AuxEntryList::has_data() const
{
if (is_presence_container) return true;
return name.is_set;
}
bool System::ActrlItems::AuxItems::FltItems::AuxFltList::EntItems::AuxEntryList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter);
}
std::string System::ActrlItems::AuxItems::FltItems::AuxFltList::EntItems::AuxEntryList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "AuxEntry-list";
ADD_KEY_TOKEN(name, "name");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::AuxItems::FltItems::AuxFltList::EntItems::AuxEntryList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::AuxItems::FltItems::AuxFltList::EntItems::AuxEntryList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::AuxItems::FltItems::AuxFltList::EntItems::AuxEntryList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::ActrlItems::AuxItems::FltItems::AuxFltList::EntItems::AuxEntryList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
}
void System::ActrlItems::AuxItems::FltItems::AuxFltList::EntItems::AuxEntryList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
}
bool System::ActrlItems::AuxItems::FltItems::AuxFltList::EntItems::AuxEntryList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "name")
return true;
return false;
}
System::ActrlItems::AuxItems::MgmtruleItems::MgmtruleItems()
:
mgmtauxrule_list(this, {"id"})
{
yang_name = "mgmtrule-items"; yang_parent_name = "aux-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::ActrlItems::AuxItems::MgmtruleItems::~MgmtruleItems()
{
}
bool System::ActrlItems::AuxItems::MgmtruleItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<mgmtauxrule_list.len(); index++)
{
if(mgmtauxrule_list[index]->has_data())
return true;
}
return false;
}
bool System::ActrlItems::AuxItems::MgmtruleItems::has_operation() const
{
for (std::size_t index=0; index<mgmtauxrule_list.len(); index++)
{
if(mgmtauxrule_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::ActrlItems::AuxItems::MgmtruleItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/actrl-items/aux-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::ActrlItems::AuxItems::MgmtruleItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "mgmtrule-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::AuxItems::MgmtruleItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::AuxItems::MgmtruleItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "MgmtAuxRule-list")
{
auto ent_ = std::make_shared<System::ActrlItems::AuxItems::MgmtruleItems::MgmtAuxRuleList>();
ent_->parent = this;
mgmtauxrule_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::AuxItems::MgmtruleItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : mgmtauxrule_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::ActrlItems::AuxItems::MgmtruleItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::ActrlItems::AuxItems::MgmtruleItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::ActrlItems::AuxItems::MgmtruleItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "MgmtAuxRule-list")
return true;
return false;
}
System::ActrlItems::AuxItems::MgmtruleItems::MgmtAuxRuleList::MgmtAuxRuleList()
:
id{YType::uint32, "id"},
ctx_id{YType::uint32, "ctx_id"},
scope_id{YType::uint32, "scope_id"},
fltid{YType::uint32, "fltid"},
name{YType::str, "name"}
{
yang_name = "MgmtAuxRule-list"; yang_parent_name = "mgmtrule-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::ActrlItems::AuxItems::MgmtruleItems::MgmtAuxRuleList::~MgmtAuxRuleList()
{
}
bool System::ActrlItems::AuxItems::MgmtruleItems::MgmtAuxRuleList::has_data() const
{
if (is_presence_container) return true;
return id.is_set
|| ctx_id.is_set
|| scope_id.is_set
|| fltid.is_set
|| name.is_set;
}
bool System::ActrlItems::AuxItems::MgmtruleItems::MgmtAuxRuleList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(id.yfilter)
|| ydk::is_set(ctx_id.yfilter)
|| ydk::is_set(scope_id.yfilter)
|| ydk::is_set(fltid.yfilter)
|| ydk::is_set(name.yfilter);
}
std::string System::ActrlItems::AuxItems::MgmtruleItems::MgmtAuxRuleList::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/actrl-items/aux-items/mgmtrule-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::ActrlItems::AuxItems::MgmtruleItems::MgmtAuxRuleList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "MgmtAuxRule-list";
ADD_KEY_TOKEN(id, "id");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::AuxItems::MgmtruleItems::MgmtAuxRuleList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (id.is_set || is_set(id.yfilter)) leaf_name_data.push_back(id.get_name_leafdata());
if (ctx_id.is_set || is_set(ctx_id.yfilter)) leaf_name_data.push_back(ctx_id.get_name_leafdata());
if (scope_id.is_set || is_set(scope_id.yfilter)) leaf_name_data.push_back(scope_id.get_name_leafdata());
if (fltid.is_set || is_set(fltid.yfilter)) leaf_name_data.push_back(fltid.get_name_leafdata());
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::AuxItems::MgmtruleItems::MgmtAuxRuleList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::AuxItems::MgmtruleItems::MgmtAuxRuleList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::ActrlItems::AuxItems::MgmtruleItems::MgmtAuxRuleList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "id")
{
id = value;
id.value_namespace = name_space;
id.value_namespace_prefix = name_space_prefix;
}
if(value_path == "ctx_id")
{
ctx_id = value;
ctx_id.value_namespace = name_space;
ctx_id.value_namespace_prefix = name_space_prefix;
}
if(value_path == "scope_id")
{
scope_id = value;
scope_id.value_namespace = name_space;
scope_id.value_namespace_prefix = name_space_prefix;
}
if(value_path == "fltid")
{
fltid = value;
fltid.value_namespace = name_space;
fltid.value_namespace_prefix = name_space_prefix;
}
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
}
void System::ActrlItems::AuxItems::MgmtruleItems::MgmtAuxRuleList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "id")
{
id.yfilter = yfilter;
}
if(value_path == "ctx_id")
{
ctx_id.yfilter = yfilter;
}
if(value_path == "scope_id")
{
scope_id.yfilter = yfilter;
}
if(value_path == "fltid")
{
fltid.yfilter = yfilter;
}
if(value_path == "name")
{
name.yfilter = yfilter;
}
}
bool System::ActrlItems::AuxItems::MgmtruleItems::MgmtAuxRuleList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "id" || name == "ctx_id" || name == "scope_id" || name == "fltid" || name == "name")
return true;
return false;
}
System::ActrlItems::AuxItems::MgmtauxfltItems::MgmtauxfltItems()
:
mgmtauxflt_list(this, {"id"})
{
yang_name = "mgmtauxflt-items"; yang_parent_name = "aux-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::ActrlItems::AuxItems::MgmtauxfltItems::~MgmtauxfltItems()
{
}
bool System::ActrlItems::AuxItems::MgmtauxfltItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<mgmtauxflt_list.len(); index++)
{
if(mgmtauxflt_list[index]->has_data())
return true;
}
return false;
}
bool System::ActrlItems::AuxItems::MgmtauxfltItems::has_operation() const
{
for (std::size_t index=0; index<mgmtauxflt_list.len(); index++)
{
if(mgmtauxflt_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::ActrlItems::AuxItems::MgmtauxfltItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/actrl-items/aux-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::ActrlItems::AuxItems::MgmtauxfltItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "mgmtauxflt-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::AuxItems::MgmtauxfltItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::AuxItems::MgmtauxfltItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "MgmtAuxFlt-list")
{
auto ent_ = std::make_shared<System::ActrlItems::AuxItems::MgmtauxfltItems::MgmtAuxFltList>();
ent_->parent = this;
mgmtauxflt_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::AuxItems::MgmtauxfltItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : mgmtauxflt_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::ActrlItems::AuxItems::MgmtauxfltItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::ActrlItems::AuxItems::MgmtauxfltItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::ActrlItems::AuxItems::MgmtauxfltItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "MgmtAuxFlt-list")
return true;
return false;
}
System::ActrlItems::AuxItems::MgmtauxfltItems::MgmtAuxFltList::MgmtAuxFltList()
:
id{YType::uint32, "id"},
mgmtruleidarr{YType::str, "mgmtruleidArr"},
mgmtruleindex{YType::uint16, "mgmtruleIndex"},
name{YType::str, "name"}
{
yang_name = "MgmtAuxFlt-list"; yang_parent_name = "mgmtauxflt-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::ActrlItems::AuxItems::MgmtauxfltItems::MgmtAuxFltList::~MgmtAuxFltList()
{
}
bool System::ActrlItems::AuxItems::MgmtauxfltItems::MgmtAuxFltList::has_data() const
{
if (is_presence_container) return true;
return id.is_set
|| mgmtruleidarr.is_set
|| mgmtruleindex.is_set
|| name.is_set;
}
bool System::ActrlItems::AuxItems::MgmtauxfltItems::MgmtAuxFltList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(id.yfilter)
|| ydk::is_set(mgmtruleidarr.yfilter)
|| ydk::is_set(mgmtruleindex.yfilter)
|| ydk::is_set(name.yfilter);
}
std::string System::ActrlItems::AuxItems::MgmtauxfltItems::MgmtAuxFltList::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/actrl-items/aux-items/mgmtauxflt-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::ActrlItems::AuxItems::MgmtauxfltItems::MgmtAuxFltList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "MgmtAuxFlt-list";
ADD_KEY_TOKEN(id, "id");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::AuxItems::MgmtauxfltItems::MgmtAuxFltList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (id.is_set || is_set(id.yfilter)) leaf_name_data.push_back(id.get_name_leafdata());
if (mgmtruleidarr.is_set || is_set(mgmtruleidarr.yfilter)) leaf_name_data.push_back(mgmtruleidarr.get_name_leafdata());
if (mgmtruleindex.is_set || is_set(mgmtruleindex.yfilter)) leaf_name_data.push_back(mgmtruleindex.get_name_leafdata());
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::AuxItems::MgmtauxfltItems::MgmtAuxFltList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::AuxItems::MgmtauxfltItems::MgmtAuxFltList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::ActrlItems::AuxItems::MgmtauxfltItems::MgmtAuxFltList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "id")
{
id = value;
id.value_namespace = name_space;
id.value_namespace_prefix = name_space_prefix;
}
if(value_path == "mgmtruleidArr")
{
mgmtruleidarr = value;
mgmtruleidarr.value_namespace = name_space;
mgmtruleidarr.value_namespace_prefix = name_space_prefix;
}
if(value_path == "mgmtruleIndex")
{
mgmtruleindex = value;
mgmtruleindex.value_namespace = name_space;
mgmtruleindex.value_namespace_prefix = name_space_prefix;
}
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
}
void System::ActrlItems::AuxItems::MgmtauxfltItems::MgmtAuxFltList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "id")
{
id.yfilter = yfilter;
}
if(value_path == "mgmtruleidArr")
{
mgmtruleidarr.yfilter = yfilter;
}
if(value_path == "mgmtruleIndex")
{
mgmtruleindex.yfilter = yfilter;
}
if(value_path == "name")
{
name.yfilter = yfilter;
}
}
bool System::ActrlItems::AuxItems::MgmtauxfltItems::MgmtAuxFltList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "id" || name == "mgmtruleidArr" || name == "mgmtruleIndex" || name == "name")
return true;
return false;
}
System::ActrlItems::FiltItems::FiltItems()
:
flt_list(this, {"id"})
{
yang_name = "filt-items"; yang_parent_name = "actrl-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::ActrlItems::FiltItems::~FiltItems()
{
}
bool System::ActrlItems::FiltItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<flt_list.len(); index++)
{
if(flt_list[index]->has_data())
return true;
}
return false;
}
bool System::ActrlItems::FiltItems::has_operation() const
{
for (std::size_t index=0; index<flt_list.len(); index++)
{
if(flt_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::ActrlItems::FiltItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/actrl-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::ActrlItems::FiltItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "filt-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::FiltItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::FiltItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "Flt-list")
{
auto ent_ = std::make_shared<System::ActrlItems::FiltItems::FltList>();
ent_->parent = this;
flt_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::FiltItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : flt_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::ActrlItems::FiltItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::ActrlItems::FiltItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::ActrlItems::FiltItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "Flt-list")
return true;
return false;
}
System::ActrlItems::FiltItems::FltList::FltList()
:
id{YType::uint32, "id"},
name{YType::str, "name"},
ownerkey{YType::str, "ownerKey"},
ownertag{YType::str, "ownerTag"},
descr{YType::str, "descr"}
,
ent_items(std::make_shared<System::ActrlItems::FiltItems::FltList::EntItems>())
, rtfvtoremoterfltp_items(std::make_shared<System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltPItems>())
, rtfvtoremoterfltatt_items(std::make_shared<System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltAttItems>())
, rsrfltpconn_items(std::make_shared<System::ActrlItems::FiltItems::FltList::RsrfltpConnItems>())
, rtvnsconntofltinst_items(std::make_shared<System::ActrlItems::FiltItems::FltList::RtvnsConnToFltInstItems>())
, rtvzfwdrfltpatt_items(std::make_shared<System::ActrlItems::FiltItems::FltList::RtvzFwdRFltPAttItems>())
, rtvzrevrfltpatt_items(std::make_shared<System::ActrlItems::FiltItems::FltList::RtvzRevRFltPAttItems>())
, rtvztaboorfltatt_items(std::make_shared<System::ActrlItems::FiltItems::FltList::RtvzTabooRFltAttItems>())
, rtvzrfltatt_items(std::make_shared<System::ActrlItems::FiltItems::FltList::RtvzRFltAttItems>())
{
ent_items->parent = this;
rtfvtoremoterfltp_items->parent = this;
rtfvtoremoterfltatt_items->parent = this;
rsrfltpconn_items->parent = this;
rtvnsconntofltinst_items->parent = this;
rtvzfwdrfltpatt_items->parent = this;
rtvzrevrfltpatt_items->parent = this;
rtvztaboorfltatt_items->parent = this;
rtvzrfltatt_items->parent = this;
yang_name = "Flt-list"; yang_parent_name = "filt-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::ActrlItems::FiltItems::FltList::~FltList()
{
}
bool System::ActrlItems::FiltItems::FltList::has_data() const
{
if (is_presence_container) return true;
return id.is_set
|| name.is_set
|| ownerkey.is_set
|| ownertag.is_set
|| descr.is_set
|| (ent_items != nullptr && ent_items->has_data())
|| (rtfvtoremoterfltp_items != nullptr && rtfvtoremoterfltp_items->has_data())
|| (rtfvtoremoterfltatt_items != nullptr && rtfvtoremoterfltatt_items->has_data())
|| (rsrfltpconn_items != nullptr && rsrfltpconn_items->has_data())
|| (rtvnsconntofltinst_items != nullptr && rtvnsconntofltinst_items->has_data())
|| (rtvzfwdrfltpatt_items != nullptr && rtvzfwdrfltpatt_items->has_data())
|| (rtvzrevrfltpatt_items != nullptr && rtvzrevrfltpatt_items->has_data())
|| (rtvztaboorfltatt_items != nullptr && rtvztaboorfltatt_items->has_data())
|| (rtvzrfltatt_items != nullptr && rtvzrfltatt_items->has_data());
}
bool System::ActrlItems::FiltItems::FltList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(id.yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(ownerkey.yfilter)
|| ydk::is_set(ownertag.yfilter)
|| ydk::is_set(descr.yfilter)
|| (ent_items != nullptr && ent_items->has_operation())
|| (rtfvtoremoterfltp_items != nullptr && rtfvtoremoterfltp_items->has_operation())
|| (rtfvtoremoterfltatt_items != nullptr && rtfvtoremoterfltatt_items->has_operation())
|| (rsrfltpconn_items != nullptr && rsrfltpconn_items->has_operation())
|| (rtvnsconntofltinst_items != nullptr && rtvnsconntofltinst_items->has_operation())
|| (rtvzfwdrfltpatt_items != nullptr && rtvzfwdrfltpatt_items->has_operation())
|| (rtvzrevrfltpatt_items != nullptr && rtvzrevrfltpatt_items->has_operation())
|| (rtvztaboorfltatt_items != nullptr && rtvztaboorfltatt_items->has_operation())
|| (rtvzrfltatt_items != nullptr && rtvzrfltatt_items->has_operation());
}
std::string System::ActrlItems::FiltItems::FltList::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/actrl-items/filt-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::ActrlItems::FiltItems::FltList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "Flt-list";
ADD_KEY_TOKEN(id, "id");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::FiltItems::FltList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (id.is_set || is_set(id.yfilter)) leaf_name_data.push_back(id.get_name_leafdata());
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (ownerkey.is_set || is_set(ownerkey.yfilter)) leaf_name_data.push_back(ownerkey.get_name_leafdata());
if (ownertag.is_set || is_set(ownertag.yfilter)) leaf_name_data.push_back(ownertag.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::FiltItems::FltList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "ent-items")
{
if(ent_items == nullptr)
{
ent_items = std::make_shared<System::ActrlItems::FiltItems::FltList::EntItems>();
}
return ent_items;
}
if(child_yang_name == "rtfvToRemoteRFltP-items")
{
if(rtfvtoremoterfltp_items == nullptr)
{
rtfvtoremoterfltp_items = std::make_shared<System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltPItems>();
}
return rtfvtoremoterfltp_items;
}
if(child_yang_name == "rtfvToRemoteRFltAtt-items")
{
if(rtfvtoremoterfltatt_items == nullptr)
{
rtfvtoremoterfltatt_items = std::make_shared<System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltAttItems>();
}
return rtfvtoremoterfltatt_items;
}
if(child_yang_name == "rsrfltpConn-items")
{
if(rsrfltpconn_items == nullptr)
{
rsrfltpconn_items = std::make_shared<System::ActrlItems::FiltItems::FltList::RsrfltpConnItems>();
}
return rsrfltpconn_items;
}
if(child_yang_name == "rtvnsConnToFltInst-items")
{
if(rtvnsconntofltinst_items == nullptr)
{
rtvnsconntofltinst_items = std::make_shared<System::ActrlItems::FiltItems::FltList::RtvnsConnToFltInstItems>();
}
return rtvnsconntofltinst_items;
}
if(child_yang_name == "rtvzFwdRFltPAtt-items")
{
if(rtvzfwdrfltpatt_items == nullptr)
{
rtvzfwdrfltpatt_items = std::make_shared<System::ActrlItems::FiltItems::FltList::RtvzFwdRFltPAttItems>();
}
return rtvzfwdrfltpatt_items;
}
if(child_yang_name == "rtvzRevRFltPAtt-items")
{
if(rtvzrevrfltpatt_items == nullptr)
{
rtvzrevrfltpatt_items = std::make_shared<System::ActrlItems::FiltItems::FltList::RtvzRevRFltPAttItems>();
}
return rtvzrevrfltpatt_items;
}
if(child_yang_name == "rtvzTabooRFltAtt-items")
{
if(rtvztaboorfltatt_items == nullptr)
{
rtvztaboorfltatt_items = std::make_shared<System::ActrlItems::FiltItems::FltList::RtvzTabooRFltAttItems>();
}
return rtvztaboorfltatt_items;
}
if(child_yang_name == "rtvzRFltAtt-items")
{
if(rtvzrfltatt_items == nullptr)
{
rtvzrfltatt_items = std::make_shared<System::ActrlItems::FiltItems::FltList::RtvzRFltAttItems>();
}
return rtvzrfltatt_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::FiltItems::FltList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(ent_items != nullptr)
{
_children["ent-items"] = ent_items;
}
if(rtfvtoremoterfltp_items != nullptr)
{
_children["rtfvToRemoteRFltP-items"] = rtfvtoremoterfltp_items;
}
if(rtfvtoremoterfltatt_items != nullptr)
{
_children["rtfvToRemoteRFltAtt-items"] = rtfvtoremoterfltatt_items;
}
if(rsrfltpconn_items != nullptr)
{
_children["rsrfltpConn-items"] = rsrfltpconn_items;
}
if(rtvnsconntofltinst_items != nullptr)
{
_children["rtvnsConnToFltInst-items"] = rtvnsconntofltinst_items;
}
if(rtvzfwdrfltpatt_items != nullptr)
{
_children["rtvzFwdRFltPAtt-items"] = rtvzfwdrfltpatt_items;
}
if(rtvzrevrfltpatt_items != nullptr)
{
_children["rtvzRevRFltPAtt-items"] = rtvzrevrfltpatt_items;
}
if(rtvztaboorfltatt_items != nullptr)
{
_children["rtvzTabooRFltAtt-items"] = rtvztaboorfltatt_items;
}
if(rtvzrfltatt_items != nullptr)
{
_children["rtvzRFltAtt-items"] = rtvzrfltatt_items;
}
return _children;
}
void System::ActrlItems::FiltItems::FltList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "id")
{
id = value;
id.value_namespace = name_space;
id.value_namespace_prefix = name_space_prefix;
}
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "ownerKey")
{
ownerkey = value;
ownerkey.value_namespace = name_space;
ownerkey.value_namespace_prefix = name_space_prefix;
}
if(value_path == "ownerTag")
{
ownertag = value;
ownertag.value_namespace = name_space;
ownertag.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
}
void System::ActrlItems::FiltItems::FltList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "id")
{
id.yfilter = yfilter;
}
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "ownerKey")
{
ownerkey.yfilter = yfilter;
}
if(value_path == "ownerTag")
{
ownertag.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
}
bool System::ActrlItems::FiltItems::FltList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "ent-items" || name == "rtfvToRemoteRFltP-items" || name == "rtfvToRemoteRFltAtt-items" || name == "rsrfltpConn-items" || name == "rtvnsConnToFltInst-items" || name == "rtvzFwdRFltPAtt-items" || name == "rtvzRevRFltPAtt-items" || name == "rtvzTabooRFltAtt-items" || name == "rtvzRFltAtt-items" || name == "id" || name == "name" || name == "ownerKey" || name == "ownerTag" || name == "descr")
return true;
return false;
}
System::ActrlItems::FiltItems::FltList::EntItems::EntItems()
:
entry_list(this, {"name"})
{
yang_name = "ent-items"; yang_parent_name = "Flt-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::FiltItems::FltList::EntItems::~EntItems()
{
}
bool System::ActrlItems::FiltItems::FltList::EntItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<entry_list.len(); index++)
{
if(entry_list[index]->has_data())
return true;
}
return false;
}
bool System::ActrlItems::FiltItems::FltList::EntItems::has_operation() const
{
for (std::size_t index=0; index<entry_list.len(); index++)
{
if(entry_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::ActrlItems::FiltItems::FltList::EntItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "ent-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::FiltItems::FltList::EntItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::FiltItems::FltList::EntItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "Entry-list")
{
auto ent_ = std::make_shared<System::ActrlItems::FiltItems::FltList::EntItems::EntryList>();
ent_->parent = this;
entry_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::FiltItems::FltList::EntItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : entry_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::ActrlItems::FiltItems::FltList::EntItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::ActrlItems::FiltItems::FltList::EntItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::ActrlItems::FiltItems::FltList::EntItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "Entry-list")
return true;
return false;
}
System::ActrlItems::FiltItems::FltList::EntItems::EntryList::EntryList()
:
name{YType::str, "name"},
descr{YType::str, "descr"},
applytofrag{YType::boolean, "applyToFrag"},
ethert{YType::enumeration, "etherT"},
arpopc{YType::enumeration, "arpOpc"},
icmpv4t{YType::uint8, "icmpv4T"},
icmpv6t{YType::uint8, "icmpv6T"}
{
yang_name = "Entry-list"; yang_parent_name = "ent-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::FiltItems::FltList::EntItems::EntryList::~EntryList()
{
}
bool System::ActrlItems::FiltItems::FltList::EntItems::EntryList::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| descr.is_set
|| applytofrag.is_set
|| ethert.is_set
|| arpopc.is_set
|| icmpv4t.is_set
|| icmpv6t.is_set;
}
bool System::ActrlItems::FiltItems::FltList::EntItems::EntryList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(descr.yfilter)
|| ydk::is_set(applytofrag.yfilter)
|| ydk::is_set(ethert.yfilter)
|| ydk::is_set(arpopc.yfilter)
|| ydk::is_set(icmpv4t.yfilter)
|| ydk::is_set(icmpv6t.yfilter);
}
std::string System::ActrlItems::FiltItems::FltList::EntItems::EntryList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "Entry-list";
ADD_KEY_TOKEN(name, "name");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::FiltItems::FltList::EntItems::EntryList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
if (applytofrag.is_set || is_set(applytofrag.yfilter)) leaf_name_data.push_back(applytofrag.get_name_leafdata());
if (ethert.is_set || is_set(ethert.yfilter)) leaf_name_data.push_back(ethert.get_name_leafdata());
if (arpopc.is_set || is_set(arpopc.yfilter)) leaf_name_data.push_back(arpopc.get_name_leafdata());
if (icmpv4t.is_set || is_set(icmpv4t.yfilter)) leaf_name_data.push_back(icmpv4t.get_name_leafdata());
if (icmpv6t.is_set || is_set(icmpv6t.yfilter)) leaf_name_data.push_back(icmpv6t.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::FiltItems::FltList::EntItems::EntryList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::FiltItems::FltList::EntItems::EntryList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::ActrlItems::FiltItems::FltList::EntItems::EntryList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
if(value_path == "applyToFrag")
{
applytofrag = value;
applytofrag.value_namespace = name_space;
applytofrag.value_namespace_prefix = name_space_prefix;
}
if(value_path == "etherT")
{
ethert = value;
ethert.value_namespace = name_space;
ethert.value_namespace_prefix = name_space_prefix;
}
if(value_path == "arpOpc")
{
arpopc = value;
arpopc.value_namespace = name_space;
arpopc.value_namespace_prefix = name_space_prefix;
}
if(value_path == "icmpv4T")
{
icmpv4t = value;
icmpv4t.value_namespace = name_space;
icmpv4t.value_namespace_prefix = name_space_prefix;
}
if(value_path == "icmpv6T")
{
icmpv6t = value;
icmpv6t.value_namespace = name_space;
icmpv6t.value_namespace_prefix = name_space_prefix;
}
}
void System::ActrlItems::FiltItems::FltList::EntItems::EntryList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
if(value_path == "applyToFrag")
{
applytofrag.yfilter = yfilter;
}
if(value_path == "etherT")
{
ethert.yfilter = yfilter;
}
if(value_path == "arpOpc")
{
arpopc.yfilter = yfilter;
}
if(value_path == "icmpv4T")
{
icmpv4t.yfilter = yfilter;
}
if(value_path == "icmpv6T")
{
icmpv6t.yfilter = yfilter;
}
}
bool System::ActrlItems::FiltItems::FltList::EntItems::EntryList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "name" || name == "descr" || name == "applyToFrag" || name == "etherT" || name == "arpOpc" || name == "icmpv4T" || name == "icmpv6T")
return true;
return false;
}
System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltPItems::RtfvToRemoteRFltPItems()
:
rtfvtoremoterfltp_list(this, {"tdn"})
{
yang_name = "rtfvToRemoteRFltP-items"; yang_parent_name = "Flt-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltPItems::~RtfvToRemoteRFltPItems()
{
}
bool System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltPItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<rtfvtoremoterfltp_list.len(); index++)
{
if(rtfvtoremoterfltp_list[index]->has_data())
return true;
}
return false;
}
bool System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltPItems::has_operation() const
{
for (std::size_t index=0; index<rtfvtoremoterfltp_list.len(); index++)
{
if(rtfvtoremoterfltp_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltPItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "rtfvToRemoteRFltP-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltPItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltPItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "RtFvToRemoteRFltP-list")
{
auto ent_ = std::make_shared<System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltPItems::RtFvToRemoteRFltPList>();
ent_->parent = this;
rtfvtoremoterfltp_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltPItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : rtfvtoremoterfltp_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltPItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltPItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltPItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "RtFvToRemoteRFltP-list")
return true;
return false;
}
System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltPItems::RtFvToRemoteRFltPList::RtFvToRemoteRFltPList()
:
tdn{YType::str, "tDn"}
{
yang_name = "RtFvToRemoteRFltP-list"; yang_parent_name = "rtfvToRemoteRFltP-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltPItems::RtFvToRemoteRFltPList::~RtFvToRemoteRFltPList()
{
}
bool System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltPItems::RtFvToRemoteRFltPList::has_data() const
{
if (is_presence_container) return true;
return tdn.is_set;
}
bool System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltPItems::RtFvToRemoteRFltPList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(tdn.yfilter);
}
std::string System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltPItems::RtFvToRemoteRFltPList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "RtFvToRemoteRFltP-list";
ADD_KEY_TOKEN(tdn, "tDn");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltPItems::RtFvToRemoteRFltPList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (tdn.is_set || is_set(tdn.yfilter)) leaf_name_data.push_back(tdn.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltPItems::RtFvToRemoteRFltPList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltPItems::RtFvToRemoteRFltPList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltPItems::RtFvToRemoteRFltPList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "tDn")
{
tdn = value;
tdn.value_namespace = name_space;
tdn.value_namespace_prefix = name_space_prefix;
}
}
void System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltPItems::RtFvToRemoteRFltPList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "tDn")
{
tdn.yfilter = yfilter;
}
}
bool System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltPItems::RtFvToRemoteRFltPList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "tDn")
return true;
return false;
}
System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltAttItems::RtfvToRemoteRFltAttItems()
:
rtfvtoremoterfltatt_list(this, {"tdn"})
{
yang_name = "rtfvToRemoteRFltAtt-items"; yang_parent_name = "Flt-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltAttItems::~RtfvToRemoteRFltAttItems()
{
}
bool System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltAttItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<rtfvtoremoterfltatt_list.len(); index++)
{
if(rtfvtoremoterfltatt_list[index]->has_data())
return true;
}
return false;
}
bool System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltAttItems::has_operation() const
{
for (std::size_t index=0; index<rtfvtoremoterfltatt_list.len(); index++)
{
if(rtfvtoremoterfltatt_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltAttItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "rtfvToRemoteRFltAtt-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltAttItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltAttItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "RtFvToRemoteRFltAtt-list")
{
auto ent_ = std::make_shared<System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltAttItems::RtFvToRemoteRFltAttList>();
ent_->parent = this;
rtfvtoremoterfltatt_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltAttItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : rtfvtoremoterfltatt_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltAttItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltAttItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltAttItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "RtFvToRemoteRFltAtt-list")
return true;
return false;
}
System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltAttItems::RtFvToRemoteRFltAttList::RtFvToRemoteRFltAttList()
:
tdn{YType::str, "tDn"}
{
yang_name = "RtFvToRemoteRFltAtt-list"; yang_parent_name = "rtfvToRemoteRFltAtt-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltAttItems::RtFvToRemoteRFltAttList::~RtFvToRemoteRFltAttList()
{
}
bool System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltAttItems::RtFvToRemoteRFltAttList::has_data() const
{
if (is_presence_container) return true;
return tdn.is_set;
}
bool System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltAttItems::RtFvToRemoteRFltAttList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(tdn.yfilter);
}
std::string System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltAttItems::RtFvToRemoteRFltAttList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "RtFvToRemoteRFltAtt-list";
ADD_KEY_TOKEN(tdn, "tDn");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltAttItems::RtFvToRemoteRFltAttList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (tdn.is_set || is_set(tdn.yfilter)) leaf_name_data.push_back(tdn.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltAttItems::RtFvToRemoteRFltAttList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltAttItems::RtFvToRemoteRFltAttList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltAttItems::RtFvToRemoteRFltAttList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "tDn")
{
tdn = value;
tdn.value_namespace = name_space;
tdn.value_namespace_prefix = name_space_prefix;
}
}
void System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltAttItems::RtFvToRemoteRFltAttList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "tDn")
{
tdn.yfilter = yfilter;
}
}
bool System::ActrlItems::FiltItems::FltList::RtfvToRemoteRFltAttItems::RtFvToRemoteRFltAttList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "tDn")
return true;
return false;
}
System::ActrlItems::FiltItems::FltList::RsrfltpConnItems::RsrfltpConnItems()
:
tdn{YType::str, "tDn"}
{
yang_name = "rsrfltpConn-items"; yang_parent_name = "Flt-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::FiltItems::FltList::RsrfltpConnItems::~RsrfltpConnItems()
{
}
bool System::ActrlItems::FiltItems::FltList::RsrfltpConnItems::has_data() const
{
if (is_presence_container) return true;
return tdn.is_set;
}
bool System::ActrlItems::FiltItems::FltList::RsrfltpConnItems::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(tdn.yfilter);
}
std::string System::ActrlItems::FiltItems::FltList::RsrfltpConnItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "rsrfltpConn-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::FiltItems::FltList::RsrfltpConnItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (tdn.is_set || is_set(tdn.yfilter)) leaf_name_data.push_back(tdn.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::FiltItems::FltList::RsrfltpConnItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::FiltItems::FltList::RsrfltpConnItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::ActrlItems::FiltItems::FltList::RsrfltpConnItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "tDn")
{
tdn = value;
tdn.value_namespace = name_space;
tdn.value_namespace_prefix = name_space_prefix;
}
}
void System::ActrlItems::FiltItems::FltList::RsrfltpConnItems::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "tDn")
{
tdn.yfilter = yfilter;
}
}
bool System::ActrlItems::FiltItems::FltList::RsrfltpConnItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "tDn")
return true;
return false;
}
System::ActrlItems::FiltItems::FltList::RtvnsConnToFltInstItems::RtvnsConnToFltInstItems()
:
rtvnsconntofltinst_list(this, {"tdn"})
{
yang_name = "rtvnsConnToFltInst-items"; yang_parent_name = "Flt-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::FiltItems::FltList::RtvnsConnToFltInstItems::~RtvnsConnToFltInstItems()
{
}
bool System::ActrlItems::FiltItems::FltList::RtvnsConnToFltInstItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<rtvnsconntofltinst_list.len(); index++)
{
if(rtvnsconntofltinst_list[index]->has_data())
return true;
}
return false;
}
bool System::ActrlItems::FiltItems::FltList::RtvnsConnToFltInstItems::has_operation() const
{
for (std::size_t index=0; index<rtvnsconntofltinst_list.len(); index++)
{
if(rtvnsconntofltinst_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::ActrlItems::FiltItems::FltList::RtvnsConnToFltInstItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "rtvnsConnToFltInst-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::FiltItems::FltList::RtvnsConnToFltInstItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::FiltItems::FltList::RtvnsConnToFltInstItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "RtVnsConnToFltInst-list")
{
auto ent_ = std::make_shared<System::ActrlItems::FiltItems::FltList::RtvnsConnToFltInstItems::RtVnsConnToFltInstList>();
ent_->parent = this;
rtvnsconntofltinst_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::FiltItems::FltList::RtvnsConnToFltInstItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : rtvnsconntofltinst_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::ActrlItems::FiltItems::FltList::RtvnsConnToFltInstItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::ActrlItems::FiltItems::FltList::RtvnsConnToFltInstItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::ActrlItems::FiltItems::FltList::RtvnsConnToFltInstItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "RtVnsConnToFltInst-list")
return true;
return false;
}
System::ActrlItems::FiltItems::FltList::RtvnsConnToFltInstItems::RtVnsConnToFltInstList::RtVnsConnToFltInstList()
:
tdn{YType::str, "tDn"}
{
yang_name = "RtVnsConnToFltInst-list"; yang_parent_name = "rtvnsConnToFltInst-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::FiltItems::FltList::RtvnsConnToFltInstItems::RtVnsConnToFltInstList::~RtVnsConnToFltInstList()
{
}
bool System::ActrlItems::FiltItems::FltList::RtvnsConnToFltInstItems::RtVnsConnToFltInstList::has_data() const
{
if (is_presence_container) return true;
return tdn.is_set;
}
bool System::ActrlItems::FiltItems::FltList::RtvnsConnToFltInstItems::RtVnsConnToFltInstList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(tdn.yfilter);
}
std::string System::ActrlItems::FiltItems::FltList::RtvnsConnToFltInstItems::RtVnsConnToFltInstList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "RtVnsConnToFltInst-list";
ADD_KEY_TOKEN(tdn, "tDn");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::FiltItems::FltList::RtvnsConnToFltInstItems::RtVnsConnToFltInstList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (tdn.is_set || is_set(tdn.yfilter)) leaf_name_data.push_back(tdn.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::FiltItems::FltList::RtvnsConnToFltInstItems::RtVnsConnToFltInstList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::FiltItems::FltList::RtvnsConnToFltInstItems::RtVnsConnToFltInstList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::ActrlItems::FiltItems::FltList::RtvnsConnToFltInstItems::RtVnsConnToFltInstList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "tDn")
{
tdn = value;
tdn.value_namespace = name_space;
tdn.value_namespace_prefix = name_space_prefix;
}
}
void System::ActrlItems::FiltItems::FltList::RtvnsConnToFltInstItems::RtVnsConnToFltInstList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "tDn")
{
tdn.yfilter = yfilter;
}
}
bool System::ActrlItems::FiltItems::FltList::RtvnsConnToFltInstItems::RtVnsConnToFltInstList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "tDn")
return true;
return false;
}
System::ActrlItems::FiltItems::FltList::RtvzFwdRFltPAttItems::RtvzFwdRFltPAttItems()
:
rtvzfwdrfltpatt_list(this, {"tdn"})
{
yang_name = "rtvzFwdRFltPAtt-items"; yang_parent_name = "Flt-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::FiltItems::FltList::RtvzFwdRFltPAttItems::~RtvzFwdRFltPAttItems()
{
}
bool System::ActrlItems::FiltItems::FltList::RtvzFwdRFltPAttItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<rtvzfwdrfltpatt_list.len(); index++)
{
if(rtvzfwdrfltpatt_list[index]->has_data())
return true;
}
return false;
}
bool System::ActrlItems::FiltItems::FltList::RtvzFwdRFltPAttItems::has_operation() const
{
for (std::size_t index=0; index<rtvzfwdrfltpatt_list.len(); index++)
{
if(rtvzfwdrfltpatt_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::ActrlItems::FiltItems::FltList::RtvzFwdRFltPAttItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "rtvzFwdRFltPAtt-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::FiltItems::FltList::RtvzFwdRFltPAttItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::FiltItems::FltList::RtvzFwdRFltPAttItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "RtVzFwdRFltPAtt-list")
{
auto ent_ = std::make_shared<System::ActrlItems::FiltItems::FltList::RtvzFwdRFltPAttItems::RtVzFwdRFltPAttList>();
ent_->parent = this;
rtvzfwdrfltpatt_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::FiltItems::FltList::RtvzFwdRFltPAttItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : rtvzfwdrfltpatt_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::ActrlItems::FiltItems::FltList::RtvzFwdRFltPAttItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::ActrlItems::FiltItems::FltList::RtvzFwdRFltPAttItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::ActrlItems::FiltItems::FltList::RtvzFwdRFltPAttItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "RtVzFwdRFltPAtt-list")
return true;
return false;
}
System::ActrlItems::FiltItems::FltList::RtvzFwdRFltPAttItems::RtVzFwdRFltPAttList::RtVzFwdRFltPAttList()
:
tdn{YType::str, "tDn"}
{
yang_name = "RtVzFwdRFltPAtt-list"; yang_parent_name = "rtvzFwdRFltPAtt-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::FiltItems::FltList::RtvzFwdRFltPAttItems::RtVzFwdRFltPAttList::~RtVzFwdRFltPAttList()
{
}
bool System::ActrlItems::FiltItems::FltList::RtvzFwdRFltPAttItems::RtVzFwdRFltPAttList::has_data() const
{
if (is_presence_container) return true;
return tdn.is_set;
}
bool System::ActrlItems::FiltItems::FltList::RtvzFwdRFltPAttItems::RtVzFwdRFltPAttList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(tdn.yfilter);
}
std::string System::ActrlItems::FiltItems::FltList::RtvzFwdRFltPAttItems::RtVzFwdRFltPAttList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "RtVzFwdRFltPAtt-list";
ADD_KEY_TOKEN(tdn, "tDn");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::FiltItems::FltList::RtvzFwdRFltPAttItems::RtVzFwdRFltPAttList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (tdn.is_set || is_set(tdn.yfilter)) leaf_name_data.push_back(tdn.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::FiltItems::FltList::RtvzFwdRFltPAttItems::RtVzFwdRFltPAttList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::FiltItems::FltList::RtvzFwdRFltPAttItems::RtVzFwdRFltPAttList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::ActrlItems::FiltItems::FltList::RtvzFwdRFltPAttItems::RtVzFwdRFltPAttList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "tDn")
{
tdn = value;
tdn.value_namespace = name_space;
tdn.value_namespace_prefix = name_space_prefix;
}
}
void System::ActrlItems::FiltItems::FltList::RtvzFwdRFltPAttItems::RtVzFwdRFltPAttList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "tDn")
{
tdn.yfilter = yfilter;
}
}
bool System::ActrlItems::FiltItems::FltList::RtvzFwdRFltPAttItems::RtVzFwdRFltPAttList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "tDn")
return true;
return false;
}
System::ActrlItems::FiltItems::FltList::RtvzRevRFltPAttItems::RtvzRevRFltPAttItems()
:
rtvzrevrfltpatt_list(this, {"tdn"})
{
yang_name = "rtvzRevRFltPAtt-items"; yang_parent_name = "Flt-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::FiltItems::FltList::RtvzRevRFltPAttItems::~RtvzRevRFltPAttItems()
{
}
bool System::ActrlItems::FiltItems::FltList::RtvzRevRFltPAttItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<rtvzrevrfltpatt_list.len(); index++)
{
if(rtvzrevrfltpatt_list[index]->has_data())
return true;
}
return false;
}
bool System::ActrlItems::FiltItems::FltList::RtvzRevRFltPAttItems::has_operation() const
{
for (std::size_t index=0; index<rtvzrevrfltpatt_list.len(); index++)
{
if(rtvzrevrfltpatt_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::ActrlItems::FiltItems::FltList::RtvzRevRFltPAttItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "rtvzRevRFltPAtt-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::FiltItems::FltList::RtvzRevRFltPAttItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::FiltItems::FltList::RtvzRevRFltPAttItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "RtVzRevRFltPAtt-list")
{
auto ent_ = std::make_shared<System::ActrlItems::FiltItems::FltList::RtvzRevRFltPAttItems::RtVzRevRFltPAttList>();
ent_->parent = this;
rtvzrevrfltpatt_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::FiltItems::FltList::RtvzRevRFltPAttItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : rtvzrevrfltpatt_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::ActrlItems::FiltItems::FltList::RtvzRevRFltPAttItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::ActrlItems::FiltItems::FltList::RtvzRevRFltPAttItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::ActrlItems::FiltItems::FltList::RtvzRevRFltPAttItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "RtVzRevRFltPAtt-list")
return true;
return false;
}
System::ActrlItems::FiltItems::FltList::RtvzRevRFltPAttItems::RtVzRevRFltPAttList::RtVzRevRFltPAttList()
:
tdn{YType::str, "tDn"}
{
yang_name = "RtVzRevRFltPAtt-list"; yang_parent_name = "rtvzRevRFltPAtt-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::FiltItems::FltList::RtvzRevRFltPAttItems::RtVzRevRFltPAttList::~RtVzRevRFltPAttList()
{
}
bool System::ActrlItems::FiltItems::FltList::RtvzRevRFltPAttItems::RtVzRevRFltPAttList::has_data() const
{
if (is_presence_container) return true;
return tdn.is_set;
}
bool System::ActrlItems::FiltItems::FltList::RtvzRevRFltPAttItems::RtVzRevRFltPAttList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(tdn.yfilter);
}
std::string System::ActrlItems::FiltItems::FltList::RtvzRevRFltPAttItems::RtVzRevRFltPAttList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "RtVzRevRFltPAtt-list";
ADD_KEY_TOKEN(tdn, "tDn");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::FiltItems::FltList::RtvzRevRFltPAttItems::RtVzRevRFltPAttList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (tdn.is_set || is_set(tdn.yfilter)) leaf_name_data.push_back(tdn.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::FiltItems::FltList::RtvzRevRFltPAttItems::RtVzRevRFltPAttList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::FiltItems::FltList::RtvzRevRFltPAttItems::RtVzRevRFltPAttList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::ActrlItems::FiltItems::FltList::RtvzRevRFltPAttItems::RtVzRevRFltPAttList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "tDn")
{
tdn = value;
tdn.value_namespace = name_space;
tdn.value_namespace_prefix = name_space_prefix;
}
}
void System::ActrlItems::FiltItems::FltList::RtvzRevRFltPAttItems::RtVzRevRFltPAttList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "tDn")
{
tdn.yfilter = yfilter;
}
}
bool System::ActrlItems::FiltItems::FltList::RtvzRevRFltPAttItems::RtVzRevRFltPAttList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "tDn")
return true;
return false;
}
System::ActrlItems::FiltItems::FltList::RtvzTabooRFltAttItems::RtvzTabooRFltAttItems()
:
rtvztaboorfltatt_list(this, {"tdn"})
{
yang_name = "rtvzTabooRFltAtt-items"; yang_parent_name = "Flt-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::FiltItems::FltList::RtvzTabooRFltAttItems::~RtvzTabooRFltAttItems()
{
}
bool System::ActrlItems::FiltItems::FltList::RtvzTabooRFltAttItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<rtvztaboorfltatt_list.len(); index++)
{
if(rtvztaboorfltatt_list[index]->has_data())
return true;
}
return false;
}
bool System::ActrlItems::FiltItems::FltList::RtvzTabooRFltAttItems::has_operation() const
{
for (std::size_t index=0; index<rtvztaboorfltatt_list.len(); index++)
{
if(rtvztaboorfltatt_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::ActrlItems::FiltItems::FltList::RtvzTabooRFltAttItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "rtvzTabooRFltAtt-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::FiltItems::FltList::RtvzTabooRFltAttItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::FiltItems::FltList::RtvzTabooRFltAttItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "RtVzTabooRFltAtt-list")
{
auto ent_ = std::make_shared<System::ActrlItems::FiltItems::FltList::RtvzTabooRFltAttItems::RtVzTabooRFltAttList>();
ent_->parent = this;
rtvztaboorfltatt_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::FiltItems::FltList::RtvzTabooRFltAttItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : rtvztaboorfltatt_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::ActrlItems::FiltItems::FltList::RtvzTabooRFltAttItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::ActrlItems::FiltItems::FltList::RtvzTabooRFltAttItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::ActrlItems::FiltItems::FltList::RtvzTabooRFltAttItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "RtVzTabooRFltAtt-list")
return true;
return false;
}
System::ActrlItems::FiltItems::FltList::RtvzTabooRFltAttItems::RtVzTabooRFltAttList::RtVzTabooRFltAttList()
:
tdn{YType::str, "tDn"}
{
yang_name = "RtVzTabooRFltAtt-list"; yang_parent_name = "rtvzTabooRFltAtt-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::FiltItems::FltList::RtvzTabooRFltAttItems::RtVzTabooRFltAttList::~RtVzTabooRFltAttList()
{
}
bool System::ActrlItems::FiltItems::FltList::RtvzTabooRFltAttItems::RtVzTabooRFltAttList::has_data() const
{
if (is_presence_container) return true;
return tdn.is_set;
}
bool System::ActrlItems::FiltItems::FltList::RtvzTabooRFltAttItems::RtVzTabooRFltAttList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(tdn.yfilter);
}
std::string System::ActrlItems::FiltItems::FltList::RtvzTabooRFltAttItems::RtVzTabooRFltAttList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "RtVzTabooRFltAtt-list";
ADD_KEY_TOKEN(tdn, "tDn");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::FiltItems::FltList::RtvzTabooRFltAttItems::RtVzTabooRFltAttList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (tdn.is_set || is_set(tdn.yfilter)) leaf_name_data.push_back(tdn.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::FiltItems::FltList::RtvzTabooRFltAttItems::RtVzTabooRFltAttList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::FiltItems::FltList::RtvzTabooRFltAttItems::RtVzTabooRFltAttList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::ActrlItems::FiltItems::FltList::RtvzTabooRFltAttItems::RtVzTabooRFltAttList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "tDn")
{
tdn = value;
tdn.value_namespace = name_space;
tdn.value_namespace_prefix = name_space_prefix;
}
}
void System::ActrlItems::FiltItems::FltList::RtvzTabooRFltAttItems::RtVzTabooRFltAttList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "tDn")
{
tdn.yfilter = yfilter;
}
}
bool System::ActrlItems::FiltItems::FltList::RtvzTabooRFltAttItems::RtVzTabooRFltAttList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "tDn")
return true;
return false;
}
System::ActrlItems::FiltItems::FltList::RtvzRFltAttItems::RtvzRFltAttItems()
:
rtvzrfltatt_list(this, {"tdn"})
{
yang_name = "rtvzRFltAtt-items"; yang_parent_name = "Flt-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::FiltItems::FltList::RtvzRFltAttItems::~RtvzRFltAttItems()
{
}
bool System::ActrlItems::FiltItems::FltList::RtvzRFltAttItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<rtvzrfltatt_list.len(); index++)
{
if(rtvzrfltatt_list[index]->has_data())
return true;
}
return false;
}
bool System::ActrlItems::FiltItems::FltList::RtvzRFltAttItems::has_operation() const
{
for (std::size_t index=0; index<rtvzrfltatt_list.len(); index++)
{
if(rtvzrfltatt_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::ActrlItems::FiltItems::FltList::RtvzRFltAttItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "rtvzRFltAtt-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::FiltItems::FltList::RtvzRFltAttItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::FiltItems::FltList::RtvzRFltAttItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "RtVzRFltAtt-list")
{
auto ent_ = std::make_shared<System::ActrlItems::FiltItems::FltList::RtvzRFltAttItems::RtVzRFltAttList>();
ent_->parent = this;
rtvzrfltatt_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::FiltItems::FltList::RtvzRFltAttItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : rtvzrfltatt_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::ActrlItems::FiltItems::FltList::RtvzRFltAttItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::ActrlItems::FiltItems::FltList::RtvzRFltAttItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::ActrlItems::FiltItems::FltList::RtvzRFltAttItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "RtVzRFltAtt-list")
return true;
return false;
}
System::ActrlItems::FiltItems::FltList::RtvzRFltAttItems::RtVzRFltAttList::RtVzRFltAttList()
:
tdn{YType::str, "tDn"}
{
yang_name = "RtVzRFltAtt-list"; yang_parent_name = "rtvzRFltAtt-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::FiltItems::FltList::RtvzRFltAttItems::RtVzRFltAttList::~RtVzRFltAttList()
{
}
bool System::ActrlItems::FiltItems::FltList::RtvzRFltAttItems::RtVzRFltAttList::has_data() const
{
if (is_presence_container) return true;
return tdn.is_set;
}
bool System::ActrlItems::FiltItems::FltList::RtvzRFltAttItems::RtVzRFltAttList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(tdn.yfilter);
}
std::string System::ActrlItems::FiltItems::FltList::RtvzRFltAttItems::RtVzRFltAttList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "RtVzRFltAtt-list";
ADD_KEY_TOKEN(tdn, "tDn");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::FiltItems::FltList::RtvzRFltAttItems::RtVzRFltAttList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (tdn.is_set || is_set(tdn.yfilter)) leaf_name_data.push_back(tdn.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::FiltItems::FltList::RtvzRFltAttItems::RtVzRFltAttList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::FiltItems::FltList::RtvzRFltAttItems::RtVzRFltAttList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::ActrlItems::FiltItems::FltList::RtvzRFltAttItems::RtVzRFltAttList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "tDn")
{
tdn = value;
tdn.value_namespace = name_space;
tdn.value_namespace_prefix = name_space_prefix;
}
}
void System::ActrlItems::FiltItems::FltList::RtvzRFltAttItems::RtVzRFltAttList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "tDn")
{
tdn.yfilter = yfilter;
}
}
bool System::ActrlItems::FiltItems::FltList::RtvzRFltAttItems::RtVzRFltAttList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "tDn")
return true;
return false;
}
System::ActrlItems::InstItems::InstItems()
:
accctrl{YType::str, "accCtrl"},
logclrintvl{YType::uint16, "logClrIntvl"},
name{YType::str, "name"},
adminst{YType::enumeration, "adminSt"},
ctrl{YType::str, "ctrl"}
{
yang_name = "inst-items"; yang_parent_name = "actrl-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::ActrlItems::InstItems::~InstItems()
{
}
bool System::ActrlItems::InstItems::has_data() const
{
if (is_presence_container) return true;
return accctrl.is_set
|| logclrintvl.is_set
|| name.is_set
|| adminst.is_set
|| ctrl.is_set;
}
bool System::ActrlItems::InstItems::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(accctrl.yfilter)
|| ydk::is_set(logclrintvl.yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(adminst.yfilter)
|| ydk::is_set(ctrl.yfilter);
}
std::string System::ActrlItems::InstItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/actrl-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::ActrlItems::InstItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "inst-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::InstItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (accctrl.is_set || is_set(accctrl.yfilter)) leaf_name_data.push_back(accctrl.get_name_leafdata());
if (logclrintvl.is_set || is_set(logclrintvl.yfilter)) leaf_name_data.push_back(logclrintvl.get_name_leafdata());
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (adminst.is_set || is_set(adminst.yfilter)) leaf_name_data.push_back(adminst.get_name_leafdata());
if (ctrl.is_set || is_set(ctrl.yfilter)) leaf_name_data.push_back(ctrl.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::InstItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::InstItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::ActrlItems::InstItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "accCtrl")
{
accctrl = value;
accctrl.value_namespace = name_space;
accctrl.value_namespace_prefix = name_space_prefix;
}
if(value_path == "logClrIntvl")
{
logclrintvl = value;
logclrintvl.value_namespace = name_space;
logclrintvl.value_namespace_prefix = name_space_prefix;
}
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "adminSt")
{
adminst = value;
adminst.value_namespace = name_space;
adminst.value_namespace_prefix = name_space_prefix;
}
if(value_path == "ctrl")
{
ctrl = value;
ctrl.value_namespace = name_space;
ctrl.value_namespace_prefix = name_space_prefix;
}
}
void System::ActrlItems::InstItems::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "accCtrl")
{
accctrl.yfilter = yfilter;
}
if(value_path == "logClrIntvl")
{
logclrintvl.yfilter = yfilter;
}
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "adminSt")
{
adminst.yfilter = yfilter;
}
if(value_path == "ctrl")
{
ctrl.yfilter = yfilter;
}
}
bool System::ActrlItems::InstItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "accCtrl" || name == "logClrIntvl" || name == "name" || name == "adminSt" || name == "ctrl")
return true;
return false;
}
System::ActrlItems::ScopeItems::ScopeItems()
:
scope_list(this, {"id"})
{
yang_name = "scope-items"; yang_parent_name = "actrl-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::ActrlItems::ScopeItems::~ScopeItems()
{
}
bool System::ActrlItems::ScopeItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<scope_list.len(); index++)
{
if(scope_list[index]->has_data())
return true;
}
return false;
}
bool System::ActrlItems::ScopeItems::has_operation() const
{
for (std::size_t index=0; index<scope_list.len(); index++)
{
if(scope_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::ActrlItems::ScopeItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/actrl-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::ActrlItems::ScopeItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "scope-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::ScopeItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::ScopeItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "Scope-list")
{
auto ent_ = std::make_shared<System::ActrlItems::ScopeItems::ScopeList>();
ent_->parent = this;
scope_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::ScopeItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : scope_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::ActrlItems::ScopeItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::ActrlItems::ScopeItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::ActrlItems::ScopeItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "Scope-list")
return true;
return false;
}
System::ActrlItems::ScopeItems::ScopeList::ScopeList()
:
id{YType::uint32, "id"},
seclbl{YType::uint16, "secLbl"},
name{YType::str, "name"},
descr{YType::str, "descr"}
,
rule_items(std::make_shared<System::ActrlItems::ScopeItems::ScopeList::RuleItems>())
, mr_items(std::make_shared<System::ActrlItems::ScopeItems::ScopeList::MrItems>())
, sr_items(std::make_shared<System::ActrlItems::ScopeItems::ScopeList::SrItems>())
, rstenconn_items(std::make_shared<System::ActrlItems::ScopeItems::ScopeList::RstenConnItems>())
{
rule_items->parent = this;
mr_items->parent = this;
sr_items->parent = this;
rstenconn_items->parent = this;
yang_name = "Scope-list"; yang_parent_name = "scope-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::ActrlItems::ScopeItems::ScopeList::~ScopeList()
{
}
bool System::ActrlItems::ScopeItems::ScopeList::has_data() const
{
if (is_presence_container) return true;
return id.is_set
|| seclbl.is_set
|| name.is_set
|| descr.is_set
|| (rule_items != nullptr && rule_items->has_data())
|| (mr_items != nullptr && mr_items->has_data())
|| (sr_items != nullptr && sr_items->has_data())
|| (rstenconn_items != nullptr && rstenconn_items->has_data());
}
bool System::ActrlItems::ScopeItems::ScopeList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(id.yfilter)
|| ydk::is_set(seclbl.yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(descr.yfilter)
|| (rule_items != nullptr && rule_items->has_operation())
|| (mr_items != nullptr && mr_items->has_operation())
|| (sr_items != nullptr && sr_items->has_operation())
|| (rstenconn_items != nullptr && rstenconn_items->has_operation());
}
std::string System::ActrlItems::ScopeItems::ScopeList::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/actrl-items/scope-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::ActrlItems::ScopeItems::ScopeList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "Scope-list";
ADD_KEY_TOKEN(id, "id");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::ScopeItems::ScopeList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (id.is_set || is_set(id.yfilter)) leaf_name_data.push_back(id.get_name_leafdata());
if (seclbl.is_set || is_set(seclbl.yfilter)) leaf_name_data.push_back(seclbl.get_name_leafdata());
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::ScopeItems::ScopeList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "rule-items")
{
if(rule_items == nullptr)
{
rule_items = std::make_shared<System::ActrlItems::ScopeItems::ScopeList::RuleItems>();
}
return rule_items;
}
if(child_yang_name == "mr-items")
{
if(mr_items == nullptr)
{
mr_items = std::make_shared<System::ActrlItems::ScopeItems::ScopeList::MrItems>();
}
return mr_items;
}
if(child_yang_name == "sr-items")
{
if(sr_items == nullptr)
{
sr_items = std::make_shared<System::ActrlItems::ScopeItems::ScopeList::SrItems>();
}
return sr_items;
}
if(child_yang_name == "rstenConn-items")
{
if(rstenconn_items == nullptr)
{
rstenconn_items = std::make_shared<System::ActrlItems::ScopeItems::ScopeList::RstenConnItems>();
}
return rstenconn_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::ScopeItems::ScopeList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(rule_items != nullptr)
{
_children["rule-items"] = rule_items;
}
if(mr_items != nullptr)
{
_children["mr-items"] = mr_items;
}
if(sr_items != nullptr)
{
_children["sr-items"] = sr_items;
}
if(rstenconn_items != nullptr)
{
_children["rstenConn-items"] = rstenconn_items;
}
return _children;
}
void System::ActrlItems::ScopeItems::ScopeList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "id")
{
id = value;
id.value_namespace = name_space;
id.value_namespace_prefix = name_space_prefix;
}
if(value_path == "secLbl")
{
seclbl = value;
seclbl.value_namespace = name_space;
seclbl.value_namespace_prefix = name_space_prefix;
}
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
}
void System::ActrlItems::ScopeItems::ScopeList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "id")
{
id.yfilter = yfilter;
}
if(value_path == "secLbl")
{
seclbl.yfilter = yfilter;
}
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
}
bool System::ActrlItems::ScopeItems::ScopeList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "rule-items" || name == "mr-items" || name == "sr-items" || name == "rstenConn-items" || name == "id" || name == "secLbl" || name == "name" || name == "descr")
return true;
return false;
}
System::ActrlItems::ScopeItems::ScopeList::RuleItems::RuleItems()
:
rule_list(this, {"scopeid", "spctag", "dpctag", "fltid"})
{
yang_name = "rule-items"; yang_parent_name = "Scope-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::ScopeItems::ScopeList::RuleItems::~RuleItems()
{
}
bool System::ActrlItems::ScopeItems::ScopeList::RuleItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<rule_list.len(); index++)
{
if(rule_list[index]->has_data())
return true;
}
return false;
}
bool System::ActrlItems::ScopeItems::ScopeList::RuleItems::has_operation() const
{
for (std::size_t index=0; index<rule_list.len(); index++)
{
if(rule_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::ActrlItems::ScopeItems::ScopeList::RuleItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "rule-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::ScopeItems::ScopeList::RuleItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::ScopeItems::ScopeList::RuleItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "Rule-list")
{
auto ent_ = std::make_shared<System::ActrlItems::ScopeItems::ScopeList::RuleItems::RuleList>();
ent_->parent = this;
rule_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::ScopeItems::ScopeList::RuleItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : rule_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::ActrlItems::ScopeItems::ScopeList::RuleItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::ActrlItems::ScopeItems::ScopeList::RuleItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::ActrlItems::ScopeItems::ScopeList::RuleItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "Rule-list")
return true;
return false;
}
System::ActrlItems::ScopeItems::ScopeList::RuleItems::RuleList::RuleList()
:
scopeid{YType::uint32, "scopeId"},
spctag{YType::uint32, "sPcTag"},
dpctag{YType::uint32, "dPcTag"},
fltid{YType::uint32, "fltId"},
name{YType::str, "name"},
descr{YType::str, "descr"},
id{YType::uint32, "id"},
type{YType::enumeration, "type"},
prio{YType::uint8, "prio"},
direction{YType::enumeration, "direction"},
action{YType::str, "action"},
qosgrp{YType::enumeration, "qosGrp"},
markdscp{YType::uint8, "markDscp"},
operst{YType::enumeration, "operSt"}
{
yang_name = "Rule-list"; yang_parent_name = "rule-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::ScopeItems::ScopeList::RuleItems::RuleList::~RuleList()
{
}
bool System::ActrlItems::ScopeItems::ScopeList::RuleItems::RuleList::has_data() const
{
if (is_presence_container) return true;
return scopeid.is_set
|| spctag.is_set
|| dpctag.is_set
|| fltid.is_set
|| name.is_set
|| descr.is_set
|| id.is_set
|| type.is_set
|| prio.is_set
|| direction.is_set
|| action.is_set
|| qosgrp.is_set
|| markdscp.is_set
|| operst.is_set;
}
bool System::ActrlItems::ScopeItems::ScopeList::RuleItems::RuleList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(scopeid.yfilter)
|| ydk::is_set(spctag.yfilter)
|| ydk::is_set(dpctag.yfilter)
|| ydk::is_set(fltid.yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(descr.yfilter)
|| ydk::is_set(id.yfilter)
|| ydk::is_set(type.yfilter)
|| ydk::is_set(prio.yfilter)
|| ydk::is_set(direction.yfilter)
|| ydk::is_set(action.yfilter)
|| ydk::is_set(qosgrp.yfilter)
|| ydk::is_set(markdscp.yfilter)
|| ydk::is_set(operst.yfilter);
}
std::string System::ActrlItems::ScopeItems::ScopeList::RuleItems::RuleList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "Rule-list";
ADD_KEY_TOKEN(scopeid, "scopeId");
ADD_KEY_TOKEN(spctag, "sPcTag");
ADD_KEY_TOKEN(dpctag, "dPcTag");
ADD_KEY_TOKEN(fltid, "fltId");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::ScopeItems::ScopeList::RuleItems::RuleList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (scopeid.is_set || is_set(scopeid.yfilter)) leaf_name_data.push_back(scopeid.get_name_leafdata());
if (spctag.is_set || is_set(spctag.yfilter)) leaf_name_data.push_back(spctag.get_name_leafdata());
if (dpctag.is_set || is_set(dpctag.yfilter)) leaf_name_data.push_back(dpctag.get_name_leafdata());
if (fltid.is_set || is_set(fltid.yfilter)) leaf_name_data.push_back(fltid.get_name_leafdata());
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
if (id.is_set || is_set(id.yfilter)) leaf_name_data.push_back(id.get_name_leafdata());
if (type.is_set || is_set(type.yfilter)) leaf_name_data.push_back(type.get_name_leafdata());
if (prio.is_set || is_set(prio.yfilter)) leaf_name_data.push_back(prio.get_name_leafdata());
if (direction.is_set || is_set(direction.yfilter)) leaf_name_data.push_back(direction.get_name_leafdata());
if (action.is_set || is_set(action.yfilter)) leaf_name_data.push_back(action.get_name_leafdata());
if (qosgrp.is_set || is_set(qosgrp.yfilter)) leaf_name_data.push_back(qosgrp.get_name_leafdata());
if (markdscp.is_set || is_set(markdscp.yfilter)) leaf_name_data.push_back(markdscp.get_name_leafdata());
if (operst.is_set || is_set(operst.yfilter)) leaf_name_data.push_back(operst.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::ScopeItems::ScopeList::RuleItems::RuleList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::ScopeItems::ScopeList::RuleItems::RuleList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::ActrlItems::ScopeItems::ScopeList::RuleItems::RuleList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "scopeId")
{
scopeid = value;
scopeid.value_namespace = name_space;
scopeid.value_namespace_prefix = name_space_prefix;
}
if(value_path == "sPcTag")
{
spctag = value;
spctag.value_namespace = name_space;
spctag.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dPcTag")
{
dpctag = value;
dpctag.value_namespace = name_space;
dpctag.value_namespace_prefix = name_space_prefix;
}
if(value_path == "fltId")
{
fltid = value;
fltid.value_namespace = name_space;
fltid.value_namespace_prefix = name_space_prefix;
}
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
if(value_path == "id")
{
id = value;
id.value_namespace = name_space;
id.value_namespace_prefix = name_space_prefix;
}
if(value_path == "type")
{
type = value;
type.value_namespace = name_space;
type.value_namespace_prefix = name_space_prefix;
}
if(value_path == "prio")
{
prio = value;
prio.value_namespace = name_space;
prio.value_namespace_prefix = name_space_prefix;
}
if(value_path == "direction")
{
direction = value;
direction.value_namespace = name_space;
direction.value_namespace_prefix = name_space_prefix;
}
if(value_path == "action")
{
action = value;
action.value_namespace = name_space;
action.value_namespace_prefix = name_space_prefix;
}
if(value_path == "qosGrp")
{
qosgrp = value;
qosgrp.value_namespace = name_space;
qosgrp.value_namespace_prefix = name_space_prefix;
}
if(value_path == "markDscp")
{
markdscp = value;
markdscp.value_namespace = name_space;
markdscp.value_namespace_prefix = name_space_prefix;
}
if(value_path == "operSt")
{
operst = value;
operst.value_namespace = name_space;
operst.value_namespace_prefix = name_space_prefix;
}
}
void System::ActrlItems::ScopeItems::ScopeList::RuleItems::RuleList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "scopeId")
{
scopeid.yfilter = yfilter;
}
if(value_path == "sPcTag")
{
spctag.yfilter = yfilter;
}
if(value_path == "dPcTag")
{
dpctag.yfilter = yfilter;
}
if(value_path == "fltId")
{
fltid.yfilter = yfilter;
}
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
if(value_path == "id")
{
id.yfilter = yfilter;
}
if(value_path == "type")
{
type.yfilter = yfilter;
}
if(value_path == "prio")
{
prio.yfilter = yfilter;
}
if(value_path == "direction")
{
direction.yfilter = yfilter;
}
if(value_path == "action")
{
action.yfilter = yfilter;
}
if(value_path == "qosGrp")
{
qosgrp.yfilter = yfilter;
}
if(value_path == "markDscp")
{
markdscp.yfilter = yfilter;
}
if(value_path == "operSt")
{
operst.yfilter = yfilter;
}
}
bool System::ActrlItems::ScopeItems::ScopeList::RuleItems::RuleList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "scopeId" || name == "sPcTag" || name == "dPcTag" || name == "fltId" || name == "name" || name == "descr" || name == "id" || name == "type" || name == "prio" || name == "direction" || name == "action" || name == "qosGrp" || name == "markDscp" || name == "operSt")
return true;
return false;
}
System::ActrlItems::ScopeItems::ScopeList::MrItems::MrItems()
:
mgmtrule_list(this, {"scopeid", "spctag", "dpctag", "fltid"})
{
yang_name = "mr-items"; yang_parent_name = "Scope-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::ScopeItems::ScopeList::MrItems::~MrItems()
{
}
bool System::ActrlItems::ScopeItems::ScopeList::MrItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<mgmtrule_list.len(); index++)
{
if(mgmtrule_list[index]->has_data())
return true;
}
return false;
}
bool System::ActrlItems::ScopeItems::ScopeList::MrItems::has_operation() const
{
for (std::size_t index=0; index<mgmtrule_list.len(); index++)
{
if(mgmtrule_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::ActrlItems::ScopeItems::ScopeList::MrItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "mr-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::ScopeItems::ScopeList::MrItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::ScopeItems::ScopeList::MrItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "MgmtRule-list")
{
auto ent_ = std::make_shared<System::ActrlItems::ScopeItems::ScopeList::MrItems::MgmtRuleList>();
ent_->parent = this;
mgmtrule_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::ScopeItems::ScopeList::MrItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : mgmtrule_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::ActrlItems::ScopeItems::ScopeList::MrItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::ActrlItems::ScopeItems::ScopeList::MrItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::ActrlItems::ScopeItems::ScopeList::MrItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "MgmtRule-list")
return true;
return false;
}
System::ActrlItems::ScopeItems::ScopeList::MrItems::MgmtRuleList::MgmtRuleList()
:
scopeid{YType::uint32, "scopeId"},
spctag{YType::uint32, "sPcTag"},
dpctag{YType::uint32, "dPcTag"},
fltid{YType::uint32, "fltId"},
name{YType::str, "name"},
descr{YType::str, "descr"},
id{YType::uint32, "id"},
type{YType::enumeration, "type"},
prio{YType::uint8, "prio"},
direction{YType::enumeration, "direction"},
action{YType::str, "action"},
qosgrp{YType::enumeration, "qosGrp"},
markdscp{YType::uint8, "markDscp"},
operst{YType::enumeration, "operSt"}
{
yang_name = "MgmtRule-list"; yang_parent_name = "mr-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::ScopeItems::ScopeList::MrItems::MgmtRuleList::~MgmtRuleList()
{
}
bool System::ActrlItems::ScopeItems::ScopeList::MrItems::MgmtRuleList::has_data() const
{
if (is_presence_container) return true;
return scopeid.is_set
|| spctag.is_set
|| dpctag.is_set
|| fltid.is_set
|| name.is_set
|| descr.is_set
|| id.is_set
|| type.is_set
|| prio.is_set
|| direction.is_set
|| action.is_set
|| qosgrp.is_set
|| markdscp.is_set
|| operst.is_set;
}
bool System::ActrlItems::ScopeItems::ScopeList::MrItems::MgmtRuleList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(scopeid.yfilter)
|| ydk::is_set(spctag.yfilter)
|| ydk::is_set(dpctag.yfilter)
|| ydk::is_set(fltid.yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(descr.yfilter)
|| ydk::is_set(id.yfilter)
|| ydk::is_set(type.yfilter)
|| ydk::is_set(prio.yfilter)
|| ydk::is_set(direction.yfilter)
|| ydk::is_set(action.yfilter)
|| ydk::is_set(qosgrp.yfilter)
|| ydk::is_set(markdscp.yfilter)
|| ydk::is_set(operst.yfilter);
}
std::string System::ActrlItems::ScopeItems::ScopeList::MrItems::MgmtRuleList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "MgmtRule-list";
ADD_KEY_TOKEN(scopeid, "scopeId");
ADD_KEY_TOKEN(spctag, "sPcTag");
ADD_KEY_TOKEN(dpctag, "dPcTag");
ADD_KEY_TOKEN(fltid, "fltId");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::ScopeItems::ScopeList::MrItems::MgmtRuleList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (scopeid.is_set || is_set(scopeid.yfilter)) leaf_name_data.push_back(scopeid.get_name_leafdata());
if (spctag.is_set || is_set(spctag.yfilter)) leaf_name_data.push_back(spctag.get_name_leafdata());
if (dpctag.is_set || is_set(dpctag.yfilter)) leaf_name_data.push_back(dpctag.get_name_leafdata());
if (fltid.is_set || is_set(fltid.yfilter)) leaf_name_data.push_back(fltid.get_name_leafdata());
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
if (id.is_set || is_set(id.yfilter)) leaf_name_data.push_back(id.get_name_leafdata());
if (type.is_set || is_set(type.yfilter)) leaf_name_data.push_back(type.get_name_leafdata());
if (prio.is_set || is_set(prio.yfilter)) leaf_name_data.push_back(prio.get_name_leafdata());
if (direction.is_set || is_set(direction.yfilter)) leaf_name_data.push_back(direction.get_name_leafdata());
if (action.is_set || is_set(action.yfilter)) leaf_name_data.push_back(action.get_name_leafdata());
if (qosgrp.is_set || is_set(qosgrp.yfilter)) leaf_name_data.push_back(qosgrp.get_name_leafdata());
if (markdscp.is_set || is_set(markdscp.yfilter)) leaf_name_data.push_back(markdscp.get_name_leafdata());
if (operst.is_set || is_set(operst.yfilter)) leaf_name_data.push_back(operst.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::ScopeItems::ScopeList::MrItems::MgmtRuleList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::ScopeItems::ScopeList::MrItems::MgmtRuleList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::ActrlItems::ScopeItems::ScopeList::MrItems::MgmtRuleList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "scopeId")
{
scopeid = value;
scopeid.value_namespace = name_space;
scopeid.value_namespace_prefix = name_space_prefix;
}
if(value_path == "sPcTag")
{
spctag = value;
spctag.value_namespace = name_space;
spctag.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dPcTag")
{
dpctag = value;
dpctag.value_namespace = name_space;
dpctag.value_namespace_prefix = name_space_prefix;
}
if(value_path == "fltId")
{
fltid = value;
fltid.value_namespace = name_space;
fltid.value_namespace_prefix = name_space_prefix;
}
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
if(value_path == "id")
{
id = value;
id.value_namespace = name_space;
id.value_namespace_prefix = name_space_prefix;
}
if(value_path == "type")
{
type = value;
type.value_namespace = name_space;
type.value_namespace_prefix = name_space_prefix;
}
if(value_path == "prio")
{
prio = value;
prio.value_namespace = name_space;
prio.value_namespace_prefix = name_space_prefix;
}
if(value_path == "direction")
{
direction = value;
direction.value_namespace = name_space;
direction.value_namespace_prefix = name_space_prefix;
}
if(value_path == "action")
{
action = value;
action.value_namespace = name_space;
action.value_namespace_prefix = name_space_prefix;
}
if(value_path == "qosGrp")
{
qosgrp = value;
qosgrp.value_namespace = name_space;
qosgrp.value_namespace_prefix = name_space_prefix;
}
if(value_path == "markDscp")
{
markdscp = value;
markdscp.value_namespace = name_space;
markdscp.value_namespace_prefix = name_space_prefix;
}
if(value_path == "operSt")
{
operst = value;
operst.value_namespace = name_space;
operst.value_namespace_prefix = name_space_prefix;
}
}
void System::ActrlItems::ScopeItems::ScopeList::MrItems::MgmtRuleList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "scopeId")
{
scopeid.yfilter = yfilter;
}
if(value_path == "sPcTag")
{
spctag.yfilter = yfilter;
}
if(value_path == "dPcTag")
{
dpctag.yfilter = yfilter;
}
if(value_path == "fltId")
{
fltid.yfilter = yfilter;
}
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
if(value_path == "id")
{
id.yfilter = yfilter;
}
if(value_path == "type")
{
type.yfilter = yfilter;
}
if(value_path == "prio")
{
prio.yfilter = yfilter;
}
if(value_path == "direction")
{
direction.yfilter = yfilter;
}
if(value_path == "action")
{
action.yfilter = yfilter;
}
if(value_path == "qosGrp")
{
qosgrp.yfilter = yfilter;
}
if(value_path == "markDscp")
{
markdscp.yfilter = yfilter;
}
if(value_path == "operSt")
{
operst.yfilter = yfilter;
}
}
bool System::ActrlItems::ScopeItems::ScopeList::MrItems::MgmtRuleList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "scopeId" || name == "sPcTag" || name == "dPcTag" || name == "fltId" || name == "name" || name == "descr" || name == "id" || name == "type" || name == "prio" || name == "direction" || name == "action" || name == "qosGrp" || name == "markDscp" || name == "operSt")
return true;
return false;
}
System::ActrlItems::ScopeItems::ScopeList::SrItems::SrItems()
:
snmprule_list(this, {"scopeid", "spctag", "dpctag", "fltid"})
{
yang_name = "sr-items"; yang_parent_name = "Scope-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::ScopeItems::ScopeList::SrItems::~SrItems()
{
}
bool System::ActrlItems::ScopeItems::ScopeList::SrItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<snmprule_list.len(); index++)
{
if(snmprule_list[index]->has_data())
return true;
}
return false;
}
bool System::ActrlItems::ScopeItems::ScopeList::SrItems::has_operation() const
{
for (std::size_t index=0; index<snmprule_list.len(); index++)
{
if(snmprule_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::ActrlItems::ScopeItems::ScopeList::SrItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "sr-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::ScopeItems::ScopeList::SrItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::ScopeItems::ScopeList::SrItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "SnmpRule-list")
{
auto ent_ = std::make_shared<System::ActrlItems::ScopeItems::ScopeList::SrItems::SnmpRuleList>();
ent_->parent = this;
snmprule_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::ScopeItems::ScopeList::SrItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : snmprule_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::ActrlItems::ScopeItems::ScopeList::SrItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::ActrlItems::ScopeItems::ScopeList::SrItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::ActrlItems::ScopeItems::ScopeList::SrItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "SnmpRule-list")
return true;
return false;
}
System::ActrlItems::ScopeItems::ScopeList::SrItems::SnmpRuleList::SnmpRuleList()
:
scopeid{YType::uint32, "scopeId"},
spctag{YType::uint32, "sPcTag"},
dpctag{YType::uint32, "dPcTag"},
fltid{YType::uint32, "fltId"},
name{YType::str, "name"},
descr{YType::str, "descr"},
id{YType::uint32, "id"},
type{YType::enumeration, "type"},
prio{YType::uint8, "prio"},
direction{YType::enumeration, "direction"},
action{YType::str, "action"},
qosgrp{YType::enumeration, "qosGrp"},
markdscp{YType::uint8, "markDscp"},
operst{YType::enumeration, "operSt"}
{
yang_name = "SnmpRule-list"; yang_parent_name = "sr-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::ScopeItems::ScopeList::SrItems::SnmpRuleList::~SnmpRuleList()
{
}
bool System::ActrlItems::ScopeItems::ScopeList::SrItems::SnmpRuleList::has_data() const
{
if (is_presence_container) return true;
return scopeid.is_set
|| spctag.is_set
|| dpctag.is_set
|| fltid.is_set
|| name.is_set
|| descr.is_set
|| id.is_set
|| type.is_set
|| prio.is_set
|| direction.is_set
|| action.is_set
|| qosgrp.is_set
|| markdscp.is_set
|| operst.is_set;
}
bool System::ActrlItems::ScopeItems::ScopeList::SrItems::SnmpRuleList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(scopeid.yfilter)
|| ydk::is_set(spctag.yfilter)
|| ydk::is_set(dpctag.yfilter)
|| ydk::is_set(fltid.yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(descr.yfilter)
|| ydk::is_set(id.yfilter)
|| ydk::is_set(type.yfilter)
|| ydk::is_set(prio.yfilter)
|| ydk::is_set(direction.yfilter)
|| ydk::is_set(action.yfilter)
|| ydk::is_set(qosgrp.yfilter)
|| ydk::is_set(markdscp.yfilter)
|| ydk::is_set(operst.yfilter);
}
std::string System::ActrlItems::ScopeItems::ScopeList::SrItems::SnmpRuleList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "SnmpRule-list";
ADD_KEY_TOKEN(scopeid, "scopeId");
ADD_KEY_TOKEN(spctag, "sPcTag");
ADD_KEY_TOKEN(dpctag, "dPcTag");
ADD_KEY_TOKEN(fltid, "fltId");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::ScopeItems::ScopeList::SrItems::SnmpRuleList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (scopeid.is_set || is_set(scopeid.yfilter)) leaf_name_data.push_back(scopeid.get_name_leafdata());
if (spctag.is_set || is_set(spctag.yfilter)) leaf_name_data.push_back(spctag.get_name_leafdata());
if (dpctag.is_set || is_set(dpctag.yfilter)) leaf_name_data.push_back(dpctag.get_name_leafdata());
if (fltid.is_set || is_set(fltid.yfilter)) leaf_name_data.push_back(fltid.get_name_leafdata());
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
if (id.is_set || is_set(id.yfilter)) leaf_name_data.push_back(id.get_name_leafdata());
if (type.is_set || is_set(type.yfilter)) leaf_name_data.push_back(type.get_name_leafdata());
if (prio.is_set || is_set(prio.yfilter)) leaf_name_data.push_back(prio.get_name_leafdata());
if (direction.is_set || is_set(direction.yfilter)) leaf_name_data.push_back(direction.get_name_leafdata());
if (action.is_set || is_set(action.yfilter)) leaf_name_data.push_back(action.get_name_leafdata());
if (qosgrp.is_set || is_set(qosgrp.yfilter)) leaf_name_data.push_back(qosgrp.get_name_leafdata());
if (markdscp.is_set || is_set(markdscp.yfilter)) leaf_name_data.push_back(markdscp.get_name_leafdata());
if (operst.is_set || is_set(operst.yfilter)) leaf_name_data.push_back(operst.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::ScopeItems::ScopeList::SrItems::SnmpRuleList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::ScopeItems::ScopeList::SrItems::SnmpRuleList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::ActrlItems::ScopeItems::ScopeList::SrItems::SnmpRuleList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "scopeId")
{
scopeid = value;
scopeid.value_namespace = name_space;
scopeid.value_namespace_prefix = name_space_prefix;
}
if(value_path == "sPcTag")
{
spctag = value;
spctag.value_namespace = name_space;
spctag.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dPcTag")
{
dpctag = value;
dpctag.value_namespace = name_space;
dpctag.value_namespace_prefix = name_space_prefix;
}
if(value_path == "fltId")
{
fltid = value;
fltid.value_namespace = name_space;
fltid.value_namespace_prefix = name_space_prefix;
}
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
if(value_path == "id")
{
id = value;
id.value_namespace = name_space;
id.value_namespace_prefix = name_space_prefix;
}
if(value_path == "type")
{
type = value;
type.value_namespace = name_space;
type.value_namespace_prefix = name_space_prefix;
}
if(value_path == "prio")
{
prio = value;
prio.value_namespace = name_space;
prio.value_namespace_prefix = name_space_prefix;
}
if(value_path == "direction")
{
direction = value;
direction.value_namespace = name_space;
direction.value_namespace_prefix = name_space_prefix;
}
if(value_path == "action")
{
action = value;
action.value_namespace = name_space;
action.value_namespace_prefix = name_space_prefix;
}
if(value_path == "qosGrp")
{
qosgrp = value;
qosgrp.value_namespace = name_space;
qosgrp.value_namespace_prefix = name_space_prefix;
}
if(value_path == "markDscp")
{
markdscp = value;
markdscp.value_namespace = name_space;
markdscp.value_namespace_prefix = name_space_prefix;
}
if(value_path == "operSt")
{
operst = value;
operst.value_namespace = name_space;
operst.value_namespace_prefix = name_space_prefix;
}
}
void System::ActrlItems::ScopeItems::ScopeList::SrItems::SnmpRuleList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "scopeId")
{
scopeid.yfilter = yfilter;
}
if(value_path == "sPcTag")
{
spctag.yfilter = yfilter;
}
if(value_path == "dPcTag")
{
dpctag.yfilter = yfilter;
}
if(value_path == "fltId")
{
fltid.yfilter = yfilter;
}
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
if(value_path == "id")
{
id.yfilter = yfilter;
}
if(value_path == "type")
{
type.yfilter = yfilter;
}
if(value_path == "prio")
{
prio.yfilter = yfilter;
}
if(value_path == "direction")
{
direction.yfilter = yfilter;
}
if(value_path == "action")
{
action.yfilter = yfilter;
}
if(value_path == "qosGrp")
{
qosgrp.yfilter = yfilter;
}
if(value_path == "markDscp")
{
markdscp.yfilter = yfilter;
}
if(value_path == "operSt")
{
operst.yfilter = yfilter;
}
}
bool System::ActrlItems::ScopeItems::ScopeList::SrItems::SnmpRuleList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "scopeId" || name == "sPcTag" || name == "dPcTag" || name == "fltId" || name == "name" || name == "descr" || name == "id" || name == "type" || name == "prio" || name == "direction" || name == "action" || name == "qosGrp" || name == "markDscp" || name == "operSt")
return true;
return false;
}
System::ActrlItems::ScopeItems::ScopeList::RstenConnItems::RstenConnItems()
:
rstenconn_list(this, {"tdn"})
{
yang_name = "rstenConn-items"; yang_parent_name = "Scope-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::ScopeItems::ScopeList::RstenConnItems::~RstenConnItems()
{
}
bool System::ActrlItems::ScopeItems::ScopeList::RstenConnItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<rstenconn_list.len(); index++)
{
if(rstenconn_list[index]->has_data())
return true;
}
return false;
}
bool System::ActrlItems::ScopeItems::ScopeList::RstenConnItems::has_operation() const
{
for (std::size_t index=0; index<rstenconn_list.len(); index++)
{
if(rstenconn_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::ActrlItems::ScopeItems::ScopeList::RstenConnItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "rstenConn-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::ScopeItems::ScopeList::RstenConnItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::ScopeItems::ScopeList::RstenConnItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "RsTenConn-list")
{
auto ent_ = std::make_shared<System::ActrlItems::ScopeItems::ScopeList::RstenConnItems::RsTenConnList>();
ent_->parent = this;
rstenconn_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::ScopeItems::ScopeList::RstenConnItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : rstenconn_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::ActrlItems::ScopeItems::ScopeList::RstenConnItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::ActrlItems::ScopeItems::ScopeList::RstenConnItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::ActrlItems::ScopeItems::ScopeList::RstenConnItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "RsTenConn-list")
return true;
return false;
}
System::ActrlItems::ScopeItems::ScopeList::RstenConnItems::RsTenConnList::RsTenConnList()
:
tdn{YType::str, "tDn"}
{
yang_name = "RsTenConn-list"; yang_parent_name = "rstenConn-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::ActrlItems::ScopeItems::ScopeList::RstenConnItems::RsTenConnList::~RsTenConnList()
{
}
bool System::ActrlItems::ScopeItems::ScopeList::RstenConnItems::RsTenConnList::has_data() const
{
if (is_presence_container) return true;
return tdn.is_set;
}
bool System::ActrlItems::ScopeItems::ScopeList::RstenConnItems::RsTenConnList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(tdn.yfilter);
}
std::string System::ActrlItems::ScopeItems::ScopeList::RstenConnItems::RsTenConnList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "RsTenConn-list";
ADD_KEY_TOKEN(tdn, "tDn");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlItems::ScopeItems::ScopeList::RstenConnItems::RsTenConnList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (tdn.is_set || is_set(tdn.yfilter)) leaf_name_data.push_back(tdn.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlItems::ScopeItems::ScopeList::RstenConnItems::RsTenConnList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlItems::ScopeItems::ScopeList::RstenConnItems::RsTenConnList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::ActrlItems::ScopeItems::ScopeList::RstenConnItems::RsTenConnList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "tDn")
{
tdn = value;
tdn.value_namespace = name_space;
tdn.value_namespace_prefix = name_space_prefix;
}
}
void System::ActrlItems::ScopeItems::ScopeList::RstenConnItems::RsTenConnList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "tDn")
{
tdn.yfilter = yfilter;
}
}
bool System::ActrlItems::ScopeItems::ScopeList::RstenConnItems::RsTenConnList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "tDn")
return true;
return false;
}
System::ActrlcapprovItems::ActrlcapprovItems()
:
prov_list(this, {"subj", "type"})
{
yang_name = "actrlcapprov-items"; yang_parent_name = "System"; is_top_level_class = false; has_list_ancestor = false;
}
System::ActrlcapprovItems::~ActrlcapprovItems()
{
}
bool System::ActrlcapprovItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<prov_list.len(); index++)
{
if(prov_list[index]->has_data())
return true;
}
return false;
}
bool System::ActrlcapprovItems::has_operation() const
{
for (std::size_t index=0; index<prov_list.len(); index++)
{
if(prov_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::ActrlcapprovItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/" << get_segment_path();
return path_buffer.str();
}
std::string System::ActrlcapprovItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "actrlcapprov-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlcapprovItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlcapprovItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "Prov-list")
{
auto ent_ = std::make_shared<System::ActrlcapprovItems::ProvList>();
ent_->parent = this;
prov_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlcapprovItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : prov_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::ActrlcapprovItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::ActrlcapprovItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::ActrlcapprovItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "Prov-list")
return true;
return false;
}
System::ActrlcapprovItems::ProvList::ProvList()
:
subj{YType::enumeration, "subj"},
type{YType::enumeration, "type"},
total{YType::uint32, "total"},
remaining{YType::uint32, "remaining"},
utilization{YType::uint8, "utilization"}
{
yang_name = "Prov-list"; yang_parent_name = "actrlcapprov-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::ActrlcapprovItems::ProvList::~ProvList()
{
}
bool System::ActrlcapprovItems::ProvList::has_data() const
{
if (is_presence_container) return true;
return subj.is_set
|| type.is_set
|| total.is_set
|| remaining.is_set
|| utilization.is_set;
}
bool System::ActrlcapprovItems::ProvList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(subj.yfilter)
|| ydk::is_set(type.yfilter)
|| ydk::is_set(total.yfilter)
|| ydk::is_set(remaining.yfilter)
|| ydk::is_set(utilization.yfilter);
}
std::string System::ActrlcapprovItems::ProvList::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/actrlcapprov-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::ActrlcapprovItems::ProvList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "Prov-list";
ADD_KEY_TOKEN(subj, "subj");
ADD_KEY_TOKEN(type, "type");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::ActrlcapprovItems::ProvList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (subj.is_set || is_set(subj.yfilter)) leaf_name_data.push_back(subj.get_name_leafdata());
if (type.is_set || is_set(type.yfilter)) leaf_name_data.push_back(type.get_name_leafdata());
if (total.is_set || is_set(total.yfilter)) leaf_name_data.push_back(total.get_name_leafdata());
if (remaining.is_set || is_set(remaining.yfilter)) leaf_name_data.push_back(remaining.get_name_leafdata());
if (utilization.is_set || is_set(utilization.yfilter)) leaf_name_data.push_back(utilization.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::ActrlcapprovItems::ProvList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::ActrlcapprovItems::ProvList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::ActrlcapprovItems::ProvList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "subj")
{
subj = value;
subj.value_namespace = name_space;
subj.value_namespace_prefix = name_space_prefix;
}
if(value_path == "type")
{
type = value;
type.value_namespace = name_space;
type.value_namespace_prefix = name_space_prefix;
}
if(value_path == "total")
{
total = value;
total.value_namespace = name_space;
total.value_namespace_prefix = name_space_prefix;
}
if(value_path == "remaining")
{
remaining = value;
remaining.value_namespace = name_space;
remaining.value_namespace_prefix = name_space_prefix;
}
if(value_path == "utilization")
{
utilization = value;
utilization.value_namespace = name_space;
utilization.value_namespace_prefix = name_space_prefix;
}
}
void System::ActrlcapprovItems::ProvList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "subj")
{
subj.yfilter = yfilter;
}
if(value_path == "type")
{
type.yfilter = yfilter;
}
if(value_path == "total")
{
total.yfilter = yfilter;
}
if(value_path == "remaining")
{
remaining.yfilter = yfilter;
}
if(value_path == "utilization")
{
utilization.yfilter = yfilter;
}
}
bool System::ActrlcapprovItems::ProvList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "subj" || name == "type" || name == "total" || name == "remaining" || name == "utilization")
return true;
return false;
}
System::AnalyticsItems::AnalyticsItems()
:
inst_items(std::make_shared<System::AnalyticsItems::InstItems>())
{
inst_items->parent = this;
yang_name = "analytics-items"; yang_parent_name = "System"; is_top_level_class = false; has_list_ancestor = false;
}
System::AnalyticsItems::~AnalyticsItems()
{
}
bool System::AnalyticsItems::has_data() const
{
if (is_presence_container) return true;
return (inst_items != nullptr && inst_items->has_data());
}
bool System::AnalyticsItems::has_operation() const
{
return is_set(yfilter)
|| (inst_items != nullptr && inst_items->has_operation());
}
std::string System::AnalyticsItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/" << get_segment_path();
return path_buffer.str();
}
std::string System::AnalyticsItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "analytics-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "inst-items")
{
if(inst_items == nullptr)
{
inst_items = std::make_shared<System::AnalyticsItems::InstItems>();
}
return inst_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(inst_items != nullptr)
{
_children["inst-items"] = inst_items;
}
return _children;
}
void System::AnalyticsItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AnalyticsItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AnalyticsItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "inst-items")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstItems()
:
inst_list(this, {"mode"})
{
yang_name = "inst-items"; yang_parent_name = "analytics-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::AnalyticsItems::InstItems::~InstItems()
{
}
bool System::AnalyticsItems::InstItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<inst_list.len(); index++)
{
if(inst_list[index]->has_data())
return true;
}
return false;
}
bool System::AnalyticsItems::InstItems::has_operation() const
{
for (std::size_t index=0; index<inst_list.len(); index++)
{
if(inst_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AnalyticsItems::InstItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/analytics-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::AnalyticsItems::InstItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "inst-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "Inst-list")
{
auto ent_ = std::make_shared<System::AnalyticsItems::InstItems::InstList>();
ent_->parent = this;
inst_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : inst_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AnalyticsItems::InstItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AnalyticsItems::InstItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AnalyticsItems::InstItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "Inst-list")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::InstList()
:
mode{YType::enumeration, "mode"},
name{YType::str, "name"},
adminst{YType::enumeration, "adminSt"},
ctrl{YType::str, "ctrl"},
opererr{YType::str, "operErr"}
,
capability_items(std::make_shared<System::AnalyticsItems::InstItems::InstList::CapabilityItems>())
, slot_items(std::make_shared<System::AnalyticsItems::InstItems::InstList::SlotItems>())
, controller_items(std::make_shared<System::AnalyticsItems::InstItems::InstList::ControllerItems>())
, recordp_items(std::make_shared<System::AnalyticsItems::InstItems::InstList::RecordpItems>())
, collector_items(std::make_shared<System::AnalyticsItems::InstItems::InstList::CollectorItems>())
, monitor_items(std::make_shared<System::AnalyticsItems::InstItems::InstList::MonitorItems>())
, prof_items(std::make_shared<System::AnalyticsItems::InstItems::InstList::ProfItems>())
, fwdinst_items(std::make_shared<System::AnalyticsItems::InstItems::InstList::FwdinstItems>())
, policy_items(std::make_shared<System::AnalyticsItems::InstItems::InstList::PolicyItems>())
{
capability_items->parent = this;
slot_items->parent = this;
controller_items->parent = this;
recordp_items->parent = this;
collector_items->parent = this;
monitor_items->parent = this;
prof_items->parent = this;
fwdinst_items->parent = this;
policy_items->parent = this;
yang_name = "Inst-list"; yang_parent_name = "inst-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::AnalyticsItems::InstItems::InstList::~InstList()
{
}
bool System::AnalyticsItems::InstItems::InstList::has_data() const
{
if (is_presence_container) return true;
return mode.is_set
|| name.is_set
|| adminst.is_set
|| ctrl.is_set
|| opererr.is_set
|| (capability_items != nullptr && capability_items->has_data())
|| (slot_items != nullptr && slot_items->has_data())
|| (controller_items != nullptr && controller_items->has_data())
|| (recordp_items != nullptr && recordp_items->has_data())
|| (collector_items != nullptr && collector_items->has_data())
|| (monitor_items != nullptr && monitor_items->has_data())
|| (prof_items != nullptr && prof_items->has_data())
|| (fwdinst_items != nullptr && fwdinst_items->has_data())
|| (policy_items != nullptr && policy_items->has_data());
}
bool System::AnalyticsItems::InstItems::InstList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(mode.yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(adminst.yfilter)
|| ydk::is_set(ctrl.yfilter)
|| ydk::is_set(opererr.yfilter)
|| (capability_items != nullptr && capability_items->has_operation())
|| (slot_items != nullptr && slot_items->has_operation())
|| (controller_items != nullptr && controller_items->has_operation())
|| (recordp_items != nullptr && recordp_items->has_operation())
|| (collector_items != nullptr && collector_items->has_operation())
|| (monitor_items != nullptr && monitor_items->has_operation())
|| (prof_items != nullptr && prof_items->has_operation())
|| (fwdinst_items != nullptr && fwdinst_items->has_operation())
|| (policy_items != nullptr && policy_items->has_operation());
}
std::string System::AnalyticsItems::InstItems::InstList::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/analytics-items/inst-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::AnalyticsItems::InstItems::InstList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "Inst-list";
ADD_KEY_TOKEN(mode, "mode");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (mode.is_set || is_set(mode.yfilter)) leaf_name_data.push_back(mode.get_name_leafdata());
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (adminst.is_set || is_set(adminst.yfilter)) leaf_name_data.push_back(adminst.get_name_leafdata());
if (ctrl.is_set || is_set(ctrl.yfilter)) leaf_name_data.push_back(ctrl.get_name_leafdata());
if (opererr.is_set || is_set(opererr.yfilter)) leaf_name_data.push_back(opererr.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "capability-items")
{
if(capability_items == nullptr)
{
capability_items = std::make_shared<System::AnalyticsItems::InstItems::InstList::CapabilityItems>();
}
return capability_items;
}
if(child_yang_name == "slot-items")
{
if(slot_items == nullptr)
{
slot_items = std::make_shared<System::AnalyticsItems::InstItems::InstList::SlotItems>();
}
return slot_items;
}
if(child_yang_name == "controller-items")
{
if(controller_items == nullptr)
{
controller_items = std::make_shared<System::AnalyticsItems::InstItems::InstList::ControllerItems>();
}
return controller_items;
}
if(child_yang_name == "recordp-items")
{
if(recordp_items == nullptr)
{
recordp_items = std::make_shared<System::AnalyticsItems::InstItems::InstList::RecordpItems>();
}
return recordp_items;
}
if(child_yang_name == "collector-items")
{
if(collector_items == nullptr)
{
collector_items = std::make_shared<System::AnalyticsItems::InstItems::InstList::CollectorItems>();
}
return collector_items;
}
if(child_yang_name == "monitor-items")
{
if(monitor_items == nullptr)
{
monitor_items = std::make_shared<System::AnalyticsItems::InstItems::InstList::MonitorItems>();
}
return monitor_items;
}
if(child_yang_name == "prof-items")
{
if(prof_items == nullptr)
{
prof_items = std::make_shared<System::AnalyticsItems::InstItems::InstList::ProfItems>();
}
return prof_items;
}
if(child_yang_name == "fwdinst-items")
{
if(fwdinst_items == nullptr)
{
fwdinst_items = std::make_shared<System::AnalyticsItems::InstItems::InstList::FwdinstItems>();
}
return fwdinst_items;
}
if(child_yang_name == "policy-items")
{
if(policy_items == nullptr)
{
policy_items = std::make_shared<System::AnalyticsItems::InstItems::InstList::PolicyItems>();
}
return policy_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(capability_items != nullptr)
{
_children["capability-items"] = capability_items;
}
if(slot_items != nullptr)
{
_children["slot-items"] = slot_items;
}
if(controller_items != nullptr)
{
_children["controller-items"] = controller_items;
}
if(recordp_items != nullptr)
{
_children["recordp-items"] = recordp_items;
}
if(collector_items != nullptr)
{
_children["collector-items"] = collector_items;
}
if(monitor_items != nullptr)
{
_children["monitor-items"] = monitor_items;
}
if(prof_items != nullptr)
{
_children["prof-items"] = prof_items;
}
if(fwdinst_items != nullptr)
{
_children["fwdinst-items"] = fwdinst_items;
}
if(policy_items != nullptr)
{
_children["policy-items"] = policy_items;
}
return _children;
}
void System::AnalyticsItems::InstItems::InstList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "mode")
{
mode = value;
mode.value_namespace = name_space;
mode.value_namespace_prefix = name_space_prefix;
}
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "adminSt")
{
adminst = value;
adminst.value_namespace = name_space;
adminst.value_namespace_prefix = name_space_prefix;
}
if(value_path == "ctrl")
{
ctrl = value;
ctrl.value_namespace = name_space;
ctrl.value_namespace_prefix = name_space_prefix;
}
if(value_path == "operErr")
{
opererr = value;
opererr.value_namespace = name_space;
opererr.value_namespace_prefix = name_space_prefix;
}
}
void System::AnalyticsItems::InstItems::InstList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "mode")
{
mode.yfilter = yfilter;
}
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "adminSt")
{
adminst.yfilter = yfilter;
}
if(value_path == "ctrl")
{
ctrl.yfilter = yfilter;
}
if(value_path == "operErr")
{
opererr.yfilter = yfilter;
}
}
bool System::AnalyticsItems::InstItems::InstList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "capability-items" || name == "slot-items" || name == "controller-items" || name == "recordp-items" || name == "collector-items" || name == "monitor-items" || name == "prof-items" || name == "fwdinst-items" || name == "policy-items" || name == "mode" || name == "name" || name == "adminSt" || name == "ctrl" || name == "operErr")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::CapabilityItems::CapabilityItems()
:
fabricmode{YType::enumeration, "fabricMode"},
buckethashwidth{YType::uint16, "bucketHashWidth"},
numtcament{YType::uint32, "numTcamEnt"},
numtcamentperv4{YType::uint16, "numTcamEntPerV4"},
numtcamentperv6{YType::uint16, "numTcamEntPerV6"},
configlatencyresfactor{YType::enumeration, "configLatencyResFactor"},
oportsupport{YType::enumeration, "oportSupport"},
oclasssupport{YType::enumeration, "oclassSupport"}
{
yang_name = "capability-items"; yang_parent_name = "Inst-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::CapabilityItems::~CapabilityItems()
{
}
bool System::AnalyticsItems::InstItems::InstList::CapabilityItems::has_data() const
{
if (is_presence_container) return true;
return fabricmode.is_set
|| buckethashwidth.is_set
|| numtcament.is_set
|| numtcamentperv4.is_set
|| numtcamentperv6.is_set
|| configlatencyresfactor.is_set
|| oportsupport.is_set
|| oclasssupport.is_set;
}
bool System::AnalyticsItems::InstItems::InstList::CapabilityItems::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(fabricmode.yfilter)
|| ydk::is_set(buckethashwidth.yfilter)
|| ydk::is_set(numtcament.yfilter)
|| ydk::is_set(numtcamentperv4.yfilter)
|| ydk::is_set(numtcamentperv6.yfilter)
|| ydk::is_set(configlatencyresfactor.yfilter)
|| ydk::is_set(oportsupport.yfilter)
|| ydk::is_set(oclasssupport.yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::CapabilityItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "capability-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::CapabilityItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (fabricmode.is_set || is_set(fabricmode.yfilter)) leaf_name_data.push_back(fabricmode.get_name_leafdata());
if (buckethashwidth.is_set || is_set(buckethashwidth.yfilter)) leaf_name_data.push_back(buckethashwidth.get_name_leafdata());
if (numtcament.is_set || is_set(numtcament.yfilter)) leaf_name_data.push_back(numtcament.get_name_leafdata());
if (numtcamentperv4.is_set || is_set(numtcamentperv4.yfilter)) leaf_name_data.push_back(numtcamentperv4.get_name_leafdata());
if (numtcamentperv6.is_set || is_set(numtcamentperv6.yfilter)) leaf_name_data.push_back(numtcamentperv6.get_name_leafdata());
if (configlatencyresfactor.is_set || is_set(configlatencyresfactor.yfilter)) leaf_name_data.push_back(configlatencyresfactor.get_name_leafdata());
if (oportsupport.is_set || is_set(oportsupport.yfilter)) leaf_name_data.push_back(oportsupport.get_name_leafdata());
if (oclasssupport.is_set || is_set(oclasssupport.yfilter)) leaf_name_data.push_back(oclasssupport.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::CapabilityItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::CapabilityItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AnalyticsItems::InstItems::InstList::CapabilityItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "fabricMode")
{
fabricmode = value;
fabricmode.value_namespace = name_space;
fabricmode.value_namespace_prefix = name_space_prefix;
}
if(value_path == "bucketHashWidth")
{
buckethashwidth = value;
buckethashwidth.value_namespace = name_space;
buckethashwidth.value_namespace_prefix = name_space_prefix;
}
if(value_path == "numTcamEnt")
{
numtcament = value;
numtcament.value_namespace = name_space;
numtcament.value_namespace_prefix = name_space_prefix;
}
if(value_path == "numTcamEntPerV4")
{
numtcamentperv4 = value;
numtcamentperv4.value_namespace = name_space;
numtcamentperv4.value_namespace_prefix = name_space_prefix;
}
if(value_path == "numTcamEntPerV6")
{
numtcamentperv6 = value;
numtcamentperv6.value_namespace = name_space;
numtcamentperv6.value_namespace_prefix = name_space_prefix;
}
if(value_path == "configLatencyResFactor")
{
configlatencyresfactor = value;
configlatencyresfactor.value_namespace = name_space;
configlatencyresfactor.value_namespace_prefix = name_space_prefix;
}
if(value_path == "oportSupport")
{
oportsupport = value;
oportsupport.value_namespace = name_space;
oportsupport.value_namespace_prefix = name_space_prefix;
}
if(value_path == "oclassSupport")
{
oclasssupport = value;
oclasssupport.value_namespace = name_space;
oclasssupport.value_namespace_prefix = name_space_prefix;
}
}
void System::AnalyticsItems::InstItems::InstList::CapabilityItems::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "fabricMode")
{
fabricmode.yfilter = yfilter;
}
if(value_path == "bucketHashWidth")
{
buckethashwidth.yfilter = yfilter;
}
if(value_path == "numTcamEnt")
{
numtcament.yfilter = yfilter;
}
if(value_path == "numTcamEntPerV4")
{
numtcamentperv4.yfilter = yfilter;
}
if(value_path == "numTcamEntPerV6")
{
numtcamentperv6.yfilter = yfilter;
}
if(value_path == "configLatencyResFactor")
{
configlatencyresfactor.yfilter = yfilter;
}
if(value_path == "oportSupport")
{
oportsupport.yfilter = yfilter;
}
if(value_path == "oclassSupport")
{
oclasssupport.yfilter = yfilter;
}
}
bool System::AnalyticsItems::InstItems::InstList::CapabilityItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "fabricMode" || name == "bucketHashWidth" || name == "numTcamEnt" || name == "numTcamEntPerV4" || name == "numTcamEntPerV6" || name == "configLatencyResFactor" || name == "oportSupport" || name == "oclassSupport")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::SlotItems::SlotItems()
:
slot_list(this, {"slotid"})
{
yang_name = "slot-items"; yang_parent_name = "Inst-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::SlotItems::~SlotItems()
{
}
bool System::AnalyticsItems::InstItems::InstList::SlotItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<slot_list.len(); index++)
{
if(slot_list[index]->has_data())
return true;
}
return false;
}
bool System::AnalyticsItems::InstItems::InstList::SlotItems::has_operation() const
{
for (std::size_t index=0; index<slot_list.len(); index++)
{
if(slot_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::SlotItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "slot-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::SlotItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::SlotItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "Slot-list")
{
auto ent_ = std::make_shared<System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList>();
ent_->parent = this;
slot_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::SlotItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : slot_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AnalyticsItems::InstItems::InstList::SlotItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AnalyticsItems::InstItems::InstList::SlotItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AnalyticsItems::InstItems::InstList::SlotItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "Slot-list")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::SlotList()
:
slotid{YType::uint16, "slotid"}
,
oclass_items(std::make_shared<System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::OclassItems>())
{
oclass_items->parent = this;
yang_name = "Slot-list"; yang_parent_name = "slot-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::~SlotList()
{
}
bool System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::has_data() const
{
if (is_presence_container) return true;
return slotid.is_set
|| (oclass_items != nullptr && oclass_items->has_data());
}
bool System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(slotid.yfilter)
|| (oclass_items != nullptr && oclass_items->has_operation());
}
std::string System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "Slot-list";
ADD_KEY_TOKEN(slotid, "slotid");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (slotid.is_set || is_set(slotid.yfilter)) leaf_name_data.push_back(slotid.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "oclass-items")
{
if(oclass_items == nullptr)
{
oclass_items = std::make_shared<System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::OclassItems>();
}
return oclass_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(oclass_items != nullptr)
{
_children["oclass-items"] = oclass_items;
}
return _children;
}
void System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "slotid")
{
slotid = value;
slotid.value_namespace = name_space;
slotid.value_namespace_prefix = name_space_prefix;
}
}
void System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "slotid")
{
slotid.yfilter = yfilter;
}
}
bool System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "oclass-items" || name == "slotid")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::OclassItems::OclassItems()
:
oclass_list(this, {"id"})
{
yang_name = "oclass-items"; yang_parent_name = "Slot-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::OclassItems::~OclassItems()
{
}
bool System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::OclassItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<oclass_list.len(); index++)
{
if(oclass_list[index]->has_data())
return true;
}
return false;
}
bool System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::OclassItems::has_operation() const
{
for (std::size_t index=0; index<oclass_list.len(); index++)
{
if(oclass_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::OclassItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "oclass-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::OclassItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::OclassItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "Oclass-list")
{
auto ent_ = std::make_shared<System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::OclassItems::OclassList>();
ent_->parent = this;
oclass_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::OclassItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : oclass_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::OclassItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::OclassItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::OclassItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "Oclass-list")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::OclassItems::OclassList::OclassList()
:
id{YType::uint16, "id"},
prioritymapping{YType::str, "priorityMapping"}
{
yang_name = "Oclass-list"; yang_parent_name = "oclass-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::OclassItems::OclassList::~OclassList()
{
}
bool System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::OclassItems::OclassList::has_data() const
{
if (is_presence_container) return true;
return id.is_set
|| prioritymapping.is_set;
}
bool System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::OclassItems::OclassList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(id.yfilter)
|| ydk::is_set(prioritymapping.yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::OclassItems::OclassList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "Oclass-list";
ADD_KEY_TOKEN(id, "id");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::OclassItems::OclassList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (id.is_set || is_set(id.yfilter)) leaf_name_data.push_back(id.get_name_leafdata());
if (prioritymapping.is_set || is_set(prioritymapping.yfilter)) leaf_name_data.push_back(prioritymapping.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::OclassItems::OclassList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::OclassItems::OclassList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::OclassItems::OclassList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "id")
{
id = value;
id.value_namespace = name_space;
id.value_namespace_prefix = name_space_prefix;
}
if(value_path == "priorityMapping")
{
prioritymapping = value;
prioritymapping.value_namespace = name_space;
prioritymapping.value_namespace_prefix = name_space_prefix;
}
}
void System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::OclassItems::OclassList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "id")
{
id.yfilter = yfilter;
}
if(value_path == "priorityMapping")
{
prioritymapping.yfilter = yfilter;
}
}
bool System::AnalyticsItems::InstItems::InstList::SlotItems::SlotList::OclassItems::OclassList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "id" || name == "priorityMapping")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::ControllerItems::ControllerItems()
:
controller_list(this, {"name"})
{
yang_name = "controller-items"; yang_parent_name = "Inst-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::ControllerItems::~ControllerItems()
{
}
bool System::AnalyticsItems::InstItems::InstList::ControllerItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<controller_list.len(); index++)
{
if(controller_list[index]->has_data())
return true;
}
return false;
}
bool System::AnalyticsItems::InstItems::InstList::ControllerItems::has_operation() const
{
for (std::size_t index=0; index<controller_list.len(); index++)
{
if(controller_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::ControllerItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "controller-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::ControllerItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::ControllerItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "Controller-list")
{
auto ent_ = std::make_shared<System::AnalyticsItems::InstItems::InstList::ControllerItems::ControllerList>();
ent_->parent = this;
controller_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::ControllerItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : controller_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AnalyticsItems::InstItems::InstList::ControllerItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AnalyticsItems::InstItems::InstList::ControllerItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AnalyticsItems::InstItems::InstList::ControllerItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "Controller-list")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::ControllerItems::ControllerList::ControllerList()
:
name{YType::str, "name"},
descr{YType::str, "descr"},
vrfname{YType::str, "vrfName"},
dstaddr{YType::str, "dstAddr"},
dstport{YType::uint16, "dstPort"},
dscp{YType::uint8, "dscp"},
srcif{YType::str, "srcIf"},
srcaddr{YType::str, "srcAddr"}
{
yang_name = "Controller-list"; yang_parent_name = "controller-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::ControllerItems::ControllerList::~ControllerList()
{
}
bool System::AnalyticsItems::InstItems::InstList::ControllerItems::ControllerList::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| descr.is_set
|| vrfname.is_set
|| dstaddr.is_set
|| dstport.is_set
|| dscp.is_set
|| srcif.is_set
|| srcaddr.is_set;
}
bool System::AnalyticsItems::InstItems::InstList::ControllerItems::ControllerList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(descr.yfilter)
|| ydk::is_set(vrfname.yfilter)
|| ydk::is_set(dstaddr.yfilter)
|| ydk::is_set(dstport.yfilter)
|| ydk::is_set(dscp.yfilter)
|| ydk::is_set(srcif.yfilter)
|| ydk::is_set(srcaddr.yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::ControllerItems::ControllerList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "Controller-list";
ADD_KEY_TOKEN(name, "name");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::ControllerItems::ControllerList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
if (vrfname.is_set || is_set(vrfname.yfilter)) leaf_name_data.push_back(vrfname.get_name_leafdata());
if (dstaddr.is_set || is_set(dstaddr.yfilter)) leaf_name_data.push_back(dstaddr.get_name_leafdata());
if (dstport.is_set || is_set(dstport.yfilter)) leaf_name_data.push_back(dstport.get_name_leafdata());
if (dscp.is_set || is_set(dscp.yfilter)) leaf_name_data.push_back(dscp.get_name_leafdata());
if (srcif.is_set || is_set(srcif.yfilter)) leaf_name_data.push_back(srcif.get_name_leafdata());
if (srcaddr.is_set || is_set(srcaddr.yfilter)) leaf_name_data.push_back(srcaddr.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::ControllerItems::ControllerList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::ControllerItems::ControllerList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AnalyticsItems::InstItems::InstList::ControllerItems::ControllerList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
if(value_path == "vrfName")
{
vrfname = value;
vrfname.value_namespace = name_space;
vrfname.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstAddr")
{
dstaddr = value;
dstaddr.value_namespace = name_space;
dstaddr.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPort")
{
dstport = value;
dstport.value_namespace = name_space;
dstport.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dscp")
{
dscp = value;
dscp.value_namespace = name_space;
dscp.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcIf")
{
srcif = value;
srcif.value_namespace = name_space;
srcif.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcAddr")
{
srcaddr = value;
srcaddr.value_namespace = name_space;
srcaddr.value_namespace_prefix = name_space_prefix;
}
}
void System::AnalyticsItems::InstItems::InstList::ControllerItems::ControllerList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
if(value_path == "vrfName")
{
vrfname.yfilter = yfilter;
}
if(value_path == "dstAddr")
{
dstaddr.yfilter = yfilter;
}
if(value_path == "dstPort")
{
dstport.yfilter = yfilter;
}
if(value_path == "dscp")
{
dscp.yfilter = yfilter;
}
if(value_path == "srcIf")
{
srcif.yfilter = yfilter;
}
if(value_path == "srcAddr")
{
srcaddr.yfilter = yfilter;
}
}
bool System::AnalyticsItems::InstItems::InstList::ControllerItems::ControllerList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "name" || name == "descr" || name == "vrfName" || name == "dstAddr" || name == "dstPort" || name == "dscp" || name == "srcIf" || name == "srcAddr")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::RecordpItems::RecordpItems()
:
recordp_list(this, {"name"})
{
yang_name = "recordp-items"; yang_parent_name = "Inst-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::RecordpItems::~RecordpItems()
{
}
bool System::AnalyticsItems::InstItems::InstList::RecordpItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<recordp_list.len(); index++)
{
if(recordp_list[index]->has_data())
return true;
}
return false;
}
bool System::AnalyticsItems::InstItems::InstList::RecordpItems::has_operation() const
{
for (std::size_t index=0; index<recordp_list.len(); index++)
{
if(recordp_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::RecordpItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "recordp-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::RecordpItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::RecordpItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "RecordP-list")
{
auto ent_ = std::make_shared<System::AnalyticsItems::InstItems::InstList::RecordpItems::RecordPList>();
ent_->parent = this;
recordp_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::RecordpItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : recordp_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AnalyticsItems::InstItems::InstList::RecordpItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AnalyticsItems::InstItems::InstList::RecordpItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AnalyticsItems::InstItems::InstList::RecordpItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "RecordP-list")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::RecordpItems::RecordPList::RecordPList()
:
name{YType::str, "name"},
match{YType::str, "match"},
collect{YType::str, "collect"},
descr{YType::str, "descr"}
{
yang_name = "RecordP-list"; yang_parent_name = "recordp-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::RecordpItems::RecordPList::~RecordPList()
{
}
bool System::AnalyticsItems::InstItems::InstList::RecordpItems::RecordPList::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| match.is_set
|| collect.is_set
|| descr.is_set;
}
bool System::AnalyticsItems::InstItems::InstList::RecordpItems::RecordPList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(match.yfilter)
|| ydk::is_set(collect.yfilter)
|| ydk::is_set(descr.yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::RecordpItems::RecordPList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "RecordP-list";
ADD_KEY_TOKEN(name, "name");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::RecordpItems::RecordPList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (match.is_set || is_set(match.yfilter)) leaf_name_data.push_back(match.get_name_leafdata());
if (collect.is_set || is_set(collect.yfilter)) leaf_name_data.push_back(collect.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::RecordpItems::RecordPList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::RecordpItems::RecordPList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AnalyticsItems::InstItems::InstList::RecordpItems::RecordPList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "match")
{
match = value;
match.value_namespace = name_space;
match.value_namespace_prefix = name_space_prefix;
}
if(value_path == "collect")
{
collect = value;
collect.value_namespace = name_space;
collect.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
}
void System::AnalyticsItems::InstItems::InstList::RecordpItems::RecordPList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "match")
{
match.yfilter = yfilter;
}
if(value_path == "collect")
{
collect.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
}
bool System::AnalyticsItems::InstItems::InstList::RecordpItems::RecordPList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "name" || name == "match" || name == "collect" || name == "descr")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::CollectorItems::CollectorItems()
:
collector_list(this, {"name"})
{
yang_name = "collector-items"; yang_parent_name = "Inst-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::CollectorItems::~CollectorItems()
{
}
bool System::AnalyticsItems::InstItems::InstList::CollectorItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<collector_list.len(); index++)
{
if(collector_list[index]->has_data())
return true;
}
return false;
}
bool System::AnalyticsItems::InstItems::InstList::CollectorItems::has_operation() const
{
for (std::size_t index=0; index<collector_list.len(); index++)
{
if(collector_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::CollectorItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "collector-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::CollectorItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::CollectorItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "Collector-list")
{
auto ent_ = std::make_shared<System::AnalyticsItems::InstItems::InstList::CollectorItems::CollectorList>();
ent_->parent = this;
collector_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::CollectorItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : collector_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AnalyticsItems::InstItems::InstList::CollectorItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AnalyticsItems::InstItems::InstList::CollectorItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AnalyticsItems::InstItems::InstList::CollectorItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "Collector-list")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::CollectorItems::CollectorList::CollectorList()
:
name{YType::str, "name"},
ver{YType::enumeration, "ver"},
descr{YType::str, "descr"},
vrfname{YType::str, "vrfName"},
dstaddr{YType::str, "dstAddr"},
dstport{YType::uint16, "dstPort"},
dscp{YType::uint8, "dscp"},
srcif{YType::str, "srcIf"},
srcaddr{YType::str, "srcAddr"}
{
yang_name = "Collector-list"; yang_parent_name = "collector-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::CollectorItems::CollectorList::~CollectorList()
{
}
bool System::AnalyticsItems::InstItems::InstList::CollectorItems::CollectorList::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| ver.is_set
|| descr.is_set
|| vrfname.is_set
|| dstaddr.is_set
|| dstport.is_set
|| dscp.is_set
|| srcif.is_set
|| srcaddr.is_set;
}
bool System::AnalyticsItems::InstItems::InstList::CollectorItems::CollectorList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(ver.yfilter)
|| ydk::is_set(descr.yfilter)
|| ydk::is_set(vrfname.yfilter)
|| ydk::is_set(dstaddr.yfilter)
|| ydk::is_set(dstport.yfilter)
|| ydk::is_set(dscp.yfilter)
|| ydk::is_set(srcif.yfilter)
|| ydk::is_set(srcaddr.yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::CollectorItems::CollectorList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "Collector-list";
ADD_KEY_TOKEN(name, "name");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::CollectorItems::CollectorList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (ver.is_set || is_set(ver.yfilter)) leaf_name_data.push_back(ver.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
if (vrfname.is_set || is_set(vrfname.yfilter)) leaf_name_data.push_back(vrfname.get_name_leafdata());
if (dstaddr.is_set || is_set(dstaddr.yfilter)) leaf_name_data.push_back(dstaddr.get_name_leafdata());
if (dstport.is_set || is_set(dstport.yfilter)) leaf_name_data.push_back(dstport.get_name_leafdata());
if (dscp.is_set || is_set(dscp.yfilter)) leaf_name_data.push_back(dscp.get_name_leafdata());
if (srcif.is_set || is_set(srcif.yfilter)) leaf_name_data.push_back(srcif.get_name_leafdata());
if (srcaddr.is_set || is_set(srcaddr.yfilter)) leaf_name_data.push_back(srcaddr.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::CollectorItems::CollectorList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::CollectorItems::CollectorList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AnalyticsItems::InstItems::InstList::CollectorItems::CollectorList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "ver")
{
ver = value;
ver.value_namespace = name_space;
ver.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
if(value_path == "vrfName")
{
vrfname = value;
vrfname.value_namespace = name_space;
vrfname.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstAddr")
{
dstaddr = value;
dstaddr.value_namespace = name_space;
dstaddr.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPort")
{
dstport = value;
dstport.value_namespace = name_space;
dstport.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dscp")
{
dscp = value;
dscp.value_namespace = name_space;
dscp.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcIf")
{
srcif = value;
srcif.value_namespace = name_space;
srcif.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcAddr")
{
srcaddr = value;
srcaddr.value_namespace = name_space;
srcaddr.value_namespace_prefix = name_space_prefix;
}
}
void System::AnalyticsItems::InstItems::InstList::CollectorItems::CollectorList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "ver")
{
ver.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
if(value_path == "vrfName")
{
vrfname.yfilter = yfilter;
}
if(value_path == "dstAddr")
{
dstaddr.yfilter = yfilter;
}
if(value_path == "dstPort")
{
dstport.yfilter = yfilter;
}
if(value_path == "dscp")
{
dscp.yfilter = yfilter;
}
if(value_path == "srcIf")
{
srcif.yfilter = yfilter;
}
if(value_path == "srcAddr")
{
srcaddr.yfilter = yfilter;
}
}
bool System::AnalyticsItems::InstItems::InstList::CollectorItems::CollectorList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "name" || name == "ver" || name == "descr" || name == "vrfName" || name == "dstAddr" || name == "dstPort" || name == "dscp" || name == "srcIf" || name == "srcAddr")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorItems()
:
monitor_list(this, {"name"})
{
yang_name = "monitor-items"; yang_parent_name = "Inst-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::MonitorItems::~MonitorItems()
{
}
bool System::AnalyticsItems::InstItems::InstList::MonitorItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<monitor_list.len(); index++)
{
if(monitor_list[index]->has_data())
return true;
}
return false;
}
bool System::AnalyticsItems::InstItems::InstList::MonitorItems::has_operation() const
{
for (std::size_t index=0; index<monitor_list.len(); index++)
{
if(monitor_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::MonitorItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "monitor-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::MonitorItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::MonitorItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "Monitor-list")
{
auto ent_ = std::make_shared<System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList>();
ent_->parent = this;
monitor_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::MonitorItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : monitor_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AnalyticsItems::InstItems::InstList::MonitorItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AnalyticsItems::InstItems::InstList::MonitorItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AnalyticsItems::InstItems::InstList::MonitorItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "Monitor-list")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::MonitorList()
:
name{YType::str, "name"},
descr{YType::str, "descr"}
,
collectorbucket_items(std::make_shared<System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems>())
, rsrecordpatt_items(std::make_shared<System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems>())
{
collectorbucket_items->parent = this;
rsrecordpatt_items->parent = this;
yang_name = "Monitor-list"; yang_parent_name = "monitor-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::~MonitorList()
{
}
bool System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| descr.is_set
|| (collectorbucket_items != nullptr && collectorbucket_items->has_data())
|| (rsrecordpatt_items != nullptr && rsrecordpatt_items->has_data());
}
bool System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(descr.yfilter)
|| (collectorbucket_items != nullptr && collectorbucket_items->has_operation())
|| (rsrecordpatt_items != nullptr && rsrecordpatt_items->has_operation());
}
std::string System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "Monitor-list";
ADD_KEY_TOKEN(name, "name");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "collectorbucket-items")
{
if(collectorbucket_items == nullptr)
{
collectorbucket_items = std::make_shared<System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems>();
}
return collectorbucket_items;
}
if(child_yang_name == "rsrecordPAtt-items")
{
if(rsrecordpatt_items == nullptr)
{
rsrecordpatt_items = std::make_shared<System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems>();
}
return rsrecordpatt_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(collectorbucket_items != nullptr)
{
_children["collectorbucket-items"] = collectorbucket_items;
}
if(rsrecordpatt_items != nullptr)
{
_children["rsrecordPAtt-items"] = rsrecordpatt_items;
}
return _children;
}
void System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
}
void System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
}
bool System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "collectorbucket-items" || name == "rsrecordPAtt-items" || name == "name" || name == "descr")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorbucketItems()
:
collectorbucket_list(this, {"id"})
{
yang_name = "collectorbucket-items"; yang_parent_name = "Monitor-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::~CollectorbucketItems()
{
}
bool System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<collectorbucket_list.len(); index++)
{
if(collectorbucket_list[index]->has_data())
return true;
}
return false;
}
bool System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::has_operation() const
{
for (std::size_t index=0; index<collectorbucket_list.len(); index++)
{
if(collectorbucket_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "collectorbucket-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "CollectorBucket-list")
{
auto ent_ = std::make_shared<System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList>();
ent_->parent = this;
collectorbucket_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : collectorbucket_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "CollectorBucket-list")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::CollectorBucketList()
:
id{YType::uint8, "id"},
hashlo{YType::uint32, "hashLo"},
hashhi{YType::uint32, "hashHi"},
descr{YType::str, "descr"}
,
rscollectoratt_items(std::make_shared<System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::RscollectorAttItems>())
{
rscollectoratt_items->parent = this;
yang_name = "CollectorBucket-list"; yang_parent_name = "collectorbucket-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::~CollectorBucketList()
{
}
bool System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::has_data() const
{
if (is_presence_container) return true;
return id.is_set
|| hashlo.is_set
|| hashhi.is_set
|| descr.is_set
|| (rscollectoratt_items != nullptr && rscollectoratt_items->has_data());
}
bool System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(id.yfilter)
|| ydk::is_set(hashlo.yfilter)
|| ydk::is_set(hashhi.yfilter)
|| ydk::is_set(descr.yfilter)
|| (rscollectoratt_items != nullptr && rscollectoratt_items->has_operation());
}
std::string System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "CollectorBucket-list";
ADD_KEY_TOKEN(id, "id");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (id.is_set || is_set(id.yfilter)) leaf_name_data.push_back(id.get_name_leafdata());
if (hashlo.is_set || is_set(hashlo.yfilter)) leaf_name_data.push_back(hashlo.get_name_leafdata());
if (hashhi.is_set || is_set(hashhi.yfilter)) leaf_name_data.push_back(hashhi.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "rscollectorAtt-items")
{
if(rscollectoratt_items == nullptr)
{
rscollectoratt_items = std::make_shared<System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::RscollectorAttItems>();
}
return rscollectoratt_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(rscollectoratt_items != nullptr)
{
_children["rscollectorAtt-items"] = rscollectoratt_items;
}
return _children;
}
void System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "id")
{
id = value;
id.value_namespace = name_space;
id.value_namespace_prefix = name_space_prefix;
}
if(value_path == "hashLo")
{
hashlo = value;
hashlo.value_namespace = name_space;
hashlo.value_namespace_prefix = name_space_prefix;
}
if(value_path == "hashHi")
{
hashhi = value;
hashhi.value_namespace = name_space;
hashhi.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
}
void System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "id")
{
id.yfilter = yfilter;
}
if(value_path == "hashLo")
{
hashlo.yfilter = yfilter;
}
if(value_path == "hashHi")
{
hashhi.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
}
bool System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "rscollectorAtt-items" || name == "id" || name == "hashLo" || name == "hashHi" || name == "descr")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::RscollectorAttItems::RscollectorAttItems()
:
rscollectoratt_list(this, {"tdn"})
{
yang_name = "rscollectorAtt-items"; yang_parent_name = "CollectorBucket-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::RscollectorAttItems::~RscollectorAttItems()
{
}
bool System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::RscollectorAttItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<rscollectoratt_list.len(); index++)
{
if(rscollectoratt_list[index]->has_data())
return true;
}
return false;
}
bool System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::RscollectorAttItems::has_operation() const
{
for (std::size_t index=0; index<rscollectoratt_list.len(); index++)
{
if(rscollectoratt_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::RscollectorAttItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "rscollectorAtt-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::RscollectorAttItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::RscollectorAttItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "RsCollectorAtt-list")
{
auto ent_ = std::make_shared<System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::RscollectorAttItems::RsCollectorAttList>();
ent_->parent = this;
rscollectoratt_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::RscollectorAttItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : rscollectoratt_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::RscollectorAttItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::RscollectorAttItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::RscollectorAttItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "RsCollectorAtt-list")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::RscollectorAttItems::RsCollectorAttList::RsCollectorAttList()
:
tdn{YType::str, "tDn"}
{
yang_name = "RsCollectorAtt-list"; yang_parent_name = "rscollectorAtt-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::RscollectorAttItems::RsCollectorAttList::~RsCollectorAttList()
{
}
bool System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::RscollectorAttItems::RsCollectorAttList::has_data() const
{
if (is_presence_container) return true;
return tdn.is_set;
}
bool System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::RscollectorAttItems::RsCollectorAttList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(tdn.yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::RscollectorAttItems::RsCollectorAttList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "RsCollectorAtt-list";
ADD_KEY_TOKEN(tdn, "tDn");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::RscollectorAttItems::RsCollectorAttList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (tdn.is_set || is_set(tdn.yfilter)) leaf_name_data.push_back(tdn.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::RscollectorAttItems::RsCollectorAttList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::RscollectorAttItems::RsCollectorAttList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::RscollectorAttItems::RsCollectorAttList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "tDn")
{
tdn = value;
tdn.value_namespace = name_space;
tdn.value_namespace_prefix = name_space_prefix;
}
}
void System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::RscollectorAttItems::RsCollectorAttList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "tDn")
{
tdn.yfilter = yfilter;
}
}
bool System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::CollectorbucketItems::CollectorBucketList::RscollectorAttItems::RsCollectorAttList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "tDn")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems::RsrecordPAttItems()
:
tdn{YType::str, "tDn"}
{
yang_name = "rsrecordPAtt-items"; yang_parent_name = "Monitor-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems::~RsrecordPAttItems()
{
}
bool System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems::has_data() const
{
if (is_presence_container) return true;
return tdn.is_set;
}
bool System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(tdn.yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "rsrecordPAtt-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (tdn.is_set || is_set(tdn.yfilter)) leaf_name_data.push_back(tdn.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "tDn")
{
tdn = value;
tdn.value_namespace = name_space;
tdn.value_namespace_prefix = name_space_prefix;
}
}
void System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "tDn")
{
tdn.yfilter = yfilter;
}
}
bool System::AnalyticsItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "tDn")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::ProfItems::ProfItems()
:
profile_list(this, {"name"})
{
yang_name = "prof-items"; yang_parent_name = "Inst-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::ProfItems::~ProfItems()
{
}
bool System::AnalyticsItems::InstItems::InstList::ProfItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<profile_list.len(); index++)
{
if(profile_list[index]->has_data())
return true;
}
return false;
}
bool System::AnalyticsItems::InstItems::InstList::ProfItems::has_operation() const
{
for (std::size_t index=0; index<profile_list.len(); index++)
{
if(profile_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::ProfItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "prof-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::ProfItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::ProfItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "Profile-list")
{
auto ent_ = std::make_shared<System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList>();
ent_->parent = this;
profile_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::ProfItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : profile_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AnalyticsItems::InstItems::InstList::ProfItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AnalyticsItems::InstItems::InstList::ProfItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AnalyticsItems::InstItems::InstList::ProfItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "Profile-list")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::ProfileList()
:
name{YType::str, "name"},
collectintvl{YType::uint32, "collectIntvl"},
srcport{YType::uint32, "srcPort"},
ippktidshift{YType::uint8, "ipPktIdShift"},
burstintvlshift{YType::uint8, "burstIntvlShift"},
mtu{YType::uint16, "mtu"},
seqnumguessthreshlo{YType::uint32, "seqNumGuessThreshLo"},
seqnumguessthreshhi{YType::uint32, "seqNumGuessThreshHi"},
descr{YType::str, "descr"}
,
payloadlenbin_items(std::make_shared<System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::PayloadlenbinItems>())
, tcpopthdrlenbin_items(std::make_shared<System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::TcpopthdrlenbinItems>())
, rcvwindowszbin_items(std::make_shared<System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::RcvwindowszbinItems>())
{
payloadlenbin_items->parent = this;
tcpopthdrlenbin_items->parent = this;
rcvwindowszbin_items->parent = this;
yang_name = "Profile-list"; yang_parent_name = "prof-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::~ProfileList()
{
}
bool System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| collectintvl.is_set
|| srcport.is_set
|| ippktidshift.is_set
|| burstintvlshift.is_set
|| mtu.is_set
|| seqnumguessthreshlo.is_set
|| seqnumguessthreshhi.is_set
|| descr.is_set
|| (payloadlenbin_items != nullptr && payloadlenbin_items->has_data())
|| (tcpopthdrlenbin_items != nullptr && tcpopthdrlenbin_items->has_data())
|| (rcvwindowszbin_items != nullptr && rcvwindowszbin_items->has_data());
}
bool System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(collectintvl.yfilter)
|| ydk::is_set(srcport.yfilter)
|| ydk::is_set(ippktidshift.yfilter)
|| ydk::is_set(burstintvlshift.yfilter)
|| ydk::is_set(mtu.yfilter)
|| ydk::is_set(seqnumguessthreshlo.yfilter)
|| ydk::is_set(seqnumguessthreshhi.yfilter)
|| ydk::is_set(descr.yfilter)
|| (payloadlenbin_items != nullptr && payloadlenbin_items->has_operation())
|| (tcpopthdrlenbin_items != nullptr && tcpopthdrlenbin_items->has_operation())
|| (rcvwindowszbin_items != nullptr && rcvwindowszbin_items->has_operation());
}
std::string System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "Profile-list";
ADD_KEY_TOKEN(name, "name");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (collectintvl.is_set || is_set(collectintvl.yfilter)) leaf_name_data.push_back(collectintvl.get_name_leafdata());
if (srcport.is_set || is_set(srcport.yfilter)) leaf_name_data.push_back(srcport.get_name_leafdata());
if (ippktidshift.is_set || is_set(ippktidshift.yfilter)) leaf_name_data.push_back(ippktidshift.get_name_leafdata());
if (burstintvlshift.is_set || is_set(burstintvlshift.yfilter)) leaf_name_data.push_back(burstintvlshift.get_name_leafdata());
if (mtu.is_set || is_set(mtu.yfilter)) leaf_name_data.push_back(mtu.get_name_leafdata());
if (seqnumguessthreshlo.is_set || is_set(seqnumguessthreshlo.yfilter)) leaf_name_data.push_back(seqnumguessthreshlo.get_name_leafdata());
if (seqnumguessthreshhi.is_set || is_set(seqnumguessthreshhi.yfilter)) leaf_name_data.push_back(seqnumguessthreshhi.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "payloadlenbin-items")
{
if(payloadlenbin_items == nullptr)
{
payloadlenbin_items = std::make_shared<System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::PayloadlenbinItems>();
}
return payloadlenbin_items;
}
if(child_yang_name == "tcpopthdrlenbin-items")
{
if(tcpopthdrlenbin_items == nullptr)
{
tcpopthdrlenbin_items = std::make_shared<System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::TcpopthdrlenbinItems>();
}
return tcpopthdrlenbin_items;
}
if(child_yang_name == "rcvwindowszbin-items")
{
if(rcvwindowszbin_items == nullptr)
{
rcvwindowszbin_items = std::make_shared<System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::RcvwindowszbinItems>();
}
return rcvwindowszbin_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(payloadlenbin_items != nullptr)
{
_children["payloadlenbin-items"] = payloadlenbin_items;
}
if(tcpopthdrlenbin_items != nullptr)
{
_children["tcpopthdrlenbin-items"] = tcpopthdrlenbin_items;
}
if(rcvwindowszbin_items != nullptr)
{
_children["rcvwindowszbin-items"] = rcvwindowszbin_items;
}
return _children;
}
void System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "collectIntvl")
{
collectintvl = value;
collectintvl.value_namespace = name_space;
collectintvl.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPort")
{
srcport = value;
srcport.value_namespace = name_space;
srcport.value_namespace_prefix = name_space_prefix;
}
if(value_path == "ipPktIdShift")
{
ippktidshift = value;
ippktidshift.value_namespace = name_space;
ippktidshift.value_namespace_prefix = name_space_prefix;
}
if(value_path == "burstIntvlShift")
{
burstintvlshift = value;
burstintvlshift.value_namespace = name_space;
burstintvlshift.value_namespace_prefix = name_space_prefix;
}
if(value_path == "mtu")
{
mtu = value;
mtu.value_namespace = name_space;
mtu.value_namespace_prefix = name_space_prefix;
}
if(value_path == "seqNumGuessThreshLo")
{
seqnumguessthreshlo = value;
seqnumguessthreshlo.value_namespace = name_space;
seqnumguessthreshlo.value_namespace_prefix = name_space_prefix;
}
if(value_path == "seqNumGuessThreshHi")
{
seqnumguessthreshhi = value;
seqnumguessthreshhi.value_namespace = name_space;
seqnumguessthreshhi.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
}
void System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "collectIntvl")
{
collectintvl.yfilter = yfilter;
}
if(value_path == "srcPort")
{
srcport.yfilter = yfilter;
}
if(value_path == "ipPktIdShift")
{
ippktidshift.yfilter = yfilter;
}
if(value_path == "burstIntvlShift")
{
burstintvlshift.yfilter = yfilter;
}
if(value_path == "mtu")
{
mtu.yfilter = yfilter;
}
if(value_path == "seqNumGuessThreshLo")
{
seqnumguessthreshlo.yfilter = yfilter;
}
if(value_path == "seqNumGuessThreshHi")
{
seqnumguessthreshhi.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
}
bool System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "payloadlenbin-items" || name == "tcpopthdrlenbin-items" || name == "rcvwindowszbin-items" || name == "name" || name == "collectIntvl" || name == "srcPort" || name == "ipPktIdShift" || name == "burstIntvlShift" || name == "mtu" || name == "seqNumGuessThreshLo" || name == "seqNumGuessThreshHi" || name == "descr")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::PayloadlenbinItems::PayloadlenbinItems()
:
payloadlenbin_list(this, {"id"})
{
yang_name = "payloadlenbin-items"; yang_parent_name = "Profile-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::PayloadlenbinItems::~PayloadlenbinItems()
{
}
bool System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::PayloadlenbinItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<payloadlenbin_list.len(); index++)
{
if(payloadlenbin_list[index]->has_data())
return true;
}
return false;
}
bool System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::PayloadlenbinItems::has_operation() const
{
for (std::size_t index=0; index<payloadlenbin_list.len(); index++)
{
if(payloadlenbin_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::PayloadlenbinItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "payloadlenbin-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::PayloadlenbinItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::PayloadlenbinItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "PayloadLenBin-list")
{
auto ent_ = std::make_shared<System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::PayloadlenbinItems::PayloadLenBinList>();
ent_->parent = this;
payloadlenbin_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::PayloadlenbinItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : payloadlenbin_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::PayloadlenbinItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::PayloadlenbinItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::PayloadlenbinItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "PayloadLenBin-list")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::PayloadlenbinItems::PayloadLenBinList::PayloadLenBinList()
:
id{YType::uint8, "id"},
lo{YType::uint32, "lo"},
hi{YType::uint32, "hi"},
descr{YType::str, "descr"}
{
yang_name = "PayloadLenBin-list"; yang_parent_name = "payloadlenbin-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::PayloadlenbinItems::PayloadLenBinList::~PayloadLenBinList()
{
}
bool System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::PayloadlenbinItems::PayloadLenBinList::has_data() const
{
if (is_presence_container) return true;
return id.is_set
|| lo.is_set
|| hi.is_set
|| descr.is_set;
}
bool System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::PayloadlenbinItems::PayloadLenBinList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(id.yfilter)
|| ydk::is_set(lo.yfilter)
|| ydk::is_set(hi.yfilter)
|| ydk::is_set(descr.yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::PayloadlenbinItems::PayloadLenBinList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "PayloadLenBin-list";
ADD_KEY_TOKEN(id, "id");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::PayloadlenbinItems::PayloadLenBinList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (id.is_set || is_set(id.yfilter)) leaf_name_data.push_back(id.get_name_leafdata());
if (lo.is_set || is_set(lo.yfilter)) leaf_name_data.push_back(lo.get_name_leafdata());
if (hi.is_set || is_set(hi.yfilter)) leaf_name_data.push_back(hi.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::PayloadlenbinItems::PayloadLenBinList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::PayloadlenbinItems::PayloadLenBinList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::PayloadlenbinItems::PayloadLenBinList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "id")
{
id = value;
id.value_namespace = name_space;
id.value_namespace_prefix = name_space_prefix;
}
if(value_path == "lo")
{
lo = value;
lo.value_namespace = name_space;
lo.value_namespace_prefix = name_space_prefix;
}
if(value_path == "hi")
{
hi = value;
hi.value_namespace = name_space;
hi.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
}
void System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::PayloadlenbinItems::PayloadLenBinList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "id")
{
id.yfilter = yfilter;
}
if(value_path == "lo")
{
lo.yfilter = yfilter;
}
if(value_path == "hi")
{
hi.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
}
bool System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::PayloadlenbinItems::PayloadLenBinList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "id" || name == "lo" || name == "hi" || name == "descr")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::TcpopthdrlenbinItems::TcpopthdrlenbinItems()
:
tcpopthdrlenbin_list(this, {"id"})
{
yang_name = "tcpopthdrlenbin-items"; yang_parent_name = "Profile-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::TcpopthdrlenbinItems::~TcpopthdrlenbinItems()
{
}
bool System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::TcpopthdrlenbinItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<tcpopthdrlenbin_list.len(); index++)
{
if(tcpopthdrlenbin_list[index]->has_data())
return true;
}
return false;
}
bool System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::TcpopthdrlenbinItems::has_operation() const
{
for (std::size_t index=0; index<tcpopthdrlenbin_list.len(); index++)
{
if(tcpopthdrlenbin_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::TcpopthdrlenbinItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "tcpopthdrlenbin-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::TcpopthdrlenbinItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::TcpopthdrlenbinItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "TCPOptHdrLenBin-list")
{
auto ent_ = std::make_shared<System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::TcpopthdrlenbinItems::TCPOptHdrLenBinList>();
ent_->parent = this;
tcpopthdrlenbin_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::TcpopthdrlenbinItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : tcpopthdrlenbin_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::TcpopthdrlenbinItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::TcpopthdrlenbinItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::TcpopthdrlenbinItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "TCPOptHdrLenBin-list")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::TcpopthdrlenbinItems::TCPOptHdrLenBinList::TCPOptHdrLenBinList()
:
id{YType::uint8, "id"},
lo{YType::uint32, "lo"},
hi{YType::uint32, "hi"},
descr{YType::str, "descr"}
{
yang_name = "TCPOptHdrLenBin-list"; yang_parent_name = "tcpopthdrlenbin-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::TcpopthdrlenbinItems::TCPOptHdrLenBinList::~TCPOptHdrLenBinList()
{
}
bool System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::TcpopthdrlenbinItems::TCPOptHdrLenBinList::has_data() const
{
if (is_presence_container) return true;
return id.is_set
|| lo.is_set
|| hi.is_set
|| descr.is_set;
}
bool System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::TcpopthdrlenbinItems::TCPOptHdrLenBinList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(id.yfilter)
|| ydk::is_set(lo.yfilter)
|| ydk::is_set(hi.yfilter)
|| ydk::is_set(descr.yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::TcpopthdrlenbinItems::TCPOptHdrLenBinList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "TCPOptHdrLenBin-list";
ADD_KEY_TOKEN(id, "id");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::TcpopthdrlenbinItems::TCPOptHdrLenBinList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (id.is_set || is_set(id.yfilter)) leaf_name_data.push_back(id.get_name_leafdata());
if (lo.is_set || is_set(lo.yfilter)) leaf_name_data.push_back(lo.get_name_leafdata());
if (hi.is_set || is_set(hi.yfilter)) leaf_name_data.push_back(hi.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::TcpopthdrlenbinItems::TCPOptHdrLenBinList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::TcpopthdrlenbinItems::TCPOptHdrLenBinList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::TcpopthdrlenbinItems::TCPOptHdrLenBinList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "id")
{
id = value;
id.value_namespace = name_space;
id.value_namespace_prefix = name_space_prefix;
}
if(value_path == "lo")
{
lo = value;
lo.value_namespace = name_space;
lo.value_namespace_prefix = name_space_prefix;
}
if(value_path == "hi")
{
hi = value;
hi.value_namespace = name_space;
hi.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
}
void System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::TcpopthdrlenbinItems::TCPOptHdrLenBinList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "id")
{
id.yfilter = yfilter;
}
if(value_path == "lo")
{
lo.yfilter = yfilter;
}
if(value_path == "hi")
{
hi.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
}
bool System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::TcpopthdrlenbinItems::TCPOptHdrLenBinList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "id" || name == "lo" || name == "hi" || name == "descr")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::RcvwindowszbinItems::RcvwindowszbinItems()
:
rcvwindowszbin_list(this, {"id"})
{
yang_name = "rcvwindowszbin-items"; yang_parent_name = "Profile-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::RcvwindowszbinItems::~RcvwindowszbinItems()
{
}
bool System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::RcvwindowszbinItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<rcvwindowszbin_list.len(); index++)
{
if(rcvwindowszbin_list[index]->has_data())
return true;
}
return false;
}
bool System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::RcvwindowszbinItems::has_operation() const
{
for (std::size_t index=0; index<rcvwindowszbin_list.len(); index++)
{
if(rcvwindowszbin_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::RcvwindowszbinItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "rcvwindowszbin-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::RcvwindowszbinItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::RcvwindowszbinItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "RcvWindowSzBin-list")
{
auto ent_ = std::make_shared<System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::RcvwindowszbinItems::RcvWindowSzBinList>();
ent_->parent = this;
rcvwindowszbin_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::RcvwindowszbinItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : rcvwindowszbin_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::RcvwindowszbinItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::RcvwindowszbinItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::RcvwindowszbinItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "RcvWindowSzBin-list")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::RcvwindowszbinItems::RcvWindowSzBinList::RcvWindowSzBinList()
:
id{YType::uint8, "id"},
lo{YType::uint32, "lo"},
hi{YType::uint32, "hi"},
descr{YType::str, "descr"}
{
yang_name = "RcvWindowSzBin-list"; yang_parent_name = "rcvwindowszbin-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::RcvwindowszbinItems::RcvWindowSzBinList::~RcvWindowSzBinList()
{
}
bool System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::RcvwindowszbinItems::RcvWindowSzBinList::has_data() const
{
if (is_presence_container) return true;
return id.is_set
|| lo.is_set
|| hi.is_set
|| descr.is_set;
}
bool System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::RcvwindowszbinItems::RcvWindowSzBinList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(id.yfilter)
|| ydk::is_set(lo.yfilter)
|| ydk::is_set(hi.yfilter)
|| ydk::is_set(descr.yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::RcvwindowszbinItems::RcvWindowSzBinList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "RcvWindowSzBin-list";
ADD_KEY_TOKEN(id, "id");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::RcvwindowszbinItems::RcvWindowSzBinList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (id.is_set || is_set(id.yfilter)) leaf_name_data.push_back(id.get_name_leafdata());
if (lo.is_set || is_set(lo.yfilter)) leaf_name_data.push_back(lo.get_name_leafdata());
if (hi.is_set || is_set(hi.yfilter)) leaf_name_data.push_back(hi.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::RcvwindowszbinItems::RcvWindowSzBinList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::RcvwindowszbinItems::RcvWindowSzBinList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::RcvwindowszbinItems::RcvWindowSzBinList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "id")
{
id = value;
id.value_namespace = name_space;
id.value_namespace_prefix = name_space_prefix;
}
if(value_path == "lo")
{
lo = value;
lo.value_namespace = name_space;
lo.value_namespace_prefix = name_space_prefix;
}
if(value_path == "hi")
{
hi = value;
hi.value_namespace = name_space;
hi.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
}
void System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::RcvwindowszbinItems::RcvWindowSzBinList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "id")
{
id.yfilter = yfilter;
}
if(value_path == "lo")
{
lo.yfilter = yfilter;
}
if(value_path == "hi")
{
hi.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
}
bool System::AnalyticsItems::InstItems::InstList::ProfItems::ProfileList::RcvwindowszbinItems::RcvWindowSzBinList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "id" || name == "lo" || name == "hi" || name == "descr")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdinstItems()
:
fwdinsttarget_list(this, {"id"})
{
yang_name = "fwdinst-items"; yang_parent_name = "Inst-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::FwdinstItems::~FwdinstItems()
{
}
bool System::AnalyticsItems::InstItems::InstList::FwdinstItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<fwdinsttarget_list.len(); index++)
{
if(fwdinsttarget_list[index]->has_data())
return true;
}
return false;
}
bool System::AnalyticsItems::InstItems::InstList::FwdinstItems::has_operation() const
{
for (std::size_t index=0; index<fwdinsttarget_list.len(); index++)
{
if(fwdinsttarget_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::FwdinstItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "fwdinst-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::FwdinstItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::FwdinstItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "FwdInstTarget-list")
{
auto ent_ = std::make_shared<System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList>();
ent_->parent = this;
fwdinsttarget_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::FwdinstItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : fwdinsttarget_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AnalyticsItems::InstItems::InstList::FwdinstItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AnalyticsItems::InstItems::InstList::FwdinstItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AnalyticsItems::InstItems::InstList::FwdinstItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "FwdInstTarget-list")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::FwdInstTargetList()
:
id{YType::uint32, "id"},
collectorid{YType::uint32, "collectorId"},
defpolicy{YType::enumeration, "DefPolicy"},
ipv4hit{YType::uint32, "ipv4Hit"},
ipv6hit{YType::uint32, "ipv6Hit"},
cehit{YType::uint32, "ceHit"},
ipv4create{YType::uint32, "ipv4Create"},
ipv6create{YType::uint32, "ipv6Create"},
cecreate{YType::uint32, "ceCreate"},
exportcount{YType::uint32, "exportCount"},
skipcount{YType::uint32, "skipCount"},
flttype{YType::enumeration, "fltType"},
dir{YType::enumeration, "dir"}
,
rsprofatt_items(std::make_shared<System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RsprofAttItems>())
, rspolicyatt_items(std::make_shared<System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RspolicyAttItems>())
, dbgstatistics_items(std::make_shared<System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::DbgStatisticsItems>())
{
rsprofatt_items->parent = this;
rspolicyatt_items->parent = this;
dbgstatistics_items->parent = this;
yang_name = "FwdInstTarget-list"; yang_parent_name = "fwdinst-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::~FwdInstTargetList()
{
}
bool System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::has_data() const
{
if (is_presence_container) return true;
return id.is_set
|| collectorid.is_set
|| defpolicy.is_set
|| ipv4hit.is_set
|| ipv6hit.is_set
|| cehit.is_set
|| ipv4create.is_set
|| ipv6create.is_set
|| cecreate.is_set
|| exportcount.is_set
|| skipcount.is_set
|| flttype.is_set
|| dir.is_set
|| (rsprofatt_items != nullptr && rsprofatt_items->has_data())
|| (rspolicyatt_items != nullptr && rspolicyatt_items->has_data())
|| (dbgstatistics_items != nullptr && dbgstatistics_items->has_data());
}
bool System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(id.yfilter)
|| ydk::is_set(collectorid.yfilter)
|| ydk::is_set(defpolicy.yfilter)
|| ydk::is_set(ipv4hit.yfilter)
|| ydk::is_set(ipv6hit.yfilter)
|| ydk::is_set(cehit.yfilter)
|| ydk::is_set(ipv4create.yfilter)
|| ydk::is_set(ipv6create.yfilter)
|| ydk::is_set(cecreate.yfilter)
|| ydk::is_set(exportcount.yfilter)
|| ydk::is_set(skipcount.yfilter)
|| ydk::is_set(flttype.yfilter)
|| ydk::is_set(dir.yfilter)
|| (rsprofatt_items != nullptr && rsprofatt_items->has_operation())
|| (rspolicyatt_items != nullptr && rspolicyatt_items->has_operation())
|| (dbgstatistics_items != nullptr && dbgstatistics_items->has_operation());
}
std::string System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "FwdInstTarget-list";
ADD_KEY_TOKEN(id, "id");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (id.is_set || is_set(id.yfilter)) leaf_name_data.push_back(id.get_name_leafdata());
if (collectorid.is_set || is_set(collectorid.yfilter)) leaf_name_data.push_back(collectorid.get_name_leafdata());
if (defpolicy.is_set || is_set(defpolicy.yfilter)) leaf_name_data.push_back(defpolicy.get_name_leafdata());
if (ipv4hit.is_set || is_set(ipv4hit.yfilter)) leaf_name_data.push_back(ipv4hit.get_name_leafdata());
if (ipv6hit.is_set || is_set(ipv6hit.yfilter)) leaf_name_data.push_back(ipv6hit.get_name_leafdata());
if (cehit.is_set || is_set(cehit.yfilter)) leaf_name_data.push_back(cehit.get_name_leafdata());
if (ipv4create.is_set || is_set(ipv4create.yfilter)) leaf_name_data.push_back(ipv4create.get_name_leafdata());
if (ipv6create.is_set || is_set(ipv6create.yfilter)) leaf_name_data.push_back(ipv6create.get_name_leafdata());
if (cecreate.is_set || is_set(cecreate.yfilter)) leaf_name_data.push_back(cecreate.get_name_leafdata());
if (exportcount.is_set || is_set(exportcount.yfilter)) leaf_name_data.push_back(exportcount.get_name_leafdata());
if (skipcount.is_set || is_set(skipcount.yfilter)) leaf_name_data.push_back(skipcount.get_name_leafdata());
if (flttype.is_set || is_set(flttype.yfilter)) leaf_name_data.push_back(flttype.get_name_leafdata());
if (dir.is_set || is_set(dir.yfilter)) leaf_name_data.push_back(dir.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "rsprofAtt-items")
{
if(rsprofatt_items == nullptr)
{
rsprofatt_items = std::make_shared<System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RsprofAttItems>();
}
return rsprofatt_items;
}
if(child_yang_name == "rspolicyAtt-items")
{
if(rspolicyatt_items == nullptr)
{
rspolicyatt_items = std::make_shared<System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RspolicyAttItems>();
}
return rspolicyatt_items;
}
if(child_yang_name == "dbgStatistics-items")
{
if(dbgstatistics_items == nullptr)
{
dbgstatistics_items = std::make_shared<System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::DbgStatisticsItems>();
}
return dbgstatistics_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(rsprofatt_items != nullptr)
{
_children["rsprofAtt-items"] = rsprofatt_items;
}
if(rspolicyatt_items != nullptr)
{
_children["rspolicyAtt-items"] = rspolicyatt_items;
}
if(dbgstatistics_items != nullptr)
{
_children["dbgStatistics-items"] = dbgstatistics_items;
}
return _children;
}
void System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "id")
{
id = value;
id.value_namespace = name_space;
id.value_namespace_prefix = name_space_prefix;
}
if(value_path == "collectorId")
{
collectorid = value;
collectorid.value_namespace = name_space;
collectorid.value_namespace_prefix = name_space_prefix;
}
if(value_path == "DefPolicy")
{
defpolicy = value;
defpolicy.value_namespace = name_space;
defpolicy.value_namespace_prefix = name_space_prefix;
}
if(value_path == "ipv4Hit")
{
ipv4hit = value;
ipv4hit.value_namespace = name_space;
ipv4hit.value_namespace_prefix = name_space_prefix;
}
if(value_path == "ipv6Hit")
{
ipv6hit = value;
ipv6hit.value_namespace = name_space;
ipv6hit.value_namespace_prefix = name_space_prefix;
}
if(value_path == "ceHit")
{
cehit = value;
cehit.value_namespace = name_space;
cehit.value_namespace_prefix = name_space_prefix;
}
if(value_path == "ipv4Create")
{
ipv4create = value;
ipv4create.value_namespace = name_space;
ipv4create.value_namespace_prefix = name_space_prefix;
}
if(value_path == "ipv6Create")
{
ipv6create = value;
ipv6create.value_namespace = name_space;
ipv6create.value_namespace_prefix = name_space_prefix;
}
if(value_path == "ceCreate")
{
cecreate = value;
cecreate.value_namespace = name_space;
cecreate.value_namespace_prefix = name_space_prefix;
}
if(value_path == "exportCount")
{
exportcount = value;
exportcount.value_namespace = name_space;
exportcount.value_namespace_prefix = name_space_prefix;
}
if(value_path == "skipCount")
{
skipcount = value;
skipcount.value_namespace = name_space;
skipcount.value_namespace_prefix = name_space_prefix;
}
if(value_path == "fltType")
{
flttype = value;
flttype.value_namespace = name_space;
flttype.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dir")
{
dir = value;
dir.value_namespace = name_space;
dir.value_namespace_prefix = name_space_prefix;
}
}
void System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "id")
{
id.yfilter = yfilter;
}
if(value_path == "collectorId")
{
collectorid.yfilter = yfilter;
}
if(value_path == "DefPolicy")
{
defpolicy.yfilter = yfilter;
}
if(value_path == "ipv4Hit")
{
ipv4hit.yfilter = yfilter;
}
if(value_path == "ipv6Hit")
{
ipv6hit.yfilter = yfilter;
}
if(value_path == "ceHit")
{
cehit.yfilter = yfilter;
}
if(value_path == "ipv4Create")
{
ipv4create.yfilter = yfilter;
}
if(value_path == "ipv6Create")
{
ipv6create.yfilter = yfilter;
}
if(value_path == "ceCreate")
{
cecreate.yfilter = yfilter;
}
if(value_path == "exportCount")
{
exportcount.yfilter = yfilter;
}
if(value_path == "skipCount")
{
skipcount.yfilter = yfilter;
}
if(value_path == "fltType")
{
flttype.yfilter = yfilter;
}
if(value_path == "dir")
{
dir.yfilter = yfilter;
}
}
bool System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "rsprofAtt-items" || name == "rspolicyAtt-items" || name == "dbgStatistics-items" || name == "id" || name == "collectorId" || name == "DefPolicy" || name == "ipv4Hit" || name == "ipv6Hit" || name == "ceHit" || name == "ipv4Create" || name == "ipv6Create" || name == "ceCreate" || name == "exportCount" || name == "skipCount" || name == "fltType" || name == "dir")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RsprofAttItems::RsprofAttItems()
:
tdn{YType::str, "tDn"}
{
yang_name = "rsprofAtt-items"; yang_parent_name = "FwdInstTarget-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RsprofAttItems::~RsprofAttItems()
{
}
bool System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RsprofAttItems::has_data() const
{
if (is_presence_container) return true;
return tdn.is_set;
}
bool System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RsprofAttItems::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(tdn.yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RsprofAttItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "rsprofAtt-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RsprofAttItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (tdn.is_set || is_set(tdn.yfilter)) leaf_name_data.push_back(tdn.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RsprofAttItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RsprofAttItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RsprofAttItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "tDn")
{
tdn = value;
tdn.value_namespace = name_space;
tdn.value_namespace_prefix = name_space_prefix;
}
}
void System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RsprofAttItems::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "tDn")
{
tdn.yfilter = yfilter;
}
}
bool System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RsprofAttItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "tDn")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RspolicyAttItems::RspolicyAttItems()
:
tdn{YType::str, "tDn"}
{
yang_name = "rspolicyAtt-items"; yang_parent_name = "FwdInstTarget-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RspolicyAttItems::~RspolicyAttItems()
{
}
bool System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RspolicyAttItems::has_data() const
{
if (is_presence_container) return true;
return tdn.is_set;
}
bool System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RspolicyAttItems::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(tdn.yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RspolicyAttItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "rspolicyAtt-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RspolicyAttItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (tdn.is_set || is_set(tdn.yfilter)) leaf_name_data.push_back(tdn.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RspolicyAttItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RspolicyAttItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RspolicyAttItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "tDn")
{
tdn = value;
tdn.value_namespace = name_space;
tdn.value_namespace_prefix = name_space_prefix;
}
}
void System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RspolicyAttItems::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "tDn")
{
tdn.yfilter = yfilter;
}
}
bool System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::RspolicyAttItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "tDn")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::DbgStatisticsItems::DbgStatisticsItems()
:
flowcreatece{YType::uint64, "flowCreateCe"},
flowcreateipv4{YType::uint64, "flowCreateIPv4"},
flowcreateipv6{YType::uint64, "flowCreateIPv6"},
flowhitce{YType::uint64, "flowHitCe"},
flowhitipv4{YType::uint64, "flowHitIPv4"},
flowhitipv6{YType::uint64, "flowHitIPv6"},
packetsseen{YType::uint64, "packetsSeen"},
export_{YType::uint64, "export"},
skipcollect{YType::uint64, "skipCollect"},
lastcollectts{YType::uint64, "lastCollectTs"}
{
yang_name = "dbgStatistics-items"; yang_parent_name = "FwdInstTarget-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::DbgStatisticsItems::~DbgStatisticsItems()
{
}
bool System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::DbgStatisticsItems::has_data() const
{
if (is_presence_container) return true;
return flowcreatece.is_set
|| flowcreateipv4.is_set
|| flowcreateipv6.is_set
|| flowhitce.is_set
|| flowhitipv4.is_set
|| flowhitipv6.is_set
|| packetsseen.is_set
|| export_.is_set
|| skipcollect.is_set
|| lastcollectts.is_set;
}
bool System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::DbgStatisticsItems::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(flowcreatece.yfilter)
|| ydk::is_set(flowcreateipv4.yfilter)
|| ydk::is_set(flowcreateipv6.yfilter)
|| ydk::is_set(flowhitce.yfilter)
|| ydk::is_set(flowhitipv4.yfilter)
|| ydk::is_set(flowhitipv6.yfilter)
|| ydk::is_set(packetsseen.yfilter)
|| ydk::is_set(export_.yfilter)
|| ydk::is_set(skipcollect.yfilter)
|| ydk::is_set(lastcollectts.yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::DbgStatisticsItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "dbgStatistics-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::DbgStatisticsItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (flowcreatece.is_set || is_set(flowcreatece.yfilter)) leaf_name_data.push_back(flowcreatece.get_name_leafdata());
if (flowcreateipv4.is_set || is_set(flowcreateipv4.yfilter)) leaf_name_data.push_back(flowcreateipv4.get_name_leafdata());
if (flowcreateipv6.is_set || is_set(flowcreateipv6.yfilter)) leaf_name_data.push_back(flowcreateipv6.get_name_leafdata());
if (flowhitce.is_set || is_set(flowhitce.yfilter)) leaf_name_data.push_back(flowhitce.get_name_leafdata());
if (flowhitipv4.is_set || is_set(flowhitipv4.yfilter)) leaf_name_data.push_back(flowhitipv4.get_name_leafdata());
if (flowhitipv6.is_set || is_set(flowhitipv6.yfilter)) leaf_name_data.push_back(flowhitipv6.get_name_leafdata());
if (packetsseen.is_set || is_set(packetsseen.yfilter)) leaf_name_data.push_back(packetsseen.get_name_leafdata());
if (export_.is_set || is_set(export_.yfilter)) leaf_name_data.push_back(export_.get_name_leafdata());
if (skipcollect.is_set || is_set(skipcollect.yfilter)) leaf_name_data.push_back(skipcollect.get_name_leafdata());
if (lastcollectts.is_set || is_set(lastcollectts.yfilter)) leaf_name_data.push_back(lastcollectts.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::DbgStatisticsItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::DbgStatisticsItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::DbgStatisticsItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "flowCreateCe")
{
flowcreatece = value;
flowcreatece.value_namespace = name_space;
flowcreatece.value_namespace_prefix = name_space_prefix;
}
if(value_path == "flowCreateIPv4")
{
flowcreateipv4 = value;
flowcreateipv4.value_namespace = name_space;
flowcreateipv4.value_namespace_prefix = name_space_prefix;
}
if(value_path == "flowCreateIPv6")
{
flowcreateipv6 = value;
flowcreateipv6.value_namespace = name_space;
flowcreateipv6.value_namespace_prefix = name_space_prefix;
}
if(value_path == "flowHitCe")
{
flowhitce = value;
flowhitce.value_namespace = name_space;
flowhitce.value_namespace_prefix = name_space_prefix;
}
if(value_path == "flowHitIPv4")
{
flowhitipv4 = value;
flowhitipv4.value_namespace = name_space;
flowhitipv4.value_namespace_prefix = name_space_prefix;
}
if(value_path == "flowHitIPv6")
{
flowhitipv6 = value;
flowhitipv6.value_namespace = name_space;
flowhitipv6.value_namespace_prefix = name_space_prefix;
}
if(value_path == "packetsSeen")
{
packetsseen = value;
packetsseen.value_namespace = name_space;
packetsseen.value_namespace_prefix = name_space_prefix;
}
if(value_path == "export")
{
export_ = value;
export_.value_namespace = name_space;
export_.value_namespace_prefix = name_space_prefix;
}
if(value_path == "skipCollect")
{
skipcollect = value;
skipcollect.value_namespace = name_space;
skipcollect.value_namespace_prefix = name_space_prefix;
}
if(value_path == "lastCollectTs")
{
lastcollectts = value;
lastcollectts.value_namespace = name_space;
lastcollectts.value_namespace_prefix = name_space_prefix;
}
}
void System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::DbgStatisticsItems::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "flowCreateCe")
{
flowcreatece.yfilter = yfilter;
}
if(value_path == "flowCreateIPv4")
{
flowcreateipv4.yfilter = yfilter;
}
if(value_path == "flowCreateIPv6")
{
flowcreateipv6.yfilter = yfilter;
}
if(value_path == "flowHitCe")
{
flowhitce.yfilter = yfilter;
}
if(value_path == "flowHitIPv4")
{
flowhitipv4.yfilter = yfilter;
}
if(value_path == "flowHitIPv6")
{
flowhitipv6.yfilter = yfilter;
}
if(value_path == "packetsSeen")
{
packetsseen.yfilter = yfilter;
}
if(value_path == "export")
{
export_.yfilter = yfilter;
}
if(value_path == "skipCollect")
{
skipcollect.yfilter = yfilter;
}
if(value_path == "lastCollectTs")
{
lastcollectts.yfilter = yfilter;
}
}
bool System::AnalyticsItems::InstItems::InstList::FwdinstItems::FwdInstTargetList::DbgStatisticsItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "flowCreateCe" || name == "flowCreateIPv4" || name == "flowCreateIPv6" || name == "flowHitCe" || name == "flowHitIPv4" || name == "flowHitIPv6" || name == "packetsSeen" || name == "export" || name == "skipCollect" || name == "lastCollectTs")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyItems()
:
policy_list(this, {"name"})
{
yang_name = "policy-items"; yang_parent_name = "Inst-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::PolicyItems::~PolicyItems()
{
}
bool System::AnalyticsItems::InstItems::InstList::PolicyItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<policy_list.len(); index++)
{
if(policy_list[index]->has_data())
return true;
}
return false;
}
bool System::AnalyticsItems::InstItems::InstList::PolicyItems::has_operation() const
{
for (std::size_t index=0; index<policy_list.len(); index++)
{
if(policy_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::PolicyItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "policy-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::PolicyItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::PolicyItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "Policy-list")
{
auto ent_ = std::make_shared<System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList>();
ent_->parent = this;
policy_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::PolicyItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : policy_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AnalyticsItems::InstItems::InstList::PolicyItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AnalyticsItems::InstItems::InstList::PolicyItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AnalyticsItems::InstItems::InstList::PolicyItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "Policy-list")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::PolicyList()
:
name{YType::str, "name"},
descr{YType::str, "descr"}
,
acl_items(std::make_shared<System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::AclItems>())
{
acl_items->parent = this;
yang_name = "Policy-list"; yang_parent_name = "policy-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::~PolicyList()
{
}
bool System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| descr.is_set
|| (acl_items != nullptr && acl_items->has_data());
}
bool System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(descr.yfilter)
|| (acl_items != nullptr && acl_items->has_operation());
}
std::string System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "Policy-list";
ADD_KEY_TOKEN(name, "name");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "acl-items")
{
if(acl_items == nullptr)
{
acl_items = std::make_shared<System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::AclItems>();
}
return acl_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(acl_items != nullptr)
{
_children["acl-items"] = acl_items;
}
return _children;
}
void System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
}
void System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
}
bool System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "acl-items" || name == "name" || name == "descr")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::AclItems::AclItems()
:
matchacl_list(this, {"name"})
{
yang_name = "acl-items"; yang_parent_name = "Policy-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::AclItems::~AclItems()
{
}
bool System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::AclItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<matchacl_list.len(); index++)
{
if(matchacl_list[index]->has_data())
return true;
}
return false;
}
bool System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::AclItems::has_operation() const
{
for (std::size_t index=0; index<matchacl_list.len(); index++)
{
if(matchacl_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::AclItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "acl-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::AclItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::AclItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "MatchAcl-list")
{
auto ent_ = std::make_shared<System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::AclItems::MatchAclList>();
ent_->parent = this;
matchacl_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::AclItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : matchacl_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::AclItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::AclItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::AclItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "MatchAcl-list")
return true;
return false;
}
System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::AclItems::MatchAclList::MatchAclList()
:
name{YType::str, "name"},
aclname{YType::str, "aclName"},
flttype{YType::enumeration, "fltType"},
descr{YType::str, "descr"}
{
yang_name = "MatchAcl-list"; yang_parent_name = "acl-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::AclItems::MatchAclList::~MatchAclList()
{
}
bool System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::AclItems::MatchAclList::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| aclname.is_set
|| flttype.is_set
|| descr.is_set;
}
bool System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::AclItems::MatchAclList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(aclname.yfilter)
|| ydk::is_set(flttype.yfilter)
|| ydk::is_set(descr.yfilter);
}
std::string System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::AclItems::MatchAclList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "MatchAcl-list";
ADD_KEY_TOKEN(name, "name");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::AclItems::MatchAclList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (aclname.is_set || is_set(aclname.yfilter)) leaf_name_data.push_back(aclname.get_name_leafdata());
if (flttype.is_set || is_set(flttype.yfilter)) leaf_name_data.push_back(flttype.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::AclItems::MatchAclList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::AclItems::MatchAclList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::AclItems::MatchAclList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "aclName")
{
aclname = value;
aclname.value_namespace = name_space;
aclname.value_namespace_prefix = name_space_prefix;
}
if(value_path == "fltType")
{
flttype = value;
flttype.value_namespace = name_space;
flttype.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
}
void System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::AclItems::MatchAclList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "aclName")
{
aclname.yfilter = yfilter;
}
if(value_path == "fltType")
{
flttype.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
}
bool System::AnalyticsItems::InstItems::InstList::PolicyItems::PolicyList::AclItems::MatchAclList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "name" || name == "aclName" || name == "fltType" || name == "descr")
return true;
return false;
}
System::HwtelemetryItems::HwtelemetryItems()
:
fte_items(std::make_shared<System::HwtelemetryItems::FteItems>())
, inbandtelemetry_items(std::make_shared<System::HwtelemetryItems::InbandtelemetryItems>())
, netflow_items(std::make_shared<System::HwtelemetryItems::NetflowItems>())
, sflow_items(std::make_shared<System::HwtelemetryItems::SflowItems>())
{
fte_items->parent = this;
inbandtelemetry_items->parent = this;
netflow_items->parent = this;
sflow_items->parent = this;
yang_name = "hwtelemetry-items"; yang_parent_name = "System"; is_top_level_class = false; has_list_ancestor = false;
}
System::HwtelemetryItems::~HwtelemetryItems()
{
}
bool System::HwtelemetryItems::has_data() const
{
if (is_presence_container) return true;
return (fte_items != nullptr && fte_items->has_data())
|| (inbandtelemetry_items != nullptr && inbandtelemetry_items->has_data())
|| (netflow_items != nullptr && netflow_items->has_data())
|| (sflow_items != nullptr && sflow_items->has_data());
}
bool System::HwtelemetryItems::has_operation() const
{
return is_set(yfilter)
|| (fte_items != nullptr && fte_items->has_operation())
|| (inbandtelemetry_items != nullptr && inbandtelemetry_items->has_operation())
|| (netflow_items != nullptr && netflow_items->has_operation())
|| (sflow_items != nullptr && sflow_items->has_operation());
}
std::string System::HwtelemetryItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/" << get_segment_path();
return path_buffer.str();
}
std::string System::HwtelemetryItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "hwtelemetry-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "fte-items")
{
if(fte_items == nullptr)
{
fte_items = std::make_shared<System::HwtelemetryItems::FteItems>();
}
return fte_items;
}
if(child_yang_name == "inbandtelemetry-items")
{
if(inbandtelemetry_items == nullptr)
{
inbandtelemetry_items = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems>();
}
return inbandtelemetry_items;
}
if(child_yang_name == "netflow-items")
{
if(netflow_items == nullptr)
{
netflow_items = std::make_shared<System::HwtelemetryItems::NetflowItems>();
}
return netflow_items;
}
if(child_yang_name == "sflow-items")
{
if(sflow_items == nullptr)
{
sflow_items = std::make_shared<System::HwtelemetryItems::SflowItems>();
}
return sflow_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(fte_items != nullptr)
{
_children["fte-items"] = fte_items;
}
if(inbandtelemetry_items != nullptr)
{
_children["inbandtelemetry-items"] = inbandtelemetry_items;
}
if(netflow_items != nullptr)
{
_children["netflow-items"] = netflow_items;
}
if(sflow_items != nullptr)
{
_children["sflow-items"] = sflow_items;
}
return _children;
}
void System::HwtelemetryItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::HwtelemetryItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::HwtelemetryItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "fte-items" || name == "inbandtelemetry-items" || name == "netflow-items" || name == "sflow-items")
return true;
return false;
}
System::HwtelemetryItems::FteItems::FteItems()
:
enable{YType::boolean, "enable"}
{
yang_name = "fte-items"; yang_parent_name = "hwtelemetry-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::HwtelemetryItems::FteItems::~FteItems()
{
}
bool System::HwtelemetryItems::FteItems::has_data() const
{
if (is_presence_container) return true;
return enable.is_set;
}
bool System::HwtelemetryItems::FteItems::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(enable.yfilter);
}
std::string System::HwtelemetryItems::FteItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/hwtelemetry-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::HwtelemetryItems::FteItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "fte-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::FteItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (enable.is_set || is_set(enable.yfilter)) leaf_name_data.push_back(enable.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::FteItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::FteItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::HwtelemetryItems::FteItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "enable")
{
enable = value;
enable.value_namespace = name_space;
enable.value_namespace_prefix = name_space_prefix;
}
}
void System::HwtelemetryItems::FteItems::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "enable")
{
enable.yfilter = yfilter;
}
}
bool System::HwtelemetryItems::FteItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "enable")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InbandtelemetryItems()
:
inst_items(std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems>())
{
inst_items->parent = this;
yang_name = "inbandtelemetry-items"; yang_parent_name = "hwtelemetry-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::HwtelemetryItems::InbandtelemetryItems::~InbandtelemetryItems()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::has_data() const
{
if (is_presence_container) return true;
return (inst_items != nullptr && inst_items->has_data());
}
bool System::HwtelemetryItems::InbandtelemetryItems::has_operation() const
{
return is_set(yfilter)
|| (inst_items != nullptr && inst_items->has_operation());
}
std::string System::HwtelemetryItems::InbandtelemetryItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/hwtelemetry-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::HwtelemetryItems::InbandtelemetryItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "inbandtelemetry-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "inst-items")
{
if(inst_items == nullptr)
{
inst_items = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems>();
}
return inst_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(inst_items != nullptr)
{
_children["inst-items"] = inst_items;
}
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::HwtelemetryItems::InbandtelemetryItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "inst-items")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstItems()
:
inst_list(this, {"mode"})
{
yang_name = "inst-items"; yang_parent_name = "inbandtelemetry-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::~InstItems()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<inst_list.len(); index++)
{
if(inst_list[index]->has_data())
return true;
}
return false;
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::has_operation() const
{
for (std::size_t index=0; index<inst_list.len(); index++)
{
if(inst_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/hwtelemetry-items/inbandtelemetry-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "inst-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "Inst-list")
{
auto ent_ = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList>();
ent_->parent = this;
inst_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : inst_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "Inst-list")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::InstList()
:
mode{YType::enumeration, "mode"},
profile{YType::enumeration, "profile"},
name{YType::str, "name"},
adminst{YType::enumeration, "adminSt"},
ctrl{YType::str, "ctrl"},
opererr{YType::str, "operErr"}
,
watchlist_items(std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems>())
, droplist_items(std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems>())
, recordp_items(std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::RecordpItems>())
, collector_items(std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::CollectorItems>())
, flowprof_items(std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FlowprofItems>())
, queueprof_items(std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::QueueprofItems>())
, monitor_items(std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems>())
, fwdinst_items(std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FwdinstItems>())
{
watchlist_items->parent = this;
droplist_items->parent = this;
recordp_items->parent = this;
collector_items->parent = this;
flowprof_items->parent = this;
queueprof_items->parent = this;
monitor_items->parent = this;
fwdinst_items->parent = this;
yang_name = "Inst-list"; yang_parent_name = "inst-items"; is_top_level_class = false; has_list_ancestor = false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::~InstList()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::has_data() const
{
if (is_presence_container) return true;
return mode.is_set
|| profile.is_set
|| name.is_set
|| adminst.is_set
|| ctrl.is_set
|| opererr.is_set
|| (watchlist_items != nullptr && watchlist_items->has_data())
|| (droplist_items != nullptr && droplist_items->has_data())
|| (recordp_items != nullptr && recordp_items->has_data())
|| (collector_items != nullptr && collector_items->has_data())
|| (flowprof_items != nullptr && flowprof_items->has_data())
|| (queueprof_items != nullptr && queueprof_items->has_data())
|| (monitor_items != nullptr && monitor_items->has_data())
|| (fwdinst_items != nullptr && fwdinst_items->has_data());
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(mode.yfilter)
|| ydk::is_set(profile.yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(adminst.yfilter)
|| ydk::is_set(ctrl.yfilter)
|| ydk::is_set(opererr.yfilter)
|| (watchlist_items != nullptr && watchlist_items->has_operation())
|| (droplist_items != nullptr && droplist_items->has_operation())
|| (recordp_items != nullptr && recordp_items->has_operation())
|| (collector_items != nullptr && collector_items->has_operation())
|| (flowprof_items != nullptr && flowprof_items->has_operation())
|| (queueprof_items != nullptr && queueprof_items->has_operation())
|| (monitor_items != nullptr && monitor_items->has_operation())
|| (fwdinst_items != nullptr && fwdinst_items->has_operation());
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::get_absolute_path() const
{
std::ostringstream path_buffer;
path_buffer << "Cisco-NX-OS-device:System/hwtelemetry-items/inbandtelemetry-items/inst-items/" << get_segment_path();
return path_buffer.str();
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "Inst-list";
ADD_KEY_TOKEN(mode, "mode");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (mode.is_set || is_set(mode.yfilter)) leaf_name_data.push_back(mode.get_name_leafdata());
if (profile.is_set || is_set(profile.yfilter)) leaf_name_data.push_back(profile.get_name_leafdata());
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (adminst.is_set || is_set(adminst.yfilter)) leaf_name_data.push_back(adminst.get_name_leafdata());
if (ctrl.is_set || is_set(ctrl.yfilter)) leaf_name_data.push_back(ctrl.get_name_leafdata());
if (opererr.is_set || is_set(opererr.yfilter)) leaf_name_data.push_back(opererr.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "watchlist-items")
{
if(watchlist_items == nullptr)
{
watchlist_items = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems>();
}
return watchlist_items;
}
if(child_yang_name == "droplist-items")
{
if(droplist_items == nullptr)
{
droplist_items = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems>();
}
return droplist_items;
}
if(child_yang_name == "recordp-items")
{
if(recordp_items == nullptr)
{
recordp_items = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::RecordpItems>();
}
return recordp_items;
}
if(child_yang_name == "collector-items")
{
if(collector_items == nullptr)
{
collector_items = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::CollectorItems>();
}
return collector_items;
}
if(child_yang_name == "flowprof-items")
{
if(flowprof_items == nullptr)
{
flowprof_items = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FlowprofItems>();
}
return flowprof_items;
}
if(child_yang_name == "queueprof-items")
{
if(queueprof_items == nullptr)
{
queueprof_items = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::QueueprofItems>();
}
return queueprof_items;
}
if(child_yang_name == "monitor-items")
{
if(monitor_items == nullptr)
{
monitor_items = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems>();
}
return monitor_items;
}
if(child_yang_name == "fwdinst-items")
{
if(fwdinst_items == nullptr)
{
fwdinst_items = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FwdinstItems>();
}
return fwdinst_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(watchlist_items != nullptr)
{
_children["watchlist-items"] = watchlist_items;
}
if(droplist_items != nullptr)
{
_children["droplist-items"] = droplist_items;
}
if(recordp_items != nullptr)
{
_children["recordp-items"] = recordp_items;
}
if(collector_items != nullptr)
{
_children["collector-items"] = collector_items;
}
if(flowprof_items != nullptr)
{
_children["flowprof-items"] = flowprof_items;
}
if(queueprof_items != nullptr)
{
_children["queueprof-items"] = queueprof_items;
}
if(monitor_items != nullptr)
{
_children["monitor-items"] = monitor_items;
}
if(fwdinst_items != nullptr)
{
_children["fwdinst-items"] = fwdinst_items;
}
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "mode")
{
mode = value;
mode.value_namespace = name_space;
mode.value_namespace_prefix = name_space_prefix;
}
if(value_path == "profile")
{
profile = value;
profile.value_namespace = name_space;
profile.value_namespace_prefix = name_space_prefix;
}
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "adminSt")
{
adminst = value;
adminst.value_namespace = name_space;
adminst.value_namespace_prefix = name_space_prefix;
}
if(value_path == "ctrl")
{
ctrl = value;
ctrl.value_namespace = name_space;
ctrl.value_namespace_prefix = name_space_prefix;
}
if(value_path == "operErr")
{
opererr = value;
opererr.value_namespace = name_space;
opererr.value_namespace_prefix = name_space_prefix;
}
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "mode")
{
mode.yfilter = yfilter;
}
if(value_path == "profile")
{
profile.yfilter = yfilter;
}
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "adminSt")
{
adminst.yfilter = yfilter;
}
if(value_path == "ctrl")
{
ctrl.yfilter = yfilter;
}
if(value_path == "operErr")
{
opererr.yfilter = yfilter;
}
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "watchlist-items" || name == "droplist-items" || name == "recordp-items" || name == "collector-items" || name == "flowprof-items" || name == "queueprof-items" || name == "monitor-items" || name == "fwdinst-items" || name == "mode" || name == "profile" || name == "name" || name == "adminSt" || name == "ctrl" || name == "operErr")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistItems()
:
watchlistacl_list(this, {"name"})
{
yang_name = "watchlist-items"; yang_parent_name = "Inst-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::~WatchlistItems()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<watchlistacl_list.len(); index++)
{
if(watchlistacl_list[index]->has_data())
return true;
}
return false;
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::has_operation() const
{
for (std::size_t index=0; index<watchlistacl_list.len(); index++)
{
if(watchlistacl_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "watchlist-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "WatchlistAcl-list")
{
auto ent_ = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList>();
ent_->parent = this;
watchlistacl_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : watchlistacl_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "WatchlistAcl-list")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::WatchlistAclList()
:
name{YType::str, "name"},
descr{YType::str, "descr"},
peracestatistics{YType::uint8, "perACEStatistics"},
configstatus{YType::uint32, "configStatus"}
,
ace_items(std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::AceItems>())
{
ace_items->parent = this;
yang_name = "WatchlistAcl-list"; yang_parent_name = "watchlist-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::~WatchlistAclList()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| descr.is_set
|| peracestatistics.is_set
|| configstatus.is_set
|| (ace_items != nullptr && ace_items->has_data());
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(descr.yfilter)
|| ydk::is_set(peracestatistics.yfilter)
|| ydk::is_set(configstatus.yfilter)
|| (ace_items != nullptr && ace_items->has_operation());
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "WatchlistAcl-list";
ADD_KEY_TOKEN(name, "name");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
if (peracestatistics.is_set || is_set(peracestatistics.yfilter)) leaf_name_data.push_back(peracestatistics.get_name_leafdata());
if (configstatus.is_set || is_set(configstatus.yfilter)) leaf_name_data.push_back(configstatus.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "ace-items")
{
if(ace_items == nullptr)
{
ace_items = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::AceItems>();
}
return ace_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(ace_items != nullptr)
{
_children["ace-items"] = ace_items;
}
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
if(value_path == "perACEStatistics")
{
peracestatistics = value;
peracestatistics.value_namespace = name_space;
peracestatistics.value_namespace_prefix = name_space_prefix;
}
if(value_path == "configStatus")
{
configstatus = value;
configstatus.value_namespace = name_space;
configstatus.value_namespace_prefix = name_space_prefix;
}
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
if(value_path == "perACEStatistics")
{
peracestatistics.yfilter = yfilter;
}
if(value_path == "configStatus")
{
configstatus.yfilter = yfilter;
}
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "ace-items" || name == "name" || name == "descr" || name == "perACEStatistics" || name == "configStatus")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::AceItems::AceItems()
:
watchlistace_list(this, {"seqnum"})
{
yang_name = "ace-items"; yang_parent_name = "WatchlistAcl-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::AceItems::~AceItems()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::AceItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<watchlistace_list.len(); index++)
{
if(watchlistace_list[index]->has_data())
return true;
}
return false;
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::AceItems::has_operation() const
{
for (std::size_t index=0; index<watchlistace_list.len(); index++)
{
if(watchlistace_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::AceItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "ace-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::AceItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::AceItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "WatchlistAce-list")
{
auto ent_ = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::AceItems::WatchlistAceList>();
ent_->parent = this;
watchlistace_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::AceItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : watchlistace_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::AceItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::AceItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::AceItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "WatchlistAce-list")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::AceItems::WatchlistAceList::WatchlistAceList()
:
seqnum{YType::uint32, "seqNum"},
descr{YType::str, "descr"},
remark{YType::str, "remark"},
action{YType::enumeration, "action"},
srcportop{YType::uint8, "srcPortOp"},
srcport1{YType::uint16, "srcPort1"},
srcport2{YType::uint16, "srcPort2"},
srcportmask{YType::uint16, "srcPortMask"},
dstportop{YType::uint8, "dstPortOp"},
dstport1{YType::uint16, "dstPort1"},
dstport2{YType::uint16, "dstPort2"},
dstportmask{YType::uint16, "dstPortMask"},
logging{YType::boolean, "logging"},
dscp{YType::uint8, "dscp"},
pktlenop{YType::uint8, "pktLenOp"},
pktlen1{YType::uint16, "pktLen1"},
pktlen2{YType::uint16, "pktLen2"},
urg{YType::boolean, "urg"},
ack{YType::boolean, "ack"},
psh{YType::boolean, "psh"},
rst{YType::boolean, "rst"},
syn{YType::boolean, "syn"},
fin{YType::boolean, "fin"},
est{YType::boolean, "est"},
rev{YType::boolean, "rev"},
tcpflagsmask{YType::uint8, "tcpFlagsMask"},
packets{YType::uint64, "packets"},
fragment{YType::boolean, "fragment"},
capturesession{YType::uint16, "captureSession"},
httpoption{YType::enumeration, "httpOption"},
vni{YType::uint32, "vni"},
vlan{YType::uint32, "vlan"},
tcpoptionlength{YType::uint32, "tcpOptionLength"},
timerange{YType::str, "timeRange"},
srcaddrgroup{YType::str, "srcAddrGroup"},
dstaddrgroup{YType::str, "dstAddrGroup"},
srcportgroup{YType::str, "srcPortGroup"},
dstportgroup{YType::str, "dstPortGroup"},
redirect{YType::str, "redirect"},
flttype{YType::enumeration, "fltType"},
protocol{YType::uint8, "protocol"},
protocolmask{YType::uint8, "protocolMask"},
srcprefix{YType::str, "srcPrefix"},
srcprefixmask{YType::str, "srcPrefixMask"},
srcprefixlength{YType::uint8, "srcPrefixLength"},
dstprefix{YType::str, "dstPrefix"},
dstprefixmask{YType::str, "dstPrefixMask"},
dstprefixlength{YType::uint8, "dstPrefixLength"}
{
yang_name = "WatchlistAce-list"; yang_parent_name = "ace-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::AceItems::WatchlistAceList::~WatchlistAceList()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::AceItems::WatchlistAceList::has_data() const
{
if (is_presence_container) return true;
return seqnum.is_set
|| descr.is_set
|| remark.is_set
|| action.is_set
|| srcportop.is_set
|| srcport1.is_set
|| srcport2.is_set
|| srcportmask.is_set
|| dstportop.is_set
|| dstport1.is_set
|| dstport2.is_set
|| dstportmask.is_set
|| logging.is_set
|| dscp.is_set
|| pktlenop.is_set
|| pktlen1.is_set
|| pktlen2.is_set
|| urg.is_set
|| ack.is_set
|| psh.is_set
|| rst.is_set
|| syn.is_set
|| fin.is_set
|| est.is_set
|| rev.is_set
|| tcpflagsmask.is_set
|| packets.is_set
|| fragment.is_set
|| capturesession.is_set
|| httpoption.is_set
|| vni.is_set
|| vlan.is_set
|| tcpoptionlength.is_set
|| timerange.is_set
|| srcaddrgroup.is_set
|| dstaddrgroup.is_set
|| srcportgroup.is_set
|| dstportgroup.is_set
|| redirect.is_set
|| flttype.is_set
|| protocol.is_set
|| protocolmask.is_set
|| srcprefix.is_set
|| srcprefixmask.is_set
|| srcprefixlength.is_set
|| dstprefix.is_set
|| dstprefixmask.is_set
|| dstprefixlength.is_set;
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::AceItems::WatchlistAceList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(seqnum.yfilter)
|| ydk::is_set(descr.yfilter)
|| ydk::is_set(remark.yfilter)
|| ydk::is_set(action.yfilter)
|| ydk::is_set(srcportop.yfilter)
|| ydk::is_set(srcport1.yfilter)
|| ydk::is_set(srcport2.yfilter)
|| ydk::is_set(srcportmask.yfilter)
|| ydk::is_set(dstportop.yfilter)
|| ydk::is_set(dstport1.yfilter)
|| ydk::is_set(dstport2.yfilter)
|| ydk::is_set(dstportmask.yfilter)
|| ydk::is_set(logging.yfilter)
|| ydk::is_set(dscp.yfilter)
|| ydk::is_set(pktlenop.yfilter)
|| ydk::is_set(pktlen1.yfilter)
|| ydk::is_set(pktlen2.yfilter)
|| ydk::is_set(urg.yfilter)
|| ydk::is_set(ack.yfilter)
|| ydk::is_set(psh.yfilter)
|| ydk::is_set(rst.yfilter)
|| ydk::is_set(syn.yfilter)
|| ydk::is_set(fin.yfilter)
|| ydk::is_set(est.yfilter)
|| ydk::is_set(rev.yfilter)
|| ydk::is_set(tcpflagsmask.yfilter)
|| ydk::is_set(packets.yfilter)
|| ydk::is_set(fragment.yfilter)
|| ydk::is_set(capturesession.yfilter)
|| ydk::is_set(httpoption.yfilter)
|| ydk::is_set(vni.yfilter)
|| ydk::is_set(vlan.yfilter)
|| ydk::is_set(tcpoptionlength.yfilter)
|| ydk::is_set(timerange.yfilter)
|| ydk::is_set(srcaddrgroup.yfilter)
|| ydk::is_set(dstaddrgroup.yfilter)
|| ydk::is_set(srcportgroup.yfilter)
|| ydk::is_set(dstportgroup.yfilter)
|| ydk::is_set(redirect.yfilter)
|| ydk::is_set(flttype.yfilter)
|| ydk::is_set(protocol.yfilter)
|| ydk::is_set(protocolmask.yfilter)
|| ydk::is_set(srcprefix.yfilter)
|| ydk::is_set(srcprefixmask.yfilter)
|| ydk::is_set(srcprefixlength.yfilter)
|| ydk::is_set(dstprefix.yfilter)
|| ydk::is_set(dstprefixmask.yfilter)
|| ydk::is_set(dstprefixlength.yfilter);
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::AceItems::WatchlistAceList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "WatchlistAce-list";
ADD_KEY_TOKEN(seqnum, "seqNum");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::AceItems::WatchlistAceList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (seqnum.is_set || is_set(seqnum.yfilter)) leaf_name_data.push_back(seqnum.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
if (remark.is_set || is_set(remark.yfilter)) leaf_name_data.push_back(remark.get_name_leafdata());
if (action.is_set || is_set(action.yfilter)) leaf_name_data.push_back(action.get_name_leafdata());
if (srcportop.is_set || is_set(srcportop.yfilter)) leaf_name_data.push_back(srcportop.get_name_leafdata());
if (srcport1.is_set || is_set(srcport1.yfilter)) leaf_name_data.push_back(srcport1.get_name_leafdata());
if (srcport2.is_set || is_set(srcport2.yfilter)) leaf_name_data.push_back(srcport2.get_name_leafdata());
if (srcportmask.is_set || is_set(srcportmask.yfilter)) leaf_name_data.push_back(srcportmask.get_name_leafdata());
if (dstportop.is_set || is_set(dstportop.yfilter)) leaf_name_data.push_back(dstportop.get_name_leafdata());
if (dstport1.is_set || is_set(dstport1.yfilter)) leaf_name_data.push_back(dstport1.get_name_leafdata());
if (dstport2.is_set || is_set(dstport2.yfilter)) leaf_name_data.push_back(dstport2.get_name_leafdata());
if (dstportmask.is_set || is_set(dstportmask.yfilter)) leaf_name_data.push_back(dstportmask.get_name_leafdata());
if (logging.is_set || is_set(logging.yfilter)) leaf_name_data.push_back(logging.get_name_leafdata());
if (dscp.is_set || is_set(dscp.yfilter)) leaf_name_data.push_back(dscp.get_name_leafdata());
if (pktlenop.is_set || is_set(pktlenop.yfilter)) leaf_name_data.push_back(pktlenop.get_name_leafdata());
if (pktlen1.is_set || is_set(pktlen1.yfilter)) leaf_name_data.push_back(pktlen1.get_name_leafdata());
if (pktlen2.is_set || is_set(pktlen2.yfilter)) leaf_name_data.push_back(pktlen2.get_name_leafdata());
if (urg.is_set || is_set(urg.yfilter)) leaf_name_data.push_back(urg.get_name_leafdata());
if (ack.is_set || is_set(ack.yfilter)) leaf_name_data.push_back(ack.get_name_leafdata());
if (psh.is_set || is_set(psh.yfilter)) leaf_name_data.push_back(psh.get_name_leafdata());
if (rst.is_set || is_set(rst.yfilter)) leaf_name_data.push_back(rst.get_name_leafdata());
if (syn.is_set || is_set(syn.yfilter)) leaf_name_data.push_back(syn.get_name_leafdata());
if (fin.is_set || is_set(fin.yfilter)) leaf_name_data.push_back(fin.get_name_leafdata());
if (est.is_set || is_set(est.yfilter)) leaf_name_data.push_back(est.get_name_leafdata());
if (rev.is_set || is_set(rev.yfilter)) leaf_name_data.push_back(rev.get_name_leafdata());
if (tcpflagsmask.is_set || is_set(tcpflagsmask.yfilter)) leaf_name_data.push_back(tcpflagsmask.get_name_leafdata());
if (packets.is_set || is_set(packets.yfilter)) leaf_name_data.push_back(packets.get_name_leafdata());
if (fragment.is_set || is_set(fragment.yfilter)) leaf_name_data.push_back(fragment.get_name_leafdata());
if (capturesession.is_set || is_set(capturesession.yfilter)) leaf_name_data.push_back(capturesession.get_name_leafdata());
if (httpoption.is_set || is_set(httpoption.yfilter)) leaf_name_data.push_back(httpoption.get_name_leafdata());
if (vni.is_set || is_set(vni.yfilter)) leaf_name_data.push_back(vni.get_name_leafdata());
if (vlan.is_set || is_set(vlan.yfilter)) leaf_name_data.push_back(vlan.get_name_leafdata());
if (tcpoptionlength.is_set || is_set(tcpoptionlength.yfilter)) leaf_name_data.push_back(tcpoptionlength.get_name_leafdata());
if (timerange.is_set || is_set(timerange.yfilter)) leaf_name_data.push_back(timerange.get_name_leafdata());
if (srcaddrgroup.is_set || is_set(srcaddrgroup.yfilter)) leaf_name_data.push_back(srcaddrgroup.get_name_leafdata());
if (dstaddrgroup.is_set || is_set(dstaddrgroup.yfilter)) leaf_name_data.push_back(dstaddrgroup.get_name_leafdata());
if (srcportgroup.is_set || is_set(srcportgroup.yfilter)) leaf_name_data.push_back(srcportgroup.get_name_leafdata());
if (dstportgroup.is_set || is_set(dstportgroup.yfilter)) leaf_name_data.push_back(dstportgroup.get_name_leafdata());
if (redirect.is_set || is_set(redirect.yfilter)) leaf_name_data.push_back(redirect.get_name_leafdata());
if (flttype.is_set || is_set(flttype.yfilter)) leaf_name_data.push_back(flttype.get_name_leafdata());
if (protocol.is_set || is_set(protocol.yfilter)) leaf_name_data.push_back(protocol.get_name_leafdata());
if (protocolmask.is_set || is_set(protocolmask.yfilter)) leaf_name_data.push_back(protocolmask.get_name_leafdata());
if (srcprefix.is_set || is_set(srcprefix.yfilter)) leaf_name_data.push_back(srcprefix.get_name_leafdata());
if (srcprefixmask.is_set || is_set(srcprefixmask.yfilter)) leaf_name_data.push_back(srcprefixmask.get_name_leafdata());
if (srcprefixlength.is_set || is_set(srcprefixlength.yfilter)) leaf_name_data.push_back(srcprefixlength.get_name_leafdata());
if (dstprefix.is_set || is_set(dstprefix.yfilter)) leaf_name_data.push_back(dstprefix.get_name_leafdata());
if (dstprefixmask.is_set || is_set(dstprefixmask.yfilter)) leaf_name_data.push_back(dstprefixmask.get_name_leafdata());
if (dstprefixlength.is_set || is_set(dstprefixlength.yfilter)) leaf_name_data.push_back(dstprefixlength.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::AceItems::WatchlistAceList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::AceItems::WatchlistAceList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::AceItems::WatchlistAceList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "seqNum")
{
seqnum = value;
seqnum.value_namespace = name_space;
seqnum.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
if(value_path == "remark")
{
remark = value;
remark.value_namespace = name_space;
remark.value_namespace_prefix = name_space_prefix;
}
if(value_path == "action")
{
action = value;
action.value_namespace = name_space;
action.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPortOp")
{
srcportop = value;
srcportop.value_namespace = name_space;
srcportop.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPort1")
{
srcport1 = value;
srcport1.value_namespace = name_space;
srcport1.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPort2")
{
srcport2 = value;
srcport2.value_namespace = name_space;
srcport2.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPortMask")
{
srcportmask = value;
srcportmask.value_namespace = name_space;
srcportmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPortOp")
{
dstportop = value;
dstportop.value_namespace = name_space;
dstportop.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPort1")
{
dstport1 = value;
dstport1.value_namespace = name_space;
dstport1.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPort2")
{
dstport2 = value;
dstport2.value_namespace = name_space;
dstport2.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPortMask")
{
dstportmask = value;
dstportmask.value_namespace = name_space;
dstportmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "logging")
{
logging = value;
logging.value_namespace = name_space;
logging.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dscp")
{
dscp = value;
dscp.value_namespace = name_space;
dscp.value_namespace_prefix = name_space_prefix;
}
if(value_path == "pktLenOp")
{
pktlenop = value;
pktlenop.value_namespace = name_space;
pktlenop.value_namespace_prefix = name_space_prefix;
}
if(value_path == "pktLen1")
{
pktlen1 = value;
pktlen1.value_namespace = name_space;
pktlen1.value_namespace_prefix = name_space_prefix;
}
if(value_path == "pktLen2")
{
pktlen2 = value;
pktlen2.value_namespace = name_space;
pktlen2.value_namespace_prefix = name_space_prefix;
}
if(value_path == "urg")
{
urg = value;
urg.value_namespace = name_space;
urg.value_namespace_prefix = name_space_prefix;
}
if(value_path == "ack")
{
ack = value;
ack.value_namespace = name_space;
ack.value_namespace_prefix = name_space_prefix;
}
if(value_path == "psh")
{
psh = value;
psh.value_namespace = name_space;
psh.value_namespace_prefix = name_space_prefix;
}
if(value_path == "rst")
{
rst = value;
rst.value_namespace = name_space;
rst.value_namespace_prefix = name_space_prefix;
}
if(value_path == "syn")
{
syn = value;
syn.value_namespace = name_space;
syn.value_namespace_prefix = name_space_prefix;
}
if(value_path == "fin")
{
fin = value;
fin.value_namespace = name_space;
fin.value_namespace_prefix = name_space_prefix;
}
if(value_path == "est")
{
est = value;
est.value_namespace = name_space;
est.value_namespace_prefix = name_space_prefix;
}
if(value_path == "rev")
{
rev = value;
rev.value_namespace = name_space;
rev.value_namespace_prefix = name_space_prefix;
}
if(value_path == "tcpFlagsMask")
{
tcpflagsmask = value;
tcpflagsmask.value_namespace = name_space;
tcpflagsmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "packets")
{
packets = value;
packets.value_namespace = name_space;
packets.value_namespace_prefix = name_space_prefix;
}
if(value_path == "fragment")
{
fragment = value;
fragment.value_namespace = name_space;
fragment.value_namespace_prefix = name_space_prefix;
}
if(value_path == "captureSession")
{
capturesession = value;
capturesession.value_namespace = name_space;
capturesession.value_namespace_prefix = name_space_prefix;
}
if(value_path == "httpOption")
{
httpoption = value;
httpoption.value_namespace = name_space;
httpoption.value_namespace_prefix = name_space_prefix;
}
if(value_path == "vni")
{
vni = value;
vni.value_namespace = name_space;
vni.value_namespace_prefix = name_space_prefix;
}
if(value_path == "vlan")
{
vlan = value;
vlan.value_namespace = name_space;
vlan.value_namespace_prefix = name_space_prefix;
}
if(value_path == "tcpOptionLength")
{
tcpoptionlength = value;
tcpoptionlength.value_namespace = name_space;
tcpoptionlength.value_namespace_prefix = name_space_prefix;
}
if(value_path == "timeRange")
{
timerange = value;
timerange.value_namespace = name_space;
timerange.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcAddrGroup")
{
srcaddrgroup = value;
srcaddrgroup.value_namespace = name_space;
srcaddrgroup.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstAddrGroup")
{
dstaddrgroup = value;
dstaddrgroup.value_namespace = name_space;
dstaddrgroup.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPortGroup")
{
srcportgroup = value;
srcportgroup.value_namespace = name_space;
srcportgroup.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPortGroup")
{
dstportgroup = value;
dstportgroup.value_namespace = name_space;
dstportgroup.value_namespace_prefix = name_space_prefix;
}
if(value_path == "redirect")
{
redirect = value;
redirect.value_namespace = name_space;
redirect.value_namespace_prefix = name_space_prefix;
}
if(value_path == "fltType")
{
flttype = value;
flttype.value_namespace = name_space;
flttype.value_namespace_prefix = name_space_prefix;
}
if(value_path == "protocol")
{
protocol = value;
protocol.value_namespace = name_space;
protocol.value_namespace_prefix = name_space_prefix;
}
if(value_path == "protocolMask")
{
protocolmask = value;
protocolmask.value_namespace = name_space;
protocolmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPrefix")
{
srcprefix = value;
srcprefix.value_namespace = name_space;
srcprefix.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPrefixMask")
{
srcprefixmask = value;
srcprefixmask.value_namespace = name_space;
srcprefixmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPrefixLength")
{
srcprefixlength = value;
srcprefixlength.value_namespace = name_space;
srcprefixlength.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPrefix")
{
dstprefix = value;
dstprefix.value_namespace = name_space;
dstprefix.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPrefixMask")
{
dstprefixmask = value;
dstprefixmask.value_namespace = name_space;
dstprefixmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPrefixLength")
{
dstprefixlength = value;
dstprefixlength.value_namespace = name_space;
dstprefixlength.value_namespace_prefix = name_space_prefix;
}
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::AceItems::WatchlistAceList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "seqNum")
{
seqnum.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
if(value_path == "remark")
{
remark.yfilter = yfilter;
}
if(value_path == "action")
{
action.yfilter = yfilter;
}
if(value_path == "srcPortOp")
{
srcportop.yfilter = yfilter;
}
if(value_path == "srcPort1")
{
srcport1.yfilter = yfilter;
}
if(value_path == "srcPort2")
{
srcport2.yfilter = yfilter;
}
if(value_path == "srcPortMask")
{
srcportmask.yfilter = yfilter;
}
if(value_path == "dstPortOp")
{
dstportop.yfilter = yfilter;
}
if(value_path == "dstPort1")
{
dstport1.yfilter = yfilter;
}
if(value_path == "dstPort2")
{
dstport2.yfilter = yfilter;
}
if(value_path == "dstPortMask")
{
dstportmask.yfilter = yfilter;
}
if(value_path == "logging")
{
logging.yfilter = yfilter;
}
if(value_path == "dscp")
{
dscp.yfilter = yfilter;
}
if(value_path == "pktLenOp")
{
pktlenop.yfilter = yfilter;
}
if(value_path == "pktLen1")
{
pktlen1.yfilter = yfilter;
}
if(value_path == "pktLen2")
{
pktlen2.yfilter = yfilter;
}
if(value_path == "urg")
{
urg.yfilter = yfilter;
}
if(value_path == "ack")
{
ack.yfilter = yfilter;
}
if(value_path == "psh")
{
psh.yfilter = yfilter;
}
if(value_path == "rst")
{
rst.yfilter = yfilter;
}
if(value_path == "syn")
{
syn.yfilter = yfilter;
}
if(value_path == "fin")
{
fin.yfilter = yfilter;
}
if(value_path == "est")
{
est.yfilter = yfilter;
}
if(value_path == "rev")
{
rev.yfilter = yfilter;
}
if(value_path == "tcpFlagsMask")
{
tcpflagsmask.yfilter = yfilter;
}
if(value_path == "packets")
{
packets.yfilter = yfilter;
}
if(value_path == "fragment")
{
fragment.yfilter = yfilter;
}
if(value_path == "captureSession")
{
capturesession.yfilter = yfilter;
}
if(value_path == "httpOption")
{
httpoption.yfilter = yfilter;
}
if(value_path == "vni")
{
vni.yfilter = yfilter;
}
if(value_path == "vlan")
{
vlan.yfilter = yfilter;
}
if(value_path == "tcpOptionLength")
{
tcpoptionlength.yfilter = yfilter;
}
if(value_path == "timeRange")
{
timerange.yfilter = yfilter;
}
if(value_path == "srcAddrGroup")
{
srcaddrgroup.yfilter = yfilter;
}
if(value_path == "dstAddrGroup")
{
dstaddrgroup.yfilter = yfilter;
}
if(value_path == "srcPortGroup")
{
srcportgroup.yfilter = yfilter;
}
if(value_path == "dstPortGroup")
{
dstportgroup.yfilter = yfilter;
}
if(value_path == "redirect")
{
redirect.yfilter = yfilter;
}
if(value_path == "fltType")
{
flttype.yfilter = yfilter;
}
if(value_path == "protocol")
{
protocol.yfilter = yfilter;
}
if(value_path == "protocolMask")
{
protocolmask.yfilter = yfilter;
}
if(value_path == "srcPrefix")
{
srcprefix.yfilter = yfilter;
}
if(value_path == "srcPrefixMask")
{
srcprefixmask.yfilter = yfilter;
}
if(value_path == "srcPrefixLength")
{
srcprefixlength.yfilter = yfilter;
}
if(value_path == "dstPrefix")
{
dstprefix.yfilter = yfilter;
}
if(value_path == "dstPrefixMask")
{
dstprefixmask.yfilter = yfilter;
}
if(value_path == "dstPrefixLength")
{
dstprefixlength.yfilter = yfilter;
}
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::WatchlistItems::WatchlistAclList::AceItems::WatchlistAceList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "seqNum" || name == "descr" || name == "remark" || name == "action" || name == "srcPortOp" || name == "srcPort1" || name == "srcPort2" || name == "srcPortMask" || name == "dstPortOp" || name == "dstPort1" || name == "dstPort2" || name == "dstPortMask" || name == "logging" || name == "dscp" || name == "pktLenOp" || name == "pktLen1" || name == "pktLen2" || name == "urg" || name == "ack" || name == "psh" || name == "rst" || name == "syn" || name == "fin" || name == "est" || name == "rev" || name == "tcpFlagsMask" || name == "packets" || name == "fragment" || name == "captureSession" || name == "httpOption" || name == "vni" || name == "vlan" || name == "tcpOptionLength" || name == "timeRange" || name == "srcAddrGroup" || name == "dstAddrGroup" || name == "srcPortGroup" || name == "dstPortGroup" || name == "redirect" || name == "fltType" || name == "protocol" || name == "protocolMask" || name == "srcPrefix" || name == "srcPrefixMask" || name == "srcPrefixLength" || name == "dstPrefix" || name == "dstPrefixMask" || name == "dstPrefixLength")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistItems()
:
droplistacl_list(this, {"name"})
{
yang_name = "droplist-items"; yang_parent_name = "Inst-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::~DroplistItems()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<droplistacl_list.len(); index++)
{
if(droplistacl_list[index]->has_data())
return true;
}
return false;
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::has_operation() const
{
for (std::size_t index=0; index<droplistacl_list.len(); index++)
{
if(droplistacl_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "droplist-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "DroplistAcl-list")
{
auto ent_ = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList>();
ent_->parent = this;
droplistacl_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : droplistacl_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "DroplistAcl-list")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::DroplistAclList()
:
name{YType::str, "name"},
descr{YType::str, "descr"},
peracestatistics{YType::uint8, "perACEStatistics"},
configstatus{YType::uint32, "configStatus"}
,
ace_items(std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::AceItems>())
{
ace_items->parent = this;
yang_name = "DroplistAcl-list"; yang_parent_name = "droplist-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::~DroplistAclList()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| descr.is_set
|| peracestatistics.is_set
|| configstatus.is_set
|| (ace_items != nullptr && ace_items->has_data());
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(descr.yfilter)
|| ydk::is_set(peracestatistics.yfilter)
|| ydk::is_set(configstatus.yfilter)
|| (ace_items != nullptr && ace_items->has_operation());
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "DroplistAcl-list";
ADD_KEY_TOKEN(name, "name");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
if (peracestatistics.is_set || is_set(peracestatistics.yfilter)) leaf_name_data.push_back(peracestatistics.get_name_leafdata());
if (configstatus.is_set || is_set(configstatus.yfilter)) leaf_name_data.push_back(configstatus.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "ace-items")
{
if(ace_items == nullptr)
{
ace_items = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::AceItems>();
}
return ace_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(ace_items != nullptr)
{
_children["ace-items"] = ace_items;
}
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
if(value_path == "perACEStatistics")
{
peracestatistics = value;
peracestatistics.value_namespace = name_space;
peracestatistics.value_namespace_prefix = name_space_prefix;
}
if(value_path == "configStatus")
{
configstatus = value;
configstatus.value_namespace = name_space;
configstatus.value_namespace_prefix = name_space_prefix;
}
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
if(value_path == "perACEStatistics")
{
peracestatistics.yfilter = yfilter;
}
if(value_path == "configStatus")
{
configstatus.yfilter = yfilter;
}
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "ace-items" || name == "name" || name == "descr" || name == "perACEStatistics" || name == "configStatus")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::AceItems::AceItems()
:
droplistace_list(this, {"seqnum"})
{
yang_name = "ace-items"; yang_parent_name = "DroplistAcl-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::AceItems::~AceItems()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::AceItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<droplistace_list.len(); index++)
{
if(droplistace_list[index]->has_data())
return true;
}
return false;
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::AceItems::has_operation() const
{
for (std::size_t index=0; index<droplistace_list.len(); index++)
{
if(droplistace_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::AceItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "ace-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::AceItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::AceItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "DroplistAce-list")
{
auto ent_ = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::AceItems::DroplistAceList>();
ent_->parent = this;
droplistace_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::AceItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : droplistace_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::AceItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::AceItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::AceItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "DroplistAce-list")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::AceItems::DroplistAceList::DroplistAceList()
:
seqnum{YType::uint32, "seqNum"},
descr{YType::str, "descr"},
remark{YType::str, "remark"},
action{YType::enumeration, "action"},
srcportop{YType::uint8, "srcPortOp"},
srcport1{YType::uint16, "srcPort1"},
srcport2{YType::uint16, "srcPort2"},
srcportmask{YType::uint16, "srcPortMask"},
dstportop{YType::uint8, "dstPortOp"},
dstport1{YType::uint16, "dstPort1"},
dstport2{YType::uint16, "dstPort2"},
dstportmask{YType::uint16, "dstPortMask"},
logging{YType::boolean, "logging"},
dscp{YType::uint8, "dscp"},
pktlenop{YType::uint8, "pktLenOp"},
pktlen1{YType::uint16, "pktLen1"},
pktlen2{YType::uint16, "pktLen2"},
urg{YType::boolean, "urg"},
ack{YType::boolean, "ack"},
psh{YType::boolean, "psh"},
rst{YType::boolean, "rst"},
syn{YType::boolean, "syn"},
fin{YType::boolean, "fin"},
est{YType::boolean, "est"},
rev{YType::boolean, "rev"},
tcpflagsmask{YType::uint8, "tcpFlagsMask"},
packets{YType::uint64, "packets"},
fragment{YType::boolean, "fragment"},
capturesession{YType::uint16, "captureSession"},
httpoption{YType::enumeration, "httpOption"},
vni{YType::uint32, "vni"},
vlan{YType::uint32, "vlan"},
tcpoptionlength{YType::uint32, "tcpOptionLength"},
timerange{YType::str, "timeRange"},
srcaddrgroup{YType::str, "srcAddrGroup"},
dstaddrgroup{YType::str, "dstAddrGroup"},
srcportgroup{YType::str, "srcPortGroup"},
dstportgroup{YType::str, "dstPortGroup"},
redirect{YType::str, "redirect"},
flttype{YType::enumeration, "fltType"},
protocol{YType::uint8, "protocol"},
protocolmask{YType::uint8, "protocolMask"},
srcprefix{YType::str, "srcPrefix"},
srcprefixmask{YType::str, "srcPrefixMask"},
srcprefixlength{YType::uint8, "srcPrefixLength"},
dstprefix{YType::str, "dstPrefix"},
dstprefixmask{YType::str, "dstPrefixMask"},
dstprefixlength{YType::uint8, "dstPrefixLength"}
{
yang_name = "DroplistAce-list"; yang_parent_name = "ace-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::AceItems::DroplistAceList::~DroplistAceList()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::AceItems::DroplistAceList::has_data() const
{
if (is_presence_container) return true;
return seqnum.is_set
|| descr.is_set
|| remark.is_set
|| action.is_set
|| srcportop.is_set
|| srcport1.is_set
|| srcport2.is_set
|| srcportmask.is_set
|| dstportop.is_set
|| dstport1.is_set
|| dstport2.is_set
|| dstportmask.is_set
|| logging.is_set
|| dscp.is_set
|| pktlenop.is_set
|| pktlen1.is_set
|| pktlen2.is_set
|| urg.is_set
|| ack.is_set
|| psh.is_set
|| rst.is_set
|| syn.is_set
|| fin.is_set
|| est.is_set
|| rev.is_set
|| tcpflagsmask.is_set
|| packets.is_set
|| fragment.is_set
|| capturesession.is_set
|| httpoption.is_set
|| vni.is_set
|| vlan.is_set
|| tcpoptionlength.is_set
|| timerange.is_set
|| srcaddrgroup.is_set
|| dstaddrgroup.is_set
|| srcportgroup.is_set
|| dstportgroup.is_set
|| redirect.is_set
|| flttype.is_set
|| protocol.is_set
|| protocolmask.is_set
|| srcprefix.is_set
|| srcprefixmask.is_set
|| srcprefixlength.is_set
|| dstprefix.is_set
|| dstprefixmask.is_set
|| dstprefixlength.is_set;
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::AceItems::DroplistAceList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(seqnum.yfilter)
|| ydk::is_set(descr.yfilter)
|| ydk::is_set(remark.yfilter)
|| ydk::is_set(action.yfilter)
|| ydk::is_set(srcportop.yfilter)
|| ydk::is_set(srcport1.yfilter)
|| ydk::is_set(srcport2.yfilter)
|| ydk::is_set(srcportmask.yfilter)
|| ydk::is_set(dstportop.yfilter)
|| ydk::is_set(dstport1.yfilter)
|| ydk::is_set(dstport2.yfilter)
|| ydk::is_set(dstportmask.yfilter)
|| ydk::is_set(logging.yfilter)
|| ydk::is_set(dscp.yfilter)
|| ydk::is_set(pktlenop.yfilter)
|| ydk::is_set(pktlen1.yfilter)
|| ydk::is_set(pktlen2.yfilter)
|| ydk::is_set(urg.yfilter)
|| ydk::is_set(ack.yfilter)
|| ydk::is_set(psh.yfilter)
|| ydk::is_set(rst.yfilter)
|| ydk::is_set(syn.yfilter)
|| ydk::is_set(fin.yfilter)
|| ydk::is_set(est.yfilter)
|| ydk::is_set(rev.yfilter)
|| ydk::is_set(tcpflagsmask.yfilter)
|| ydk::is_set(packets.yfilter)
|| ydk::is_set(fragment.yfilter)
|| ydk::is_set(capturesession.yfilter)
|| ydk::is_set(httpoption.yfilter)
|| ydk::is_set(vni.yfilter)
|| ydk::is_set(vlan.yfilter)
|| ydk::is_set(tcpoptionlength.yfilter)
|| ydk::is_set(timerange.yfilter)
|| ydk::is_set(srcaddrgroup.yfilter)
|| ydk::is_set(dstaddrgroup.yfilter)
|| ydk::is_set(srcportgroup.yfilter)
|| ydk::is_set(dstportgroup.yfilter)
|| ydk::is_set(redirect.yfilter)
|| ydk::is_set(flttype.yfilter)
|| ydk::is_set(protocol.yfilter)
|| ydk::is_set(protocolmask.yfilter)
|| ydk::is_set(srcprefix.yfilter)
|| ydk::is_set(srcprefixmask.yfilter)
|| ydk::is_set(srcprefixlength.yfilter)
|| ydk::is_set(dstprefix.yfilter)
|| ydk::is_set(dstprefixmask.yfilter)
|| ydk::is_set(dstprefixlength.yfilter);
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::AceItems::DroplistAceList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "DroplistAce-list";
ADD_KEY_TOKEN(seqnum, "seqNum");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::AceItems::DroplistAceList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (seqnum.is_set || is_set(seqnum.yfilter)) leaf_name_data.push_back(seqnum.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
if (remark.is_set || is_set(remark.yfilter)) leaf_name_data.push_back(remark.get_name_leafdata());
if (action.is_set || is_set(action.yfilter)) leaf_name_data.push_back(action.get_name_leafdata());
if (srcportop.is_set || is_set(srcportop.yfilter)) leaf_name_data.push_back(srcportop.get_name_leafdata());
if (srcport1.is_set || is_set(srcport1.yfilter)) leaf_name_data.push_back(srcport1.get_name_leafdata());
if (srcport2.is_set || is_set(srcport2.yfilter)) leaf_name_data.push_back(srcport2.get_name_leafdata());
if (srcportmask.is_set || is_set(srcportmask.yfilter)) leaf_name_data.push_back(srcportmask.get_name_leafdata());
if (dstportop.is_set || is_set(dstportop.yfilter)) leaf_name_data.push_back(dstportop.get_name_leafdata());
if (dstport1.is_set || is_set(dstport1.yfilter)) leaf_name_data.push_back(dstport1.get_name_leafdata());
if (dstport2.is_set || is_set(dstport2.yfilter)) leaf_name_data.push_back(dstport2.get_name_leafdata());
if (dstportmask.is_set || is_set(dstportmask.yfilter)) leaf_name_data.push_back(dstportmask.get_name_leafdata());
if (logging.is_set || is_set(logging.yfilter)) leaf_name_data.push_back(logging.get_name_leafdata());
if (dscp.is_set || is_set(dscp.yfilter)) leaf_name_data.push_back(dscp.get_name_leafdata());
if (pktlenop.is_set || is_set(pktlenop.yfilter)) leaf_name_data.push_back(pktlenop.get_name_leafdata());
if (pktlen1.is_set || is_set(pktlen1.yfilter)) leaf_name_data.push_back(pktlen1.get_name_leafdata());
if (pktlen2.is_set || is_set(pktlen2.yfilter)) leaf_name_data.push_back(pktlen2.get_name_leafdata());
if (urg.is_set || is_set(urg.yfilter)) leaf_name_data.push_back(urg.get_name_leafdata());
if (ack.is_set || is_set(ack.yfilter)) leaf_name_data.push_back(ack.get_name_leafdata());
if (psh.is_set || is_set(psh.yfilter)) leaf_name_data.push_back(psh.get_name_leafdata());
if (rst.is_set || is_set(rst.yfilter)) leaf_name_data.push_back(rst.get_name_leafdata());
if (syn.is_set || is_set(syn.yfilter)) leaf_name_data.push_back(syn.get_name_leafdata());
if (fin.is_set || is_set(fin.yfilter)) leaf_name_data.push_back(fin.get_name_leafdata());
if (est.is_set || is_set(est.yfilter)) leaf_name_data.push_back(est.get_name_leafdata());
if (rev.is_set || is_set(rev.yfilter)) leaf_name_data.push_back(rev.get_name_leafdata());
if (tcpflagsmask.is_set || is_set(tcpflagsmask.yfilter)) leaf_name_data.push_back(tcpflagsmask.get_name_leafdata());
if (packets.is_set || is_set(packets.yfilter)) leaf_name_data.push_back(packets.get_name_leafdata());
if (fragment.is_set || is_set(fragment.yfilter)) leaf_name_data.push_back(fragment.get_name_leafdata());
if (capturesession.is_set || is_set(capturesession.yfilter)) leaf_name_data.push_back(capturesession.get_name_leafdata());
if (httpoption.is_set || is_set(httpoption.yfilter)) leaf_name_data.push_back(httpoption.get_name_leafdata());
if (vni.is_set || is_set(vni.yfilter)) leaf_name_data.push_back(vni.get_name_leafdata());
if (vlan.is_set || is_set(vlan.yfilter)) leaf_name_data.push_back(vlan.get_name_leafdata());
if (tcpoptionlength.is_set || is_set(tcpoptionlength.yfilter)) leaf_name_data.push_back(tcpoptionlength.get_name_leafdata());
if (timerange.is_set || is_set(timerange.yfilter)) leaf_name_data.push_back(timerange.get_name_leafdata());
if (srcaddrgroup.is_set || is_set(srcaddrgroup.yfilter)) leaf_name_data.push_back(srcaddrgroup.get_name_leafdata());
if (dstaddrgroup.is_set || is_set(dstaddrgroup.yfilter)) leaf_name_data.push_back(dstaddrgroup.get_name_leafdata());
if (srcportgroup.is_set || is_set(srcportgroup.yfilter)) leaf_name_data.push_back(srcportgroup.get_name_leafdata());
if (dstportgroup.is_set || is_set(dstportgroup.yfilter)) leaf_name_data.push_back(dstportgroup.get_name_leafdata());
if (redirect.is_set || is_set(redirect.yfilter)) leaf_name_data.push_back(redirect.get_name_leafdata());
if (flttype.is_set || is_set(flttype.yfilter)) leaf_name_data.push_back(flttype.get_name_leafdata());
if (protocol.is_set || is_set(protocol.yfilter)) leaf_name_data.push_back(protocol.get_name_leafdata());
if (protocolmask.is_set || is_set(protocolmask.yfilter)) leaf_name_data.push_back(protocolmask.get_name_leafdata());
if (srcprefix.is_set || is_set(srcprefix.yfilter)) leaf_name_data.push_back(srcprefix.get_name_leafdata());
if (srcprefixmask.is_set || is_set(srcprefixmask.yfilter)) leaf_name_data.push_back(srcprefixmask.get_name_leafdata());
if (srcprefixlength.is_set || is_set(srcprefixlength.yfilter)) leaf_name_data.push_back(srcprefixlength.get_name_leafdata());
if (dstprefix.is_set || is_set(dstprefix.yfilter)) leaf_name_data.push_back(dstprefix.get_name_leafdata());
if (dstprefixmask.is_set || is_set(dstprefixmask.yfilter)) leaf_name_data.push_back(dstprefixmask.get_name_leafdata());
if (dstprefixlength.is_set || is_set(dstprefixlength.yfilter)) leaf_name_data.push_back(dstprefixlength.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::AceItems::DroplistAceList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::AceItems::DroplistAceList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::AceItems::DroplistAceList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "seqNum")
{
seqnum = value;
seqnum.value_namespace = name_space;
seqnum.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
if(value_path == "remark")
{
remark = value;
remark.value_namespace = name_space;
remark.value_namespace_prefix = name_space_prefix;
}
if(value_path == "action")
{
action = value;
action.value_namespace = name_space;
action.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPortOp")
{
srcportop = value;
srcportop.value_namespace = name_space;
srcportop.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPort1")
{
srcport1 = value;
srcport1.value_namespace = name_space;
srcport1.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPort2")
{
srcport2 = value;
srcport2.value_namespace = name_space;
srcport2.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPortMask")
{
srcportmask = value;
srcportmask.value_namespace = name_space;
srcportmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPortOp")
{
dstportop = value;
dstportop.value_namespace = name_space;
dstportop.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPort1")
{
dstport1 = value;
dstport1.value_namespace = name_space;
dstport1.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPort2")
{
dstport2 = value;
dstport2.value_namespace = name_space;
dstport2.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPortMask")
{
dstportmask = value;
dstportmask.value_namespace = name_space;
dstportmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "logging")
{
logging = value;
logging.value_namespace = name_space;
logging.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dscp")
{
dscp = value;
dscp.value_namespace = name_space;
dscp.value_namespace_prefix = name_space_prefix;
}
if(value_path == "pktLenOp")
{
pktlenop = value;
pktlenop.value_namespace = name_space;
pktlenop.value_namespace_prefix = name_space_prefix;
}
if(value_path == "pktLen1")
{
pktlen1 = value;
pktlen1.value_namespace = name_space;
pktlen1.value_namespace_prefix = name_space_prefix;
}
if(value_path == "pktLen2")
{
pktlen2 = value;
pktlen2.value_namespace = name_space;
pktlen2.value_namespace_prefix = name_space_prefix;
}
if(value_path == "urg")
{
urg = value;
urg.value_namespace = name_space;
urg.value_namespace_prefix = name_space_prefix;
}
if(value_path == "ack")
{
ack = value;
ack.value_namespace = name_space;
ack.value_namespace_prefix = name_space_prefix;
}
if(value_path == "psh")
{
psh = value;
psh.value_namespace = name_space;
psh.value_namespace_prefix = name_space_prefix;
}
if(value_path == "rst")
{
rst = value;
rst.value_namespace = name_space;
rst.value_namespace_prefix = name_space_prefix;
}
if(value_path == "syn")
{
syn = value;
syn.value_namespace = name_space;
syn.value_namespace_prefix = name_space_prefix;
}
if(value_path == "fin")
{
fin = value;
fin.value_namespace = name_space;
fin.value_namespace_prefix = name_space_prefix;
}
if(value_path == "est")
{
est = value;
est.value_namespace = name_space;
est.value_namespace_prefix = name_space_prefix;
}
if(value_path == "rev")
{
rev = value;
rev.value_namespace = name_space;
rev.value_namespace_prefix = name_space_prefix;
}
if(value_path == "tcpFlagsMask")
{
tcpflagsmask = value;
tcpflagsmask.value_namespace = name_space;
tcpflagsmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "packets")
{
packets = value;
packets.value_namespace = name_space;
packets.value_namespace_prefix = name_space_prefix;
}
if(value_path == "fragment")
{
fragment = value;
fragment.value_namespace = name_space;
fragment.value_namespace_prefix = name_space_prefix;
}
if(value_path == "captureSession")
{
capturesession = value;
capturesession.value_namespace = name_space;
capturesession.value_namespace_prefix = name_space_prefix;
}
if(value_path == "httpOption")
{
httpoption = value;
httpoption.value_namespace = name_space;
httpoption.value_namespace_prefix = name_space_prefix;
}
if(value_path == "vni")
{
vni = value;
vni.value_namespace = name_space;
vni.value_namespace_prefix = name_space_prefix;
}
if(value_path == "vlan")
{
vlan = value;
vlan.value_namespace = name_space;
vlan.value_namespace_prefix = name_space_prefix;
}
if(value_path == "tcpOptionLength")
{
tcpoptionlength = value;
tcpoptionlength.value_namespace = name_space;
tcpoptionlength.value_namespace_prefix = name_space_prefix;
}
if(value_path == "timeRange")
{
timerange = value;
timerange.value_namespace = name_space;
timerange.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcAddrGroup")
{
srcaddrgroup = value;
srcaddrgroup.value_namespace = name_space;
srcaddrgroup.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstAddrGroup")
{
dstaddrgroup = value;
dstaddrgroup.value_namespace = name_space;
dstaddrgroup.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPortGroup")
{
srcportgroup = value;
srcportgroup.value_namespace = name_space;
srcportgroup.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPortGroup")
{
dstportgroup = value;
dstportgroup.value_namespace = name_space;
dstportgroup.value_namespace_prefix = name_space_prefix;
}
if(value_path == "redirect")
{
redirect = value;
redirect.value_namespace = name_space;
redirect.value_namespace_prefix = name_space_prefix;
}
if(value_path == "fltType")
{
flttype = value;
flttype.value_namespace = name_space;
flttype.value_namespace_prefix = name_space_prefix;
}
if(value_path == "protocol")
{
protocol = value;
protocol.value_namespace = name_space;
protocol.value_namespace_prefix = name_space_prefix;
}
if(value_path == "protocolMask")
{
protocolmask = value;
protocolmask.value_namespace = name_space;
protocolmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPrefix")
{
srcprefix = value;
srcprefix.value_namespace = name_space;
srcprefix.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPrefixMask")
{
srcprefixmask = value;
srcprefixmask.value_namespace = name_space;
srcprefixmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcPrefixLength")
{
srcprefixlength = value;
srcprefixlength.value_namespace = name_space;
srcprefixlength.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPrefix")
{
dstprefix = value;
dstprefix.value_namespace = name_space;
dstprefix.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPrefixMask")
{
dstprefixmask = value;
dstprefixmask.value_namespace = name_space;
dstprefixmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPrefixLength")
{
dstprefixlength = value;
dstprefixlength.value_namespace = name_space;
dstprefixlength.value_namespace_prefix = name_space_prefix;
}
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::AceItems::DroplistAceList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "seqNum")
{
seqnum.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
if(value_path == "remark")
{
remark.yfilter = yfilter;
}
if(value_path == "action")
{
action.yfilter = yfilter;
}
if(value_path == "srcPortOp")
{
srcportop.yfilter = yfilter;
}
if(value_path == "srcPort1")
{
srcport1.yfilter = yfilter;
}
if(value_path == "srcPort2")
{
srcport2.yfilter = yfilter;
}
if(value_path == "srcPortMask")
{
srcportmask.yfilter = yfilter;
}
if(value_path == "dstPortOp")
{
dstportop.yfilter = yfilter;
}
if(value_path == "dstPort1")
{
dstport1.yfilter = yfilter;
}
if(value_path == "dstPort2")
{
dstport2.yfilter = yfilter;
}
if(value_path == "dstPortMask")
{
dstportmask.yfilter = yfilter;
}
if(value_path == "logging")
{
logging.yfilter = yfilter;
}
if(value_path == "dscp")
{
dscp.yfilter = yfilter;
}
if(value_path == "pktLenOp")
{
pktlenop.yfilter = yfilter;
}
if(value_path == "pktLen1")
{
pktlen1.yfilter = yfilter;
}
if(value_path == "pktLen2")
{
pktlen2.yfilter = yfilter;
}
if(value_path == "urg")
{
urg.yfilter = yfilter;
}
if(value_path == "ack")
{
ack.yfilter = yfilter;
}
if(value_path == "psh")
{
psh.yfilter = yfilter;
}
if(value_path == "rst")
{
rst.yfilter = yfilter;
}
if(value_path == "syn")
{
syn.yfilter = yfilter;
}
if(value_path == "fin")
{
fin.yfilter = yfilter;
}
if(value_path == "est")
{
est.yfilter = yfilter;
}
if(value_path == "rev")
{
rev.yfilter = yfilter;
}
if(value_path == "tcpFlagsMask")
{
tcpflagsmask.yfilter = yfilter;
}
if(value_path == "packets")
{
packets.yfilter = yfilter;
}
if(value_path == "fragment")
{
fragment.yfilter = yfilter;
}
if(value_path == "captureSession")
{
capturesession.yfilter = yfilter;
}
if(value_path == "httpOption")
{
httpoption.yfilter = yfilter;
}
if(value_path == "vni")
{
vni.yfilter = yfilter;
}
if(value_path == "vlan")
{
vlan.yfilter = yfilter;
}
if(value_path == "tcpOptionLength")
{
tcpoptionlength.yfilter = yfilter;
}
if(value_path == "timeRange")
{
timerange.yfilter = yfilter;
}
if(value_path == "srcAddrGroup")
{
srcaddrgroup.yfilter = yfilter;
}
if(value_path == "dstAddrGroup")
{
dstaddrgroup.yfilter = yfilter;
}
if(value_path == "srcPortGroup")
{
srcportgroup.yfilter = yfilter;
}
if(value_path == "dstPortGroup")
{
dstportgroup.yfilter = yfilter;
}
if(value_path == "redirect")
{
redirect.yfilter = yfilter;
}
if(value_path == "fltType")
{
flttype.yfilter = yfilter;
}
if(value_path == "protocol")
{
protocol.yfilter = yfilter;
}
if(value_path == "protocolMask")
{
protocolmask.yfilter = yfilter;
}
if(value_path == "srcPrefix")
{
srcprefix.yfilter = yfilter;
}
if(value_path == "srcPrefixMask")
{
srcprefixmask.yfilter = yfilter;
}
if(value_path == "srcPrefixLength")
{
srcprefixlength.yfilter = yfilter;
}
if(value_path == "dstPrefix")
{
dstprefix.yfilter = yfilter;
}
if(value_path == "dstPrefixMask")
{
dstprefixmask.yfilter = yfilter;
}
if(value_path == "dstPrefixLength")
{
dstprefixlength.yfilter = yfilter;
}
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::DroplistItems::DroplistAclList::AceItems::DroplistAceList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "seqNum" || name == "descr" || name == "remark" || name == "action" || name == "srcPortOp" || name == "srcPort1" || name == "srcPort2" || name == "srcPortMask" || name == "dstPortOp" || name == "dstPort1" || name == "dstPort2" || name == "dstPortMask" || name == "logging" || name == "dscp" || name == "pktLenOp" || name == "pktLen1" || name == "pktLen2" || name == "urg" || name == "ack" || name == "psh" || name == "rst" || name == "syn" || name == "fin" || name == "est" || name == "rev" || name == "tcpFlagsMask" || name == "packets" || name == "fragment" || name == "captureSession" || name == "httpOption" || name == "vni" || name == "vlan" || name == "tcpOptionLength" || name == "timeRange" || name == "srcAddrGroup" || name == "dstAddrGroup" || name == "srcPortGroup" || name == "dstPortGroup" || name == "redirect" || name == "fltType" || name == "protocol" || name == "protocolMask" || name == "srcPrefix" || name == "srcPrefixMask" || name == "srcPrefixLength" || name == "dstPrefix" || name == "dstPrefixMask" || name == "dstPrefixLength")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::RecordpItems::RecordpItems()
:
recordp_list(this, {"name"})
{
yang_name = "recordp-items"; yang_parent_name = "Inst-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::RecordpItems::~RecordpItems()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::RecordpItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<recordp_list.len(); index++)
{
if(recordp_list[index]->has_data())
return true;
}
return false;
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::RecordpItems::has_operation() const
{
for (std::size_t index=0; index<recordp_list.len(); index++)
{
if(recordp_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::RecordpItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "recordp-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::RecordpItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::RecordpItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "RecordP-list")
{
auto ent_ = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::RecordpItems::RecordPList>();
ent_->parent = this;
recordp_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::RecordpItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : recordp_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::RecordpItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::RecordpItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::RecordpItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "RecordP-list")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::RecordpItems::RecordPList::RecordPList()
:
name{YType::str, "name"},
collect0{YType::str, "collect0"},
descr{YType::str, "descr"}
{
yang_name = "RecordP-list"; yang_parent_name = "recordp-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::RecordpItems::RecordPList::~RecordPList()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::RecordpItems::RecordPList::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| collect0.is_set
|| descr.is_set;
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::RecordpItems::RecordPList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(collect0.yfilter)
|| ydk::is_set(descr.yfilter);
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::RecordpItems::RecordPList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "RecordP-list";
ADD_KEY_TOKEN(name, "name");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::RecordpItems::RecordPList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (collect0.is_set || is_set(collect0.yfilter)) leaf_name_data.push_back(collect0.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::RecordpItems::RecordPList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::RecordpItems::RecordPList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::RecordpItems::RecordPList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "collect0")
{
collect0 = value;
collect0.value_namespace = name_space;
collect0.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::RecordpItems::RecordPList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "collect0")
{
collect0.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::RecordpItems::RecordPList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "name" || name == "collect0" || name == "descr")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::CollectorItems::CollectorItems()
:
collector_list(this, {"name"})
{
yang_name = "collector-items"; yang_parent_name = "Inst-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::CollectorItems::~CollectorItems()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::CollectorItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<collector_list.len(); index++)
{
if(collector_list[index]->has_data())
return true;
}
return false;
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::CollectorItems::has_operation() const
{
for (std::size_t index=0; index<collector_list.len(); index++)
{
if(collector_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::CollectorItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "collector-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::CollectorItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::CollectorItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "Collector-list")
{
auto ent_ = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::CollectorItems::CollectorList>();
ent_->parent = this;
collector_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::CollectorItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : collector_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::CollectorItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::CollectorItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::CollectorItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "Collector-list")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::CollectorItems::CollectorList::CollectorList()
:
name{YType::str, "name"},
descr{YType::str, "descr"},
vrfname{YType::str, "vrfName"},
dstaddr{YType::str, "dstAddr"},
dstport{YType::uint16, "dstPort"},
dscp{YType::uint8, "dscp"},
srcif{YType::str, "srcIf"},
srcaddr{YType::str, "srcAddr"},
sequencenumber{YType::uint32, "sequenceNumber"}
{
yang_name = "Collector-list"; yang_parent_name = "collector-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::CollectorItems::CollectorList::~CollectorList()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::CollectorItems::CollectorList::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| descr.is_set
|| vrfname.is_set
|| dstaddr.is_set
|| dstport.is_set
|| dscp.is_set
|| srcif.is_set
|| srcaddr.is_set
|| sequencenumber.is_set;
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::CollectorItems::CollectorList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(descr.yfilter)
|| ydk::is_set(vrfname.yfilter)
|| ydk::is_set(dstaddr.yfilter)
|| ydk::is_set(dstport.yfilter)
|| ydk::is_set(dscp.yfilter)
|| ydk::is_set(srcif.yfilter)
|| ydk::is_set(srcaddr.yfilter)
|| ydk::is_set(sequencenumber.yfilter);
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::CollectorItems::CollectorList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "Collector-list";
ADD_KEY_TOKEN(name, "name");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::CollectorItems::CollectorList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
if (vrfname.is_set || is_set(vrfname.yfilter)) leaf_name_data.push_back(vrfname.get_name_leafdata());
if (dstaddr.is_set || is_set(dstaddr.yfilter)) leaf_name_data.push_back(dstaddr.get_name_leafdata());
if (dstport.is_set || is_set(dstport.yfilter)) leaf_name_data.push_back(dstport.get_name_leafdata());
if (dscp.is_set || is_set(dscp.yfilter)) leaf_name_data.push_back(dscp.get_name_leafdata());
if (srcif.is_set || is_set(srcif.yfilter)) leaf_name_data.push_back(srcif.get_name_leafdata());
if (srcaddr.is_set || is_set(srcaddr.yfilter)) leaf_name_data.push_back(srcaddr.get_name_leafdata());
if (sequencenumber.is_set || is_set(sequencenumber.yfilter)) leaf_name_data.push_back(sequencenumber.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::CollectorItems::CollectorList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::CollectorItems::CollectorList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::CollectorItems::CollectorList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
if(value_path == "vrfName")
{
vrfname = value;
vrfname.value_namespace = name_space;
vrfname.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstAddr")
{
dstaddr = value;
dstaddr.value_namespace = name_space;
dstaddr.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dstPort")
{
dstport = value;
dstport.value_namespace = name_space;
dstport.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dscp")
{
dscp = value;
dscp.value_namespace = name_space;
dscp.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcIf")
{
srcif = value;
srcif.value_namespace = name_space;
srcif.value_namespace_prefix = name_space_prefix;
}
if(value_path == "srcAddr")
{
srcaddr = value;
srcaddr.value_namespace = name_space;
srcaddr.value_namespace_prefix = name_space_prefix;
}
if(value_path == "sequenceNumber")
{
sequencenumber = value;
sequencenumber.value_namespace = name_space;
sequencenumber.value_namespace_prefix = name_space_prefix;
}
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::CollectorItems::CollectorList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
if(value_path == "vrfName")
{
vrfname.yfilter = yfilter;
}
if(value_path == "dstAddr")
{
dstaddr.yfilter = yfilter;
}
if(value_path == "dstPort")
{
dstport.yfilter = yfilter;
}
if(value_path == "dscp")
{
dscp.yfilter = yfilter;
}
if(value_path == "srcIf")
{
srcif.yfilter = yfilter;
}
if(value_path == "srcAddr")
{
srcaddr.yfilter = yfilter;
}
if(value_path == "sequenceNumber")
{
sequencenumber.yfilter = yfilter;
}
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::CollectorItems::CollectorList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "name" || name == "descr" || name == "vrfName" || name == "dstAddr" || name == "dstPort" || name == "dscp" || name == "srcIf" || name == "srcAddr" || name == "sequenceNumber")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FlowprofItems::FlowprofItems()
:
flowprofile_list(this, {"name"})
{
yang_name = "flowprof-items"; yang_parent_name = "Inst-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FlowprofItems::~FlowprofItems()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FlowprofItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<flowprofile_list.len(); index++)
{
if(flowprofile_list[index]->has_data())
return true;
}
return false;
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FlowprofItems::has_operation() const
{
for (std::size_t index=0; index<flowprofile_list.len(); index++)
{
if(flowprofile_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FlowprofItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "flowprof-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FlowprofItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FlowprofItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "FlowProfile-list")
{
auto ent_ = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FlowprofItems::FlowProfileList>();
ent_->parent = this;
flowprofile_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FlowprofItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : flowprofile_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FlowprofItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FlowprofItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FlowprofItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "FlowProfile-list")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FlowprofItems::FlowProfileList::FlowProfileList()
:
name{YType::str, "name"},
dscp{YType::uint16, "dscp"},
dscpmask{YType::uint16, "dscpMask"},
age{YType::uint16, "age"},
latencyquant{YType::uint16, "latencyQuant"},
descr{YType::str, "descr"}
{
yang_name = "FlowProfile-list"; yang_parent_name = "flowprof-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FlowprofItems::FlowProfileList::~FlowProfileList()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FlowprofItems::FlowProfileList::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| dscp.is_set
|| dscpmask.is_set
|| age.is_set
|| latencyquant.is_set
|| descr.is_set;
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FlowprofItems::FlowProfileList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(dscp.yfilter)
|| ydk::is_set(dscpmask.yfilter)
|| ydk::is_set(age.yfilter)
|| ydk::is_set(latencyquant.yfilter)
|| ydk::is_set(descr.yfilter);
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FlowprofItems::FlowProfileList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "FlowProfile-list";
ADD_KEY_TOKEN(name, "name");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FlowprofItems::FlowProfileList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (dscp.is_set || is_set(dscp.yfilter)) leaf_name_data.push_back(dscp.get_name_leafdata());
if (dscpmask.is_set || is_set(dscpmask.yfilter)) leaf_name_data.push_back(dscpmask.get_name_leafdata());
if (age.is_set || is_set(age.yfilter)) leaf_name_data.push_back(age.get_name_leafdata());
if (latencyquant.is_set || is_set(latencyquant.yfilter)) leaf_name_data.push_back(latencyquant.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FlowprofItems::FlowProfileList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FlowprofItems::FlowProfileList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FlowprofItems::FlowProfileList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dscp")
{
dscp = value;
dscp.value_namespace = name_space;
dscp.value_namespace_prefix = name_space_prefix;
}
if(value_path == "dscpMask")
{
dscpmask = value;
dscpmask.value_namespace = name_space;
dscpmask.value_namespace_prefix = name_space_prefix;
}
if(value_path == "age")
{
age = value;
age.value_namespace = name_space;
age.value_namespace_prefix = name_space_prefix;
}
if(value_path == "latencyQuant")
{
latencyquant = value;
latencyquant.value_namespace = name_space;
latencyquant.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FlowprofItems::FlowProfileList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "dscp")
{
dscp.yfilter = yfilter;
}
if(value_path == "dscpMask")
{
dscpmask.yfilter = yfilter;
}
if(value_path == "age")
{
age.yfilter = yfilter;
}
if(value_path == "latencyQuant")
{
latencyquant.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FlowprofItems::FlowProfileList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "name" || name == "dscp" || name == "dscpMask" || name == "age" || name == "latencyQuant" || name == "descr")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::QueueprofItems::QueueprofItems()
:
queueprofile_list(this, {"name"})
{
yang_name = "queueprof-items"; yang_parent_name = "Inst-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::QueueprofItems::~QueueprofItems()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::QueueprofItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<queueprofile_list.len(); index++)
{
if(queueprofile_list[index]->has_data())
return true;
}
return false;
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::QueueprofItems::has_operation() const
{
for (std::size_t index=0; index<queueprofile_list.len(); index++)
{
if(queueprofile_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::QueueprofItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "queueprof-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::QueueprofItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::QueueprofItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "QueueProfile-list")
{
auto ent_ = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::QueueprofItems::QueueProfileList>();
ent_->parent = this;
queueprofile_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::QueueprofItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : queueprofile_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::QueueprofItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::QueueprofItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::QueueprofItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "QueueProfile-list")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::QueueprofItems::QueueProfileList::QueueProfileList()
:
name{YType::str, "name"},
depth{YType::uint32, "depth"},
latency{YType::uint32, "latency"},
breach{YType::uint16, "breach"},
taildrop{YType::boolean, "tailDrop"},
descr{YType::str, "descr"}
{
yang_name = "QueueProfile-list"; yang_parent_name = "queueprof-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::QueueprofItems::QueueProfileList::~QueueProfileList()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::QueueprofItems::QueueProfileList::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| depth.is_set
|| latency.is_set
|| breach.is_set
|| taildrop.is_set
|| descr.is_set;
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::QueueprofItems::QueueProfileList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(depth.yfilter)
|| ydk::is_set(latency.yfilter)
|| ydk::is_set(breach.yfilter)
|| ydk::is_set(taildrop.yfilter)
|| ydk::is_set(descr.yfilter);
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::QueueprofItems::QueueProfileList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "QueueProfile-list";
ADD_KEY_TOKEN(name, "name");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::QueueprofItems::QueueProfileList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (depth.is_set || is_set(depth.yfilter)) leaf_name_data.push_back(depth.get_name_leafdata());
if (latency.is_set || is_set(latency.yfilter)) leaf_name_data.push_back(latency.get_name_leafdata());
if (breach.is_set || is_set(breach.yfilter)) leaf_name_data.push_back(breach.get_name_leafdata());
if (taildrop.is_set || is_set(taildrop.yfilter)) leaf_name_data.push_back(taildrop.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::QueueprofItems::QueueProfileList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::QueueprofItems::QueueProfileList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::QueueprofItems::QueueProfileList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "depth")
{
depth = value;
depth.value_namespace = name_space;
depth.value_namespace_prefix = name_space_prefix;
}
if(value_path == "latency")
{
latency = value;
latency.value_namespace = name_space;
latency.value_namespace_prefix = name_space_prefix;
}
if(value_path == "breach")
{
breach = value;
breach.value_namespace = name_space;
breach.value_namespace_prefix = name_space_prefix;
}
if(value_path == "tailDrop")
{
taildrop = value;
taildrop.value_namespace = name_space;
taildrop.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::QueueprofItems::QueueProfileList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "depth")
{
depth.yfilter = yfilter;
}
if(value_path == "latency")
{
latency.yfilter = yfilter;
}
if(value_path == "breach")
{
breach.yfilter = yfilter;
}
if(value_path == "tailDrop")
{
taildrop.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::QueueprofItems::QueueProfileList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "name" || name == "depth" || name == "latency" || name == "breach" || name == "tailDrop" || name == "descr")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorItems()
:
monitor_list(this, {"name"})
{
yang_name = "monitor-items"; yang_parent_name = "Inst-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::~MonitorItems()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<monitor_list.len(); index++)
{
if(monitor_list[index]->has_data())
return true;
}
return false;
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::has_operation() const
{
for (std::size_t index=0; index<monitor_list.len(); index++)
{
if(monitor_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "monitor-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "Monitor-list")
{
auto ent_ = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList>();
ent_->parent = this;
monitor_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : monitor_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "Monitor-list")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::MonitorList()
:
name{YType::str, "name"},
descr{YType::str, "descr"}
,
rsrecordpatt_items(std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems>())
, rscollectoratt_items(std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RscollectorAttItems>())
, rswatchlistatt_items(std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RswatchlistAttItems>())
, rsdroplistatt_items(std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsdroplistAttItems>())
{
rsrecordpatt_items->parent = this;
rscollectoratt_items->parent = this;
rswatchlistatt_items->parent = this;
rsdroplistatt_items->parent = this;
yang_name = "Monitor-list"; yang_parent_name = "monitor-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::~MonitorList()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::has_data() const
{
if (is_presence_container) return true;
return name.is_set
|| descr.is_set
|| (rsrecordpatt_items != nullptr && rsrecordpatt_items->has_data())
|| (rscollectoratt_items != nullptr && rscollectoratt_items->has_data())
|| (rswatchlistatt_items != nullptr && rswatchlistatt_items->has_data())
|| (rsdroplistatt_items != nullptr && rsdroplistatt_items->has_data());
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(name.yfilter)
|| ydk::is_set(descr.yfilter)
|| (rsrecordpatt_items != nullptr && rsrecordpatt_items->has_operation())
|| (rscollectoratt_items != nullptr && rscollectoratt_items->has_operation())
|| (rswatchlistatt_items != nullptr && rswatchlistatt_items->has_operation())
|| (rsdroplistatt_items != nullptr && rsdroplistatt_items->has_operation());
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "Monitor-list";
ADD_KEY_TOKEN(name, "name");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (name.is_set || is_set(name.yfilter)) leaf_name_data.push_back(name.get_name_leafdata());
if (descr.is_set || is_set(descr.yfilter)) leaf_name_data.push_back(descr.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "rsrecordPAtt-items")
{
if(rsrecordpatt_items == nullptr)
{
rsrecordpatt_items = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems>();
}
return rsrecordpatt_items;
}
if(child_yang_name == "rscollectorAtt-items")
{
if(rscollectoratt_items == nullptr)
{
rscollectoratt_items = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RscollectorAttItems>();
}
return rscollectoratt_items;
}
if(child_yang_name == "rswatchlistAtt-items")
{
if(rswatchlistatt_items == nullptr)
{
rswatchlistatt_items = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RswatchlistAttItems>();
}
return rswatchlistatt_items;
}
if(child_yang_name == "rsdroplistAtt-items")
{
if(rsdroplistatt_items == nullptr)
{
rsdroplistatt_items = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsdroplistAttItems>();
}
return rsdroplistatt_items;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
if(rsrecordpatt_items != nullptr)
{
_children["rsrecordPAtt-items"] = rsrecordpatt_items;
}
if(rscollectoratt_items != nullptr)
{
_children["rscollectorAtt-items"] = rscollectoratt_items;
}
if(rswatchlistatt_items != nullptr)
{
_children["rswatchlistAtt-items"] = rswatchlistatt_items;
}
if(rsdroplistatt_items != nullptr)
{
_children["rsdroplistAtt-items"] = rsdroplistatt_items;
}
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "name")
{
name = value;
name.value_namespace = name_space;
name.value_namespace_prefix = name_space_prefix;
}
if(value_path == "descr")
{
descr = value;
descr.value_namespace = name_space;
descr.value_namespace_prefix = name_space_prefix;
}
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "name")
{
name.yfilter = yfilter;
}
if(value_path == "descr")
{
descr.yfilter = yfilter;
}
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "rsrecordPAtt-items" || name == "rscollectorAtt-items" || name == "rswatchlistAtt-items" || name == "rsdroplistAtt-items" || name == "name" || name == "descr")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems::RsrecordPAttItems()
:
tdn{YType::str, "tDn"}
{
yang_name = "rsrecordPAtt-items"; yang_parent_name = "Monitor-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems::~RsrecordPAttItems()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems::has_data() const
{
if (is_presence_container) return true;
return tdn.is_set;
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(tdn.yfilter);
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "rsrecordPAtt-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (tdn.is_set || is_set(tdn.yfilter)) leaf_name_data.push_back(tdn.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "tDn")
{
tdn = value;
tdn.value_namespace = name_space;
tdn.value_namespace_prefix = name_space_prefix;
}
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "tDn")
{
tdn.yfilter = yfilter;
}
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsrecordPAttItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "tDn")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RscollectorAttItems::RscollectorAttItems()
:
rscollectoratt_list(this, {"tdn"})
{
yang_name = "rscollectorAtt-items"; yang_parent_name = "Monitor-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RscollectorAttItems::~RscollectorAttItems()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RscollectorAttItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<rscollectoratt_list.len(); index++)
{
if(rscollectoratt_list[index]->has_data())
return true;
}
return false;
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RscollectorAttItems::has_operation() const
{
for (std::size_t index=0; index<rscollectoratt_list.len(); index++)
{
if(rscollectoratt_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RscollectorAttItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "rscollectorAtt-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RscollectorAttItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RscollectorAttItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "RsCollectorAtt-list")
{
auto ent_ = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RscollectorAttItems::RsCollectorAttList>();
ent_->parent = this;
rscollectoratt_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RscollectorAttItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : rscollectoratt_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RscollectorAttItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RscollectorAttItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RscollectorAttItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "RsCollectorAtt-list")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RscollectorAttItems::RsCollectorAttList::RsCollectorAttList()
:
tdn{YType::str, "tDn"}
{
yang_name = "RsCollectorAtt-list"; yang_parent_name = "rscollectorAtt-items"; is_top_level_class = false; has_list_ancestor = true;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RscollectorAttItems::RsCollectorAttList::~RsCollectorAttList()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RscollectorAttItems::RsCollectorAttList::has_data() const
{
if (is_presence_container) return true;
return tdn.is_set;
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RscollectorAttItems::RsCollectorAttList::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(tdn.yfilter);
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RscollectorAttItems::RsCollectorAttList::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "RsCollectorAtt-list";
ADD_KEY_TOKEN(tdn, "tDn");
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RscollectorAttItems::RsCollectorAttList::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (tdn.is_set || is_set(tdn.yfilter)) leaf_name_data.push_back(tdn.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RscollectorAttItems::RsCollectorAttList::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RscollectorAttItems::RsCollectorAttList::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RscollectorAttItems::RsCollectorAttList::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "tDn")
{
tdn = value;
tdn.value_namespace = name_space;
tdn.value_namespace_prefix = name_space_prefix;
}
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RscollectorAttItems::RsCollectorAttList::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "tDn")
{
tdn.yfilter = yfilter;
}
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RscollectorAttItems::RsCollectorAttList::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "tDn")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RswatchlistAttItems::RswatchlistAttItems()
:
tdn{YType::str, "tDn"}
{
yang_name = "rswatchlistAtt-items"; yang_parent_name = "Monitor-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RswatchlistAttItems::~RswatchlistAttItems()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RswatchlistAttItems::has_data() const
{
if (is_presence_container) return true;
return tdn.is_set;
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RswatchlistAttItems::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(tdn.yfilter);
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RswatchlistAttItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "rswatchlistAtt-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RswatchlistAttItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (tdn.is_set || is_set(tdn.yfilter)) leaf_name_data.push_back(tdn.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RswatchlistAttItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RswatchlistAttItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RswatchlistAttItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "tDn")
{
tdn = value;
tdn.value_namespace = name_space;
tdn.value_namespace_prefix = name_space_prefix;
}
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RswatchlistAttItems::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "tDn")
{
tdn.yfilter = yfilter;
}
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RswatchlistAttItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "tDn")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsdroplistAttItems::RsdroplistAttItems()
:
tdn{YType::str, "tDn"}
{
yang_name = "rsdroplistAtt-items"; yang_parent_name = "Monitor-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsdroplistAttItems::~RsdroplistAttItems()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsdroplistAttItems::has_data() const
{
if (is_presence_container) return true;
return tdn.is_set;
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsdroplistAttItems::has_operation() const
{
return is_set(yfilter)
|| ydk::is_set(tdn.yfilter);
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsdroplistAttItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "rsdroplistAtt-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsdroplistAttItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
if (tdn.is_set || is_set(tdn.yfilter)) leaf_name_data.push_back(tdn.get_name_leafdata());
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsdroplistAttItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsdroplistAttItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsdroplistAttItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
if(value_path == "tDn")
{
tdn = value;
tdn.value_namespace = name_space;
tdn.value_namespace_prefix = name_space_prefix;
}
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsdroplistAttItems::set_filter(const std::string & value_path, YFilter yfilter)
{
if(value_path == "tDn")
{
tdn.yfilter = yfilter;
}
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::MonitorItems::MonitorList::RsdroplistAttItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "tDn")
return true;
return false;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FwdinstItems::FwdinstItems()
:
fwdinsttarget_list(this, {"id"})
{
yang_name = "fwdinst-items"; yang_parent_name = "Inst-list"; is_top_level_class = false; has_list_ancestor = true;
}
System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FwdinstItems::~FwdinstItems()
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FwdinstItems::has_data() const
{
if (is_presence_container) return true;
for (std::size_t index=0; index<fwdinsttarget_list.len(); index++)
{
if(fwdinsttarget_list[index]->has_data())
return true;
}
return false;
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FwdinstItems::has_operation() const
{
for (std::size_t index=0; index<fwdinsttarget_list.len(); index++)
{
if(fwdinsttarget_list[index]->has_operation())
return true;
}
return is_set(yfilter);
}
std::string System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FwdinstItems::get_segment_path() const
{
std::ostringstream path_buffer;
path_buffer << "fwdinst-items";
return path_buffer.str();
}
std::vector<std::pair<std::string, LeafData> > System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FwdinstItems::get_name_leaf_data() const
{
std::vector<std::pair<std::string, LeafData> > leaf_name_data {};
return leaf_name_data;
}
std::shared_ptr<ydk::Entity> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FwdinstItems::get_child_by_name(const std::string & child_yang_name, const std::string & segment_path)
{
if(child_yang_name == "FwdInstTarget-list")
{
auto ent_ = std::make_shared<System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FwdinstItems::FwdInstTargetList>();
ent_->parent = this;
fwdinsttarget_list.append(ent_);
return ent_;
}
return nullptr;
}
std::map<std::string, std::shared_ptr<ydk::Entity>> System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FwdinstItems::get_children() const
{
std::map<std::string, std::shared_ptr<ydk::Entity>> _children{};
char count_=0;
count_ = 0;
for (auto ent_ : fwdinsttarget_list.entities())
{
if(_children.find(ent_->get_segment_path()) == _children.end())
_children[ent_->get_segment_path()] = ent_;
else
_children[ent_->get_segment_path()+count_++] = ent_;
}
return _children;
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FwdinstItems::set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix)
{
}
void System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FwdinstItems::set_filter(const std::string & value_path, YFilter yfilter)
{
}
bool System::HwtelemetryItems::InbandtelemetryItems::InstItems::InstList::FwdinstItems::has_leaf_or_child_of_name(const std::string & name) const
{
if(name == "FwdInstTarget-list")
return true;
return false;
}
}
}
| 33.284387 | 1,219 | 0.689136 | [
"vector"
] |
c5162c56bcafa884e37bdb95e1798f4a1c402bed | 4,979 | cpp | C++ | JoJoEngine/ImporterMesh.cpp | joeyGumer/JoJoEngine | 15289b1f87e5c79a51ff04a703977abf9dd84886 | [
"MIT"
] | null | null | null | JoJoEngine/ImporterMesh.cpp | joeyGumer/JoJoEngine | 15289b1f87e5c79a51ff04a703977abf9dd84886 | [
"MIT"
] | null | null | null | JoJoEngine/ImporterMesh.cpp | joeyGumer/JoJoEngine | 15289b1f87e5c79a51ff04a703977abf9dd84886 | [
"MIT"
] | null | null | null | #include "ImporterMesh.h"
#include "Application.h"
#include "ModuleFileSystem.h"
#include "ComponentMesh.h"
#include "Assimp/include/cimport.h"
#include "Assimp/include/scene.h"
#include "Assimp/include/postprocess.h"
#include "Assimp/include/cfileio.h"
bool ImporterMesh::Import(aiMesh* ai_mesh ,std::string& output_filename)
{
Mesh mesh;
LoadAssimpMesh(&mesh, ai_mesh);
SaveAssimpMesh(mesh, output_filename);
return true;
}
Mesh* ImporterMesh::Load(const char* filename)
{
Mesh* mesh = new Mesh();
char* buffer;
App->fs->Load(filename, &buffer);
char* cursor = buffer;
// amount of indices / vertices / normals / texture_coords / colors
uint ranges[5];
uint bytes = sizeof(ranges);
memcpy(ranges, cursor, bytes);
//Data groups quantity
mesh->num_indices = ranges[0];
mesh->num_vertices = ranges[1];
mesh->num_normals = ranges[2];
mesh->num_texture_UVs = ranges[3];
mesh->num_colors = ranges[4];
//Data groups
uint vert_size = mesh->num_vertices * 3 * sizeof(float);
uint ind_size = mesh->num_indices * sizeof(uint);
uint norm_size = mesh->num_normals * 3 * sizeof(float);
uint uv_size = mesh->num_texture_UVs * 2 * sizeof(float);
uint color_size = mesh->num_colors * 3 * sizeof(uint);
//Indices
cursor += bytes;
bytes = ind_size;
mesh->indices = new uint[ind_size];
memcpy(mesh->indices, cursor, bytes);
//Vertices
cursor += bytes;
bytes = vert_size;
mesh->vertices = new float[vert_size];
memcpy(mesh->vertices, cursor, bytes);
//Normals
cursor += bytes;
bytes = norm_size;
mesh->normals = new float[norm_size];
memcpy(mesh->normals, cursor, bytes);
//UVs
cursor += bytes;
bytes = uv_size;
mesh->texture_UVs = new float[uv_size];
memcpy(mesh->texture_UVs, cursor, bytes);
//Colors
cursor += bytes;
bytes = color_size;
mesh->colors = new uint[color_size];
memcpy(mesh->colors, cursor, bytes);
return mesh;
}
bool ImporterMesh::LoadAssimpMesh(Mesh* m, aiMesh* new_mesh)
{
//Copy vertices
m->num_vertices = new_mesh->mNumVertices;
m->vertices = new float[m->num_vertices * 3];
memcpy(m->vertices, new_mesh->mVertices, sizeof(float) * m->num_vertices * 3);
LOG("New mesh with %d vertices", m->num_vertices);
//Copy faces/indices
if (new_mesh->HasFaces())
{
m->num_indices = new_mesh->mNumFaces * 3;
m->indices = new uint[m->num_indices]; // assume each face is a triangle
for (uint i = 0; i < new_mesh->mNumFaces; i++)
{
if (new_mesh->mFaces[i].mNumIndices != 3)
{
LOG("WARNING, geometry face with != 3 indices!");
}
else//NOTE: is memcopy really necesary instead of a for?
memcpy(&m->indices[i * 3], new_mesh->mFaces[i].mIndices, 3 * sizeof(uint));
}
LOG("New mesh with %d faces", new_mesh->mNumFaces);
}
//normals
if (new_mesh->HasNormals())
{
m->num_normals = new_mesh->mNumVertices;
m->normals = new float[m->num_normals * 3];
memcpy(m->normals, new_mesh->mNormals, sizeof(float) * m->num_vertices * 3);
LOG("New mesh with %d normals", m->num_vertices);
}
//Copy textures (only one set of UVs)
if (new_mesh->HasTextureCoords(0))
{
m->num_texture_UVs = new_mesh->mNumVertices;
m->texture_UVs = new float[m->num_texture_UVs * 2];
for (int i = 0; i < m->num_texture_UVs; i++)
{
memcpy(&m->texture_UVs[i * 2], &new_mesh->mTextureCoords[0][i].x, sizeof(float));
memcpy(&m->texture_UVs[(i * 2) + 1], &new_mesh->mTextureCoords[0][i].y, sizeof(float));
//m->texture_UVs[i * 2] = new_mesh->mTextureCoords[0][i].x;
//m->texture_UVs[(i * 2) + 1] = new_mesh->mTextureCoords[0][i].y;
}
LOG("New mesh with %d UVs", m->num_texture_UVs);
}
//Colors
return true;
}
bool ImporterMesh::SaveAssimpMesh(Mesh& mesh, std::string& output_filename)
{
bool ret = false;
//Ranges info as header for the file
uint ranges[5] = { mesh.num_indices, mesh.num_vertices, mesh.num_normals, mesh.num_texture_UVs , mesh.num_colors };
//All data groups size
uint vert_size = mesh.num_vertices * 3 * sizeof(float);
uint ind_size = mesh.num_indices * sizeof(uint);
uint norm_size = mesh.num_normals * 3 * sizeof(float);
uint uv_size = mesh.num_texture_UVs * 2 * sizeof(float);
uint color_size = mesh.num_colors * 3 * sizeof(uint);
//Total size of the buffer
uint size = vert_size + ind_size + norm_size + uv_size + sizeof(ranges);
char* data = new char[size];
char* cursor = data;
//Ranges info as header
uint bytes = sizeof(ranges);
memcpy(cursor, ranges, bytes);
//Indices
cursor += bytes;
bytes = ind_size;
memcpy(cursor, mesh.indices, bytes);
//Vertices
cursor += bytes;
bytes = vert_size;
memcpy(cursor, mesh.vertices, bytes);
//Normals
cursor += bytes;
bytes = norm_size;
memcpy(cursor, mesh.normals, bytes);
//UVs
cursor += bytes;
bytes = uv_size;
memcpy(cursor, mesh.texture_UVs, bytes);
//Colors
cursor += bytes;
bytes = color_size;
memcpy(cursor, mesh.colors, bytes);
ret = App->fs->SaveUnique("Mesh", data, size, LIBRARY_MESHES, "jme", output_filename);
RELEASE_ARRAY(data);
return ret;
} | 25.274112 | 117 | 0.686684 | [
"mesh",
"geometry"
] |
c51805dd8387ffc99cc8cea1cd0e227a395d3b78 | 8,909 | hpp | C++ | src/catkin_ws/src/modrob_simulation/modrob_simulation/src/gripper_integration.hpp | JakobThumm/safe_rl_manipulators | 1724aee2ec4cbbd8fecfbf1653991e182d4ca48b | [
"MIT"
] | null | null | null | src/catkin_ws/src/modrob_simulation/modrob_simulation/src/gripper_integration.hpp | JakobThumm/safe_rl_manipulators | 1724aee2ec4cbbd8fecfbf1653991e182d4ca48b | [
"MIT"
] | null | null | null | src/catkin_ws/src/modrob_simulation/modrob_simulation/src/gripper_integration.hpp | JakobThumm/safe_rl_manipulators | 1724aee2ec4cbbd8fecfbf1653991e182d4ca48b | [
"MIT"
] | null | null | null | //#include "GripperIntegration.h"
#include <string>
using namespace std;
std::string gripper_links(int last_joint, int robot_num)
{
std::string gripperLinkDes;
gripperLinkDes += "\n\t<link name=\"hand\">\n";
gripperLinkDes += "\t\t<inertial>\n";
gripperLinkDes += "\t\t\t<origin rpy=\"0.000000 0.000000 0.000000\" xyz=\"0.000000 0.000000 0.06250\"/>\n";
gripperLinkDes += "\t\t\t<mass value=\"" + std::to_string(0.184000) + "\"/>\n";
gripperLinkDes += "\t\t\t<inertia ixx=\"0.550000\" ixy=\"-0.000002\" ixz=\"-0.000003\" iyy=\"0.930000\" iyz=\"0.000005\" izz=\"0.550000\"/>\n";
gripperLinkDes += "\t\t</inertial>\n";
gripperLinkDes += "\t\t<visual>\n";
gripperLinkDes += "\t\t\t<origin rpy=\"0.000000 -0.000000 0.000000\" xyz=\"0.000000 0.000000 0.06250\"/>\n";
gripperLinkDes += "\t\t<geometry>\n";
gripperLinkDes += "\t\t\t\t<mesh filename=\"package://modrob_simulation/stl_files/E_Schimaneck.STL\"/>\n";
gripperLinkDes += "\t\t\t</geometry>\n";
gripperLinkDes += "\t\t</visual>\n";
gripperLinkDes += "\t\t<collision>\n";
gripperLinkDes += "\t\t\t<origin rpy=\"0.000000 -0.000000 0.000000\" xyz=\"0.002343744 0.000000 0.02165501\"/>\n";
gripperLinkDes += "\t\t\t<geometry>\n";
gripperLinkDes += "\t\t\t\t<box size=\"0.08531006 0.08485281 0.1616900\"/>\n";
gripperLinkDes += "\t\t\t</geometry>\n";
gripperLinkDes += "\t\t\t</collision>\n";
gripperLinkDes += "\t</link>\n\n";
gripperLinkDes += "\t<gazebo reference=\"hand\">\n";
gripperLinkDes += "\t\t<material>Gazebo/DarkGrey</material>\n";
gripperLinkDes += "\t</gazebo>\n\n";
gripperLinkDes += "\t<gazebo reference=\"hand\">\n";
gripperLinkDes += "\t\t<kp>" + std::to_string(0.000000) + "</kp>\n";
gripperLinkDes += "\t\t<kd>" + std::to_string(0.000000) + "</kd>\n";
gripperLinkDes += "\t\t<mu1>" + std::to_string(0.000000) + "</mu1>\n";
gripperLinkDes += "\t\t<mu2>" + std::to_string(0.000000) + "</mu2>\n";
gripperLinkDes += "\t</gazebo>\n\n";
// Add contact sensors
gripperLinkDes += "\t<gazebo reference=\"hand\">\n";
gripperLinkDes += "\t\t<sensor name=\"hand_collision_sensor\" type=\"contact\">\n";
gripperLinkDes += "\t\t\t<always_on>true</always_on>\n";
gripperLinkDes += "\t\t\t<plugin name=\"modrob_contact_plugin\" filename=\"libmodrob_contact_plugin.so\">\n";
gripperLinkDes += "\t\t\t\t<name_space>modrob" + std::to_string(robot_num) + "</name_space>\n\t\t\t</plugin>\n";
gripperLinkDes += "\t\t\t<contact>\n";
gripperLinkDes += "\t\t\t\t<collision>distal_link_of_joint" + std::to_string(last_joint) + "_NV_fixed_joint_lump__hand_collision</collision>\n";
gripperLinkDes += "\t\t\t</contact>\n\t\t</sensor>\n\t</gazebo>\n\n";
gripperLinkDes += "\t<link name=\"finger1\">\n";
gripperLinkDes += "\t\t<inertial>\n";
gripperLinkDes += "\t\t\t<origin rpy=\"0.00000 0.000000 0.0\" xyz=\"0.0 -0.000 0.001500\"/>\n";
gripperLinkDes += "\t\t\t<mass value=\"" + std::to_string(0.006944)+ "\"/>\n";
gripperLinkDes += "\t\t\t<inertia ixx=\"0.000004629\" ixy=\"0.000000486\" ixz=\"0.000000972\" iyy=\"0.000004157\" iyz=\"0.000001389\" izz=\"0.00000138\"/>\n";
gripperLinkDes += "\t\t</inertial>\n";
gripperLinkDes += "\t\t<visual>\n";
gripperLinkDes += "\t\t\t<origin rpy=\"0.000000 0.000000 0.0\" xyz=\"0.0 -0.000 0.001500\"/>\n";
gripperLinkDes += "\t\t\t<geometry>\n";
gripperLinkDes += "\t\t\t\t<mesh filename=\"package://modrob_simulation/stl_files/finger_Birne_Gimatic_m.STL\"/>\n";
gripperLinkDes += "\t\t\t</geometry>\n";
gripperLinkDes += "\t\t</visual>\n";
/*
gripperLinkDes += "\t\t<collision>\n";
gripperLinkDes += "\t\t\t<origin rpy=\"0.000000 0.000000 0.0\" xyz=\"0.0 -0.000 0.001500\"/>\n";
gripperLinkDes += "\t\t\t<geometry>\n";
gripperLinkDes += "\t\t\t\t<mesh filename=\"package://modrob_simulation/stl_files/finger_Birne_Gimatic_m.STL\"/>\n";
gripperLinkDes += "\t\t\t</geometry>\n";
gripperLinkDes += "\t\t</collision>\n";
*/
gripperLinkDes += "\t</link>\n\n";
gripperLinkDes += "\t<gazebo reference=\"finger1\">\n";
gripperLinkDes += "\t\t<material>Gazebo/Blue</material>\n";
gripperLinkDes += "\t</gazebo>\n\n";
gripperLinkDes += "\t<gazebo reference=\"finger1\">\n";
gripperLinkDes += "\t\t<kp>110.000000</kp>\n";
gripperLinkDes += "\t\t<kd>10.000000</kd>\n";
gripperLinkDes += "\t\t<mu1>100.00</mu1>\n"; // was 0.38
gripperLinkDes += "\t\t<mu2>100.00</mu2>\n"; // was 0.38
gripperLinkDes += "\t</gazebo>\n\n";
// Add contact sensors
/*
gripperLinkDes += "\t<gazebo reference=\"finger1\">\n";
gripperLinkDes += "\t\t<sensor name=\"finger1_collision_sensor\" type=\"contact\">\n";
gripperLinkDes += "\t\t\t<always_on>true</always_on>\n";
gripperLinkDes += "\t\t\t<plugin name=\"modrob_contact_plugin\" filename=\"libmodrob_contact_plugin.so\">\n";
gripperLinkDes += "\t\t\t\t<name_space>modrob" + std::to_string(robot_num) + "</name_space>\n\t\t\t</plugin>\n";
gripperLinkDes += "\t\t\t<contact>\n";
gripperLinkDes += "\t\t\t\t<collision>finger1_collision</collision>\n";
gripperLinkDes += "\t\t\t</contact>\n\t\t</sensor>\n\t</gazebo>\n\n";
*/
gripperLinkDes += "\t<link name=\"finger2\">\n";
gripperLinkDes += "\t\t<inertial>\n";
gripperLinkDes += "\t\t\t<origin rpy=\"0.00000 0.000000 0.0\" xyz=\"0.000 0.00 0.001500\"/>\n";
gripperLinkDes += "\t\t\t<mass value=\"0.006944\"/>\n";
gripperLinkDes += "\t\t\t<inertia ixx=\"0.000004629\" ixy=\"0.000000486\" ixz=\"0.000000972\" iyy=\"0.000004157\" iyz=\"0.000001389\" izz=\"0.00000138\"/>\n";
gripperLinkDes += "\t\t</inertial>\n";
gripperLinkDes += "\t\t<visual>\n";
gripperLinkDes += "\t\t\t<origin rpy=\"0.000000 0.000000 0.0\" xyz=\"0.000 0.00 0.001500\"/>\n";
gripperLinkDes += "\t\t\t<geometry>\n";
gripperLinkDes += "\t\t\t\t<mesh filename=\"package://modrob_simulation/stl_files/finger_Birne_Gimatic_m.STL\"/>\n";
gripperLinkDes += "\t\t\t</geometry>\n";
gripperLinkDes += "\t\t</visual>\n";
/*
gripperLinkDes += "\t\t<collision>\n";
gripperLinkDes += "\t\t\t<origin rpy=\"0.000000 0.000000 0.0\" xyz=\"0.000 0.00 0.001500\"/>\n";
gripperLinkDes += "\t\t\t<geometry>\n";
gripperLinkDes += "\t\t\t\t<mesh filename=\"package://modrob_simulation/stl_files/finger_Birne_Gimatic_m.STL\"/>\n";
gripperLinkDes += "\t\t\t</geometry>\n";
gripperLinkDes += "\t\t</collision>\n";
*/
gripperLinkDes += "\t</link>\n\n";
gripperLinkDes += "\t<gazebo reference=\"finger2\">\n";
gripperLinkDes += "\t\t<material>Gazebo/Blue</material>\n";
gripperLinkDes += "\t</gazebo>\n\n";
gripperLinkDes += "\t<gazebo reference=\"finger2\">\n";
gripperLinkDes += "\t\t<kp>110.000000</kp>\n";
gripperLinkDes += "\t\t<kd>10.000000</kd>\n";
gripperLinkDes += "\t\t<mu1>100.00</mu1>\n"; // was 0.38
gripperLinkDes += "\t\t<mu2>100.00</mu2>\n"; // was 0.38
gripperLinkDes += "\t</gazebo>\n\n";
// Add contact sensors
/*
gripperLinkDes += "\t<gazebo reference=\"finger2\">\n";
gripperLinkDes += "\t\t<sensor name=\"finger2_collision_sensor\" type=\"contact\">\n";
gripperLinkDes += "\t\t\t<always_on>true</always_on>\n";
gripperLinkDes += "\t\t\t<plugin name=\"modrob_contact_plugin\" filename=\"libmodrob_contact_plugin.so\">\n";
gripperLinkDes += "\t\t\t\t<name_space>modrob" + std::to_string(robot_num) + "</name_space>\n\t\t\t</plugin>\n";
gripperLinkDes += "\t\t\t<contact>\n";
gripperLinkDes += "\t\t\t\t<collision>finger2_collision</collision>\n";
gripperLinkDes += "\t\t\t</contact>\n\t\t</sensor>\n\t</gazebo>\n\n";
*/
return gripperLinkDes;
}
std::string gripper_joints()
{
std::string gripperJointDes;
gripperJointDes += "\n\t<joint name=\"fixed_gripper_to_arm_link\" type=\"fixed\">\n";
gripperJointDes += "\t\t<origin rpy=\"0.000000 0.000000 0.000000\" xyz=\"0.000000 0.000000 0.059775\"/>\n";
gripperJointDes += "\t\t<parent link=\"tool_dummy\"/>\n";
gripperJointDes += "\t\t<child link=\"hand\"/>\n";
gripperJointDes += "\t</joint>\n\n";
gripperJointDes += "\t<joint name=\"hand_to_finger1\" type=\"prismatic\">\n";
gripperJointDes += "\t\t<origin rpy=\"0.000000 0.000000 +1.570796327\" xyz=\"0.00700 -0.03200 0.06200\"/>\n";
gripperJointDes += "\t\t<parent link=\"hand\"/>\n";
gripperJointDes += "\t\t<child link=\"finger1\"/>\n";
gripperJointDes += "\t\t<dynamics damping=\"12.590000\" friction=\"0.400000\"/>\n";
gripperJointDes += "\t\t<limit effort=\"3.0\" lower=\"-0.0\" upper=\"0.0100\" velocity=\"0.5\"/> <!-- was 0.38 and 0.0 -->\n";
gripperJointDes += "\t</joint>\n\n";
gripperJointDes += "\t<joint name=\"hand_to_finger2\" type=\"prismatic\">\n";
gripperJointDes += "\t\t<origin rpy=\"0.000000 0.000000 -1.570796327\" xyz=\"-0.00700 0.0620 0.06200\"/>\n";
gripperJointDes += "\t\t<parent link=\"hand\"/>\n";
gripperJointDes += "\t\t<child link=\"finger2\"/>\n";
gripperJointDes += "\t\t<dynamics damping=\"12.590000\" friction=\"0.400000\"/>\n";
gripperJointDes += "\t\t<limit effort=\"3.0\" lower=\"0.03\" upper=\"0.04\" velocity=\"0.5\"/>\n";
gripperJointDes += "\t</joint>\n\n";
return gripperJointDes;
} | 57.477419 | 159 | 0.647884 | [
"mesh",
"geometry"
] |
c5246042ae9680fb9a9d6dcfda5f0612bcf18325 | 7,189 | cpp | C++ | Engine Round 2/MeshImporter.cpp | dafral/Round2_Engine | 23c0b3a5661fa4902acdd7e953f8f168a7f87922 | [
"MIT"
] | 1 | 2019-04-28T12:08:54.000Z | 2019-04-28T12:08:54.000Z | Engine Round 2/MeshImporter.cpp | dafral/Round2_Engine | 23c0b3a5661fa4902acdd7e953f8f168a7f87922 | [
"MIT"
] | null | null | null | Engine Round 2/MeshImporter.cpp | dafral/Round2_Engine | 23c0b3a5661fa4902acdd7e953f8f168a7f87922 | [
"MIT"
] | null | null | null | #include "Application.h"
#include "ModuleRenderer3D.h"
#include "MeshImporter.h"
#include "Component_Material.h"
#include "Component_Transform.h"
#include "glew/include/glew.h"
#include "SDL/include/SDL_opengl.h"
#include "Assimp/include/cimport.h"
#include "Assimp/include/scene.h"
#include "Assimp/include/postprocess.h"
#include "Assimp/include/cfileio.h"
#pragma comment (lib, "Assimp/libx86/assimp.lib")
MeshImporter::MeshImporter(Application* app, bool start_enabled) : Module(app, start_enabled)
{}
// Destructor
MeshImporter::~MeshImporter()
{}
void MeshImporter::ImportScene(const char* full_path, const char* file_name)
{
// Creating the parent (empty game object)
GameObject* empty_go = App->scene->CreateGameObject(file_name, App->scene->root_node);
// Loading scene
const aiScene* scene = aiImportFile(full_path, aiProcessPreset_TargetRealtime_MaxQuality);
aiNode* node = scene->mRootNode;
if (scene != nullptr && scene->HasMeshes())
{
ImportMesh(full_path, empty_go, scene, node);
CONSOLELOG("Scene %s loaded.", full_path);
}
else
{
CONSOLELOG("Error loading scene %s.", full_path);
}
// Releasing scene
aiReleaseImport(scene);
}
void MeshImporter::ImportMesh(const char* full_path, GameObject* parent, const aiScene* scene, aiNode* node)
{
if (node->mNumMeshes <= 0)
{
// Recursion
for (int i = 0; i < node->mNumChildren; i++)
ImportMesh(full_path, parent, scene, node->mChildren[i]);
}
else
{
for (int i = 0; i < node->mNumMeshes; i++)
{
aiMesh* new_mesh = scene->mMeshes[node->mMeshes[i]];
// Creating a Game Object (child of parent) for each mesh.
GameObject* go = App->scene->CreateGameObject(node->mName.C_Str(), parent);
Component_Mesh* cmesh = App->renderer3D->CreateComponentMesh(go);
// Setting values cmesh
cmesh->SetFaces(new_mesh);
cmesh->SetUVs(new_mesh);
// Changing transform
Component_Transform* trans = (Component_Transform*)go->FindComponentWithType(TRANSFORM);
if (node != nullptr)
{
aiVector3D translation;
aiVector3D scaling;
aiQuaternion rotation;
node->mTransformation.Decompose(scaling, rotation, translation);
float3 pos(translation.x, translation.y, translation.z);
float3 scale(scaling.x, scaling.y, scaling.z);
Quat rot(rotation.x, rotation.y, rotation.z, rotation.w);
trans->SetPosition(pos);
trans->SetRotation(rot);
trans->SetScale(scale);
}
// Load Texture and color
if (scene->HasMaterials())
{
// Material -------------------------------------------------
aiMaterial* mat = scene->mMaterials[new_mesh->mMaterialIndex];
aiString texture_name;
mat->GetTexture(aiTextureType_DIFFUSE, 0, &texture_name);
if (texture_name.length > 0)
{
std::string directory = App->filesystem->GetDirectory(full_path);
std::string file_name = App->filesystem->GetNameWithoutPath(texture_name.C_Str(), false);
directory.append(file_name.c_str());
App->material_importer->Import(directory.c_str(), go);
}
// Color ----------------------------------------------------
aiColor3D my_color;
mat->Get(AI_MATKEY_COLOR_DIFFUSE, my_color);
cmesh->SetColor({ my_color[0], my_color[1], my_color[2] });
}
// Check if we already loaded this mesh in memory
Component_Mesh* aux = App->renderer3D->IsMeshLoaded(cmesh);
if (App->renderer3D->GetMeshesVector()->size() == 1 || aux == nullptr) cmesh->LoadBuffers(new_mesh);
else cmesh->SetIDs(aux);
// Import mesh HERE
App->mesh_importer->Save(App->filesystem->library_mesh_path.c_str(), cmesh);
// Recursion
for (int i = 0; i < node->mNumChildren; i++)
ImportMesh(full_path, go, scene, node->mChildren[i]);
}
}
}
Component_Mesh* MeshImporter::Load(const char * filepath)
{
//Open the file and get the size
FILE* file = fopen(filepath, "rb");
fseek(file, 0, SEEK_END);
uint size = ftell(file);
rewind(file);
// Create a buffer to get the data of the file
char* buffer = new char[size];
char* cursor = buffer;
// Read the file and close it
fread(buffer, sizeof(char), size, file);
fclose(file);
// Copy the ranges
uint ranges[3]; // ranges[0] = Vertices, ranges[1] = Indices, ranges[2] = Uvs
uint bytes = sizeof(ranges);
memcpy(ranges, cursor, bytes);
cursor += bytes;
//Copy the ids
uint ids[3]; // ids[0] = Vertices, ids[1] = Indices, ids[2] = Uvs
bytes = sizeof(ids);
memcpy(ids, cursor, bytes);
cursor += bytes;
// Store indices
uint* indices = new uint[ranges[1]];
bytes = sizeof(uint) * ranges[1];
memcpy(indices, cursor, bytes);
cursor += bytes;
// Store vertices
float* vertices = new float[ranges[0] * 3];
bytes = sizeof(float) * ranges[0] * 3;
memcpy(vertices, cursor, bytes);
cursor += bytes;
// Store UVs
float* uvs = new float[ranges[2] * 3];
bytes = sizeof(float) * ranges[2] * 3;
memcpy(uvs, cursor, bytes);
cursor += bytes;
float color[3];
bytes = sizeof(color);
memcpy(color, cursor, bytes);
cursor += bytes;
// Create mesh --------------
Component_Mesh* new_mesh = new Component_Mesh;
new_mesh->SetFaces(vertices, ranges[0], indices, ranges[1]);
new_mesh->SetUvs(uvs, ranges[2]);
new_mesh->SetIDs(ids[0], ids[1], ids[2]);
new_mesh->SetColor(float3(color[0], color[1], color[2]));
//new_mesh->LoadToMemory();
App->renderer3D->GetMeshesVector()->push_back(new_mesh);
CONSOLELOG("Loading mesh with %d vertices", new_mesh->GetNumVertices());
CONSOLELOG("Loading mesh with %d indices", new_mesh->GetNumIndices());
RELEASE_ARRAY(indices);
RELEASE_ARRAY(vertices);
RELEASE_ARRAY(uvs);
return new_mesh;
}
bool MeshImporter::Save(const char * path, Component_Mesh* mesh)
{
bool ret = true;
std::string name = std::to_string(mesh->GetUniqueID()).c_str();
uint ranges[3] = { mesh->GetNumVertices(), mesh->GetNumIndices(), mesh->GetNumUVs() };
uint ids[3] = { mesh->GetIdVertices(), mesh->GetIdIndices(), mesh->GetIdUVs() };
float color[3] = { mesh->GetColor().x, mesh->GetColor().y, mesh->GetColor().z };
uint size = sizeof(double) + sizeof(ranges) + sizeof(ids) +
sizeof(uint) * mesh->GetNumIndices() +
sizeof(float) * mesh->GetNumVertices() * 3 +
sizeof(float) * mesh->GetNumUVs() * 3 +
sizeof(color);
// Allocate data
char* data = new char[size];
char* cursor = data;
// Store ranges
uint bytes = sizeof(ranges);
memcpy(cursor, ranges, bytes);
cursor += bytes;
//Store ids
bytes = sizeof(ids);
memcpy(cursor, ids, bytes);
cursor += bytes;
// Store indices
bytes = sizeof(uint) * mesh->GetNumIndices();
memcpy(cursor, mesh->GetIndices(), bytes);
cursor += bytes;
// Store vertices
bytes = sizeof(float) * mesh->GetNumVertices() * 3;
memcpy(cursor, mesh->GetVertices(), bytes);
cursor += bytes;
// Store UVs
bytes = sizeof(float) * mesh->GetNumUVs() * 3;
memcpy(cursor, mesh->GetTexCoords(), bytes);
cursor += bytes;
bytes = sizeof(color);
memcpy(cursor, color, bytes);
//fopen
if (App->filesystem->SaveFile(path, data, name.c_str(), "mymesh", size) == false)
{
return false;
}
CONSOLELOG("New mesh saved with %d vertices", ranges[0]);
CONSOLELOG("New mesh saved with %d indices", ranges[1]);
RELEASE_ARRAY(data);
return ret;
}
| 27.231061 | 108 | 0.671582 | [
"mesh",
"object",
"transform"
] |
c5257d6e0f66ed0baa56a9d2279876ae38670580 | 1,669 | hpp | C++ | include/cex/basicauth.hpp | patrickjane/libcex | 3136fa693353bd6a1298370fed620a47eede81fe | [
"MIT"
] | 13 | 2019-03-11T11:18:36.000Z | 2021-11-15T15:03:13.000Z | include/cex/basicauth.hpp | patrickjane/libcex | 3136fa693353bd6a1298370fed620a47eede81fe | [
"MIT"
] | 2 | 2021-02-26T21:30:24.000Z | 2022-03-21T12:16:41.000Z | include/cex/basicauth.hpp | patrickjane/libcex | 3136fa693353bd6a1298370fed620a47eede81fe | [
"MIT"
] | 5 | 2019-07-19T10:51:53.000Z | 2022-01-05T10:43:34.000Z | //*************************************************************************
// File basicauth.hpp
// Date 10.09.2018 - #1
// Copyright (c) 2018-2018 by Patrick Fial
//-------------------------------------------------------------------------
// HTTP basic auth functions
// Middleware that sets username/password from HTTP basic authentication header
//*************************************************************************
#ifndef __BASICAUTH_HPP__
#define __BASICAUTH_HPP__
/*! \file basicauth.hpp
\brief Basic auth middleware function
Tries to extract username and password information from the `Authorization` HTTP header. Only allows
to retrieve `Basic` authentication information.
Upon success (e.g. a `Authorization` header is present and its contents could be extracted) stores the
values in the Request object's properties `basicUsername` and `basicPassword`.
*/
//***************************************************************************
// includes
//***************************************************************************
#include <string>
#include <core.hpp>
namespace cex
{
//**************************************************************************
// Middlewares
//***************************************************************************
// basicAuth
//***************************************************************************
/*! \public
\brief Creates a middleware that extracts username and password information from the `Authorization` HTTP header
*/
MiddlewareFunction basicAuth();
//***************************************************************************
} // namespace cex
#endif // __BASICAUTH_HPP_
| 34.061224 | 114 | 0.443379 | [
"object"
] |
c5329afaf837f710615e920237d1eef34e66dd53 | 5,647 | cpp | C++ | backend/src/device.cpp | JanConGitHub/wakeit | a22cc8eed3eecdc1c576e94c5a0c29ef2dfdb0c0 | [
"MIT"
] | 1 | 2015-05-15T11:01:31.000Z | 2015-05-15T11:01:31.000Z | backend/src/device.cpp | JanConGitHub/wakeit | a22cc8eed3eecdc1c576e94c5a0c29ef2dfdb0c0 | [
"MIT"
] | 6 | 2015-05-11T17:12:27.000Z | 2016-11-30T18:34:36.000Z | backend/src/device.cpp | JanConGitHub/wakeit | a22cc8eed3eecdc1c576e94c5a0c29ef2dfdb0c0 | [
"MIT"
] | 3 | 2015-07-24T18:05:08.000Z | 2019-06-21T01:28:33.000Z | /**
* The MIT License (MIT)
*
* Copyright (c) 2015 Nathan Osman
*
* 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 <QNetworkInterface>
#include "device.h"
// TODO: make these configurable settings
// Number of packets to send and the delay (in MS) between packets
const int PacketCount = 4;
const int PacketDelay = 500;
Device::Device()
: mHostLookup(-1)
{
// Prepare the timer
connect(&mTimer, SIGNAL(timeout()), this, SLOT(onTimeout()));
mTimer.setInterval(PacketDelay);
mTimer.setSingleShot(true);
}
void Device::wake()
{
// If we're busy, ignore the request
if(isBusy()) {
qWarning("Device is busy");
return;
}
// Reset the number of packets remaining to be sent
mPacketsRemaining = PacketCount;
// If this packet is to be sent locally, then don't bother doing anything
// with the address, since we are using local addresses anyway
if(mLocal) {
onTimeout();
} else {
mAddress.setAddress(mHost);
// If the address is invalid, it's probably a hostname - look it up
// Otherwise, jump immediately to the timeout slot
if(mAddress.isNull()) {
mHostLookup = QHostInfo::lookupHost(mHost, this, SLOT(onLookupHost(QHostInfo)));
} else {
onTimeout();
}
}
}
void Device::cancel()
{
if(isBusy()) {
// We are either waiting for a lookup or timer
if(mHostLookup != -1) {
QHostInfo::abortHostLookup(mHostLookup);
} else {
mTimer.stop();
}
emit finished();
}
}
bool Device::fromJson(const QJsonObject &object)
{
// Make sure none of the fields are missing
if(!object.contains("title") ||
!object.contains("local") ||
!object.contains("host") ||
!object.contains("mac") ||
!object.contains("port")) {
return false;
}
// TODO: verify the data
mTitle = object.value("title").toString();
mLocal = object.value("local").toBool();
mHost = object.value("host").toString();
mMac = object.value("mac").toString();
if (object.value("port").toInt() == 0) {
mPort = 9;
}
else {
mPort = object.value("port").toInt();
};
return true;
}
QJsonObject Device::toJson()
{
QJsonObject object;
object.insert("title", mTitle);
object.insert("local", mLocal);
object.insert("host", mHost);
object.insert("mac", mMac);
object.insert("port", mPort);
return object;
}
void Device::onLookupHost(const QHostInfo &info)
{
mHostLookup = -1;
// Check to ensure that there was no error performing the lookup
if(info.error() == QHostInfo::NoError) {
// Grab the first address and jump to the timeout slot
mAddress = info.addresses().first();
onTimeout();
} else {
// Emit the error and indicate that the wake process finished
emit error(info.errorString());
emit finished();
}
}
void Device::onTimeout()
{
QByteArray packet = buildPacket();
if(mLocal) {
// For local broadcasts, enumerate all network interfaces and send the
// packet on all of the ones that have a valid broadcast address
foreach(QNetworkInterface interface, QNetworkInterface::allInterfaces()) {
if(interface.flags() & QNetworkInterface::CanBroadcast) {
foreach(QNetworkAddressEntry entry, interface.addressEntries()) {
if(!entry.broadcast().isNull()) {
// TODO: failure is ignored here
mSocket.writeDatagram(packet, entry.broadcast(), mPort);
}
}
}
}
} else {
// Write the packet to the socket
if(mSocket.writeDatagram(packet, mAddress, mPort) == -1) {
emit error(mSocket.errorString());
emit finished();
return;
}
}
// Decrement the number of remaining packets
--mPacketsRemaining;
// Check to see if the last packet was sent
if(mPacketsRemaining) {
mTimer.start();
} else {
emit finished();
}
}
QByteArray Device::buildPacket()
{
// The first six bytes contain the value 255
QByteArray packet(6, '\xff');
// Parse the MAC address by interpreting the data as hexadecimal
QByteArray macAddress = QByteArray::fromHex(mMac.toUtf8());
// Append sixteen repetitions of the MAC address
for(int i = 0; i < 16; ++i) {
packet.append(macAddress);
}
return packet;
}
| 27.019139 | 92 | 0.624402 | [
"object"
] |
c537f772a41fcceb2026197d7a4c3acc058dde8c | 34,238 | cpp | C++ | src/chrono_vehicle/wheeled_vehicle/test_rig/ChSuspensionTestRig.cpp | lucasw/chrono | e79d8c761c718ecb4c796725cff37026f357da8c | [
"BSD-3-Clause"
] | null | null | null | src/chrono_vehicle/wheeled_vehicle/test_rig/ChSuspensionTestRig.cpp | lucasw/chrono | e79d8c761c718ecb4c796725cff37026f357da8c | [
"BSD-3-Clause"
] | null | null | null | src/chrono_vehicle/wheeled_vehicle/test_rig/ChSuspensionTestRig.cpp | lucasw/chrono | e79d8c761c718ecb4c796725cff37026f357da8c | [
"BSD-3-Clause"
] | null | null | null | // =============================================================================
// PROJECT CHRONO - http://projectchrono.org
//
// Copyright (c) 2014 projectchrono.org
// All rights reserved.
//
// Use of this source code is governed by a BSD-style license that can be found
// in the LICENSE file at the top level of the distribution and at
// http://projectchrono.org/license-chrono.txt.
//
// =============================================================================
// Authors: Radu Serban
// =============================================================================
//
// Implementation of a suspension testing mechanism for a wheeld vehicle.
//
// The reference frame follows the ISO standard: Z-axis up, X-axis
// pointing forward, and Y-axis towards the left of the vehicle.
//
// =============================================================================
#include "chrono_vehicle/wheeled_vehicle/test_rig/ChSuspensionTestRig.h"
#include <algorithm>
#include <cstdio>
#include "chrono/assets/ChCylinderShape.h"
#include "chrono_vehicle/ChVehicleModelData.h"
#include "chrono_vehicle/utils/ChUtilsJSON.h"
#include "chrono_vehicle/wheeled_vehicle/vehicle/WheeledVehicle.h"
#ifdef CHRONO_POSTPROCESS
#include "chrono_postprocess/ChGnuPlot.h"
#endif
using namespace rapidjson;
namespace chrono {
namespace vehicle {
// =============================================================================
// Definition of a terrain object for use by a suspension test rig.
// Note that this assumes an ISO world frame.
class TestRigTerrain : public ChTerrain {
public:
TestRigTerrain(int naxles, const std::vector<double>& x);
virtual double GetHeight(const ChVector<>& loc) const override;
virtual ChVector<> GetNormal(const ChVector<>& loc) const override;
virtual float GetCoefficientFriction(const ChVector<>& loc) const override;
int m_naxles;
std::vector<double> m_x;
std::vector<double> m_height_L;
std::vector<double> m_height_R;
};
TestRigTerrain::TestRigTerrain(int naxles, const std::vector<double>& x) : m_naxles(naxles), m_x(x) {
m_height_L.resize(naxles, -1000);
m_height_R.resize(naxles, -1000);
}
double TestRigTerrain::GetHeight(const ChVector<>& loc) const {
double min_delta = 1000;
int axle = 0;
for (int ia = 0; ia < m_naxles; ia++) {
auto delta = std::abs(loc.x() - m_x[ia]);
if (delta < min_delta) {
axle = ia;
min_delta = delta;
}
}
return (loc.y() < 0) ? m_height_R[axle] : m_height_L[axle];
}
ChVector<> TestRigTerrain::GetNormal(const ChVector<>& loc) const {
return ChVector<>(0, 0, 1);
}
float TestRigTerrain::GetCoefficientFriction(const ChVector<>& loc) const {
return 0.8f;
}
// =============================================================================
// Static variables
const double ChSuspensionTestRigPlatform::m_post_hheight = 0.05;
const double ChSuspensionTestRigPlatform::m_post_radius = 0.4;
const double ChSuspensionTestRigPushrod::m_rod_length = 3;
const double ChSuspensionTestRigPushrod::m_rod_radius = 0.02;
// =============================================================================
// Base class implementation
// =============================================================================
ChSuspensionTestRig::ChSuspensionTestRig(std::shared_ptr<ChWheeledVehicle> vehicle,
std::vector<int> axle_index,
double displ_limit)
: m_vehicle(vehicle),
m_axle_index(axle_index),
m_displ_limit(displ_limit),
m_ride_height(-1),
m_vis_suspension(VisualizationType::PRIMITIVES),
m_vis_subchassis(VisualizationType::PRIMITIVES),
m_vis_steering(VisualizationType::PRIMITIVES),
m_vis_wheel(VisualizationType::NONE),
m_vis_tire(VisualizationType::PRIMITIVES),
m_plot_output(false),
m_plot_output_step(0),
m_next_plot_output_time(0),
m_csv(nullptr) {
// Cache number of tested axles and steering mechanisms
m_naxles = (int)axle_index.size();
// Initialize the vehicle
m_vehicle->Initialize(ChCoordsys<>());
// Fix chassis to ground
m_vehicle->GetChassis()->SetFixed(true);
// Disconnect driveline
m_vehicle->DisconnectDriveline();
}
ChSuspensionTestRig::ChSuspensionTestRig(const std::string& spec_filename)
: m_vis_suspension(VisualizationType::PRIMITIVES),
m_vis_subchassis(VisualizationType::PRIMITIVES),
m_vis_steering(VisualizationType::PRIMITIVES),
m_vis_wheel(VisualizationType::NONE),
m_vis_tire(VisualizationType::PRIMITIVES),
m_plot_output(false),
m_plot_output_step(0),
m_next_plot_output_time(0),
m_csv(nullptr) {
// Open and parse the input file (rig JSON specification file)
Document d;
ReadFileJSON(spec_filename, d);
if (d.IsNull())
return;
// Read top-level data
assert(d.HasMember("Type"));
std::string type = d["Type"].GetString();
assert(type.compare("SuspensionTestRig") == 0);
assert(d.HasMember("Vehicle Input File"));
m_vehicle = chrono_types::make_shared<WheeledVehicle>(vehicle::GetDataFile(d["Vehicle Input File"].GetString()),
ChContactMethod::SMC);
assert(d.HasMember("Test Axle Indices"));
m_naxles = (int)d["Test Axle Indices"].Size();
m_axle_index.resize(m_naxles);
for (int ia = 0; ia < m_naxles; ia++)
m_axle_index[ia] = d["Test Axle Indices"][ia].GetInt();
if (d.HasMember("Test Subchassis Indices")) {
int nsubchassis = (int)d["Test Subchassis Indices"].Size();
m_subchassis_index.resize(nsubchassis);
for (int is = 0; is < nsubchassis; is++)
m_subchassis_index[is] = d["Test Subchassis Indices"][is].GetInt();
}
if (d.HasMember("Test Steering Indices")) {
int nsteerings = (int)d["Test Steering Indices"].Size();
m_steering_index.resize(nsteerings);
for (int is = 0; is < nsteerings; is++)
m_steering_index[is] = d["Test Steering Indices"][is].GetInt();
}
assert(d.HasMember("Displacement Limit"));
m_displ_limit = d["Displacement Limit"].GetDouble();
if (d.HasMember("Initial Ride Height")) {
m_ride_height = d["Initial Ride Height"].GetDouble();
} else {
m_ride_height = -1;
}
// Initialize the vehicle
m_vehicle->Initialize(ChCoordsys<>());
// Fix chassis to ground
m_vehicle->GetChassis()->SetFixed(true);
// Disconnect driveline
m_vehicle->DisconnectDriveline();
}
ChSuspensionTestRig::~ChSuspensionTestRig() {
delete m_csv;
}
void ChSuspensionTestRig::IncludeSubchassis(int index) {
m_subchassis_index.push_back(index);
}
void ChSuspensionTestRig::IncludeSteeringMechanism(int index) {
m_steering_index.push_back(index);
}
void ChSuspensionTestRig::Initialize() {
for (auto ia : m_axle_index) {
if (ia < 0 || ia >= m_vehicle->GetNumberAxles()) {
throw ChException("Incorrect axle index " + std::to_string(ia) + " for the given vehicle");
}
for (const auto& wheel : m_vehicle->GetAxle(ia)->GetWheels()) {
if (!wheel->GetTire()) {
throw ChException("No tires attached to axle " + std::to_string(ia) + " for the given vehicle");
}
}
}
for (auto is : m_steering_index) {
if (is < 0 || is >= (int)m_vehicle->GetSteerings().size()) {
throw ChException("Incorrect steering index " + std::to_string(is) + " for the given vehicle");
}
}
if (!m_driver) {
throw ChException("No driver system provided");
}
// Initialize visualization for all vehicle subsystems
m_vehicle->SetChassisVisualizationType(VisualizationType::NONE);
m_vehicle->SetSubchassisVisualizationType(VisualizationType::NONE);
m_vehicle->SetSteeringVisualizationType(VisualizationType::NONE);
m_vehicle->SetSuspensionVisualizationType(VisualizationType::NONE);
m_vehicle->SetWheelVisualizationType(VisualizationType::NONE);
m_vehicle->SetTireVisualizationType(VisualizationType::NONE);
// Process axles
for (auto ia : m_axle_index) {
const auto& axle = m_vehicle->GetAxle(ia);
// Overwrite visualization setting
axle->m_suspension->SetVisualizationType(m_vis_suspension);
if (axle->m_antirollbar) {
axle->m_antirollbar->SetVisualizationType(m_vis_suspension);
}
for (const auto& wheel : axle->GetWheels()) {
wheel->SetVisualizationType(m_vis_wheel);
wheel->GetTire()->SetVisualizationType(m_vis_tire);
}
// Enable output
m_vehicle->SetSuspensionOutput(ia, true);
if (axle->m_antirollbar) {
m_vehicle->SetAntirollbarOutput(ia, true);
}
// Initialize reference spindle vertical positions at design configuration.
m_spindle_ref_L.push_back(axle->m_suspension->GetSpindlePos(LEFT).z());
m_spindle_ref_R.push_back(axle->m_suspension->GetSpindlePos(RIGHT).z());
}
// Process subchassis mechanisms
for (auto is : m_subchassis_index) {
// Overwrite visualization setting
m_vehicle->GetSubchassis(is)->SetVisualizationType(m_vis_subchassis);
// Enable output
m_vehicle->SetSubchassisOutput(is, true);
}
// Process steering mechanisms
for (auto is : m_steering_index) {
// Overwrite visualization setting
m_vehicle->GetSteering(is)->SetVisualizationType(m_vis_steering);
// Enable output
m_vehicle->SetSteeringOutput(is, true);
}
// Let derived classes construct their rig mechanism
InitializeRig();
// Calculate displacement offset to set rig at specified ride height (if any).
// The rig will be moved dynamically to this configuration over a time interval displ_delay.
double displ_delay = 0;
m_displ_offset.resize(m_naxles, 0.0);
if (m_ride_height > 0) {
displ_delay = 0.5;
for (int ia = 0; ia < m_naxles; ia++) {
m_displ_offset[ia] = CalcDisplacementOffset(ia);
}
}
// Create the terrain system; pass spindle X positions
std::vector<double> xS;
for (auto ia : m_axle_index) {
const auto& suspension = m_vehicle->GetAxle(ia)->m_suspension;
xS.push_back(suspension->GetSpindlePos(LEFT).x());
}
m_terrain = std::unique_ptr<ChTerrain>(new TestRigTerrain(m_naxles, xS));
// Initialize the driver system
m_driver->m_delay = displ_delay;
m_driver->Initialize(m_naxles);
m_steering_input = 0;
m_left_inputs.resize(m_naxles, 0.0);
m_right_inputs.resize(m_naxles, 0.0);
}
// -----------------------------------------------------------------------------
void ChSuspensionTestRig::SetDriver(std::shared_ptr<ChDriverSTR> driver) {
m_driver = driver;
}
// -----------------------------------------------------------------------------
const ChVector<>& ChSuspensionTestRig::GetSpindlePos(int axle, VehicleSide side) const {
return m_vehicle->GetSpindlePos(m_axle_index[axle], side);
}
ChQuaternion<> ChSuspensionTestRig::GetSpindleRot(int axle, VehicleSide side) const {
return m_vehicle->GetSpindleRot(m_axle_index[axle], side);
}
const ChVector<>& ChSuspensionTestRig::GetSpindleLinVel(int axle, VehicleSide side) const {
return m_vehicle->GetSpindleLinVel(m_axle_index[axle], side);
}
ChVector<> ChSuspensionTestRig::GetSpindleAngVel(int axle, VehicleSide side) const {
return m_vehicle->GetSpindleAngVel(m_axle_index[axle], side);
}
double ChSuspensionTestRig::GetWheelTravel(int axle, VehicleSide side) const {
if (m_vehicle->GetChTime() < m_driver->m_delay)
return 0;
const auto& suspension = m_vehicle->GetAxle(m_axle_index[axle])->m_suspension;
return (side == LEFT) ? suspension->GetSpindlePos(LEFT).z() - m_spindle_ref_L[axle]
: suspension->GetSpindlePos(RIGHT).z() - m_spindle_ref_R[axle];
}
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
void ChSuspensionTestRig::Advance(double step) {
double time = m_vehicle->GetChTime();
// Actuation inputs
std::vector<double> displ_left(m_naxles, 0.0);
std::vector<double> displ_right(m_naxles, 0.0);
std::vector<double> displ_speed_left(m_naxles, 0.0);
std::vector<double> displ_speed_right(m_naxles, 0.0);
if (time < m_driver->m_delay) {
// Automatic phase to bring rig at specified initial ride height
for (int ia = 0; ia < m_naxles; ia++) {
displ_left[ia] = m_displ_offset[ia] * time / m_driver->m_delay;
displ_right[ia] = m_displ_offset[ia] * time / m_driver->m_delay;
// Update spindle vertical reference positions
const auto& suspension = m_vehicle->GetAxle(m_axle_index[ia])->m_suspension;
m_spindle_ref_L.push_back(suspension->GetSpindlePos(LEFT).z());
m_spindle_ref_R.push_back(suspension->GetSpindlePos(RIGHT).z());
}
} else {
// Use actual driver inputs to set current actuator displacements
m_steering_input = m_driver->GetSteering();
m_left_inputs = m_driver->GetDisplacementLeft();
m_right_inputs = m_driver->GetDisplacementRight();
const auto& left_input_speed = m_driver->GetDisplacementSpeedLeft();
const auto& right_input_speed = m_driver->GetDisplacementSpeedRight();
for (int ia = 0; ia < m_naxles; ia++) {
displ_left[ia] = m_displ_offset[ia] + m_displ_limit * m_left_inputs[ia];
displ_right[ia] = m_displ_offset[ia] + m_displ_limit * m_right_inputs[ia];
displ_speed_left[ia] = m_displ_limit * left_input_speed[ia];
displ_speed_right[ia] = m_displ_limit * right_input_speed[ia];
}
}
////std::cout << time << " " << m_steering_input << " ";
////std::cout << m_left_inputs[0] << " " << m_right_inputs[0] << " ";
////std::cout << displ_left[0] << " " << displ_right[0] << std::endl;
// Synchronize vehicle system
DriverInputs driver_inputs = {m_steering_input, 0, 0};
m_vehicle->Synchronize(time, driver_inputs, *m_terrain);
// Synchronize driver system
m_driver->Synchronize(time);
// Update actuators
UpdateActuators(displ_left, displ_speed_left, displ_right, displ_speed_right);
// Update the terrain "height" under each spindle.
auto terrain = static_cast<TestRigTerrain*>(m_terrain.get());
for (int ia = 0; ia < m_naxles; ia++) {
terrain->m_height_L[ia] = CalcTerrainHeight(ia, LEFT);
terrain->m_height_R[ia] = CalcTerrainHeight(ia, RIGHT);
}
// Advance vehicle state
m_vehicle->Advance(step);
// Generate output for plotting if requested
time = m_vehicle->GetChTime();
if (!m_driver->Started()) {
m_next_plot_output_time = time + m_plot_output_step;
} else if (m_plot_output && time > m_next_plot_output_time) {
CollectPlotData(time);
m_next_plot_output_time += m_plot_output_step;
}
}
// -----------------------------------------------------------------------------
// Log constraint violations
// -----------------------------------------------------------------------------
void ChSuspensionTestRig::LogConstraintViolations() {
GetLog().SetNumFormat("%16.4e");
// Report constraint violations for the suspension joints
for (auto ia : m_axle_index) {
const auto& axle = m_vehicle->GetAxle(ia);
GetLog() << "\n---- LEFT side suspension constraint violations\n\n";
axle->m_suspension->LogConstraintViolations(LEFT);
GetLog() << "\n---- RIGHT side suspension constraint violations\n\n";
axle->m_suspension->LogConstraintViolations(RIGHT);
}
// Report constraint violations for the steering joints
for (auto is : m_steering_index) {
GetLog() << "\n---- STEERING constrain violations\n\n";
m_vehicle->GetSteering(is)->LogConstraintViolations();
}
GetLog().SetNumFormat("%g");
}
// -----------------------------------------------------------------------------
void ChSuspensionTestRig::SetOutput(ChVehicleOutput::Type type,
const std::string& out_dir,
const std::string& out_name,
double output_step) {
m_vehicle->SetOutput(type, out_dir, out_name, output_step);
}
void ChSuspensionTestRig::SetPlotOutput(double output_step) {
m_plot_output = true;
m_plot_output_step = output_step;
m_csv = new utils::CSV_writer(" ");
}
void ChSuspensionTestRig::CollectPlotData(double time) {
*m_csv << time;
for (int ia = 0; ia < m_naxles; ia++) {
const auto& axle = m_vehicle->GetAxle(m_axle_index[ia]);
// Suspension spring and shock forces
auto frc_left = axle->m_suspension->ReportSuspensionForce(LEFT);
auto frc_right = axle->m_suspension->ReportSuspensionForce(RIGHT);
// Tire camber angle (flip sign of reported camber angle on the left to get common definition)
double gamma_left = -axle->m_wheels[0]->GetTire()->GetCamberAngle() * CH_C_RAD_TO_DEG;
double gamma_right = axle->m_wheels[1]->GetTire()->GetCamberAngle() * CH_C_RAD_TO_DEG;
*m_csv << m_left_inputs[ia] << m_right_inputs[ia]; // 1 2
*m_csv << GetSpindlePos(ia, LEFT) << GetSpindlePos(ia, RIGHT); // 3 4 5 6 7 8
*m_csv << GetSpindleLinVel(ia, LEFT) << GetSpindleLinVel(ia, RIGHT); // 9 10 11 12 13 14
*m_csv << GetWheelTravel(ia, LEFT) << GetWheelTravel(ia, RIGHT); // 15 16
*m_csv << frc_left.spring_force << frc_right.spring_force; // 17 18
*m_csv << frc_left.shock_force << frc_right.shock_force; // 19 20
*m_csv << gamma_left << gamma_right; // 21 22
*m_csv << GetRideHeight(ia); // 23
}
*m_csv << std::endl;
}
void ChSuspensionTestRig::PlotOutput(const std::string& out_dir, const std::string& out_name) {
if (!m_plot_output)
return;
std::string out_file = out_dir + "/" + out_name + ".txt";
m_csv->write_to_file(out_file);
#ifdef CHRONO_POSTPROCESS
std::string gplfile = out_dir + "/tmp.gpl";
postprocess::ChGnuPlot mplot(gplfile.c_str());
for (int ia = 0; ia < m_naxles; ia++) {
std::string title = "Suspension test rig - Axle " + std::to_string(ia) + " - Spring forces ";
mplot.OutputWindow(3 * ia + 0);
mplot.SetTitle(title.c_str());
mplot.SetLabelX("wheel travel [m]");
mplot.SetLabelY("spring force [N]");
mplot.SetCommand("set format y '%4.1e'");
mplot.SetCommand("set terminal wxt size 800, 600");
mplot.Plot(out_file.c_str(), 1 + 23 * ia + 15, 1 + 23 * ia + 17, "left", " with lines lw 2");
mplot.Plot(out_file.c_str(), 1 + 23 * ia + 16, 1 + 23 * ia + 18, "right", " with lines lw 2");
title = "Suspension test rig - Axle " + std::to_string(ia) + " - Shock forces";
mplot.OutputWindow(3 * ia + 1);
mplot.SetTitle(title.c_str());
mplot.SetLabelX("wheel vertical speed [m/s]");
mplot.SetLabelY("shock force [N]");
mplot.SetCommand("set format y '%4.1e'");
mplot.SetCommand("set terminal wxt size 800, 600");
mplot.Plot(out_file.c_str(), 1 + 23 * ia + 11, 1 + 23 * ia + 19, "left", " with lines lw 2");
mplot.Plot(out_file.c_str(), 1 + 23 * ia + 14, 1 + 23 * ia + 20, "right", " with lines lw 2");
title = "Suspension test rig - Axle " + std::to_string(ia) + " - Camber angle";
mplot.OutputWindow(3 * ia + 2);
mplot.SetTitle(title.c_str());
mplot.SetLabelX("wheel travel [m]");
mplot.SetLabelY("camber angle [deg]");
mplot.SetCommand("set format y '%4.1f'");
mplot.SetCommand("set terminal wxt size 800, 600");
mplot.Plot(out_file.c_str(), 1 + 23 * ia + 15, 1 + 23 * ia + 21, "left", " with lines lw 2");
mplot.Plot(out_file.c_str(), 1 + 23 * ia + 16, 1 + 23 * ia + 22, "right", " with lines lw 2");
}
#endif
}
// =============================================================================
// ChSuspensionTestRigPlatform class implementation
// =============================================================================
ChSuspensionTestRigPlatform::ChSuspensionTestRigPlatform(std::shared_ptr<ChWheeledVehicle> vehicle,
std::vector<int> axle_index,
double displ_limit)
: ChSuspensionTestRig(vehicle, axle_index, displ_limit) {}
ChSuspensionTestRigPlatform::ChSuspensionTestRigPlatform(const std::string& spec_filename)
: ChSuspensionTestRig(spec_filename) {}
ChSuspensionTestRigPlatform::~ChSuspensionTestRigPlatform() {
auto sys = m_vehicle->GetSystem();
if (sys) {
for (int ia = 0; ia < m_naxles; ia++) {
sys->Remove(m_post_L[ia]);
sys->Remove(m_post_R[ia]);
sys->Remove(m_linact_L[ia]);
sys->Remove(m_linact_R[ia]);
}
}
}
void ChSuspensionTestRigPlatform::InitializeRig() {
auto sys = m_vehicle->GetSystem();
// Create a contact material for the posts (shared)
//// TODO: are default material properties ok?
MaterialInfo minfo;
auto post_mat = minfo.CreateMaterial(sys->GetContactMethod());
for (int ia = 0; ia < m_naxles; ia++) {
const auto& axle = m_vehicle->GetAxle(m_axle_index[ia]);
const auto& suspension = axle->m_suspension;
auto tire_radius = axle->m_wheels[0]->GetTire()->GetRadius();
// Create the left post body (green)
ChVector<> spindle_L_pos = suspension->GetSpindlePos(LEFT);
ChVector<> post_L_pos = spindle_L_pos - ChVector<>(0, 0, tire_radius);
auto post_L = std::shared_ptr<ChBody>(sys->NewBody());
post_L->SetPos(post_L_pos);
post_L->SetMass(100);
post_L->SetCollide(true);
sys->Add(post_L);
AddPostVisualization(post_L, ChColor(0.1f, 0.8f, 0.15f));
post_L->GetCollisionModel()->ClearModel();
post_L->GetCollisionModel()->AddCylinder(post_mat, m_post_radius, m_post_radius, m_post_hheight,
ChVector<>(0, 0, -m_post_hheight),
ChMatrix33<>(Q_from_AngX(CH_C_PI / 2)));
post_L->GetCollisionModel()->BuildModel();
// Create the right post body (red)
ChVector<> spindle_R_pos = suspension->GetSpindlePos(RIGHT);
ChVector<> post_R_pos = spindle_R_pos - ChVector<>(0, 0, tire_radius);
auto post_R = std::shared_ptr<ChBody>(sys->NewBody());
post_R->SetPos(post_R_pos);
post_R->SetMass(100);
post_R->SetCollide(true);
sys->Add(post_R);
AddPostVisualization(post_R, ChColor(0.8f, 0.1f, 0.1f));
post_R->GetCollisionModel()->ClearModel();
post_R->GetCollisionModel()->AddCylinder(post_mat, m_post_radius, m_post_radius, m_post_hheight,
ChVector<>(0, 0, -m_post_hheight),
ChMatrix33<>(Q_from_AngX(CH_C_PI / 2)));
post_R->GetCollisionModel()->BuildModel();
// Create and initialize actuators
auto func_L = chrono_types::make_shared<ChFunction_Setpoint>();
auto func_R = chrono_types::make_shared<ChFunction_Setpoint>();
auto linact_L = chrono_types::make_shared<ChLinkMotorLinearPosition>();
linact_L->SetNameString("L_post_linActuator");
linact_L->SetMotionFunction(func_L);
linact_L->Initialize(m_vehicle->GetChassisBody(), post_L,
ChFrame<>(ChVector<>(post_L_pos), Q_from_AngY(CH_C_PI_2)));
sys->AddLink(linact_L);
auto linact_R = chrono_types::make_shared<ChLinkMotorLinearPosition>();
linact_R->SetNameString("R_post_linActuator");
linact_R->SetMotionFunction(func_R);
linact_R->Initialize(m_vehicle->GetChassisBody(), post_R,
ChFrame<>(ChVector<>(post_R_pos), Q_from_AngY(CH_C_PI_2)));
sys->AddLink(linact_R);
// Cache bodies and actuators
m_post_L.push_back(post_L);
m_post_R.push_back(post_R);
m_linact_L.push_back(linact_L);
m_linact_R.push_back(linact_R);
}
}
void ChSuspensionTestRigPlatform::AddPostVisualization(std::shared_ptr<ChBody> post, const ChColor& color) {
// Platform (on post body)
auto mat = chrono_types::make_shared<ChVisualMaterial>();
mat->SetDiffuseColor({color.R, color.G, color.B});
auto base_cyl = chrono_types::make_shared<ChCylinderShape>();
base_cyl->GetCylinderGeometry().rad = m_post_radius;
base_cyl->GetCylinderGeometry().p1 = ChVector<>(0, 0, 0);
base_cyl->GetCylinderGeometry().p2 = ChVector<>(0, 0, -2 * m_post_hheight);
base_cyl->AddMaterial(mat);
post->AddVisualShape(base_cyl);
// Piston (on post body)
auto piston = chrono_types::make_shared<ChCylinderShape>();
piston->GetCylinderGeometry().rad = m_post_radius / 6.0;
piston->GetCylinderGeometry().p1 = ChVector<>(0, 0, -2 * m_post_hheight);
piston->GetCylinderGeometry().p2 = ChVector<>(0, 0, -m_post_hheight * 20.0);
piston->AddMaterial(mat);
post->AddVisualShape(piston);
// Post sleeve (on chassis/ground body)
auto cyl = chrono_types::make_shared<ChCylinderShape>();
cyl->GetCylinderGeometry().rad = m_post_radius / 4.0;
cyl->GetCylinderGeometry().p1 = post->GetPos() - ChVector<>(0, 0, 16 * m_post_hheight);
cyl->GetCylinderGeometry().p2 = post->GetPos() - ChVector<>(0, 0, 32 * m_post_hheight);
cyl->AddMaterial(mat);
m_vehicle->GetChassisBody()->AddVisualShape(cyl);
}
double ChSuspensionTestRigPlatform::CalcDisplacementOffset(int axle) {
return -m_ride_height - m_post_L[axle]->GetPos().z();
}
double ChSuspensionTestRigPlatform::CalcTerrainHeight(int axle, VehicleSide side) {
// Update the height of the underlying terrain object, using the current z positions of the post bodies.
return (side == LEFT) ? m_post_L[axle]->GetPos().z() : m_post_R[axle]->GetPos().z();
}
void ChSuspensionTestRigPlatform::UpdateActuators(std::vector<double> displ_left,
std::vector<double> displ_speed_left,
std::vector<double> displ_right,
std::vector<double> displ_speed_right) {
for (int ia = 0; ia < m_naxles; ia++) {
auto func_L = std::static_pointer_cast<ChFunction_Setpoint>(m_linact_L[ia]->GetMotionFunction());
auto func_R = std::static_pointer_cast<ChFunction_Setpoint>(m_linact_R[ia]->GetMotionFunction());
func_L->SetSetpointAndDerivatives(displ_left[ia], displ_speed_left[ia], 0.0);
func_R->SetSetpointAndDerivatives(displ_right[ia], displ_speed_right[ia], 0.0);
}
}
double ChSuspensionTestRigPlatform::GetActuatorDisp(int axle, VehicleSide side) {
double time = m_vehicle->GetChTime();
return (side == LEFT) ? m_linact_L[axle]->GetMotionFunction()->Get_y(time)
: m_linact_R[axle]->GetMotionFunction()->Get_y(time);
}
double ChSuspensionTestRigPlatform::GetActuatorForce(int axle, VehicleSide side) {
return (side == LEFT) ? m_linact_L[axle]->Get_react_force().x() : m_linact_R[axle]->Get_react_force().x();
}
double ChSuspensionTestRigPlatform::GetRideHeight(int axle) const {
// Note: the chassis reference frame is constructed at a height of 0.
return -(m_post_L[axle]->GetPos().z() + m_post_R[axle]->GetPos().z()) / 2;
}
// =============================================================================
// ChSuspensionTestRigPushrod class implementation
// =============================================================================
ChSuspensionTestRigPushrod::ChSuspensionTestRigPushrod(std::shared_ptr<ChWheeledVehicle> vehicle,
std::vector<int> axle_index,
double displ_limit)
: ChSuspensionTestRig(vehicle, axle_index, displ_limit) {}
ChSuspensionTestRigPushrod::ChSuspensionTestRigPushrod(const std::string& spec_filename)
: ChSuspensionTestRig(spec_filename) {}
ChSuspensionTestRigPushrod::~ChSuspensionTestRigPushrod() {
auto sys = m_vehicle->GetSystem();
if (sys) {
for (int ia = 0; ia < m_naxles; ia++) {
sys->Remove(m_rod_L[ia]);
sys->Remove(m_rod_R[ia]);
sys->Remove(m_linact_L[ia]);
sys->Remove(m_linact_R[ia]);
}
}
}
void ChSuspensionTestRigPushrod::InitializeRig() {
auto sys = m_vehicle->GetSystem();
for (int ia = 0; ia < m_naxles; ia++) {
const auto& axle = m_vehicle->GetAxle(m_axle_index[ia]);
const auto& suspension = axle->m_suspension;
// Create and initialize the linear actuators.
// These connect the spindle centers with ground points directly below the spindles at the initial
// configuration.
auto func_L = chrono_types::make_shared<ChFunction_Setpoint>();
auto func_R = chrono_types::make_shared<ChFunction_Setpoint>();
const auto& pos_sL = suspension->GetSpindle(LEFT)->GetCoord();
const auto& pos_sR = suspension->GetSpindle(RIGHT)->GetCoord();
auto pos_gL = pos_sL;
auto pos_gR = pos_sR;
pos_gL.pos.z() = -m_rod_length;
pos_gR.pos.z() = -m_rod_length;
auto linact_L = chrono_types::make_shared<ChLinkLinActuator>();
linact_L->SetNameString("L_rod_actuator");
linact_L->Set_dist_funct(func_L);
linact_L->Initialize(m_vehicle->GetChassisBody(), suspension->GetSpindle(LEFT), false, pos_gL, pos_sL);
linact_L->Set_lin_offset(m_rod_length);
sys->AddLink(linact_L);
auto linact_R = chrono_types::make_shared<ChLinkLinActuator>();
linact_R->SetNameString("R_rod_actuator");
linact_R->Set_dist_funct(func_R);
linact_R->Initialize(m_vehicle->GetChassisBody(), suspension->GetSpindle(RIGHT), false, pos_gR, pos_sR);
linact_R->Set_lin_offset(m_rod_length);
sys->AddLink(linact_R);
// Create the two rod bodies (used only for visualization)
auto rod_L = std::shared_ptr<ChBody>(sys->NewBody());
rod_L->SetPos(pos_sL.pos);
rod_L->SetBodyFixed(true);
sys->Add(rod_L);
AddRodVisualization(rod_L, ChColor(0.1f, 0.8f, 0.15f));
auto rod_R = std::shared_ptr<ChBody>(sys->NewBody());
rod_R->SetPos(pos_sR.pos);
rod_R->SetBodyFixed(true);
sys->Add(rod_R);
AddRodVisualization(rod_R, ChColor(0.8f, 0.1f, 0.1f));
// Cache bodies and actuators
m_rod_L.push_back(rod_L);
m_rod_R.push_back(rod_R);
m_linact_L.push_back(linact_L);
m_linact_R.push_back(linact_R);
}
}
void ChSuspensionTestRigPushrod::AddRodVisualization(std::shared_ptr<ChBody> rod, const ChColor& color) {
auto cyl = chrono_types::make_shared<ChCylinderShape>();
cyl->GetCylinderGeometry().p1 = ChVector<>(0, 0, 0);
cyl->GetCylinderGeometry().p2 = ChVector<>(0, 0, -m_rod_length);
cyl->GetCylinderGeometry().rad = m_rod_radius;
cyl->SetColor(color);
rod->AddVisualShape(cyl);
}
double ChSuspensionTestRigPushrod::CalcDisplacementOffset(int axle) {
// Set initial spindle position based on tire radius (note: tire assumed rigid here)
auto tire_radius = m_vehicle->GetAxle(m_axle_index[axle])->m_wheels[0]->GetTire()->GetRadius();
return tire_radius - m_ride_height;
}
double ChSuspensionTestRigPushrod::CalcTerrainHeight(int axle, VehicleSide side) {
// No terrain used here
return -1000;
}
void ChSuspensionTestRigPushrod::UpdateActuators(std::vector<double> displ_left,
std::vector<double> displ_speed_left,
std::vector<double> displ_right,
std::vector<double> displ_speed_right) {
for (int ia = 0; ia < m_naxles; ia++) {
auto func_L = std::static_pointer_cast<ChFunction_Setpoint>(m_linact_L[ia]->Get_dist_funct());
auto func_R = std::static_pointer_cast<ChFunction_Setpoint>(m_linact_R[ia]->Get_dist_funct());
func_L->SetSetpointAndDerivatives(displ_left[ia], displ_speed_left[ia], 0.0);
func_R->SetSetpointAndDerivatives(displ_right[ia], displ_speed_right[ia], 0.0);
// Move the rod visualization bodies
const auto& axle = m_vehicle->GetAxle(m_axle_index[ia]);
m_rod_L[ia]->SetPos(axle->m_suspension->GetSpindle(LEFT)->GetPos());
m_rod_R[ia]->SetPos(axle->m_suspension->GetSpindle(RIGHT)->GetPos());
}
}
double ChSuspensionTestRigPushrod::GetActuatorDisp(int axle, VehicleSide side) {
double time = m_vehicle->GetChTime();
return (side == LEFT) ? m_linact_L[axle]->Get_dist_funct()->Get_y(time)
: m_linact_R[axle]->Get_dist_funct()->Get_y(time);
}
double ChSuspensionTestRigPushrod::GetActuatorForce(int axle, VehicleSide side) {
//// TODO
////ChVector<> react = m_linact_L[ia]->Get_react_force();
return 0;
}
double ChSuspensionTestRigPushrod::GetRideHeight(int axle) const {
// Estimated from average spindle positions and tire radius (note: tire assumed rigid here)
const auto& suspension = m_vehicle->GetAxle(m_axle_index[axle])->m_suspension;
auto tire_radius = m_vehicle->GetAxle(m_axle_index[axle])->m_wheels[0]->GetTire()->GetRadius();
auto spindle_avg = (suspension->GetSpindle(LEFT)->GetPos().z() + suspension->GetSpindle(RIGHT)->GetPos().z()) / 2;
return tire_radius - spindle_avg;
}
} // end namespace vehicle
} // end namespace chrono
| 42.165025 | 118 | 0.621882 | [
"object",
"vector"
] |
c53ae1882a53a4d30592ae4ba511854a0b300052 | 9,518 | cpp | C++ | src/org/apache/poi/sl/draw/DrawShape.cpp | pebble2015/cpoi | 6dcc0c5e13e3e722b4ef9fd0baffbf62bf71ead6 | [
"Apache-2.0"
] | null | null | null | src/org/apache/poi/sl/draw/DrawShape.cpp | pebble2015/cpoi | 6dcc0c5e13e3e722b4ef9fd0baffbf62bf71ead6 | [
"Apache-2.0"
] | null | null | null | src/org/apache/poi/sl/draw/DrawShape.cpp | pebble2015/cpoi | 6dcc0c5e13e3e722b4ef9fd0baffbf62bf71ead6 | [
"Apache-2.0"
] | null | null | null | // Generated from /POI/java/org/apache/poi/sl/draw/DrawShape.java
#include <org/apache/poi/sl/draw/DrawShape.hpp>
#include <java/awt/BasicStroke.hpp>
#include <java/awt/Graphics2D.hpp>
#include <java/awt/Shape.hpp>
#include <java/awt/geom/AffineTransform.hpp>
#include <java/awt/geom/Rectangle2D.hpp>
#include <java/lang/Class.hpp>
#include <java/lang/ClassCastException.hpp>
#include <java/lang/Math.hpp>
#include <java/lang/NullPointerException.hpp>
#include <java/lang/Object.hpp>
#include <java/lang/RuntimeException.hpp>
#include <java/lang/String.hpp>
#include <java/lang/StringBuilder.hpp>
#include <java/util/Locale.hpp>
#include <org/apache/poi/sl/draw/Drawable_DrawableHint.hpp>
#include <org/apache/poi/sl/draw/Drawable.hpp>
#include <org/apache/poi/sl/usermodel/PlaceableShape.hpp>
#include <org/apache/poi/sl/usermodel/Shape.hpp>
#include <org/apache/poi/sl/usermodel/StrokeStyle_LineCap.hpp>
#include <org/apache/poi/sl/usermodel/StrokeStyle_LineDash.hpp>
#include <org/apache/poi/sl/usermodel/StrokeStyle.hpp>
#include <Array.hpp>
#include <cmath>
template<typename T, typename U>
static T java_cast(U* u)
{
if(!u) return static_cast<T>(nullptr);
auto t = dynamic_cast<T>(u);
if(!t) throw new ::java::lang::ClassCastException();
return t;
}
template<typename T>
static T* npc(T* t)
{
if(!t) throw new ::java::lang::NullPointerException();
return t;
}
poi::sl::draw::DrawShape::DrawShape(const ::default_init_tag&)
: super(*static_cast< ::default_init_tag* >(0))
{
clinit();
}
poi::sl::draw::DrawShape::DrawShape(::poi::sl::usermodel::Shape* shape)
: DrawShape(*static_cast< ::default_init_tag* >(0))
{
ctor(shape);
}
void poi::sl::draw::DrawShape::ctor(::poi::sl::usermodel::Shape* shape)
{
super::ctor();
this->shape = shape;
}
bool poi::sl::draw::DrawShape::isHSLF(::poi::sl::usermodel::Shape* shape)
{
clinit();
return npc(npc(npc(npc(shape)->getClass())->getCanonicalName())->toLowerCase(::java::util::Locale::ROOT()))->contains(u"hslf"_j);
}
void poi::sl::draw::DrawShape::applyTransform(::java::awt::Graphics2D* graphics)
{
if(!(dynamic_cast< ::poi::sl::usermodel::PlaceableShape* >(shape) != nullptr)) {
return;
}
auto ps = java_cast< ::poi::sl::usermodel::PlaceableShape* >(shape);
auto const isHSLF = DrawShape::isHSLF(shape);
auto tx = java_cast< ::java::awt::geom::AffineTransform* >(npc(graphics)->getRenderingHint(Drawable::GROUP_TRANSFORM()));
if(tx == nullptr) {
tx = new ::java::awt::geom::AffineTransform();
}
auto const anchor = npc(npc(tx)->createTransformedShape(npc(ps)->getAnchor()))->getBounds2D();
auto cmds = isHSLF ? new ::char16_tArray({
u'h'
, u'v'
, u'r'
}) : new ::char16_tArray({
u'r'
, u'h'
, u'v'
});
for(auto ch : *npc(cmds)) {
{
double rotation;
switch (ch) {
case u'h':
if(npc(ps)->getFlipHorizontal()) {
npc(graphics)->translate(npc(anchor)->getX() + npc(anchor)->getWidth(), npc(anchor)->getY());
npc(graphics)->scale(-int32_t(1), 1);
npc(graphics)->translate(-npc(anchor)->getX(), -npc(anchor)->getY());
}
break;
case u'v':
if(npc(ps)->getFlipVertical()) {
npc(graphics)->translate(npc(anchor)->getX(), npc(anchor)->getY() + npc(anchor)->getHeight());
npc(graphics)->scale(1, -int32_t(1));
npc(graphics)->translate(-npc(anchor)->getX(), -npc(anchor)->getY());
}
break;
case u'r':
rotation = npc(ps)->getRotation();
if(rotation != 0.0) {
auto centerX = npc(anchor)->getCenterX();
auto centerY = npc(anchor)->getCenterY();
rotation = std::fmod(rotation, rotation);
if(rotation < 0) {
rotation += 360.0;
}
auto quadrant = ((static_cast< int32_t >(rotation) + int32_t(45)) / int32_t(90)) % int32_t(4);
double scaleX = 1.0, scaleY = 1.0;
if(quadrant == 1 || quadrant == 3) {
::java::awt::geom::AffineTransform* txs;
if(isHSLF) {
txs = new ::java::awt::geom::AffineTransform(tx);
} else {
txs = new ::java::awt::geom::AffineTransform();
npc(txs)->translate(centerX, centerY);
npc(txs)->rotate(::java::lang::Math::PI / 2.0);
npc(txs)->translate(-centerX, -centerY);
npc(txs)->concatenate(tx);
}
npc(txs)->translate(centerX, centerY);
npc(txs)->rotate(::java::lang::Math::PI / 2.0);
npc(txs)->translate(-centerX, -centerY);
auto anchor2 = npc(npc(txs)->createTransformedShape(npc(ps)->getAnchor()))->getBounds2D();
scaleX = safeScale(npc(anchor)->getWidth(), npc(anchor2)->getWidth());
scaleY = safeScale(npc(anchor)->getHeight(), npc(anchor2)->getHeight());
} else {
quadrant = 0;
}
npc(graphics)->translate(centerX, centerY);
auto rot = ::java::lang::Math::toRadians(rotation - quadrant * 90.0);
if(rot != 0) {
npc(graphics)->rotate(rot);
}
npc(graphics)->scale(scaleX, scaleY);
rot = ::java::lang::Math::toRadians(quadrant * 90.0);
if(rot != 0) {
npc(graphics)->rotate(rot);
}
npc(graphics)->translate(-centerX, -centerY);
}
break;
default:
throw new ::java::lang::RuntimeException(::java::lang::StringBuilder().append(u"unexpected transform code "_j)->append(ch)->toString());
}
}
}
}
double poi::sl::draw::DrawShape::safeScale(double dim1, double dim2)
{
clinit();
if(dim1 == 0.0) {
return 1;
}
return (dim2 == 0.0) ? static_cast< double >(int32_t(1)) : dim1 / dim2;
}
void poi::sl::draw::DrawShape::draw(::java::awt::Graphics2D* graphics)
{
}
void poi::sl::draw::DrawShape::drawContent(::java::awt::Graphics2D* graphics)
{
}
java::awt::geom::Rectangle2D* poi::sl::draw::DrawShape::getAnchor(::java::awt::Graphics2D* graphics, ::poi::sl::usermodel::PlaceableShape* shape)
{
clinit();
return getAnchor(graphics, npc(shape)->getAnchor());
}
java::awt::geom::Rectangle2D* poi::sl::draw::DrawShape::getAnchor(::java::awt::Graphics2D* graphics, ::java::awt::geom::Rectangle2D* anchor)
{
clinit();
if(graphics == nullptr) {
return anchor;
}
auto tx = java_cast< ::java::awt::geom::AffineTransform* >(npc(graphics)->getRenderingHint(Drawable::GROUP_TRANSFORM()));
if(tx != nullptr && !npc(tx)->isIdentity()) {
anchor = npc(npc(tx)->createTransformedShape(anchor))->getBounds2D();
}
return anchor;
}
poi::sl::usermodel::Shape* poi::sl::draw::DrawShape::getShape()
{
return shape;
}
java::awt::BasicStroke* poi::sl::draw::DrawShape::getStroke(::poi::sl::usermodel::StrokeStyle* strokeStyle)
{
clinit();
auto lineWidth = static_cast< float >(npc(strokeStyle)->getLineWidth());
if(lineWidth == 0.0f) {
lineWidth = 0.25f;
}
auto lineDash = npc(strokeStyle)->getLineDash();
if(lineDash == nullptr) {
lineDash = ::poi::sl::usermodel::StrokeStyle_LineDash::SOLID;
}
auto dashPatI = npc(lineDash)->pattern;
float const dash_phase = int32_t(0);
::floatArray* dashPatF = nullptr;
if(dashPatI != nullptr) {
dashPatF = new ::floatArray(npc(dashPatI)->length);
for (auto i = int32_t(0); i < npc(dashPatI)->length; i++) {
(*dashPatF)[i] = (*dashPatI)[i] * ::java::lang::Math::max(static_cast< float >(int32_t(1)), lineWidth);
}
}
auto lineCapE = npc(strokeStyle)->getLineCap();
if(lineCapE == nullptr) {
lineCapE = ::poi::sl::usermodel::StrokeStyle_LineCap::FLAT;
}
int32_t lineCap;
{
auto v = lineCapE;
if((v == ::poi::sl::usermodel::StrokeStyle_LineCap::ROUND)) {
lineCap = ::java::awt::BasicStroke::CAP_ROUND;
goto end_switch0;;
}
if((v == ::poi::sl::usermodel::StrokeStyle_LineCap::SQUARE)) {
lineCap = ::java::awt::BasicStroke::CAP_SQUARE;
goto end_switch0;;
}
if((v == ::poi::sl::usermodel::StrokeStyle_LineCap::FLAT)) {
lineCap = ::java::awt::BasicStroke::CAP_BUTT;
goto end_switch0;;
}
end_switch0:;
}
auto lineJoin = ::java::awt::BasicStroke::JOIN_ROUND;
return new ::java::awt::BasicStroke(lineWidth, lineCap, lineJoin, lineWidth, dashPatF, dash_phase);
}
extern java::lang::Class *class_(const char16_t *c, int n);
java::lang::Class* poi::sl::draw::DrawShape::class_()
{
static ::java::lang::Class* c = ::class_(u"org.apache.poi.sl.draw.DrawShape", 32);
return c;
}
java::lang::Class* poi::sl::draw::DrawShape::getClass0()
{
return class_();
}
| 36.749035 | 152 | 0.563144 | [
"object",
"shape",
"transform",
"solid"
] |
c54eb9f9810d2a6963a44a95c06bcb7b10b71bf5 | 10,231 | hpp | C++ | include/caffe/util/math_functions.hpp | abhiTronix/caffe-opencl-windows-amd | 1de97750d3c97756f39899d3b158120971a8a5da | [
"BSD-2-Clause"
] | 8 | 2019-06-29T14:51:28.000Z | 2021-07-25T04:10:38.000Z | include/caffe/util/math_functions.hpp | KorJeongHyeonLee/Caffe-CL-Origin | 430344adbb3a05b4611b1b821a68c82d6480ba26 | [
"Intel",
"BSD-2-Clause"
] | 1 | 2018-12-12T11:57:27.000Z | 2019-06-30T03:31:09.000Z | include/caffe/util/math_functions.hpp | KorJeongHyeonLee/Caffe-CL-Origin | 430344adbb3a05b4611b1b821a68c82d6480ba26 | [
"Intel",
"BSD-2-Clause"
] | 2 | 2018-08-31T20:13:22.000Z | 2019-06-29T14:51:33.000Z | #ifndef CAFFE_UTIL_MATH_FUNCTIONS_H_
#define CAFFE_UTIL_MATH_FUNCTIONS_H_
#include <stdint.h>
#include <cmath> // for std::fabs and std::signbit
// This code is taken from https://github.com/sh1r0/caffe-android-lib
#include <cstring> // for memset
#include "glog/logging.h"
#include "caffe/common.hpp"
#include "caffe/util/device_alternate.hpp"
#include "caffe/util/mkl_alternate.hpp"
namespace caffe {
// Caffe gemm provides a simpler interface to the gemm functions, with the
// limitation that the data has to be contiguous in memory.
template<typename Dtype>
void caffe_cpu_gemm(const CBLAS_TRANSPOSE TransA, const CBLAS_TRANSPOSE TransB,
const int_tp M, const int_tp N, const int_tp K,
const Dtype alpha, const Dtype* A, const Dtype* B,
const Dtype beta, Dtype* C);
template<typename Dtype>
void caffe_cpu_gemv(const CBLAS_TRANSPOSE TransA, const int_tp M,
const int_tp N, const Dtype alpha, const Dtype* A,
const Dtype* x, const Dtype beta, Dtype* y);
template<typename Dtype>
void caffe_axpy(const int_tp N, const Dtype alpha, const Dtype* X, Dtype* Y);
template<typename Dtype>
void caffe_cpu_axpby(const int_tp N, const Dtype alpha, const Dtype* X,
const Dtype beta, Dtype* Y);
template<typename Dtype>
void caffe_cpu_copy(const int_tp N, const Dtype* X, Dtype* Y);
template<typename Dtype>
void caffe_copy(const int_tp N, const Dtype *X, Dtype *Y);
template<typename Dtype>
void caffe_set(const int_tp N, const Dtype alpha, Dtype *X);
inline void caffe_memset(const uint_tp N, const int_tp alpha, void* X) {
memset(X, alpha, N); // NOLINT(caffe/alt_fn)
}
template<typename Dtype>
void caffe_add_scalar(const int_tp N, const Dtype alpha, Dtype *X);
template<typename Dtype>
void caffe_scal(const int_tp N, const Dtype alpha, Dtype *X);
template<typename Dtype>
void caffe_sqr(const int_tp N, const Dtype* a, Dtype* y);
template <typename Dtype>
void caffe_sqrt(const int_tp N, const Dtype* a, Dtype* y);
template <typename Dtype>
void caffe_add(const int_tp N, const Dtype* a, const Dtype* b, Dtype* y);
template<typename Dtype>
void caffe_sub(const int_tp N, const Dtype* a, const Dtype* b, Dtype* y);
template<typename Dtype>
void caffe_mul(const int_tp N, const Dtype* a, const Dtype* b, Dtype* y);
template<typename Dtype>
void caffe_div(const int_tp N, const Dtype* a, const Dtype* b, Dtype* y);
template<typename Dtype>
void caffe_powx(const int_tp n, const Dtype* a, const Dtype b, Dtype* y);
uint_tp caffe_rng_rand();
template<typename Dtype>
Dtype caffe_nextafter(const Dtype b);
void caffe_rng_uniform(const int_tp n, uint_tp* r);
template<typename Dtype>
void caffe_rng_uniform(const int_tp n, const Dtype a, const Dtype b, Dtype* r);
template<typename Dtype>
void caffe_rng_gaussian(const int_tp n, const Dtype mu, const Dtype sigma,
Dtype* r);
template<typename Dtype, typename Itype>
void caffe_rng_bernoulli(const int_tp n, const Dtype p, Itype* r);
template<typename Dtype>
void caffe_exp(const int_tp n, const Dtype* a, Dtype* y);
template<typename Dtype>
void caffe_log(const int_tp n, const Dtype* a, Dtype* y);
template<typename Dtype>
void caffe_abs(const int_tp n, const Dtype* a, Dtype* y);
template<typename Dtype>
Dtype caffe_cpu_dot(const int_tp n, const Dtype* x, const Dtype* y);
template<typename Dtype>
Dtype caffe_cpu_strided_dot(const int_tp n, const Dtype* x, const int_tp incx,
const Dtype* y, const int_tp incy);
// Returns the sum of the absolute values of the elements of vector x
template<typename Dtype>
Dtype caffe_cpu_asum(const int_tp n, const Dtype* x);
// the branchless, type-safe version from
// http://stackoverflow.com/questions/1903954/is-there-a-standard-sign-function-signum-sgn-in-c-c
template<typename Dtype>
inline int8_t caffe_sign(Dtype val) {
return (Dtype(0) < val) - (val < Dtype(0));
}
// The following two macros are modifications of DEFINE_VSL_UNARY_FUNC
// in include/caffe/util/mkl_alternate.hpp authored by @Rowland Depp.
// Please refer to commit 7e8ef25c7 of the boost-eigen branch.
// Git cherry picking that commit caused a conflict hard to resolve and
// copying that file in convenient for code reviewing.
// So they have to be pasted here temporarily.
#define DEFINE_CAFFE_CPU_UNARY_FUNC(name, operation) \
template<typename Dtype> \
void caffe_cpu_##name(const int_tp n, const Dtype* x, Dtype* y) { \
CHECK_GT(n, 0); CHECK(x); CHECK(y); \
for (int_tp i = 0; i < n; ++i) { \
operation; \
} \
}
// output is 1 for the positives, 0 for zero, and -1 for the negatives
DEFINE_CAFFE_CPU_UNARY_FUNC(sign, y[i] = caffe_sign<Dtype>(x[i]))
// This returns a nonzero value if the input has its sign bit set.
// The name sngbit is meant to avoid conflicts with std::signbit in the macro.
// The extra parens are needed because CUDA < 6.5 defines signbit as a macro,
// and we don't want that to expand here when CUDA headers are also included.
DEFINE_CAFFE_CPU_UNARY_FUNC(sgnbit, \
y[i] = static_cast<bool>((std::signbit)(x[i])))
DEFINE_CAFFE_CPU_UNARY_FUNC(fabs, y[i] = std::fabs(x[i]))
template<typename Dtype>
void caffe_cpu_scale(const int_tp n, const Dtype alpha, const Dtype *x,
Dtype* y);
#ifndef CPU_ONLY // GPU
#ifdef USE_CUDA
// Decaf gpu gemm provides an interface that is almost the same as the cpu
// gemm function - following the c convention and calling the fortran-order
// gpu code under the hood.
template<typename Dtype>
void caffe_gpu_gemm(const CBLAS_TRANSPOSE TransA, const CBLAS_TRANSPOSE TransB,
const int_tp M, const int_tp N, const int_tp K,
const Dtype alpha, const Dtype* A, const Dtype* B,
const Dtype beta, Dtype* C);
template<typename Dtype>
void caffe_gpu_gemv(const CBLAS_TRANSPOSE TransA, const int_tp M,
const int_tp N, const Dtype alpha, const Dtype* A,
const Dtype* x, const Dtype beta, Dtype* y);
template<typename Dtype>
void caffe_gpu_axpy(const int_tp N, const Dtype alpha, const Dtype* X,
Dtype* Y);
template<typename Dtype>
void caffe_gpu_axpby(const int_tp N, const Dtype alpha, const Dtype* X,
const Dtype beta, Dtype* Y);
void caffe_gpu_memcpy(const uint_tp N, const void *X, void *Y);
template<typename Dtype>
void caffe_gpu_set(const int_tp N, const Dtype alpha, Dtype *X);
inline void caffe_gpu_memset(const uint_tp N, const int_tp alpha, void* X) {
CUDA_CHECK(cudaMemset(X, alpha, N)); // NOLINT(caffe/alt_fn)
}
template<typename Dtype>
void caffe_gpu_add_scalar(const int_tp N, const Dtype alpha, Dtype *X);
template<typename Dtype>
void caffe_gpu_scal(const int_tp N, const Dtype alpha, Dtype *X);
template<typename Dtype>
void caffe_gpu_add(const int_tp N, const Dtype* a, const Dtype* b, Dtype* y);
template <typename Dtype>
void caffe_gpu_scal(const int_tp N, const Dtype alpha, Dtype* X,
cudaStream_t str);
template<typename Dtype>
void caffe_gpu_sub(const int_tp N, const Dtype* a, const Dtype* b, Dtype* y);
template<typename Dtype>
void caffe_gpu_mul(const int_tp N, const Dtype* a, const Dtype* b, Dtype* y);
template<typename Dtype>
void caffe_gpu_div(const int_tp N, const Dtype* a, const Dtype* b, Dtype* y);
template<typename Dtype>
void caffe_gpu_abs(const int_tp n, const Dtype* a, Dtype* y);
template<typename Dtype>
void caffe_gpu_exp(const int_tp n, const Dtype* a, Dtype* y);
template<typename Dtype>
void caffe_gpu_log(const int_tp n, const Dtype* a, Dtype* y);
template<typename Dtype>
void caffe_gpu_powx(const int_tp n, const Dtype* a, const Dtype b, Dtype* y);
template <typename Dtype>
void caffe_gpu_sqrt(const int_tp n, const Dtype* a, Dtype* y);
// caffe_gpu_rng_uniform with two arguments generates integers in the range
// [0, UINT_MAX].
void caffe_gpu_rng_uniform(const int_tp n, unsigned int* r); // NOLINT
void caffe_gpu_rng_uniform(const int_tp n, unsigned long long* r); // NOLINT
// caffe_gpu_rng_uniform with four arguments generates floats in the range
// (a, b] (strictly greater than a, less than or equal to b) due to the
// specification of curandGenerateUniform. With a = 0, b = 1, just calls
// curandGenerateUniform; with other limits will shift and scale the outputs
// appropriately after calling curandGenerateUniform.
template<typename Dtype>
void caffe_gpu_rng_uniform(const int_tp n, const Dtype a, const Dtype b,
Dtype* r);
template<typename Dtype>
void caffe_gpu_rng_gaussian(const int_tp n, const Dtype mu, const Dtype sigma,
Dtype* r);
template<typename Dtype>
void caffe_gpu_rng_bernoulli(const int_tp n, const Dtype p, int_tp* r);
template<typename Dtype>
void caffe_gpu_dot(const int_tp n, const Dtype* x, const Dtype* y, Dtype* out);
template<typename Dtype>
void caffe_gpu_asum(const int_tp n, const Dtype* x, Dtype* y);
template<typename Dtype>
void caffe_gpu_sign(const int_tp n, const Dtype* x, Dtype* y);
template<typename Dtype>
void caffe_gpu_sgnbit(const int_tp n, const Dtype* x, Dtype* y);
template<typename Dtype>
void caffe_gpu_fabs(const int_tp n, const Dtype* x, Dtype* y);
template<typename Dtype>
void caffe_gpu_scale(const int_tp n, const Dtype alpha, const Dtype *x,
Dtype* y);
#define DEFINE_AND_INSTANTIATE_GPU_UNARY_FUNC(name, operation) \
template<typename Dtype> \
__global__ void name##_kernel(const int_tp n, const Dtype* x, Dtype* y) { \
CUDA_KERNEL_LOOP(index, n) { \
operation; \
} \
} \
template <> \
void caffe_gpu_##name<float>(const int_tp n, const float* x, float* y) { \
/* NOLINT_NEXT_LINE(whitespace/operators) */ \
name##_kernel<float><<<CAFFE_GET_BLOCKS(n), CAFFE_CUDA_NUM_THREADS>>>( \
n, x, y); \
} \
template <> \
void caffe_gpu_##name<double>(const int_tp n, const double* x, double* y) { \
/* NOLINT_NEXT_LINE(whitespace/operators) */ \
name##_kernel<double><<<CAFFE_GET_BLOCKS(n), CAFFE_CUDA_NUM_THREADS>>>( \
n, x, y); \
}
#endif // USE_CUDA
#endif // !CPU_ONLY
} // namespace caffe
#endif // CAFFE_UTIL_MATH_FUNCTIONS_H_
| 35.27931 | 97 | 0.720066 | [
"vector"
] |
c5548c16f7c136391f605061fd26bfef38b44743 | 4,920 | cc | C++ | third_party/blink/renderer/core/intersection_observer/intersection_observation.cc | zipated/src | 2b8388091c71e442910a21ada3d97ae8bc1845d3 | [
"BSD-3-Clause"
] | 2,151 | 2020-04-18T07:31:17.000Z | 2022-03-31T08:39:18.000Z | third_party/blink/renderer/core/intersection_observer/intersection_observation.cc | cangulcan/src | 2b8388091c71e442910a21ada3d97ae8bc1845d3 | [
"BSD-3-Clause"
] | 395 | 2020-04-18T08:22:18.000Z | 2021-12-08T13:04:49.000Z | third_party/blink/renderer/core/intersection_observer/intersection_observation.cc | cangulcan/src | 2b8388091c71e442910a21ada3d97ae8bc1845d3 | [
"BSD-3-Clause"
] | 338 | 2020-04-18T08:03:10.000Z | 2022-03-29T12:33:22.000Z | // Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "third_party/blink/renderer/core/intersection_observer/intersection_observation.h"
#include "third_party/blink/renderer/core/dom/element_rare_data.h"
#include "third_party/blink/renderer/core/frame/local_frame.h"
#include "third_party/blink/renderer/core/intersection_observer/intersection_observer.h"
#include "third_party/blink/renderer/core/layout/intersection_geometry.h"
namespace blink {
IntersectionObservation::IntersectionObservation(IntersectionObserver& observer,
Element& target)
: observer_(observer),
target_(&target),
// Note that the spec says the initial value of m_lastThresholdIndex
// should be -1, but since m_lastThresholdIndex is unsigned, we use a
// different sentinel value.
last_is_visible_(false),
last_threshold_index_(kMaxThresholdIndex - 1) {
UpdateShouldReportRootBoundsAfterDomChange();
}
void IntersectionObservation::ComputeIntersectionObservations(
DOMHighResTimeStamp timestamp) {
DCHECK(Observer());
if (!target_)
return;
Vector<Length> root_margin(4);
root_margin[0] = observer_->TopMargin();
root_margin[1] = observer_->RightMargin();
root_margin[2] = observer_->BottomMargin();
root_margin[3] = observer_->LeftMargin();
IntersectionGeometry geometry(observer_->root(), *Target(), root_margin,
should_report_root_bounds_);
geometry.ComputeGeometry();
// Some corner cases for threshold index:
// - If target rect is zero area, because it has zero width and/or zero
// height,
// only two states are recognized:
// - 0 means not intersecting.
// - 1 means intersecting.
// No other threshold crossings are possible.
// - Otherwise:
// - If root and target do not intersect, the threshold index is 0.
// - If root and target intersect but the intersection has zero-area
// (i.e., they have a coincident edge or corner), we consider the
// intersection to have "crossed" a zero threshold, but not crossed
// any non-zero threshold.
unsigned new_threshold_index;
float new_visible_ratio;
if (geometry.DoesIntersect()) {
if (geometry.TargetRect().IsEmpty()) {
new_visible_ratio = 1;
} else {
float intersection_area =
geometry.IntersectionRect().Size().Width().ToFloat() *
geometry.IntersectionRect().Size().Height().ToFloat();
float target_area = geometry.TargetRect().Size().Width().ToFloat() *
geometry.TargetRect().Size().Height().ToFloat();
new_visible_ratio = intersection_area / target_area;
}
new_threshold_index =
Observer()->FirstThresholdGreaterThan(new_visible_ratio);
} else {
new_visible_ratio = 0;
new_threshold_index = 0;
}
// TODO(tkent): We can't use CHECK_LT due to a compile error.
CHECK(new_threshold_index < kMaxThresholdIndex);
bool is_visible = false;
if (RuntimeEnabledFeatures::IntersectionObserverV2Enabled() &&
Observer()->trackVisibility()) {
// TODO(szager): Determine visibility.
}
if (last_threshold_index_ != new_threshold_index ||
last_is_visible_ != is_visible) {
FloatRect snapped_root_bounds(geometry.RootRect());
FloatRect* root_bounds_pointer =
should_report_root_bounds_ ? &snapped_root_bounds : nullptr;
IntersectionObserverEntry* new_entry = new IntersectionObserverEntry(
timestamp, new_visible_ratio, FloatRect(geometry.TargetRect()),
root_bounds_pointer, FloatRect(geometry.IntersectionRect()),
geometry.DoesIntersect(), is_visible, Target());
Observer()->EnqueueIntersectionObserverEntry(*new_entry);
SetLastThresholdIndex(new_threshold_index);
SetWasVisible(is_visible);
}
}
void IntersectionObservation::Disconnect() {
DCHECK(Observer());
if (target_)
Target()->EnsureIntersectionObserverData().RemoveObservation(*Observer());
observer_.Clear();
}
void IntersectionObservation::UpdateShouldReportRootBoundsAfterDomChange() {
if (!Observer()->RootIsImplicit()) {
should_report_root_bounds_ = true;
return;
}
should_report_root_bounds_ = false;
LocalFrame* target_frame = Target()->GetDocument().GetFrame();
if (!target_frame)
return;
Frame& root_frame = target_frame->Tree().Top();
if (&root_frame == target_frame) {
should_report_root_bounds_ = true;
} else {
should_report_root_bounds_ =
target_frame->GetSecurityContext()->GetSecurityOrigin()->CanAccess(
root_frame.GetSecurityContext()->GetSecurityOrigin());
}
}
void IntersectionObservation::Trace(blink::Visitor* visitor) {
visitor->Trace(observer_);
visitor->Trace(target_);
}
} // namespace blink
| 38.139535 | 91 | 0.707317 | [
"geometry",
"vector"
] |
c557095663fa9fe25543c54dd7b54369fcb3183b | 18,529 | hpp | C++ | include/ODBCLSLB/STMT.hpp | aliakseis/odbcpp | 7dc71f3019502674a15cac52dd90aa46e1183594 | [
"MIT"
] | null | null | null | include/ODBCLSLB/STMT.hpp | aliakseis/odbcpp | 7dc71f3019502674a15cac52dd90aa46e1183594 | [
"MIT"
] | null | null | null | include/ODBCLSLB/STMT.hpp | aliakseis/odbcpp | 7dc71f3019502674a15cac52dd90aa46e1183594 | [
"MIT"
] | null | null | null | #pragma once
///////////////////////////////////////////////////////////
//////////////////////// statements
///////////////////////////////////////////////////////////
class odbcEXPORTED odbcSTMT : public odbcBASE {
protected:
/***************************************************
pConn
Pointer to owning connection object.
***************************************************/
odbcCONNECT* pConn;
/***************************************************
hstmt
ODBC statement handle.
***************************************************/
HSTMT hstmt{};
/***************************************************
lpszStmt
SQL statement string.
***************************************************/
LPUCSTR lpszStmt;
/***************************************************
pParmBindings
Array of parameter bindings represented by
sPARMBIND structs.
***************************************************/
const sPARMBIND* pParmBindings;
/***************************************************
ParmCount
count of sPARMBIND structs in array.
***************************************************/
UWORD ParmCount;
/***************************************************
pParms
Pointer to parameter data structure.
***************************************************/
void* pParms;
/***************************************************
bError
Non-zero if an error occurred (useful if error
occurs during construction).
***************************************************/
bool bError;
/***************************************************
bPrepared
Non-zero if we have prepared the statement.
***************************************************/
bool bPrepared;
/***************************************************
bParmsBound
Non-zero if we have bound the parameters represented
by the array of sPARMBIND structures.
***************************************************/
bool bParmsBound;
/***************************************************
bExecuted
Non-zero if we have executed the SQL statement
via a call to Execute or ExecDirect member functions.
***************************************************/
bool bExecuted;
/***************************************************
iParm
Index of last sPARMBIND structure processed.
***************************************************/
UWORD iParm;
/***************************************************
iParmRow
Index of last parameter set processed, when multiple
parameter sets are indicated by calling ParamOptions.
***************************************************/
UDWORD iParmRow;
// new in v2.0
/***************************************************
iParamOptRowCount
Number of parameter rows passed in call to
ParamOptions.
***************************************************/
UDWORD iParamOptRowCount;
// end new in v2.0
public:
/***************************************************
odbcSTMT
Constructor.
Arguments:
podbcCONNECT pC
Connection object pointer.
LPUCSTR lpszStmt
SQL statement string. Default value
is NULL.
bool bPrepare
If true (non-zero), SQLPrepare should
be invoked to prepare the SQL statement.
Default value is false.
bool bExecute
If true (non-zero), SQLExecute should
be invoked (if bPrepare was non-zero)
or SQLExecDirect should be invoked
(if bprepare was zero) to execute the SQL
statement. Default value is false.
cpsPARMBIND psParmBindings
If non-NULL, address of array of structures
defining the binding of parameters in the
SQL statement to members of the structure
containing parameter values at execution
time. Default value is NULL.
UWORD uParmCount
Count of array elements in psParmBindings.
Default value is 0.
void* pvParmStruct
Address of structure containing parameter
values. Default value is NULL.
***************************************************/
odbcSTMT(
odbcCONNECT* pC,
LPUCSTR lpszSentStmt = NULL,
const sPARMBIND* psParmBindings = NULL,
UWORD uParmCount = 0,
void* pvParmStruct = NULL
);
odbcSTMT(
odbcCONNECT* pC,
LPCSTR lpszSentStmt,
const sPARMBIND* psParmBindings = NULL,
UWORD uParmCount = 0,
void* pvParmStruct = NULL
);
/***************************************************
~odbcSTMT
Destructor.
***************************************************/
virtual ~odbcSTMT();
/***************************************************
SetParmBindings
Set value of protected data members that define
bindings between members of parameter structure
and SQL statement parameters, as defined by the
array of sPARMBIND structs..
***************************************************/
virtual void SetParmBindings
(
const sPARMBIND* psParmBindings = NULL,
UWORD uParmCount = 0,
void* pvParmStruct = NULL
)
{
pParmBindings = psParmBindings;
ParmCount = uParmCount;
pParms = pvParmStruct;
bExecuted = bParmsBound = false;
}
/***************************************************
LastParmProcessed
Zero-based index of the last parameter processed
by SetParams() (useful if an error occurs).
***************************************************/
virtual UWORD LastParmProcessed()
{
return iParm;
}
/***************************************************
GetHstmt
Get ODBC HSTMT associated with this statement.
***************************************************/
virtual HSTMT GetHstmt() { return hstmt; }
/***************************************************
GetParmBindings
Get parameter bindings array address, count,
and struct address. Note that the first and
third arguments are addresses of pointers (pointers
to pointers).
***************************************************/
virtual void GetParmBindings
(
const sPARMBIND** ppsParmBindings,
UWORD * puParmCount,
void* * ppvParmStruct
)
{
*ppsParmBindings = pParmBindings;
*puParmCount = ParmCount;
*ppvParmStruct = pParms;
}
/***************************************************
SetStmt
Sets the SQL command string associated with
the statement. You may also need to call
ResetParams() if parameter bindings have
taken place.
***************************************************/
virtual LPUCSTR SetStmt(LPUCSTR Stmt)
{
LPUCSTR Temp = lpszStmt;
lpszStmt = Stmt;
return Temp;
}
virtual LPCSTR SetStmt(LPSTR Stmt)
{
LPCSTR Temp = (LPCSTR)lpszStmt;
lpszStmt = (LPUCSTR)Stmt;
return Temp;
}
/***************************************************
GetStmt
Get current SQL command string associated with
the statement.
***************************************************/
virtual LPUCSTR GetStmt()
{
return lpszStmt;
}
/***************************************************
GetParmRow
Get index of last parameter set processed, when multiple
parameter sets are indicated by calling ParamOptions.
***************************************************/
virtual UDWORD GetParmRow()
{
return iParmRow;
}
/***************************************************
ErrorFlag
Gets current value of internal error flag; useful
if determining if an error occurred during construc-
tion when return codes were not available.
***************************************************/
virtual bool ErrorFlag()
{
return bError;
}
/***************************************************
Prepared
true if SQLPrepare was called successfully
already on this statement object.
***************************************************/
virtual bool Prepared()
{
return bPrepared;
}
/***************************************************
ParmsBound
Returns true if parameter bindings have been
done on this statement.
***************************************************/
virtual bool ParmsBound()
{
return bParmsBound;
}
/***************************************************
Executed
Returns true if a successful call to SQLExecute
or SQLExecDirect has occurred on this object.
***************************************************/
virtual bool Executed()
{
return bExecuted;
}
////////////////////////////////////////////////////////
////////////////////// core functions //////////////////
////////////////////////////////////////////////////////
/***************************************************
Cancel
Invoke SQLCancel.
***************************************************/
virtual RETCODE Cancel();
/***************************************************
Close
Call SQLFreeStmt with SQL_CLOSE argument.
***************************************************/
virtual RETCODE Close();
/***************************************************
ResetParams
Remove old parameter bindings by calling SQLFreeStmt
with SQL_RESET_PARAMS flag.
***************************************************/
virtual RETCODE ResetParams();
/***************************************************
RowCount
Get count of rows affected by the statement. Overloaded
to two versions: one returns a result code, and the count
is returned in the signed double-word pointed to by pcrow;
the other version returns the count directly.
***************************************************/
virtual RETCODE RowCount(
SDWORD *pcrow
);
virtual SDWORD RowCount();
/***************************************************
Prepare
Invoke SQLPrepare; bind parameters if parameter
bindings need to be done. Overloaded version without
argument prepares statement stored internally.
***************************************************/
virtual RETCODE Prepare(LPUCSTR szSqlStr);
virtual RETCODE Prepare(LPSTR szSqlStr)
{
return Prepare((LPUCSTR)szSqlStr);
}
virtual RETCODE Prepare();
/***************************************************
ExecDirect
Invoke SQLExecDirect.
***************************************************/
virtual RETCODE ExecDirect(LPUCSTR szSqlStr);
virtual RETCODE ExecDirect(LPSTR szSqlStr)
{
return ExecDirect((LPUCSTR)szSqlStr);
}
/***************************************************
Execute
Invoke SQLExecute.
***************************************************/
virtual RETCODE Execute();
/***************************************************
SetParams
Invoke SetParam member function passing internal array of
parameter bindings.
***************************************************/
bool SetParams();
/***************************************************
SetParam
Invoke SQLSetParam to bind a parameter.
***************************************************/
virtual RETCODE SetParam(
UWORD ipar,
SWORD fCType,
SWORD fSqlType,
UDWORD cbColDef,
SWORD ibScale,
void* rgbValue,
SDWORD *pcbValue);
/***************************************************
SetParam
Bind multiple parameters as represented by the
array of sPARMBIND structures pointed to by
psParmBindings. The count of structures is
passed as the uCount argument.If desired, these
are bound to the structure pointed to by pvBuf.
(You can also use the constants SQL_DATA_AT_EXEC
and SQL_NULL_DATA to indicate run-time parameter
binding or null data values; see sqlstruc.hpp
for instructions).
One disadvantage is that this function binds
only a single value to each parameter.
***************************************************/
virtual RETCODE SetParam(
const sPARMBIND* psParmBindings,
UWORD uCount,
void* pvBuf
);
/***************************************************
RegisterError
Get more information on the most recent error code
from an ODBC operation. Results can be retrieved using
member functions in the parent odbcBASE class.
This function calls the base class member function Error()
with arguments appropriate for this object type.
***************************************************/
RETCODE RegisterError() override;
////////////////////////////////////////////////////////
////////////////////// level 1 functions ///////////////
////////////////////////////////////////////////////////
/***************************************************
GetStmtOption
GetStmtOption returns the value of a given
option for this statement.
***************************************************/
virtual UDWORD GetStmtOption(UWORD fOption);
/***************************************************
SetStmtOption
SetStmtOption sets the value of a given
option for this statement.
***************************************************/
virtual RETCODE SetStmtOption(UWORD fOption, UDWORD ulValue);
/***************************************************
ParamData
Invoke SQLParamData.
***************************************************/
virtual RETCODE ParamData(void* *prgbValue);
/***************************************************
PutData
Invoke SQLPutData.
***************************************************/
virtual RETCODE PutData(
void* prgbValue,
SDWORD cbValue);
/***************************************************
DescribeParam
Invoke SQLDescribeParam.
***************************************************/
virtual RETCODE DescribeParam(
UWORD ipar,
SWORD *pfSqlType,
UDWORD *pcbColDef,
SWORD *pibScale,
SWORD *pfNullable
);
virtual RETCODE DescribeParam(
UWORD ipar,
sPARMBIND* pParmBind
);
/***************************************************
CTypeFromSqlType
Given SQL data type, return corresponding default
C data type.
***************************************************/
virtual SWORD CTypeFromSqlType(
SWORD fSqlType
);
/***************************************************
NumParams
Invoke SQLNumParams.
***************************************************/
virtual RETCODE NumParams(
SWORD *pcpar
);
virtual SWORD NumParams();
/***************************************************
ParamOptions
Invoke SQLParamOptions.
***************************************************/
virtual RETCODE ParamOptions(
UDWORD crow,
UDWORD *pirow);
virtual RETCODE ParamOptions(UDWORD crow);
////////////////////////////////////////////////
///////////// statement executors //////////////
////////////////////////////////////////////////
/***************************************************
DoStmt
Execute a statement using SQLExecute or SQLExecDirect
depending on the value of the bPrepared flag
(set when SQLPrepare is successfully executed).
***************************************************/
virtual bool DoStmt();
/***************************************************
pParmStruct
Returns address of parameter structure.
***************************************************/
virtual void* pParmStruct()
{
return pParms;
}
// new in v2.0
#if (ODBCVER >= 0x0200)
/***************************************************
BindParameter
Bind storage for parameter data.
***************************************************/
virtual RETCODE BindParameter
(
UWORD ipar,
SWORD fParamType,
SWORD fCType,
SWORD fSqlType,
UDWORD cbColDef,
SWORD ibScale,
void* rgbValue,
SDWORD cbValueMax,
SDWORD * pcbValue
);
#endif // #if (ODBCVER >= 0x0200)
// end new in v2.0
};
| 27.010204 | 71 | 0.377948 | [
"object"
] |
c56037391d32ad2c345720e3c77e1194bcaa1855 | 3,590 | cpp | C++ | leetcode/weekly/191.cpp | bvbasavaraju/competitive_programming | a82ffc1b639588a84f4273b44285d57cdc2f4b11 | [
"Apache-2.0"
] | 1 | 2020-05-05T13:06:51.000Z | 2020-05-05T13:06:51.000Z | leetcode/weekly/191.cpp | bvbasavaraju/competitive_programming | a82ffc1b639588a84f4273b44285d57cdc2f4b11 | [
"Apache-2.0"
] | null | null | null | leetcode/weekly/191.cpp | bvbasavaraju/competitive_programming | a82ffc1b639588a84f4273b44285d57cdc2f4b11 | [
"Apache-2.0"
] | null | null | null | /****************************************************
Date: May 31th, 2020
Successful submissions : 1
Time expiration : 1
Not Solved : 1
Wrong Answer/ Partial result : 1
link: https://leetcode.com/contest/weekly-contest-191
****************************************************/
#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <string>
#include <stack>
#include <queue>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <cmath>
#include <limits.h>
using namespace std;
/*
Q: 1464. Maximum Product of Two Elements in an Array
*/
class Solution1_t
{
public:
int maxProduct(vector<int>& nums)
{
sort(nums.begin(), nums.end());
int l = nums.size();
return (nums[l-1] - 1) * (nums[l-2] - 1);
}
};
/*
Q: 1465. Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts - time limit exceeded
*/
class Solution2_1
{
public:
int maxArea(int h, int w, vector<int>& hc, vector<int>& vc)
{
const int MOD = 1000000007;
hc.push_back(h);
vc.push_back(w);
sort(hc.begin(), hc.end());
sort(vc.begin(), vc.end());
int lh = hc.size();
int lc = vc.size();
int ans = 0;
vector<vector<int>> a(lh, vector<int>(lc, 0));
vector<vector<int>> p(lh, vector<int>(lc, 0));
for(int i = 0; i < lh; ++i)
{
int row_sum = 0;
for(int j = 0; j < lc; ++j)
{
p[i][j] = ((hc[i] % MOD) * (vc[j] % MOD)) % MOD;
if(i == 0 && j == 0)
{
a[i][j] = p[i][j];
}
else if(j == 0)
{
a[i][j] = (((p[i][j] - p[i-1][j]) % MOD ) + MOD) % MOD;
}
else if(i == 0)
{
a[i][j] = (((p[i][j] - p[i][j-1]) % MOD ) + MOD) % MOD;
}
else
{
a[i][j] = ((((((p[i][j] - p[i-1][j]) % MOD ) + MOD ) % MOD - row_sum) % MOD) + MOD ) % MOD;
}
row_sum = (row_sum + a[i][j]) % MOD;
ans = max(ans, a[i][j]);
}
}
return ans;
}
};
/*
Q: 1466. Reorder Routes to Make All Paths Lead to the City Zero
*/
class Solution3_t
{
private:
bool isReachable(int source, vector<bool>& v, unordered_map<int, vector<int>>& source_dest_map)
{
if(source == 0)
{
return true;
}
v[source] = true;
for(auto s : source_dest_map[source])
{
if(isReachable(s, v, source_dest_map))
{
v[source] = false;
return true;
}
}
v[source] = false;
return false;
}
public:
int minReorder(int n, vector<vector<int>>& connections)
{
unordered_map<int, vector<int>> source_dest_map;
unordered_map<int, vector<int>> dest_source_map;
for(auto c : connections)
{
source_dest_map[c[0]].push_back(c[1]);
dest_source_map[c[1]].push_back(c[0]);
}
int ans = 0;
vector<bool> v(n, false);
for(int i = 1; i < n; ++i)
{
if(!isReachable(i, v, source_dest_map))
{
if(dest_source_map.find(i) != dest_source_map.end() && dest_source_map[i].size() > 0)
{
source_dest_map[i].push_back(dest_source_map[i][0]);
}
ans++;
}
}
return ans;
}
};
/*
Q: 1467. Probability of a Two Boxes Having The Same Number of Distinct Balls
*/
class Solution4_t
{
public:
double getProbability(vector<int>& balls)
{
return 0.0;
}
};
int main()
{
{
Solution2_1 s2;
vector<int> h = {1,2,4};
vector<int> v = {1,3};
cout << s2.maxArea(5, 4, h, v) << endl;
}
return 0;
} | 20.397727 | 101 | 0.507799 | [
"vector"
] |
c567e3f311867fd95ab90898e75e4f3fa26c6036 | 19,471 | cpp | C++ | source/Core/Castor3D/Render/Ssao/SsaoBlurPass.cpp | DragonJoker/Castor3D | ee0b02eeda70cd235a224be306539850e32195f6 | [
"MIT"
] | 245 | 2015-10-29T14:31:45.000Z | 2022-03-31T13:04:45.000Z | source/Core/Castor3D/Render/Ssao/SsaoBlurPass.cpp | DragonJoker/Castor3D | ee0b02eeda70cd235a224be306539850e32195f6 | [
"MIT"
] | 64 | 2016-03-11T19:45:05.000Z | 2022-03-31T23:58:33.000Z | source/Core/Castor3D/Render/Ssao/SsaoBlurPass.cpp | DragonJoker/Castor3D | ee0b02eeda70cd235a224be306539850e32195f6 | [
"MIT"
] | 11 | 2018-05-24T09:07:43.000Z | 2022-03-21T21:05:20.000Z | #include "Castor3D/Render/Ssao/SsaoBlurPass.hpp"
#include "Castor3D/Engine.hpp"
#include "Castor3D/Buffer/UniformBufferPools.hpp"
#include "Castor3D/Buffer/UniformBuffer.hpp"
#include "Castor3D/Material/Texture/Sampler.hpp"
#include "Castor3D/Material/Texture/TextureLayout.hpp"
#include "Castor3D/Material/Texture/TextureUnit.hpp"
#include "Castor3D/Miscellaneous/ProgressBar.hpp"
#include "Castor3D/Miscellaneous/PipelineVisitor.hpp"
#include "Castor3D/Render/RenderPipeline.hpp"
#include "Castor3D/Render/RenderSystem.hpp"
#include "Castor3D/Render/Ssao/SsaoConfig.hpp"
#include "Castor3D/Shader/Program.hpp"
#include "Castor3D/Shader/Shaders/GlslLight.hpp"
#include "Castor3D/Shader/Shaders/GlslUtils.hpp"
#include "Castor3D/Shader/Ubos/GpInfoUbo.hpp"
#include "Castor3D/Shader/Ubos/MatrixUbo.hpp"
#include "Castor3D/Shader/Ubos/SsaoConfigUbo.hpp"
#include <CastorUtils/Design/ResourceCache.hpp>
#include <CastorUtils/Graphics/RgbaColour.hpp>
#include <ashespp/Image/Image.hpp>
#include <ashespp/Pipeline/GraphicsPipelineCreateInfo.hpp>
#include <ashespp/RenderPass/RenderPassCreateInfo.hpp>
#include <ShaderWriter/Source.hpp>
#include <RenderGraph/FrameGraph.hpp>
CU_ImplementCUSmartPtr( castor3d, SsaoBlurPass )
using namespace castor;
namespace castor3d
{
namespace
{
enum Idx : uint32_t
{
SsaoCfgUboIdx = 0u,
GpInfoUboIdx,
BlurCfgUboIdx,
NmlImgIdx,
InpImgIdx,
BntImgIdx,
};
ShaderPtr getVertexProgram()
{
using namespace sdw;
VertexWriter writer;
// Shader inputs
auto position = writer.declInput< Vec2 >( "position", 0u );
// Shader outputs
auto out = writer.getOut();
writer.implementFunction< Void >( "main"
, [&]()
{
out.vtx.position = vec4( position, 0.0_f, 1.0_f );
} );
return std::make_unique< ast::Shader >( std::move( writer.getShader() ) );
}
ShaderPtr getPixelProgram( bool useNormalsBuffer )
{
using namespace sdw;
FragmentWriter writer;
UBO_SSAO_CONFIG( writer, SsaoCfgUboIdx, 0u );
UBO_GPINFO( writer, GpInfoUboIdx, 0u );
Ubo configuration{ writer, "BlurConfiguration", BlurCfgUboIdx, 0u };
/** (1, 0) or (0, 1)*/
auto c3d_axis = configuration.declMember< IVec2 >( "c3d_axis" );
auto c3d_dummy = configuration.declMember< IVec2 >( "c3d_dummy" );
auto c3d_gaussian = configuration.declMember< Vec4 >( "c3d_gaussian", 2u );
configuration.end();
auto c3d_mapNormal = writer.declSampledImage< FImg2DRgba32 >( "c3d_mapNormal", NmlImgIdx, 0u, useNormalsBuffer );
auto c3d_mapInput = writer.declSampledImage< FImg2DRgba32 >( "c3d_mapInput", InpImgIdx, 0u );
auto c3d_mapBentInput = writer.declSampledImage< FImg2DRgba32 >( "c3d_mapBentInput", BntImgIdx, 0u );
/** Same size as result buffer, do not offset by guard band when reading from it */
auto c3d_readMultiplyFirst = writer.declConstant( "c3d_readMultiplyFirst", vec3( 2.0_f ) );
auto c3d_readAddSecond = writer.declConstant( "c3d_readAddSecond", vec3( 1.0_f ) );
auto in = writer.getIn();
// Shader outputs
auto pxl_fragColor = writer.declOutput< Vec3 >( "pxl_fragColor", 0u );
auto pxl_bentNormal = writer.declOutput< Vec3 >( "pxl_bentNormal", 1u );
#define result pxl_fragColor.r()
#define keyPassThrough pxl_fragColor.g()
/** Returns a number on (0, 1) */
auto unpackKey = writer.implementFunction< Float >( "unpackKey"
, [&]( Float const & p )
{
writer.returnStmt( p );
}
, InFloat{ writer, "p" } );
// Reconstruct camera-space P.xyz from screen-space S = (x, y) in
// pixels and camera-space z < 0. Assumes that the upper-left pixel center
// is at (0.5, 0.5) [but that need not be the location at which the sample tap
// was placed!]
// Costs 3 MADD. Error is on the order of 10^3 at the far plane, partly due to z precision.
auto reconstructCSPosition = writer.implementFunction< Vec3 >( "reconstructCSPosition"
, [&]( Vec2 const & S
, Float const & z
, Vec4 const & projInfo )
{
writer.returnStmt( vec3( sdw::fma( S.xy(), projInfo.xy(), projInfo.zw() ) * z, z ) );
}
, InVec2{ writer, "S" }
, InFloat{ writer, "z" }
, InVec4{ writer, "projInfo" } );
auto positionFromKey = writer.implementFunction< Vec3 >( "positionFromKey"
, [&]( Float const & key
, IVec2 const & ssCenter
, Vec4 const & projInfo )
{
auto z = writer.declLocale( "z"
, key * c3d_ssaoConfigData.farPlaneZ );
auto position = writer.declLocale( "position"
, reconstructCSPosition( vec2( ssCenter ) + vec2( 0.5_f )
, z
, projInfo ) );
writer.returnStmt( position );
}
, InFloat{ writer, "key" }
, InIVec2{ writer, "ssCenter" }
, InVec4{ writer, "projInfo" } );
auto getTapInformation = writer.implementFunction< Vec3 >( "getTapInformation"
, [&]( IVec2 const & tapLoc
, Float tapKey
, Float value
, Vec3 bent )
{
auto temp = writer.declLocale( "temp"
, c3d_mapInput.fetch( tapLoc, 0_i ).rgb() );
tapKey = unpackKey( temp.g() );
value = temp.r();
if ( useNormalsBuffer )
{
temp = c3d_mapNormal.fetch( tapLoc, 0_i ).xyz();
temp = normalize( sdw::fma( temp, c3d_readMultiplyFirst.xyz(), c3d_readAddSecond.xyz() ) );
}
else
{
temp = vec3( 0.0_f );
}
writer.returnStmt( temp );
}
, InIVec2{ writer, "tapLoc" }
, OutFloat{ writer, "tapKey" }
, OutFloat{ writer, "value" }
, OutVec3{ writer, "bent" } );
auto square = writer.implementFunction< Float >( "square"
, [&]( Float const & x )
{
writer.returnStmt( x * x );
}
, InFloat{ writer, "x" } );
auto calculateBilateralWeight = writer.implementFunction< Float >( "calculateBilateralWeight"
, [&]( Float const & key
, Float const & tapKey
, IVec2 const & tapLoc
, Vec3 const & normal
, Vec3 const & tapNormal
, Vec3 const & position )
{
auto scale = writer.declLocale( "scale"
, 1.5_f * c3d_ssaoConfigData.invRadius );
// The "bilateral" weight. As depth difference increases, decrease weight.
// The key values are in scene-specific scale. To make them scale-invariant, factor in
// the AO radius, which should be based on the scene scale.
auto depthWeight = writer.declLocale( "depthWeight"
, max( 0.0_f, 1.0_f - ( c3d_ssaoConfigData.edgeSharpness * 2000.0_f ) * abs( tapKey - key ) * scale ) );
auto k_normal = writer.declLocale( "k_normal"
, 1.0_f );
auto k_plane = writer.declLocale( "k_plane"
, 1.0_f );
// Prevents blending over creases.
auto normalWeight = writer.declLocale( "normalWeight"
, 1.0_f );
auto planeWeight = writer.declLocale( "planeWeight"
, 1.0_f );
if ( useNormalsBuffer )
{
auto normalCloseness = writer.declLocale( "normalCloseness"
, dot( tapNormal, normal ) );
IF( writer, c3d_ssaoConfigData.blurHighQuality == 0_i )
{
normalCloseness = normalCloseness * normalCloseness;
normalCloseness = normalCloseness * normalCloseness;
k_normal = 4.0_f;
}
FI;
auto normalError = writer.declLocale( "normalError"
, ( 1.0_f - normalCloseness ) * k_normal );
normalWeight = max( 1.0_f - c3d_ssaoConfigData.edgeSharpness * normalError, 0.0_f );
IF( writer, c3d_ssaoConfigData.blurHighQuality )
{
auto lowDistanceThreshold2 = writer.declLocale( "lowDistanceThreshold2"
, 0.001_f );
auto tapPosition = writer.declLocale( "tapPosition"
, positionFromKey( tapKey, tapLoc, c3d_ssaoConfigData.projInfo ) );
// Change position in camera space
auto dq = writer.declLocale( "dq"
, position - tapPosition );
// How far away is this point from the original sample
// in camera space? (Max value is unbounded)
auto distance2 = writer.declLocale( "distance2"
, dot( dq, dq ) );
// How far off the expected plane (on the perpendicular) is this point? Max value is unbounded.
auto planeError = writer.declLocale( "planeError"
, max( abs( dot( dq, tapNormal ) ), abs( dot( dq, normal ) ) ) );
// Minimum distance threshold must be scale-invariant, so factor in the radius
planeWeight = writer.ternary( distance2 * square( scale ) < lowDistanceThreshold2
, 1.0_f
, Float{ pow( max( 0.0_f
, 1.0_f - c3d_ssaoConfigData.edgeSharpness * 2.0 * k_plane * planeError / sqrt( distance2 ) )
, 2.0_f ) } );
}
FI;
}
writer.returnStmt( depthWeight * normalWeight * planeWeight );
}
, InFloat{ writer, "key" }
, InFloat{ writer, "tapKey" }
, InIVec2{ writer, "tapLoc" }
, InVec3{ writer, "normal" }
, InVec3{ writer, "tapNormal" }
, InVec3{ writer, "position" } );
writer.implementFunction< Void >( "main"
, [&]()
{
auto ssCenter = writer.declLocale( "ssCenter"
, ivec2( in.fragCoord.xy() ) );
auto temp = writer.declLocale( "temp"
, c3d_mapInput.fetch( ssCenter, 0_i ) );
auto sum = writer.declLocale( "sum"
, temp.r() );
auto bentNormal = writer.declLocale( "bentNormal"
, c3d_gpInfoData.readNormal( c3d_mapBentInput.fetch( ssCenter, 0_i ).xyz() ) );
keyPassThrough = temp.g();
auto key = writer.declLocale( "key"
, unpackKey( keyPassThrough ) );
auto normal = writer.declLocale( "normal"
, vec3( 0.0_f ) );
if ( useNormalsBuffer )
{
normal = normalize( c3d_gpInfoData.readNormal( c3d_mapNormal.fetch( ssCenter, 0_i ).xyz() ) );
}
IF( writer, key == 1.0_f )
{
// Sky pixel (if you aren't using depth keying, disable this test)
result = sum;
pxl_bentNormal = c3d_gpInfoData.writeNormal( bentNormal );
writer.returnStmt();
}
FI;
// Base weight for depth falloff. Increase this for more blurriness,
// decrease it for better edge discrimination
auto BASE = writer.declLocale( "BASE"
, c3d_gaussian[0_u][0_u] );
auto totalWeight = writer.declLocale( "totalWeight"
, BASE );
sum *= totalWeight;
bentNormal *= totalWeight;
auto position = writer.declLocale( "position"
, positionFromKey( key, ssCenter, c3d_ssaoConfigData.projInfo ) );
FOR( writer, Int, r, -c3d_ssaoConfigData.blurRadius, r <= c3d_ssaoConfigData.blurRadius, ++r )
{
// We already handled the zero case above. This loop should be unrolled and the static branch optimized out,
// so the IF statement has no runtime cost
IF( writer, r != 0_i )
{
auto tapLoc = writer.declLocale( "tapLoc"
, ssCenter + c3d_axis * ( r * c3d_ssaoConfigData.blurStepSize ) );
// spatial domain: offset gaussian tap
auto absR = writer.declLocale( "absR"
, writer.cast< UInt >( abs( r ) ) );
auto weight = writer.declLocale( "weight"
, 0.3_f + c3d_gaussian[absR % 2_u][absR / 2_u] );
auto tapKey = writer.declLocale< Float >( "tapKey" );
auto value = writer.declLocale< Float >( "value" );
auto bent = writer.declLocale< Vec3 >( "bent" );
auto tapNormal = writer.declLocale( "tapNormal"
, getTapInformation( tapLoc, tapKey, value, bent ) );
auto bilateralWeight = writer.declLocale( "bilateralWeight"
, calculateBilateralWeight( key
, tapKey
, tapLoc
, normal
, tapNormal
, position ) );
weight *= bilateralWeight;
sum += value * weight;
bentNormal += bent * weight;
totalWeight += weight;
}
FI;
}
ROF;
auto const epsilon = writer.declLocale( "epsilon"
, 0.0001_f );
result = sum / ( totalWeight + epsilon );
bentNormal /= ( totalWeight + epsilon );
pxl_bentNormal = c3d_gpInfoData.writeNormal( bentNormal );
} );
return std::make_unique< ast::Shader >( std::move( writer.getShader() ) );
#undef result
#undef keyPassThrough
}
Texture doCreateTexture( RenderDevice const & device
, crg::ResourceHandler & handler
, String const & name
, VkFormat format
, VkExtent2D const & size )
{
return { device
, handler
, name
, 0u
, { size.width, size.height, 1u }
, 1u
, 1u
, format
, ( VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
| VK_IMAGE_USAGE_SAMPLED_BIT ) };
}
castor::String getName( bool useNormalsBuffer )
{
return "SsaoBlur" + ( useNormalsBuffer ? std::string{ "Nml" } : std::string{} );
}
crg::rq::Config getConfig( VkExtent2D const & renderSize
, SsaoConfig const & ssaoConfig
, ashes::PipelineShaderStageCreateInfoArray const & stages0
, ashes::PipelineShaderStageCreateInfoArray const & stages1 )
{
crg::rq::Config result;
result.renderSize( renderSize );
result.enabled( &ssaoConfig.enabled );
result.programs( { crg::makeVkArray< VkPipelineShaderStageCreateInfo >( stages0 )
, crg::makeVkArray< VkPipelineShaderStageCreateInfo >( stages1 ) } );
return result;
}
}
//*********************************************************************************************
SsaoBlurPass::RenderQuad::RenderQuad( crg::FramePass const & pass
, crg::GraphContext & context
, crg::RunnableGraph & graph
, crg::rq::Config config
, SsaoConfig const & ssaoConfig )
: crg::RenderQuad{ pass
, context
, graph
, 2u
, std::move( config ) }
, ssaoConfig{ ssaoConfig }
{
}
uint32_t SsaoBlurPass::RenderQuad::doGetPassIndex()const
{
return ssaoConfig.useNormalsBuffer ? 1u : 0u;
}
//*********************************************************************************************
SsaoBlurPass::Program::Program( RenderDevice const & device
, bool useNormalsBuffer )
: vertexShader{ VK_SHADER_STAGE_VERTEX_BIT
, getName( useNormalsBuffer )
, getVertexProgram() }
, pixelShader{ VK_SHADER_STAGE_FRAGMENT_BIT
, getName( useNormalsBuffer )
, getPixelProgram( useNormalsBuffer ) }
, stages{ makeShaderState( device, vertexShader )
, makeShaderState( device, pixelShader ) }
{
}
//*********************************************************************************************
SsaoBlurPass::SsaoBlurPass( crg::FrameGraph & graph
, RenderDevice const & device
, ProgressBar * progress
, crg::FramePass const & previousPass
, String const & prefix
, VkExtent2D const & size
, SsaoConfig const & config
, SsaoConfigUbo & ssaoConfigUbo
, GpInfoUbo const & gpInfoUbo
, Point2i const & axis
, Texture const & input
, Texture const & bentInput
, Texture const & normals )
: m_device{ device }
, m_graph{ graph }
, m_ssaoConfigUbo{ ssaoConfigUbo }
, m_gpInfoUbo{ gpInfoUbo }
, m_bentInput{ bentInput }
, m_config{ config }
, m_size{ size }
, m_result{ doCreateTexture( m_device, graph.getHandler(), "SsaoBlur" + prefix, SsaoBlurPass::ResultFormat, m_size ) }
, m_bentResult{ doCreateTexture( m_device, graph.getHandler(), "SsaoBentNormals" + prefix, m_bentInput.getFormat(), m_size ) }
, m_configurationUbo{ m_device.uboPools->getBuffer< Configuration >( 0u ) }
, m_programs{ Program{ device, false }, Program{ device, true } }
{
stepProgressBar( progress, "Creating SSAO " + prefix + " blur pass" );
auto & configuration = m_configurationUbo.getData();
configuration.axis = axis;
auto & pass = graph.createPass( "SsaoBlur" + prefix
, [this, progress, prefix, config]( crg::FramePass const & pass
, crg::GraphContext & context
, crg::RunnableGraph & graph )
{
stepProgressBar( progress, "Initialising SSAO " + prefix + " blur pass" );
auto result = std::make_unique< RenderQuad >( pass
, context
, graph
, getConfig( m_size
, config
, m_programs[0].stages
, m_programs[1].stages )
, m_config );
m_device.renderSystem.getEngine()->registerTimer( graph.getName() + "/SSAO"
, result->getTimer() );
return result;
} );
m_lastPass = &pass;
pass.addDependency( previousPass );
m_ssaoConfigUbo.createPassBinding( pass, SsaoCfgUboIdx );
m_gpInfoUbo.createPassBinding( pass, GpInfoUboIdx );
m_configurationUbo.createPassBinding( pass, "SsaoBlurCfg", BlurCfgUboIdx );
pass.addSampledView( normals.sampledViewId
, NmlImgIdx
, VK_IMAGE_LAYOUT_UNDEFINED );
pass.addSampledView( input.sampledViewId
, InpImgIdx
, VK_IMAGE_LAYOUT_UNDEFINED );
pass.addSampledView( bentInput.sampledViewId
, BntImgIdx
, VK_IMAGE_LAYOUT_UNDEFINED );
pass.addOutputColourView( m_result.targetViewId, opaqueWhiteClearColor );
pass.addOutputColourView( m_bentResult.targetViewId, transparentBlackClearColor );
m_result.create();
m_bentResult.create();
}
void SsaoBlurPass::update( CpuUpdater & updater )
{
if ( m_config.blurRadius.isDirty() )
{
auto & configuration = m_configurationUbo.getData();
switch ( m_config.blurRadius.value().value() )
{
case 1u:
configuration.gaussian[0][0] = 0.5f;
configuration.gaussian[0][1] = 0.25f;
break;
case 2u:
configuration.gaussian[0][0] = 0.153170f;
configuration.gaussian[0][1] = 0.144893f;
configuration.gaussian[0][2] = 0.122649f;
break;
case 3u:
configuration.gaussian[0][0] = 0.153170f;
configuration.gaussian[0][1] = 0.144893f;
configuration.gaussian[0][2] = 0.122649f;
configuration.gaussian[0][3] = 0.092902f;
break;
case 4u:
configuration.gaussian[0][0] = 0.153170f;
configuration.gaussian[0][1] = 0.144893f;
configuration.gaussian[0][2] = 0.122649f;
configuration.gaussian[0][3] = 0.092902f;
configuration.gaussian[1][0] = 0.062970f;
break;
case 5u:
configuration.gaussian[0][0] = 0.111220f;
configuration.gaussian[0][1] = 0.107798f;
configuration.gaussian[0][2] = 0.098151f;
configuration.gaussian[0][3] = 0.083953f;
configuration.gaussian[1][0] = 0.067458f;
configuration.gaussian[1][1] = 0.050920f;
break;
default:
configuration.gaussian[0][0] = 0.111220f;
configuration.gaussian[0][1] = 0.107798f;
configuration.gaussian[0][2] = 0.098151f;
configuration.gaussian[0][3] = 0.083953f;
configuration.gaussian[1][0] = 0.067458f;
configuration.gaussian[1][1] = 0.050920f;
configuration.gaussian[1][2] = 0.036108f;
break;
}
}
}
void SsaoBlurPass::accept( bool horizontal
, SsaoConfig & config
, PipelineVisitorBase & visitor )
{
if ( horizontal )
{
visitor.visit( "SSAO HBlurred AO"
, getResult()
, m_graph.getFinalLayout( getResult().sampledViewId ).layout
, TextureFactors{}.invert( true ) );
}
else
{
visitor.visit( "SSAO Blurred AO"
, getResult()
, m_graph.getFinalLayout( getResult().sampledViewId ).layout
, TextureFactors{}.invert( true ) );
}
if ( horizontal )
{
visitor.visit( "HBlurred Bent Normals"
, getBentResult()
, m_graph.getFinalLayout( getBentResult().sampledViewId ).layout
, TextureFactors{}.invert( true ) );
}
else
{
visitor.visit( "Blurred Bent Normals"
, getBentResult()
, m_graph.getFinalLayout( getBentResult().sampledViewId ).layout
, TextureFactors{}.invert( true ) );
}
if ( m_config.useNormalsBuffer )
{
visitor.visit( m_programs[1].vertexShader );
visitor.visit( m_programs[1].pixelShader );
}
else
{
visitor.visit( m_programs[0].vertexShader );
visitor.visit( m_programs[0].pixelShader );
}
config.accept( "SsaoBlur", visitor );
}
}
| 32.72437 | 128 | 0.647219 | [
"render"
] |
c569244a9117ab831534ce1e2ab74c10939cdb96 | 14,715 | cpp | C++ | src/bootd/event/DynamicEventDB.cpp | Tofee/bootd | e5cc02571c464aef785749f840e77ebcdb77cf58 | [
"Apache-2.0"
] | null | null | null | src/bootd/event/DynamicEventDB.cpp | Tofee/bootd | e5cc02571c464aef785749f840e77ebcdb77cf58 | [
"Apache-2.0"
] | null | null | null | src/bootd/event/DynamicEventDB.cpp | Tofee/bootd | e5cc02571c464aef785749f840e77ebcdb77cf58 | [
"Apache-2.0"
] | null | null | null | // Copyright (c) 2013-2018 LG Electronics, Inc.
//
// 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.
//
// SPDX-License-Identifier: Apache-2.0
#include "util/Logger.h"
#include "DynamicEventDB.h"
const char *DynamicEventDB::EVENT_BOOT_COMPLETE = "boot-complete";
const char *DynamicEventDB::KEY_READY = "ready";
const char *DynamicEventDB::KEY_TIME = "time";
const char *DynamicEventDB::KEY_EXTRA = "extra";
DynamicEventDB::DynamicEventDB()
: m_isInLoop(false),
m_waitTimeoutId(0),
m_waitEventTimeoutId(0),
m_waitFileTimeoutId(0),
m_dir(NULL),
m_dirMonitor(NULL),
m_dirMonitorId(0)
{
m_eventDatabase = pbnjson::Object();
}
DynamicEventDB::~DynamicEventDB()
{
}
bool DynamicEventDB::isWaitSomething()
{
return m_isInLoop;
}
bool DynamicEventDB::hasEvent(string eventName)
{
return m_eventDatabase.hasKey(eventName);
}
bool DynamicEventDB::getEventStatus(string eventName)
{
if (!m_eventDatabase.hasKey(eventName)) {
g_Logger.debugLog(Logger::MSGID_EVENT,
"No event status : '%s'",
eventName.c_str());
return false;
}
return m_eventDatabase[eventName][KEY_READY].asBool();
}
bool DynamicEventDB::getEventStatus(string eventName, JValue &extra)
{
if (!getEventStatus(eventName))
return false;
extra = m_eventDatabase[eventName][KEY_EXTRA].duplicate();
return true;
}
bool DynamicEventDB::replaceEventsInfo(JValue &events, string origin, string &result)
{
result = origin;
for (int i = 0; i < events.arraySize(); i++) {
string pattern = "${" + events[i].asString() + "}";
string::size_type pos = result.find(pattern);
if (pos != string::npos) {
JValue extra;
if (!getEventStatus(events[i].asString(), extra))
return false;
result.replace(pos, pattern.size(), extra.asString());
}
}
return true;
}
bool DynamicEventDB::removeEvent(string eventName)
{
if (!m_eventDatabase.hasKey(eventName)) {
g_Logger.debugLog(Logger::MSGID_EVENT,
"'%s' event is not database",
eventName.c_str());
return true;
}
return m_eventDatabase.remove(eventName);
}
int DynamicEventDB::_waitTimeout(void* ctx)
{
g_Logger.debugLog(Logger::MSGID_EVENT, "Timeout is done");
DynamicEventDB *eventCore = (DynamicEventDB*)ctx;
eventCore->m_waitTimeoutId = 0;
if (!eventCore->m_isInLoop) {
g_Logger.warningLog(Logger::MSGID_EVENT, "Timeout is done without loop. This might be a bug");
} else {
eventCore->m_isInLoop = false;
}
return G_SOURCE_REMOVE;
}
bool DynamicEventDB::waitTimeout(GMainLoop* mainLoop, int seconds)
{
if (m_isInLoop) {
g_Logger.warningLog(Logger::MSGID_EVENT, "EventCore already waits something. This might be a bug");
return false;
}
g_Logger.debugLog(Logger::MSGID_EVENT,
"EventCore waits timeout(%d)",
seconds);
m_waitTimeoutId = g_timeout_add_seconds(seconds, DynamicEventDB::_waitTimeout, this);
m_isInLoop = true;
while (m_isInLoop) {
g_main_context_iteration(g_main_loop_get_context(mainLoop), TRUE);
}
return true;
}
int DynamicEventDB::_waitEventTimeout(void* ctx)
{
DynamicEventDB *eventCore = (DynamicEventDB*)ctx;
g_Logger.debugLog(Logger::MSGID_EVENT, "Event (%s) timeout is done", eventCore->m_waitEvent.c_str());
eventCore->m_waitEventTimeoutId = 0;
if (!eventCore->m_isInLoop) {
g_Logger.warningLog(Logger::MSGID_EVENT, "Timeout is done without loop. This might be a bug");
} else {
eventCore->m_isInLoop = false;
}
return G_SOURCE_REMOVE;
}
bool DynamicEventDB::existEvent(GMainLoop* mainLoop, string eventName, int seconds)
{
if (m_isInLoop) {
g_Logger.warningLog(Logger::MSGID_EVENT, "EventCore already waits something. This might be a bug");
return false;
}
if (m_eventDatabase.hasKey(eventName)) {
g_Logger.debugLog(Logger::MSGID_EVENT,
"'%s' event is already occured",
eventName.c_str());
return true;
}
g_Logger.debugLog(Logger::MSGID_EVENT,
"EventCore waits event(%s)/timeout(%d)",
eventName.c_str(), seconds);
m_existEvent = eventName;
m_waitEventTimeoutId = g_timeout_add_seconds(seconds, DynamicEventDB::_waitEventTimeout, this);
m_isInLoop = true;
while (m_isInLoop) {
g_main_context_iteration(g_main_loop_get_context(mainLoop), TRUE);
}
return true;
}
bool DynamicEventDB::waitEvent(GMainLoop* mainLoop, string eventName, int seconds)
{
if (m_isInLoop) {
g_Logger.warningLog(Logger::MSGID_EVENT, "EventCore already waits something. This might be a bug");
return false;
}
if (m_eventDatabase.hasKey(eventName) && m_eventDatabase[eventName][KEY_READY].asBool()) {
g_Logger.debugLog(Logger::MSGID_EVENT,
"'%s' event is already completed",
eventName.c_str());
return true;
}
g_Logger.debugLog(Logger::MSGID_EVENT,
"EventCore waits event(%s)/timeout(%d)",
eventName.c_str(), seconds);
m_waitEvent = eventName;
m_waitEventTimeoutId = g_timeout_add_seconds(seconds, DynamicEventDB::_waitEventTimeout, this);
m_isInLoop = true;
while (m_isInLoop) {
g_main_context_iteration(g_main_loop_get_context(mainLoop), TRUE);
}
return true;
}
int DynamicEventDB::_waitAsyncEventTimeout(void* ctx)
{
AsyncEventData* asyncEvent = (AsyncEventData*)ctx;
g_Logger.debugLog(Logger::MSGID_EVENT,
"Async event (%s) timeout is done",
asyncEvent->m_eventName.c_str());
DynamicEventDB::instance()->callAsyncEventListeners(asyncEvent->m_eventName);
return G_SOURCE_REMOVE;
}
bool DynamicEventDB::waitAsyncEvent(GMainLoop* mainLoop, string eventName, int seconds, DynamicEventDBListener *listener)
{
if (m_eventDatabase.hasKey(eventName) && m_eventDatabase[eventName][KEY_READY].asBool()) {
g_Logger.debugLog(Logger::MSGID_EVENT,
"'%s' event is already completed",
eventName.c_str());
listener->onWaitAsyncEvent(eventName);
return true;
}
AsyncEventData* asyncEvent = new AsyncEventData();
guint waitAsyncEventTimeoutId = g_timeout_add_seconds(seconds, DynamicEventDB::_waitAsyncEventTimeout, asyncEvent);
asyncEvent->m_eventName = eventName;
asyncEvent->m_listener = listener;
asyncEvent->m_timeoutId = waitAsyncEventTimeoutId;
g_Logger.debugLog(Logger::MSGID_EVENT,
"EventCore waits async event(%s)/timeout(%d)/id(%u)",
eventName.c_str(), seconds, waitAsyncEventTimeoutId);
map<string, vector<AsyncEventData*>>::iterator asyncEventIter = m_asyncEventData.find(eventName);
if (asyncEventIter != m_asyncEventData.end()) {
asyncEventIter->second.push_back(asyncEvent);
} else {
vector<AsyncEventData*> asyncEventVector;
asyncEventVector.push_back(asyncEvent);
m_asyncEventData.insert(pair<string, vector<AsyncEventData*>> (eventName, asyncEventVector));
}
return true;
}
bool DynamicEventDB::triggerEvent(string eventName, JValue extra)
{
if (!m_eventDatabase.hasKey(eventName)) {
pbnjson::JValue event = pbnjson::Object();
event.put(KEY_READY, true);
event.put(KEY_EXTRA, extra);
m_eventDatabase.put(eventName, event);
g_Logger.debugLog(Logger::MSGID_EVENT,
"Add new event : '%s' [Status : trigger] %s",
eventName.c_str(),
extra.stringify().c_str());
goto DONE;
}
m_eventDatabase[eventName].put(KEY_READY, true);
m_eventDatabase[eventName].put(KEY_EXTRA, extra);
DONE:
if ((m_waitEvent == eventName || m_existEvent == eventName) && m_waitEventTimeoutId > 0) {
g_source_remove(m_waitEventTimeoutId);
m_waitEventTimeoutId = 0;
m_isInLoop = false;
}
g_Logger.debugLog(Logger::MSGID_EVENT,
"Trigger '%s' event (%s)",
eventName.c_str(),
extra.stringify().c_str());
callEventListeners(eventName, TriggerEvent);
if (!m_asyncEventData.empty())
callAsyncEventListeners(eventName);
return true;
}
bool DynamicEventDB::clearEvent(string eventName)
{
if (!m_eventDatabase.hasKey(eventName)) {
pbnjson::JValue event = pbnjson::Object();
event.put(KEY_READY, false);
event.put(KEY_EXTRA, "");
m_eventDatabase.put(eventName, event);
g_Logger.debugLog(Logger::MSGID_EVENT,
"Add new event : '%s', [Status : clear]",
eventName.c_str());
goto DONE;
}
m_eventDatabase[eventName].put(KEY_READY, false);
m_eventDatabase[eventName].put(KEY_EXTRA, pbnjson::Object());
DONE:
if (m_existEvent == eventName && m_waitEventTimeoutId > 0) {
g_source_remove(m_waitEventTimeoutId);
m_waitEventTimeoutId = 0;
m_isInLoop = false;
}
callEventListeners(eventName, ClearEvent);
return true;
}
void DynamicEventDB::callEventListeners(string eventName, EventHandleType type)
{
struct timespec curTime;
char timeBuffer[256] = { 0, };
g_Logger.getCurrentTime(curTime);
sprintf(timeBuffer, "%ld.%09ld", curTime.tv_sec, curTime.tv_nsec);
m_eventDatabase[eventName].put(KEY_TIME, timeBuffer);
}
void DynamicEventDB::callAsyncEventListeners(string eventName)
{
map<string, vector<AsyncEventData*>>::iterator asyncEventIter = m_asyncEventData.find(eventName);
if (asyncEventIter == m_asyncEventData.end()) {
g_Logger.debugLog(Logger::MSGID_EVENT, "No wait async event (%s)", eventName.c_str());
return;
}
for (vector<AsyncEventData*>::iterator iter = asyncEventIter->second.begin(); iter != asyncEventIter->second.end(); ) {
(*iter)->m_listener->onWaitAsyncEvent(eventName);
g_Logger.debugLog(Logger::MSGID_EVENT, "Remove async event timeout resource (%u)", (*iter)->m_timeoutId);
g_source_remove((*iter)->m_timeoutId);
delete *iter;
iter = asyncEventIter->second.erase(iter);
}
m_asyncEventData.erase(asyncEventIter);
}
int DynamicEventDB::_waitFileTimeout(void* ctx)
{
g_Logger.debugLog(Logger::MSGID_EVENT, "File timeout is done");
DynamicEventDB *eventCore = (DynamicEventDB*)ctx;
eventCore->m_waitFileTimeoutId = 0;
eventCore->cleanFileMonitor();
if (!eventCore->m_isInLoop) {
g_Logger.warningLog(Logger::MSGID_EVENT, "Timeout is done without loop. This might be a bug");
} else {
eventCore->m_isInLoop = false;
}
return G_SOURCE_REMOVE;
}
void DynamicEventDB::_waitFile(GFileMonitor *monitor,
GFile *file,
GFile *other_file,
GFileMonitorEvent event_type,
gpointer user_data)
{
DynamicEventDB *eventCore = (DynamicEventDB *)user_data;
if (G_FILE_MONITOR_EVENT_CREATED != event_type) {
g_Logger.debugLog(Logger::MSGID_EVENT, "Not creation event. Keep waiting...");
return;
}
// UTP service is watching initfile as well. Don't remove file.
// if (!g_file_delete(file, NULL, NULL)) {
// g_Logger.errorLog(Logger::MSGID_EVENT, "Deleting file fails");
//}
if (eventCore->m_waitFileTimeoutId > 0) {
g_source_remove(eventCore->m_waitFileTimeoutId);
eventCore->m_waitFileTimeoutId = 0;
}
eventCore->m_isInLoop = false;
g_Logger.debugLog(Logger::MSGID_EVENT, "EventCore exits because file is created");
eventCore->cleanFileMonitor();
}
bool DynamicEventDB::waitFile(GMainLoop* mainLoop, string filePath, int seconds)
{
if (m_isInLoop) {
g_Logger.warningLog(Logger::MSGID_EVENT, "EventCore already waits something. This might be a bug");
return false;
}
if (access(filePath.c_str(), F_OK) == 0) {
g_Logger.debugLog(Logger::MSGID_EVENT, "'%s' file is already created", filePath.c_str());
// UTP service is watching initfile as well. Don't remove file.
// unlink(filePath.c_str());
return true;
}
m_dir = g_file_new_for_path(filePath.c_str());
m_dirMonitor = g_file_monitor_file(m_dir, G_FILE_MONITOR_NONE, NULL, NULL);
if (m_dirMonitor == NULL) {
g_object_unref(m_dir);
g_Logger.warningLog(Logger::MSGID_EVENT, "Creating monitor fails.");
return false;
}
g_Logger.debugLog(Logger::MSGID_EVENT, "EventCore waits file(%s)/timeout(%d)", filePath.c_str(), seconds);
m_dirMonitorId = g_signal_connect(m_dirMonitor, "changed", G_CALLBACK(_waitFile), this);
m_waitFileTimeoutId = g_timeout_add_seconds(seconds, &DynamicEventDB::_waitFileTimeout, this);
m_isInLoop = true;
while (m_isInLoop) {
g_main_context_iteration(g_main_loop_get_context(mainLoop), TRUE);
}
return true;
}
void DynamicEventDB::cleanFileMonitor()
{
if (0 != m_dirMonitorId)
g_signal_handler_disconnect(m_dirMonitor, m_dirMonitorId);
if (NULL != m_dirMonitor)
g_object_unref(m_dirMonitor);
if (NULL != m_dir)
g_object_unref(m_dir);
}
void DynamicEventDB::printAsyncEventMap()
{
g_Logger.debugLog(Logger::MSGID_EVENT, "Information of async event map");
if (m_asyncEventData.empty()) {
g_Logger.debugLog(Logger::MSGID_EVENT, "No data");
return;
}
map<string, vector<AsyncEventData*>>::iterator iter;
for(iter = m_asyncEventData.begin(); iter != m_asyncEventData.end(); iter++) {
g_Logger.debugLog(Logger::MSGID_EVENT, "\tEvent : %s", iter->first.c_str());
for(unsigned int i = 0; i < iter->second.size(); i++) {
g_Logger.debugLog(Logger::MSGID_EVENT, "\t\tG_SOURCE_ID : %u", iter->second[i]->m_timeoutId);
}
}
}
| 33.75 | 123 | 0.655386 | [
"object",
"vector"
] |
c56dbb7d2b5b55e54fb3d9aa423927cd8df72b7a | 4,460 | cpp | C++ | Samples/System/AdvancedExceptionHandling/SharedMemory/SharedMemory.cpp | acidburn0zzz/Xbox-GDK-Samples | 0a998ca467f923aa04bd124a5e5ca40fe16c386c | [
"MIT"
] | 1 | 2021-12-30T09:49:18.000Z | 2021-12-30T09:49:18.000Z | Samples/System/AdvancedExceptionHandling/SharedMemory/SharedMemory.cpp | acidburn0zzz/Xbox-GDK-Samples | 0a998ca467f923aa04bd124a5e5ca40fe16c386c | [
"MIT"
] | null | null | null | Samples/System/AdvancedExceptionHandling/SharedMemory/SharedMemory.cpp | acidburn0zzz/Xbox-GDK-Samples | 0a998ca467f923aa04bd124a5e5ca40fe16c386c | [
"MIT"
] | null | null | null | //--------------------------------------------------------------------------------------
// SharedMemory.cpp
//
// Advanced Technology Group (ATG)
// Copyright (C) Microsoft Corporation. All rights reserved.
//--------------------------------------------------------------------------------------
#include "pch.h"
#include "SharedMemory.h"
namespace SharedMemory
{
uint32_t c_sizeSharedMemory = sizeof(SharedMemoryBlock);
const wchar_t *g_sharedStartEventName = L"OutOfProcStartExceptionEvent";
const wchar_t *g_sharedFinishedEventName = L"OutOfProcFinishedExceptionEvent";
const wchar_t *g_sharedMemoryName = L"OutOfProcSharedMemory";
HANDLE g_sharedFileMappingHandle = nullptr;
HANDLE g_sharedStartEvent;
HANDLE g_sharedFinishedEvent;
SharedMemoryBlock *g_sharedMemory;
SharedMemoryBlock *InitSharedMemory()
{
bool needInitialMemoryClear = false;
// These Events have names which means if an Event has already been created with the same name then CreateEvent will return a handle to that Event
// This allows the communication between processes, they are each referencing the same Event object in the kernel
g_sharedStartEvent = CreateEvent(nullptr, FALSE, FALSE, g_sharedStartEventName);
g_sharedFinishedEvent = CreateEvent(nullptr, FALSE, FALSE, g_sharedFinishedEventName);
// A shared memory is created through a file mapping object that is not backed by a file including the page file
// The main reason no backing file is chosen for this shared memory is because that is required on the console, having a backing file used for read/write access is not allowed
// First attempt to open the file mapping object by name, this will only succeed if the object has already been created
// Doing the operations in this order removes the need for synchronization between systems for which system will create the object
// The OS is already handling the synchronization on the mapping object creation
g_sharedFileMappingHandle = OpenFileMappingW(
FILE_MAP_ALL_ACCESS,
FALSE,
g_sharedMemoryName);
// If the attempt to open the object fails then attempt to create the file mapping object
// Note: There is still technically a race condition with this code where the open fails, another thread creates the object, then the original thread will fail to create
// For the purposes of this sample extra protection has not been created to handle this race condition, it won't happen in the examples shown in the sample
if (g_sharedFileMappingHandle == nullptr)
{
needInitialMemoryClear = true;
g_sharedFileMappingHandle = CreateFileMappingW(
INVALID_HANDLE_VALUE,
NULL,
PAGE_READWRITE,
0,
c_sizeSharedMemory,
g_sharedMemoryName);
}
if (g_sharedFileMappingHandle == nullptr)
return nullptr;
// Once the file mapping object has been created the memory can now be mapped into the process
g_sharedMemory = (SharedMemoryBlock *)MapViewOfFile(g_sharedFileMappingHandle,
FILE_MAP_ALL_ACCESS,
0,
0,
c_sizeSharedMemory);
if (!g_sharedMemory)
{
CleanupSharedMemory();
return nullptr;
}
if (needInitialMemoryClear)
memset(g_sharedMemory, 0, c_sizeSharedMemory);
return g_sharedMemory;
}
// Cleaning up the shared memory object is straight forward with ummapping the view and closing the associated handles
// The objects ref-counted through the handles and they will stay allocated until the last handle is closed.
void CleanupSharedMemory()
{
if (g_sharedMemory != nullptr)
{
UnmapViewOfFile(g_sharedMemory);
g_sharedMemory = nullptr;
}
if (g_sharedFileMappingHandle != nullptr)
{
CloseHandle(g_sharedFileMappingHandle);
g_sharedFileMappingHandle = nullptr;
}
CloseHandle(g_sharedStartEvent);
CloseHandle(g_sharedFinishedEvent);
g_sharedStartEvent = INVALID_HANDLE_VALUE;
g_sharedFinishedEvent = INVALID_HANDLE_VALUE;
}
}
| 44.6 | 184 | 0.646637 | [
"object"
] |
c578ff6791d1e40954e56712cad45a8b9793654f | 1,526 | cpp | C++ | android-31/android/view/OrientationListener.cpp | YJBeetle/QtAndroidAPI | 1468b5dc6eafaf7709f0b00ba1a6ec2b70684266 | [
"Apache-2.0"
] | 12 | 2020-03-26T02:38:56.000Z | 2022-03-14T08:17:26.000Z | android-31/android/view/OrientationListener.cpp | YJBeetle/QtAndroidAPI | 1468b5dc6eafaf7709f0b00ba1a6ec2b70684266 | [
"Apache-2.0"
] | 1 | 2021-01-27T06:07:45.000Z | 2021-11-13T19:19:43.000Z | android-29/android/view/OrientationListener.cpp | YJBeetle/QtAndroidAPI | 1468b5dc6eafaf7709f0b00ba1a6ec2b70684266 | [
"Apache-2.0"
] | 3 | 2021-02-02T12:34:55.000Z | 2022-03-08T07:45:57.000Z | #include "../../JFloatArray.hpp"
#include "../content/Context.hpp"
#include "./OrientationListener.hpp"
namespace android::view
{
// Fields
jint OrientationListener::ORIENTATION_UNKNOWN()
{
return getStaticField<jint>(
"android.view.OrientationListener",
"ORIENTATION_UNKNOWN"
);
}
// QJniObject forward
OrientationListener::OrientationListener(QJniObject obj) : JObject(obj) {}
// Constructors
OrientationListener::OrientationListener(android::content::Context arg0)
: JObject(
"android.view.OrientationListener",
"(Landroid/content/Context;)V",
arg0.object()
) {}
OrientationListener::OrientationListener(android::content::Context arg0, jint arg1)
: JObject(
"android.view.OrientationListener",
"(Landroid/content/Context;I)V",
arg0.object(),
arg1
) {}
// Methods
void OrientationListener::disable() const
{
callMethod<void>(
"disable",
"()V"
);
}
void OrientationListener::enable() const
{
callMethod<void>(
"enable",
"()V"
);
}
void OrientationListener::onAccuracyChanged(jint arg0, jint arg1) const
{
callMethod<void>(
"onAccuracyChanged",
"(II)V",
arg0,
arg1
);
}
void OrientationListener::onOrientationChanged(jint arg0) const
{
callMethod<void>(
"onOrientationChanged",
"(I)V",
arg0
);
}
void OrientationListener::onSensorChanged(jint arg0, JFloatArray arg1) const
{
callMethod<void>(
"onSensorChanged",
"(I[F)V",
arg0,
arg1.object<jfloatArray>()
);
}
} // namespace android::view
| 19.818182 | 84 | 0.684797 | [
"object"
] |
c5811c5f91306f8b75514dd472e3ab68ddd23e08 | 13,661 | cc | C++ | DQM/GEM/src/GEMDQMEfficiencyClientBase.cc | menglu21/cmssw | c3d6cb102c0aaddf652805743370c28044d53da6 | [
"Apache-2.0"
] | null | null | null | DQM/GEM/src/GEMDQMEfficiencyClientBase.cc | menglu21/cmssw | c3d6cb102c0aaddf652805743370c28044d53da6 | [
"Apache-2.0"
] | null | null | null | DQM/GEM/src/GEMDQMEfficiencyClientBase.cc | menglu21/cmssw | c3d6cb102c0aaddf652805743370c28044d53da6 | [
"Apache-2.0"
] | null | null | null | #include "DQM/GEM/interface/GEMDQMEfficiencyClientBase.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/Utilities/interface/isFinite.h"
#include "TEfficiency.h"
#include "TPRegexp.h"
#include <regex>
GEMDQMEfficiencyClientBase::GEMDQMEfficiencyClientBase(const edm::ParameterSet& ps)
: kConfidenceLevel_(ps.getUntrackedParameter<double>("confidenceLevel")),
kLogCategory_(ps.getUntrackedParameter<std::string>("logCategory")) {}
// Returns a tuple of
// - a boolean indicating whether the parsing is successful or not
// - name of a variable used in the efficiency monitoring
// - GEM subdetector name like GE11-P-L1
// - a boolean indicating whether the name is a numerator name.
std::tuple<bool, std::string, std::string, bool> GEMDQMEfficiencyClientBase::parseEfficiencySourceName(
std::string name) {
// NOTE This expression must be consistent with TODO
// TODO use regex
const bool success = TPRegexp("\\w+(?:_match)?_GE\\d1-(P|M)[0-9\\-]*").MatchB(name);
if (not success) {
return std::make_tuple(success, "", "", false);
}
const std::string numerator_pattern = "_match";
const auto numerator_pattern_start = name.find(numerator_pattern);
const bool is_numerator = numerator_pattern_start != std::string::npos;
if (is_numerator) {
// keep a delimiter between a variable name and a GEM name
// e.g. 'muon_pt_matched_GE11-L1' --> 'muon_pt_GE11-L1'
name.erase(numerator_pattern_start, numerator_pattern.length());
}
// find the position of the delimiter.
// Because variable name can has "_", find the last one.
// NOTE The GEM name must not contains "_"
const unsigned long last_pos = name.find_last_of('_');
// "muon_pt"
const std::string var_name = name.substr(0, last_pos);
// "GE11-L1"
const std::string gem_name = name.substr(last_pos + 1);
return std::make_tuple(success, var_name, gem_name, is_numerator);
}
GEMDetId GEMDQMEfficiencyClientBase::parseGEMLabel(const std::string gem_label, const std::string delimiter) {
// GE11-P
// GE11-P-L1
// GE11-P-E1
int region = 0;
int station = 0;
int layer = 0;
int chamber = 0;
int ieta = 0;
std::vector<std::string> tokens;
// static const?
const std::regex re_station{"GE\\d1"};
const std::regex re_region{"(P|M)"};
const std::regex re_layer{"L\\d"};
const std::regex re_chamber_layer{"\\d+L\\d"};
const std::regex re_ieta{"E\\d+"};
std::string::size_type last_pos = gem_label.find_first_not_of(delimiter, 0);
std::string::size_type pos = gem_label.find_first_of(delimiter, last_pos);
while ((pos != std::string::npos) or (last_pos != std::string::npos)) {
const std::string token = gem_label.substr(last_pos, pos - last_pos);
if (std::regex_match(token, re_region)) {
region = (token == "P") ? 1 : -1;
} else if (std::regex_match(token, re_station)) {
station = std::stoi(token.substr(2, 1));
} else if (std::regex_match(token, re_layer)) {
layer = std::stoi(token.substr(1));
} else if (std::regex_match(token, re_chamber_layer)) {
const unsigned long layer_prefix_pos = token.find('L');
chamber = std::stoi(token.substr(0, layer_prefix_pos));
layer = std::stoi(token.substr(layer_prefix_pos + 1));
} else if (std::regex_match(token, re_ieta)) {
ieta = std::stoi(token.substr(1));
} else {
edm::LogError(kLogCategory_) << "unknown pattern: " << gem_label << " --> " << token;
}
}
const GEMDetId id{region, 1, station, layer, chamber, ieta};
return id;
}
std::map<std::string, GEMDQMEfficiencyClientBase::MEPair> GEMDQMEfficiencyClientBase::makeEfficiencySourcePair(
DQMStore::IBooker& ibooker, DQMStore::IGetter& igetter, const std::string& folder, const std::string prefix) {
ibooker.setCurrentFolder(folder);
igetter.setCurrentFolder(folder);
std::map<std::string, MEPair> me_pairs;
for (const std::string& name : igetter.getMEs()) {
// If name doesn't start with prefix
// The default prefix is empty string.
if (name.rfind(prefix, 0) != 0) {
// TODO LogDebug
continue;
}
const std::string fullpath = folder + "/" + name;
const MonitorElement* me = igetter.get(fullpath);
if (me == nullptr) {
edm::LogError(kLogCategory_) << "failed to get " << fullpath;
continue;
}
const auto [parsing_success, var_name, gem_name, is_matched] = parseEfficiencySourceName(name);
if (not parsing_success) {
// TODO LogDebug
continue;
}
const std::string key = var_name + "_" + gem_name;
if (me_pairs.find(key) == me_pairs.end()) {
me_pairs[key] = {nullptr, nullptr};
}
if (is_matched)
me_pairs[key].first = me;
else
me_pairs[key].second = me;
}
// remove invalid pairs
for (auto it = me_pairs.cbegin(); it != me_pairs.cend();) {
auto [me_numerator, me_denominator] = (*it).second;
bool okay = true;
if (me_numerator == nullptr) {
okay = false;
} else if (me_denominator == nullptr) {
okay = false;
} else if (me_numerator->kind() != me_denominator->kind()) {
okay = false;
}
// anyways, move on to the next one
if (okay) {
it++;
} else {
it = me_pairs.erase(it);
}
}
return me_pairs;
}
void GEMDQMEfficiencyClientBase::setBins(TH1F* dst_hist, const TAxis* src_axis) {
const int nbins = src_axis->GetNbins();
if (src_axis->IsVariableBinSize()) {
std::vector<double> edges;
edges.reserve(nbins + 1);
for (int bin = 1; bin <= nbins; bin++) {
edges.push_back(src_axis->GetBinLowEdge(bin));
}
edges.push_back(src_axis->GetBinUpEdge(nbins));
dst_hist->SetBins(nbins, &edges[0]);
} else {
const double xlow = src_axis->GetBinLowEdge(1);
const double xup = src_axis->GetBinUpEdge(nbins);
dst_hist->SetBins(nbins, xlow, xup);
}
for (int bin = 1; bin <= nbins; bin++) {
const TString label{src_axis->GetBinLabel(bin)};
if (label.Length() > 0) {
dst_hist->GetXaxis()->SetBinLabel(bin, label);
}
}
}
// Returns a boolean indicating whether the numerator and the denominator are
// consistent.
//
// TEfficiency::CheckConsistency raises errors and leads to an exception.
// So, the efficiency client will skip inconsitent two histograms.
// https://github.com/root-project/root/blob/v6-24-06/hist/hist/src/TEfficiency.cxx#L1494-L1512
bool GEMDQMEfficiencyClientBase::checkConsistency(const TH1& pass, const TH1& total) {
if (pass.GetDimension() != total.GetDimension()) {
edm::LogError(kLogCategory_) << "numerator and denominator have different dimensions: " << pass.GetName() << " & "
<< total.GetName();
return false;
}
if (not TEfficiency::CheckBinning(pass, total)) {
edm::LogError(kLogCategory_) << "numerator and denominator have different binning: " << pass.GetName() << " & "
<< total.GetName();
return false;
}
if (not TEfficiency::CheckEntries(pass, total)) {
edm::LogError(kLogCategory_) << "numerator and denominator do not have consistent bin contents " << pass.GetName()
<< " & " << total.GetName();
return false;
}
return true;
}
// MonitorElement doesn't support TGraphAsymmErrors
TH1F* GEMDQMEfficiencyClientBase::makeEfficiency(const TH1F* h_numerator,
const TH1F* h_denominator,
const char* name,
const char* title) {
if (h_numerator == nullptr) {
edm::LogError(kLogCategory_) << "numerator is nullptr";
return nullptr;
}
if (h_denominator == nullptr) {
edm::LogError(kLogCategory_) << "denominator is nulpptr";
return nullptr;
}
if (not checkConsistency(*h_numerator, *h_denominator)) {
return nullptr;
}
if (name == nullptr) {
name = Form("eff_%s", h_denominator->GetName());
}
if (title == nullptr) {
title = h_denominator->GetTitle();
}
const TAxis* x_axis = h_denominator->GetXaxis();
// create an empty TProfile for storing efficiencies and uncertainties.
TH1F* h_eff = new TH1F();
h_eff->SetName(name);
h_eff->SetTitle(title);
h_eff->GetXaxis()->SetTitle(x_axis->GetTitle());
h_eff->GetYaxis()->SetTitle("Efficiency");
setBins(h_eff, h_denominator->GetXaxis());
// efficiency calculation
const int nbins = x_axis->GetNbins();
for (int bin = 1; bin <= nbins; bin++) {
const double passed = h_numerator->GetBinContent(bin);
const double total = h_denominator->GetBinContent(bin);
if (total < 1) {
continue;
}
const double efficiency = passed / total;
const double lower_boundary = TEfficiency::ClopperPearson(total, passed, kConfidenceLevel_, false);
const double upper_boundary = TEfficiency::ClopperPearson(total, passed, kConfidenceLevel_, true);
const double error = std::max(efficiency - lower_boundary, upper_boundary - efficiency);
h_eff->SetBinContent(bin, efficiency);
h_eff->SetBinError(bin, error);
}
return h_eff;
}
//
TH2F* GEMDQMEfficiencyClientBase::makeEfficiency(const TH2F* h_numerator,
const TH2F* h_denominator,
const char* name,
const char* title) {
if (h_numerator == nullptr) {
edm::LogError(kLogCategory_) << "numerator is nullptr";
return nullptr;
}
if (h_denominator == nullptr) {
edm::LogError(kLogCategory_) << "denominator is nulpptr";
return nullptr;
}
if (not checkConsistency(*h_numerator, *h_denominator)) {
return nullptr;
}
if (name == nullptr) {
name = Form("eff_%s", h_denominator->GetName());
}
if (title == nullptr) {
title = h_denominator->GetTitle();
}
TEfficiency eff(*h_numerator, *h_denominator);
auto h_eff = dynamic_cast<TH2F*>(eff.CreateHistogram());
h_eff->SetName(name);
h_eff->SetTitle(title);
return h_eff;
}
// FIXME TH2D::ProjectionX looks buggy
TH1F* GEMDQMEfficiencyClientBase::projectHistogram(const TH2F* h_2d, const unsigned int on_which_axis) {
if ((on_which_axis != TH1::kXaxis) and (on_which_axis != TH1::kYaxis)) {
edm::LogError(kLogCategory_) << "invalid choice: " << on_which_axis << "."
<< " choose from [TH1::kXaxis (=1), TH1::kYaxis (=2)]";
return nullptr;
}
const bool on_x_axis = (on_which_axis == TH1::kXaxis);
// on which axis is the histogram projected?
const TAxis* src_proj_axis = on_x_axis ? h_2d->GetXaxis() : h_2d->GetYaxis();
// along which axis do the entries accumulate?
const TAxis* src_accum_axis = on_x_axis ? h_2d->GetYaxis() : h_2d->GetXaxis();
const TString prefix = on_x_axis ? "_proj_on_x" : "_proj_on_y";
const TString name = h_2d->GetName() + prefix;
const TString title = h_2d->GetTitle();
TH1F* h_proj = new TH1F();
h_proj->SetName(name);
h_proj->SetTitle(title);
h_proj->GetXaxis()->SetTitle(src_proj_axis->GetTitle());
setBins(h_proj, src_proj_axis);
for (int proj_bin = 1; proj_bin <= src_proj_axis->GetNbins(); proj_bin++) {
double cumsum = 0.0;
for (int accum_bin = 1; accum_bin <= src_accum_axis->GetNbins(); accum_bin++) {
if (on_x_axis) {
cumsum += h_2d->GetBinContent(proj_bin, accum_bin);
} else {
cumsum += h_2d->GetBinContent(accum_bin, proj_bin);
}
}
h_proj->SetBinContent(proj_bin, cumsum);
}
h_proj->Sumw2();
return h_proj;
}
void GEMDQMEfficiencyClientBase::bookEfficiencyAuto(DQMStore::IBooker& ibooker,
DQMStore::IGetter& igetter,
const std::string& folder) {
const std::map<std::string, MEPair> me_pairs = makeEfficiencySourcePair(ibooker, igetter, folder);
for (auto& [key, value] : me_pairs) {
const auto& [me_numerator, me_denominator] = value;
const MonitorElement::Kind me_kind = me_numerator->kind();
if (me_kind == MonitorElement::Kind::TH1F) {
TH1F* h_numerator = me_numerator->getTH1F();
if (h_numerator == nullptr) {
edm::LogError(kLogCategory_) << "failed to get TH1F from h_numerator " << key;
continue;
}
TH1F* h_denominator = me_denominator->getTH1F();
if (h_denominator == nullptr) {
edm::LogError(kLogCategory_) << "failed to get TH1F from h_denominator" << key;
continue;
}
if (TH1F* eff = makeEfficiency(h_numerator, h_denominator)) {
ibooker.book1D(eff->GetName(), eff);
} else {
// makeEfficiency will report the error.
continue;
}
} else if (me_kind == MonitorElement::Kind::TH2F) {
TH2F* h_numerator = me_numerator->getTH2F();
if (h_numerator == nullptr) {
edm::LogError(kLogCategory_) << "failed to get TH1F from h_numerator " << key;
continue;
}
TH2F* h_denominator = me_denominator->getTH2F();
if (h_denominator == nullptr) {
edm::LogError(kLogCategory_) << "failed to get TH1F from h_denominator" << key;
continue;
}
if (TH2F* eff = makeEfficiency(h_numerator, h_denominator)) {
ibooker.book2D(eff->GetName(), eff);
} else {
// makeEfficiency will report the error.
continue;
}
} else {
edm::LogError(kLogCategory_) << "got an unepxected MonitorElement::Kind "
<< "0x" << std::hex << static_cast<int>(me_kind);
continue;
}
} // me_pairs
}
| 32.838942 | 118 | 0.637655 | [
"vector"
] |
c58b5b00410e05972f2bf7875e7d9d7bfdec4925 | 2,024 | cpp | C++ | lib/Target/Sophon/BM188x/Lowers/SumLower.cpp | LiuLeif/onnc | 3f69e46172a9c33cc04541ff7fd78d5d7b6bdbba | [
"BSD-3-Clause"
] | 450 | 2018-08-03T08:17:03.000Z | 2022-03-17T17:21:06.000Z | lib/Target/Sophon/BM188x/Lowers/SumLower.cpp | ffk0716/onnc | 91e4955ade64b479db17aaeccacf4b7339fe44d2 | [
"BSD-3-Clause"
] | 104 | 2018-08-13T07:31:50.000Z | 2021-08-24T11:24:40.000Z | lib/Target/Sophon/BM188x/Lowers/SumLower.cpp | ffk0716/onnc | 91e4955ade64b479db17aaeccacf4b7339fe44d2 | [
"BSD-3-Clause"
] | 100 | 2018-08-12T04:27:39.000Z | 2022-03-11T04:17:42.000Z | //===- SumLower.cpp -------------------------------------------------------===//
//
// The ONNC Project
//
// See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "SumLower.h"
#include "../Compute/Sum.h"
#include <onnc/IR/IRBuilder.h>
using namespace onnc;
using namespace onnc::BM188X;
//===----------------------------------------------------------------------===//
// SumLower
//===----------------------------------------------------------------------===//
BM188X::SumLower::SumLower()
{
}
BM188X::SumLower::~SumLower()
{
}
int BM188X::SumLower::isMe(const xNode &pNode) const
{
if (pNode.kind() == xSymbol("Sum") ||
pNode.kind() == xSymbol("TGSum"))
return kTargetNormal;
return kNotMe;
}
onnc::ComputeOperator *
BM188X::SumLower::activate(ComputeGraph& pGraph, xNode &pNode) const
{
// check input/output name
if (0 == pNode.inputs().size())
return nullptr;
for (xValue* xv : pNode.inputs()) {
if (!xv->has_unique_name())
return nullptr;
}
if (1 != pNode.outputs().size())
return nullptr;
for (xValue* xv : pNode.outputs()) {
if (!xv->has_unique_name())
return nullptr;
}
// create operators
BM188X::Sum* op = pGraph.addOperator<BM188X::Sum>();
if (pNode.hasAttribute(xSymbol("do_relu")))
op->setDoRelu(pNode.i(xSymbol("do_relu")));
// init xquant with zero values.
op->setThresholdXQuantized(std::vector<int>(pNode.inputs().size()));
// set input/output
for (xValue* xv : pNode.inputs()) {
onnc::Tensor* tensor = pGraph.getValue<onnc::Tensor>(xv->uniqueName());
if (nullptr == tensor)
tensor = IRBuilder::CreateComputeTensor(pGraph, *xv);
op->addInput(*tensor);
}
for (xValue* xv : pNode.outputs()) {
onnc::Tensor* tensor = pGraph.getValue<onnc::Tensor>(xv->uniqueName());
if (nullptr == tensor)
tensor = IRBuilder::CreateComputeTensor(pGraph, *xv);
op->addOutput(*tensor);
}
return op;
}
| 25.620253 | 80 | 0.537549 | [
"vector"
] |
c59207da0d72fe1dc9d6c931f782bccb69645d02 | 5,164 | hpp | C++ | src/resembla_ensemble.hpp | atlimited/resembla | 82293cecfccfca6e2a95688b21f0659ba75e8cae | [
"Apache-2.0"
] | null | null | null | src/resembla_ensemble.hpp | atlimited/resembla | 82293cecfccfca6e2a95688b21f0659ba75e8cae | [
"Apache-2.0"
] | null | null | null | src/resembla_ensemble.hpp | atlimited/resembla | 82293cecfccfca6e2a95688b21f0659ba75e8cae | [
"Apache-2.0"
] | 1 | 2019-12-03T07:06:41.000Z | 2019-12-03T07:06:41.000Z | /*
Resembla
https://github.com/tuem/resembla
Copyright 2017 Takashi Uemura
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 RESEMBLA_RESEMBLA_ENSEMBLE_HPP
#define RESEMBLA_RESEMBLA_ENSEMBLE_HPP
#include <string>
#include <vector>
#include <memory>
#include <unordered_map>
#include <algorithm>
#include <simstring/simstring.h>
#include "resembla_interface.hpp"
#include "csv_reader.hpp"
#include "eliminator.hpp"
namespace resembla {
template<typename Indexer, typename ScoreFunction>
class ResemblaEnsemble: public ResemblaInterface
{
public:
ResemblaEnsemble(const std::string& measure_name,
const std::string& simstring_db_path, const std::string& index_path,
const int simstring_measure, const double simstring_threshold, const size_t max_candidate,
std::shared_ptr<Indexer> indexer, std::shared_ptr<ScoreFunction> score_func):
measure_name(measure_name), simstring_measure(simstring_measure), simstring_threshold(simstring_threshold),
max_candidate(max_candidate), indexer(indexer), score_func(score_func)
{
load(simstring_db_path, index_path);
}
void append(const std::shared_ptr<ResemblaInterface> resembla, double weight = 1.0)
{
children.push_back(resembla);
weights.push_back(weight);
}
std::vector<output_type> find(const string_type& query,
double threshold = 0.0, size_t max_response = 0) const
{
string_type search_query = indexer->index(query);
// search from N-gram index
std::vector<string_type> simstring_result;
{
std::lock_guard<std::mutex> lock(mutex_simstring);
db.retrieve(search_query, simstring_measure, simstring_threshold, std::back_inserter(simstring_result));
}
if(simstring_result.empty()){
return {};
}
else if(simstring_result.size() > max_candidate){
Eliminator<string_type> eliminate(search_query);
eliminate(simstring_result, max_candidate, true);
}
// load original texts
std::vector<string_type> candidates;
for(const auto& i: simstring_result){
if(i.empty()){
continue;
}
const auto& j = inverse.at(i);
std::copy(std::begin(j), std::end(j), std::back_inserter(candidates));
}
return eval(query, candidates, threshold, max_response);
}
std::vector<output_type> eval(const string_type& query, const std::vector<string_type>& candidates,
double threshold = 0.0, size_t max_response = 0) const
{
std::unordered_map<string_type, std::vector<double>> work;
for(const auto& resembla: children){
for(const auto& r: resembla->eval(query, candidates, 0.0, 0)){
auto p = work.insert(std::pair<string_type, std::vector<double>>(r.text, {r.score}));
if(!p.second){
p.first->second.push_back(r.score);
}
}
}
std::vector<output_type> results;
for(const auto& p: work){
double score = (*score_func)(weights, p.second);
if(score >= threshold){
results.push_back({p.first, measure_name, score});
}
}
if(max_response != 0 && results.size() > max_response){
std::partial_sort(results.begin(), results.begin() + max_response, results.end());
results.erase(results.begin() + max_response, results.end());
}
else{
std::sort(results.begin(), results.end());
}
return results;
}
protected:
const std::string measure_name;
mutable simstring::reader db;
mutable std::mutex mutex_simstring;
std::unordered_map<string_type, std::vector<string_type>> inverse;
const int simstring_measure;
const double simstring_threshold;
const size_t max_candidate;
const std::shared_ptr<Indexer> indexer;
const std::shared_ptr<ScoreFunction> score_func;
std::vector<std::shared_ptr<ResemblaInterface>> children;
std::vector<double> weights;
void load(const std::string& simstring_db_path, const std::string& index_path)
{
db.open(simstring_db_path);
for(const auto& columns: CsvReader<string_type>(index_path, 2)){
const auto& indexed = columns[0];
const auto& original = columns[1];
auto p = inverse.insert(std::pair<string_type, std::vector<string_type>>(indexed, {original}));
if(!p.second){
p.first->second.push_back(original);
}
}
}
};
}
#endif
| 33.102564 | 116 | 0.650658 | [
"vector"
] |
c59ecafee628c403e44d9bdc944ff3150c2a1b3f | 8,724 | cpp | C++ | active16/src/libalf/libalf_interfaces/jalf/src/jni_learning_algorithm.cpp | adiojha629/JIRP_LRM | a06e3725a8f4f406a100d2a4c2c69d4e9450a2d3 | [
"MIT"
] | 2 | 2021-09-22T13:02:55.000Z | 2021-11-08T19:16:55.000Z | active16/src/libalf/libalf_interfaces/jalf/src/jni_learning_algorithm.cpp | adiojha629/JIRP_LRM | a06e3725a8f4f406a100d2a4c2c69d4e9450a2d3 | [
"MIT"
] | null | null | null | active16/src/libalf/libalf_interfaces/jalf/src/jni_learning_algorithm.cpp | adiojha629/JIRP_LRM | a06e3725a8f4f406a100d2a4c2c69d4e9450a2d3 | [
"MIT"
] | null | null | null | /* $Id: jni_learning_algorithm.cpp 1435 2011-01-24 19:03:01Z neider $
* vim: fdm=marker
*
* This file is part of libalf.
*
* libalf is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* libalf is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with libalf. If not, see <http://www.gnu.org/licenses/>.
*
* (c) 2009 Lehrstuhl Softwaremodellierung und Verifikation (I2), RWTH Aachen University
* and Lehrstuhl Logik und Theorie diskreter Systeme (I7), RWTH Aachen University
* Author: Daniel Neider <neider@automata.rwth-aachen.de>
*
*/
#include <set>
#include <map>
#include <iostream>
#include <string>
#include "jni_tools.h"
#include <libalf/knowledgebase.h>
#include <libalf/learning_algorithm.h>
#include <libalf/normalizer.h>
#include <libalf/normalizer_msc.h>
#include <jni.h>
#include "jni_learning_algorithm.h"
using namespace std;
using namespace libalf;
JNIEXPORT void JNICALL Java_de_libalf_jni_JNILearningAlgorithm_add_1counterexample (JNIEnv *env , jobject obj, jintArray counterexample, jlong pointer) {
// Get Java array info
jsize length = env->GetArrayLength(counterexample);
jint *entry = env->GetIntArrayElements(counterexample, 0);
// Copy array
int len = (int)length;
list<int> ce;
for(int i=0; i<len; i++) ce.push_back(((jint)entry[i]));
// Clean
env->ReleaseIntArrayElements(counterexample, entry, 0);
// Get the algorithm object
learning_algorithm<bool>* algorithm = (learning_algorithm<bool>*)pointer;
// Forward method call
algorithm->add_counterexample(ce);
}
JNIEXPORT jobject JNICALL Java_de_libalf_jni_JNILearningAlgorithm_advance (JNIEnv *env, jobject obj, jlong pointer) {
// Get the algorithm object
learning_algorithm<bool>* algorithm = (learning_algorithm<bool>*)pointer;
// Create a new automaton
conjecture * cj;
// Advance!
cj = algorithm->advance();
if(cj != NULL) {
// Return a conjectrue if ready
jobject aut;
finite_automaton * sa = dynamic_cast<finite_automaton*>(cj);
if(sa == NULL) {
fprintf(stderr, "FIXME: HYPOTHESIS IS NOT A SIMPLE AUTOMATON!\n");
delete cj;
return NULL;
}
set<int> final_states;
sa->get_final_states(final_states);
aut = convertAutomaton(env, sa->is_deterministic, sa->input_alphabet_size, sa->state_count, sa->initial_states, final_states, sa->transitions);
delete cj;
return aut;
} else {
return NULL;
}
}
JNIEXPORT jboolean JNICALL Java_de_libalf_jni_JNILearningAlgorithm_conjecture_1ready (JNIEnv *evn, jobject obj, jlong pointer) {
// Get the algorithm object
learning_algorithm<bool>* algorithm = (learning_algorithm<bool>*)pointer;
// Forward method call
return algorithm->conjecture_ready();
}
JNIEXPORT jint JNICALL Java_de_libalf_jni_JNILearningAlgorithm_get_1alphabet_1size (JNIEnv *env, jobject obj, jlong pointer) {
// Get the algorithm object
learning_algorithm<bool>* algorithm = (learning_algorithm<bool>*)pointer;
// Forward method call
return algorithm->get_alphabet_size();
}
JNIEXPORT void JNICALL Java_de_libalf_jni_JNILearningAlgorithm_increase_1alphabet_1size (JNIEnv *env, jobject obj, jint newSize, jlong pointer) {
// Get the algorithm object
learning_algorithm<bool>* algorithm = (learning_algorithm<bool>*)pointer;
// Forward method call
return algorithm->increase_alphabet_size(newSize);
}
JNIEXPORT void JNICALL Java_de_libalf_jni_JNILearningAlgorithm_set_1alphabet_1size (JNIEnv *env, jobject obj, jint newSize, jlong pointer) {
// Get the algorithm object
learning_algorithm<bool>* algorithm = (learning_algorithm<bool>*)pointer;
// Forward method call
return algorithm->set_alphabet_size(newSize);
}
JNIEXPORT void JNICALL Java_de_libalf_jni_JNILearningAlgorithm_set_1knowledge_1source (JNIEnv *env, jobject obj, jlong knowledgebase_pointer, jlong pointer) {
// Get the knowledgebase object
knowledgebase<bool> *base = (knowledgebase<bool>*) knowledgebase_pointer;
// Get the algorithm object
learning_algorithm<bool>* algorithm = (learning_algorithm<bool>*)pointer;
// Forward method call
return algorithm->set_knowledge_source(base);
}
JNIEXPORT void JNICALL Java_de_libalf_jni_JNILearningAlgorithm_set_1knowledge_1source_1NULL (JNIEnv *env, jobject obj, jlong pointer) {
// Get the algorithm object
learning_algorithm<bool>* algorithm = (learning_algorithm<bool>*)pointer;
// Forward method call
return algorithm->set_knowledge_source(NULL);
}
JNIEXPORT jboolean JNICALL Java_de_libalf_jni_JNILearningAlgorithm_sync_1to_1knowledgebase (JNIEnv *env, jobject obj, jlong pointer) {
// Get the algorithm object
learning_algorithm<bool>* algorithm = (learning_algorithm<bool>*)pointer;
// Forward method call
return algorithm->sync_to_knowledgebase();
}
JNIEXPORT jboolean JNICALL Java_de_libalf_jni_JNILearningAlgorithm_supports_1sync (JNIEnv *env, jobject obj, jlong pointer) {
// Get the algorithm object
learning_algorithm<bool>* algorithm = (learning_algorithm<bool>*)pointer;
// Forward method call
return algorithm->supports_sync();
}
JNIEXPORT jintArray JNICALL Java_de_libalf_jni_JNILearningAlgorithm_serialize (JNIEnv *env, jobject obj, jlong pointer) {
// Get the algorithm object
learning_algorithm<bool>* algorithm = (learning_algorithm<bool>*)pointer;
// Convert
jintArray arr = basic_string2jintArray_tohl(env, algorithm->serialize());
return arr;
}
JNIEXPORT jboolean JNICALL Java_de_libalf_jni_JNILearningAlgorithm_deserialize (JNIEnv *env, jobject obj, jintArray serialization, jlong pointer) {
// Get Java array info
jsize length = env->GetArrayLength(serialization);
jint *entry = env->GetIntArrayElements(serialization, 0);
// Copy array
int len = (int)length;
basic_string<int32_t> serial;
for(int i=0; i<len; i++) serial.push_back(htonl((jint)entry[i]));
// Clean
env->ReleaseIntArrayElements(serialization, entry, 0);
// Get the algorithm object
learning_algorithm<bool>* algorithm = (learning_algorithm<bool>*)pointer;
// Forward method call
serial_stretch ser(serial);
return algorithm->deserialize(ser);
}
JNIEXPORT void JNICALL Java_de_libalf_jni_JNILearningAlgorithm_set_1logger (JNIEnv *env, jobject obj, jlong logger_pointer, jlong pointer) {
// Get the algorithm object
learning_algorithm<bool>* algorithm = (learning_algorithm<bool>*)pointer;
// Get the logger object
buffered_logger* logger = (buffered_logger*)logger_pointer;
// Forward method call
algorithm->set_logger(logger);
}
JNIEXPORT void JNICALL Java_de_libalf_jni_JNILearningAlgorithm_destroy (JNIEnv *env, jobject obj, jlong pointer) {
// Kill the learning algorithm
delete (learning_algorithm<bool>*)pointer;
}
JNIEXPORT void JNICALL Java_de_libalf_jni_JNILearningAlgorithm_set_1normalizer (JNIEnv *env, jobject obj, jlong normalizer_pointer, jlong pointer) {
// Get the normalizer object
normalizer_msc* norm = (normalizer_msc*)normalizer_pointer;
// Get the algorithm object
learning_algorithm<bool>* algorithm = (learning_algorithm<bool>*)pointer;
// Forward method call
algorithm->set_normalizer(norm);
}
JNIEXPORT void JNICALL Java_de_libalf_jni_JNILearningAlgorithm_set_1normalizer_1NULL (JNIEnv *env, jobject obj, jlong pointer) {
// Get the algorithm object
learning_algorithm<bool>* algorithm = (learning_algorithm<bool>*)pointer;
// Forward method call
algorithm->set_normalizer(NULL);
}
JNIEXPORT void JNICALL Java_de_libalf_jni_JNILearningAlgorithm_remove_1normalizer (JNIEnv *env, jobject obj, jlong pointer) {
// Get the algorithm object
learning_algorithm<bool>* algorithm = (learning_algorithm<bool>*)pointer;
// Forward method call
algorithm->unset_normalizer();
}
JNIEXPORT jstring JNICALL Java_de_libalf_jni_JNILearningAlgorithm_get_1name (JNIEnv *env, jobject obj, jlong pointer) {
// Get the algorithm object
learning_algorithm<bool>* algorithm = (learning_algorithm<bool>*)pointer;
//Convert string
const char* c = algorithm->get_name();
return env->NewStringUTF(c);
}
JNIEXPORT jstring JNICALL Java_de_libalf_jni_JNILearningAlgorithm_tostring (JNIEnv *env, jobject obj, jlong pointer) {
// Get the algorithm object
learning_algorithm<bool>* algorithm = (learning_algorithm<bool>*)pointer;
// Get string
string str;
str = algorithm->to_string();
//Convert string
const char* c = str.c_str();
return env->NewStringUTF(c);
}
| 34.482213 | 158 | 0.775791 | [
"object"
] |
c59f3d8b9b6390775439ef88833da6ccb2115191 | 2,757 | cpp | C++ | kratos/mpi/tests/sources/test_mpi_coloring_utilities.cpp | lcirrott/Kratos | 8406e73e0ad214c4f89df4e75e9b29d0eb4a47ea | [
"BSD-4-Clause"
] | 2 | 2019-10-25T09:28:10.000Z | 2019-11-21T12:51:46.000Z | kratos/mpi/tests/sources/test_mpi_coloring_utilities.cpp | lcirrott/Kratos | 8406e73e0ad214c4f89df4e75e9b29d0eb4a47ea | [
"BSD-4-Clause"
] | 13 | 2019-10-07T12:06:51.000Z | 2020-02-18T08:48:33.000Z | kratos/mpi/tests/sources/test_mpi_coloring_utilities.cpp | lcirrott/Kratos | 8406e73e0ad214c4f89df4e75e9b29d0eb4a47ea | [
"BSD-4-Clause"
] | null | null | null | // | / |
// ' / __| _` | __| _ \ __|
// . \ | ( | | ( |\__ `
// _|\_\_| \__,_|\__|\___/ ____/
// Multi-Physics
//
// License: BSD License
// Kratos default license: kratos/license.txt
//
// Main authors: Riccardo Rossi
//
//
#include "mpi.h"
#include "mpi/mpi_environment.h"
#include "includes/parallel_environment.h"
#include "utilities/communication_coloring_utilities.h"
#include "testing/testing.h"
namespace Kratos {
namespace Testing {
KRATOS_DISTRIBUTED_TEST_CASE_IN_SUITE(MPIColoringUtilities_ComputeRecvList, KratosMPICoreFastSuite)
{
DataCommunicator& r_default_comm = ParallelEnvironment::GetDefaultDataCommunicator();
const int world_size = r_default_comm.Size();
const int current_rank = r_default_comm.Rank();
if(world_size == 4) //only implemented for the case of 4 mpi ranks
{
// send lists
std::vector< std::vector< int > > send_list(4);
send_list[0] = {1,3};
send_list[1] = {0,2,3};
send_list[2]; //does not send to anyone!!
send_list[3] = {0};
// //expected_recv_list;
std::vector< std::vector< int > > expected_recv_list(4);
expected_recv_list[0] = {1,3};
expected_recv_list[1] = {0};
expected_recv_list[2] = {1};
expected_recv_list[3] = {0,1};
auto recv_list = MPIColoringUtilities::ComputeRecvList(send_list[current_rank], r_default_comm);
for(unsigned int j=0; j<recv_list.size(); ++j)
{
KRATOS_CHECK_EQUAL(recv_list[j], expected_recv_list[current_rank][j]);
}
}
};
KRATOS_TEST_CASE_IN_SUITE(MPIColoringUtilities_ComputeCommunicationScheduling, KratosMPICoreFastSuite)
{
DataCommunicator& r_default_comm = ParallelEnvironment::GetDefaultDataCommunicator();
const int world_size = r_default_comm.Size();
const int current_rank = r_default_comm.Rank();
if(world_size == 4) //only implemented for the case of 4 mpi ranks
{
// send lists
std::vector< std::vector< int > > send_list(4);
send_list[0] = {1,3};
send_list[1] = {0,2,3};
send_list[2]; //does not send to anyone!!
send_list[3] = {0};
// //expected_recv_list;
std::vector< std::vector< int > > expected_colors(4);
expected_colors[0] = {1,3,-1};
expected_colors[1] = {0,2,3};
expected_colors[2] = {-1,1,-1};
expected_colors[3] = {-1,0,1};
auto colors = MPIColoringUtilities::ComputeCommunicationScheduling(send_list[current_rank], r_default_comm);
for(unsigned int j=0; j<colors.size(); ++j)
{
KRATOS_CHECK_EQUAL(colors[j], expected_colors[current_rank][j]);
}
}
};
}
} | 30.296703 | 116 | 0.619514 | [
"vector"
] |
c5a0c091ccd232cc0732f22fe4de643e5584c7f2 | 775 | cpp | C++ | minimize-the-absolute-difference.cpp | babu-thomas/interviewbit-solutions | 21125bf30b2d94b6f03310a4917679f216f55af3 | [
"MIT"
] | 16 | 2018-12-04T16:23:07.000Z | 2021-09-21T06:32:04.000Z | minimize-the-absolute-difference.cpp | babu-thomas/interviewbit-solutions | 21125bf30b2d94b6f03310a4917679f216f55af3 | [
"MIT"
] | 1 | 2019-08-21T16:20:03.000Z | 2019-08-21T16:21:41.000Z | minimize-the-absolute-difference.cpp | babu-thomas/interviewbit-solutions | 21125bf30b2d94b6f03310a4917679f216f55af3 | [
"MIT"
] | 23 | 2019-06-21T12:09:57.000Z | 2021-09-22T18:03:28.000Z | // Time - O(N), Space - O(1)
int Solution::solve(vector<int> &A, vector<int> &B, vector<int> &C) {
int p = A.size();
int q = B.size();
int r = C.size();
int i = 0, j = 0, k = 0;
int min_val, max_val, diff, min_diff = numeric_limits<int>::max();
while(i < p && j < q && k < r) {
min_val = min(A[i], min(B[j], C[k]));
max_val = max(A[i], max(B[j], C[k]));
diff = max_val - min_val;
if(diff == 0) {
return 0;
}
if(diff < min_diff) {
min_diff = diff;
}
if(A[i] == min_val) {
i++;
}
else if(B[j] == min_val) {
j++;
}
else {
k++;
}
}
return min_diff;
}
| 22.794118 | 70 | 0.384516 | [
"vector"
] |
c5a1aa63c55c91c2bc93b27b042a75d07b805417 | 28,857 | cpp | C++ | tests/unit/LinearAlgebra/MiddleSizeMatrixUnitTest.cpp | hpgem/hpgem | b2f7ac6bdef3262af0c3e8559cb991357a96457f | [
"BSD-3-Clause-Clear"
] | 5 | 2020-04-01T15:35:26.000Z | 2022-02-22T02:48:12.000Z | tests/unit/LinearAlgebra/MiddleSizeMatrixUnitTest.cpp | hpgem/hpgem | b2f7ac6bdef3262af0c3e8559cb991357a96457f | [
"BSD-3-Clause-Clear"
] | 139 | 2020-01-06T12:42:24.000Z | 2022-03-10T20:58:14.000Z | tests/unit/LinearAlgebra/MiddleSizeMatrixUnitTest.cpp | hpgem/hpgem | b2f7ac6bdef3262af0c3e8559cb991357a96457f | [
"BSD-3-Clause-Clear"
] | 4 | 2020-04-10T09:19:33.000Z | 2021-08-21T07:20:42.000Z | /*
This file forms part of hpGEM. This package has been developed over a number of
years by various people at the University of Twente and a full list of
contributors can be found at http://hpgem.org/about-the-code/team
This code is distributed using BSD 3-Clause License. A copy of which can found
below.
Copyright (c) 2014, University of Twente
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.
*/
#include <iostream>
#include <cstdlib>
#include <cmath>
#include "LinearAlgebra/MiddleSizeMatrix.h"
#include "LinearAlgebra/MiddleSizeVector.h"
#include "Logger.h"
#include "../catch.hpp"
using namespace hpgem;
using LinearAlgebra::MiddleSizeMatrix;
using LinearAlgebra::MiddleSizeVector;
TEST_CASE("MiddleSizeMatrixUnitTest", "[MiddleSizeMatrixUnitTest]") {
// constructors
LinearAlgebra::MiddleSizeVector vec0{0., 1.}, vec1{2., 3.}, vec2{4., 5.},
vec3{6., 7.};
MiddleSizeMatrix A0, A22(2, 2), A23(2, 3), A32(3, 2), destroy(3, 3, 1),
count0({vec0, vec1}), count1({vec2, vec3}), copy(count0), bla({count0}),
merge({count0, count1});
INFO("Rows in a matrix");
CHECK(destroy.getNumberOfRows() == 3);
INFO("Columns in a matrix");
CHECK(destroy.getNumberOfColumns() == 3);
INFO("Size of a matrix");
CHECK(destroy.size() == 9);
for (std::size_t i = 0; i < destroy.size(); ++i) {
INFO("Entry of a matrix");
CHECK(std::abs(destroy[i] - 1.) < 1e-12);
}
for (std::size_t i = 0; i < destroy.getNumberOfRows(); ++i) {
for (std::size_t j = 0; j < destroy.getNumberOfColumns(); ++j) {
INFO("Entry of a matrix");
CHECK(std::abs(destroy(i, j) - 1.) < 1e-12);
}
}
MiddleSizeMatrix moved(std::move(destroy));
INFO("Rows in a matrix");
CHECK(moved.getNumberOfRows() == 3);
INFO("Columns in a matrix");
CHECK(moved.getNumberOfColumns() == 3);
INFO("Size of a matrix");
CHECK(moved.size() == 9);
for (std::size_t i = 0; i < moved.size(); ++i) {
INFO("Entry of a matrix");
CHECK(std::abs(moved[i] - 1.) < 1e-12);
}
for (std::size_t i = 0; i < moved.getNumberOfRows(); ++i) {
for (std::size_t j = 0; j < moved.getNumberOfColumns(); ++j) {
INFO("Entry of a matrix");
CHECK(std::abs(moved(i, j) - 1.) < 1e-12);
}
}
INFO("Rows in a matrix");
CHECK(A0.getNumberOfRows() == 0);
INFO("Columns in a matrix");
CHECK(A0.getNumberOfColumns() == 0);
INFO("Size of a matrix");
CHECK(A0.size() == 0);
INFO("Rows in a matrix");
CHECK(A22.getNumberOfRows() == 2);
INFO("Columns in a matrix");
CHECK(A22.getNumberOfColumns() == 2);
INFO("Size of a matrix");
CHECK(A22.size() == 4);
INFO("Rows in a matrix");
CHECK(A23.getNumberOfRows() == 2);
INFO("Columns in a matrix");
CHECK(A23.getNumberOfColumns() == 3);
INFO("Size of a matrix");
CHECK(A23.size() == 6);
INFO("Rows in a matrix");
CHECK(A32.getNumberOfRows() == 3);
INFO("Columns in a matrix");
CHECK(A32.getNumberOfColumns() == 2);
INFO("Size of a matrix");
CHECK(A32.size() == 6);
INFO("Rows in a matrix");
CHECK(count0.getNumberOfRows() == 2);
INFO("Columns in a matrix");
CHECK(count0.getNumberOfColumns() == 2);
INFO("Size of a matrix");
CHECK(count0.size() == 4);
for (std::size_t i = 0; i < count0.size(); ++i) {
INFO("Entry of a matrix");
CHECK(std::abs(count0[i] - double(i)) < 1e-12);
}
INFO("Entry of a matrix");
CHECK(std::abs(count0(0, 0) - 0.) < 1e-12);
INFO("Entry of a matrix");
CHECK(std::abs(count0(1, 0) - 1.) < 1e-12);
INFO("Entry of a matrix");
CHECK(std::abs(count0(0, 1) - 2.) < 1e-12);
INFO("Entry of a matrix");
CHECK(std::abs(count0(1, 1) - 3.) < 1e-12);
INFO("Rows in a matrix");
CHECK(count1.getNumberOfRows() == 2);
INFO("Columns in a matrix");
CHECK(count1.getNumberOfColumns() == 2);
INFO("Size of a matrix");
CHECK(count1.size() == 4);
for (std::size_t i = 0; i < count1.size(); ++i) {
INFO("Entry of a matrix");
CHECK(std::abs(count1[i] - 4. - double(i)) < 1e-12);
}
INFO("Rows in a matrix");
CHECK(copy.getNumberOfRows() == 2);
INFO("Columns in a matrix");
CHECK(copy.getNumberOfColumns() == 2);
INFO("Size of a matrix");
CHECK(copy.size() == 4);
for (std::size_t i = 0; i < copy.size(); ++i) {
INFO("Entry of a matrix");
CHECK(std::abs(copy[i] - double(i)) < 1e-12);
}
INFO("Rows in a matrix");
CHECK(bla.getNumberOfRows() == 2);
INFO("Columns in a matrix");
CHECK(bla.getNumberOfColumns() == 2);
INFO("Size of a matrix");
CHECK(bla.size() == 4);
for (std::size_t i = 0; i < bla.size(); ++i) {
INFO("Entry of a matrix");
CHECK(std::abs(bla[i] - double(i)) < 1e-12);
}
INFO("Rows in a matrix");
CHECK(merge.getNumberOfRows() == 2);
INFO("Columns in a matrix");
CHECK(merge.getNumberOfColumns() == 4);
INFO("Size of a matrix");
CHECK(merge.size() == 8);
for (std::size_t i = 0; i < merge.size(); ++i) {
INFO("Entry of a matrix");
CHECK(std::abs(merge[i] - double(i)) < 1e-12);
}
A23(0, 0) = 0.0;
A23(1, 0) = 0.1;
A23(0, 1) = 0.2;
A23(1, 1) = 0.3;
A23(0, 2) = 0.4;
A23(1, 2) = 0.5;
A32[0] = 0.0;
A32[1] = 0.1;
A32[2] = 0.2;
A32[3] = 0.3;
A32[4] = 0.4;
A32[5] = 0.5;
// out-of-place operators
INFO("multiply");
CHECK(std::abs((count0 * count1)(0, 0) - 10.) < 1e-12);
INFO("multiply");
CHECK(std::abs((count0 * count1)(1, 0) - 19.) < 1e-12);
INFO("multiply");
CHECK(std::abs((count0 * count1)(0, 1) - 14.) < 1e-12);
INFO("multiply");
CHECK(std::abs((count0 * count1)(1, 1) - 27.) < 1e-12);
INFO("multiply");
CHECK(std::abs((count1 * count0)(0, 0) - 6.) < 1e-12);
INFO("multiply");
CHECK(std::abs((count1 * count0)(1, 0) - 7.) < 1e-12);
INFO("multiply");
CHECK(std::abs((count1 * count0)(0, 1) - 26.) < 1e-12);
INFO("multiply");
CHECK(std::abs((count1 * count0)(1, 1) - 31.) < 1e-12);
INFO("multiply");
CHECK(std::abs((count0 * A23)(0, 0) - .2) < 1e-12);
INFO("multiply");
CHECK(std::abs((count0 * A23)(1, 0) - .3) < 1e-12);
INFO("multiply");
CHECK(std::abs((count0 * A23)(0, 1) - .6) < 1e-12);
INFO("multiply");
CHECK(std::abs((count0 * A23)(1, 1) - 1.1) < 1e-12);
INFO("multiply");
CHECK(std::abs((count0 * A23)(0, 2) - 1.) < 1e-12);
INFO("multiply");
CHECK(std::abs((count0 * A23)(1, 2) - 1.9) < 1e-12);
INFO("multiply");
CHECK(std::abs((A32 * count0)(0, 0) - .3) < 1e-12);
INFO("multiply");
CHECK(std::abs((A32 * count0)(1, 0) - .4) < 1e-12);
INFO("multiply");
CHECK(std::abs((A32 * count0)(2, 0) - .5) < 1e-12);
INFO("multiply");
CHECK(std::abs((A32 * count0)(0, 1) - .9) < 1e-12);
INFO("multiply");
CHECK(std::abs((A32 * count0)(1, 1) - 1.4) < 1e-12);
INFO("multiply");
CHECK(std::abs((A32 * count0)(2, 1) - 1.9) < 1e-12);
INFO("multiply");
CHECK(std::abs((A32 * A23)(0, 0) - .03) < 1e-12);
INFO("multiply");
CHECK(std::abs((A32 * A23)(1, 0) - .04) < 1e-12);
INFO("multiply");
CHECK(std::abs((A32 * A23)(2, 0) - .05) < 1e-12);
INFO("multiply");
CHECK(std::abs((A32 * A23)(0, 1) - .09) < 1e-12);
INFO("multiply");
CHECK(std::abs((A32 * A23)(1, 1) - .14) < 1e-12);
INFO("multiply");
CHECK(std::abs((A32 * A23)(2, 1) - .19) < 1e-12);
INFO("multiply");
CHECK(std::abs((A32 * A23)(0, 2) - .15) < 1e-12);
INFO("multiply");
CHECK(std::abs((A32 * A23)(1, 2) - .24) < 1e-12);
INFO("multiply");
CHECK(std::abs((A32 * A23)(2, 2) - .33) < 1e-12);
INFO("multiply");
CHECK(std::abs((A23 * A32)(0, 0) - .1) < 1e-12);
INFO("multiply");
CHECK(std::abs((A23 * A32)(1, 0) - .13) < 1e-12);
INFO("multiply");
CHECK(std::abs((A23 * A32)(0, 1) - .28) < 1e-12);
INFO("multiply");
CHECK(std::abs((A23 * A32)(1, 1) - .40) < 1e-12);
INFO("multiply");
CHECK(std::abs((vec1 * count0) * vec1 - 45.) < 1e-12);
INFO("multiply");
CHECK(std::abs(vec1 * (count0 * vec1) - 45.) < 1e-12);
MiddleSizeVector size3 = {3., 4., 5.};
INFO("multiply");
CHECK(std::abs(size3 * (A32 * vec0) - 5.) < 1e-12);
INFO("multiply");
CHECK(std::abs((size3 * A32) * vec0 - 5.) < 1e-12);
INFO("multiply");
CHECK(std::abs((2 * count0 * 2)(0, 0) - 0.) < 1e-12);
INFO("multiply");
CHECK(std::abs((2 * count0 * 2)(1, 0) - 4.) < 1e-12);
INFO("multiply");
CHECK(std::abs((2 * count0 * 2)(0, 1) - 8.) < 1e-12);
INFO("multiply");
CHECK(std::abs((2 * count0 * 2)(1, 1) - 12.) < 1e-12);
INFO("divide");
CHECK(std::abs((count0 / 2.)(0, 0) - 0.) < 1e-12);
INFO("divide");
CHECK(std::abs((count0 / 2.)(1, 0) - .5) < 1e-12);
INFO("divide");
CHECK(std::abs((count0 / 2.)(0, 1) - 1.) < 1e-12);
INFO("divide");
CHECK(std::abs((count0 / 2.)(1, 1) - 1.5) < 1e-12);
INFO("add");
CHECK(std::abs((count0 + count1)(0, 0) - 4.) < 1e-12);
INFO("add");
CHECK(std::abs((count0 + count1)(1, 0) - 6.) < 1e-12);
INFO("add");
CHECK(std::abs((count0 + count1)(0, 1) - 8.) < 1e-12);
INFO("add");
CHECK(std::abs((count0 + count1)(1, 1) - 10.) < 1e-12);
INFO("add");
CHECK(std::abs((count1 + count0)(0, 0) - 4.) < 1e-12);
INFO("add");
CHECK(std::abs((count1 + count0)(1, 0) - 6.) < 1e-12);
INFO("add");
CHECK(std::abs((count1 + count0)(0, 1) - 8.) < 1e-12);
INFO("add");
CHECK(std::abs((count1 + count0)(1, 1) - 10.) < 1e-12);
INFO("subtract");
CHECK(std::abs((count0 - count1)(0, 0) + 4.) < 1e-12);
INFO("subtract");
CHECK(std::abs((count0 - count1)(1, 0) + 4.) < 1e-12);
INFO("subtract");
CHECK(std::abs((count0 - count1)(0, 1) + 4.) < 1e-12);
INFO("subtract");
CHECK(std::abs((count0 - count1)(1, 1) + 4.) < 1e-12);
INFO("subtract");
CHECK(std::abs((count1 - count0)(0, 0) - 4.) < 1e-12);
INFO("subtract");
CHECK(std::abs((count1 - count0)(1, 0) - 4.) < 1e-12);
INFO("subtract");
CHECK(std::abs((count1 - count0)(0, 1) - 4.) < 1e-12);
INFO("subtract");
CHECK(std::abs((count1 - count0)(1, 1) - 4.) < 1e-12);
// assignent operators
destroy = 4;
INFO("Rows in a matrix");
CHECK(destroy.getNumberOfRows() == 1);
INFO("Columns in a matrix");
CHECK(destroy.getNumberOfColumns() == 1);
INFO("Size of a matrix");
CHECK(destroy.size() == 1);
INFO("Entry of a matrix");
CHECK(std::abs(destroy[0] - 4.) < 1e-12);
MiddleSizeMatrix extra = copy;
INFO("Rows in a matrix");
CHECK(extra.getNumberOfRows() == 2);
INFO("Columns in a matrix");
CHECK(extra.getNumberOfColumns() == 2);
INFO("Size of a matrix");
CHECK(extra.size() == 4);
for (std::size_t i = 0; i < extra.size(); ++i) {
INFO("Entry of a matrix");
CHECK(std::abs(extra[i] - double(i)) < 1e-12);
}
copy = count1;
INFO("Rows in a matrix");
CHECK(copy.getNumberOfRows() == 2);
INFO("Columns in a matrix");
CHECK(copy.getNumberOfColumns() == 2);
INFO("Size of a matrix");
CHECK(copy.size() == 4);
for (std::size_t i = 0; i < copy.size(); ++i) {
INFO("Entry of a matrix");
CHECK(std::abs(copy[i] - double(i) - 4.) < 1e-12);
}
A0 = std::move(destroy);
INFO("Rows in a matrix");
CHECK(A0.getNumberOfRows() == 1);
INFO("Columns in a matrix");
CHECK(A0.getNumberOfColumns() == 1);
INFO("Size of a matrix");
CHECK(A0.size() == 1);
INFO("Entry of a matrix");
CHECK(std::abs(A0[0] - 4.) < 1e-12);
count0 *= count1;
INFO("Rows in a matrix");
CHECK(count0.getNumberOfRows() == 2);
INFO("Columns in a matrix");
CHECK(count0.getNumberOfColumns() == 2);
INFO("Size of a matrix");
CHECK(count0.size() == 4);
INFO("multiply");
CHECK(std::abs((count0)(0, 0) - 10.) < 1e-12);
INFO("multiply");
CHECK(std::abs((count0)(1, 0) - 19.) < 1e-12);
INFO("multiply");
CHECK(std::abs((count0)(0, 1) - 14.) < 1e-12);
INFO("multiply");
CHECK(std::abs((count0)(1, 1) - 27.) < 1e-12);
count1 *= A23;
INFO("Rows in a matrix");
CHECK(count1.getNumberOfRows() == 2);
INFO("Columns in a matrix");
CHECK(count1.getNumberOfColumns() == 3);
INFO("Size of a matrix");
CHECK(count1.size() == 6);
INFO("multiply");
CHECK(std::abs((count1)(0, 0) - .6) < 1e-12);
INFO("multiply");
CHECK(std::abs((count1)(1, 0) - .7) < 1e-12);
INFO("multiply");
CHECK(std::abs((count1)(0, 1) - 2.6) < 1e-12);
INFO("multiply");
CHECK(std::abs((count1)(1, 1) - 3.1) < 1e-12);
INFO("multiply");
CHECK(std::abs((count1)(0, 2) - 4.6) < 1e-12);
INFO("multiply");
CHECK(std::abs((count1)(1, 2) - 5.5) < 1e-12);
count0 *= 4;
INFO("Rows in a matrix");
CHECK(count0.getNumberOfRows() == 2);
INFO("Columns in a matrix");
CHECK(count0.getNumberOfColumns() == 2);
INFO("Size of a matrix");
CHECK(count0.size() == 4);
INFO("multiply");
CHECK(std::abs((count0)(0, 0) - 40.) < 1e-12);
INFO("multiply");
CHECK(std::abs((count0)(1, 0) - 76.) < 1e-12);
INFO("multiply");
CHECK(std::abs((count0)(0, 1) - 56.) < 1e-12);
INFO("multiply");
CHECK(std::abs((count0)(1, 1) - 108.) < 1e-12);
count0 /= 2;
INFO("Rows in a matrix");
CHECK(count0.getNumberOfRows() == 2);
INFO("Columns in a matrix");
CHECK(count0.getNumberOfColumns() == 2);
INFO("Size of a matrix");
CHECK(count0.size() == 4);
INFO("divide");
CHECK(std::abs((count0)(0, 0) - 20.) < 1e-12);
INFO("divide");
CHECK(std::abs((count0)(1, 0) - 38.) < 1e-12);
INFO("divide");
CHECK(std::abs((count0)(0, 1) - 28.) < 1e-12);
INFO("divide");
CHECK(std::abs((count0)(1, 1) - 54.) < 1e-12);
copy += extra;
INFO("Rows in a matrix");
CHECK(copy.getNumberOfRows() == 2);
INFO("Columns in a matrix");
CHECK(copy.getNumberOfColumns() == 2);
INFO("Size of a matrix");
CHECK(copy.size() == 4);
INFO("add");
CHECK(std::abs((copy)(0, 0) - 4.) < 1e-12);
INFO("add");
CHECK(std::abs((copy)(1, 0) - 6.) < 1e-12);
INFO("add");
CHECK(std::abs((copy)(0, 1) - 8.) < 1e-12);
INFO("add");
CHECK(std::abs((copy)(1, 1) - 10.) < 1e-12);
extra -= count0;
INFO("Rows in a matrix");
CHECK(extra.getNumberOfRows() == 2);
INFO("Columns in a matrix");
CHECK(extra.getNumberOfColumns() == 2);
INFO("Size of a matrix");
CHECK(extra.size() == 4);
INFO("subtract");
CHECK(std::abs((extra)(0, 0) + 20.) < 1e-12);
INFO("subtract");
CHECK(std::abs((extra)(1, 0) + 37.) < 1e-12);
INFO("subtract");
CHECK(std::abs((extra)(0, 1) + 26.) < 1e-12);
INFO("subtract");
CHECK(std::abs((extra)(1, 1) + 51.) < 1e-12);
extra.axpy(3., copy);
INFO("Rows in a matrix");
CHECK(extra.getNumberOfRows() == 2);
INFO("Columns in a matrix");
CHECK(extra.getNumberOfColumns() == 2);
INFO("Size of a matrix");
CHECK(extra.size() == 4);
INFO("ax+y");
CHECK(std::abs((extra)(0, 0) + 8.) < 1e-12);
INFO("ax+y");
CHECK(std::abs((extra)(1, 0) + 19.) < 1e-12);
INFO("ax+y");
CHECK(std::abs((extra)(0, 1) + 2.) < 1e-12);
INFO("ax+y");
CHECK(std::abs((extra)(1, 1) + 21.) < 1e-12);
A0.resize(3, 7);
INFO("Rows in a matrix");
CHECK(A0.getNumberOfRows() == 3);
INFO("Columns in a matrix");
CHECK(A0.getNumberOfColumns() == 7);
INFO("Size of a matrix");
CHECK(A0.size() == 21);
INFO("Entry of a matrix");
CHECK(std::abs(A0[0] - 4.) < 1e-12);
// wedge stuff
INFO("norm of wedge stuff vector");
CHECK(std::abs((MiddleSizeMatrix(vec0).computeWedgeStuffVector()) *
(MiddleSizeMatrix(vec0).computeWedgeStuffVector()) -
vec0 * vec0) < 1e-12);
INFO("direction of wedge stuff vector");
CHECK(std::abs((MiddleSizeMatrix(vec0).computeWedgeStuffVector()) * vec0) <
1e-12);
INFO("norm of wedge stuff vector");
CHECK(std::abs((MiddleSizeMatrix(vec1).computeWedgeStuffVector()) *
(MiddleSizeMatrix(vec1).computeWedgeStuffVector()) -
vec1 * vec1) < 1e-12);
INFO("direction of wedge stuff vector");
CHECK(std::abs((MiddleSizeMatrix(vec1).computeWedgeStuffVector()) * vec1) <
1e-12);
INFO("norm of wedge stuff vector");
CHECK(std::abs((MiddleSizeMatrix(vec2).computeWedgeStuffVector()) *
(MiddleSizeMatrix(vec2).computeWedgeStuffVector()) -
vec2 * vec2) < 1e-12);
INFO("direction of wedge stuff vector");
CHECK(std::abs((MiddleSizeMatrix(vec2).computeWedgeStuffVector()) * vec2) <
1e-12);
INFO("norm of wedge stuff vector");
CHECK(std::abs((MiddleSizeMatrix(vec3).computeWedgeStuffVector()) *
(MiddleSizeMatrix(vec3).computeWedgeStuffVector()) -
vec3 * vec3) < 1e-12);
INFO("direction of wedge stuff vector");
CHECK(std::abs((MiddleSizeMatrix(vec3).computeWedgeStuffVector()) * vec3) <
1e-12);
MiddleSizeVector vec3D0{0., 1., 2.}, vec3D1{3., 4., 5.},
vec3D2{0., -1., 2.};
///\todo test that the norm of the 3D wedge stuff vector equals the area of
/// the triangle formed by nodes {0, 0, 0}, v1 and v2
INFO("direction of wedge stuff vector");
CHECK(std::abs(
(MiddleSizeMatrix({vec3D0, vec3D1}).computeWedgeStuffVector()) *
vec3D0) < 1e-12);
INFO("direction of wedge stuff vector");
CHECK(std::abs(
(MiddleSizeMatrix({vec3D0, vec3D1}).computeWedgeStuffVector()) *
vec3D1) < 1e-12);
INFO("direction of wedge stuff vector");
CHECK(std::abs(
(MiddleSizeMatrix({vec3D1, vec3D2}).computeWedgeStuffVector()) *
vec3D1) < 1e-12);
INFO("direction of wedge stuff vector");
CHECK(std::abs(
(MiddleSizeMatrix({vec3D1, vec3D2}).computeWedgeStuffVector()) *
vec3D2) < 1e-12);
INFO("direction of wedge stuff vector");
CHECK(std::abs(
(MiddleSizeMatrix({vec3D0, vec3D2}).computeWedgeStuffVector()) *
vec3D0) < 1e-12);
INFO("direction of wedge stuff vector");
CHECK(std::abs(
(MiddleSizeMatrix({vec3D0, vec3D2}).computeWedgeStuffVector()) *
vec3D2) < 1e-12);
MiddleSizeVector vec4D0{0., 1., 2., 3.}, vec4D1{4., 5., 6., 7.},
vec4D2{0., -1., 2., -3.}, vec4D3{0., -1., -2., 3.};
///\todo test that the norm of the 4D wedge stuff vector equals the area of
/// the tetrahedron formed by nodes {0, 0, 0}, v1 and v2 and v3
INFO("direction of wedge stuff vector");
CHECK(std::abs((MiddleSizeMatrix({vec4D0, vec4D1, vec4D2})
.computeWedgeStuffVector()) *
vec4D0) < 1e-12);
INFO("direction of wedge stuff vector");
CHECK(std::abs((MiddleSizeMatrix({vec4D0, vec4D1, vec4D2})
.computeWedgeStuffVector()) *
vec4D1) < 1e-12);
INFO("direction of wedge stuff vector");
CHECK(std::abs((MiddleSizeMatrix({vec4D0, vec4D1, vec4D2})
.computeWedgeStuffVector()) *
vec4D2) < 1e-12);
INFO("direction of wedge stuff vector");
CHECK(std::abs((MiddleSizeMatrix({vec4D0, vec4D1, vec4D3})
.computeWedgeStuffVector()) *
vec4D0) < 1e-12);
INFO("direction of wedge stuff vector");
CHECK(std::abs((MiddleSizeMatrix({vec4D0, vec4D1, vec4D3})
.computeWedgeStuffVector()) *
vec4D1) < 1e-12);
INFO("direction of wedge stuff vector");
CHECK(std::abs((MiddleSizeMatrix({vec4D0, vec4D1, vec4D3})
.computeWedgeStuffVector()) *
vec4D3) < 1e-12);
INFO("direction of wedge stuff vector");
CHECK(std::abs((MiddleSizeMatrix({vec4D0, vec4D2, vec4D3})
.computeWedgeStuffVector()) *
vec4D0) < 1e-12);
INFO("direction of wedge stuff vector");
CHECK(std::abs((MiddleSizeMatrix({vec4D0, vec4D2, vec4D3})
.computeWedgeStuffVector()) *
vec4D2) < 1e-12);
INFO("direction of wedge stuff vector");
CHECK(std::abs((MiddleSizeMatrix({vec4D0, vec4D2, vec4D3})
.computeWedgeStuffVector()) *
vec4D3) < 1e-12);
INFO("direction of wedge stuff vector");
CHECK(std::abs((MiddleSizeMatrix({vec4D1, vec4D2, vec4D3})
.computeWedgeStuffVector()) *
vec4D1) < 1e-12);
INFO("direction of wedge stuff vector");
CHECK(std::abs((MiddleSizeMatrix({vec4D1, vec4D2, vec4D3})
.computeWedgeStuffVector()) *
vec4D2) < 1e-12);
INFO("direction of wedge stuff vector");
CHECK(std::abs((MiddleSizeMatrix({vec4D1, vec4D2, vec4D3})
.computeWedgeStuffVector()) *
vec4D3) < 1e-12);
copy.concatenate(extra);
INFO("Rows in a matrix");
CHECK(copy.getNumberOfRows() == 4);
INFO("Columns in a matrix");
CHECK(copy.getNumberOfColumns() == 2);
INFO("Size of a matrix");
CHECK(copy.size() == 8);
INFO("concatenate");
CHECK(std::abs((copy)(0, 0) - 4.) < 1e-12);
INFO("concatenate");
CHECK(std::abs((copy)(1, 0) - 6.) < 1e-12);
INFO("concatenate");
CHECK(std::abs((copy)(0, 1) - 8.) < 1e-12);
INFO("concatenate");
CHECK(std::abs((copy)(1, 1) - 10.) < 1e-12);
INFO("concatenate");
CHECK(std::abs((copy)(2, 0) + 8.) < 1e-12);
INFO("concatenate");
CHECK(std::abs((copy)(3, 0) + 19.) < 1e-12);
INFO("concatenate");
CHECK(std::abs((copy)(2, 1) + 2.) < 1e-12);
INFO("concatenate");
CHECK(std::abs((copy)(3, 1) + 21.) < 1e-12);
INFO("getColumn");
CHECK(MiddleSizeMatrix({vec3D0, vec3D1}).getColumn(0).size() == 3);
INFO("getColumn");
CHECK(std::abs(((MiddleSizeMatrix({vec3D0, vec3D1}).getColumn(0)) -
vec3D0)[0]) < 1e-12);
INFO("getColumn");
CHECK(std::abs(((MiddleSizeMatrix({vec3D0, vec3D1}).getColumn(0)) -
vec3D0)[1]) < 1e-12);
INFO("getColumn");
CHECK(std::abs(((MiddleSizeMatrix({vec3D0, vec3D1}).getColumn(0)) -
vec3D0)[2]) < 1e-12);
INFO("getColumn");
CHECK(MiddleSizeMatrix({vec3D0, vec3D1}).getColumn(1).size() == 3);
INFO("getColumn");
CHECK(std::abs(((MiddleSizeMatrix({vec3D0, vec3D1}).getColumn(1)) -
vec3D1)[0]) < 1e-12);
INFO("getColumn");
CHECK(std::abs(((MiddleSizeMatrix({vec3D0, vec3D1}).getColumn(1)) -
vec3D1)[1]) < 1e-12);
INFO("getColumn");
CHECK(std::abs(((MiddleSizeMatrix({vec3D0, vec3D1}).getColumn(1)) -
vec3D1)[2]) < 1e-12);
INFO("getRow");
CHECK(MiddleSizeMatrix({vec3D0, vec3D1}).getRow(0).size() == 2);
INFO("getRow");
CHECK(std::abs(((MiddleSizeMatrix({vec3D0, vec3D1}).getRow(0)))[0] - 0.) <
1e-12);
INFO("getRow");
CHECK(std::abs(((MiddleSizeMatrix({vec3D0, vec3D1}).getRow(0)))[1] - 3.) <
1e-12);
INFO("getRow");
CHECK(MiddleSizeMatrix({vec3D0, vec3D1}).getRow(1).size() == 2);
INFO("getRow");
CHECK(std::abs(((MiddleSizeMatrix({vec3D0, vec3D1}).getRow(1)))[0] - 1.) <
1e-12);
INFO("getRow");
CHECK(std::abs(((MiddleSizeMatrix({vec3D0, vec3D1}).getRow(1)))[1] - 4.) <
1e-12);
INFO("getRow");
CHECK(MiddleSizeMatrix({vec3D0, vec3D1}).getRow(2).size() == 2);
INFO("getRow");
CHECK(std::abs(((MiddleSizeMatrix({vec3D0, vec3D1}).getRow(2)))[0] - 2.) <
1e-12);
INFO("getRow");
CHECK(std::abs(((MiddleSizeMatrix({vec3D0, vec3D1}).getRow(2)))[1] - 5.) <
1e-12);
///\todo figure out a way to test a LU factorisation
MiddleSizeVector duplicate = vec2;
count0.solve(vec2);
INFO("inverse and solve");
CHECK(std::abs((vec2 - count0.inverse() * duplicate)[0]) < 1e-12);
INFO("inverse and solve");
CHECK(std::abs((vec2 - count0.inverse() * duplicate)[1]) < 1e-12);
INFO("inverse");
CHECK(std::abs((count0 - count0.inverse().inverse())[0]) < 1e-12);
INFO("inverse");
CHECK(std::abs((count0 - count0.inverse().inverse())[1]) < 1e-12);
INFO("inverse");
CHECK(std::abs((count0 - count0.inverse().inverse())[2]) < 1e-12);
INFO("inverse");
CHECK(std::abs((count0 - count0.inverse().inverse())[3]) < 1e-12);
INFO("transpose");
CHECK(std::abs((count0 - count0.transpose().transpose())[0]) < 1e-12);
INFO("transpose");
CHECK(std::abs((count0 - count0.transpose().transpose())[1]) < 1e-12);
INFO("transpose");
CHECK(std::abs((count0 - count0.transpose().transpose())[2]) < 1e-12);
INFO("transpose");
CHECK(std::abs((count0 - count0.transpose().transpose())[3]) < 1e-12);
INFO("transpose");
CHECK(std::abs(A23(0, 0) - A23.transpose()(0, 0)) < 1e-12);
INFO("transpose");
CHECK(std::abs(A23(1, 0) - A23.transpose()(0, 1)) < 1e-12);
INFO("transpose");
CHECK(std::abs(A23(0, 1) - A23.transpose()(1, 0)) < 1e-12);
INFO("transpose");
CHECK(std::abs(A23(1, 1) - A23.transpose()(1, 1)) < 1e-12);
INFO("transpose");
CHECK(std::abs(A23(0, 2) - A23.transpose()(2, 0)) < 1e-12);
INFO("transpose");
CHECK(std::abs(A23(1, 2) - A23.transpose()(2, 1)) < 1e-12);
auto data = A23.data();
INFO("data");
CHECK(std::abs(data[0] - A23[0]) < 1e-12);
INFO("data");
CHECK(std::abs(data[1] - A23[1]) < 1e-12);
INFO("data");
CHECK(std::abs(data[2] - A23[2]) < 1e-12);
INFO("data");
CHECK(std::abs(data[3] - A23[3]) < 1e-12);
INFO("data");
CHECK(std::abs(data[4] - A23[4]) < 1e-12);
INFO("data");
CHECK(std::abs(data[5] - A23[5]) < 1e-12);
data[2] = 17.3;
INFO("data");
CHECK(std::abs(A23[2] - 17.3) < 1e-12);
std::cout << A32 << std::endl;
}
TEST_CASE("MiddleSizeMatrix solve lower", "[MiddleSizeMatrixUnitTest]") {
LinearAlgebra::MiddleSizeMatrix L(2, 2);
// Define a test matrix
// [1 0; 1 2]
L(0, 0) = 1.0;
L(1, 0) = 1.0;
L(1, 1) = 2.0;
LinearAlgebra::MiddleSizeVector vec({3.0, 4.0});
SECTION("Solve Lx = b") {
L.solveLowerTriangular(vec, LinearAlgebra::Side::OP_LEFT,
LinearAlgebra::Transpose::NOT);
CHECK(vec(0) == 3.0);
CHECK(vec(1) == 0.5);
}
SECTION("Solve xL = b") {
L.solveLowerTriangular(vec, hpgem::LinearAlgebra::Side::OP_RIGHT,
hpgem::LinearAlgebra::Transpose::NOT);
CHECK(vec(0) == 1.0);
CHECK(vec(1) == 2.0);
}
SECTION("Solve L^T x = b") {
L.solveLowerTriangular(vec, hpgem::LinearAlgebra::Side::OP_LEFT,
hpgem::LinearAlgebra::Transpose::TRANSPOSE);
CHECK(vec(0) == 1.0);
CHECK(vec(1) == 2.0);
}
SECTION("Solve x L^T = b") {
L.solveLowerTriangular(vec, hpgem::LinearAlgebra::Side::OP_RIGHT,
hpgem::LinearAlgebra::Transpose::TRANSPOSE);
CHECK(vec(0) == 3.0);
CHECK(vec(1) == 0.5);
}
// Reset for next
}
| 38.52737 | 80 | 0.560211 | [
"vector",
"3d"
] |
c5a68c4ee6b86b1f5e041e80503564ecd2bd9d36 | 794 | cc | C++ | packager/app/gflags_hex_bytes.cc | koln67/shaka-packager | 5b9fd409a5de502e8af2e46ee12840bd2226874d | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 1,288 | 2016-05-25T01:20:31.000Z | 2022-03-02T23:56:56.000Z | packager/app/gflags_hex_bytes.cc | koln67/shaka-packager | 5b9fd409a5de502e8af2e46ee12840bd2226874d | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 894 | 2016-05-17T00:39:30.000Z | 2022-03-02T18:46:21.000Z | packager/app/gflags_hex_bytes.cc | koln67/shaka-packager | 5b9fd409a5de502e8af2e46ee12840bd2226874d | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 400 | 2016-05-25T01:20:35.000Z | 2022-03-03T02:12:00.000Z | // Copyright 2017 Google Inc. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd
#include "packager/app/gflags_hex_bytes.h"
#include "packager/base/strings/string_number_conversions.h"
namespace shaka {
bool ValidateHexString(const char* flagname,
const std::string& value,
std::vector<uint8_t>* value_bytes) {
std::vector<uint8_t> temp_value_bytes;
if (!value.empty() && !base::HexStringToBytes(value, &temp_value_bytes)) {
printf("Invalid hex string for --%s: %s\n", flagname, value.c_str());
return false;
}
value_bytes->swap(temp_value_bytes);
return true;
}
} // namespace shaka
| 30.538462 | 76 | 0.688917 | [
"vector"
] |
c5a7e8093c1406bdfccf566edf4078fb85e7269e | 14,987 | hpp | C++ | src/input/fd_imageManager.hpp | Fluxanoia/Fluxdrive | 5671bbb0690b2d55eb4a0d9b614b36e4b72a3378 | [
"Zlib"
] | null | null | null | src/input/fd_imageManager.hpp | Fluxanoia/Fluxdrive | 5671bbb0690b2d55eb4a0d9b614b36e4b72a3378 | [
"Zlib"
] | null | null | null | src/input/fd_imageManager.hpp | Fluxanoia/Fluxdrive | 5671bbb0690b2d55eb4a0d9b614b36e4b72a3378 | [
"Zlib"
] | null | null | null | #ifndef FD_IMAGE_MANAGER_H_
#define FD_IMAGE_MANAGER_H_
#include <memory>
#include <vector>
#include <string>
#include <SDL_ttf.h>
#include <SDL_image.h>
#include "fd_paths.hpp"
#include "fd_registry.hpp"
#include "../maths/fd_maths.hpp"
#include "../display/fd_resizable.hpp"
/*!
@file
@brief The file containing the classes relating to image management.
*/
//! The data type of the font register value.
typedef int FD_FontRegister;
//! The data type of the image register value.
typedef int FD_ImageRegister;
//! The FD_Font class, manages a font.
class FD_Font {
private:
FD_FontRegister reg;
const int size{ 0 };
TTF_Font* font{ nullptr };
bool loaded{ false };
public:
//! Constructs a FD_Font.
/*!
\param registry The registry of to use.
\param reg The register of the path.
\param size The font size.
*/
FD_Font(const std::weak_ptr<FD_Registry> registry,
const FD_FontRegister reg, const int size);
//! Destroys the FD_Font.
~FD_Font();
//! Checks whether two fonts are identical.
/*!
\param font The font to check against.
\return Whether the two fonts are identical.
*/
bool verify(const std::shared_ptr<FD_Font> font) const;
//! Checks whether two fonts are identical.
/*!
\param reg The register of the font to check against.
\param size The size of the font to check against.
\return Whether the two fonts are identical.
*/
bool verify(const FD_FontRegister reg, const int size) const;
//! Returns the rendered dimensions of the given text.
/*!
\return The rendered dimensions of the given text.
*/
bool getRenderedDimensions(std::string s, int& w, int& h);
//! Returns the size of the font.
/*!
\return The size of the font.
*/
int getSize() const;
//! Returns the raw font.
/*!
\return The raw font.
*/
TTF_Font* getFont();
//! Returns whether the font is loaded or not.
/*
\return Whether the font is loaded or not.
*/
bool isLoaded() const;
//! Returns the register used by the font.
/*!
\return The register used by the font.
*/
FD_FontRegister getRegister() const;
};
//! The FD_Image class, manages all types of visual information.
class FD_Image {
protected:
//! The different image types.
enum ImageType {
//! Corresponds to an invalid image.
IT_INVALID = -1,
//! Corresponds to FD_TextImage.
IT_TEXT,
//! Corresponds to FD_FileImage.
IT_FILE,
//! Corresponds to FD_PureImage.
IT_PURE,
//! Corresponds to FD_GeomImage.
IT_GEOM
};
//! The type of the image.
const ImageType type;
//! Whether the image is loaded or not.
bool loaded{ false };
//! The extrusion of the image.
/*!
The extrusion allows images to be drawn slightly larger than
intended. This is useful if you're trying to draw a grid and there are
small gaps between the cells.
*/
int extrusion{ 0 };
//! The width of the image.
Uint32 width{ 0 };
//! The height of the image.
Uint32 height{ 0 };
//! The texture of the image.
SDL_Texture* texture{ nullptr };
//! The underlay colour of the image.
/*!
This is drawn before the overlay colour and image are drawn.
*/
SDL_Colour underlay_colour{ 0, 0, 0, 0 };
//! The overlay colour of the image.
/*!
This is drawn after the underlay colour and image are drawn.
*/
SDL_Colour overlay_colour{ 0, 0, 0, 0 };
//! Updates the dimensions and loaded status of the image.
void query();
public:
//! Constructs a FD_Image.
FD_Image(const ImageType type);
//! Destroys the FD_Image.
~FD_Image();
//! Renders the image.
/*!
\param renderer The renderer to use.
\param alpha The alpha of the image.
\param srcrect The source rectangle of the image.
\param dstrect The destination rectangle of the image.
\param angle The angle of the image.
\param center_x The x center of the image relative to its top left corner, in units of the image's width.
\param center_y The y center of the image relative to its top left corner, in units of the image's height.
\param flip The flip flags of the image.
\param blend The blend mode of the image.
\param clip The clip rectangle of the image.
*/
virtual void render(SDL_Renderer* renderer,
Uint8 alpha = 255,
const SDL_Rect* srcrect = nullptr,
const SDL_Rect* dstrect = nullptr,
double angle = 0.0,
double center_x = 0.5,
double center_y = 0.5,
SDL_RendererFlip flip = SDL_FLIP_NONE,
SDL_BlendMode blend = SDL_BLENDMODE_NONE,
const SDL_Rect* clip = nullptr);
//! Checks whether two images are identical using a register.
/*!
\param reg The register to check against.
\return Whether the register corresponds to this image.
*/
virtual bool verify(const FD_ImageRegister reg) const;
//! Checks whether two images are identical using a font, text and, colour.
/*!
\param font The register to check against.
\param prefix The prefix to check against.
\param text The text to check against.
\param suffix The suffix to check against.
\param colour The colour to check against.
\return Whether the register corresponds to this image.
*/
virtual bool verify(const std::shared_ptr<FD_Font> font,
const std::string prefix,
const std::string text,
const std::string suffix,
const SDL_Colour colour = { 255, 255, 255, 255 }) const;
//! Returns whether the image is loaded or not.
/*!
\return Whether the image is loaded or not.
*/
bool isLoaded() const;
//! Returns the image width.
/*!
\return The image width.
*/
Uint32 getWidth() const;
//! Returns the image height.
/*!
\return The image height.
*/
Uint32 getHeight() const;
//! Returns the raw texture.
/*!
\return The raw texture.
*/
SDL_Texture* getTexture() const;
//! Sets the extrusion of the image.
/*!
\param size The new extrusion value.
\sa extrusion
*/
void setToExtrude(int size);
//! Sets the overlay colour.
/*!
\param colour The new overlay colour.
*/
void setOverlayColour(SDL_Colour colour);
//! Sets the underlay colour.
/*!
\param colour The new underlay colour.
*/
void setUnderlayColour(SDL_Colour colour);
};
//! The FD_FileImage class, specialising the image to work with files.
class FD_FileImage : public FD_Image {
private:
FD_ImageRegister reg;
public:
//! Constructs a FD_FileImage.
/*!
\param registry The registry of to use.
\param reg The register of the path.
\param renderer The renderer to use.
*/
FD_FileImage(const std::weak_ptr<FD_Registry> registry,
const FD_ImageRegister reg, SDL_Renderer* renderer);
//! Destroys the FD_FileImage.
~FD_FileImage();
//! Checks whether two images are identical using a register.
/*!
\param reg The register to check against.
\return Whether the register corresponds to this image.
*/
bool verify(const FD_ImageRegister reg) const override;
//! Returns the register of this image.
/*!
\return The register of this image.
*/
FD_ImageRegister getRegister() const;
};
//! The FD_TextImage class, specialises the image to work with text.
class FD_TextImage : public FD_Image {
private:
const std::string prefix;
const std::string suffix;
std::string text;
SDL_Colour colour;
const std::shared_ptr<FD_Font> font;
public:
//! Constructs a FD_TextImage.
/*!
The prefix and suffix cannot be changed once this class is instantiated
but the text can. This can be useful for score displays, etc.
\param renderer The renderer to use.
\param font The font to use.
\param prefix The prefix to the text.
\param text The text.
\param suffix The suffix to the text.
\param colour The colour of the text.
*/
FD_TextImage(SDL_Renderer* renderer,
const std::shared_ptr<FD_Font> font,
const std::string prefix,
const std::string text,
const std::string suffix,
const SDL_Colour colour = { 255,255,255,255 });
//! Destroys the FD_TextImage.
~FD_TextImage();
//! Changes the text of the image.
/*!
\param renderer The renderer to use.
\param text The new text.
*/
void changeText(SDL_Renderer* renderer, std::string text);
//! Changes the colour of the text.
/*!
\warning This does not redraw the image.
\param c The new text colour.
*/
void setTextColour(SDL_Colour c);
};
//! This allows the FD_PureImage to re-draw itself by storing the components seperately.
typedef struct FD_PureElement_ {
//! The image used by the element.
std::weak_ptr<FD_Image> image;
//! The opacity of the image.
Uint8 opacity{ 255 };
//! The source rectangle of the element.
SDL_Rect* srcrect{ nullptr };
//! The destination rectangle of the element.
SDL_Rect* dstrect{ nullptr };
//! The angle of the element.
double angle{ 0 };
//! The center of the element, relative to the top left.
SDL_Point* center{ nullptr };
//! The flipping flags of the element.
SDL_RendererFlip flags{ SDL_FLIP_NONE };
//! The blend mode.
SDL_BlendMode blend_mode{ SDL_BLENDMODE_BLEND };
//! The clip rectangle.
SDL_Rect* clip{ nullptr };
} FD_PureElement;
//! The FD_PureImage class, specialises the image for custom renderered texture.
/*!
If the texture given to this class has the SDL_TEXTUREACCESS_RENDER flag,
add this class to the appropriate FD_Window's resizable list.
*/
class FD_PureImage : public FD_Image, public FD_Resizable {
private:
SDL_Renderer* renderer;
Uint32 pure_width, pure_height;
std::vector<FD_PureElement*> elements;
public:
//! Constructs a FD_PureImage.
/*!
You should add this image to the resizable list unless you aren't
planning on resizing the window.
\param renderer The renderer to use to construct the texture.
\param width The width of the made texture.
\param height The height of the made texture.
\param elements The elements to render.
\sa FD_PureElement
*/
FD_PureImage(SDL_Renderer* renderer, Uint32 width, Uint32 height,
std::vector<FD_PureElement*> elements);
//! Destroys the FD_PureImage.
~FD_PureImage();
//! Removes an element from the image.
/*!
\warning This does not redraw the image.
\param e The element to remove.
*/
void remove(FD_PureElement* e);
//! Adds an element to the image.
/*!
\warning This does not redraw the image.
\param e The element to add.
*/
void add(FD_PureElement* e);
//! Removes all elements from the image.
/*!
\warning
*/
void clear();
//! Redraws the image, should be used only when the elements change.
void redraw();
//! Redraws the image, should be used only when the elements change.
/*!
\param width The new width of the image.
\param height The new height of the image.
*/
void redraw(Uint32 width, Uint32 height);
//! When the window is resized, the video device is lost - this circumvents that issue.
/*!
\param width The new width of the window.
\param height The new height of the window.
*/
void resized(int width, int height);
};
//! The FD_ImageManager class, can manage all the visual resources for the program.
class FD_ImageManager : public FD_Registered {
private:
SDL_Renderer* renderer;
std::vector<std::shared_ptr<FD_FileImage>> file_images{ };
std::vector<std::shared_ptr<FD_TextImage>> text_images{ };
std::vector<std::shared_ptr<FD_Font>> fonts{ };
public:
//! Constructs the FD_ImageManager.
/*!
\param renderer The renderer to use.
*/
FD_ImageManager(SDL_Renderer* renderer);
//! Destroys the FD_ImageManager.
~FD_ImageManager();
//! Loads a file image using a register.
/*!
\param reg The register to use.
\return The loaded image.
*/
std::weak_ptr<FD_FileImage> loadImage(const FD_ImageRegister reg);
//! Loads a text image using a font, text and, colour.
/*!
\param font The font to use.
\param text The text to use.
\param colour The colour to use.
\return The loaded image.
*/
std::weak_ptr<FD_TextImage> loadImage(const std::shared_ptr<FD_Font> font,
const std::string text,
const SDL_Colour colour = { 255,255,255,255 });
//! Loads a text image with a prefix and suffix.
/*!
\param font The font to use.
\param prefix The prefix to use.
\param text The text to use.
\param suffix The suffix to use.
\param colour The colour to use.
\return The loaded image.
*/
std::weak_ptr<FD_TextImage> loadImage(const std::shared_ptr<FD_Font> font,
const std::string prefix,
const std::string text,
const std::string suffix,
const SDL_Colour colour = { 255,255,255,255 });
//! Loads file images in bulk.
/*!
\param regs The file registers to use.
\return The loaded images.
*/
std::vector<std::weak_ptr<FD_FileImage>> bulkLoadImage(
const std::vector<FD_ImageRegister> regs);
//! Loads text images in bulk.
/*!
\param font The font to use.
\param texts The text to use.
\param colour The colour to use.
\return The loaded images.
*/
std::vector<std::weak_ptr<FD_TextImage>> bulkLoadImage(
const std::shared_ptr<FD_Font> font,
const std::vector<std::string> texts,
const SDL_Colour colour = { 255,255,255,255 });
//! Loads text images with prefixes and suffixes in bulk.
/*!
\param font The font to use.
\param prefixes The prefixes to use.
\param texts The text to use.
\param suffixes The suffixes to use.
\param colour The colour to use.
\return The loaded images.
*/
std::vector<std::weak_ptr<FD_TextImage>> bulkLoadImage(
const std::shared_ptr<FD_Font> font,
const std::vector<std::string> prefixes,
const std::vector<std::string> texts,
const std::vector<std::string> suffixes,
const SDL_Colour colour = { 255,255,255,255 });
//! Loads a font.
/*!
\param reg The register to use.
\param size The size of the font.
\return The loaded font.
*/
std::weak_ptr<FD_Font> loadFont(const FD_FontRegister reg, const int size);
//! Deletes an image from the manager.
/*!
\warning This should be a PNG or JPG.
\param reg The register of the image to delete.
\return Whether an image was deleted.
*/
bool deleteImage(const FD_ImageRegister reg);
//! Deletes an image from the manager.
/*!
\param font The font of the image to delete.
\param text The text of the image to delete.
\param colour The colour of the image to delete.
\return Whether an image was deleted.
*/
bool deleteImage(const std::shared_ptr<FD_Font> font,
const std::string text,
const SDL_Colour colour = { 255,255,255,255 });
//! Deletes an image from the manager.
/*!
\param font The font of the image to delete.
\param prefix The prefix of the image to delete.
\param text The text of the image to delete.
\param suffix The suffix of the image to delete.
\param colour The colour of the image to delete.
\return Whether an image was deleted.
*/
bool deleteImage(const std::shared_ptr<FD_Font> font,
const std::string prefix,
const std::string text,
const std::string suffix,
const SDL_Colour colour = { 255,255,255,255 });
//! Deletes a font from the manager.
/*!
\param reg The register of the font to delete.
\param size The size of the font to delete.
*/
bool deleteFont(const FD_FontRegister reg, const int size);
};
#endif | 26.858423 | 108 | 0.705812 | [
"render",
"vector"
] |
c5a896f9b051d59394317385a1cdf0301daea76a | 11,206 | cpp | C++ | csgo_internal/RageBot.cpp | XGOD4/REDHOOK | ee8d4addf2051c07defa6df494ce00cdddefd709 | [
"MIT"
] | 1 | 2018-04-19T00:50:58.000Z | 2018-04-19T00:50:58.000Z | csgo_internal/RageBot.cpp | XGOD4/REDHOOK | ee8d4addf2051c07defa6df494ce00cdddefd709 | [
"MIT"
] | 1 | 2018-04-14T06:34:14.000Z | 2018-04-14T06:34:14.000Z | csgo_internal/RageBot.cpp | XGOD4/REDHOOK | ee8d4addf2051c07defa6df494ce00cdddefd709 | [
"MIT"
] | null | null | null | #include "Cheat.h"
// lazy
float m_bestfov = 360.0f;
float m_bestdist = 8192.f;
float m_bestthreat = 0.f;
Vector m_besthitbox = Vector( 0, 0, 0 );
CBaseEntity* m_bestent = nullptr;
bool m_target = false;
void CRageBot::Run()
{
DropTarget();
// AA fixmove
CFixMove fixMove;
fixMove.Start();
if( Vars.Ragebot.Antiaim.Enabled )
{
G::InAntiAim = true;
AntiAim->Run();
}
else
{
G::InAntiAim = false;
G::SendPacket = true;
}
fixMove.End();
G::Aimbotting = false;
if( !G::LocalPlayer->GetWeapon()->IsGun() || G::LocalPlayer->GetWeapon()->IsEmpty() )
return;
if( G::BestTarget == -1 )
FindTarget();
if( Vars.Ragebot.Hold && !G::PressedKeys[ Vars.Ragebot.HoldKey ] )
return;
if( G::BestTarget != -1 && !G::LocalPlayer->GetWeapon()->IsReloading() && m_target )
GoToTarget();
}
void CRageBot::FindTarget()
{
m_bestfov = Vars.Ragebot.FOV;
m_bestdist = 8192.f;
m_bestthreat = 0.f;
m_besthitbox = Vector( 0, 0, 0 );
m_target = false;
m_bestent = nullptr;
for( int i = 0; i <= I::Globals->maxClients; i++ )
{
if( !EntityIsValid( i ) )
continue;
CBaseEntity* Entity = I::ClientEntList->GetClientEntity( i );
Vector hitbox = Entity->GetBonePosition( Vars.Ragebot.Hitbox );
if( Vars.Ragebot.TargetMethod == 0 )
{
float fov = M::GetFov( G::UserCmd->viewangles, M::CalcAngle( G::LocalPlayer->GetEyePosition(), hitbox ) );
if( fov < m_bestfov )
{
m_bestfov = fov;
G::BestTarget = i;
m_bestent = Entity;
if( Vars.Ragebot.HitScanAll )
{
if( BestAimPointAll( Entity, m_besthitbox ) )
m_target = true;
}
else if( Vars.Ragebot.HitScanHitbox )
{
if( BestAimPointHitbox( Entity, m_besthitbox ) )
m_target = true;
}
else
{
m_besthitbox = hitbox;
m_target = true;
}
}
}
if( Vars.Ragebot.TargetMethod == 1 )
{
float fov = M::GetFov( G::UserCmd->viewangles, M::CalcAngle( G::LocalPlayer->GetEyePosition(), hitbox ) );
float dist = M::VectorDistance( G::LocalPlayer->GetOrigin(), Entity->GetOrigin() );
if( dist < m_bestdist && fov < m_bestfov )
{
m_bestdist = dist;
G::BestTarget = i;
m_bestent = Entity;
if( Vars.Ragebot.HitScanAll )
{
if( BestAimPointAll( Entity, m_besthitbox ) )
m_target = true;
}
else if( Vars.Ragebot.HitScanHitbox )
{
if( BestAimPointHitbox( Entity, m_besthitbox ) )
m_target = true;
}
else
{
m_besthitbox = hitbox;
m_target = true;
}
}
}
// threat target method spreads the damage evenally across all players that you're able to do damage to
// if a target is aiming at you they're are prioritised
if( Vars.Ragebot.TargetMethod == 2 )
{
float fov = M::GetFov( G::UserCmd->viewangles, M::CalcAngle( G::LocalPlayer->GetEyePosition(), hitbox ) );
float dist = M::VectorDistance( G::LocalPlayer->GetOrigin(), Entity->GetOrigin() );
float health = ( float )Entity->GetHealth();
float threat = health / dist;
if( Entity->IsTargetingLocal() )
threat += 100;
if( threat > m_bestthreat && fov < m_bestfov )
{
m_bestthreat = threat;
G::BestTarget = i;
m_bestent = Entity;
if( Vars.Ragebot.HitScanAll )
{
if( BestAimPointAll( Entity, m_besthitbox ) )
m_target = true;
}
else if( Vars.Ragebot.HitScanHitbox )
{
if( BestAimPointHitbox( Entity, m_besthitbox ) )
m_target = true;
}
else
{
m_besthitbox = hitbox;
m_target = true;
}
}
}
}
}
void CRageBot::GoToTarget()
{
bool auto_shoot = false;
bool can_shoot = true;
bool reloading = false;
auto weapon = G::LocalPlayer->GetWeapon();
float server_time = G::LocalPlayer->GetTickBase() * I::Globals->interval_per_tick;
float next_shot = weapon->GetNextPrimaryAttack() - server_time;
if( next_shot > 0 )
can_shoot = false;
// just simple velocity prediction, not engine prediction
m_besthitbox = m_bestent->GetPredicted( m_besthitbox );
QAngle aim_angle = M::CalcAngle( G::LocalPlayer->GetEyePosition(), m_besthitbox );
aim_angle -= G::LocalPlayer->GetPunch() * 2.f;
// fixmove for silentaim
CFixMove fixMove;
if( Vars.Ragebot.Silent )
fixMove.Start();
if( Vars.Ragebot.Aimstep && can_shoot )
{
G::Aimbotting = true;
QAngle angNextAngle;
bool bFinished = Aimstep( G::LastAngle, aim_angle, angNextAngle, Vars.Ragebot.AimstepAmount );
G::UserCmd->viewangles = angNextAngle;
G::LastAngle = angNextAngle;
if( bFinished )
auto_shoot = true;
}
else if( can_shoot )
{
G::Aimbotting = true;
G::UserCmd->viewangles = aim_angle;
auto_shoot = true;
}
if( Vars.Ragebot.Silent )
fixMove.End();
if( Vars.Ragebot.AutoStop )
{
G::UserCmd->forwardmove = 0;
G::UserCmd->sidemove = 0;
G::UserCmd->upmove = 0;
G::UserCmd->buttons = 0;
}
if( Vars.Ragebot.AutoCrouch )
G::UserCmd->buttons |= IN_DUCK;
float hitchance = 75.f + ( Vars.Ragebot.HitChanceAmt / 4 );
if( auto_shoot && can_shoot && Vars.Ragebot.AutoFire && ( !Vars.Ragebot.HitChance || ( 1.0f - G::LocalPlayer->GetWeapon()->GetAccuracyPenalty() ) * 100.f >= hitchance ) )
G::UserCmd->buttons |= IN_ATTACK;
}
void CRageBot::DropTarget()
{
if( !EntityIsValid( G::BestTarget ) || Vars.Ragebot.HitScanAll || Vars.Ragebot.HitScanHitbox )
G::BestTarget = -1;
}
bool CRageBot::Aimstep( QAngle src, QAngle dst, QAngle& out, int steps )
{
QAngle delta_angle = ( dst - src ).Normalized();;
bool x_finished = false;
bool y_finished = false;
if( delta_angle.x > steps )
src.x += steps;
else if( delta_angle.x < -steps )
src.x -= steps;
else
{
x_finished = true;
src.x = dst.x;
}
if( delta_angle.y > steps )
src.y += steps;
else if( delta_angle.y < -steps )
src.y -= steps;
else
{
y_finished = true;
src.y = dst.y;
}
src.Normalized();
out = src;
return x_finished && y_finished;
}
bool CRageBot::GetHitbox( CBaseEntity* target, Hitbox* hitbox )
{
matrix3x4a_t matrix[ MAXSTUDIOBONES ];
if( !target->SetupBones( matrix, MAXSTUDIOBONES, BONE_USED_BY_HITBOX, 0 ) )
return false;
studiohdr_t* hdr = I::ModelInfo->GetStudioModel( target->GetModel() );
if( !hdr )
return false;
mstudiohitboxset_t* hitboxSet = hdr->pHitboxSet( target->GetHitboxSet() );
mstudiobbox_t* untransformedBox = hitboxSet->pHitbox( hitbox->hitbox );
Vector bbmin = untransformedBox->bbmin;
Vector bbmax = untransformedBox->bbmax;
if( untransformedBox->radius != -1.f )
{
bbmin -= Vector( untransformedBox->radius, untransformedBox->radius, untransformedBox->radius );
bbmax += Vector( untransformedBox->radius, untransformedBox->radius, untransformedBox->radius );
}
Vector points[] = { ( ( bbmin + bbmax ) * .5f ),
Vector( bbmin.x, bbmin.y, bbmin.z ),
Vector( bbmin.x, bbmax.y, bbmin.z ),
Vector( bbmax.x, bbmax.y, bbmin.z ),
Vector( bbmax.x, bbmin.y, bbmin.z ),
Vector( bbmax.x, bbmax.y, bbmax.z ),
Vector( bbmin.x, bbmax.y, bbmax.z ),
Vector( bbmin.x, bbmin.y, bbmax.z ),
Vector( bbmax.x, bbmin.y, bbmax.z ) };
for( int index = 0; index <= 8; ++index )
{
if( index != 0 )
points[ index ] = ( ( ( ( points[ index ] + points[ 0 ] ) * .5f ) + points[ index ] ) * .5f );
M::VectorTransform( points[ index ], matrix[ untransformedBox->bone ], hitbox->points[ index ] );
}
return true;
}
bool CRageBot::GetBestPoint( CBaseEntity* target, Hitbox* hitbox, BestPoint* point )
{
Vector center = hitbox->points[ 0 ];
if( hitbox->hitbox == HITBOX_HEAD )
{
Vector high = ( ( hitbox->points[ 3 ] + hitbox->points[ 5 ] ) * .5f );
float pitch = target->GetEyeAngles().x;
if( ( pitch > 0.f ) && ( pitch <= 89.f ) )
{
Vector height = ( ( ( high - hitbox->points[ 0 ] ) / 3 ) * 4 );
Vector new_height = ( hitbox->points[ 0 ] + ( height * ( pitch / 89.f ) ) );
hitbox->points[ 0 ] = new_height;
point->flags |= FL_HIGH;
}
else if( ( pitch < 292.5f ) && ( pitch >= 271.f ) )
{
hitbox->points[ 0 ] -= Vector( 0.f, 0.f, 1.f );
point->flags |= FL_LOW;
}
}
for( int index = 0; index <= 8; ++index )
{
int temp_damage = AutoWall->GetDamage( hitbox->points[ index ] );
if( ( point->dmg < temp_damage ) )
{
point->dmg = temp_damage;
point->point = hitbox->points[ index ];
point->index = index;
}
}
return ( point->dmg > Vars.Ragebot.AutoWallDmg );
}
int hitboxes[7] =
{
HITBOX_HEAD,
HITBOX_CHEST,
HITBOX_PELVIS,
HITBOX_RIGHT_FOREARM,
HITBOX_LEFT_FOREARM,
HITBOX_RIGHT_CALF,
HITBOX_LEFT_CALF
};
// goes through the above hitboxes and selects the best point on the target that will deal the most damage
bool CRageBot::BestAimPointAll( CBaseEntity* target, Vector& hitbox )
{
BestPoint aim_point;
for( int i = 0; i < 7; i++ )
{
Hitbox hitbox( hitboxes[ i ] );
GetHitbox( target, &hitbox );
if( !GetBestPoint( target, &hitbox, &aim_point ) )
continue;
}
if( aim_point.dmg > Vars.Ragebot.AutoWallDmg )
{
hitbox = aim_point.point;
return true;
}
return false;
}
// checks multiple points inside the selected hitbox and picks the best point which will deal the most damage
bool CRageBot::BestAimPointHitbox( CBaseEntity* target, Vector& hitbox )
{
BestPoint aim_point;
int hitboxnum = 0;
switch( Vars.Ragebot.Hitbox )
{
case 0:
hitboxnum = 3;
break;
case 1:
hitboxnum = 6;
break;
case 2:
case 3:
hitboxnum = 4;
break;
case 4:
hitboxnum = 7;
break;
case 5:
hitboxnum = 1;
break;
case 6:
hitboxnum = 0;
break;
default:
hitboxnum = 0;
break;
}
Hitbox hitboxx( hitboxnum );
GetHitbox( target, &hitboxx );
if( !GetBestPoint( target, &hitboxx, &aim_point ) )
return false;
if( aim_point.dmg > Vars.Ragebot.AutoWallDmg )
{
hitbox = aim_point.point;
return true;
}
return false;
}
bool CRageBot::EntityIsValid( int i )
{
CBaseEntity* Entity = I::ClientEntList->GetClientEntity( i );
if( !Entity )
return false;
if( Entity == G::LocalPlayer )
return false;
if( !Vars.Ragebot.FriendlyFire )
{
if( Entity->GetTeam() == G::LocalPlayer->GetTeam() )
return false;
}
if( Entity->GetDormant() )
return false;
if( Entity->GetImmune() )
return false;
if( Entity->GetHealth() <= 0 )
return false;
if( !Vars.Ragebot.HitScanAll && !Vars.Ragebot.HitScanHitbox )
{
if( Vars.Ragebot.AutoWallDmg > AutoWall->GetDamage( Entity->GetBonePosition( Vars.Ragebot.Hitbox ) ) )
return false;
}
return true;
}
void CRageBot::CFixMove::Start()
{
m_oldangle = G::UserCmd->viewangles;
m_oldforward = G::UserCmd->forwardmove;
m_oldsidemove = G::UserCmd->sidemove;
}
void CRageBot::CFixMove::End()
{
float yaw_delta = G::UserCmd->viewangles.y - m_oldangle.y;
float f1;
float f2;
if( m_oldangle.y < 0.f )
f1 = 360.0f + m_oldangle.y;
else
f1 = m_oldangle.y;
if( G::UserCmd->viewangles.y < 0.0f )
f2 = 360.0f + G::UserCmd->viewangles.y;
else
f2 = G::UserCmd->viewangles.y;
if( f2 < f1 )
yaw_delta = abs( f2 - f1 );
else
yaw_delta = 360.0f - abs( f1 - f2 );
yaw_delta = 360.0f - yaw_delta;
G::UserCmd->forwardmove = cos( DEG2RAD( yaw_delta ) ) * m_oldforward + cos( DEG2RAD( yaw_delta + 90.f ) ) * m_oldsidemove;
G::UserCmd->sidemove = sin( DEG2RAD( yaw_delta ) ) * m_oldforward + sin( DEG2RAD( yaw_delta + 90.f ) ) * m_oldsidemove;
}
| 22.822811 | 171 | 0.644744 | [
"vector"
] |
c5aba6d34dffb6391e1bed1736ae0bc082e710e4 | 4,000 | cc | C++ | third_party/blink/renderer/core/inspector/console_message.cc | zipated/src | 2b8388091c71e442910a21ada3d97ae8bc1845d3 | [
"BSD-3-Clause"
] | 2,151 | 2020-04-18T07:31:17.000Z | 2022-03-31T08:39:18.000Z | third_party/blink/renderer/core/inspector/console_message.cc | cangulcan/src | 2b8388091c71e442910a21ada3d97ae8bc1845d3 | [
"BSD-3-Clause"
] | 395 | 2020-04-18T08:22:18.000Z | 2021-12-08T13:04:49.000Z | third_party/blink/renderer/core/inspector/console_message.cc | cangulcan/src | 2b8388091c71e442910a21ada3d97ae8bc1845d3 | [
"BSD-3-Clause"
] | 338 | 2020-04-18T08:03:10.000Z | 2022-03-29T12:33:22.000Z | // Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "third_party/blink/renderer/core/inspector/console_message.h"
#include "third_party/blink/public/web/web_console_message.h"
#include "third_party/blink/renderer/bindings/core/v8/source_location.h"
#include "third_party/blink/renderer/core/dom/node.h"
#include "third_party/blink/renderer/core/frame/local_frame.h"
#include "third_party/blink/renderer/core/inspector/identifiers_factory.h"
#include "third_party/blink/renderer/core/workers/worker_thread.h"
#include "third_party/blink/renderer/platform/wtf/assertions.h"
#include "third_party/blink/renderer/platform/wtf/time.h"
namespace blink {
// static
ConsoleMessage* ConsoleMessage::CreateForRequest(
MessageSource source,
MessageLevel level,
const String& message,
const String& url,
DocumentLoader* loader,
unsigned long request_identifier) {
ConsoleMessage* console_message = ConsoleMessage::Create(
source, level, message, SourceLocation::Capture(url, 0, 0));
console_message->request_identifier_ =
IdentifiersFactory::RequestId(loader, request_identifier);
return console_message;
}
// static
ConsoleMessage* ConsoleMessage::Create(
MessageSource source,
MessageLevel level,
const String& message,
std::unique_ptr<SourceLocation> location) {
return new ConsoleMessage(source, level, message, std::move(location));
}
// static
ConsoleMessage* ConsoleMessage::Create(MessageSource source,
MessageLevel level,
const String& message) {
return ConsoleMessage::Create(source, level, message,
SourceLocation::Capture());
}
// static
ConsoleMessage* ConsoleMessage::CreateFromWorker(
MessageLevel level,
const String& message,
std::unique_ptr<SourceLocation> location,
WorkerThread* worker_thread) {
ConsoleMessage* console_message = ConsoleMessage::Create(
kWorkerMessageSource, level, message, std::move(location));
console_message->worker_id_ =
IdentifiersFactory::IdFromToken(worker_thread->GetDevToolsWorkerToken());
return console_message;
}
ConsoleMessage::ConsoleMessage(MessageSource source,
MessageLevel level,
const String& message,
std::unique_ptr<SourceLocation> location)
: source_(source),
level_(level),
message_(message),
location_(std::move(location)),
timestamp_(WTF::CurrentTimeMS()),
frame_(nullptr) {}
ConsoleMessage::~ConsoleMessage() = default;
SourceLocation* ConsoleMessage::Location() const {
return location_.get();
}
const String& ConsoleMessage::RequestIdentifier() const {
return request_identifier_;
}
double ConsoleMessage::Timestamp() const {
return timestamp_;
}
MessageSource ConsoleMessage::Source() const {
return source_;
}
MessageLevel ConsoleMessage::Level() const {
return level_;
}
const String& ConsoleMessage::Message() const {
return message_;
}
const String& ConsoleMessage::WorkerId() const {
return worker_id_;
}
LocalFrame* ConsoleMessage::Frame() const {
// Do not reference detached frames.
if (frame_ && frame_->Client())
return frame_;
return nullptr;
}
Vector<DOMNodeId>& ConsoleMessage::Nodes() {
return nodes_;
}
void ConsoleMessage::SetNodes(LocalFrame* frame, Vector<DOMNodeId> nodes) {
frame_ = frame;
nodes_ = std::move(nodes);
}
void ConsoleMessage::Trace(blink::Visitor* visitor) {
visitor->Trace(frame_);
}
STATIC_ASSERT_ENUM(WebConsoleMessage::kLevelVerbose, kVerboseMessageLevel);
STATIC_ASSERT_ENUM(WebConsoleMessage::kLevelInfo, kInfoMessageLevel);
STATIC_ASSERT_ENUM(WebConsoleMessage::kLevelWarning, kWarningMessageLevel);
STATIC_ASSERT_ENUM(WebConsoleMessage::kLevelError, kErrorMessageLevel);
} // namespace blink
| 30.769231 | 79 | 0.72675 | [
"vector"
] |
c5ad9d9ed8e1e66d21cdf21d1eee0e5be4449130 | 13,017 | cpp | C++ | WebKit/Source/JavaScriptCore/dfg/DFGGraph.cpp | JavaScriptTesting/LJS | 9818dbdb421036569fff93124ac2385d45d01c3a | [
"Apache-2.0"
] | 1 | 2019-06-18T06:52:54.000Z | 2019-06-18T06:52:54.000Z | WebKit/Source/JavaScriptCore/dfg/DFGGraph.cpp | JavaScriptTesting/LJS | 9818dbdb421036569fff93124ac2385d45d01c3a | [
"Apache-2.0"
] | null | null | null | WebKit/Source/JavaScriptCore/dfg/DFGGraph.cpp | JavaScriptTesting/LJS | 9818dbdb421036569fff93124ac2385d45d01c3a | [
"Apache-2.0"
] | null | null | null | /*
* Copyright (C) 2011 Apple Inc. 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 APPLE INC. ``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 APPLE INC. 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.
*/
#include "config.h"
#include "DFGGraph.h"
#include "CodeBlock.h"
#if ENABLE(DFG_JIT)
namespace JSC { namespace DFG {
#ifndef NDEBUG
// Creates an array of stringized names.
static const char* dfgOpNames[] = {
#define STRINGIZE_DFG_OP_ENUM(opcode, flags) #opcode ,
FOR_EACH_DFG_OP(STRINGIZE_DFG_OP_ENUM)
#undef STRINGIZE_DFG_OP_ENUM
};
const char *Graph::opName(NodeType op)
{
return dfgOpNames[op & NodeIdMask];
}
const char* Graph::nameOfVariableAccessData(VariableAccessData* variableAccessData)
{
// Variables are already numbered. For readability of IR dumps, this returns
// an alphabetic name for the variable access data, so that you don't have to
// reason about two numbers (variable number and live range number), but instead
// a number and a letter.
unsigned index = std::numeric_limits<unsigned>::max();
for (unsigned i = 0; i < m_variableAccessData.size(); ++i) {
if (&m_variableAccessData[i] == variableAccessData) {
index = i;
break;
}
}
ASSERT(index != std::numeric_limits<unsigned>::max());
if (!index)
return "A";
static char buf[10];
BoundsCheckedPointer<char> ptr(buf, sizeof(buf));
while (index) {
*ptr++ = 'A' + (index % 26);
index /= 26;
}
*ptr++ = 0;
return buf;
}
static void printWhiteSpace(unsigned amount)
{
while (amount-- > 0)
printf(" ");
}
void Graph::dumpCodeOrigin(NodeIndex nodeIndex)
{
if (!nodeIndex)
return;
Node& currentNode = at(nodeIndex);
Node& previousNode = at(nodeIndex - 1);
if (previousNode.codeOrigin.inlineCallFrame == currentNode.codeOrigin.inlineCallFrame)
return;
Vector<CodeOrigin> previousInlineStack = previousNode.codeOrigin.inlineStack();
Vector<CodeOrigin> currentInlineStack = currentNode.codeOrigin.inlineStack();
unsigned commonSize = std::min(previousInlineStack.size(), currentInlineStack.size());
unsigned indexOfDivergence = commonSize;
for (unsigned i = 0; i < commonSize; ++i) {
if (previousInlineStack[i].inlineCallFrame != currentInlineStack[i].inlineCallFrame) {
indexOfDivergence = i;
break;
}
}
// Print the pops.
for (unsigned i = previousInlineStack.size(); i-- > indexOfDivergence;) {
printWhiteSpace(i * 2);
printf("<-- %p\n", previousInlineStack[i].inlineCallFrame->executable.get());
}
// Print the pushes.
for (unsigned i = indexOfDivergence; i < currentInlineStack.size(); ++i) {
printWhiteSpace(i * 2);
printf("--> %p\n", currentInlineStack[i].inlineCallFrame->executable.get());
}
}
void Graph::dump(NodeIndex nodeIndex, CodeBlock* codeBlock)
{
Node& node = at(nodeIndex);
NodeType op = node.op;
unsigned refCount = node.refCount();
bool skipped = !refCount;
bool mustGenerate = node.mustGenerate();
if (mustGenerate) {
ASSERT(refCount);
--refCount;
}
dumpCodeOrigin(nodeIndex);
printWhiteSpace((node.codeOrigin.inlineDepth() - 1) * 2);
// Example/explanation of dataflow dump output
//
// 14: <!2:7> GetByVal(@3, @13)
// ^1 ^2 ^3 ^4 ^5
//
// (1) The nodeIndex of this operation.
// (2) The reference count. The number printed is the 'real' count,
// not including the 'mustGenerate' ref. If the node is
// 'mustGenerate' then the count it prefixed with '!'.
// (3) The virtual register slot assigned to this node.
// (4) The name of the operation.
// (5) The arguments to the operation. The may be of the form:
// @# - a NodeIndex referencing a prior node in the graph.
// arg# - an argument number.
// $# - the index in the CodeBlock of a constant { for numeric constants the value is displayed | for integers, in both decimal and hex }.
// id# - the index in the CodeBlock of an identifier { if codeBlock is passed to dump(), the string representation is displayed }.
// var# - the index of a var on the global object, used by GetGlobalVar/PutGlobalVar operations.
printf("% 4d:%s<%c%u:", (int)nodeIndex, skipped ? " skipped " : " ", mustGenerate ? '!' : ' ', refCount);
if (node.hasResult() && !skipped && node.hasVirtualRegister())
printf("%u", node.virtualRegister());
else
printf("-");
printf(">\t%s(", opName(op));
bool hasPrinted = false;
if (op & NodeHasVarArgs) {
for (unsigned childIdx = node.firstChild(); childIdx < node.firstChild() + node.numChildren(); childIdx++) {
if (hasPrinted)
printf(", ");
else
hasPrinted = true;
printf("@%u", m_varArgChildren[childIdx]);
}
} else {
if (node.child1() != NoNode)
printf("@%u", node.child1());
if (node.child2() != NoNode)
printf(", @%u", node.child2());
if (node.child3() != NoNode)
printf(", @%u", node.child3());
hasPrinted = node.child1() != NoNode;
}
if (node.hasArithNodeFlags()) {
printf("%s%s", hasPrinted ? ", " : "", arithNodeFlagsAsString(node.rawArithNodeFlags()));
hasPrinted = true;
}
if (node.hasVarNumber()) {
printf("%svar%u", hasPrinted ? ", " : "", node.varNumber());
hasPrinted = true;
}
if (node.hasIdentifier()) {
if (codeBlock)
printf("%sid%u{%s}", hasPrinted ? ", " : "", node.identifierNumber(), codeBlock->identifier(node.identifierNumber()).ustring().utf8().data());
else
printf("%sid%u", hasPrinted ? ", " : "", node.identifierNumber());
hasPrinted = true;
}
if (node.hasStructureSet()) {
for (size_t i = 0; i < node.structureSet().size(); ++i) {
printf("%sstruct(%p)", hasPrinted ? ", " : "", node.structureSet()[i]);
hasPrinted = true;
}
}
if (node.hasStructureTransitionData()) {
printf("%sstruct(%p -> %p)", hasPrinted ? ", " : "", node.structureTransitionData().previousStructure, node.structureTransitionData().newStructure);
hasPrinted = true;
}
if (node.hasStorageAccessData()) {
StorageAccessData& storageAccessData = m_storageAccessData[node.storageAccessDataIndex()];
if (codeBlock)
printf("%sid%u{%s}", hasPrinted ? ", " : "", storageAccessData.identifierNumber, codeBlock->identifier(storageAccessData.identifierNumber).ustring().utf8().data());
else
printf("%sid%u", hasPrinted ? ", " : "", storageAccessData.identifierNumber);
printf(", %lu", static_cast<unsigned long>(storageAccessData.offset));
hasPrinted = true;
}
ASSERT(node.hasVariableAccessData() == node.hasLocal());
if (node.hasVariableAccessData()) {
VariableAccessData* variableAccessData = node.variableAccessData();
int operand = variableAccessData->operand();
if (operandIsArgument(operand))
printf("%sarg%u(%s)", hasPrinted ? ", " : "", operandToArgument(operand), nameOfVariableAccessData(variableAccessData));
else
printf("%sr%u(%s)", hasPrinted ? ", " : "", operand, nameOfVariableAccessData(variableAccessData));
hasPrinted = true;
}
if (node.hasConstantBuffer() && codeBlock) {
if (hasPrinted)
printf(", ");
printf("%u:[", node.startConstant());
for (unsigned i = 0; i < node.numConstants(); ++i) {
if (i)
printf(", ");
printf("%s", codeBlock->constantBuffer(node.startConstant())[i].description());
}
printf("]");
hasPrinted = true;
}
if (op == JSConstant) {
printf("%s$%u", hasPrinted ? ", " : "", node.constantNumber());
if (codeBlock) {
JSValue value = valueOfJSConstant(codeBlock, nodeIndex);
printf(" = %s", value.description());
}
hasPrinted = true;
}
if (op == WeakJSConstant) {
printf("%s%p", hasPrinted ? ", " : "", node.weakConstant());
hasPrinted = true;
}
if (node.isBranch() || node.isJump()) {
printf("%sT:#%u", hasPrinted ? ", " : "", node.takenBlockIndex());
hasPrinted = true;
}
if (node.isBranch()) {
printf("%sF:#%u", hasPrinted ? ", " : "", node.notTakenBlockIndex());
hasPrinted = true;
}
(void)hasPrinted;
printf(")");
if (!skipped) {
if (node.hasVariableAccessData())
printf(" predicting %s, double ratio %lf%s", predictionToString(node.variableAccessData()->prediction()), node.variableAccessData()->doubleVoteRatio(), node.variableAccessData()->shouldUseDoubleFormat() ? ", forcing double" : "");
else if (node.hasVarNumber())
printf(" predicting %s", predictionToString(getGlobalVarPrediction(node.varNumber())));
else if (node.hasHeapPrediction())
printf(" predicting %s", predictionToString(node.getHeapPrediction()));
}
printf("\n");
}
void Graph::dump(CodeBlock* codeBlock)
{
for (size_t b = 0; b < m_blocks.size(); ++b) {
BasicBlock* block = m_blocks[b].get();
printf("Block #%u (bc#%u): %s%s\n", (int)b, block->bytecodeBegin, block->isReachable ? "" : " (skipped)", block->isOSRTarget ? " (OSR target)" : "");
printf(" vars before: ");
if (block->cfaHasVisited)
dumpOperands(block->valuesAtHead, stdout);
else
printf("<empty>");
printf("\n");
printf(" var links: ");
dumpOperands(block->variablesAtHead, stdout);
printf("\n");
for (size_t i = block->begin; i < block->end; ++i)
dump(i, codeBlock);
printf(" vars after: ");
if (block->cfaHasVisited)
dumpOperands(block->valuesAtTail, stdout);
else
printf("<empty>");
printf("\n");
}
printf("Phi Nodes:\n");
for (size_t i = m_blocks.last()->end; i < size(); ++i)
dump(i, codeBlock);
}
#endif
// FIXME: Convert this method to be iterative, not recursive.
void Graph::refChildren(NodeIndex op)
{
Node& node = at(op);
if (node.op & NodeHasVarArgs) {
for (unsigned childIdx = node.firstChild(); childIdx < node.firstChild() + node.numChildren(); childIdx++)
ref(m_varArgChildren[childIdx]);
} else {
if (node.child1() == NoNode) {
ASSERT(node.child2() == NoNode && node.child3() == NoNode);
return;
}
ref(node.child1());
if (node.child2() == NoNode) {
ASSERT(node.child3() == NoNode);
return;
}
ref(node.child2());
if (node.child3() == NoNode)
return;
ref(node.child3());
}
}
void Graph::predictArgumentTypes(CodeBlock* codeBlock)
{
ASSERT(codeBlock);
ASSERT(codeBlock->alternative());
CodeBlock* profiledCodeBlock = codeBlock->alternative();
ASSERT(codeBlock->m_numParameters >= 1);
for (size_t arg = 0; arg < static_cast<size_t>(codeBlock->m_numParameters); ++arg) {
ValueProfile* profile = profiledCodeBlock->valueProfileForArgument(arg);
if (!profile)
continue;
at(m_arguments[arg]).variableAccessData()->predict(profile->computeUpdatedPrediction());
#if DFG_ENABLE(DEBUG_VERBOSE)
printf("Argument [%lu] prediction: %s\n", arg, predictionToString(at(m_arguments[arg]).variableAccessData()->prediction()));
#endif
}
}
} } // namespace JSC::DFG
#endif
| 36.875354 | 243 | 0.606054 | [
"object",
"vector"
] |
c5b2508b352696340f9c1e522cdf7758b17d1a9a | 902 | cpp | C++ | lowest_common_ancestor.cpp | rakibulhossain/competetive-programming-library | 1a1d8e18e411c6094001d56a7aca45cc106e0f09 | [
"MIT"
] | 1 | 2021-11-18T13:07:39.000Z | 2021-11-18T13:07:39.000Z | lowest_common_ancestor.cpp | Sajjadhossaintalukder/competetive-programming-library | 1a1d8e18e411c6094001d56a7aca45cc106e0f09 | [
"MIT"
] | null | null | null | lowest_common_ancestor.cpp | Sajjadhossaintalukder/competetive-programming-library | 1a1d8e18e411c6094001d56a7aca45cc106e0f09 | [
"MIT"
] | 2 | 2021-08-07T05:09:52.000Z | 2021-08-23T19:41:07.000Z | #include<bits/stdc++.h>
using namespace std;
const int siz=1e5+7;
// t = 1st parent; l = level , par = ancestors
int n,t[siz],l[siz],par[siz][20];
vector<int>v[siz];
void dfs(int x,int from,int level=0)
{
l[x]=level;
t[x]=from;
for(int i=0;i<v[x].size();i++) if(v[x][i]!=from) dfs(v[x][i],x,level+1);
}
void lca_init()
{
memset(par,-1,sizeof(par));
for(int i=1;i<=n;i++) par[i][0]=t[i];
for(int j=1;(1<<j)<n;j++)
for(int i=1;i<=n;i++)
if(par[i][j-1]!=-1) par[i][j]=par[par[i][j-1]][j-1];
}
int lca(int p,int q)
{
if(l[p]<l[q]) swap(p,q);
int log=31-__builtin_clz(l[p]);
for(int i=log;i>=0;i--)
{
if(l[p]-(1<<i)>=l[q]) p=par[p][i];
}
if(p==q) return p;
for(int i=log;i>=0;i--)
{
if(par[p][i]!=-1&&par[p][i]!=par[q][i])
p=par[p][i],q=par[q][i];
}
return t[p];
}
int main()
{
return 0;
}
| 21.47619 | 76 | 0.48337 | [
"vector"
] |
c5bccdcc9025499a4de19c273cdbd165287a92c2 | 3,044 | cpp | C++ | src/ast/structure-definition-statement.cpp | alta-lang/alta-core | 290ebcd94b4b2956fd34f5cd0e516e756d4fc219 | [
"MIT"
] | null | null | null | src/ast/structure-definition-statement.cpp | alta-lang/alta-core | 290ebcd94b4b2956fd34f5cd0e516e756d4fc219 | [
"MIT"
] | 6 | 2019-03-04T01:37:27.000Z | 2019-09-07T20:12:36.000Z | src/ast/structure-definition-statement.cpp | alta-lang/alta-core | 290ebcd94b4b2956fd34f5cd0e516e756d4fc219 | [
"MIT"
] | null | null | null | #include "../../include/altacore/ast/structure-definition-statement.hpp"
#include "../../include/altacore/util.hpp"
#include <sstream>
#include <crossguid/guid.hpp>
const AltaCore::AST::NodeType AltaCore::AST::StructureDefinitionStatement::nodeType() {
return NodeType::StructureDefinitionStatement;
};
AltaCore::AST::StructureDefinitionStatement::StructureDefinitionStatement(std::string _name):
name(_name)
{};
ALTACORE_AST_DETAIL_D(StructureDefinitionStatement) {
ALTACORE_MAKE_DH(StructureDefinitionStatement);
info->structure = DET::Class::create(name, info->inputScope, {}, true);
info->inputScope->items.push_back(info->structure);
info->structure->isStructure = true;
info->structure->isExternal = info->isExternal = isExternal;
info->structure->isTyped = info->isTyped = isTyped;
info->structure->isLiteral = info->isLiteral = std::find(modifiers.begin(), modifiers.end(), "literal") != modifiers.end();
info->isExport = std::find(modifiers.begin(), modifiers.end(), "export") != modifiers.end();
if (info->isExport) {
if (auto mod = Util::getModule(scope.get()).lock()) {
mod->exports->items.push_back(info->structure);
}
}
auto voidType = std::make_shared<DET::Type>(DET::NativeType::Void);
info->structure->constructors.push_back(DET::Function::create(info->structure->scope, "constructor", {}, voidType));
info->structure->defaultConstructor = info->structure->constructors.front();
for (size_t i = 0; i < members.size(); i++) {
auto& [type, name] = members[i];
auto det = type->fullDetail(info->inputScope);
info->memberTypes.push_back(det);
auto var = std::make_shared<DET::Variable>(name, det->type, info->structure->scope);
var->visibility = Visibility::Public;
info->structure->scope->items.push_back(var);
std::vector<std::tuple<std::string, std::shared_ptr<AltaCore::DET::Type>, bool, std::string>> params;
for (size_t j = 0; j < i; j++) {
auto& [type2, name2] = members[j];
std::stringstream uuidStream;
uuidStream << xg::newGuid();
auto newID = uuidStream.str();
params.push_back(std::make_tuple(name2, info->memberTypes[j]->type, false, newID));
}
std::stringstream uuidStream;
uuidStream << xg::newGuid();
auto newID = uuidStream.str();
params.push_back(std::make_tuple(name, info->memberTypes[i]->type, false, newID));
info->structure->constructors.push_back(DET::Function::create(info->structure->scope, "constructor", params, voidType));
}
for (auto& attr: attributes) {
info->attributes.push_back(attr->fullDetail(info->inputScope, shared_from_this(), info));
}
return info;
};
ALTACORE_AST_VALIDATE_D(StructureDefinitionStatement) {
ALTACORE_VS_S(StructureDefinitionStatement);
for (size_t i = 0; i < members.size(); ++i) {
auto& [type, name] = members[i];
type->validate(stack, info->memberTypes[i]);
}
for (size_t i = 0; i < attributes.size(); ++i) {
attributes[i]->validate(stack, info->attributes[i]);
}
ALTACORE_VS_E;
};
| 36.238095 | 125 | 0.688568 | [
"vector"
] |
c5c618d87575f2aecc22f2303584aaf97f5c5f25 | 1,235 | cpp | C++ | graphs/assignments/codingninja.cpp | ramchandra94/datastructures_in_cpp | 28274ff4f0d9736cfe690ef002b90b9ebbfaf2f7 | [
"MIT"
] | null | null | null | graphs/assignments/codingninja.cpp | ramchandra94/datastructures_in_cpp | 28274ff4f0d9736cfe690ef002b90b9ebbfaf2f7 | [
"MIT"
] | null | null | null | graphs/assignments/codingninja.cpp | ramchandra94/datastructures_in_cpp | 28274ff4f0d9736cfe690ef002b90b9ebbfaf2f7 | [
"MIT"
] | null | null | null | int validPoint(int x, int y, int n, int m){
return (x >=0 && x < n && y >= 0 && y < m);
}
bool dfs(vector<vector<char>> &board,
vector<vector<bool>> &used,
string &word, int x, int y, int wordIndex, int n, int m){
if(wordIndex == 11){
return true;
}
used[x][y] = true;
bool found = false;
int dXdY[8][2] = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1}};
for(int i=0; i < 8; i++){
int newX = x + dXdY[i][0];
int newY = y + dXdY[i][1];
if(validPoint(newX, newY, n, m) && board[newX][newY] == word[wordIndex] && !used[newX][newY]){
found = found | dfs(board, used, word, newX, newY, wordIndex+1, n, m);
}
}
used[x][y] = false;
return found;
}
bool hasPath(vector<vector<char>> &board, int n, int m){
bool foundPath = false;
string word = "CODINGNINJA";
vector<vector<bool>> used(n, vector<bool>(m, false));
for(int i=0; i < n; i++){
for(int j=0; j < m; j++){
if(board[i][j] == word[0]) {
foundPath = dfs(board, used, word, i, j, 1, n, m);
if (foundPath) break;
}
}
if (foundPath) break;
}
return foundPath;
} | 27.444444 | 102 | 0.483401 | [
"vector"
] |
c5cf809078b7dc58108df7924dce2dfb4ff7dbe5 | 6,377 | cpp | C++ | Src/NCEEHelper/main.cpp | dtcxzyw/NCEEHelper | c7db44c087cdd58e179aec9dd6cf726fa2c0ee10 | [
"Unlicense"
] | 1 | 2021-12-28T14:31:23.000Z | 2021-12-28T14:31:23.000Z | Src/NCEEHelper/main.cpp | dtcxzyw/NCEEHelper | c7db44c087cdd58e179aec9dd6cf726fa2c0ee10 | [
"Unlicense"
] | null | null | null | Src/NCEEHelper/main.cpp | dtcxzyw/NCEEHelper | c7db44c087cdd58e179aec9dd6cf726fa2c0ee10 | [
"Unlicense"
] | 1 | 2022-02-17T08:04:37.000Z | 2022-02-17T08:04:37.000Z | #include "../Shared/Command.hpp"
#pragma warning(push, 0)
#define GUID_DEFINED
#include "../ThirdParty/Bus/BusSystem.hpp"
#include <rang.hpp>
#pragma warning(pop)
#include <sstream>
BUS_MODULE_NAME("NCEEHelper.Main");
static int mainImpl(int argc, char** argv, Bus::ModuleSystem& sys) {
BUS_TRACE_BEG() {
if(argc < 2) {
std::stringstream ss;
ss << "Possible Command:" << std::endl;
for(auto id : sys.list<Command>()) {
ss << id.name << std::endl;
}
sys.getReporter().apply(ReportLevel::Info, ss.str(),
BUS_DEFSRCLOC());
BUS_TRACE_THROW(std::invalid_argument("Need Command Name"));
}
std::shared_ptr<Command> command =
sys.instantiateByName<Command>(argv[1]);
if(!command)
BUS_TRACE_THROW(std::invalid_argument("No function called " +
std::string(argv[1])));
std::vector<char*> nargv{ argv[0] };
for(int i = 2; i < argc; ++i)
nargv.emplace_back(argv[i]);
return command->doCommand(static_cast<int>(nargv.size()), nargv.data());
}
BUS_TRACE_END();
}
static Bus::ReportFunction colorOutput(std::ostream& out, rang::fg col,
const std::string& pre,
bool inDetail = false) {
return [=, &out](Bus::ReportLevel, const std::string& message,
const Bus::SourceLocation& srcLoc) {
if(srcLoc.module == std::string("BusSystem.MSVCDelayLoader"))
return;
out << col;
if(inDetail) {
out << pre << ':' << message << std::endl;
out << "module:" << srcLoc.module << std::endl;
out << "function:" << srcLoc.functionName << std::endl;
out << "location:" << srcLoc.srcFile << " line " << srcLoc.line
<< std::endl;
} else {
out << pre << "[" << srcLoc.module << "]:" << message << std::endl;
}
out << std::endl << rang::fg::reset;
};
}
static void processException(const std::exception& ex,
const std::string& lastModule);
static void processException(const Bus::SourceLocation& ex,
const std::string& lastModule);
template <typename T>
static void nestedException(const T& exc, const std::string& lastModule) {
try {
std::rethrow_if_nested(exc);
} catch(const std::exception& ex) {
if(&ex)
processException(ex, lastModule);
else {
std::cerr << "Unrecognizable Exception." << std::endl;
}
} catch(const Bus::SourceLocation& ex) {
if(&ex)
processException(ex, lastModule);
else {
std::cerr << "Unrecognizable SourceLocation." << std::endl;
}
} catch(...) {
std::cerr << "Unknown Error" << std::endl;
}
}
static void processException(const std::exception& ex,
const std::string& lastModule) {
std::cerr << "Reason:" << ex.what() << std::endl;
nestedException(ex, lastModule);
}
static void processException(const Bus::SourceLocation& src,
const std::string& lastModule) {
if(lastModule != src.module)
std::cerr << "in module " << src.module << std::endl;
std::cerr << src.functionName << " at " << src.srcFile << " line "
<< src.line << std::endl;
nestedException(src, src.module);
}
#define PROCEXC() \
catch(const Bus::SourceLocation& ex) { \
std::cerr << rang::fg::red << "Exception:" << std::endl; \
processException(ex, ""); \
std::cerr << rang::fg::reset; \
} \
catch(const std::exception& ex) { \
std::cerr << rang::fg::red << "Exception:" << std::endl; \
processException(ex, ""); \
std::cerr << rang::fg::reset; \
}
static void loadPlugins(Bus::ModuleSystem& sys) {
for(auto p : fs::directory_iterator("Plugins")) {
if(p.status().type() == fs::file_type::directory) {
auto dir = p.path();
auto dll = dir / dir.filename().replace_extension(".dll");
if(fs::exists(dll)) {
try {
sys.getReporter().apply(ReportLevel::Info,
"Loading module " +
dir.filename().string(),
BUS_DEFSRCLOC());
sys.loadModuleFile(dll);
}
PROCEXC();
}
}
}
std::stringstream ss;
ss << "Loaded Module:" << std::endl;
for(auto mod : sys.listModules()) {
ss << Bus::GUID2Str(mod.guid) << " " << mod.name << " " << mod.version
<< std::endl;
}
sys.getReporter().apply(ReportLevel::Info, ss.str(), BUS_DEFSRCLOC());
}
std::shared_ptr<Bus::ModuleInstance> getBuiltin(Bus::ModuleSystem& sys);
int main(int argc, char** argv) {
auto reporter = std::make_shared<Bus::Reporter>();
reporter->addAction(
ReportLevel::Debug,
colorOutput(std::cerr, rang::fg::yellow, "Debug", true));
reporter->addAction(ReportLevel::Error,
colorOutput(std::cerr, rang::fg::red, "Error", true));
reporter->addAction(ReportLevel::Info,
colorOutput(std::cerr, rang::fg::reset, "Info"));
reporter->addAction(ReportLevel::Warning,
colorOutput(std::cerr, rang::fg::yellow, "Warning"));
try {
Bus::ModuleSystem sys(reporter, [] {
try {
std::rethrow_exception(std::current_exception());
}
PROCEXC();
});
try {
Bus::addModuleSearchPath(fs::current_path() / "Shared", *reporter);
sys.wrapBuiltin(getBuiltin);
loadPlugins(sys);
return mainImpl(argc, argv, sys);
}
PROCEXC();
}
PROCEXC();
return EXIT_FAILURE;
}
| 38.185629 | 80 | 0.495217 | [
"vector"
] |
c5d0e5392d3c208006df50e9e6707a17b745febd | 1,142 | cpp | C++ | radix/main.cpp | benacq/Data-Structures-and-Algorithms-prep | d4e2da9b34776901f8796bfb54fa1a2161c99485 | [
"MIT"
] | 6 | 2021-04-13T14:07:02.000Z | 2021-12-08T02:23:31.000Z | radix/main.cpp | benacq/Data-Structures-and-Algorithms-prep | d4e2da9b34776901f8796bfb54fa1a2161c99485 | [
"MIT"
] | null | null | null | radix/main.cpp | benacq/Data-Structures-and-Algorithms-prep | d4e2da9b34776901f8796bfb54fa1a2161c99485 | [
"MIT"
] | null | null | null | #include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
void countingSort(vector<int> &numbers, int number_place) {
vector<queue<int>> buckets(10);
vector<int> sorted;
sorted.reserve(numbers.size());
for (int number: numbers) {
buckets[(number / number_place) % 10].push(number);
}
for (auto bucket: buckets) {
while (!bucket.empty()) {
sorted.push_back(bucket.front());
bucket.pop();
}
}
for (int i = 0; i < sorted.size(); ++i) {
numbers[i] = sorted[i];
}
}
void radixSort(vector<int> &numbers) {
int max_num = *max_element(numbers.begin(), numbers.end());
for (int number_place = 1; max_num / number_place > 0; number_place *= 10) {
countingSort(numbers, number_place);
}
}
int main() {
// vector<int> numbers = {52, 43, 13, 71, 9, 1, 9, 4, 4973, 785, 326, 1};
vector<int> numbers = {47, 8521, 86, 774, 8975, 741, 21, 100, 500, 7789, 7410, 24, 23, 8, 121};
radixSort(numbers);
for (int number: numbers) {
cout << number << " ";
}
return 0;
}
| 21.961538 | 99 | 0.574431 | [
"vector"
] |
c5d822297cbf441c62f68087a4a37e88602cca35 | 1,076 | cc | C++ | util/Test/tVariate.cc | erikleitch/climax | 66ce64b0ab9f3a3722d3177cc5215ccf59369e88 | [
"MIT"
] | 1 | 2018-11-01T05:15:31.000Z | 2018-11-01T05:15:31.000Z | util/Test/tVariate.cc | erikleitch/climax | 66ce64b0ab9f3a3722d3177cc5215ccf59369e88 | [
"MIT"
] | null | null | null | util/Test/tVariate.cc | erikleitch/climax | 66ce64b0ab9f3a3722d3177cc5215ccf59369e88 | [
"MIT"
] | 2 | 2017-05-02T19:35:55.000Z | 2018-03-07T00:54:51.000Z | #include <iostream>
#include <iomanip>
#include <cmath>
#include "gcp/program/Program.h"
#include "gcp/util/UniformVariate.h"
#include "gcp/util/Exception.h"
#include "gcp/util/Sampler.h"
#include "gcp/pgutil/PgUtil.h"
#include <vector>
using namespace std;
using namespace gcp::util;
using namespace gcp::program;
KeyTabEntry Program::keywords[] = {
{ "val", "0.0", "d", "Val"},
{ "mean", "0.0", "d", "Mean"},
{ "sigma", "0.0", "d", "Sigma"},
{ END_OF_KEYWORDS}
};
void Program::initializeUsage() {};
int Program::main()
{
UniformVariate var(0.0, 1.0);
var.value() = 0.5;
var.prior().setType(Distribution::DIST_UNIFORM);
var.prior().setUniformXMin(0.2);
var.prior().setUniformXMax(0.7);
var.value() = 0.6;
try {
COUT("JOINT PDF = " << var.jointPdf());
} catch(...) {
COUT("JOINT PDF is zero");
}
var.value() = 0.8;
COUT("PDF = " << var.pdf());
COUT("Prio PDF = " << var.priorPdf());
try {
COUT("LN JOINT PDF = " << var.jointPdf());
} catch(...) {
COUT("JOINT PDF is zero");
}
return 0;
}
| 17.639344 | 51 | 0.58829 | [
"vector"
] |
c5e1b5ee84695d10660ab3ed31bce0351458889f | 6,789 | hpp | C++ | src/Forces/RotationalDivisionForce.hpp | clairemiller/2018_MaintainingStemCellNiche | 2999a37169ac0db78ebf9ac57b36153a0a149eb3 | [
"BSD-4-Clause-UC"
] | null | null | null | src/Forces/RotationalDivisionForce.hpp | clairemiller/2018_MaintainingStemCellNiche | 2999a37169ac0db78ebf9ac57b36153a0a149eb3 | [
"BSD-4-Clause-UC"
] | null | null | null | src/Forces/RotationalDivisionForce.hpp | clairemiller/2018_MaintainingStemCellNiche | 2999a37169ac0db78ebf9ac57b36153a0a149eb3 | [
"BSD-4-Clause-UC"
] | null | null | null | /*
Copyright (c) 2005-2016, University of Oxford.
All rights reserved.
University of Oxford means the Chancellor, Masters and Scholars of the
University of Oxford, having an administrative office at Wellington
Square, Oxford OX1 2JD, UK.
This file is part of Chaste.
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 University of Oxford 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.
*/
#ifndef ROTATIONALDIVISIONFORCE_HPP_
#define ROTATIONALDIVISIONFORCE_HPP_
#include "AbstractForce.hpp"
#include "NodeBasedCellPopulation.hpp"
#include "StemCellProliferativeType.hpp"
#include "DifferentiatedCellProliferativeType.hpp"
#include "SimulationTime.hpp"
/**
* A class to apply a rotational force to two cells involved in the mitotic division phase from a single cell
*/
template<unsigned DIM>
class RotationalDivisionForce : public AbstractForce<DIM, DIM>
{
private:
/** Needed for serialization. */
friend class boost::serialization::access;
/**
* Archive the object and its member variables.
*
* @param archive the archive
* @param version the current version of this class
*/
template<class Archive>
void serialize(Archive & archive, const unsigned int version)
{
archive & boost::serialization::base_object<AbstractForce<DIM,DIM> >(*this);
archive & mTorsionCoefficient;
archive & mNormalVector;
archive & mGrowthDuration;
archive & mPropSpringLength;
}
double DotProduct(c_vector<double,DIM> u, c_vector<double,DIM> v) const;
protected:
// The scaling parameter - in radian^{-1}
double mTorsionCoefficient;
// The desired direction
c_vector<double,DIM> mNormalVector;
// The force duration
double mGrowthDuration;
// The vertical direction
unsigned mVertical;
// Whether the rotational spring force is proportional to spring length
bool mPropSpringLength;
public:
/**
* Constructor.
*/
RotationalDivisionForce(double torsionCoefficient, double growthDuration=1.0);
/**
* Overridden AddForceContribution() method.
*
* @param rCellPopulation reference to the cell population
*/
void AddForceContribution(AbstractCellPopulation<DIM>& rCellPopulation);
/**
* Set method for normal vector
* @param the new value of normal vector
*/
void SetNormalVector(c_vector<double, DIM> normalVec);
/**
* Set method for proportional to spring length
* @param the new value of the boolean
*/
void SetProportionalToSpringLength(bool propSpringLength);
/**
* Get method for torsion coefficient
*
* @return the value of mTorsionCoefficient
*/
virtual double GetTorsionCoefficient(double age = -1.0) const;
/**
* Get method for division vector
*
* @return the value of mTorsionCoefficient
*/
virtual c_vector<double,DIM> GetNormalVector(c_vector<double,DIM> p) const;
/**
* Get the distance from a point to the plane
*
* @param the point of interest
* @return the distance to the plane
*/
virtual double GetDistanceToBasePlane(c_vector<double,DIM> p) const;
/**
* Get method for spring growth duration
*
* @return the value of mGrowthDuration
*/
double GetGrowthDuration() const;
/**
* Overridden OutputForceParameters() method.
*
* @param rParamsFile the file stream to which the parameters are output
*/
virtual void OutputForceParameters(out_stream& rParamsFile);
/**
* Overridden WriteDataToVisualizerSetupFile() method.
* Write any data necessary to a visualization setup file.
* Used by AbstractCellBasedSimulation::WriteVisualizerSetupFile().
*
* @param pVizSetupFile a visualization setup file
*/
virtual void WriteDataToVisualizerSetupFile(out_stream& pVizSetupFile);
};
// Serialization for Boost >= 1.36
#include "SerializationExportWrapper.hpp"
EXPORT_TEMPLATE_CLASS_SAME_DIMS(RotationalDivisionForce)
namespace boost
{
namespace serialization
{
template<class Archive, unsigned DIM>
inline void save_construct_data(Archive & ar, const RotationalDivisionForce<DIM> * t, const unsigned int file_version)
{
double torsion_coefficient, growth_duration;
c_vector<double,DIM> division_vector;
torsion_coefficient = t->GetTorsionCoefficient();
ar << torsion_coefficient;
division_vector = t->GetNormalVector(zero_vector<double>(DIM));
for (unsigned i =0; i < DIM; i++)
{
ar << division_vector[i];
}
growth_duration = t->GetGrowthDuration();
ar << growth_duration;
}
template<class Archive, unsigned DIM>
inline void load_construct_data(Archive & ar, RotationalDivisionForce<DIM> * t, const unsigned int file_version)
{
double torsion_coefficient, division_angle, growth_duration;
c_vector<double,DIM> division_vector;
ar >> torsion_coefficient;
for (unsigned i =0; i < DIM; i++)
{
ar >> division_vector[i];
}
ar >> growth_duration;
::new(t)RotationalDivisionForce<DIM>(torsion_coefficient,growth_duration);
t->SetNormalVector(division_vector);
}
} // End namespace serialization
} // End namespace boost
#endif /*ROTATIONALDIVISIONFORCE_HPP_*/
| 33.117073 | 120 | 0.707615 | [
"object",
"vector"
] |
c5e7e2f584b776f96a3b1a53ecc8777e8ca0f973 | 1,511 | cpp | C++ | trainingregional2018/contest1/P5.cpp | Victoralin10/ACMSolutions | 6d6e50da87b2bc455e953629737215b74b10269c | [
"MIT"
] | null | null | null | trainingregional2018/contest1/P5.cpp | Victoralin10/ACMSolutions | 6d6e50da87b2bc455e953629737215b74b10269c | [
"MIT"
] | null | null | null | trainingregional2018/contest1/P5.cpp | Victoralin10/ACMSolutions | 6d6e50da87b2bc455e953629737215b74b10269c | [
"MIT"
] | null | null | null | #include <bits/stdc++.h>
#define REP(i, n) for(int i = 0; i < n; i++)
#define REPR(i, a, b) for (int i = a; i < b; i++)
#define clr(t, val) memset(t, val, sizeof(t))
#define all(v) v.begin(), v.end()
#define SZ(v) ((int)(v).size())
#define TEST(x) cerr << "test " << #x << " " << x << endl;
using namespace std;
clock_t _inicio = clock();
typedef long long Long;
typedef vector <int> vInt;
typedef pair <int, int> Pair;
void solve(vector <vInt> &caso) {
sort(all(caso));
set <int> starts;
for (vInt &t: caso) {
starts.insert(t[0]);
}
Pair ans = {-1, -1};
for (int a: starts) {
int cnt = 0;
for (vInt &t: caso) {
if (a < t[0] || a > t[1]) continue;
if ((a - t[0])%t[2] == 0) cnt++;
}
if ((cnt&1)) {
ans = {a, cnt};
break;
}
}
if (ans.first > 0) cout << ans.first << " " << ans.second << endl;
else puts("no corruption");
}
int main(int nargs, char **args) {
string line;
vector <vInt> caso;
while (getline(cin, line)) {
if (line == "") {
if (SZ(caso) > 0) {
solve(caso);
caso.clear();
}
} else {
stringstream io(line);
int a, b, k;
io >> a >> b >> k;
caso.push_back({a, b, k});
}
}
if (SZ(caso) > 0) {
solve(caso);
}
// cerr << "Time elapsed: " << (clock() - _inicio)/1000 << " ms" << endl;
return 0;
}
| 23.246154 | 77 | 0.446062 | [
"vector"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.