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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
6f0cb1c9533c70a2a1ec476f9f05fcf6b03233e8 | 12,690 | cpp | C++ | src/gfx-obj/ImporterObj.cpp | alecnunn/mud | 9e204e2dc65f4a8ab52da3d11e6a261ff279d353 | [
"Zlib"
] | 1 | 2019-03-28T20:45:32.000Z | 2019-03-28T20:45:32.000Z | src/gfx-obj/ImporterObj.cpp | alecnunn/mud | 9e204e2dc65f4a8ab52da3d11e6a261ff279d353 | [
"Zlib"
] | null | null | null | src/gfx-obj/ImporterObj.cpp | alecnunn/mud | 9e204e2dc65f4a8ab52da3d11e6a261ff279d353 | [
"Zlib"
] | null | null | null | // Copyright (c) 2019 Hugo Amiard hugo.amiard@laposte.net
// This software is provided 'as-is' under the zlib License, see the LICENSE.txt file.
// This notice and the license may not be removed or altered from any source distribution.
#include <infra/Cpp20.h>
#ifndef MUD_CPP_20
#include <array>
#include <fstream>
#include <sstream>
#include <string>
#endif
#include <bgfx/bgfx.h>
#ifdef MUD_MODULES
module mud.gfx.obj;
#else
#include <infra/Vector.h>
#include <infra/File.h>
#include <infra/StringConvert.h>
#include <pool/Pool.h>
#include <math/Timer.h>
#include <math/Stream.h>
#include <math/VecOps.h>
#include <geom/Mesh.h>
#include <srlz/Serial.h>
#include <gfx/Material.h>
#include <gfx/Mesh.h>
#include <gfx/Model.h>
#include <gfx/Prefab.h>
#include <gfx/Draw.h>
#include <gfx/Node3.h>
#include <gfx/Texture.h>
#include <gfx/Asset.h>
#include <gfx/GfxSystem.h>
#include <gfx-obj/Types.h>
#include <gfx-obj/ImporterObj.h>
#endif
namespace mud
{
static ImportConfig load_model_config(cstring path, cstring model_name)
{
ImportConfig config = {};
string config_path = file_directory(path) + "/" + model_name + ".cfg";
if(file_exists(config_path.c_str()))
unpack_json_file(Ref(&config), config_path);
config.m_transform = bxSRT(config.m_scale, config.m_rotation, config.m_position);
return config;
}
ImporterOBJ::ImporterOBJ(GfxSystem& gfx_system)
: m_gfx_system(gfx_system)
{
static auto load_obj_model = [&](GfxSystem& gfx_system, Model& model, cstring path)
{
UNUSED(gfx_system);
ImportConfig config = load_model_config(path, model.m_name.c_str());
this->import_model(model, path, config);
};
static auto load_obj_prefab = [&](GfxSystem& gfx_system, Prefab& prefab, cstring path)
{
UNUSED(gfx_system);
ImportConfig config = load_model_config(path, prefab.m_name.c_str());
this->import_prefab(prefab, path, config);
};
gfx_system.add_importer(ModelFormat::obj, *this);
gfx_system.models().add_format(".obj", load_obj_model);
gfx_system.prefabs().add_format(".obj", load_obj_prefab);
}
void import_material_library(GfxSystem& gfx_system, const string& path, MaterialMap& material_map)
{
string models_path = "models/" + path;
string materials_path = "materials/" + path;
LocatedFile location = gfx_system.locate_file(models_path.c_str());
if(location.m_location == nullptr)
location = gfx_system.locate_file(materials_path.c_str());
std::ifstream file = std::ifstream(string(location.m_location) + location.m_name);
if(!file.good())
return;
Material* current = nullptr;
string line;
while(std::getline(file, line))
{
std::istringstream stream(line);
string command = read<string>(stream);
// "Ka" ambient rgb
// "Kd" diffuse rgb
// "Ks" specular rgb
// "Kt" "Tf" transmittance rgb
// "Ni" ior(index of refraction) float
// "Ke" emission rgb
// "Ns" shininess float
// "illum" illum model
// "d" dissolve
// "Tr" transparency
// "Pr" PBR: roughness
// "Pm" PBR: metallic
// "Ps" PBR: sheen
// "Pc" PBR: clearcoat thickness
// "Pcr" PBR: clearcoat roughness
// "aniso" PBR: anisotropy
// "anisor" PBR: anisotropy rotation
auto fetch_texture = [&](const string& path) -> Texture*
{
// @todo replace backslashes with slashes ?
if(gfx_system.locate_file(("textures/" + path).c_str()).m_location)
return gfx_system.textures().file(path.c_str());
else
return nullptr;
};
if(command == "newmtl")
{
string name = read<string>(stream);
current = &gfx_system.fetch_material(name.c_str(), "pbr/pbr");
current->m_pbr_block.m_enabled = true;
material_map[name] = current;
}
else if(command == "Ka")
{
// nothing
}
else if(command == "Kd")
{
Colour albedo = read<Colour>(stream);
current->m_pbr_block.m_albedo.m_value = albedo;
}
else if(command == "Ks")
{
Colour specular = read<Colour>(stream);
current->m_pbr_block.m_metallic.m_value = max(specular.m_r, max(specular.m_g, specular.m_b));
}
else if(command == "Ke")
{
Colour emissive = read<Colour>(stream);
current->m_pbr_block.m_emissive.m_value = emissive;
current->m_pbr_block.m_emissive.m_value.m_a = length(to_vec3(emissive));
}
else if(command == "Ns")
{
float specular = read<float>(stream);
current->m_pbr_block.m_metallic.m_value = (1000.f - specular) / 1000.f;
}
else if(command == "d")
{
float d = read<float>(stream);
current->m_pbr_block.m_albedo.m_value.m_a = d;
}
else if(command == "Tr")
{
float tr = read<float>(stream);
current->m_pbr_block.m_albedo.m_value.m_a = 1.f - tr;
}
else if(command == "Pr")
{
float roughness = read<float>(stream);
current->m_pbr_block.m_roughness.m_value = roughness;
}
else if(command == "Pm")
{
float metallic = read<float>(stream);
current->m_pbr_block.m_metallic.m_value = metallic;
}
else if(command == "map_Ka ") // ambient texture
{
// nothing
}
else if(command == "map_Kd") // diffuse texture
{
string map = read<string>(stream);
current->m_pbr_block.m_albedo.m_texture = fetch_texture(map);
}
else if(command == "map_Ks") // specular texture
{
string map = read<string>(stream);
//current->m_pbr_block.m_metallic.m_value = 1.f;
current->m_pbr_block.m_metallic.m_texture = fetch_texture(map);
}
else if(command == "map_Ke") // emissive texture
{
string map = read<string>(stream);
current->m_pbr_block.m_emissive.m_texture = fetch_texture(map);
current->m_pbr_block.m_emissive.m_value.m_a = 2.f;
}
else if(command == "map_Ns") // specular highlight texture
{
string map = read<string>(stream);
current->m_pbr_block.m_roughness.m_texture = fetch_texture(map);
}
else if(command == "map_bump" || command == "bump") // bump texture
{
string map = read<string>(stream);
current->m_pbr_block.m_normal.m_texture = fetch_texture(map);
}
else if(command == "map_Pr") // PBR: roughness texture
{
string map = read<string>(stream);
current->m_pbr_block.m_roughness.m_texture = fetch_texture(map);
}
else if(command == "map_Pm") // PBR: metallic texture
{
string map = read<string>(stream);
//current->m_pbr_block.m_metallic.m_value = 1.f;
current->m_pbr_block.m_metallic.m_texture = fetch_texture(map);
}
// "map_d" alpha texture
// "disp" displacement texture
// "refl" reflection map
// "map_Pr" PBR: roughness texture
// "map_Pm" PBR: metallic texture
// "map_Ps" PBR: sheen texture
// "norm" PBR: normal map texture
}
}
void ImporterOBJ::import(Import& scene, const string& path, const ImportConfig& config)
{
printf("INFO: gltf - loading scene %s\n", scene.m_file.c_str());
Clock clock;
clock.step();
bool generate_tangents = true;
std::vector<vec3> vertices;
std::vector<vec3> normals;
std::vector<vec2> uvs;
std::map<string, Material*> materials;
enum VertAttrib
{
POSITION,
TEXCOORD,
NORMAL
};
struct MeshWriter
{
MeshWriter(const ImportConfig& config, Import& import, bool generate_tangents)
: m_config(config)
, m_import(import)
, m_name(import.m_name)
, m_generate_tangents(generate_tangents)
{}
~MeshWriter()
{
if(m_shape.vertex_count() == 0 || m_skip)
return;
Mesh& mesh = m_import.m_gfx_system.meshes().construct(m_name.c_str(), true);
m_shape.bake(!m_normals, m_generate_tangents && m_uvs);
mesh.write(PLAIN, m_shape, m_config.m_optimize_geometry);
mesh.m_material = m_material;
m_import.m_meshes.push_back(&mesh);
Model& model = m_import.m_gfx_system.models().create(m_name.c_str());
model.add_item(mesh, bxidentity());
model.prepare();
m_import.m_models.push_back(&model);
m_import.m_items.push_back({ bxidentity(), &model, -1 });
//printf("INFO: ImporterOBJ imported mesh %s material %s with %u vertices and %u faces\n",
// m_mesh.m_name.c_str(), m_mesh.m_material->m_name.c_str(), m_shape.m_positions.size(), m_shape.m_indices.size() / 3);
}
inline void face(ShapeVertex* face, size_t a, size_t b, size_t c)
{
auto vertex = [&](ShapeVertex& vertex)
{
m_shape.m_positions.push_back(vertex.m_position);
m_shape.m_normals.push_back(vertex.m_normal);
m_shape.m_uv0s.push_back(vertex.m_uv0);
};
// bool flip_faces;
// int i = !flip_faces && i < 2 ? 1 ^ i : i;
vertex(face[a]);
vertex(face[b]);
vertex(face[c]);
}
const ImportConfig& m_config;
Import& m_import;
string m_name;
Material* m_material = nullptr;
MeshPacker m_shape;
bool m_generate_tangents;
bool m_normals = true;
bool m_uvs = true;
int m_smoothing_group = 0;
bool m_skip = false;
};
string filename = path + ".obj";
std::ifstream filestream(filename);
if(!filestream.good())
{
printf("ERROR: could not locate model %s\n", filename.c_str());
return;
}
unique_ptr<MeshWriter> mesh_writer = make_unique<MeshWriter>(config, scene, generate_tangents);
string line;
while(std::getline(filestream, line))
{
if(line.back() == '\r')
line.pop_back();
string tokens[5];
split(line, " ", { tokens, 5 });
const string& command = tokens[0];
if(command == "o" || command == "g")
{
mesh_writer = nullptr;
mesh_writer = make_unique<MeshWriter>(config, scene, generate_tangents);
}
if(command == "o")
{
const string& name = tokens[1];
scene.m_name = name.c_str();
}
else if(command == "g")
{
const string& name = tokens[1];
mesh_writer->m_name = name.c_str();
if(config.filter_element(name))
mesh_writer->m_skip = true;
}
else if(command == "usemtl")
{
const string& material = tokens[1];
mesh_writer->m_material = materials[material];
if(config.filter_material(material))
mesh_writer->m_skip = true;
}
else if(command == "s") //smoothing
{
const string& value = tokens[1];
mesh_writer->m_smoothing_group = value == "off" ? 0
: std::stoi(value);
}
else if(command == "v")
{
vec3 vert = { std::stof(tokens[1]), std::stof(tokens[2]), std::stof(tokens[3]) };
vert = config.m_transform * vec4(vert, 1.f);
vertices.emplace_back(vert);
}
else if(command == "vt")
{
vec2 uv = { std::stof(tokens[1]), std::stof(tokens[2]) };
uvs.push_back({ uv.x, 1.f - uv.y });
}
else if(command == "vn")
{
vec3 norm = { std::stof(tokens[1]), std::stof(tokens[2]), std::stof(tokens[3]) };
norm = config.m_transform * vec4(norm, 0.f);
normals.emplace_back(norm);
}
else if(command == "f")
{
std::array<ShapeVertex, 4> verts;
size_t num_vertices = tokens[4] == "" ? 3 : 4;
for(size_t i = 0; i < num_vertices; ++i)
{
string ids[3];
split(tokens[i + 1], "/", { ids, 3 });
int face[3] = { std::stoi(ids[0]), std::stoi(ids[1]), std::stoi(ids[2]) };
verts[i].m_position = face[POSITION] >= 0 ? vertices[face[POSITION] - 1] : vertices[face[POSITION] + vertices.size()];
if(face[TEXCOORD] != 0)
verts[i].m_uv0 = face[TEXCOORD] >= 0 ? uvs[face[TEXCOORD] - 1] : uvs[face[TEXCOORD] + uvs.size()];
if(face[NORMAL] != 0)
verts[i].m_normal = face[NORMAL] >= 0 ? normals[face[NORMAL] - 1] : normals[face[NORMAL] + normals.size()];
}
mesh_writer->face(verts.data(), 0, 1, 2);
if(!tokens[4].empty())
mesh_writer->face(verts.data(), 0, 2, 3);
}
else if(command == "mtllib")
{
const string& lib_path = tokens[1];
import_material_library(m_gfx_system, lib_path, materials);
}
}
printf("INFO: obj - imported %i vertices in %.2f seconds\n", int(vertices.size()), clock.step());
mesh_writer = nullptr;
}
void ImporterOBJ::import_model(Model& model, const string& filepath, const ImportConfig& config)
{
Import state = { m_gfx_system, filepath, config };
this->import(state, filepath, config);
for(const Import::Item& item : state.m_items)
{
for(const ModelItem& model_item : item.model->m_items)
model.add_item(*model_item.m_mesh, item.transform, item.skin);
}
model.prepare();
}
void ImporterOBJ::import_prefab(Prefab& prefab, const string& filepath, const ImportConfig& config)
{
Import state = { m_gfx_system, filepath, config };
this->import(state, filepath, config);
import_to_prefab(m_gfx_system, prefab, state, config.m_flags);
}
void ImporterOBJ::repack(const string& filepath, const ImportConfig& config)
{
UNUSED(filepath); UNUSED(config);
printf("WARNING: obj - repack for this format not supported\n");
}
}
| 28.452915 | 126 | 0.653349 | [
"mesh",
"vector",
"model",
"transform"
] |
6f0f3a324fc26f05d5c94f81fd207bb402b82b18 | 30,841 | cpp | C++ | src/game/client/c_te.cpp | cstom4994/SourceEngineRebuild | edfd7f8ce8af13e9d23586318350319a2e193c08 | [
"MIT"
] | 6 | 2022-01-23T09:40:33.000Z | 2022-03-20T20:53:25.000Z | src/game/client/c_te.cpp | cstom4994/SourceEngineRebuild | edfd7f8ce8af13e9d23586318350319a2e193c08 | [
"MIT"
] | null | null | null | src/game/client/c_te.cpp | cstom4994/SourceEngineRebuild | edfd7f8ce8af13e9d23586318350319a2e193c08 | [
"MIT"
] | 1 | 2022-02-06T21:05:23.000Z | 2022-02-06T21:05:23.000Z | //========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//===========================================================================//
#include "cbase.h"
#include "itempents.h"
#include "effect_dispatch_data.h"
#include "tier1/KeyValues.h"
#include "iefx.h"
#include "IEffects.h"
#include "toolframework_client.h"
#include "cdll_client_int.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
// External definitions
void TE_ArmorRicochet(IRecipientFilter &filter, float delay,
const Vector *pos, const Vector *dir);
void TE_BeamEntPoint(IRecipientFilter &filter, float delay,
int nStartEntity, const Vector *start, int nEndEntity, const Vector *end,
int modelindex, int haloindex, int startframe, int framerate,
float life, float width, float endWidth, int fadeLength, float amplitude,
int r, int g, int b, int a, int speed);
void TE_BeamEnts(IRecipientFilter &filter, float delay,
int start, int end, int modelindex, int haloindex, int startframe, int framerate,
float life, float width, float endWidth, int fadeLength, float amplitude,
int r, int g, int b, int a, int speed);
void TE_BeamFollow(IRecipientFilter &filter, float delay,
int iEntIndex, int modelIndex, int haloIndex, float life, float width, float endWidth,
float fadeLength, float r, float g, float b, float a);
void TE_BeamPoints(IRecipientFilter &filter, float delay,
const Vector *start, const Vector *end, int modelindex, int haloindex, int startframe, int framerate,
float life, float width, float endWidth, int fadeLength, float amplitude,
int r, int g, int b, int a, int speed);
void TE_BeamLaser(IRecipientFilter &filter, float delay,
int start, int end, int modelindex, int haloindex, int startframe, int framerate,
float life, float width, float endWidth, int fadeLength, float amplitude, int r, int g, int b, int a,
int speed);
void TE_BeamRing(IRecipientFilter &filter, float delay,
int start, int end, int modelindex, int haloindex, int startframe, int framerate,
float life, float width, int spread, float amplitude, int r, int g, int b, int a, int speed,
int flags = 0);
void TE_BeamRingPoint(IRecipientFilter &filter, float delay,
const Vector ¢er, float start_radius, float end_radius, int modelindex, int haloindex,
int startframe, int framerate,
float life, float width, int spread, float amplitude, int r, int g, int b, int a, int speed,
int flags = 0);
void TE_BeamSpline(IRecipientFilter &filter, float delay,
int points, Vector *rgPoints);
void TE_BloodStream(IRecipientFilter &filter, float delay,
const Vector *org, const Vector *dir, int r, int g, int b, int a, int amount);
void TE_BloodStream(IRecipientFilter &filter, float delay, KeyValues *pKeyValues);
void TE_BloodSprite(IRecipientFilter &filter, float delay,
const Vector *org, const Vector *dir, int r, int g, int b, int a, int size);
void TE_BloodSprite(IRecipientFilter &filter, float delay, KeyValues *pKeyValues);
void TE_BreakModel(IRecipientFilter &filter, float delay,
const Vector &pos, const QAngle &angles, const Vector &size, const Vector &vel,
int modelindex, int randomization, int count, float time, int flags);
void TE_BreakModel(IRecipientFilter &filter, float delay, KeyValues *pKeyValues);
void TE_BSPDecal(IRecipientFilter &filter, float delay,
const Vector *pos, int entity, int index);
void TE_ProjectDecal(IRecipientFilter &filter, float delay,
const Vector *pos, const QAngle *angles, float distance, int index);
void TE_ProjectDecal(IRecipientFilter &filter, float delay, KeyValues *pKeyValues);
void TE_Bubbles(IRecipientFilter &filter, float delay,
const Vector *mins, const Vector *maxs, float height, int modelindex, int count, float speed);
void TE_BubbleTrail(IRecipientFilter &filter, float delay,
const Vector *mins, const Vector *maxs, float height, int modelindex, int count, float speed);
void TE_Decal(IRecipientFilter &filter, float delay,
const Vector *pos, const Vector *start, int entity, int hitbox, int index);
void TE_Decal(IRecipientFilter &filter, float delay, KeyValues *pKeyValues);
void TE_DynamicLight(IRecipientFilter &filter, float delay,
const Vector *org, int r, int g, int b, int exponent, float radius, float time, float decay,
int nLightIndex = LIGHT_INDEX_TE_DYNAMIC);
void TE_DynamicLight(IRecipientFilter &filter, float delay, KeyValues *pKeyValues);
void TE_Explosion(IRecipientFilter &filter, float delay,
const Vector *pos, int modelindex, float scale, int framerate, int flags, int radius, int magnitude,
const Vector *normal = NULL, unsigned char materialType = 'C', bool bShouldAffectRagdolls = true);
void TE_Explosion(IRecipientFilter &filter, float delay, KeyValues *pKeyValues);
void TE_ShatterSurface(IRecipientFilter &filter, float delay,
const Vector *pos, const QAngle *angle, const Vector *vForce, const Vector *vForcePos,
float width, float height, float shardsize, ShatterSurface_t surfacetype,
int front_r, int front_g, int front_b, int back_r, int back_g, int back_b);
void TE_ShatterSurface(IRecipientFilter &filter, float delay, KeyValues *pKeyValues);
void TE_GlowSprite(IRecipientFilter &filter, float delay,
const Vector *pos, int modelindex, float life, float size, int brightness);
void TE_GlowSprite(IRecipientFilter &filter, float delay, KeyValues *pKeyValues);
void TE_FootprintDecal(IRecipientFilter &filter, float delay, const Vector *origin, const Vector *right,
int entity, int index, unsigned char materialType);
void TE_Fizz(IRecipientFilter &filter, float delay,
const C_BaseEntity *ed, int modelindex, int density, int current);
void TE_KillPlayerAttachments(IRecipientFilter &filter, float delay,
int player);
void TE_LargeFunnel(IRecipientFilter &filter, float delay,
const Vector *pos, int modelindex, int reversed);
void TE_MetalSparks(IRecipientFilter &filter, float delay,
const Vector *pos, const Vector *dir);
void TE_EnergySplash(IRecipientFilter &filter, float delay,
const Vector *pos, const Vector *dir, bool bExplosive);
void TE_PlayerDecal(IRecipientFilter &filter, float delay,
const Vector *pos, int player, int entity);
void TE_ShowLine(IRecipientFilter &filter, float delay,
const Vector *start, const Vector *end);
void TE_Smoke(IRecipientFilter &filter, float delay,
const Vector *pos, int modelindex, float scale, int framerate);
void TE_Sparks(IRecipientFilter &filter, float delay,
const Vector *pos, int nMagnitude, int nTrailLength, const Vector *pDir);
void TE_Sprite(IRecipientFilter &filter, float delay,
const Vector *pos, int modelindex, float size, int brightness);
void TE_Sprite(IRecipientFilter &filter, float delay, KeyValues *pKeyValues);
void TE_SpriteSpray(IRecipientFilter &filter, float delay,
const Vector *pos, const Vector *dir, int modelindex, int speed, float noise, int count);
void TE_SpriteSpray(IRecipientFilter &filter, float delay, KeyValues *pKeyValues);
void TE_WorldDecal(IRecipientFilter &filter, float delay,
const Vector *pos, int index);
void TE_WorldDecal(IRecipientFilter &filter, float delay, KeyValues *pKeyValues);
void TE_MuzzleFlash(IRecipientFilter &filter, float delay,
const Vector &start, const QAngle &angles, float scale, int type);
void TE_Dust(IRecipientFilter &filter, float delay,
const Vector &pos, const Vector &dir, float size, float speed);
void TE_GaussExplosion(IRecipientFilter &filter, float delayt,
const Vector &pos, const Vector &dir, int type);
void TE_DispatchEffect(IRecipientFilter &filter, float delay,
const Vector &pos, const char *pName, const CEffectData &data);
void TE_DispatchEffect(IRecipientFilter &filter, float delay, KeyValues *pKeyValues);
void TE_PhysicsProp(IRecipientFilter &filter, float delay,
int modelindex, int skin, const Vector &pos, const QAngle &angles, const Vector &vel,
bool breakmodel, int effects);
void TE_PhysicsProp(IRecipientFilter &filter, float delay, KeyValues *pKeyValues);
void TE_ConcussiveExplosion(IRecipientFilter &filter, float delay, KeyValues *pKeyValues);
void TE_ClientProjectile(IRecipientFilter &filter, float delay,
const Vector *vecOrigin, const Vector *vecVelocity, int modelindex, int lifetime,
CBaseEntity *pOwner);
class C_TempEntsSystem : public ITempEntsSystem {
private:
//-----------------------------------------------------------------------------
// Purpose: Returning true means don't even call TE func
// Input : filter -
// *suppress_host -
// Output : static bool
//-----------------------------------------------------------------------------
bool SuppressTE(IRecipientFilter &filter) {
if (!CanPredict())
return true;
C_RecipientFilter &_filter = ((C_RecipientFilter &) filter);
if (!_filter.GetRecipientCount()) {
// Suppress it
return true;
}
// There's at least one recipient
return false;
}
public:
virtual void ArmorRicochet(IRecipientFilter &filter, float delay,
const Vector *pos, const Vector *dir) {
if (!SuppressTE(filter)) {
TE_ArmorRicochet(filter, delay, pos, dir);
}
}
virtual void BeamEntPoint(IRecipientFilter &filter, float delay,
int nStartEntity, const Vector *pStart, int nEndEntity, const Vector *pEnd,
int modelindex, int haloindex, int startframe, int framerate,
float life, float width, float endWidth, int fadeLength, float amplitude,
int r, int g, int b, int a, int speed) {
if (!SuppressTE(filter)) {
TE_BeamEntPoint(filter, delay, nStartEntity, pStart, nEndEntity, pEnd,
modelindex, haloindex, startframe, framerate,
life, width, endWidth, fadeLength, amplitude, r, g, b, a, speed);
}
}
virtual void BeamEnts(IRecipientFilter &filter, float delay,
int start, int end, int modelindex, int haloindex, int startframe, int framerate,
float life, float width, float endWidth, int fadeLength, float amplitude,
int r, int g, int b, int a, int speed) {
if (!SuppressTE(filter)) {
TE_BeamEnts(filter, delay,
start, end, modelindex, haloindex, startframe, framerate,
life, width, endWidth, fadeLength, amplitude,
r, g, b, a, speed);
}
}
virtual void BeamFollow(IRecipientFilter &filter, float delay,
int iEntIndex, int modelIndex, int haloIndex, float life, float width, float endWidth,
float fadeLength, float r, float g, float b, float a) {
if (!SuppressTE(filter)) {
TE_BeamFollow(filter, delay,
iEntIndex, modelIndex, haloIndex, life, width, endWidth, fadeLength,
r, g, b, a);
}
}
virtual void BeamPoints(IRecipientFilter &filter, float delay,
const Vector *start, const Vector *end, int modelindex, int haloindex, int startframe,
int framerate,
float life, float width, float endWidth, int fadeLength, float amplitude,
int r, int g, int b, int a, int speed) {
if (!SuppressTE(filter)) {
TE_BeamPoints(filter, delay,
start, end, modelindex, haloindex, startframe, framerate,
life, width, endWidth, fadeLength, amplitude,
r, g, b, a, speed);
}
}
virtual void BeamLaser(IRecipientFilter &filter, float delay,
int start, int end, int modelindex, int haloindex, int startframe, int framerate,
float life, float width, float endWidth, int fadeLength, float amplitude, int r, int g,
int b, int a, int speed) {
if (!SuppressTE(filter)) {
TE_BeamLaser(filter, delay,
start, end, modelindex, haloindex, startframe, framerate,
life, width, endWidth, fadeLength, amplitude, r, g, b, a, speed);
}
}
virtual void BeamRing(IRecipientFilter &filter, float delay,
int start, int end, int modelindex, int haloindex, int startframe, int framerate,
float life, float width, int spread, float amplitude, int r, int g, int b, int a, int speed,
int flags = 0) {
if (!SuppressTE(filter)) {
TE_BeamRing(filter, delay,
start, end, modelindex, haloindex, startframe, framerate,
life, width, spread, amplitude, r, g, b, a, speed, flags);
}
}
virtual void BeamRingPoint(IRecipientFilter &filter, float delay,
const Vector ¢er, float start_radius, float end_radius, int modelindex,
int haloindex, int startframe, int framerate,
float life, float width, int spread, float amplitude, int r, int g, int b, int a,
int speed, int flags = 0) {
if (!SuppressTE(filter)) {
TE_BeamRingPoint(filter, delay,
center, start_radius, end_radius, modelindex, haloindex, startframe, framerate,
life, width, spread, amplitude, r, g, b, a, speed, flags);
}
}
virtual void BeamSpline(IRecipientFilter &filter, float delay,
int points, Vector *rgPoints) {
if (!SuppressTE(filter)) {
TE_BeamSpline(filter, delay, points, rgPoints);
}
}
virtual void BloodStream(IRecipientFilter &filter, float delay,
const Vector *org, const Vector *dir, int r, int g, int b, int a, int amount) {
if (!SuppressTE(filter)) {
TE_BloodStream(filter, delay, org, dir, r, g, b, a, amount);
}
}
virtual void BloodSprite(IRecipientFilter &filter, float delay,
const Vector *org, const Vector *dir, int r, int g, int b, int a, int size) {
if (!SuppressTE(filter)) {
TE_BloodSprite(filter, delay, org, dir, r, g, b, a, size);
}
}
virtual void BreakModel(IRecipientFilter &filter, float delay,
const Vector &pos, const QAngle &angles, const Vector &size, const Vector &vel,
int modelindex, int randomization, int count, float time, int flags) {
if (!SuppressTE(filter)) {
TE_BreakModel(filter, delay, pos, angles, size, vel, modelindex, randomization,
count, time, flags);
}
}
virtual void BSPDecal(IRecipientFilter &filter, float delay,
const Vector *pos, int entity, int index) {
if (!SuppressTE(filter)) {
TE_BSPDecal(filter, delay, pos, entity, index);
}
}
virtual void ProjectDecal(IRecipientFilter &filter, float delay,
const Vector *pos, const QAngle *angles, float distance, int index) {
if (!SuppressTE(filter)) {
TE_ProjectDecal(filter, delay, pos, angles, distance, index);
}
}
virtual void Bubbles(IRecipientFilter &filter, float delay,
const Vector *mins, const Vector *maxs, float height, int modelindex, int count, float speed) {
if (!SuppressTE(filter)) {
TE_Bubbles(filter, delay, mins, maxs, height, modelindex, count, speed);
}
}
virtual void BubbleTrail(IRecipientFilter &filter, float delay,
const Vector *mins, const Vector *maxs, float flWaterZ, int modelindex, int count,
float speed) {
if (!SuppressTE(filter)) {
TE_BubbleTrail(filter, delay, mins, maxs, flWaterZ, modelindex, count, speed);
}
}
virtual void Decal(IRecipientFilter &filter, float delay,
const Vector *pos, const Vector *start, int entity, int hitbox, int index) {
if (!SuppressTE(filter)) {
TE_Decal(filter, delay, pos, start, entity, hitbox, index);
}
}
virtual void DynamicLight(IRecipientFilter &filter, float delay,
const Vector *org, int r, int g, int b, int exponent, float radius, float time,
float decay) {
if (!SuppressTE(filter)) {
TE_DynamicLight(filter, delay, org, r, g, b, exponent, radius, time, decay);
}
}
virtual void Explosion(IRecipientFilter &filter, float delay,
const Vector *pos, int modelindex, float scale, int framerate, int flags, int radius,
int magnitude, const Vector *normal = NULL, unsigned char materialType = 'C') {
if (!SuppressTE(filter)) {
TE_Explosion(filter, delay, pos, modelindex, scale, framerate, flags, radius, magnitude,
normal, materialType);
}
}
virtual void ShatterSurface(IRecipientFilter &filter, float delay,
const Vector *pos, const QAngle *angle, const Vector *vForce, const Vector *vForcePos,
float width, float height, float shardsize, ShatterSurface_t surfacetype,
int front_r, int front_g, int front_b, int back_r, int back_g, int back_b) {
if (!SuppressTE(filter)) {
TE_ShatterSurface(filter, delay, pos, angle, vForce, vForcePos,
width, height, shardsize, surfacetype, front_r, front_g, front_b, back_r, back_g, back_b);
}
}
virtual void GlowSprite(IRecipientFilter &filter, float delay,
const Vector *pos, int modelindex, float life, float size, int brightness) {
if (!SuppressTE(filter)) {
TE_GlowSprite(filter, delay, pos, modelindex, life, size, brightness);
}
}
virtual void FootprintDecal(IRecipientFilter &filter, float delay, const Vector *origin, const Vector *right,
int entity, int index, unsigned char materialType) {
if (!SuppressTE(filter)) {
TE_FootprintDecal(filter, delay, origin, right,
entity, index, materialType);
}
}
virtual void Fizz(IRecipientFilter &filter, float delay,
const C_BaseEntity *ed, int modelindex, int density, int current) {
if (!SuppressTE(filter)) {
TE_Fizz(filter, delay,
ed, modelindex, density, current);
}
}
virtual void KillPlayerAttachments(IRecipientFilter &filter, float delay,
int player) {
if (!SuppressTE(filter)) {
TE_KillPlayerAttachments(filter, delay, player);
}
}
virtual void LargeFunnel(IRecipientFilter &filter, float delay,
const Vector *pos, int modelindex, int reversed) {
if (!SuppressTE(filter)) {
TE_LargeFunnel(filter, delay, pos, modelindex, reversed);
}
}
virtual void MetalSparks(IRecipientFilter &filter, float delay,
const Vector *pos, const Vector *dir) {
if (!SuppressTE(filter)) {
TE_MetalSparks(filter, delay, pos, dir);
}
}
virtual void EnergySplash(IRecipientFilter &filter, float delay,
const Vector *pos, const Vector *dir, bool bExplosive) {
if (!SuppressTE(filter)) {
TE_EnergySplash(filter, delay,
pos, dir, bExplosive);
}
}
virtual void PlayerDecal(IRecipientFilter &filter, float delay,
const Vector *pos, int player, int entity) {
if (!SuppressTE(filter)) {
TE_PlayerDecal(filter, delay,
pos, player, entity);
}
}
virtual void ShowLine(IRecipientFilter &filter, float delay,
const Vector *start, const Vector *end) {
if (!SuppressTE(filter)) {
TE_ShowLine(filter, delay,
start, end);
}
}
virtual void Smoke(IRecipientFilter &filter, float delay,
const Vector *pos, int modelindex, float scale, int framerate) {
if (!SuppressTE(filter)) {
TE_Smoke(filter, delay,
pos, modelindex, scale, framerate);
}
}
virtual void Sparks(IRecipientFilter &filter, float delay,
const Vector *pos, int nMagnitude, int nTrailLength, const Vector *pDir) {
if (!SuppressTE(filter)) {
TE_Sparks(filter, delay,
pos, nMagnitude, nTrailLength, pDir);
}
}
virtual void Sprite(IRecipientFilter &filter, float delay,
const Vector *pos, int modelindex, float size, int brightness) {
if (!SuppressTE(filter)) {
TE_Sprite(filter, delay,
pos, modelindex, size, brightness);
}
}
virtual void SpriteSpray(IRecipientFilter &filter, float delay,
const Vector *pos, const Vector *dir, int modelindex, int speed, float noise, int count) {
if (!SuppressTE(filter)) {
TE_SpriteSpray(filter, delay,
pos, dir, modelindex, speed, noise, count);
}
}
virtual void WorldDecal(IRecipientFilter &filter, float delay,
const Vector *pos, int index) {
if (!SuppressTE(filter)) {
TE_WorldDecal(filter, delay,
pos, index);
}
}
virtual void MuzzleFlash(IRecipientFilter &filter, float delay,
const Vector &start, const QAngle &angles, float scale, int type) {
if (!SuppressTE(filter)) {
TE_MuzzleFlash(filter, delay,
start, angles, scale, type);
}
}
virtual void Dust(IRecipientFilter &filter, float delay,
const Vector &pos, const Vector &dir, float size, float speed) {
if (!SuppressTE(filter)) {
TE_Dust(filter, delay,
pos, dir, size, speed);
}
}
virtual void GaussExplosion(IRecipientFilter &filter, float delay,
const Vector &pos, const Vector &dir, int type) {
if (!SuppressTE(filter)) {
TE_GaussExplosion(filter, delay, pos, dir, type);
}
}
virtual void DispatchEffect(IRecipientFilter &filter, float delay,
const Vector &pos, const char *pName, const CEffectData &data) {
if (!SuppressTE(filter)) {
TE_DispatchEffect(filter, delay, pos, pName, data);
}
}
virtual void PhysicsProp(IRecipientFilter &filter, float delay, int modelindex, int skin,
const Vector &pos, const QAngle &angles, const Vector &vel, int flags, int fEffects) {
if (!SuppressTE(filter)) {
TE_PhysicsProp(filter, delay, modelindex, skin, pos, angles, vel, flags, fEffects);
}
}
virtual void ClientProjectile(IRecipientFilter &filter, float delay,
const Vector *vecOrigin, const Vector *vecVelocity, int modelindex, int lifetime,
CBaseEntity *pOwner) {
if (!SuppressTE(filter)) {
TE_ClientProjectile(filter, delay, vecOrigin, vecVelocity, modelindex, lifetime, pOwner);
}
}
// For playback from external tools
virtual void TriggerTempEntity(KeyValues *pKeyValues) {
g_pEffects->SuppressEffectsSounds(true);
SuppressParticleEffects(true);
// While playing back, suppress recording
bool bIsRecording = clienttools->IsInRecordingMode();
clienttools->EnableRecordingMode(false);
CBroadcastRecipientFilter filter;
TERecordingType_t type = (TERecordingType_t) pKeyValues->GetInt("te");
switch (type) {
case TE_DYNAMIC_LIGHT:
TE_DynamicLight(filter, 0.0f, pKeyValues);
break;
case TE_WORLD_DECAL:
TE_WorldDecal(filter, 0.0f, pKeyValues);
break;
case TE_DISPATCH_EFFECT:
TE_DispatchEffect(filter, 0.0f, pKeyValues);
break;
case TE_MUZZLE_FLASH: {
Vector vecOrigin;
QAngle angles;
vecOrigin.x = pKeyValues->GetFloat("originx");
vecOrigin.y = pKeyValues->GetFloat("originy");
vecOrigin.z = pKeyValues->GetFloat("originz");
angles.x = pKeyValues->GetFloat("anglesx");
angles.y = pKeyValues->GetFloat("anglesy");
angles.z = pKeyValues->GetFloat("anglesz");
float flScale = pKeyValues->GetFloat("scale");
int nType = pKeyValues->GetInt("type");
TE_MuzzleFlash(filter, 0.0f, vecOrigin, angles, flScale, nType);
}
break;
case TE_ARMOR_RICOCHET: {
Vector vecOrigin, vecDirection;
vecOrigin.x = pKeyValues->GetFloat("originx");
vecOrigin.y = pKeyValues->GetFloat("originy");
vecOrigin.z = pKeyValues->GetFloat("originz");
vecDirection.x = pKeyValues->GetFloat("directionx");
vecDirection.y = pKeyValues->GetFloat("directiony");
vecDirection.z = pKeyValues->GetFloat("directionz");
TE_ArmorRicochet(filter, 0.0f, &vecOrigin, &vecDirection);
}
break;
case TE_METAL_SPARKS: {
Vector vecOrigin, vecDirection;
vecOrigin.x = pKeyValues->GetFloat("originx");
vecOrigin.y = pKeyValues->GetFloat("originy");
vecOrigin.z = pKeyValues->GetFloat("originz");
vecDirection.x = pKeyValues->GetFloat("directionx");
vecDirection.y = pKeyValues->GetFloat("directiony");
vecDirection.z = pKeyValues->GetFloat("directionz");
TE_MetalSparks(filter, 0.0f, &vecOrigin, &vecDirection);
}
break;
case TE_SMOKE: {
Vector vecOrigin, vecDirection;
vecOrigin.x = pKeyValues->GetFloat("originx");
vecOrigin.y = pKeyValues->GetFloat("originy");
vecOrigin.z = pKeyValues->GetFloat("originz");
float flScale = pKeyValues->GetFloat("scale");
int nFrameRate = pKeyValues->GetInt("framerate");
TE_Smoke(filter, 0.0f, &vecOrigin, 0, flScale, nFrameRate);
}
break;
case TE_SPARKS: {
Vector vecOrigin, vecDirection;
vecOrigin.x = pKeyValues->GetFloat("originx");
vecOrigin.y = pKeyValues->GetFloat("originy");
vecOrigin.z = pKeyValues->GetFloat("originz");
vecDirection.x = pKeyValues->GetFloat("directionx");
vecDirection.y = pKeyValues->GetFloat("directiony");
vecDirection.z = pKeyValues->GetFloat("directionz");
int nMagnitude = pKeyValues->GetInt("magnitude");
int nTrailLength = pKeyValues->GetInt("traillength");
TE_Sparks(filter, 0.0f, &vecOrigin, nMagnitude, nTrailLength, &vecDirection);
}
break;
case TE_BLOOD_STREAM:
TE_BloodStream(filter, 0.0f, pKeyValues);
break;
case TE_BLOOD_SPRITE:
TE_BloodSprite(filter, 0.0f, pKeyValues);
break;
case TE_BREAK_MODEL:
TE_BreakModel(filter, 0.0f, pKeyValues);
break;
case TE_GLOW_SPRITE:
TE_GlowSprite(filter, 0.0f, pKeyValues);
break;
case TE_PHYSICS_PROP:
TE_PhysicsProp(filter, 0.0f, pKeyValues);
break;
case TE_SPRITE_SINGLE:
TE_Sprite(filter, 0.0f, pKeyValues);
break;
case TE_SPRITE_SPRAY:
TE_SpriteSpray(filter, 0.0f, pKeyValues);
break;
case TE_SHATTER_SURFACE:
TE_ShatterSurface(filter, 0.0f, pKeyValues);
break;
case TE_DECAL:
TE_Decal(filter, 0.0f, pKeyValues);
break;
case TE_PROJECT_DECAL:
TE_ProjectDecal(filter, 0.0f, pKeyValues);
break;
case TE_EXPLOSION:
TE_Explosion(filter, 0.0f, pKeyValues);
break;
#ifdef HL2_DLL
case TE_CONCUSSIVE_EXPLOSION:
TE_ConcussiveExplosion( filter, 0.0f, pKeyValues );
break;
#endif
}
SuppressParticleEffects(false);
g_pEffects->SuppressEffectsSounds(false);
clienttools->EnableRecordingMode(bIsRecording);
}
};
static C_TempEntsSystem g_TESystem;
// Expose to rest of engine
ITempEntsSystem *te = &g_TESystem; | 43.933048 | 120 | 0.58432 | [
"vector"
] |
6f10a4900ba5c74ab24324df47d0ab94d36bcf54 | 2,097 | cpp | C++ | Radiatie/radiatie.cpp | rusucosmin/Cplusplus | 0e95cd01d20b22404aa4166c71d5a9e834a5a21b | [
"MIT"
] | 11 | 2015-08-29T13:41:22.000Z | 2020-01-08T20:34:06.000Z | Radiatie/radiatie.cpp | rusucosmin/Cplusplus | 0e95cd01d20b22404aa4166c71d5a9e834a5a21b | [
"MIT"
] | null | null | null | Radiatie/radiatie.cpp | rusucosmin/Cplusplus | 0e95cd01d20b22404aa4166c71d5a9e834a5a21b | [
"MIT"
] | 5 | 2016-01-20T18:17:01.000Z | 2019-10-30T11:57:15.000Z | #include <fstream>
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
const int maxn = 15005;
const int maxl = 16;
int n, m, k, father[maxn], dp[maxl][maxn], ancestor[maxl][maxn], level[maxn];
vector <pair<int, pair<int, int > > > edges;
vector <pair<int, int> > g[maxn];
inline int find(int x) {
if(x != father[x])
father[x] = find(father[x]);
return father[x];
}
void dfs(int node, int dad) {
ancestor[0][node] = dad;
level[node] = level[dad] + 1;
for(auto it : g[node])
if(it.first != dad) {
dp[0][it.first] = it.second;
dfs(it.first, node);
}
}
inline int query(int x, int y) {
if(level[x] < level[y])
swap(x, y);
int log1, log2;
for(log1 = 1 ; (1 << log1) < level[x] ; ++ log1);
for(log2 = 1 ; (1 << log2) < level[y] ; ++ log2);
int ans = 0;
for(int i = log1 ; i >= 0 ; -- i)
if(level[x] - (1 << i) >= level[y]) {
ans = max(ans, dp[i][x]);
x = ancestor[i][x];
}
if(x == y)
return ans;
for(int i = log2 ; i >= 0 ; -- i)
if(ancestor[i][x] != ancestor[i][y]) {
ans = max(ans, dp[i][x]);
ans = max(ans, dp[i][y]);
x = ancestor[i][x];
y = ancestor[i][y];
}
ans = max(ans, dp[0][x]);
ans = max(ans, dp[0][y]);
return ans;
}
int main() {
ifstream fin("radiatie.in");
ofstream fout("radiatie.out");
fin >> n >> m >> k;
while (m -- ) {
int x, y, z;
fin >> x >> y >> z;
edges.push_back(make_pair(z, make_pair(x, y)));
}
sort(edges.begin(), edges.end());
for(int i = 1 ; i <= n ; ++ i)
father[i] = i;
for(auto it : edges) {
int tx = find(it.second.first);
int ty = find(it.second.second);
if(tx != ty) {
father[tx] = ty;
g[it.second.first].push_back(make_pair(it.second.second, it.first));
g[it.second.second].push_back(make_pair(it.second.first, it.first));
}
}
dfs(1, 0);
for(int i = 1 ; (1 << i) <= n ; ++ i)
for(int j = 1 ; j <= n ; ++ j) {
ancestor[i][j] = ancestor[i - 1][ ancestor[i - 1][j] ];
dp[i][j] = max(dp[i - 1][j], dp[i - 1][ ancestor[i - 1][j] ]);
}
while (k -- ) {
int x, y;
fin >> x >> y;
fout << query(x, y) << '\n';
}
}
| 20.97 | 77 | 0.531235 | [
"vector"
] |
6f169bc04994598e42bb07696c7d598ca49e1df7 | 14,741 | cc | C++ | src/flatzinc/solver.cc | sammy5976/ThinkNin | 601dff2ed70691555294152de37d9547494e4bb1 | [
"Apache-2.0"
] | null | null | null | src/flatzinc/solver.cc | sammy5976/ThinkNin | 601dff2ed70691555294152de37d9547494e4bb1 | [
"Apache-2.0"
] | null | null | null | src/flatzinc/solver.cc | sammy5976/ThinkNin | 601dff2ed70691555294152de37d9547494e4bb1 | [
"Apache-2.0"
] | 3 | 2016-04-14T10:31:30.000Z | 2017-02-05T06:04:21.000Z | // Copyright 2010-2014 Google
// 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 <string>
#include "base/integral_types.h"
#include "base/logging.h"
#include "base/map_util.h"
#include "base/hash.h"
#include "constraint_solver/constraint_solver.h"
#include "flatzinc/model.h"
#include "flatzinc/sat_constraint.h"
#include "flatzinc/solver.h"
#include "util/string_array.h"
DECLARE_bool(fz_logging);
DECLARE_bool(fz_verbose);
DECLARE_bool(fz_debug);
DEFINE_bool(use_sat, true, "Use a sat solver for propagating on booleans.");
namespace operations_research {
IntExpr* FzSolver::GetExpression(const FzArgument& arg) {
switch (arg.type) {
case FzArgument::INT_VALUE: {
return solver_.MakeIntConst(arg.Value());
}
case FzArgument::INT_VAR_REF: {
return Extract(arg.variables[0]);
}
default: {
LOG(FATAL) << "Cannot extract " << arg.DebugString() << " as a variable";
return nullptr;
}
}
}
std::vector<IntVar*> FzSolver::GetVariableArray(const FzArgument& arg) {
std::vector<IntVar*> result;
if (arg.type == FzArgument::INT_VAR_REF_ARRAY) {
result.resize(arg.variables.size());
for (int i = 0; i < arg.variables.size(); ++i) {
result[i] = Extract(arg.variables[i])->Var();
}
} else if (arg.type == FzArgument::INT_LIST) {
result.resize(arg.values.size());
for (int i = 0; i < arg.values.size(); ++i) {
result[i] = solver_.MakeIntConst(arg.values[i]);
}
} else if (arg.type == FzArgument::VOID_ARGUMENT) {
// Nothing to do.
} else {
LOG(FATAL) << "Cannot extract " << arg.DebugString()
<< " as a variable array";
}
return result;
}
IntExpr* FzSolver::Extract(FzIntegerVariable* var) {
IntExpr* result = FindPtrOrNull(extracted_map_, var);
if (result != nullptr) {
return result;
}
if (var->domain.IsSingleton()) {
result = solver_.MakeIntConst(var->domain.values.back());
} else if (var->IsAllInt64()) {
result = solver_.MakeIntVar(kint32min, kint32max, var->name);
} else if (var->domain.is_interval) {
result =
solver_.MakeIntVar(std::max<int64>(var->Min(), kint32min),
std::min<int64>(var->Max(), kint32max), var->name);
} else {
result = solver_.MakeIntVar(var->domain.values, var->name);
}
FZVLOG << "Extract " << var->DebugString() << FZENDL;
FZVLOG << " - created " << result->DebugString() << FZENDL;
extracted_map_[var] = result;
return result;
}
void FzSolver::SetExtracted(FzIntegerVariable* fz_var, IntExpr* expr) {
CHECK(!ContainsKey(extracted_map_, fz_var));
if (!expr->IsVar() && !fz_var->domain.is_interval) {
FZVLOG << " - lift to var" << FZENDL;
expr = expr->Var();
}
extracted_map_[fz_var] = expr;
}
int64 FzSolver::SolutionValue(FzIntegerVariable* var) {
IntExpr* const result = FindPtrOrNull(extracted_map_, var);
if (result != nullptr) {
if (result->IsVar()) {
return result->Var()->Value();
} else {
int64 emin = 0;
int64 emax = 0;
result->Range(&emin, &emax);
CHECK_EQ(emin, emax) << "Expression " << result->DebugString()
<< " is not fixed to a single value at a solution";
return emin;
}
} else {
CHECK(var->domain.IsSingleton());
return var->domain.values[0];
}
}
// The format is fixed in the flatzinc specification.
std::string FzSolver::SolutionString(const FzOnSolutionOutput& output, bool store) {
if (output.variable != nullptr) {
const int64 value = SolutionValue(output.variable);
if (store) {
stored_values_.back()[output.variable] = value;
}
if (output.display_as_boolean) {
return StringPrintf("%s = %s;", output.name.c_str(),
value == 1 ? "true" : "false");
} else {
return StringPrintf("%s = %" GG_LL_FORMAT "d;", output.name.c_str(),
value);
}
} else {
const int bound_size = output.bounds.size();
std::string result =
StringPrintf("%s = array%dd(", output.name.c_str(), bound_size);
for (int i = 0; i < bound_size; ++i) {
if (output.bounds[i].max_value != 0) {
result.append(StringPrintf("%" GG_LL_FORMAT "d..%" GG_LL_FORMAT "d, ",
output.bounds[i].min_value,
output.bounds[i].max_value));
} else {
result.append("{},");
}
}
result.append("[");
for (int i = 0; i < output.flat_variables.size(); ++i) {
const int64 value = SolutionValue(output.flat_variables[i]);
FzIntegerVariable* const var = output.flat_variables[i];
if (output.display_as_boolean) {
result.append(StringPrintf(value ? "true" : "false"));
} else {
result.append(StringPrintf("%" GG_LL_FORMAT "d", value));
}
if (i != output.flat_variables.size() - 1) {
result.append(", ");
}
if (store) {
stored_values_.back()[var] = value;
}
}
result.append("]);");
return result;
}
return "";
}
namespace {
struct ConstraintWithIo {
FzConstraint* ct;
int index;
hash_set<FzIntegerVariable*> required;
ConstraintWithIo(FzConstraint* cte, int i,
const hash_set<FzIntegerVariable*>& defined)
: ct(cte), index(i) {
// Collect required variables.
for (const FzArgument& arg : ct->arguments) {
for (FzIntegerVariable* const var : arg.variables) {
if (var != cte->target_variable && ContainsKey(defined, var)) {
required.insert(var);
}
}
}
}
std::string DebugString() const {
return StringPrintf("Ctio(%s, %d, deps_size = %lu)", ct->type.c_str(),
index, required.size());
}
};
int ComputeWeight(const ConstraintWithIo& ctio) {
return ctio.required.size() * 2 + (ctio.ct->target_variable == nullptr);
}
// Comparator to sort constraints based on numbers of required
// elements and index. Reverse sorting to put elements to remove at the end.
struct ConstraintWithIoComparator {
bool operator()(ConstraintWithIo* a, ConstraintWithIo* b) const {
const int a_weight = ComputeWeight(*a);
const int b_weight = ComputeWeight(*b);
return a_weight > b_weight || (a_weight == b_weight && a->index > b->index);
}
};
} // namespace
bool FzSolver::Extract() {
// Create the sat solver.
if (FLAGS_use_sat) {
FZLOG << " - Use sat" << FZENDL;
sat_ = MakeSatPropagator(&solver_);
solver_.AddConstraint(reinterpret_cast<Constraint*>(sat_));
} else {
sat_ = nullptr;
}
// Build statistics.
statistics_.BuildStatistics();
// Extract variables.
FZLOG << "Extract variables" << FZENDL;
int extracted_variables = 0;
int extracted_constants = 0;
int skipped_variables = 0;
hash_set<FzIntegerVariable*> defined_variables;
for (FzIntegerVariable* const var : model_.variables()) {
if (var->defining_constraint == nullptr && var->active) {
Extract(var);
if (var->domain.IsSingleton()) {
extracted_constants++;
} else {
extracted_variables++;
}
} else {
FZVLOG << "Skip " << var->DebugString() << FZENDL;
if (var->defining_constraint != nullptr) {
FZVLOG << " - defined by " << var->defining_constraint->DebugString()
<< FZENDL;
}
defined_variables.insert(var);
skipped_variables++;
}
}
FZLOG << " - " << extracted_variables << " variables created" << FZENDL;
FZLOG << " - " << extracted_constants << " constants created" << FZENDL;
FZLOG << " - " << skipped_variables << " variables skipped" << FZENDL;
// Parse model to store info.
FZLOG << "Extract constraints" << FZENDL;
for (FzConstraint* const ct : model_.constraints()) {
if (ct->type == "all_different_int") {
StoreAllDifferent(ct->Arg(0).variables);
}
}
// Sort constraints such that defined variables are created before the
// extraction of the constraints that use them.
int index = 0;
std::vector<ConstraintWithIo*> to_sort;
std::vector<FzConstraint*> sorted;
hash_map<const FzIntegerVariable*, std::vector<ConstraintWithIo*>> dependencies;
for (FzConstraint* ct : model_.constraints()) {
if (ct != nullptr && ct->active) {
ConstraintWithIo* const ctio =
new ConstraintWithIo(ct, index++, defined_variables);
to_sort.push_back(ctio);
for (FzIntegerVariable* const var : ctio->required) {
dependencies[var].push_back(ctio);
}
}
}
// Sort a first time.
std::sort(to_sort.begin(), to_sort.end(), ConstraintWithIoComparator());
for (ConstraintWithIo* const ctio : to_sort) {
CHECK(ctio != nullptr);
}
// Topological sort.
while (!to_sort.empty()) {
if (!to_sort.back()->required.empty()) {
// Sort again.
std::sort(to_sort.begin(), to_sort.end(), ConstraintWithIoComparator());
}
ConstraintWithIo* const ctio = to_sort.back();
if (!ctio->required.empty()) {
// Recovery. We pick the last constraint (min number of required variable)
// And we clean all of them (mark as non target).
std::vector<FzIntegerVariable*> required_vars(ctio->required.begin(),
ctio->required.end());
for (FzIntegerVariable* const fz_var : required_vars) {
FZDLOG << " - clean " << fz_var->DebugString() << FZENDL;
if (fz_var->defining_constraint != nullptr) {
fz_var->defining_constraint->target_variable = nullptr;
fz_var->defining_constraint = nullptr;
}
for (ConstraintWithIo* const to_clean : dependencies[fz_var]) {
to_clean->required.erase(fz_var);
}
}
continue;
}
to_sort.pop_back();
FZDLOG << "Pop " << ctio->ct->DebugString() << FZENDL;
CHECK(ctio->required.empty());
// TODO(user): Implement recovery mode.
sorted.push_back(ctio->ct);
FzIntegerVariable* const var = ctio->ct->target_variable;
if (var != nullptr && ContainsKey(dependencies, var)) {
FZDLOG << " - clean " << var->DebugString() << FZENDL;
for (ConstraintWithIo* const to_clean : dependencies[var]) {
to_clean->required.erase(var);
}
}
delete ctio;
}
for (FzConstraint* const ct : sorted) {
ExtractConstraint(ct);
}
FZLOG << " - " << sorted.size() << " constraints parsed" << FZENDL;
const int num_cp_constraints = solver_.constraints();
if (num_cp_constraints <= 1) {
FZLOG << " - " << num_cp_constraints
<< " constraint added to the CP solver" << FZENDL;
} else {
FZLOG << " - " << num_cp_constraints
<< " constraints added to the CP solver" << FZENDL;
}
const int num_sat_constraints = FLAGS_use_sat ? NumSatConstraints(sat_) : 0;
if (num_sat_constraints > 0) {
FZLOG << " - " << num_sat_constraints << " constraints added to SAT solver"
<< FZENDL;
}
// Add domain constraints to created expressions.
int domain_constraints = 0;
for (FzIntegerVariable* const var : model_.variables()) {
if (var->defining_constraint != nullptr && var->active) {
const FzDomain& domain = var->domain;
if (!domain.is_interval && domain.values.size() == 2 &&
domain.values[0] == 0 && domain.values[1] == 1) {
// Canonicalize domains: {0, 1} -> [0 ,, 1]
var->domain.is_interval = true;
}
IntExpr* const expr = Extract(var);
if (expr->IsVar() && domain.is_interval && !domain.values.empty() &&
(expr->Min() < domain.values[0] || expr->Max() > domain.values[1])) {
FZVLOG << "Intersect variable domain of " << expr->DebugString()
<< " with" << domain.DebugString() << FZENDL;
expr->Var()->SetRange(domain.values[0], domain.values[1]);
} else if (expr->IsVar() && !domain.is_interval) {
FZVLOG << "Intersect variable domain of " << expr->DebugString()
<< " with " << domain.DebugString() << FZENDL;
expr->Var()->SetValues(domain.values);
} else if (domain.is_interval && !domain.values.empty() &&
(expr->Min() < domain.values[0] ||
expr->Max() > domain.values[1])) {
FZVLOG << "Add domain constraint " << domain.DebugString() << " onto "
<< expr->DebugString() << FZENDL;
solver_.AddConstraint(solver_.MakeBetweenCt(
expr->Var(), domain.values[0], domain.values[1]));
domain_constraints++;
} else if (!domain.is_interval) {
FZVLOG << "Add domain constraint " << domain.DebugString() << " onto "
<< expr->DebugString() << FZENDL;
solver_.AddConstraint(solver_.MakeMemberCt(expr->Var(), domain.values));
domain_constraints++;
}
}
}
if (domain_constraints == 1) {
FZLOG << " - 1 domain constraint added" << FZENDL;
} else if (domain_constraints > 1) {
FZLOG << " - " << domain_constraints << " domain constraints added"
<< FZENDL;
}
return true;
}
// ----- Alldiff info support -----
void FzSolver::StoreAllDifferent(const std::vector<FzIntegerVariable*>& diffs) {
if (!diffs.empty()) {
std::vector<FzIntegerVariable*> local(diffs);
std::sort(local.begin(), local.end());
FZVLOG << "Store AllDifferent info for [" << JoinDebugStringPtr(diffs, ", ")
<< "]" << FZENDL;
alldiffs_[local.front()].push_back(local);
}
}
namespace {
template <class T>
bool EqualVector(const std::vector<T>& v1, const std::vector<T>& v2) {
if (v1.size() != v2.size()) return false;
for (int i = 0; i < v1.size(); ++i) {
if (v1[i] != v2[i]) return false;
}
return true;
}
} // namespace
bool FzSolver::IsAllDifferent(const std::vector<FzIntegerVariable*>& diffs) const {
std::vector<FzIntegerVariable*> local(diffs);
std::sort(local.begin(), local.end());
const FzIntegerVariable* const start = local.front();
if (!ContainsKey(alldiffs_, start)) return false;
const std::vector<std::vector<FzIntegerVariable*>>& stored =
FindOrDie(alldiffs_, start);
for (const std::vector<FzIntegerVariable*>& one_diff : stored) {
if (EqualVector(local, one_diff)) {
return true;
}
}
return false;
}
} // namespace operations_research
| 35.779126 | 84 | 0.618276 | [
"vector",
"model"
] |
6f17fc06fef42f1281a37e2b2743ea776a8ad43b | 2,921 | cpp | C++ | tests/validation/reference/ChannelExtract.cpp | elenita1221/ComputeLibrary | 3d2d44ef55ab6b08afda8be48301ce3c55c7bc67 | [
"MIT"
] | 2 | 2020-07-25T20:27:14.000Z | 2021-08-22T17:20:59.000Z | tests/validation/reference/ChannelExtract.cpp | elenita1221/ComputeLibrary | 3d2d44ef55ab6b08afda8be48301ce3c55c7bc67 | [
"MIT"
] | null | null | null | tests/validation/reference/ChannelExtract.cpp | elenita1221/ComputeLibrary | 3d2d44ef55ab6b08afda8be48301ce3c55c7bc67 | [
"MIT"
] | 1 | 2021-08-22T17:09:09.000Z | 2021-08-22T17:09:09.000Z | /*
* Copyright (c) 2017-2018 ARM Limited.
*
* SPDX-License-Identifier: MIT
*
* 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 "ChannelExtract.h"
#include "arm_compute/core/Types.h"
#include "tests/validation/Helpers.h"
namespace arm_compute
{
namespace test
{
namespace validation
{
namespace reference
{
template <typename T>
SimpleTensor<uint8_t> channel_extract(const TensorShape &shape, const std::vector<SimpleTensor<T>> &tensor_planes, Format format, Channel channel)
{
// Find plane and channel index
const unsigned int plane_idx = plane_idx_from_channel(format, channel);
const unsigned int channel_idx = channel_idx_from_format(format, channel);
// Create dst and get src tensor
SimpleTensor<T> src = tensor_planes[plane_idx];
SimpleTensor<T> dst{ calculate_subsampled_shape(shape, format, channel), Format::U8 };
// Single planar formats with subsampling require a double horizontal step
const int step_x = ((Format::YUYV422 == format || Format::UYVY422 == format) && Channel::Y != channel) ? 2 : 1;
const int width = dst.shape().x();
const int height = dst.shape().y();
// Loop over each pixel and extract channel
for(int y = 0; y < height; ++y)
{
for(int x = 0; x < width; ++x)
{
const Coordinates src_coord{ x * step_x, y };
const Coordinates dst_coord{ x, y };
const auto *src_pixel = reinterpret_cast<const T *>(src(src_coord));
auto *dst_pixel = reinterpret_cast<T *>(dst(dst_coord));
dst_pixel[0] = src_pixel[channel_idx];
}
}
return dst;
}
template SimpleTensor<uint8_t> channel_extract(const TensorShape &shape, const std::vector<SimpleTensor<uint8_t>> &tensor_planes, Format format, Channel channel);
} // namespace reference
} // namespace validation
} // namespace test
} // namespace arm_compute
| 38.434211 | 162 | 0.71277 | [
"shape",
"vector"
] |
6f18cb4e3815cbb946171c9daee8b6c0688a6e08 | 1,892 | hpp | C++ | include/codegen/include/GlobalNamespace/ShaderVariantsSO.hpp | Futuremappermydud/Naluluna-Modifier-Quest | bfda34370764b275d90324b3879f1a429a10a873 | [
"MIT"
] | 1 | 2021-11-12T09:29:31.000Z | 2021-11-12T09:29:31.000Z | include/codegen/include/GlobalNamespace/ShaderVariantsSO.hpp | Futuremappermydud/Naluluna-Modifier-Quest | bfda34370764b275d90324b3879f1a429a10a873 | [
"MIT"
] | null | null | null | include/codegen/include/GlobalNamespace/ShaderVariantsSO.hpp | Futuremappermydud/Naluluna-Modifier-Quest | bfda34370764b275d90324b3879f1a429a10a873 | [
"MIT"
] | 2 | 2021-10-03T02:14:20.000Z | 2021-11-12T09:29:36.000Z | // Autogenerated from CppHeaderCreator
// Created by Sc2ad
// =========================================================================
#pragma once
#pragma pack(push, 8)
// Begin includes
#include "extern/beatsaber-hook/shared/utils/typedefs.h"
// Including type: PersistentScriptableObject
#include "GlobalNamespace/PersistentScriptableObject.hpp"
// Completed includes
// Begin forward declares
// Forward declaring namespace: GlobalNamespace
namespace GlobalNamespace {
}
// Completed forward declares
// Type namespace:
namespace GlobalNamespace {
// Autogenerated type: ShaderVariantsSO
class ShaderVariantsSO : public GlobalNamespace::PersistentScriptableObject {
public:
// Nested type: GlobalNamespace::ShaderVariantsSO::ShaderVariant
class ShaderVariant;
// private ShaderVariantsSO/ShaderVariant[] _shaderVariants
// Offset: 0x18
::Array<GlobalNamespace::ShaderVariantsSO::ShaderVariant*>* shaderVariants;
// public ShaderVariantsSO/ShaderVariant[] get_shaderVariants()
// Offset: 0x19156F8
::Array<GlobalNamespace::ShaderVariantsSO::ShaderVariant*>* get_shaderVariants();
// public System.Void Init(ShaderVariantsSO/ShaderVariant[] shaderVariants)
// Offset: 0x1915700
void Init(::Array<GlobalNamespace::ShaderVariantsSO::ShaderVariant*>* shaderVariants);
// public System.Void .ctor()
// Offset: 0x1915708
// Implemented from: PersistentScriptableObject
// Base method: System.Void PersistentScriptableObject::.ctor()
// Base method: System.Void ScriptableObject::.ctor()
// Base method: System.Void Object::.ctor()
// Base method: System.Void Object::.ctor()
static ShaderVariantsSO* New_ctor();
}; // ShaderVariantsSO
}
#include "extern/beatsaber-hook/shared/utils/il2cpp-type-check.hpp"
DEFINE_IL2CPP_ARG_TYPE(GlobalNamespace::ShaderVariantsSO*, "", "ShaderVariantsSO");
#pragma pack(pop)
| 42.044444 | 90 | 0.728858 | [
"object"
] |
6f1c521df0f73d4fc7852876f0e49ecf8360f781 | 4,680 | cxx | C++ | track_oracle/core/track_oracle_row_view.cxx | neal-siekierski/kwiver | 1c97ad72c8b6237cb4b9618665d042be16825005 | [
"BSD-3-Clause"
] | 1 | 2017-07-31T07:07:32.000Z | 2017-07-31T07:07:32.000Z | track_oracle/core/track_oracle_row_view.cxx | neal-siekierski/kwiver | 1c97ad72c8b6237cb4b9618665d042be16825005 | [
"BSD-3-Clause"
] | 4 | 2021-03-19T00:52:41.000Z | 2022-03-11T23:48:06.000Z | track_oracle/core/track_oracle_row_view.cxx | neal-siekierski/kwiver | 1c97ad72c8b6237cb4b9618665d042be16825005 | [
"BSD-3-Clause"
] | null | null | null | /*ckwg +5
* Copyright 2010-2016 by Kitware, Inc. All Rights Reserved. Please refer to
* KITWARE_LICENSE.TXT for licensing information, or contact General Counsel,
* Kitware, Inc., 28 Corporate Drive, Clifton Park, NY 12065.
*/
#include "track_oracle_row_view.h"
#include <vital/logger/logger.h>
static kwiver::vital::logger_handle_t main_logger( kwiver::vital::get_logger( __FILE__ ) );
using std::cerr;
using std::ostream;
using std::vector;
namespace kwiver {
namespace track_oracle {
track_oracle_row_view
::track_oracle_row_view()
{
}
track_oracle_row_view
::track_oracle_row_view( const track_oracle_row_view& other )
: track_field_host()
{
for (size_t i=0; i<other.field_list.size(); ++i)
{
this->field_list.push_back( other.field_list[i]->clone() );
this->this_owns_ptr.push_back( true );
}
}
track_oracle_row_view&
track_oracle_row_view
::operator=( const track_oracle_row_view& other )
{
if (this != &other)
{
this->reset();
for (size_t i=0; i<other.field_list.size(); ++i)
{
this->field_list.push_back( other.field_list[i]->clone() );
this->this_owns_ptr.push_back( true );
}
}
return *this;
}
track_oracle_row_view
::~track_oracle_row_view()
{
this->reset();
}
void
track_oracle_row_view
::reset()
{
for (unsigned i=0; i<this->field_list.size(); ++i)
{
if ( this->this_owns_ptr[i] )
{
delete this->field_list[i];
}
}
this->field_list.clear();
}
const track_oracle_row_view&
track_oracle_row_view
::operator()( const track_handle_type& h ) const
{
this->set_cursor( h.row );
return *this;
}
void
track_oracle_row_view
::remove_row( const track_handle_type& t )
{
for (unsigned i=0; i<this->field_list.size(); ++i) {
this->field_list[i]->remove_at_row( t.row );
}
}
vector< field_handle_type >
track_oracle_row_view
::list_missing_elements( const oracle_entry_handle_type& row ) const
{
vector< field_handle_type > missing_fields;
for (unsigned i=0; i<this->field_list.size(); ++i)
{
field_handle_type f = this->field_list[i]->get_field_handle();
if (! track_oracle_core::field_has_row(row, f ))
{
missing_fields.push_back( f );
}
}
return missing_fields;
}
bool
track_oracle_row_view
::is_complete() const
{
for (unsigned i=0; i<this->field_list.size(); ++i)
{
if ( ! this->field_list[i]->exists() )
{
LOG_INFO( main_logger, "Row " << this->get_cursor() << " is missing ");
LOG_INFO( main_logger, this->field_list[i] );
LOG_INFO( main_logger, "\ncomplete dump:");
LOG_INFO( main_logger, *this << "");
return false;
}
}
return true;
}
void
track_oracle_row_view
::copy_values( const oracle_entry_handle_type& src,
const oracle_entry_handle_type& dst ) const
{
for ( size_t i=0; i<this->field_list.size(); ++i )
{
this->field_list[i]->copy_value( src, dst );
}
}
ostream&
operator<<( ostream& os, const track_oracle_row_view& r )
{
size_t n = r.field_list.size();
os << "h=" << r.get_cursor() << "; " << n;
if (n == 1)
{
os << " field:";
}
else
{
os << " fields:";
}
os << "\n";
for (unsigned i=0; i<r.field_list.size(); ++i)
{
os << "..";
os << r.field_list[i];
os << "\n";
}
return os;
}
bool
track_oracle_row_view
::add_field( track_field_base& field, bool this_owns )
{
if (this->contains_element( field.get_field_handle() )) return false;
field.set_host( this );
this->field_list.push_back( &field );
this->this_owns_ptr.push_back( this_owns );
return true;
}
bool
track_oracle_row_view
::contains_element( const element_descriptor& e ) const
{
return this->contains_element( track_oracle_core::lookup_by_name( e.name ));
}
bool
track_oracle_row_view
::contains_element( field_handle_type f ) const
{
if ( f == INVALID_FIELD_HANDLE ) return false;
for (size_t i=0; i<this->field_list.size(); ++i)
{
if ( this->field_list[i]->get_field_handle() == f) return true;
}
return false;
}
vector< field_handle_type >
track_oracle_row_view
::list_elements() const
{
vector< field_handle_type > ret;
for (size_t i=0; i<this->field_list.size(); ++i)
{
ret.push_back( this->field_list[i]->get_field_handle() );
}
return ret;
}
track_field_base*
track_oracle_row_view
::clone_field_from_element( const element_descriptor& e ) const
{
field_handle_type f = track_oracle_core::lookup_by_name( e.name );
if ( f == INVALID_FIELD_HANDLE ) return 0;
for (size_t i=0; i<this->field_list.size(); ++i)
{
if (this->field_list[i]->get_field_handle() == f)
{
return this->field_list[i]->clone();
}
}
return 0;
}
} // ...track_oracle
} // ...kwiver
| 21.272727 | 91 | 0.666026 | [
"vector"
] |
6f1de17433437d2500edd996fb36641fa6d44c85 | 2,322 | hpp | C++ | drw.hpp | DaveDuck321/dwm_cpp | 86ae2d57c4d7338deeb94c28156dae50bb8e045c | [
"MIT"
] | null | null | null | drw.hpp | DaveDuck321/dwm_cpp | 86ae2d57c4d7338deeb94c28156dae50bb8e045c | [
"MIT"
] | null | null | null | drw.hpp | DaveDuck321/dwm_cpp | 86ae2d57c4d7338deeb94c28156dae50bb8e045c | [
"MIT"
] | null | null | null | /* See LICENSE file for copyright and license details. */
#pragma once
#include <X11/Xft/Xft.h>
#include <X11/Xlib.h>
#include <memory>
#include <optional>
#include <string_view>
#include <vector>
class CursorFont {
public:
CursorFont(Display*, int shape);
CursorFont(CursorFont&&);
~CursorFont();
Cursor getXCursor() const;
private:
Display* fDisplay;
std::optional<Cursor> fCursor;
};
struct ColorScheme {
std::string foreground;
std::string background;
std::string border;
};
struct XColorScheme {
XColorScheme(Display*, int screen, const ColorScheme&);
XftColor foreground;
XftColor background;
XftColor border;
};
template <typename Scheme> struct Theme {
Scheme normal;
Scheme selected;
};
class DisplayFont {
public:
DisplayFont(Display*, int screen, const char* fontName);
DisplayFont(Display*, FcPattern*);
DisplayFont(DisplayFont&&);
~DisplayFont();
bool doesCodepointExistInFont(long utf8Codepoint) const;
std::optional<DisplayFont>
generateDerivedFontWithCodepoint(int screen, long utf8Codepoint) const;
uint getHeight() const;
uint getTextExtent(std::string_view) const;
XftFont* getXFont() const;
private:
void dieIfFontIsColored() const;
Display* fDisplay;
XftFont* fXfont;
FcPattern* fPattern;
};
class Drw {
public:
Drw(Display* dpy, int screen, Window win, uint w, uint h);
~Drw();
void resize(uint w, uint h);
const std::vector<DisplayFont>&
createFontSet(const std::vector<std::string>& fontNames);
uint getPrimaryFontHeight() const;
const std::vector<DisplayFont>& getFontset() const;
Theme<XColorScheme> parseTheme(const Theme<ColorScheme>&) const;
void setScheme(const XColorScheme&);
int getTextWidth(std::string_view);
void renderRect(int x, int y, uint w, uint h, bool filled,
bool invert) const;
int renderText(int x, int y, uint w, uint h, uint lpad, std::string_view,
bool invert);
void map(Window win, int x, int y, uint w, uint h) const;
private:
uint fWidth, fHeight;
Display* fDisplay;
int fScreen;
Window fRoot;
Drawable fDrawable;
GC fGC;
std::optional<XColorScheme> fScheme;
std::vector<DisplayFont> fFonts;
};
| 22.543689 | 77 | 0.67528 | [
"shape",
"vector"
] |
6f2cd170502725d32f94d547cb3b4bf7fab379ed | 6,798 | cxx | C++ | smtk/mesh/testing/cxx/UnitTestCreateMesh.cxx | yumin/SMTK | d280f10c5b70953b2a0196f71832955c7fc75e7f | [
"BSD-3-Clause-Clear"
] | null | null | null | smtk/mesh/testing/cxx/UnitTestCreateMesh.cxx | yumin/SMTK | d280f10c5b70953b2a0196f71832955c7fc75e7f | [
"BSD-3-Clause-Clear"
] | 4 | 2016-11-10T15:49:51.000Z | 2017-02-06T23:24:16.000Z | smtk/mesh/testing/cxx/UnitTestCreateMesh.cxx | yumin/SMTK | d280f10c5b70953b2a0196f71832955c7fc75e7f | [
"BSD-3-Clause-Clear"
] | null | null | null |
//=========================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//=========================================================================
#include "smtk/mesh/Collection.h"
#include "smtk/mesh/Manager.h"
#include "smtk/io/ImportMesh.h"
#include "smtk/mesh/testing/cxx/helpers.h"
namespace
{
//SMTK_DATA_DIR is a define setup by cmake
std::string data_root = SMTK_DATA_DIR;
//----------------------------------------------------------------------------
smtk::mesh::CollectionPtr load_mesh(smtk::mesh::ManagerPtr mngr)
{
std::string file_path(data_root);
file_path += "/mesh/twoassm_out.h5m";
smtk::mesh::CollectionPtr c = smtk::io::ImportMesh::entireFile(file_path, mngr);
test( c->isValid(), "collection should be valid");
return c;
}
//----------------------------------------------------------------------------
void cleanup(const smtk::mesh::CollectionPtr& c,
smtk::mesh::MeshSet meshset)
{
smtk::mesh::MeshSet allMeshes = c->meshes();
const bool is_part_of_collection =
smtk::mesh::set_intersect(allMeshes, meshset).is_empty();
if(is_part_of_collection)
{
test( c->removeMeshes(meshset) == true );
}
}
//----------------------------------------------------------------------------
void verify_create_empty_mesh(const smtk::mesh::CollectionPtr& c)
{
const std::size_t numMeshesBeforeCreation = c->numberOfMeshes();
smtk::mesh::CellSet emptyCellSet = smtk::mesh::CellSet(c, smtk::mesh::HandleRange() );
smtk::mesh::MeshSet result = c->createMesh( emptyCellSet );
test(result.is_empty(), "empty cellset should create empty meshset");
test(numMeshesBeforeCreation == c->numberOfMeshes(),
"the number of meshes shouldn't change when adding an empty mesh");
}
//----------------------------------------------------------------------------
void verify_create_mesh_with_cells_from_other_collection(
smtk::mesh::ManagerPtr mngr,
const smtk::mesh::CollectionPtr& c)
{
//make another collection inside the manager
smtk::mesh::CollectionPtr otherc = load_mesh(mngr);
const std::size_t numMeshesBeforeCreation = c->numberOfMeshes();
smtk::mesh::CellSet cellsFromOtherMesh = otherc->cells();
smtk::mesh::MeshSet result = c->createMesh( cellsFromOtherMesh );
test(result.is_empty(), "cellset from different collection should create empty meshset");
test(numMeshesBeforeCreation == c->numberOfMeshes());
//unload the second collection from memory
mngr->removeCollection(otherc);
}
//----------------------------------------------------------------------------
void verify_create_mesh_with_invalid_cell_ids(const smtk::mesh::CollectionPtr& c)
{
const std::size_t numMeshesBeforeCreation = c->numberOfMeshes();
smtk::mesh::HandleRange invalidRange;
invalidRange.insert(0,5); //insert values 0 to 5;
smtk::mesh::CellSet invalidCellIds = smtk::mesh::CellSet(c, invalidRange);
smtk::mesh::MeshSet result = c->createMesh( invalidCellIds );
test(result.is_empty(), "invalid cellset should create empty meshset");
test(numMeshesBeforeCreation == c->numberOfMeshes());
}
//----------------------------------------------------------------------------
void verify_create_mesh(const smtk::mesh::CollectionPtr& c)
{
const std::size_t numMeshesBeforeCreation = c->numberOfMeshes();
smtk::mesh::CellSet allNonVolumeCells =
smtk::mesh::set_difference(c->cells(), c->cells( smtk::mesh::Dims3 ) );
smtk::mesh::MeshSet result = c->createMesh( allNonVolumeCells );
test( result.size() == 1, "valid cellset should create meshset with single mesh");
test( (numMeshesBeforeCreation + 1) == c->numberOfMeshes());
test( result.cells().size() == allNonVolumeCells.size() );
test( result.cells() == allNonVolumeCells );
cleanup(c, result);
}
//----------------------------------------------------------------------------
void verify_create_mesh_num_meshes(const smtk::mesh::CollectionPtr& c)
{
const std::size_t numMeshesBeforeCreation = c->numberOfMeshes();
//validate that for each mesh we create the numberOfMeshes is correct
std::vector< smtk::mesh::MeshSet > results;
for(int i=0; i < 3; ++i)
{
smtk::mesh::DimensionType dt = static_cast<smtk::mesh::DimensionType>(i);
results.push_back( c->createMesh( c->cells( dt ) ) );
}
test( (numMeshesBeforeCreation + 3) == c->numberOfMeshes());
for(int i=0; i < results.size(); ++i)
{
cleanup(c, results[i]);
}
}
//----------------------------------------------------------------------------
void verify_create_mesh_updated_mesh_queries(const smtk::mesh::CollectionPtr& c)
{
const std::size_t numMeshesBeforeCreation = c->numberOfMeshes();
smtk::mesh::CellSet allNonVolumeCells =
smtk::mesh::set_difference(c->cells(), c->cells( smtk::mesh::Dims3 ) );
smtk::mesh::MeshSet result = c->createMesh( allNonVolumeCells );
test( (numMeshesBeforeCreation + 1) == c->numberOfMeshes());
//The meshset returned from create should entirely be contained within
//all the meshes in the collection
smtk::mesh::MeshSet intersect = smtk::mesh::set_intersect(c->meshes(), result );
test( intersect == result );
//The meshset returned from create should entirely be contained within
//all the meshes that have 2d cells
intersect = smtk::mesh::set_intersect(c->meshes(smtk::mesh::Dims2), result );
test( intersect == result );
cleanup(c, result);
}
//----------------------------------------------------------------------------
void verify_create_mesh_num_cells(const smtk::mesh::CollectionPtr& c)
{
const std::size_t numCellsBeforeCreation = c->cells().size();
smtk::mesh::CellSet allNonVolumeCells =
smtk::mesh::set_difference(c->cells(), c->cells( smtk::mesh::Dims3 ) );
smtk::mesh::MeshSet result = c->createMesh( allNonVolumeCells );
test( result.size() == 1, "valid cellset should create meshset with single mesh");
test( numCellsBeforeCreation == c->cells().size());
cleanup(c, result);
}
}
//----------------------------------------------------------------------------
int UnitTestCreateMesh(int, char** const)
{
smtk::mesh::ManagerPtr mngr = smtk::mesh::Manager::create();
smtk::mesh::CollectionPtr c = load_mesh(mngr);
verify_create_empty_mesh(c);
verify_create_mesh_with_cells_from_other_collection(mngr,c);
verify_create_mesh_with_invalid_cell_ids(c);
verify_create_mesh(c);
verify_create_mesh_num_meshes(c);
verify_create_mesh_updated_mesh_queries(c);
verify_create_mesh_num_cells(c);
return 0;
}
| 34.160804 | 91 | 0.620035 | [
"mesh",
"vector"
] |
6f340a57388903f56b39128297731d8f5f10a892 | 1,732 | cpp | C++ | cpp/Selecting Courses/Selecting Courses.cpp | xuzishan/Algorithm-learning-through-Problems | 4aee347af6fd7fd935838e1cbea57c197e88705c | [
"MIT"
] | 27 | 2016-11-04T09:18:25.000Z | 2022-02-12T12:34:01.000Z | cpp/Selecting Courses/Selecting Courses.cpp | Der1128/Algorithm-learning-through-Problems | 4aee347af6fd7fd935838e1cbea57c197e88705c | [
"MIT"
] | 1 | 2016-11-05T02:30:24.000Z | 2016-11-16T10:21:09.000Z | cpp/Selecting Courses/Selecting Courses.cpp | Der1128/Algorithm-learning-through-Problems | 4aee347af6fd7fd935838e1cbea57c197e88705c | [
"MIT"
] | 20 | 2016-11-04T10:26:02.000Z | 2021-09-25T05:41:21.000Z | //
// Selecting Courses.cpp
// laboratory
//
// Created by 徐子珊 on 15/6/15.
// Copyright (c) 2015年 xu_zishan. All rights reserved.
//
#include <iostream>
#include <fstream>
#include <string>
#include "../utility/maxflow.h"
pair<Network , vector<vector<int>>> makeGraph(vector<vector<pair<int, int>>> &course){
int n=course.size(), N=n+86;
Network G(N);
vector<vector<int>> c(N, vector<int>(N));
for (int l=1; l<=n; l++) {
G.insertEdge(0, l);
c[0][l]=1;
}
for (int l=1; l<=n; l++) {
int t=course[l-1].size();
for (int j=0; j<t; j++){
int p=course[l-1][j].first, q=course[l-1][j].second;
int r=n+(p-1)*12+q;
G.insertEdge(l, r);
c[l][r]=1;
}
}
for (int r=n+1; r<N-1; r++) {
G.insertEdge(r, N-1);
c[r][N-1]=1;
}
return make_pair(G, c);
}
int selectingCourse(vector<vector<pair<int, int>>> &course) {
int n=course.size(), N=n+86;
pair<Network, vector<vector<int>>> p=makeGraph(course);
Network G=p.first;
vector<vector<int>> c=p.second;
int f=maxFlow(G, c, 0, N-1);
return f;
}
int main(){
ifstream inputdata("Selecting Courses/inputdata.txt");
ofstream outputdata("Selecting Courses/outputdata.txt");
int n;
while(inputdata>>n){
vector<vector<pair<int, int>>> course(n, vector<pair<int, int>>());
for(int i=0; i<n; i++){
int t;
inputdata>>t;
for(int j=0; j<t; j++){
int p, q;
inputdata>>p>>q;
course[i].push_back(make_pair(p, q));
}
}
int result=selectingCourse(course);
outputdata<<result<<endl;
cout<<result<<endl;
}
inputdata.close();
outputdata.close();
return 0;
} | 26.646154 | 87 | 0.550808 | [
"vector"
] |
6f36453ad85cd871ca6519d7c808862660c288f9 | 3,538 | cpp | C++ | src/tests/ascent/t_ascent_web_main.cpp | srini009/ascent | 70558059dc3fe514206781af6e48715d8934c37c | [
"BSD-3-Clause"
] | null | null | null | src/tests/ascent/t_ascent_web_main.cpp | srini009/ascent | 70558059dc3fe514206781af6e48715d8934c37c | [
"BSD-3-Clause"
] | null | null | null | src/tests/ascent/t_ascent_web_main.cpp | srini009/ascent | 70558059dc3fe514206781af6e48715d8934c37c | [
"BSD-3-Clause"
] | null | null | null | //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
// Copyright (c) Lawrence Livermore National Security, LLC and other Ascent
// Project developers. See top-level LICENSE AND COPYRIGHT files for dates and
// other details. No copyright assignment is required to contribute to Ascent.
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
//-----------------------------------------------------------------------------
///
/// file: t_ascent_web.cpp
///
//-----------------------------------------------------------------------------
#include "gtest/gtest.h"
#include <ascent.hpp>
#include <iostream>
#include <math.h>
#include <conduit_blueprint.hpp>
#include "t_config.hpp"
#include "t_utils.hpp"
using namespace std;
using namespace conduit;
using namespace ascent;
const float64 PI_VALUE = 3.14159265359;
bool launch_server = false;
bool use_doc_root = false;
std::string doc_root = "";
#include <flow.hpp>
//-----------------------------------------------------------------------------
TEST(ascent_web, test_ascent_main_web_launch)
{
// this test launches a web server and infinitely streams images from
// ascent we only run it if we passed proper command line arg
if(!launch_server)
{
return;
}
//
// Create example mesh.
//
Node data, verify_info;
conduit::blueprint::mesh::examples::braid("hexs",100,100,100,data);
EXPECT_TRUE(conduit::blueprint::mesh::verify(data,verify_info));
string output_path = prepare_output_dir();
string output_file = conduit::utils::join_file_path(output_path,"tout_render_3d_web_main_runtime");
// remove old images before rendering
remove_test_image(output_file);
//
// Create the actions.
//
conduit::Node scenes;
scenes["s1/plots/p1/type"] = "pseudocolor";
scenes["s1/plots/p1/field"] = "braid";
scenes["s1/image_prefix"] = output_file;
conduit::Node actions;
conduit::Node &add_plots = actions.append();
add_plots["action"] = "add_scenes";
add_plots["scenes"] = scenes;
actions.print();
// we want the "flow" runtime
Node open_opts;
open_opts["runtime/type"] = "ascent";
open_opts["web/stream"] = "true";
if(use_doc_root)
{
open_opts["web/document_root"] = doc_root;
}
open_opts["ascent_info"] = "verbose";
Ascent ascent;
ascent.open(open_opts);
uint64 *cycle_ptr = data["state/cycle"].value();
float64 *time_ptr = data["state/time"].value();
ascent.publish(data);
ascent.execute(actions);
while(true)
{
cycle_ptr[0]+=1;
time_ptr[0] = PI_VALUE * cycle_ptr[0];
ASCENT_INFO(data["state"].to_json());
// publish the same mesh data, but update the state info
actions.reset();
ascent.publish(data);
ascent.execute(actions);
conduit::utils::sleep(1000);
}
ascent.close();
}
//-----------------------------------------------------------------------------
int main(int argc, char* argv[])
{
int result = 0;
::testing::InitGoogleTest(&argc, argv);
for(int i=0; i < argc ; i++)
{
std::string arg_str(argv[i]);
if(arg_str == "launch")
{
launch_server = true;;
}
else if(arg_str == "doc_root" && (i+1 < argc) )
{
use_doc_root = true;
doc_root = std::string(argv[i+1]);
i++;
}
}
result = RUN_ALL_TESTS();
return result;
}
| 24.741259 | 103 | 0.541266 | [
"mesh"
] |
6f375051f42ceb7cc4084166296627090e0330cf | 2,843 | cpp | C++ | test/performance/saxpy_b.cpp | karl-lunarg/vulkan-compute-example | 1f31b2ce7312b4c16f1561f593c70560c2e8cd22 | [
"MIT"
] | 42 | 2018-07-31T13:43:32.000Z | 2022-03-27T14:46:45.000Z | test/performance/saxpy_b.cpp | karl-lunarg/vulkan-compute-example | 1f31b2ce7312b4c16f1561f593c70560c2e8cd22 | [
"MIT"
] | 1 | 2018-04-17T08:34:27.000Z | 2018-04-17T08:34:27.000Z | test/performance/saxpy_b.cpp | karl-lunarg/vulkan-compute-example | 1f31b2ce7312b4c16f1561f593c70560c2e8cd22 | [
"MIT"
] | 5 | 2019-11-09T13:07:55.000Z | 2021-11-12T23:22:36.000Z | #include <sltbench/Bench.h>
#include <example_filter.h>
#include <vulkan_helpers.hpp>
#include <memory>
#include <vector>
namespace {
struct Params{
uint32_t width;
uint32_t height;
float a;
auto operator== (const Params& other) const-> bool {
return width == other.width && height == other.height && a == other.a;
}
auto operator!= (const Params& other) const-> bool { return !(*this == other); }
friend auto operator<< (std::ostream& s, const Params& p)-> std::ostream& {
s << "{" << p.width << ", " << p.height << ", " << p.a << "}";
return s;
}
};
struct DataFixFull {
ExampleFilter f{"shaders/saxpy.spv"};
Params p;
std::vector<float> y;
std::vector<float> x;
};
struct FixSaxpyFull: private DataFixFull {
using Type = DataFixFull;
auto SetUp(const Params& p)-> Type& {
if(p != this->p) {
this->p = p;
y = std::vector<float>(p.width*p.height, 3.1f);
x = std::vector<float>(p.width*p.height, 1.9f);
}
return *this;
}
auto TearDown()-> void {}
}; // class FixSaxpyFull
struct FixShaderOnly: private DataFixFull {
using Type = ExampleFilter;
struct DeviceData{
explicit DeviceData(const DataFixFull& d)
: d_y{vuh::Array<float>::fromHost(d.y, d.f.device, d.f.physDevice)}
, d_x{vuh::Array<float>::fromHost(d.x, d.f.device, d.f.physDevice)}
{}
vuh::Array<float> d_y;
vuh::Array<float> d_x;
};
auto SetUp(const Params& p)-> Type& {
if(p != this->p){
this->p = p;
y = std::vector<float>(p.width*p.height, 3.1f);
x = std::vector<float>(p.width*p.height, 1.9f);
f.unbindParameters();
_dev_data = std::make_unique<DeviceData>(static_cast<const DataFixFull&>(*this));
f.bindParameters(_dev_data->d_y, _dev_data->d_x, {p.width, p.height, p.a});
}
return f;
}
auto TearDown()-> void {}
private:
std::unique_ptr<DeviceData> _dev_data;
}; // struct FixShaderOnly
/// Copy arrays data to gpu device, setup the kernel and run it.
auto saxpy(DataFixFull& fix, const Params& p)-> void {
auto d_y = vuh::Array<float>::fromHost(fix.y, fix.f.device, fix.f.physDevice);
auto d_x = vuh::Array<float>::fromHost(fix.x, fix.f.device, fix.f.physDevice);
fix.f(d_y, d_x, {fix.p.width, fix.p.height, fix.p.a});
}
/// Just run the kernel, assumes the data has been copied and shader is all set up.
auto saxpy(ExampleFilter& f, const Params& p)-> void {
f.run();
}
static const auto params = std::vector<Params>({{32u, 32u, 2.f}, {128, 128, 2.f}, {1024, 1024, 3.f}});
} // namespace
SLTBENCH_FUNCTION_WITH_FIXTURE_AND_ARGS(saxpy, FixSaxpyFull, params);
SLTBENCH_FUNCTION_WITH_FIXTURE_AND_ARGS(saxpy, FixShaderOnly, params);
SLTBENCH_MAIN();
| 27.336538 | 102 | 0.610271 | [
"vector"
] |
6f3c219989884545b8f131464c75c269ea61530f | 20,446 | cpp | C++ | InSight/src/InSight/Shader/BaseShader.cpp | I-Hudson/InSightEngine | a766c87a7be51a19ab796a81888fbbf93a8a43be | [
"Apache-2.0"
] | 3 | 2019-05-26T19:22:27.000Z | 2019-07-09T21:42:18.000Z | InSight/src/InSight/Shader/BaseShader.cpp | I-Hudson/InSightEngine | a766c87a7be51a19ab796a81888fbbf93a8a43be | [
"Apache-2.0"
] | 15 | 2019-05-26T09:32:22.000Z | 2019-06-11T11:31:03.000Z | InSight/src/InSight/Shader/BaseShader.cpp | I-Hudson/Insight-Engine | a766c87a7be51a19ab796a81888fbbf93a8a43be | [
"Apache-2.0"
] | null | null | null | #include "Shader/BaseShader.h"
#include "Utilities.h"
#include "Log.h"
#include "Entity/Entity.h"
#include "Component/MeshComponent.h"
#include <glm/ext.hpp>
using namespace::InSight;
void BaseShader::setLightVolumeManager(LightVolumeManager * aManager)
{
//set light volume manager
mLightVolumes = aManager;
}
BaseShader::BaseShader()
{
//set gbuffer and mode to render
mGBuffer = nullptr;
mModeToRender = RenderMode::Opaque;
}
BaseShader::BaseShader(const char* aVertexPath, const char* aControlpath, const char* aEvaluationpath, const char* aGeometryPath, const char* aFragmentPath,
unsigned int aInputCount /*= 3*/, const char* aInputs[] /*= nullptr*/, unsigned int aOutputCount /*= 1*/, const char* aOutputs[]/*= nullptr*/)
{
//load all shaders
unsigned int vertex = Utility::loadShader(aVertexPath, GL_VERTEX_SHADER);
unsigned int control = Utility::loadShader(aControlpath, GL_TESS_CONTROL_SHADER);
unsigned int evaluation = Utility::loadShader(aEvaluationpath, GL_TESS_EVALUATION_SHADER);
unsigned int geometry = Utility::loadShader(aGeometryPath, GL_GEOMETRY_SHADER);
unsigned int fragment = Utility::loadShader(aFragmentPath, GL_FRAGMENT_SHADER);
//const char* szInputs[] = { "Position", "Color", "Normal", "Tangnet", "Bitangent", "TexCoord1" };
const char* szInputs[] = { "Position", "Normal", "TexCoord1" };
const char* szOutputs[] = { "FragColour" };
//create program
mShaderID = Utility::createProgram(
vertex,
control,
evaluation,
geometry,
fragment,
aInputCount,
aInputs != nullptr ? aInputs : szInputs,
aOutputCount,
aOutputs != nullptr ? aOutputs : szOutputs);
//delete shaders
glDeleteShader(vertex);
glDeleteShader(control);
glDeleteShader(evaluation);
glDeleteShader(geometry);
glDeleteShader(fragment);
//reserve splace for the vector
//mMeshes.reserve(16);
//set gbuffer and mode to render
mGBuffer = nullptr;
mModeToRender = RenderMode::Opaque;
}
BaseShader::~BaseShader()
{
}
void BaseShader::destroy()
{
//delete/destroy
glDeleteProgram(mShaderID);
glDeleteFramebuffers(1, &mFrameBuffer);
mBoolUniforms.clear();
mUnsignedIntUniforms.clear();
mFloatUniforms.clear();
mVec2Uniforms.clear();
mVec3Uniforms.clear();
mVec4Uniforms.clear();
mMat2Uniforms.clear();
mMat3Uniforms.clear();
mMat4Uniforms.clear();
for (auto& t : mFrameBufferTextures)
{
glDeleteTextures(1, &t.mTexture);
}
mFrameBufferTextures.clear();
if (mGBuffer != nullptr && !mGBuffer->hasBeenDeleted())
{
mGBuffer->destroy();
delete mGBuffer;
}
mMeshComponent = nullptr;
mMeshes.clear();
EN_TRACE("BaseShader Has Been Deleted");
}
void BaseShader::addMesh(MeshComponent* aMesh)
{
bool found = false;
short insertLocation = 0;
//loop thought all current meshes
for(int i = 0; i < mMeshes.size(); ++i)
{
//if we find the the mesh we want to add
//then break
if (mMeshes[i] == aMesh)
{
found = true;
break;
}
//get the position of the mesh. If it is closer to the center of the world
//insert before current mesh
glm::vec3 newMeshVec3 = *aMesh->entity->getComponent<TransformComponent>()->getPosition();
float newMeshDist = glm::distance(newMeshVec3, glm::vec3(0, 0, 0));
glm::vec3 currentMeshVec3 = *mMeshes[i]->entity->getComponent<TransformComponent>()->getPosition();
float currentMeshDist = glm::distance(currentMeshVec3, glm::vec3(0, 0, 0));
if (newMeshDist < currentMeshDist)
{
insertLocation = i;
}
}
if (!found)
{
//if aMesh is not found add it
mMeshes.insert(mMeshes.begin() + 0, aMesh);
}
}
void BaseShader::removeMesh(MeshComponent* aMesh)
{
if (std::find(mMeshes.begin(), mMeshes.end(), aMesh) != mMeshes.end())
{
//if aMesh is not found add it
//mMeshes.(aMesh);
}
}
bool compareDistance(MeshComponent* aM1, MeshComponent* aM2)
{
//compare the distance between two meshes
glm::vec3 newMeshVec3 = *aM1->entity->getComponent<TransformComponent>()->getPosition();
float newMeshDist = glm::distance(newMeshVec3, glm::vec3(0, 0, 0));
glm::vec3 currentMeshVec3 = *aM2->entity->getComponent<TransformComponent>()->getPosition();
float currentMeshDist = glm::distance(currentMeshVec3, glm::vec3(0, 0, 0));
return newMeshDist < currentMeshDist;
}
void BaseShader::sortMeshOrder()
{
//sort all meshes
std::sort(mMeshes.begin(), mMeshes.end(), compareDistance);
}
void BaseShader::setDrawBuffers()
{
//set the draw buffers
glDrawBuffers(drawBuffers.size(), drawBuffers.data());
}
void BaseShader::drawMeshes(const bool& aBindTextures, const glm::mat4& aModelMatrx)
{
//draw all meshes
for (unsigned int i = 0; i < mMeshes.size(); ++i)
{
mMeshes[i]->draw(this, aModelMatrx, aBindTextures);
}
}
void BaseShader::drawMeshes(std::vector<MeshComponent*>& aMeshes, const bool& aBindTextures, const glm::mat4& aModelMatrx)
{
//draw all meshes
for (unsigned int i = 0; i < aMeshes.size(); ++i)
{
if (aMeshes[i]->getRenderMode() == mModeToRender)
{
aMeshes[i]->draw(this, aModelMatrx, aBindTextures);
}
}
}
void BaseShader::gui()
{
if (ImGui::CollapsingHeader("BaseShader"))
{
}
}
void BaseShader::useShader(bool aClear, const bool& aActiveTextures, Entity* aE)
{
//if clear is true clear
if (aClear)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
glUseProgram(mShaderID);
setUniforms();
//get all mesh components. if they are the same render mode draw them
std::vector<MeshComponent*> allMeshes = aE->getEntityManger()->getAllEntityComponents<MeshComponent>();
for (unsigned int i = 0; i < allMeshes.size(); ++i)
{
if (allMeshes[i]->getRenderMode() == mModeToRender)
{
allMeshes[i]->draw(this, glm::mat4(), aActiveTextures);
}
}
glUseProgram(0);
}
void BaseShader::useShader(bool aClear /* = false */, const bool& aActiveTextures /*= true */)
{
//sort meshes
//sortMeshOrder();
//if (mFrameBuffer != -1)
//{
// glBindFramebuffer(GL_FRAMEBUFFER, mFrameBuffer);
//}
//else
//{
// glBindFramebuffer(GL_FRAMEBUFFER, 0);
//}
//if (aClear)
//{
// //bind framebuffer
// if (mFrameBuffer != -1)
// {
// //glBindFramebuffer(GL_FRAMEBUFFER, mFrameBuffer);
// }
// else
// {
// //glBindFramebuffer(GL_FRAMEBUFFER, 0);
// }
// //clear framebuffer
// //glClearColor(0.25, 0.25, 0.25, 1.0);
// glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//}
//bind gbuffer
if (mGBuffer != nullptr)
{
mGBuffer->bindBuffer();
}
else
{
//glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
//if clear is true, clear
if (aClear)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
glUseProgram(mShaderID);
setUniforms();
//get all mesh components. if they are the same render mode draw them
std::vector<MeshComponent*> allMeshes = mMeshComponent->entity->getEntityManger()->getAllEntityComponents<MeshComponent>();
for (unsigned int i = 0; i < allMeshes.size(); ++i)
{
if (allMeshes[i]->getRenderMode() == mModeToRender)
{
allMeshes[i]->draw(this, glm::mat4(), aActiveTextures);
}
}
glUseProgram(0);
}
void BaseShader::useShader(bool aClear, const int& aDrawMode)
{
//if clear is true, clear
if (aClear)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
glUseProgram(mShaderID);
setUniforms();
//std::vector<MeshComponent*> allMeshes = mMeshComponent->entity->getEntityManger()->getAllEntityComponents<MeshComponent>();
//draw all meshes
for (unsigned int i = 0; i < mMeshes.size(); ++i)
{
if (mMeshes[i]->getRenderMode() == mModeToRender)
{
mMeshes[i]->draw(aDrawMode, this);
}
}
glUseProgram(0);
}
void BaseShader::useShader(bool aClear /* = false */)
{
//sort meshes
//sortMeshOrder();
//if (mFrameBuffer != -1)
//{
// glBindFramebuffer(GL_FRAMEBUFFER, mFrameBuffer);
//}
//else
//{
// glBindFramebuffer(GL_FRAMEBUFFER, 0);
//}
//if (aClear)
//{
// //bind framebuffer
// if (mFrameBuffer != -1)
// {
// //glBindFramebuffer(GL_FRAMEBUFFER, mFrameBuffer);
// }
// else
// {
// //glBindFramebuffer(GL_FRAMEBUFFER, 0);
// }
// //clear framebuffer
// //glClearColor(0.25, 0.25, 0.25, 1.0);
// glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//}
//if clear is true, clear
if (aClear)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
glUseProgram(mShaderID);
setUniforms();
//std::vector<MeshComponent*> allMeshes = mMeshComponent->entity->getEntityManger()->getAllEntityComponents<MeshComponent>();
//draw all meshes
for (unsigned int i = 0; i < mMeshes.size(); ++i)
{
if (mMeshes[i]->getRenderMode() == mModeToRender)
{
mMeshes[i]->draw(this);
}
}
glUseProgram(0);
}
void BaseShader::useShaderPP(bool aClear)
{
//if clear is true, clear
if (aClear)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
glUseProgram(mShaderID);
setUniforms();
}
void BaseShader::createFrameBuffer()
{
//generate framebuffer
glGenFramebuffers(1, &mFrameBuffer);
}
unsigned int BaseShader::attachTextureToFrameBuffer(int aLevel, int aInternalFormat,
int aWidth, int aHeight,
int aBoarder, GLenum aFormat,
GLenum aType, const void* aPixels,
GLenum aAttachment)
{
//bind buffer
glBindFramebuffer(GL_FRAMEBUFFER, mFrameBuffer);
unsigned int fbo;
//gen texture, set texture props
glGenTextures(1, &fbo);
glBindTexture(GL_TEXTURE_2D, fbo);
glTexImage2D(GL_TEXTURE_2D, aLevel, aInternalFormat, aWidth, aHeight, aBoarder, aFormat, aType, aPixels);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
if (aAttachment == GL_DEPTH_ATTACHMENT)
{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}
glFramebufferTexture(GL_FRAMEBUFFER, aAttachment, fbo, 0);
glBindTexture(GL_TEXTURE_2D, 0);
FBTexture fbTexture;
fbTexture.mTextureSize = glm::vec2(aWidth, aHeight);
fbTexture.mTexture = fbo;
//add texture to mFrameBufferTextures
mFrameBufferTextures.push_back(fbTexture);
//update draw buffers
if (aAttachment != GL_DEPTH_STENCIL_ATTACHMENT &&
aAttachment != GL_COLOR_ATTACHMENT4 && aAttachment != GL_DEPTH_ATTACHMENT)
{
drawBuffers.push_back(aAttachment);
glDrawBuffers(drawBuffers.size(), drawBuffers.data());
//setDrawBuffers();
}
//check status
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (status != GL_FRAMEBUFFER_COMPLETE)
{
printf("Framebuffer Error\n");
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
return fbo;
}
void BaseShader::setMeshComponent(InSight::MeshComponent* aMeshComponent)
{
//set mesh component
mMeshComponent = aMeshComponent;
mMeshes.push_back(aMeshComponent);
}
MeshComponent* BaseShader::getMeshComponent()
{
//get mesh component
return mMeshComponent;
}
void BaseShader::setGBuffer(GBuffer * aGBuffer)
{
//set gbuffer
mGBuffer = aGBuffer;
}
GBuffer* BaseShader::getGBuffer()
{
//get pointer to gbuffer
return mGBuffer;
}
unsigned int* BaseShader::getTexture(int aIndex)
{
//get a texture
if (mFrameBufferTextures.size() > 0)
{
return &mFrameBufferTextures[aIndex].mTexture;
}
else
{
return 0;
}
}
unsigned int BaseShader::numOfTexturesAttached() const
{
//return number of textures attached
return mFrameBufferTextures.size();
}
std::vector<FBTexture>* BaseShader::getAllTextures()
{
//get all texures
return &mFrameBufferTextures;
}
void BaseShader::setBool(const std::string& name, bool& aValue)
{
//glUniform1i(glGetUniformLocation(mShaderID, name.c_str()), (int)value);
//add a new bool uniform
mBoolUniforms.emplace(std::pair<std::string, bool*>(name, &aValue));
}
// ------------------------------------------------------------------------
void BaseShader::setUnsignedIntUniforms(const std::string &aName, unsigned int& aValue)
{
//glUniform1i(glGetUniformLocation(mShaderID, name.c_str()), value);
//add a new unsigned int uniform
mUnsignedIntUniforms.emplace(std::pair<std::string, unsigned int*>(aName, &aValue));
}
void BaseShader::setUnsignedIntUniformsOverride(const std::string& aName, unsigned int& aValue)
{
//find uniform with aName
std::map< std::string, unsigned int*>::iterator it = mUnsignedIntUniforms.find(aName);
if (it != mUnsignedIntUniforms.end())
{
//if uniform found set it's value to aValue
mUnsignedIntUniforms[aName] = &aValue;
}
else
{
//add a new unsigned int uniform
mUnsignedIntUniforms.emplace(std::pair<std::string, unsigned int*>(aName, &aValue));
}
}
// ------------------------------------------------------------------------
void BaseShader::setFloat(const std::string& name, float& value, bool aSetEveryFrame /*= false*/)
{
//if aSetEveryFrame is true then all set uniform for this frame
if (aSetEveryFrame)
{
unsigned int loc = glGetUniformLocation(mShaderID, name.c_str());
glUniform1f(loc, value);
return;
}
//glUniform1f(glGetUniformLocation(mShaderID, name.c_str()), value);
//add a new float int uniform
mFloatUniforms.emplace(std::pair<std::string, float*>(name, &value));
}
void BaseShader::setFloatOverride(const std::string & aName, float & aValue)
{
//find uniform with aName
std::map< std::string, float*>::iterator it = mFloatUniforms.find(aName);
if (it != mFloatUniforms.end())
{
//if uniform found set it's value to aValue
mFloatUniforms[aName] = &aValue;
}
else
{
//add a new float uniform
mFloatUniforms.emplace(std::pair<std::string, float*>(aName, &aValue));
}
}
// ------------------------------------------------------------------------
void BaseShader::setVec2(const std::string& name, glm::vec2& value)
{
//glUniform2fv(glGetUniformLocation(mShaderID, name.c_str()), 1, &value[0]);
//add a new vec2 uniform
mVec2Uniforms.emplace(std::pair<std::string, glm::vec2*>(name, &value));
}
void BaseShader::setVec2(const std::string& name, float x, float y)
{
//glUniform2f(glGetUniformLocation(mShaderID, name.c_str()), x, y);
//mVec2Uniforms.insert(std::pair<std::string, std::shared_ptr<glm::vec2>>(name,
// std::make_shared<glm::vec2>(glm::vec2(x,y))));
}
// ------------------------------------------------------------------------
void BaseShader::setVec3(const std::string& name, glm::vec3& value, bool aSetEveryFrame /*= false*/)
{
//if aSetEveryFrame is true then all set uniform for this frame
if (aSetEveryFrame)
{
unsigned int loc = glGetUniformLocation(mShaderID, name.c_str());
glUniform3fv(loc, 1, glm::value_ptr(value));
return;
}
//glUniform3fv(glGetUniformLocation(mShaderID, name.c_str()), 1, &value[0]);
//add a new vec3 uniform
mVec3Uniforms.emplace(std::pair<std::string, glm::vec3*>(name, &value));
}
void BaseShader::setVec3(const std::string& name, float x, float y, float z)
{
//glUniform3f(glGetUniformLocation(mShaderID, name.c_str()), x, y, z);
//mVec3Uniforms.insert(std::pair<std::string, std::shared_ptr<glm::vec3>>(name,
// std::make_shared<glm::vec3>(glm::vec3(x, y, z))));
}
// ------------------------------------------------------------------------
void BaseShader::setVec4(const std::string& name, glm::vec4& value, bool aSetEveryFrame /*= false*/)
{
//if aSetEveryFrame is true then all set uniform for this frame
if (aSetEveryFrame)
{
unsigned int loc = glGetUniformLocation(mShaderID, name.c_str());
glUniform4fv(loc, 1, glm::value_ptr(value));
return;
}
//glUniform4fv(glGetUniformLocation(mShaderID, name.c_str()), 1, &value[0]);
//add a new vec4 uniform
mVec4Uniforms.emplace(std::pair<std::string, glm::vec4*>(name, &value));
}
void BaseShader::setVec4(const std::string & name, float x, float y, float z, float w)
{
//glUniform4f(glGetUniformLocation(mShaderID, name.c_str()), x, y, z, w);
//mVec2Uniforms.emplace(std::pair<std::string, glm::mat3*>(name, &mat));
}
// ------------------------------------------------------------------------
void BaseShader::setMat2(const std::string& name, glm::mat2& mat)
{
//glUniformMatrix2fv(glGetUniformLocation(mShaderID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
//add a new mat2 uniform
mMat2Uniforms.emplace(std::pair<std::string, glm::mat2*>(name, &mat));
}
// ------------------------------------------------------------------------
void BaseShader::setMat3(const std::string& name, glm::mat3& mat)
{
//glUniformMatrix3fv(glGetUniformLocation(mShaderID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
//add a new vec3 uniform
mMat3Uniforms.emplace(std::pair<std::string, glm::mat3*>(name, &mat));
// ------------------------------------------------------------------------
}
// ------------------------------------------------------------------------
void BaseShader::setMat4(const std::string& aName, glm::mat4& aMat, bool aSetEveryFrame /*= false*/)
{
//unsigned int uniformLoc = glGetUniformLocation(mShaderID, name.c_str());
//glUniformMatrix4fv(uniformLoc, 1, GL_FALSE, glm::value_ptr(mat));
//if aSetEveryFrame is true then all set uniform for this frame
if (aSetEveryFrame)
{
unsigned int loc = glGetUniformLocation(mShaderID, aName.c_str());
glUniformMatrix4fv(loc, 1, false, glm::value_ptr(aMat));
return;
}
bool add = true;
//if mat4 is found update it's value
for(auto& mat4 : mMat4Uniforms)
{
if (mat4.first == aName)
{
mat4.second = &aMat;
add = false;
break;
}
}
if (add)
{
//add a new mat4 uniform
mMat4Uniforms.emplace(std::pair<std::string, glm::mat4*>(aName, &aMat));
}
}
void BaseShader::setMat4Override(const std::string & aName, glm::mat4 & aMat)
{
//find uniform with aName
std::map< std::string, glm::mat4*>::iterator it = mMat4Uniforms.find(aName);
if (it != mMat4Uniforms.end())
{
//if uniform found set it's value to aMat
mMat4Uniforms[aName] = &aMat;
}
else
{
mMat4Uniforms.emplace(std::pair<std::string, glm::mat4*>(aName, &aMat));
}
}
void BaseShader::setBaseRenderer(BaseRenderer* aBaseRenderer)
{
//set BaseRenderer
mBaseRenderer = aBaseRenderer;
}
BaseRenderer* BaseShader::getBaseRenderer()
{
//get pointer to BaseRenderer
return mBaseRenderer;
}
void BaseShader::setUniforms(unsigned int aProgramID)
{
//set all unioforms
//get program
unsigned int program = aProgramID == -1 ? mShaderID : aProgramID;
//for though all uniforms store of it's tpye
for (std::map<std::string, bool*>::iterator it = mBoolUniforms.begin();
it != mBoolUniforms.end(); ++it)
{
//get the uniform location, then set it;s value
unsigned int loc = glGetUniformLocation(program, it->first.c_str());
float v = *it->second;
glUniform1f(loc, v);
}
int index = 0;
for (std::map<std::string, unsigned int*>::iterator it = mUnsignedIntUniforms.begin();
it != mUnsignedIntUniforms.end(); ++it)
{
glActiveTexture(GL_TEXTURE0 + index);
unsigned int loc = glGetUniformLocation(program, it->first.c_str());
glUniform1i(loc, index);
unsigned int i = *it->second;
glBindTexture(GL_TEXTURE_2D, i);
index++;
}
for (std::map<std::string, float*>::iterator it = mFloatUniforms.begin();
it != mFloatUniforms.end(); ++it)
{
unsigned int loc = glGetUniformLocation(program, it->first.c_str());
glUniform1f(loc, *it->second);
}
for (std::map<std::string, glm::vec2*>::iterator it = mVec2Uniforms.begin();
it != mVec2Uniforms.end(); ++it)
{
unsigned int loc = glGetUniformLocation(program, it->first.c_str());
glUniform2fv(loc, 1, glm::value_ptr(*it->second));
}
for (std::map<std::string, glm::vec3*>::iterator it = mVec3Uniforms.begin();
it != mVec3Uniforms.end(); ++it)
{
unsigned int loc = glGetUniformLocation(program, it->first.c_str());
glUniform3fv(loc, 1, glm::value_ptr(*it->second));
}
for (std::map<std::string, glm::vec4*>::iterator it = mVec4Uniforms.begin();
it != mVec4Uniforms.end(); ++it)
{
unsigned int loc = glGetUniformLocation(program, it->first.c_str());
glUniform4fv(loc, 1, glm::value_ptr(*it->second));
}
for (std::map<std::string, glm::mat2*>::iterator it = mMat2Uniforms.begin();
it != mMat2Uniforms.end(); ++it)
{
unsigned int loc = glGetUniformLocation(program, it->first.c_str());
glUniformMatrix2fv(loc, 1, false, glm::value_ptr(*it->second));
}
for (std::map<std::string, glm::mat3*>::iterator it = mMat3Uniforms.begin();
it != mMat3Uniforms.end(); ++it)
{
unsigned int loc = glGetUniformLocation(program, it->first.c_str());
glUniformMatrix3fv(loc, 1, false, glm::value_ptr(*it->second));
}
for (std::map<std::string, glm::mat4*>::iterator it = mMat4Uniforms.begin();
it != mMat4Uniforms.end(); ++it)
{
unsigned int loc = glGetUniformLocation(program, it->first.c_str());
glUniformMatrix4fv(loc, 1, false, glm::value_ptr(*it->second));
}
}
| 27.29773 | 156 | 0.683019 | [
"mesh",
"geometry",
"render",
"vector"
] |
6f3dc6146a00981db88986c6a022cbf5a69a5e4a | 7,262 | cpp | C++ | integrators/pathtracer.cpp | capagot/swpathtracer | 613045f5bf75e0295a5cdcc60bebdfb8a534f4ae | [
"MIT"
] | 14 | 2016-08-11T19:15:18.000Z | 2022-02-11T18:32:37.000Z | integrators/pathtracer.cpp | capagot/swpathtracer | 613045f5bf75e0295a5cdcc60bebdfb8a534f4ae | [
"MIT"
] | null | null | null | integrators/pathtracer.cpp | capagot/swpathtracer | 613045f5bf75e0295a5cdcc60bebdfb8a534f4ae | [
"MIT"
] | null | null | null | #include "pathtracer.h"
#include "timer.h"
PathTracer::PathTracer(Camera& camera, const Scene& scene, PathTerminationCriterion path_termination_criterion,
int path_length, std::unique_ptr<PixelSampler> pixel_sampler,
PRNG<std::uniform_real_distribution, float, std::mt19937>& prng)
: Integrator(camera, scene, Integrator::Type::PATHTRACER, std::move(pixel_sampler)),
path_length_(path_length),
path_termination_criterion_(path_termination_criterion),
prng_(prng) {}
glm::vec3 PathTracer::traceRay(const Ray& world_ray, int depth, std::size_t& num_intersection_tests,
std::size_t& num_intersections) {
IntersectionRecord intersection_record;
intersection_record.t_ = std::numeric_limits<float>::infinity();
glm::vec3 radiance(0.0f);
if ((path_termination_criterion_ == PathTerminationCriterion::MAX_DEPTH) && (depth >= path_length_))
return glm::vec3(0.0f); // returns zero radiance
if (!scene_.intersect(world_ray, intersection_record, num_intersection_tests, num_intersections)) {
if (!depth) // If it is a primary ray (depth == 0), returns the background color
return scene_.getBackgroundColor();
else // If it is not a primary ray, returns zero radiance
return glm::vec3(0.0f);
}
ONB local_frame(intersection_record.normal_);
glm::vec3 local_wo = glm::normalize(local_frame.getWorldToLocalMatrix() * -world_ray.getDirection());
glm::vec3 local_wi;
float pdf;
glm::vec3 bsdf;
glm::vec3 reflectance;
scene_.getMaterial(intersection_record.material_id_).evalBSDF(local_wo, bsdf, reflectance, pdf, local_wi);
glm::vec3 world_wi = local_frame.getLocalToWorldMatrix() * local_wi;
Ray world_new_ray = Ray(intersection_record.position_ + world_wi * 1e-3f, world_wi);
glm::vec3 emission = scene_.getMaterial(intersection_record.material_id_).getEmission();
float k = std::max(std::max(reflectance[0], reflectance[1]), reflectance[2]);
if ((path_termination_criterion_ == PathTerminationCriterion::RUSSIAN_ROULETTE) && (depth >= path_length_)) {
if ((prng_() < k) &&
(depth < 1000)) // if RR gets crazy and does not stop, force stopping it after 1000 bounces.
bsdf = bsdf / k;
else
return emission;
}
// Rendering Equation estimator
radiance =
emission +
(bsdf * traceRay(world_new_ray, depth + 1, num_intersection_tests, num_intersections) * local_wi.y) / pdf;
return radiance;
}
void PathTracer::render() {
Timer timer;
int_tests_count_ = 0;
int_count_ = 0;
min_int_tests_count_pp_ = std::numeric_limits<std::size_t>::max();
max_int_tests_count_pp_ = 0;
min_int_count_pp_ = std::numeric_limits<std::size_t>::max();
max_int_count_pp_ = 0;
std::cout << "Rendering\n";
std::cout << "--------------------------------------------------------------------------------\n";
#ifndef DEBUG
std::cout << " Threads ........................: " << omp_get_max_threads() << "\n";
#else
std::cout << " Threads ........................: 1\n";
#endif
timer.start();
unsigned int x_ini = camera_.getImageBuffer().getViewportLeft();
unsigned int x_end = x_ini + camera_.getImageBuffer().getViewportWidth();
unsigned int y_ini = camera_.getImageBuffer().getViewportTop();
unsigned int y_end = y_ini + camera_.getImageBuffer().getViewportHeight();
#ifndef DEBUG
#pragma omp parallel for schedule(dynamic, 1) reduction(+ : int_tests_count_, int_count_) reduction(min: min_int_tests_count_pp_, min_int_count_pp_) reduction(max: max_int_tests_count_pp_, max_int_count_pp_)
#endif
// DEBUG
//for (std::size_t i = 0; i < 231214328; ++i )
// float dummy = prng_();
for (unsigned int y = y_ini; y < y_end; ++y)
//unsigned int y = 314;
{
printProgress(y);
for (unsigned int x = x_ini; x < x_end; ++x)
//unsigned int x = 323;
{
std::size_t curr_int_tests_count;
std::size_t curr_int_count;
for (unsigned int sample = 0; sample < pixel_sampler_->getSPP(); ++sample) {
// DEBUG
//if (y > 310)
// std::cout << "[" << x << ", " << y << "] ( sample: " << sample << ") - prng_.aux_count_: " << prng_.aux_count_ << "\n";
float x_screen = x + pixel_sampler_->getSample(sample).x;
float y_screen = y + pixel_sampler_->getSample(sample).y;
Ray ray = camera_.getRay(x_screen, y_screen);
glm::vec3 radiance = traceRay(ray, 0, curr_int_tests_count, curr_int_count);
camera_.getImageBuffer().setPixelValue(x, y, camera_.getImageBuffer().getPixelValue(x, y) + radiance);
}
camera_.getImageBuffer().setPixelValue(
x, y, camera_.getImageBuffer().getPixelValue(x, y) / static_cast<float>(pixel_sampler_->getSPP()));
// update integration statistics...
int_tests_count_ += curr_int_tests_count;
int_count_ += curr_int_count;
min_int_tests_count_pp_ = std::min(min_int_tests_count_pp_, curr_int_tests_count);
max_int_tests_count_pp_ = std::max(max_int_tests_count_pp_, curr_int_tests_count);
min_int_count_pp_ = std::min(min_int_count_pp_, curr_int_count);
max_int_count_pp_ = std::max(max_int_count_pp_, curr_int_count);
}
}
timer.finish();
total_integration_time_ = timer.getElapsedTime();
std::cout << "\n";
std::cout << " Statistics :\n";
std::cout << " Total rendering time .........: " << total_integration_time_ << " usec\n";
std::cout << " Intersection tests ...........: " << int_tests_count_ << "\n";
std::cout << " Min intersection tests pp ..: " << min_int_tests_count_pp_ << "\n";
std::cout << " Max intersection tests pp ..: " << max_int_tests_count_pp_ << "\n";
std::cout << " Intersections ................: " << int_count_ << std::fixed << std::setprecision(2) << " ("
<< (100.0f * int_count_) / int_tests_count_ << "% of all intersection tests)\n";
std::cout << " Min intersections pp .......: " << min_int_count_pp_ << "\n";
std::cout << " Max intersections pp .......: " << max_int_count_pp_ << "\n";
std::cout << "\n";
}
void PathTracer::saveImageToFile() {
camera_.getImageBuffer().convertTosRGB();
camera_.getImageBuffer().saveToFile();
}
void PathTracer::printProgress(unsigned int y) {
std::stringstream progress_stream;
// progress_stream << "\r Progress .......................: " << std::fixed << std::setw(6) << std::setprecision(2)
// << 100.0f * y / (camera_.getImageBuffer().getViewportTop() + camera_.getImageBuffer().getViewportHeight() - 1)
// << "%";
progress_stream << "\r Progress .......................: " << std::fixed << std::setw(6) << std::setprecision(2)
<< 100.0f * (y - camera_.getImageBuffer().getViewportTop()) / camera_.getImageBuffer().getViewportHeight()
<< "%";
std::clog << progress_stream.str();
}
| 44.280488 | 207 | 0.612779 | [
"render"
] |
6f49500e47447f61f552136e902edc56017e2cd5 | 17,505 | hxx | C++ | main/comphelper/inc/comphelper/locale.hxx | jimjag/openoffice | 74746a22d8cc22b031b00fcd106f4496bf936c77 | [
"Apache-2.0"
] | 1 | 2019-12-27T19:25:34.000Z | 2019-12-27T19:25:34.000Z | main/comphelper/inc/comphelper/locale.hxx | ackza/openoffice | d49dfe9c625750e261c7ed8d6ccac8d361bf3418 | [
"Apache-2.0"
] | 1 | 2019-11-25T03:08:58.000Z | 2019-11-25T03:08:58.000Z | main/comphelper/inc/comphelper/locale.hxx | ackza/openoffice | d49dfe9c625750e261c7ed8d6ccac8d361bf3418 | [
"Apache-2.0"
] | 6 | 2019-11-19T00:28:25.000Z | 2019-11-22T06:48:49.000Z | /**************************************************************
*
* 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
*
* 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 _COMPHELPER_LOCALE_HXX_
#define _COMPHELPER_LOCALE_HXX_
//_______________________________________________
// includes
#include <vector>
#include <rtl/ustring.hxx>
#include "comphelper/comphelperdllapi.h"
// These are specified by i386 ABI suppl. but
// only affect Solaris i386/illumos so far.
#if !defined(_XPG4_2) || defined(__EXTENSIONS__)
#undef CS
#undef ES
#endif
//_______________________________________________
// namespace
namespace comphelper{
//_______________________________________________
// definitions
/** @short A Locale object represents a specific geographical, political, or cultural region.
@descr This Locale class can be used to:
- provide the different parts of a Locale (Language, Country, Variant)
- converting it from/to ISO formatted string values (like e.g. "en-US")
- provide some predefined (static) Locale objects
*/
class COMPHELPER_DLLPUBLIC Locale
{
//-------------------------------------------
// const
public:
/** @short separates LANGUAGE and COUNTRY part of an ISO formatted Locale. */
static const sal_Unicode SEPERATOR_LC;
/** @short separates COUNTRY and VARIANT part of an ISO formatted Locale. */
static const sal_Unicode SEPERATOR_CV;
/** @short separates COUNTRY and VARIANT part of an ISO formatted Locale.
@descr Its true for some linux derivates only :-( */
static const sal_Unicode SEPERATOR_CV_LINUX;
/** @short some predefined Locale objects. */
static const Locale& EN_US();
static const Locale& EN();
static const Locale& DE_DE();
static const Locale& DE_CH();
static const Locale& DE_AT();
static const Locale& AR();
static const Locale& CA();
static const Locale& CS();
static const Locale& DA();
static const Locale& EL();
static const Locale& ES();
static const Locale& FI();
static const Locale& FR();
static const Locale& HE();
static const Locale& HI_IN();
static const Locale& HU();
static const Locale& IT();
static const Locale& JA();
static const Locale& KO();
static const Locale& NL();
static const Locale& PL();
static const Locale& PT();
static const Locale& PT_BR();
static const Locale& RU();
static const Locale& SK();
static const Locale& SL();
static const Locale& SV();
static const Locale& TH();
static const Locale& TR();
static const Locale& X_DEFAULT();
static const Locale& X_COMMENT();
static const Locale& X_TRANSLATE();
static const Locale& X_NOTRANSLATE();
static const Locale& ZH_CN();
static const Locale& ZH_TW();
//-------------------------------------------
// types
public:
/** @short will be throw during conversion, if a Locale can't be interpreted. */
struct MalFormedLocaleException
{
public:
::rtl::OUString Message;
MalFormedLocaleException()
{}
MalFormedLocaleException(const ::rtl::OUString& sMessage)
: Message(sMessage)
{}
};
//-------------------------------------------
// member
private :
//---------------------------------------
/** @short must be a valid ISO Language Code.
@descr These codes are the lower-case two-letter codes as defined by ISO-639.
You can find a full list of these codes at a number of sites, such as:
<BR><a href ="http://www.ics.uci.edu/pub/ietf/http/related/iso639.txt">
http://www.ics.uci.edu/pub/ietf/http/related/iso639.txt</a>
*/
::rtl::OUString m_sLanguage;
//---------------------------------------
/** @short must be a valid ISO Country Code.
@descr These codes are the upper-case two-letter codes as defined by ISO-3166.
You can find a full list of these codes at a number of sites, such as:
<BR><a href="http://www.chemie.fu-berlin.de/diverse/doc/ISO_3166.html">
http://www.chemie.fu-berlin.de/diverse/doc/ISO_3166.html</a>
*/
::rtl::OUString m_sCountry;
//---------------------------------------
/** @short Variant codes are vendor and browser-specific.
@descr For example, use WIN for Windows, MAC for Macintosh, and POSIX for POSIX.
Where there are two variants, separate them with an underscore, and
put the most important one first. For example, a Traditional Spanish collation
might be referenced, with "ES", "ES", "Traditional_WIN".
*/
::rtl::OUString m_sVariant;
//-------------------------------------------
// interface
public :
//---------------------------------------
/** @short needed by outside users!
@descr Otherwise it wouldn't be possible to use
any instance of such Locale static ...
*/
Locale();
//---------------------------------------
/** @short construct a Locale from an ISO formatted string value.
@seealso fromISO()
@param sISO
an ISO formatted string value, which can be parsed and
tokenized into a Lamnguage, Country and Variant part.
@throw MalFormedLocaleException
if conversion failed.
*/
Locale(const ::rtl::OUString& sISO)
throw(MalFormedLocaleException);
//---------------------------------------
/** @short construct a Locale from language, country and variant.
@seealso setLanguage()
@seealso setCountry()
@seealso setVariant()
@param sLanguage
lowercase two-letter ISO-639 code.
@param sCountry
uppercase two-letter ISO-3166 code.
@param sVariant
vendor and browser specific code.
*/
Locale(const ::rtl::OUString& sLanguage ,
const ::rtl::OUString& sCountry ,
const ::rtl::OUString& sVariant = ::rtl::OUString());
//---------------------------------------
/** @short copy constructor.
@param aCopy
the copy object.
*/
Locale(const Locale& aCopy);
//---------------------------------------
/** @short returns the language code for this locale.
@descr That will either be the empty string or
a lowercase ISO 639 code.
@return [string]
the language code.
*/
::rtl::OUString getLanguage() const;
//---------------------------------------
/** @short returns the country/region code for this locale.
@descr That will either be the empty string or an
upercase ISO 3166 2-letter code.
@return [string]
the country code.
*/
::rtl::OUString getCountry() const;
//---------------------------------------
/** @short returns the variant code for this locale.
@return [string]
the variant code.
*/
::rtl::OUString getVariant() const;
//---------------------------------------
/** @short set the new language code for this locale.
@descr That will either be the empty string or
a lowercase ISO 639 code.
@param sLanguage
the language code.
*/
void setLanguage(const ::rtl::OUString& sLanguage);
//---------------------------------------
/** @short set the new country/region code for this locale.
@descr That will either be the empty string or an
upercase ISO 3166 2-letter code.
@param sCountry
the country code.
*/
void setCountry(const ::rtl::OUString& sCountry);
//---------------------------------------
/** @short set the new variant code for this locale.
@param sVariant
the variant code.
*/
void setVariant(const ::rtl::OUString& sVariant);
//---------------------------------------
/** @short take over new Locale informations.
@seealso Locale(const ::rtl::OUString& sISO)
@param sISO
an ISO formatted string value, which can be parsed and
tokenized into a Lamnguage, Country and Variant part.
e.g. "en-US" or "en-US_WIN"
@throw MalFormedLocaleException
if conversion failed.
*/
void fromISO(const ::rtl::OUString& sISO)
throw(MalFormedLocaleException);
//---------------------------------------
/** @short converts this Locale to an ISO formatted string value.
@descr The different parts of this Locale will be assempled
e.g. to "en-US" or "en-US_WIN"
@return [string]
the ISO formatted string.
*/
::rtl::OUString toISO() const;
//---------------------------------------
/** @short check, if two Locale objects are equals.
@descr All parts of a Locale (means Language, Country and Variant)
will be checked.
@param aComparable
the Locale object for compare.
@return [boolean]
TRUE if both objects uses the same values for
Language, Country and Variant.
*/
sal_Bool equals(const Locale& aComparable) const;
//---------------------------------------
/** @short check, if two Locale objects
uses the same language.
@descr The Country and Variant parts of a Locale
won't be checked here.
@return [boolean]
TRUE if both objects uses the same
Language value.
*/
sal_Bool similar(const Locale& aComparable) const;
//---------------------------------------
/** @short search for an equal or at least for a similar
Locale in a list of possible ones.
@descr First it searches for a Locale, which is equals
to the reference Locale.
(means: same Language, Country, Variant)
If the reference Locale couldnt be located, it will
tried again - but we are checking for "similar" Locales then.
(means: same Language)
If no similar Locale could be located, we search
for a Locale "en-US" inside the given Locale list.
If "en-US" could not be located, we search for
a Locale "en" inside the given list.
If no "same" nor any "similar" locale could be found,
we try "x-default" and "x-notranslate" explicitly.
Sometimes localized variables are optimized and doesn't use
localzation really. E.g. in case the localized value is a fix
product name.
If no locale match till now, we use any other existing
locale, which exists inside the set of given ones!
@seealso equals()
@seealso similar()
@param lISOList
the list of possible Locales
(as formatted ISO strings).
@param sReferenceISO
the reference Locale, which should be searched
if its equals or similar to any Locale inside
the provided Locale list.
@return An iterator, which points to the found element
inside the given Locale list.
If no matching Locale could be found, it points
to the end of the list.
@throw [MalFormedLocaleException]
if at least one ISO formatted string couldnt
be converted to a valid Locale Object.
*/
static ::std::vector< ::rtl::OUString >::const_iterator getFallback(const ::std::vector< ::rtl::OUString >& lISOList ,
const ::rtl::OUString& sReferenceISO)
throw(MalFormedLocaleException);
//---------------------------------------
/** @short search for the next possible fallback locale.
@descr Instead of getFallback(vector<>, string) this method
uses the given locale and decide by using an algorithm
which locale can be the next possible one.
Algorithm:
- if locale has country return language only
- if locale different "en-US" return "en-US"
- if locale "en-US" return "en"
@param aLocale [in/out]!
the incoming value will be used to start
search for a possible fallback ...
and in case such fallback was found this parameter
will be used for return too.
@return TRUE if the parameter aLocale contains a new fallback value;
FALSE otherwise.
*/
static sal_Bool getFallback(Locale& aLocale);
//---------------------------------------
/** @short assign elements of another locale
to this instance.
@param rCopy
another locale object.
*/
void operator=(const Locale& rCopy);
//---------------------------------------
/** @short check if two Locale objects are equals.
@seealso equals()
@param aComparable
the Locale object for compare.
@return [boolean]
TRUE if both objects uses the same values for
Language, Country and Variant.
*/
sal_Bool operator==(const Locale& aComparable) const;
//---------------------------------------
/** @short check if two Locale objects are different.
@param aComparable
the Locale object for compare.
@return [boolean]
TRUE if at least one part of such Locale
isn't the same.
*/
sal_Bool operator!=(const Locale& aComparable) const;
};
} // namespace salhelper
#endif // _COMPHELPER_LOCALE_HXX_
| 39.073661 | 130 | 0.471694 | [
"object",
"vector"
] |
6f5da7a3c1b6806b18a4acb65ff3198d8f25bb74 | 17,203 | cpp | C++ | src/hand/pose3d/mediapipe/mediapipe.cpp | bububa/openvision | 0864e48ec8e69ac13d6889d41f7e1171f53236dd | [
"Apache-2.0"
] | 1 | 2022-02-08T06:42:05.000Z | 2022-02-08T06:42:05.000Z | src/hand/pose3d/mediapipe/mediapipe.cpp | bububa/openvision | 0864e48ec8e69ac13d6889d41f7e1171f53236dd | [
"Apache-2.0"
] | null | null | null | src/hand/pose3d/mediapipe/mediapipe.cpp | bububa/openvision | 0864e48ec8e69ac13d6889d41f7e1171f53236dd | [
"Apache-2.0"
] | null | null | null | #include "mediapipe.hpp"
#include "mat.h"
#include <math.h>
namespace ovhand3d {
static float calculate_scale(float min_scale, float max_scale, int stride_index,
int num_strides) {
if (num_strides == 1)
return (min_scale + max_scale) * 0.5f;
else
return min_scale +
(max_scale - min_scale) * 1.0 * stride_index / (num_strides - 1.0f);
}
static void generate_anchors(std::vector<Anchor> &anchors,
const AnchorsParams &anchor_params) {
int layer_id = 0;
for (int layer_id = 0; layer_id < anchor_params.strides.size();) {
std::vector<float> anchor_height;
std::vector<float> anchor_width;
std::vector<float> aspect_ratios;
std::vector<float> scales;
int last_same_stride_layer = layer_id;
while (last_same_stride_layer < (int)anchor_params.strides.size() &&
anchor_params.strides[last_same_stride_layer] ==
anchor_params.strides[layer_id]) {
const float scale =
calculate_scale(anchor_params.min_scale, anchor_params.max_scale,
last_same_stride_layer, anchor_params.strides.size());
{
for (int aspect_ratio_id = 0;
aspect_ratio_id < (int)anchor_params.aspect_ratios.size();
aspect_ratio_id++) {
aspect_ratios.push_back(anchor_params.aspect_ratios[aspect_ratio_id]);
scales.push_back(scale);
}
const float scale_next =
last_same_stride_layer == (int)anchor_params.strides.size() - 1
? 1.0f
: calculate_scale(
anchor_params.min_scale, anchor_params.max_scale,
last_same_stride_layer + 1, anchor_params.strides.size());
scales.push_back(sqrt(scale * scale_next));
aspect_ratios.push_back(1.0);
}
last_same_stride_layer++;
}
for (int i = 0; i < (int)aspect_ratios.size(); ++i) {
const float ratio_sqrts = sqrt(aspect_ratios[i]);
anchor_height.push_back(scales[i] / ratio_sqrts);
anchor_width.push_back(scales[i] * ratio_sqrts);
}
int feature_map_height = 0;
int feature_map_width = 0;
const int stride = anchor_params.strides[layer_id];
feature_map_height = ceil(1.0f * anchor_params.input_size_height / stride);
feature_map_width = ceil(1.0f * anchor_params.input_size_width / stride);
for (int y = 0; y < feature_map_height; ++y) {
for (int x = 0; x < feature_map_width; ++x) {
for (int anchor_id = 0; anchor_id < (int)anchor_height.size();
++anchor_id) {
const float x_center =
(x + anchor_params.anchor_offset_x) * 1.0f / feature_map_width;
const float y_center =
(y + anchor_params.anchor_offset_y) * 1.0f / feature_map_height;
Anchor new_anchor;
new_anchor.x_center = x_center;
new_anchor.y_center = y_center;
new_anchor.w = 1.0f;
new_anchor.h = 1.0f;
anchors.push_back(new_anchor);
}
}
}
layer_id = last_same_stride_layer;
}
}
static void create_ssd_anchors(int input_w, int input_h,
std::vector<Anchor> &anchors) {
AnchorsParams anchor_options;
anchor_options.num_layers = 4;
anchor_options.min_scale = 0.1484375;
anchor_options.max_scale = 0.75;
anchor_options.input_size_height = 192;
anchor_options.input_size_width = 192;
anchor_options.anchor_offset_x = 0.5f;
anchor_options.anchor_offset_y = 0.5f;
anchor_options.strides.push_back(8);
anchor_options.strides.push_back(16);
anchor_options.strides.push_back(16);
anchor_options.strides.push_back(16);
anchor_options.aspect_ratios.push_back(1.0);
generate_anchors(anchors, anchor_options);
}
static int decode_bounds(std::list<DetectRegion> ®ion_list,
float score_thresh, int input_img_w, int input_img_h,
float *scores_ptr, float *bboxes_ptr,
std::vector<Anchor> &anchors) {
DetectRegion region;
int i = 0;
for (auto &anchor : anchors) {
float score = ov::sigmoid(scores_ptr[i]);
if (score > score_thresh) {
float *p = bboxes_ptr + (i * 18);
float cx = p[0] / input_img_w + anchor.x_center;
float cy = p[1] / input_img_h + anchor.y_center;
float w = p[2] / input_img_w;
float h = p[3] / input_img_h;
ov::Point2f topleft, btmright;
topleft.x = cx - w * 0.5f;
topleft.y = cy - h * 0.5f;
btmright.x = cx + w * 0.5f;
btmright.y = cy + h * 0.5f;
region.score = score;
region.topleft = topleft;
region.btmright = btmright;
for (int j = 0; j < 7; j++) {
float lx = p[4 + (2 * j) + 0];
float ly = p[4 + (2 * j) + 1];
lx += anchor.x_center * input_img_w;
ly += anchor.y_center * input_img_h;
lx /= (float)input_img_w;
ly /= (float)input_img_h;
region.landmarks[j].x = lx;
region.landmarks[j].y = ly;
}
region_list.push_back(region);
}
i++;
}
return 0;
}
static float calc_intersection_over_union(DetectRegion ®ion0,
DetectRegion ®ion1) {
float sx0 = region0.topleft.x;
float sy0 = region0.topleft.y;
float ex0 = region0.btmright.x;
float ey0 = region0.btmright.y;
float sx1 = region1.topleft.x;
float sy1 = region1.topleft.y;
float ex1 = region1.btmright.x;
float ey1 = region1.btmright.y;
float xmin0 = std::min(sx0, ex0);
float ymin0 = std::min(sy0, ey0);
float xmax0 = std::max(sx0, ex0);
float ymax0 = std::max(sy0, ey0);
float xmin1 = std::min(sx1, ex1);
float ymin1 = std::min(sy1, ey1);
float xmax1 = std::max(sx1, ex1);
float ymax1 = std::max(sy1, ey1);
float area0 = (ymax0 - ymin0) * (xmax0 - xmin0);
float area1 = (ymax1 - ymin1) * (xmax1 - xmin1);
if (area0 <= 0 || area1 <= 0)
return 0.0f;
float intersect_xmin = std::max(xmin0, xmin1);
float intersect_ymin = std::max(ymin0, ymin1);
float intersect_xmax = std::min(xmax0, xmax1);
float intersect_ymax = std::min(ymax0, ymax1);
float intersect_area = std::max(intersect_ymax - intersect_ymin, 0.0f) *
std::max(intersect_xmax - intersect_xmin, 0.0f);
return intersect_area / (area0 + area1 - intersect_area);
}
static int non_max_suppression(std::list<DetectRegion> ®ion_list,
std::list<DetectRegion> ®ion_nms_list,
float iou_thresh) {
region_list.sort([](DetectRegion &v1, DetectRegion &v2) {
return v1.score > v2.score ? true : false;
});
for (auto itr = region_list.begin(); itr != region_list.end(); itr++) {
DetectRegion region_candidate = *itr;
int ignore_candidate = false;
for (auto itr_nms = region_nms_list.rbegin();
itr_nms != region_nms_list.rend(); itr_nms++) {
DetectRegion region_nms = *itr_nms;
float iou = calc_intersection_over_union(region_candidate, region_nms);
if (iou >= iou_thresh) {
ignore_candidate = true;
break;
}
}
if (!ignore_candidate) {
region_nms_list.push_back(region_candidate);
if (region_nms_list.size() >= 5)
break;
}
}
return 0;
}
static float normalize_radians(float angle) {
return angle - 2 * M_PI * floor((angle - (-M_PI)) / (2 * M_PI));
}
static void compute_rotation(DetectRegion ®ion) {
float x0 = region.landmarks[0].x;
float y0 = region.landmarks[0].y;
float x1 = region.landmarks[2].x;
float y1 = region.landmarks[2].y;
float target_angle = M_PI * 0.5f;
float rotation = target_angle - atan2(-(y1 - y0), x1 - x0);
region.rotation = normalize_radians(rotation);
}
void rot_vec(ov::Point2f &vec, float rotation) {
float sx = vec.x;
float sy = vec.y;
vec.x = sx * cos(rotation) - sy * sin(rotation);
vec.y = sx * sin(rotation) + sy * cos(rotation);
}
void compute_detect_to_roi(DetectRegion ®ion, const int &target_size,
PalmObject &palm) {
float width = region.btmright.x - region.topleft.x;
float height = region.btmright.y - region.topleft.y;
float palm_cx = region.topleft.x + width * 0.5f;
float palm_cy = region.topleft.y + height * 0.5f;
float hand_cx;
float hand_cy;
float rotation = region.rotation;
float shift_x = 0.0f;
float shift_y = -0.5f;
if (rotation == 0.0f) {
hand_cx = palm_cx + (width * shift_x);
hand_cy = palm_cy + (height * shift_y);
} else {
float dx =
(width * shift_x) * cos(rotation) - (height * shift_y) * sin(rotation);
float dy =
(width * shift_x) * sin(rotation) + (height * shift_y) * cos(rotation);
hand_cx = palm_cx + dx;
hand_cy = palm_cy + dy;
}
float long_side = std::max(width, height);
width = long_side;
height = long_side;
float hand_w = width * 2.6f;
float hand_h = height * 2.6f;
palm.hand_cx = hand_cx;
palm.hand_cy = hand_cy;
palm.hand_w = hand_w;
palm.hand_h = hand_h;
float dx = hand_w * 0.5f;
float dy = hand_h * 0.5f;
palm.hand_pos[0].x = -dx;
palm.hand_pos[0].y = -dy;
palm.hand_pos[1].x = +dx;
palm.hand_pos[1].y = -dy;
palm.hand_pos[2].x = +dx;
palm.hand_pos[2].y = +dy;
palm.hand_pos[3].x = -dx;
palm.hand_pos[3].y = +dy;
for (int i = 0; i < 4; i++) {
rot_vec(palm.hand_pos[i], rotation);
palm.hand_pos[i].x += hand_cx;
palm.hand_pos[i].y += hand_cy;
}
for (int i = 0; i < 7; i++) {
palm.landmarks[i] = region.landmarks[i];
}
palm.rotation = rotation;
palm.score = region.score;
}
static void pack_detect_result(std::vector<DetectRegion> &detect_results,
std::list<DetectRegion> ®ion_list,
const int &target_size,
std::vector<PalmObject> &palmlist) {
for (auto ®ion : region_list) {
compute_rotation(region);
PalmObject palm;
compute_detect_to_roi(region, target_size, palm);
palmlist.push_back(palm);
detect_results.push_back(region);
}
}
MediapipeHand::MediapipeHand() : ov::EstimatorBase() {
palm_blob_allocator_.set_size_compare_ratio(0.f);
palm_workspace_allocator_.set_size_compare_ratio(0.f);
hand_blob_allocator_.set_size_compare_ratio(0.f);
hand_workspace_allocator_.set_size_compare_ratio(0.f);
palm_net_ = new ncnn::Net();
hand_net_ = new ncnn::Net();
initialized_ = false;
if (num_threads > 0) {
palm_net_->opt.num_threads = num_threads;
hand_net_->opt.num_threads = num_threads;
}
palm_net_->opt.blob_allocator = &palm_blob_allocator_;
palm_net_->opt.workspace_allocator = &palm_workspace_allocator_;
palm_net_->opt.lightmode = light_mode_;
hand_net_->opt.blob_allocator = &hand_blob_allocator_;
hand_net_->opt.workspace_allocator = &hand_workspace_allocator_;
hand_net_->opt.lightmode = light_mode_;
#ifdef OV_VULKAN
palm_net_->opt.use_vulkan_compute = true;
hand_net_->opt.use_vulkan_compute = true;
#endif // OV_VULKAN
}
MediapipeHand::~MediapipeHand() {
if (palm_net_) {
palm_net_->clear();
}
if (hand_net_) {
hand_net_->clear();
}
palm_workspace_allocator_.clear();
palm_blob_allocator_.clear();
hand_workspace_allocator_.clear();
hand_blob_allocator_.clear();
}
void MediapipeHand::set_num_threads(int n) {
EstimatorBase::set_num_threads(n);
if (palm_net_) {
palm_net_->opt.num_threads = n;
}
if (hand_net_) {
hand_net_->opt.num_threads = n;
}
}
void MediapipeHand::set_light_mode(bool mode) {
if (palm_net_) {
palm_net_->opt.lightmode = mode;
}
if (hand_net_) {
hand_net_->opt.lightmode = mode;
}
light_mode_ = mode;
}
int MediapipeHand::LoadModel(const char *palm_path, const char *hand_path) {
std::string palm_param_file = std::string(palm_path) + "/param";
std::string palm_bin_file = std::string(palm_path) + "/bin";
std::string hand_param_file = std::string(hand_path) + "/param";
std::string hand_bin_file = std::string(hand_path) + "/bin";
if (palm_net_->load_param(palm_param_file.c_str()) == -1 ||
palm_net_->load_model(palm_bin_file.c_str()) == -1) {
return 10000;
}
if (hand_net_->load_param(hand_param_file.c_str()) == -1 ||
hand_net_->load_model(hand_bin_file.c_str()) == -1) {
return 10000;
}
initialized_ = true;
anchors.clear();
create_ssd_anchors(target_size, target_size, anchors);
return 0;
}
int MediapipeHand::Detect(const unsigned char *rgbdata, int img_width,
int img_height, std::vector<PalmObject> &objects) {
if (!initialized_) {
return 10000;
}
if (rgbdata == 0) {
return 10001;
}
int w = img_width;
int h = img_height;
float scale = 1.f;
if (w > h) {
scale = (float)target_size / w;
w = target_size;
h = h * scale;
} else {
scale = (float)target_size / h;
h = target_size;
w = w * scale;
}
ncnn::Mat in = ncnn::Mat::from_pixels_resize(rgbdata, ncnn::Mat::PIXEL_RGB,
img_width, img_height, w, h);
int wpad = target_size - w;
int hpad = target_size - h;
ncnn::Mat in_pad;
ncnn::copy_make_border(in, in_pad, hpad / 2, hpad - hpad / 2, wpad / 2,
wpad - wpad / 2, ncnn::BORDER_CONSTANT, 0.f);
const float norm_vals[3] = {1 / 255.f, 1 / 255.f, 1 / 255.f};
in_pad.substract_mean_normalize(0, norm_vals);
ncnn::Extractor ex = palm_net_->create_extractor();
ncnn::Mat cls, reg;
ex.input("input", in_pad);
ex.extract("cls", cls);
ex.extract("reg", reg);
float *scores = (float *)cls.data;
float *bboxes = (float *)reg.data;
std::list<DetectRegion> region_list, region_nms_list;
std::vector<DetectRegion> detect_results;
decode_bounds(region_list, prob_threshold, target_size, target_size, scores,
bboxes, anchors);
non_max_suppression(region_list, region_nms_list, nms_threshold);
objects.clear();
pack_detect_result(detect_results, region_nms_list, target_size, objects);
for (int i = 0; i < objects.size(); i++) {
objects[i].hand_pos[0].x =
(objects[i].hand_pos[0].x * target_size - ((float)wpad / 2)) / scale;
objects[i].hand_pos[0].y =
(objects[i].hand_pos[0].y * target_size - ((float)hpad / 2)) / scale;
objects[i].hand_pos[1].x =
(objects[i].hand_pos[1].x * target_size - ((float)wpad / 2)) / scale;
objects[i].hand_pos[1].y =
(objects[i].hand_pos[1].y * target_size - ((float)hpad / 2)) / scale;
objects[i].hand_pos[2].x =
(objects[i].hand_pos[2].x * target_size - ((float)wpad / 2)) / scale;
objects[i].hand_pos[2].y =
(objects[i].hand_pos[2].y * target_size - ((float)hpad / 2)) / scale;
objects[i].hand_pos[3].x =
(objects[i].hand_pos[3].x * target_size - ((float)wpad / 2)) / scale;
objects[i].hand_pos[3].y =
(objects[i].hand_pos[3].y * target_size - ((float)hpad / 2)) / scale;
for (int j = 0; j < 7; j++) {
objects[i].landmarks[j].x =
(objects[i].landmarks[j].x * target_size - ((float)wpad / 2)) / scale;
objects[i].landmarks[j].y =
(objects[i].landmarks[j].y * target_size - ((float)hpad / 2)) / scale;
}
const float srcPts[8] = {
objects[i].hand_pos[0].x, objects[i].hand_pos[0].y,
objects[i].hand_pos[1].x, objects[i].hand_pos[1].y,
objects[i].hand_pos[2].x, objects[i].hand_pos[2].y,
objects[i].hand_pos[3].x, objects[i].hand_pos[3].y,
};
const float dstPts[8] = {
0, 0, 224, 0, 224, 224, 0, 224,
};
float tm[6];
unsigned char *trans_mat =
(unsigned char *)malloc(224 * 224 * 3 * sizeof(unsigned char));
ncnn::get_affine_transform(dstPts, srcPts, 4, tm);
ncnn::warpaffine_bilinear_c3(rgbdata, img_width, img_height, trans_mat, 224,
224, tm);
ncnn::Mat trans_image =
ncnn::Mat::from_pixels(trans_mat, ncnn::Mat::PIXEL_RGB, 224, 224);
free(trans_mat);
float score = GetLandmarks(trans_image, tm, objects[i].skeleton,
objects[i].skeleton3d);
}
return 0;
}
float MediapipeHand::GetLandmarks(ncnn::Mat in, float tm[6],
std::vector<ov::Point2f> &skeleton,
std::vector<ov::Point3d> &skeleton3d) {
const float norm_vals[3] = {1 / 255.f, 1 / 255.f, 1 / 255.f};
in.substract_mean_normalize(NULL, norm_vals);
ncnn::Mat points, score;
{
ncnn::Extractor ex = hand_net_->create_extractor();
ex.input("input", in);
ex.extract("points", points);
ex.extract("score", score);
}
float *points_data = (float *)points.data;
float *score_data = (float *)score.data;
for (int i = 0; i < 21; i++) {
ov::Point3d pt3d;
pt3d.x = points_data[i * 3];
pt3d.y = points_data[i * 3 + 1];
pt3d.z = points_data[i * 3 + 2];
ov::Point2f pt;
pt.x = pt3d.x * tm[0] + pt3d.y * tm[1] + tm[2];
pt.y = pt3d.x * tm[3] + pt3d.y * tm[4] + tm[5];
skeleton.push_back(pt);
pt3d.x /= 224.f;
pt3d.y /= 224.f;
skeleton3d.push_back(pt3d);
}
return score_data[0];
}
} // namespace ovhand3d
| 32.035382 | 80 | 0.621403 | [
"vector"
] |
6f5e7abc7f4c74958266e15651f0974149d61d5a | 14,263 | cpp | C++ | marsyas-vamp/marsyas/src/apps/rhythmMap/rhythmMap.cpp | jaouahbi/VampPlugins | 27c2248d1c717417fe4d448cdfb4cb882a8a336a | [
"Apache-2.0"
] | null | null | null | marsyas-vamp/marsyas/src/apps/rhythmMap/rhythmMap.cpp | jaouahbi/VampPlugins | 27c2248d1c717417fe4d448cdfb4cb882a8a336a | [
"Apache-2.0"
] | null | null | null | marsyas-vamp/marsyas/src/apps/rhythmMap/rhythmMap.cpp | jaouahbi/VampPlugins | 27c2248d1c717417fe4d448cdfb4cb882a8a336a | [
"Apache-2.0"
] | null | null | null | #include <marsyas/system/MarSystemManager.h>
#include <marsyas/marsystems/SimilarityMatrix.h>
#include <marsyas/marsystems/Metric2.h>
#include <marsyas/marsystems/DTW.h>
#include <marsyas/marsystems/AveragingPattern.h>
#include <marsyas/Collection.h>
using namespace std;
using namespace Marsyas;
#define MAX_TEMPLATES 10
#define ACC_INPUT 8000
#define ACC_TEMPLATE 1000
#define BIN 8
#define NITERATION 15
void recognize(string sfName, string tpName)
{
mrs_natural i, j, k, l;
mrs_natural nsamples, sfrq, obs, outsize;
mrs_natural wsize = 0;
mrs_natural maxsize, totalCount, inputsize;
mrs_real msecondsPerFrame;
MarSystemManager mng;
MarSystem* netInp = mng.create("Series", "netInp");
MarSystem* accInp = mng.create("Accumulator", "accInp");
MarSystem* wavInp = mng.create("Series", "wavInp");
MarSystem* wavaccInp = mng.create("Accumulator","wavaccInp");
MarSystem* wavnetInp = mng.create("Series","wavnetInp");
MarSystem* wavplOut = mng.create("Parallel","wavplOut");
MarSystem* wavsrdOut = mng.create("Shredder","wavsrdOut");
MarSystem* plTpl = mng.create("Parallel","plTpl");
MarSystem* Inp = mng.create("Series","Inp");
MarSystem* Tpl = mng.create("Series","Tpl");
MarSystem* sim = mng.create("SimilarityMatrix", "sim");
MarSystem* met = mng.create("Metric2", "met");
MarSystem* dtw = mng.create("DTW", "dtw");
MarSystem* ap = mng.create("AveragingPattern", "ap");
Collection templates;
ostringstream oss, oss2;
string tmpStr;
realvec sizes, b, countvector, segments;
realvec beginPos, endPos, order;
realvec dataInp, dataTpl, inpspec, allspec, tplspec;
realvec featuresInp, featuresTpl;
realvec simInput, simOutput, algOutput, tplOutput;
mrs_bool b_begin;
MarSystem* netTpl[MAX_TEMPLATES];
MarSystem* accTpl[MAX_TEMPLATES];
MarSystem* srsTpl[MAX_TEMPLATES];
MarSystem* wavnetOut[MAX_TEMPLATES];
templates.read(tpName);
sizes.create(templates.size()+1);
outsize = 0;
/*** caluculate templates spectrogram ***/
if(templates.size() > MAX_TEMPLATES) {
cerr << "Error: invalied templates size!" << endl;
exit(-1);
}
for(i=0; i< (mrs_natural)templates.size(); ++i) {
oss.str(""); oss << "net" << i;
tmpStr = oss.str();
netTpl[i] = mng.create("Series", tmpStr);
oss.str(""); oss << "srs" << i;
srsTpl[i] = mng.create("Series", oss.str());
oss.str(""); oss << "tplsrc" << i;
netTpl[i]->addMarSystem(mng.create("SoundFileSource",oss.str()));
oss2.str(""); oss2 << "SoundFileSource/" << oss.str() << "/mrs_string/filename";
netTpl[i]->updControl(oss2.str(),templates.entry(i));
oss2.str(""); oss2 << "SoundFileSource/" << oss.str() << "/mrs_natural/size";
nsamples = netTpl[i]->getctrl(oss2.str())->to<mrs_natural>();
oss.str(""); oss << "han" << i;
netTpl[i]->addMarSystem(mng.create("Windowing",oss.str()));
oss2.str(""); oss2 << "Windowing/" << oss.str() << "/mrs_natural/onSamples";
wsize = netTpl[i]->getctrl(oss2.str())->to<mrs_natural>();
sizes(i+1) = nsamples/wsize;
oss.str(""); oss << "spc" << i;
netTpl[i]->addMarSystem(mng.create("Spectrum",oss.str()));
oss.str(""); oss << "psc" << i;
netTpl[i]->addMarSystem(mng.create("PowerSpectrum",oss.str()));
//oss.str(""); oss << "mfcc" << i;
//netTpl[i]->addMarSystem(mng.create("MFCC",oss.str()));
oss.str(""); oss << "acc" << i;
accTpl[i] = mng.create("Accumulator",oss.str());
accTpl[i]->addMarSystem(netTpl[i]);
accTpl[i]->updControl("mrs_natural/nTimes",ACC_TEMPLATE);
srsTpl[i]->addMarSystem(accTpl[i]);
plTpl->addMarSystem(srsTpl[i]);
outsize += sizes(i+1);
}
Tpl->addMarSystem(plTpl);
Tpl->tick();
dataTpl = Tpl->getctrl("mrs_realvec/processedData")->to<mrs_realvec>();
maxsize = sizes.maxval();
/*** calculate the feature vector of template ***/
featuresTpl.create(BIN*(templates.size()+1),dataTpl.getCols());
sfrq = netTpl[0]->getctrl("SoundFileSource/tplsrc0/mrs_real/osrate")->to<mrs_real>();
obs = netTpl[0]->getctrl("mrs_natural/onObservations")->to<mrs_natural>();
b.create(BIN+2);
for(i=0; i<BIN+2; ++i) {
b(i) = wsize*700/sfrq*(pow(10, (log10(1.0+sfrq/1400))*i/(BIN+1))-1);
}
for(j=0; j<BIN; j++) {
for(l=0; l<(mrs_natural)templates.size(); l++) {
for(k=0; k<obs; k++) {
if(b(j) < k && k < b(j+1)) {
for(i=0; i<dataTpl.getCols(); ++i) {
featuresTpl(j+l*BIN,i) += dataTpl(k+l*obs,i)*(k-b(j))/(b(j+1)-b(j));
}
} else if(b(j+1) <= k && k <= b(j+2)) {
for(i=0; i<dataTpl.getCols(); ++i) {
featuresTpl(j+l*BIN,i) += dataTpl(k+l*obs,i)*(b(j+2)-k)/(b(j+2)-b(j+1));
}
}
}
}
for(l=0; l<(mrs_natural)templates.size(); l++) {
for(i=0; i<featuresTpl.getCols(); ++i) {
featuresTpl(j+l*BIN,i) /= (b(j+2)-b(j))/2;
featuresTpl(j+l*BIN,i) = log(100000*featuresTpl(j+l*BIN,i)+1);
}
}
}
/*** set controls to input series ***/
netInp->addMarSystem(mng.create("SoundFileSource","inpsrc"));
netInp->addMarSystem(mng.create("Spectrum","spc"));
netInp->addMarSystem(mng.create("PowerSpectrum","psc"));
//netInp->addMarSystem(mng.create("MFCC","mfcc"));
accInp->addMarSystem(netInp);
accInp->updControl("mrs_natural/nTimes",ACC_INPUT);
Inp->addMarSystem(accInp);
/*** set controls to rhythm map ***/
sim->updControl("mrs_natural/calcCovMatrix",2);
sim->updControl("mrs_string/normalize", "MeanStd");
sim->addMarSystem(met);
met->updControl("mrs_string/metric","euclideanDistance");
dtw->updControl("mrs_string/lastPos","lowest");
dtw->updControl("mrs_string/startPos","lowest");
dtw->updControl("mrs_string/localPath","diagonal");
dtw->updControl("mrs_bool/weight",false);
dtw->updControl("mrs_string/mode","OnePass");
/*** calculate first templates ***/
tplOutput.create(featuresTpl.getRows(),maxsize);
for(i=0; i<maxsize; ++i) {
for(j=0; j<featuresTpl.getRows(); j++) {
tplOutput(j,i) = featuresTpl(j,i);
}
}
/*** calculate input spectrogram ***/
netInp->updControl("SoundFileSource/inpsrc/mrs_string/filename",sfName);
inputsize = netInp->getctrl("SoundFileSource/inpsrc/mrs_natural/size")->to<mrs_natural>();
inputsize /= wsize;
accInp->updControl("mrs_natural/nTimes",inputsize);
Inp->tick();
dataInp = Inp->getctrl("mrs_realvec/processedData")->to<mrs_realvec>();
/*** calculate input feature vector of input ***/
featuresInp.create(BIN,dataInp.getCols());
sfrq = netInp->getctrl("SoundFileSource/inpsrc/mrs_real/osrate")->to<mrs_real>();
obs = netInp->getctrl("mrs_natural/onObservations")->to<mrs_natural>();
b.create(BIN+2);
for(i=0; i<BIN+2; ++i) {
b(i) = wsize*700/sfrq*(pow(10, (log10(1.0+sfrq/1400))*i/(BIN+1))-1);
}
for(j=0; j<BIN; j++) {
for(k=0; k<obs; k++) {
if(b(j) < k && k < b(j+1)) {
for(i=0; i<dataInp.getCols(); ++i) {
featuresInp(j,i) += dataInp(k,i)*(k-b(j))/(b(j+1)-b(j));
}
} else if(b(j+1) <= k && k <= b(j+2)) {
for(i=0; i<dataInp.getCols(); ++i) {
featuresInp(j,i) += dataInp(k,i)*(b(j+2)-k)/(b(j+2)-b(j+1));
}
}
}
for(i=0; i<featuresInp.getCols(); ++i) {
featuresInp(j,i) /= (b(j+2)-b(j))/2;
featuresInp(j,i) = log(100000*featuresInp(j,i)+1);
}
}
/*** calculate input of SimilarityMatrix ***/
simInput.create(featuresInp.getRows()+featuresTpl.getRows(),dataInp.getCols());
for(i=0; i<featuresInp.getCols(); ++i) {
for(j=0; j<featuresInp.getRows(); j++) {
simInput(j,i) = featuresInp(j,i);
}
}
for(i=0; i<featuresTpl.getCols(); ++i) {
for(j=0; j<featuresTpl.getRows(); j++) {
simInput(j+featuresInp.getRows(),i) = featuresTpl(j,i);
}
}
/*** update control of rhythm map ***/
sizes(0) = featuresInp.getCols();
sim->updControl("mrs_realvec/sizes",sizes);
sim->updControl("mrs_natural/inSamples",simInput.getCols());
sim->updControl("mrs_natural/inObservations",simInput.getRows());
simOutput.create(outsize,sizes(0));
dtw->updControl("mrs_realvec/sizes",sizes);
dtw->updControl("mrs_natural/inSamples",simOutput.getCols());
dtw->updControl("mrs_natural/inObservations",simOutput.getRows());
//<<<<<<< .mine
//=======
//
//>>>>>>> .r3676
algOutput.create(3*sizes(0),2);
ap->updControl("mrs_realvec/sizes",sizes);
ap->updControl("mrs_natural/inSamples",simInput.getCols());
ap->updControl("mrs_natural/inObservations",simInput.getRows());
/*** iterative learning ***/
for(l=0; l<NITERATION; l++) {
sim->process(simInput,simOutput);
dtw->process(simOutput,algOutput);
ap->updControl("mrs_realvec/alignment",algOutput);
ap->process(simInput,simInput);
MarControlAccessor acs(dtw->getctrl("mrs_real/totalDistance"));
cout << "ITR#" << l << " " << acs.to<mrs_real>() << endl;
}
/*** calculate the segment information ***/
beginPos.create(sizes.getSize()-1);
endPos.create(sizes.getSize()-1);
beginPos(0) = 0;
for(i=1; i<sizes.getSize()-1; ++i) {
beginPos(i) = sizes(i) + beginPos(i-1);
}
for(i=0; i<sizes.getSize()-1; ++i) {
endPos(i) = beginPos(i) + sizes(i+1);
}
order.create(sizes.getSize()-1);
l=0; i=0;
while(l==0) {
if(algOutput(i,0) >= 0 && algOutput(i,1) >= 0) {
l = i;
}
++i ;
}
k = 1; totalCount = 1;
for(i=0; i<beginPos.getSize(); ++i) {
if(beginPos(i) <= algOutput(l,1) && algOutput(l,1) < endPos(i)) {
order(i) = k;
k ++;
break;
}
}
b_begin = true;
for(i=l; i<algOutput.getRows(); ++i) {
for(j=0; j<beginPos.getSize(); j++) {
if(algOutput(i,1) == beginPos(j)) {
if(!b_begin) {
if(order(j) == 0) {
order(j) = k;
k++;
}
b_begin = true;
totalCount++;
}
break;
} else if(algOutput(i,1) == endPos(j)-1) {
b_begin = false;
break;
}
}
}
segments.create(totalCount,3);
msecondsPerFrame = (mrs_real)wsize/(mrs_real)sfrq*1000.0;
segments(0,0) = 0.0; segments(0,2) = 1;
b_begin = true;
k = 0;
for(i=l; i<algOutput.getRows(); ++i) {
for(j=0; j<beginPos.getSize(); j++) {
if(algOutput(i,1) == beginPos(j)) {
if(!b_begin) {
b_begin = true;
segments(k,1) = (mrs_real)algOutput(i,0)*msecondsPerFrame;
k++;
segments(k,0) = (mrs_real)algOutput(i,0)*msecondsPerFrame;
segments(k,2) = order(j);
}
break;
} else if(algOutput(i,1) == endPos(j)-1) {
b_begin = false;
break;
}
}
}
segments(k,1) = (mrs_real)algOutput(algOutput.getRows()-1,0)*msecondsPerFrame;
oss.str(""); oss << sfName << "_segments.txt";
segments.write(oss.str());
cout << "Now writing a segmentation file: " << oss.str() << "." << endl;
/*** create WAV file of template patterns ***/
wavInp->addMarSystem(wavaccInp);
wavaccInp->addMarSystem(wavnetInp);
wavnetInp->addMarSystem(mng.create("SoundFileSource","wavsrc"));
wavnetInp->updControl("SoundFileSource/wavsrc/mrs_string/filename",sfName);
wavnetInp->addMarSystem(mng.create("Spectrum","wavspc"));
wavaccInp->updControl("mrs_natural/nTimes",inputsize);
wavInp->tick();
inpspec = wavInp->getctrl("mrs_realvec/processedData")->to<mrs_realvec>();
allspec.create(inpspec.getRows()*sizes.getSize(),inpspec.getCols());
for(i=0; i<inpspec.getCols(); ++i) {
for(j=0; j<inpspec.getRows(); j++) {
allspec(j,i) = inpspec(j,i);
}
}
sizes(0) = inpspec.getCols();
ap->updControl("mrs_natural/inSamples",allspec.getCols());
ap->updControl("mrs_natural/inObservations",allspec.getRows());
ap->updControl("mrs_realvec/sizes",sizes);
ap->updControl("mrs_realvec/alignmnet",algOutput);
ap->process(allspec,allspec);
tplspec.create(inpspec.getRows()*order.maxval(),maxsize);
for(k=1; k<=order.maxval(); k++) {
for(l=0; l<order.getSize(); l++) {
if(order(l) == k) {
for(i=0; i<maxsize; ++i) {
for(j=0; j<inpspec.getRows(); j++) {
tplspec(j+(k-1)*inpspec.getRows(),i) = allspec(j+(l+1)*inpspec.getRows(),i);
}
}
break;
}
}
}
for(i=0; i<order.maxval(); ++i) {
oss.str(""); oss << "wavnetOut" << i;
wavnetOut[i] = mng.create("Series",oss.str());
wavplOut->addMarSystem(wavnetOut[i]);
oss.str(""); oss << "ispOut" << i;
wavnetOut[i]->addMarSystem(mng.create("InvSpectrum",oss.str()));
oss.str(""); oss << "sfsOut" << i;
wavnetOut[i]->addMarSystem(mng.create("SoundFileSink",oss.str()));
oss.str(""); oss << "SoundFileSink/sfsOut" << i << "/mrs_natural/inObservations";
wavnetOut[i]->updControl(oss.str(),1);
oss.str(""); oss << "SoundFileSink/sfsOut" << i << "/mrs_natural/inSamples";
wavnetOut[i]->updControl(oss.str(),inpspec.getRows());
oss.str(""); oss << "SoundFileSink/sfsOut" << i << "/mrs_real/israte";
wavnetOut[i]->updControl(oss.str(),sfrq);
oss2.str(""); oss2 << "SoundFileSink/sfsOut" << i << "/mrs_string/filename";
oss.str(""); oss << sfName << "_template" << i+1 << ".wav";
wavnetOut[i]->updControl(oss2.str(),oss.str());
wavnetOut[i]->updControl("mrs_natural/inObservations",inpspec.getRows());
wavnetOut[i]->updControl("mrs_natural/inSamples",1);
cout << "Now writing WAV file: " << oss.str() << "." << endl;
}
wavsrdOut->addMarSystem(wavplOut);
wavsrdOut->updControl("mrs_natural/nTimes",maxsize);
wavsrdOut->updControl("mrs_natural/inSamples",tplspec.getCols());
wavsrdOut->updControl("mrs_natural/inObservations",tplspec.getRows());
wavplOut->updControl("mrs_natural/inSamples",1);
wavplOut->updControl("mrs_natural/inObservations",tplspec.getRows());
realvec tmpRealvec(order.maxval(),wsize);
wavsrdOut->process(tplspec,tmpRealvec);
/*** delete memory ***/
delete sim;
delete dtw;
delete ap;
delete Inp;
delete Tpl;
delete wavInp;
delete wavsrdOut;
}
int main(int argc, const char **argv)
{
string fileName;
string templates;
if (argc<2)
{
cout<<"Please enter filename."<<endl;
exit(1);
}
else
{
fileName = argv[1];
templates = argv[2];
}
cout << "Processing file " << fileName << endl;
recognize(fileName, templates);
exit(0);
}
| 33.56 | 92 | 0.615719 | [
"vector"
] |
6f5ea14e269abf8b274b12acf5e0f3630d0012b7 | 5,818 | cpp | C++ | spike/rasters/components/CollignonMesh/CollignonMesh_test.cpp | davidson16807/libtectonics | aa0ae2b8a4a1d2a9a346bbdeb334be876ad75646 | [
"CC-BY-4.0"
] | 7 | 2020-06-09T19:56:55.000Z | 2021-02-17T01:53:30.000Z | spike/rasters/components/CollignonMesh/CollignonMesh_test.cpp | davidson16807/tectonics.cpp | c40278dba14260c598764467c7abf23b190e676b | [
"CC-BY-4.0"
] | null | null | null | spike/rasters/components/CollignonMesh/CollignonMesh_test.cpp | davidson16807/tectonics.cpp | c40278dba14260c598764467c7abf23b190e676b | [
"CC-BY-4.0"
] | null | null | null |
// 3rd party libraries
#define CATCH_CONFIG_MAIN // This tells Catch to provide a main() - only do this in one cpp file
#include "catch/catch.hpp"
#define GLM_FORCE_PURE // disable anonymous structs so we can build with ISO C++
#define GLM_ENABLE_EXPERIMENTAL // disable anonymous structs so we can build with ISO C++
#include <glm/vec3.hpp> // *vec3
#include <glm/gtx/string_cast.hpp> // to_string
// in-house libraries
#include "CollignonMesh.hpp"
TEST_CASE( "CollignonMesh.sphere_position() purity", "[rasters]" ) {
SECTION("CollignonMesh.sphere_position() must be called repeatedly without changing the output"){
for(int x = -10; x < 10; x+=1){
for(int y = -10; y < 10; y+=1){
CHECK(rasters::CollignonMesh(2.0f, 10).sphere_position(glm::vec2(x,y)) ==
rasters::CollignonMesh(2.0f, 10).sphere_position(glm::vec2(x,y)));
}}
}
}
TEST_CASE( "CollignonMesh sphere_position() closeness preservation", "[rasters]" ) {
SECTION("changes in grid_position must not result in changes to sphere_position that exceed a reasonable multiple"){
rasters::CollignonMesh mesh(2.0f, 10);
const float factor(3.0*2.0/10.0);
const glm::vec2 dx(0.01, 0.0);
const glm::vec2 dy(0.0, 0.01);
for(int x = -10; x < 10; x+=1){
for(int y = -10; y < 10; y+=1){
glm::vec2 v = glm::vec2(x,y);
CHECK( glm::distance(mesh.sphere_position(v), mesh.sphere_position(v+dx)) < factor * glm::length(dx) );
CHECK( glm::distance(mesh.sphere_position(v), mesh.sphere_position(v-dx)) < factor * glm::length(dx) );
CHECK( glm::distance(mesh.sphere_position(v), mesh.sphere_position(v+dy)) < factor * glm::length(dy) );
CHECK( glm::distance(mesh.sphere_position(v), mesh.sphere_position(v-dy)) < factor * glm::length(dy) );
}}
}
}
TEST_CASE( "CollignonMesh sphere_position() congruence", "[rasters]" ) {
SECTION("a modulo can be applied to input which results in the same output"){
rasters::CollignonMesh mesh(2.0f, 10);
const float epsilon(1e-4f);
const glm::vec2 nx(40, 0);
const glm::vec2 ny(0, 40);
for(int x = -10; x < 10; x+=1){
for(int y = -10; y < 10; y+=1){
glm::vec2 v = glm::vec2(x,y);
CHECK( glm::distance(mesh.sphere_position(v), mesh.sphere_position(v+nx)) < epsilon );
CHECK( glm::distance(mesh.sphere_position(v), mesh.sphere_position(v-nx)) < epsilon );
CHECK( glm::distance(mesh.sphere_position(v), mesh.sphere_position(v+ny)) < epsilon );
CHECK( glm::distance(mesh.sphere_position(v), mesh.sphere_position(v-ny)) < epsilon );
}}
}
}
TEST_CASE( "CollignonMesh.grid_position() purity", "[rasters]" ) {
SECTION("CollignonMesh.grid_position() must be called repeatedly without changing the output"){
rasters::CollignonMesh mesh(2.0f, 10);
const float epsilon(1e-4f);
for(float x = -2.0f; x < 2.0f; x+=0.5f){
for(float y = -2.0f; y < 2.0f; y+=0.5f){
for(float z = -2.0f; z < 2.0f; z+=0.5f){
glm::vec3 v(x,y,z);
if(glm::length(v) > epsilon){
CHECK(rasters::CollignonMesh(2.0f, 10).grid_position(glm::vec3(x,y,z)) ==
rasters::CollignonMesh(2.0f, 10).grid_position(glm::vec3(x,y,z)));
}
}}}
}
}
TEST_CASE( "CollignonMesh grid_position() / sphere_position() invertibility", "[rasters]" ) {
SECTION("CollignonMesh.sphere_position() must reconstruct input passed to grid_position() for any unit vector"){
rasters::CollignonMesh mesh(2.0f, 10);
const float epsilon(1e-4f);
for(float x = -2.0f; x < 2.0f; x+=0.5f){
for(float y = -2.0f; y < 2.0f; y+=0.5f){
for(float z = -2.0f; z < 2.0f; z+=0.5f){
if(glm::length(glm::vec3(x,y,z)) > epsilon){
glm::vec3 v = 2.0f*glm::normalize(glm::vec3(x,y,z));
glm::vec2 u = mesh.grid_position(v);
glm::vec3 v2 = mesh.sphere_position( u );
CHECK( v2.x == Approx(v.x).margin(epsilon) );
CHECK( v2.y == Approx(v.y).margin(epsilon) );
CHECK( v2.z == Approx(v.z).margin(epsilon) );
}
}}}
}
}
TEST_CASE( "CollignonMesh memory_id() / grid_position() invertibility", "[rasters]" ) {
SECTION("CollignonMesh.grid_position() must reconstruct input passed to memory_id() for any unit vector"){
rasters::CollignonMesh mesh(2.0f, 10);
for(int i = 0; i < mesh.vertex_count; i++){
CHECK( i == mesh.memory_id(mesh.grid_position(i)) );
}
}
}
TEST_CASE( "CollignonMesh memory_id() congruence", "[rasters]" ) {
SECTION("an modulo can be applied to input which results in the same output"){
rasters::CollignonMesh mesh(2.0f, 10);
const glm::vec2 nx(40, 0);
const glm::vec2 ny(0, 40);
for(int x = -10; x < 10; x+=1){
for(int y = -10; y < 10; y+=1){
glm::vec2 v = glm::vec2(x,y);
CHECK( mesh.memory_id(v) == mesh.memory_id(v+nx));
CHECK( mesh.memory_id(v) == mesh.memory_id(v-nx));
CHECK( mesh.memory_id(v) == mesh.memory_id(v+ny));
CHECK( mesh.memory_id(v) == mesh.memory_id(v-ny));
}}
}
}
TEST_CASE( "CollignonMesh memory_id() range restrictions", "[rasters]" ) {
SECTION("CollignonMesh.memory_id() must not produce results outside valid range"){
rasters::CollignonMesh mesh(2.0f, 10);
for(int x = -10; x < 10; x+=1){
for(int y = -10; y < 10; y+=1){
int i = mesh.memory_id(glm::vec2(x,y));
CHECK( 0 <= i );
CHECK( i < mesh.vertex_count );
}}
}
}
/*
*/
| 42.779412 | 120 | 0.580784 | [
"mesh",
"vector"
] |
6f5f418f2b0f2391d1b552004964f35682438d2b | 2,787 | cpp | C++ | android-31/android/media/tv/TvView_TvInputCallback.cpp | YJBeetle/QtAndroidAPI | 1468b5dc6eafaf7709f0b00ba1a6ec2b70684266 | [
"Apache-2.0"
] | 12 | 2020-03-26T02:38:56.000Z | 2022-03-14T08:17:26.000Z | android-31/android/media/tv/TvView_TvInputCallback.cpp | YJBeetle/QtAndroidAPI | 1468b5dc6eafaf7709f0b00ba1a6ec2b70684266 | [
"Apache-2.0"
] | 1 | 2021-01-27T06:07:45.000Z | 2021-11-13T19:19:43.000Z | android-30/android/media/tv/TvView_TvInputCallback.cpp | YJBeetle/QtAndroidAPI | 1468b5dc6eafaf7709f0b00ba1a6ec2b70684266 | [
"Apache-2.0"
] | 3 | 2021-02-02T12:34:55.000Z | 2022-03-08T07:45:57.000Z | #include "./TvContentRating.hpp"
#include "../../net/Uri.hpp"
#include "../../../JString.hpp"
#include "./TvView_TvInputCallback.hpp"
namespace android::media::tv
{
// Fields
// QJniObject forward
TvView_TvInputCallback::TvView_TvInputCallback(QJniObject obj) : JObject(obj) {}
// Constructors
TvView_TvInputCallback::TvView_TvInputCallback()
: JObject(
"android.media.tv.TvView$TvInputCallback",
"()V"
) {}
// Methods
void TvView_TvInputCallback::onChannelRetuned(JString arg0, android::net::Uri arg1) const
{
callMethod<void>(
"onChannelRetuned",
"(Ljava/lang/String;Landroid/net/Uri;)V",
arg0.object<jstring>(),
arg1.object()
);
}
void TvView_TvInputCallback::onConnectionFailed(JString arg0) const
{
callMethod<void>(
"onConnectionFailed",
"(Ljava/lang/String;)V",
arg0.object<jstring>()
);
}
void TvView_TvInputCallback::onContentAllowed(JString arg0) const
{
callMethod<void>(
"onContentAllowed",
"(Ljava/lang/String;)V",
arg0.object<jstring>()
);
}
void TvView_TvInputCallback::onContentBlocked(JString arg0, android::media::tv::TvContentRating arg1) const
{
callMethod<void>(
"onContentBlocked",
"(Ljava/lang/String;Landroid/media/tv/TvContentRating;)V",
arg0.object<jstring>(),
arg1.object()
);
}
void TvView_TvInputCallback::onDisconnected(JString arg0) const
{
callMethod<void>(
"onDisconnected",
"(Ljava/lang/String;)V",
arg0.object<jstring>()
);
}
void TvView_TvInputCallback::onTimeShiftStatusChanged(JString arg0, jint arg1) const
{
callMethod<void>(
"onTimeShiftStatusChanged",
"(Ljava/lang/String;I)V",
arg0.object<jstring>(),
arg1
);
}
void TvView_TvInputCallback::onTrackSelected(JString arg0, jint arg1, JString arg2) const
{
callMethod<void>(
"onTrackSelected",
"(Ljava/lang/String;ILjava/lang/String;)V",
arg0.object<jstring>(),
arg1,
arg2.object<jstring>()
);
}
void TvView_TvInputCallback::onTracksChanged(JString arg0, JObject arg1) const
{
callMethod<void>(
"onTracksChanged",
"(Ljava/lang/String;Ljava/util/List;)V",
arg0.object<jstring>(),
arg1.object()
);
}
void TvView_TvInputCallback::onVideoAvailable(JString arg0) const
{
callMethod<void>(
"onVideoAvailable",
"(Ljava/lang/String;)V",
arg0.object<jstring>()
);
}
void TvView_TvInputCallback::onVideoSizeChanged(JString arg0, jint arg1, jint arg2) const
{
callMethod<void>(
"onVideoSizeChanged",
"(Ljava/lang/String;II)V",
arg0.object<jstring>(),
arg1,
arg2
);
}
void TvView_TvInputCallback::onVideoUnavailable(JString arg0, jint arg1) const
{
callMethod<void>(
"onVideoUnavailable",
"(Ljava/lang/String;I)V",
arg0.object<jstring>(),
arg1
);
}
} // namespace android::media::tv
| 23.225 | 108 | 0.69573 | [
"object"
] |
6f637efe99c16dc1dc2d1434d76889fdbd73b8a5 | 8,873 | cc | C++ | L1Trigger/L1TCommon/plugins/L1TSummary.cc | ckamtsikis/cmssw | ea19fe642bb7537cbf58451dcf73aa5fd1b66250 | [
"Apache-2.0"
] | 852 | 2015-01-11T21:03:51.000Z | 2022-03-25T21:14:00.000Z | L1Trigger/L1TCommon/plugins/L1TSummary.cc | ckamtsikis/cmssw | ea19fe642bb7537cbf58451dcf73aa5fd1b66250 | [
"Apache-2.0"
] | 30,371 | 2015-01-02T00:14:40.000Z | 2022-03-31T23:26:05.000Z | L1Trigger/L1TCommon/plugins/L1TSummary.cc | ckamtsikis/cmssw | ea19fe642bb7537cbf58451dcf73aa5fd1b66250 | [
"Apache-2.0"
] | 3,240 | 2015-01-02T05:53:18.000Z | 2022-03-31T17:24:21.000Z | // -*- C++ -*-
//
// L1TSummary: produce command line visible summary of L1T system
//
#include <iostream>
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/EDAnalyzer.h"
#include "FWCore/Framework/interface/MakerMacros.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "DataFormats/L1Trigger/interface/EGamma.h"
#include "DataFormats/L1Trigger/interface/Tau.h"
#include "DataFormats/L1Trigger/interface/Jet.h"
#include "DataFormats/L1Trigger/interface/Muon.h"
#include "DataFormats/L1Trigger/interface/EtSum.h"
using namespace std;
using namespace edm;
using namespace l1t;
class L1TSummary : public EDAnalyzer {
public:
explicit L1TSummary(const ParameterSet&);
~L1TSummary() override;
static void fillDescriptions(ConfigurationDescriptions& descriptions);
private:
void beginJob() override;
void analyze(Event const&, EventSetup const&) override;
void endJob() override;
void beginRun(Run const&, EventSetup const&) override;
void endRun(Run const&, EventSetup const&) override;
void beginLuminosityBlock(LuminosityBlock const&, EventSetup const&) override;
void endLuminosityBlock(LuminosityBlock const&, EventSetup const&) override;
// Tag string to mark summary with:
string tag_;
// Checks to perform:
bool egCheck_;
bool tauCheck_;
bool jetCheck_;
bool sumCheck_;
bool muonCheck_;
bool bxZeroOnly_;
// EDM tokens:
edm::EDGetTokenT<EGammaBxCollection> egToken_;
std::vector<edm::EDGetTokenT<TauBxCollection>> tauTokens_;
edm::EDGetTokenT<JetBxCollection> jetToken_;
edm::EDGetTokenT<EtSumBxCollection> sumToken_;
edm::EDGetTokenT<MuonBxCollection> muonToken_;
// keep a tally for summary:
int egCount_;
int tauCount_;
int jetCount_;
int sumCount_;
int muonCount_;
};
L1TSummary::L1TSummary(const ParameterSet& iConfig) {
// InputTag barrelTfInputTag = iConfig.getParameter<InputTag>("barrelTFInput");
// InputTag overlapTfInputTag = iConfig.getParameter<InputTag>("overlapTFInput");
// InputTag forwardTfInputTag = iConfig.getParameter<InputTag>("forwardTFInput");
//m_barrelTfInputToken = consumes<MicroGMTConfiguration::InputCollection>(iConfig.getParameter<InputTag>("bmtfDigis"));
tag_ = iConfig.getParameter<string>("tag");
egCheck_ = iConfig.getParameter<bool>("egCheck");
tauCheck_ = iConfig.getParameter<bool>("tauCheck");
jetCheck_ = iConfig.getParameter<bool>("jetCheck");
sumCheck_ = iConfig.getParameter<bool>("sumCheck");
muonCheck_ = iConfig.getParameter<bool>("muonCheck");
bxZeroOnly_ = iConfig.getParameter<bool>("bxZeroOnly");
//cout << "L1T Summary for " << tag << "\n";
//cout << "DEBUG: egCheck: " << egCheck_ << "\n";
//cout << "DEBUG: tauCheck: " << tauCheck_ << "\n";
//cout << "DEBUG: jetCheck: " << jetCheck_ << "\n";
//cout << "DEBUG: sumCheck: " << sumCheck_ << "\n";
//cout << "DEBUG: muonCheck: " << muonCheck_ << "\n";
if (egCheck_) {
egToken_ = consumes<EGammaBxCollection>(iConfig.getParameter<InputTag>("egToken"));
}
if (tauCheck_) {
const auto& taus = iConfig.getParameter<std::vector<edm::InputTag>>("tauTokens");
for (const auto& tau : taus) {
tauTokens_.push_back(consumes<l1t::TauBxCollection>(tau));
}
}
if (jetCheck_) {
jetToken_ = consumes<JetBxCollection>(iConfig.getParameter<InputTag>("jetToken"));
}
if (sumCheck_) {
sumToken_ = consumes<EtSumBxCollection>(iConfig.getParameter<InputTag>("sumToken"));
}
if (muonCheck_) {
muonToken_ = consumes<MuonBxCollection>(iConfig.getParameter<InputTag>("muonToken"));
}
egCount_ = 0;
tauCount_ = 0;
jetCount_ = 0;
sumCount_ = 0;
muonCount_ = 0;
}
L1TSummary::~L1TSummary() {}
void L1TSummary::analyze(Event const& iEvent, EventSetup const& iSetup) {
cout << "L1TSummary Module output for " << tag_ << "\n";
if (egCheck_) {
Handle<EGammaBxCollection> XTMP;
iEvent.getByToken(egToken_, XTMP);
if (XTMP.isValid()) {
cout << "INFO: L1T found e-gamma collection.\n";
for (int ibx = XTMP->getFirstBX(); ibx <= XTMP->getLastBX(); ++ibx) {
for (auto it = XTMP->begin(ibx); it != XTMP->end(ibx); it++) {
if (bxZeroOnly_ && (ibx != 0))
continue;
if (it->et() > 0) {
egCount_++;
cout << "bx: " << ibx << " et: " << it->et() << " eta: " << it->eta() << " phi: " << it->phi()
<< "\n";
}
}
}
} else {
LogWarning("MissingProduct") << "L1Upgrade e-gamma's not found." << std::endl;
}
}
if (tauCheck_) {
for (auto& tautoken : tauTokens_) {
Handle<TauBxCollection> XTMP;
iEvent.getByToken(tautoken, XTMP);
if (XTMP.isValid()) {
cout << "INFO: L1T found tau collection.\n";
for (int ibx = XTMP->getFirstBX(); ibx <= XTMP->getLastBX(); ++ibx) {
for (auto it = XTMP->begin(ibx); it != XTMP->end(ibx); it++) {
if (it->et() > 0) {
if (bxZeroOnly_ && (ibx != 0))
continue;
tauCount_++;
cout << "bx: " << ibx << " et: " << it->et() << " eta: " << it->eta() << " phi: " << it->phi()
<< "\n";
}
}
}
} else {
LogWarning("MissingProduct") << "L1Upgrade tau's not found." << std::endl;
}
}
}
if (jetCheck_) {
Handle<JetBxCollection> XTMP;
iEvent.getByToken(jetToken_, XTMP);
if (XTMP.isValid()) {
cout << "INFO: L1T found jet collection.\n";
for (int ibx = XTMP->getFirstBX(); ibx <= XTMP->getLastBX(); ++ibx) {
for (auto it = XTMP->begin(ibx); it != XTMP->end(ibx); it++) {
if (it->et() > 0) {
if (bxZeroOnly_ && (ibx != 0))
continue;
jetCount_++;
cout << "bx: " << ibx << " et: " << it->et() << " eta: " << it->eta() << " phi: " << it->phi()
<< "\n";
}
}
}
} else {
LogWarning("MissingProduct") << "L1T upgrade jets not found." << std::endl;
}
}
if (sumCheck_) {
Handle<EtSumBxCollection> XTMP;
iEvent.getByToken(sumToken_, XTMP);
if (XTMP.isValid()) {
cout << "INFO: L1T found sum collection.\n";
for (int ibx = XTMP->getFirstBX(); ibx <= XTMP->getLastBX(); ++ibx) {
for (auto it = XTMP->begin(ibx); it != XTMP->end(ibx); it++) {
//if (it->et() > 0) {
if (bxZeroOnly_ && (ibx != 0))
continue;
sumCount_++;
cout << "bx: " << ibx << " et: " << it->et() << " eta: " << it->eta() << " phi: " << it->phi()
<< " type: " << it->getType() << "\n";
//}
}
}
} else {
LogWarning("MissingProduct") << "L1T upgrade sums not found." << std::endl;
}
}
if (muonCheck_) {
Handle<MuonBxCollection> XTMP;
iEvent.getByToken(muonToken_, XTMP);
if (XTMP.isValid()) {
cout << "INFO: L1T found muon collection.\n";
for (int ibx = XTMP->getFirstBX(); ibx <= XTMP->getLastBX(); ++ibx) {
for (auto it = XTMP->begin(ibx); it != XTMP->end(ibx); it++) {
if (it->et() > 0) {
if (bxZeroOnly_ && (ibx != 0))
continue;
muonCount_++;
cout << "bx: " << ibx << " et: " << it->et() << " eta: " << it->eta() << " phi: " << it->phi()
<< "\n";
}
}
}
} else {
LogWarning("MissingProduct") << "L1T upgrade muons not found." << std::endl;
}
}
}
void L1TSummary::beginJob() { cout << "INFO: L1TSummary module beginJob called.\n"; }
void L1TSummary::endJob() {
cout << "INFO: L1T Summary for " << tag_ << "\n";
cout << "INFO: count of non-zero candidates for each type follows:\n";
if (egCheck_)
cout << "eg: " << egCount_ << "\n";
if (tauCheck_)
cout << "tau: " << tauCount_ << "\n";
if (jetCheck_)
cout << "jet: " << jetCount_ << "\n";
if (sumCheck_)
cout << "sum: " << sumCount_ << "\n";
if (muonCheck_)
cout << "muon: " << muonCount_ << "\n";
}
void L1TSummary::beginRun(Run const& run, EventSetup const& iSetup) {}
void L1TSummary::endRun(Run const&, EventSetup const&) {}
void L1TSummary::beginLuminosityBlock(LuminosityBlock const&, EventSetup const&) {}
void L1TSummary::endLuminosityBlock(LuminosityBlock const&, EventSetup const&) {}
void L1TSummary::fillDescriptions(ConfigurationDescriptions& descriptions) {
//The following says we do not know what parameters are allowed so do no validation
// Please change this to state exactly what you do use, even if it is no parameters
ParameterSetDescription desc;
desc.setUnknown();
descriptions.addDefault(desc);
}
DEFINE_FWK_MODULE(L1TSummary);
| 34.126923 | 121 | 0.598219 | [
"vector"
] |
6f6a0a7d2227c0712babffe625f4e153139e01e3 | 2,345 | cpp | C++ | MonteCarlo/monte_carlo.cpp | fchapoton/NaCl | d3a584c548e7e81cf7734209a5e65a77763156a5 | [
"Apache-2.0"
] | 59 | 2015-01-06T14:16:28.000Z | 2021-07-22T04:31:45.000Z | MonteCarlo/monte_carlo.cpp | fchapoton/NaCl | d3a584c548e7e81cf7734209a5e65a77763156a5 | [
"Apache-2.0"
] | 4 | 2016-02-02T07:56:50.000Z | 2016-11-14T23:16:10.000Z | MonteCarlo/monte_carlo.cpp | fchapoton/NaCl | d3a584c548e7e81cf7734209a5e65a77763156a5 | [
"Apache-2.0"
] | 29 | 2015-03-10T15:35:55.000Z | 2021-07-22T04:31:46.000Z | #include "mc_instance.hpp"
#include "singleton_factory.hpp"
#include <vector>
#include <thread>
#include <functional>
pp::Module* pp::CreateModule() {
return new InstanceFactory<MonteCarloInstance>();
}
void MonteCarloInstance::Simulate( int32_t /*result*/,
std::function<int(double,double)> model, unsigned int N) {
// Run the simulation in 10 parts or max 1e6 points at a time
const len_t nParts = 10;
auto step = N/nParts;
step = step > 0 ? step : 1;
step = step < 1e6 ? step : 1e6;
len_t runningTotal = 0;
unsigned int count=0;
for( len_t i=step; i<=N; i += step) {
if ( run_simulation_ ) {
auto res = mc.sim(model, step);
runningTotal += res.Total;
auto outData = PostResponse( runningTotal, i);
count++;
}
}
pp::VarDictionary msg;
msg.Set( "Type", "completed" );
PostMessage( msg );
}
pp::VarDictionary MonteCarloInstance::PostResponse( len_t runningTotal, len_t i){
pp::VarDictionary outData;
outData.Set( "Type", "partial" );
outData.Set( "Samples", static_cast<double>(i) );
outData.Set( "Total", static_cast<double>(runningTotal) );
auto runningMean = 1.0*runningTotal/i;
outData.Set( "Mean", runningMean );
outData.Set( "StdError", sqrt( runningMean*(1.0-runningMean)/i));
PostMessage( outData ); // For progress measurement
return outData;
}
void MonteCarloInstance::HandleMessage( const pp::Var& var_message ) {
// Interface: receive a { cmd: ..., args... } dictionary
// - sim, nPts = start simulation with that number of runs
// - receive anything else = stop the simulation
pp::VarDictionary var_dict( var_message );
auto cmd = var_dict.Get( "cmd" ).AsString();
if ( cmd == "sim" ) {
// Message is number of simulations to run
auto N = var_dict.Get("nPts").AsInt();
auto modelFactory = SingletonFactory<std::function<int(double,double)>>::getInstance();
auto model = modelFactory.getObject( var_dict.Get("model").AsString() );
// Enable simulation
run_simulation_ = true;
// Start simulation on background thread
sim_thread_.message_loop().PostWork(
callback_factory_.NewCallback( &MonteCarloInstance::Simulate, model, N));
} else {
// Disable simulation - background thread will see this at start of
// next iteration and terminate early
run_simulation_ = false;
}
}
| 35 | 91 | 0.677186 | [
"vector",
"model"
] |
6f713343725ba855c93ab475b34de417fb49f69c | 6,449 | cc | C++ | src/kerberos.cc | NickNaso/kerberos | 743afb5da3adb00b51462f5d89447a97b0ad8b7a | [
"Apache-2.0"
] | null | null | null | src/kerberos.cc | NickNaso/kerberos | 743afb5da3adb00b51462f5d89447a97b0ad8b7a | [
"Apache-2.0"
] | null | null | null | src/kerberos.cc | NickNaso/kerberos | 743afb5da3adb00b51462f5d89447a97b0ad8b7a | [
"Apache-2.0"
] | null | null | null | #include <memory>
#include "common.h"
#include "kerberos.h"
#include "kerberos_client.h"
#include "kerberos_server.h"
#include "kerberos_worker.h"
using v8::FunctionTemplate;
#define GSS_MECH_OID_KRB5 9
#define GSS_MECH_OID_SPNEGO 6
static char krb5_mech_oid_bytes[] = "\x2a\x86\x48\x86\xf7\x12\x01\x02\x02";
gss_OID_desc krb5_mech_oid = {9, &krb5_mech_oid_bytes};
static char spnego_mech_oid_bytes[] = "\x2b\x06\x01\x05\x05\x02";
gss_OID_desc spnego_mech_oid = {6, &spnego_mech_oid_bytes};
NAN_METHOD(InitializeClient) {
std::string service(*Nan::Utf8String(info[0]));
v8::Local<v8::Object> options = Nan::To<v8::Object>(info[1]).ToLocalChecked();
Nan::Callback* callback = new Nan::Callback(Nan::To<v8::Function>(info[2]).ToLocalChecked());
std::string principal = StringOptionValue(options, "principal");
uint32_t gss_flags =
UInt32OptionValue(options, "gssFlags", GSS_C_MUTUAL_FLAG | GSS_C_SEQUENCE_FLAG);
uint32_t mech_oid_int = UInt32OptionValue(options, "mechOID", 0);
gss_OID mech_oid = GSS_C_NO_OID;
if (mech_oid_int == GSS_MECH_OID_KRB5) {
mech_oid = &krb5_mech_oid;
} else if (mech_oid_int == GSS_MECH_OID_SPNEGO) {
mech_oid = &spnego_mech_oid;
}
KerberosWorker::Run(callback, "kerberos:InitializeClient", [=](KerberosWorker::SetOnFinishedHandler onFinished) {
gss_client_state* client_state = gss_client_state_new();
std::shared_ptr<gss_result> result(authenticate_gss_client_init(
service.c_str(), principal.c_str(), gss_flags, NULL, mech_oid, client_state), ResultDeleter);
// must clean up state if we won't be using it, smart pointers won't help here unfortunately
// because we can't `release` a shared pointer.
if (result->code == AUTH_GSS_ERROR) {
free(client_state);
}
return onFinished([=](KerberosWorker* worker) {
Nan::HandleScope scope;
if (result->code == AUTH_GSS_ERROR) {
v8::Local<v8::Value> argv[] = {Nan::New(result->message).ToLocalChecked(), Nan::Null()};
worker->Call(2, argv);
return;
}
v8::Local<v8::Value> argv[] = {Nan::Null(), KerberosClient::NewInstance(client_state)};
worker->Call(2, argv);
});
});
}
NAN_METHOD(InitializeServer) {
std::string service(*Nan::Utf8String(info[0]));
Nan::Callback* callback = new Nan::Callback(Nan::To<v8::Function>(info[1]).ToLocalChecked());
KerberosWorker::Run(callback, "kerberos:InitializeServer", [=](KerberosWorker::SetOnFinishedHandler onFinished) {
gss_server_state* server_state = gss_server_state_new();
std::shared_ptr<gss_result> result(
authenticate_gss_server_init(service.c_str(), server_state), ResultDeleter);
// must clean up state if we won't be using it, smart pointers won't help here unfortunately
// because we can't `release` a shared pointer.
if (result->code == AUTH_GSS_ERROR) {
free(server_state);
}
return onFinished([=](KerberosWorker* worker) {
Nan::HandleScope scope;
if (result->code == AUTH_GSS_ERROR) {
v8::Local<v8::Value> argv[] = {Nan::New(result->message).ToLocalChecked(), Nan::Null()};
worker->Call(2, argv);
return;
}
v8::Local<v8::Value> argv[] = {Nan::Null(), KerberosServer::NewInstance(server_state)};
worker->Call(2, argv);
});
});
}
NAN_METHOD(PrincipalDetails) {
std::string service(*Nan::Utf8String(info[0]));
std::string hostname(*Nan::Utf8String(info[1]));
Nan::Callback* callback = new Nan::Callback(Nan::To<v8::Function>(info[2]).ToLocalChecked());
KerberosWorker::Run(callback, "kerberos:PrincipalDetails", [=](KerberosWorker::SetOnFinishedHandler onFinished) {
std::shared_ptr<gss_result> result(
server_principal_details(service.c_str(), hostname.c_str()), ResultDeleter);
return onFinished([=](KerberosWorker* worker) {
Nan::HandleScope scope;
if (result->code == AUTH_GSS_ERROR) {
v8::Local<v8::Value> argv[] = {Nan::New(result->message).ToLocalChecked(), Nan::Null()};
worker->Call(2, argv);
return;
}
v8::Local<v8::Value> argv[] = {Nan::Null(), Nan::New(result->data).ToLocalChecked()};
worker->Call(2, argv);
});
});
}
NAN_METHOD(CheckPassword) {
std::string username(*Nan::Utf8String(info[0]));
std::string password(*Nan::Utf8String(info[1]));
std::string service(*Nan::Utf8String(info[2]));
std::string defaultRealm(*Nan::Utf8String(info[3]));
Nan::Callback* callback = new Nan::Callback(Nan::To<v8::Function>(info[4]).ToLocalChecked());
KerberosWorker::Run(callback, "kerberos:CheckPassword", [=](KerberosWorker::SetOnFinishedHandler onFinished) {
std::shared_ptr<gss_result> result(authenticate_user_krb5pwd(
username.c_str(), password.c_str(), service.c_str(), defaultRealm.c_str()), ResultDeleter);
return onFinished([=](KerberosWorker* worker) {
Nan::HandleScope scope;
if (result->code == AUTH_GSS_ERROR) {
v8::Local<v8::Value> argv[] = {Nan::New(result->message).ToLocalChecked(), Nan::Null()};
worker->Call(2, argv);
} else {
v8::Local<v8::Value> argv[] = {Nan::Null(), Nan::Null()};
worker->Call(2, argv);
}
});
});
}
NAN_MODULE_INIT(Init) {
// Custom types
KerberosClient::Init(target);
KerberosServer::Init(target);
Nan::Set(target,
Nan::New("initializeClient").ToLocalChecked(),
Nan::GetFunction(Nan::New<FunctionTemplate>(InitializeClient)).ToLocalChecked());
Nan::Set(target,
Nan::New("initializeServer").ToLocalChecked(),
Nan::GetFunction(Nan::New<FunctionTemplate>(InitializeServer)).ToLocalChecked());
Nan::Set(target,
Nan::New("principalDetails").ToLocalChecked(),
Nan::GetFunction(Nan::New<FunctionTemplate>(PrincipalDetails)).ToLocalChecked());
Nan::Set(target,
Nan::New("checkPassword").ToLocalChecked(),
Nan::GetFunction(Nan::New<FunctionTemplate>(CheckPassword)).ToLocalChecked());
}
NODE_MODULE(kerberos, Init)
| 41.076433 | 117 | 0.630951 | [
"object"
] |
4cff5297a53e9f2cac213cbf706c30b4ee77abba | 1,664 | cc | C++ | src/include_diagram/visitor/translation_unit_context.cc | buffyanamin/clang-uml | 7ca70d97eecc0f3ab1267b024771edc6131950fb | [
"Apache-2.0"
] | null | null | null | src/include_diagram/visitor/translation_unit_context.cc | buffyanamin/clang-uml | 7ca70d97eecc0f3ab1267b024771edc6131950fb | [
"Apache-2.0"
] | null | null | null | src/include_diagram/visitor/translation_unit_context.cc | buffyanamin/clang-uml | 7ca70d97eecc0f3ab1267b024771edc6131950fb | [
"Apache-2.0"
] | null | null | null | /**
* src/include_diagram/visitor/translation_unit_context.cc
*
* Copyright (c) 2021-2022 Bartek Kryza <bkryza@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "translation_unit_context.h"
#include "cx/util.h"
namespace clanguml::include_diagram::visitor {
translation_unit_context::translation_unit_context(
cppast::cpp_entity_index &idx,
clanguml::include_diagram::model::diagram &diagram,
const clanguml::config::include_diagram &config)
: entity_index_{idx}
, diagram_{diagram}
, config_{config}
{
}
const cppast::cpp_entity_index &translation_unit_context::entity_index() const
{
return entity_index_;
}
const clanguml::config::include_diagram &
translation_unit_context::config() const
{
return config_;
}
clanguml::include_diagram::model::diagram &translation_unit_context::diagram()
{
return diagram_;
}
void translation_unit_context::set_current_file(
type_safe::optional_ref<common::model::source_file> f)
{
current_file_ = f;
}
type_safe::optional_ref<common::model::source_file>
translation_unit_context::get_current_file() const
{
return current_file_;
}
}
| 26 | 78 | 0.752404 | [
"model"
] |
98096abf0131b1333a6aafbbfea9b6fd4c138ae3 | 4,750 | cpp | C++ | GoogleCodeJam/GCJ21/Round2/B.cpp | Mindjolt2406/Competitive-Programming | d000d98bf7005ee4fb809bcea2f110e4c4793b80 | [
"MIT"
] | 2 | 2018-12-11T14:37:24.000Z | 2022-01-23T18:11:54.000Z | GoogleCodeJam/GCJ21/Round2/B.cpp | Mindjolt2406/Competitive-Programming | d000d98bf7005ee4fb809bcea2f110e4c4793b80 | [
"MIT"
] | null | null | null | GoogleCodeJam/GCJ21/Round2/B.cpp | Mindjolt2406/Competitive-Programming | d000d98bf7005ee4fb809bcea2f110e4c4793b80 | [
"MIT"
] | null | null | null | #include<bits/stdc++.h>
// g++ -std=c++17 -Wl,-stack_size -Wl,0x10000000 main.cpp
#define mt make_tuple
#define mp make_pair
#define pu push_back
#define INF 1000000001
#define MOD 1000000007
#define EPS 1e-6
#define ll long long int
#define ld long double
#define fi first
#define se second
#define all(v) v.begin(),v.end()
#define pr(v) { for(int i=0;i<v.size();i++) { v[i]==INF? cout<<"INF " : cout<<v[i]<<" "; } cout<<endl;}
#define t1(x) cerr<<#x<<" : "<<x<<endl
#define t2(x, y) cerr<<#x<<" : "<<x<<" "<<#y<<" : "<<y<<endl
#define t3(x, y, z) cerr<<#x<<" : " <<x<<" "<<#y<<" : "<<y<<" "<<#z<<" : "<<z<<endl
#define t4(a,b,c,d) cerr<<#a<<" : "<<a<<" "<<#b<<" : "<<b<<" "<<#c<<" : "<<c<<" "<<#d<<" : "<<d<<endl
#define t5(a,b,c,d,e) cerr<<#a<<" : "<<a<<" "<<#b<<" : "<<b<<" "<<#c<<" : "<<c<<" "<<#d<<" : "<<d<<" "<<#e<<" : "<<e<<endl
#define t6(a,b,c,d,e,f) cerr<<#a<<" : "<<a<<" "<<#b<<" : "<<b<<" "<<#c<<" : "<<c<<" "<<#d<<" : "<<d<<" "<<#e<<" : "<<e<<" "<<#f<<" : "<<f<<endl
#define GET_MACRO(_1,_2,_3,_4,_5,_6,NAME,...) NAME
#define t(...) GET_MACRO(__VA_ARGS__,t6,t5, t4, t3, t2, t1)(__VA_ARGS__)
#define _ cerr<<"here"<<endl;
#define __ {ios::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);}
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template<class A, class B> ostream& operator<<(ostream& out, const pair<A, B> &a){ return out<<"("<<a.first<<", "<<a.second<<")";}
template <int> ostream& operator<<(ostream& os, const vector<int>& v) { os << "["; for (int i = 0; i < v.size(); ++i) { if(v[i]!=INF) os << v[i]; else os << "INF";if (i != v.size() - 1) os << ", "; } os << "]\n"; return os; }
template <typename T> ostream& operator<<(ostream& os, const vector<T>& v) { os << "["; for (int i = 0; i < v.size(); ++i) { os << v[i]; ;if (i != v.size() - 1) os << ", "; } os << "]\n"; return os; }
template <typename T> ostream& operator<<(ostream& os, const set<T>& s) {os << "{"; for(auto it : s) {if(it != *s.rbegin()) os << it << ", "; else os << it;} os << "}"; return os;}
// const int MAXN = 1e6 + 10;
const int MAXN = 1e6 + 10;
// stores smallest prime factor for every number
ll spf[MAXN];
// Calculating SPF (Smallest Prime Factor) for every
// number till MAXN.
// Time Complexity : O(nloglogn)
void sieve()
{
spf[1] = 1;
for (ll i=2; i<MAXN; i++)
// marking smallest prime factor for every
// number to be itself.
spf[i] = i;
// separately marking spf for every even
// number as 2
for (ll i=4; i<MAXN; i+=2)
spf[i] = 2;
for (ll i=3; i*i<MAXN; i++)
{
// checking if i is prime
if (spf[i] == i)
{
// marking SPF for all numbers divisible by i
for (ll j=i*i; j<MAXN; j+=i)
// marking spf[j] if it is not
// previously marked
if (spf[j]==j)
spf[j] = i;
}
}
}
// A O(log n) function returning primefactorization
// by dividing by smallest prime factor at every step
vector<vector<int> > primeFactors(MAXN);
vector<int> getFactorization(int x)
{
// t(x);
vector<int> ret;
for(ll i = 2; i * i <= x; i++) {
if(x%i == 0) {
ret.pu(i);
if(i != x/i) ret.pu(x/i);
}
}
return ret;
}
void precompute() {
sieve();
for(int i = 3; i < MAXN; i++) {
// t(i);
primeFactors[i] = getFactorization(i);
}
}
vector<vector<pair<int, int> > > mapper(MAXN);
vector<int> invMapper(MAXN);
void precompute2() {
int N = MAXN;
// int N = 20;
for(int i = 3; i < N; i++) {
for(auto factor : primeFactors[i]) {
if(factor == 1 || factor == i) continue;
for(auto it : mapper[factor]) {
int val = it.fi, depth = it.se;
if(val + i < N) {
mapper[i].pu(mp(val + i, depth + 1));
invMapper[val + i] = max(invMapper[val + i], depth + 1);
// if(it + i == 12) t(i, depth[i], 12);
}
}
}
// depth[i] = max(depth[i], 1);
mapper[i].pu(mp(i, 1));
invMapper[i] = max(invMapper[i], 1);
}
// t(primeFactors[12]);
// for(int i = 3; i < 20; i++) {
// t(i, mapper[i]);
// }
// for(int i = 3; i < 20; i++) {
// t(i, invMapper[i]);
// t(i, mapper[i]);
// }
}
void solve() {
int n;
cin >> n;
cout << invMapper[n] << endl;
}
int main() {
precompute();
precompute2();
__;
int t;
cin >> t;
for(int h = 1; h <= t; h++) {
cout << "Case #" << h << ": ";
solve();
}
return 0;
}
| 31.25 | 226 | 0.473684 | [
"vector"
] |
981c5ee33896be6f36d4c731797f463c4297e22e | 4,881 | cpp | C++ | LibRocketNet/Context.cpp | daeken/LibRocket.Net | 6990f3f5cab214e0cded94054af980bd01795d5f | [
"MIT"
] | 1 | 2016-10-29T02:58:18.000Z | 2016-10-29T02:58:18.000Z | LibRocketNet/Context.cpp | daeken/LibRocket.Net | 6990f3f5cab214e0cded94054af980bd01795d5f | [
"MIT"
] | null | null | null | LibRocketNet/Context.cpp | daeken/LibRocket.Net | 6990f3f5cab214e0cded94054af980bd01795d5f | [
"MIT"
] | null | null | null | #include "stdafx.h"
#include "Context.h"
#include "Util.h"
#include "Element.h"
#include "ElementDocument.h"
#include "Rocket/Core/Context.h"
namespace LibRocketNet {
Context::Context(Rocket::Core::Context * ctx) {
ContextPtr = ctx;
ContextPtr->AddReference();
}
Context::~Context() {
ContextPtr->RemoveReference();
}
String^ Context::Name::get() {
return Util::ToNetString(ContextPtr->GetName());
}
Vector2i Context::Dimensions::get() {
return Vector2i(ContextPtr->GetDimensions());
}
void Context::Dimensions::set(Vector2i d){
ContextPtr->SetDimensions(Rocket::Core::Vector2i(d.X, d.Y));
}
bool Context::Update() {
return ContextPtr->Update();
}
bool Context::Render() {
return ContextPtr->Render();
}
ElementDocument^ Context::CreateDocument(String^ tag) {
auto docPtr = ContextPtr->CreateDocument(Util::ToRocketString(tag));
if (!docPtr) return nullptr;
return ElementDocument::Create(docPtr);
}
ElementDocument^ Context::LoadDocument(String^ documentPath) {
auto docPtr = ContextPtr->LoadDocument(Util::ToRocketString(documentPath));
if (!docPtr) return nullptr;
return ElementDocument::Create(docPtr);
}
ElementDocument^ Context::LoadDocumentFromMemory(String^ str) {
auto docPtr = ContextPtr->LoadDocumentFromMemory(Util::ToRocketString(str));
if (!docPtr) return nullptr;
return ElementDocument::Create(docPtr);
}
void Context::UnloadDocument(ElementDocument^ document) {
ContextPtr->UnloadDocument(document->DocumentPtr);
}
void Context::UnloadAllDocuments() {
ContextPtr->UnloadAllDocuments();
}
void Context::AddMouseCursor(ElementDocument ^ cursorDocument) {
ContextPtr->AddMouseCursor(cursorDocument->DocumentPtr);
}
ElementDocument^ Context::LoadMouseCursor(String^ documentPath) {
auto docPtr = ContextPtr->LoadMouseCursor(Util::ToRocketString(documentPath));
if (!docPtr) return nullptr;
return ElementDocument::Create(docPtr);
}
void Context::UnloadMouseCursor(String^ cursorName) {
ContextPtr->UnloadMouseCursor(Util::ToRocketString(cursorName));
}
void Context::UnloadAllMouseCursors() {
ContextPtr->UnloadAllMouseCursors();
}
void Context::ShowMouseCursor(bool show) {
ContextPtr->ShowMouseCursor(show);
}
bool Context::SetMouseCursor(String^ cursor) {
return ContextPtr->SetMouseCursor(Util::ToRocketString(cursor));
}
ElementDocument^ Context::GetDocument(String^ id) {
return ElementDocument::Create(ContextPtr->GetDocument(Util::ToRocketString(id)));
}
ElementDocument^ Context::GetDocument(int index) {
return ElementDocument::Create(ContextPtr->GetDocument(index));
}
int Context::NumDocuments::get() {
return ContextPtr->GetNumDocuments();
}
Element^ Context::HoverElement::get() {
return Element::Create(ContextPtr->GetHoverElement());
}
Element^ Context::FocusElement::get(){
return Element::Create(ContextPtr->GetFocusElement());
}
Element^ Context::RootElement::get(){
return Element::Create(ContextPtr->GetRootElement());
}
void Context::PullDocumentToFront(ElementDocument^ document) {
ContextPtr->PullDocumentToFront(document->DocumentPtr);
}
void Context::PushDocumentToBack(ElementDocument^ document) {
ContextPtr->PushDocumentToBack(document->DocumentPtr);
}
bool Context::ProcessKeyDown(KeyIdentifiers key, KeyModifier modifiers) {
return ContextPtr->ProcessKeyDown((Rocket::Core::Input::KeyIdentifier)key, (int)modifiers);
}
bool Context::ProcessKeyUp(KeyIdentifiers key, KeyModifier modifiers){
return ContextPtr->ProcessKeyUp((Rocket::Core::Input::KeyIdentifier)key, (int)modifiers);
}
bool Context::ProcessTextInput(unsigned short int word) {
return ContextPtr->ProcessTextInput(word);
}
void Context::ProcessMouseMove(int x, int y, KeyModifier keyModifierState) {
ContextPtr->ProcessMouseMove(x, y, (int)keyModifierState);
}
void Context::ProcessMouseButtonDown(int buttonIndex, KeyModifier keyModifierState) {
ContextPtr->ProcessMouseButtonDown(buttonIndex, (int)keyModifierState);
}
void Context::ProcessMouseButtonUp(int buttonIndex, KeyModifier keyModifierState) {
ContextPtr->ProcessMouseButtonUp(buttonIndex, (int)keyModifierState);
}
void Context::ProcessMouseWheel(int wheelDelta, KeyModifier keyModifierState) {
ContextPtr->ProcessMouseWheel(wheelDelta, (int)keyModifierState);
}
RenderInterface^ Context::RenderInterface::get() {
return _renderInterface;
}
bool Context::GetActiveClipRegion(Vector2i% origin, Vector2i% dimensions) {
Rocket::Core::Vector2i o;
Rocket::Core::Vector2i d;
auto ret = ContextPtr->GetActiveClipRegion(o, d);
origin = Vector2i(o.x,o.y);
dimensions = Vector2i(d.x, d.y);
return ret;
}
void Context::SetActiveClipRegion(Vector2i origin, Vector2i dimensions) {
ContextPtr->SetActiveClipRegion(Rocket::Core::Vector2i(origin.X, origin.Y), Rocket::Core::Vector2i(dimensions.X, dimensions.Y));
}
} | 28.711765 | 130 | 0.754558 | [
"render"
] |
981dacdca6ef7be9e6e5d2ae65e21b5e0cbd85e8 | 4,319 | hpp | C++ | src/boost/test/utils/runtime/argument.hpp | Liastre/uri | f5a701d19e3dd9cec950dcc70f6a42f0d9151f89 | [
"BSL-1.0"
] | 521 | 2016-02-14T00:39:01.000Z | 2022-03-01T22:39:25.000Z | src/boost/test/utils/runtime/argument.hpp | Liastre/uri | f5a701d19e3dd9cec950dcc70f6a42f0d9151f89 | [
"BSL-1.0"
] | 8 | 2017-02-21T11:47:33.000Z | 2018-11-01T09:37:14.000Z | src/boost/test/utils/runtime/argument.hpp | Liastre/uri | f5a701d19e3dd9cec950dcc70f6a42f0d9151f89 | [
"BSL-1.0"
] | 48 | 2017-02-21T10:18:13.000Z | 2022-03-25T02:35:20.000Z | // (C) Copyright Gennadiy Rozental 2001.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// See http://www.boost.org/libs/test for the library home page.
//
// File : $RCSfile$
//
// Version : $Revision$
//
// Description : model of actual argument (both typed and abstract interface)
// ***************************************************************************
#ifndef BOOST_TEST_UTILS_RUNTIME_ARGUMENT_HPP
#define BOOST_TEST_UTILS_RUNTIME_ARGUMENT_HPP
// Boost.Test Runtime parameters
#include <boost/test/utils/runtime/fwd.hpp>
#include <boost/test/utils/runtime/errors.hpp>
// Boost.Test
#include <boost/test/utils/class_properties.hpp>
#include <boost/test/utils/rtti.hpp>
#include <boost/test/utils/basic_cstring/compare.hpp>
#include <boost/test/detail/throw_exception.hpp>
// STL
#include <cassert>
#include <boost/test/detail/suppress_warnings.hpp>
namespace network_boost {
namespace runtime {
// ************************************************************************** //
// ************** runtime::argument ************** //
// ************************************************************************** //
class argument {
public:
// Constructor
argument( rtti::id_t value_type )
: p_value_type( value_type )
{}
// Destructor
virtual ~argument() {}
// Public properties
rtti::id_t const p_value_type;
};
// ************************************************************************** //
// ************** runtime::typed_argument ************** //
// ************************************************************************** //
template<typename T>
class typed_argument : public argument {
public:
// Constructor
explicit typed_argument( T const& v )
: argument( rtti::type_id<T>() )
, p_value( v )
{}
unit_test::readwrite_property<T> p_value;
};
// ************************************************************************** //
// ************** runtime::arguments_store ************** //
// ************************************************************************** //
class arguments_store {
public:
typedef std::map<cstring, argument_ptr> storage_type;
/// Returns number of arguments in the store; mostly used for testing
std::size_t size() const { return m_arguments.size(); }
/// Clears the store for reuse
void clear() { m_arguments.clear(); }
/// Returns true if there is an argument corresponding to the specified parameter name
bool has( cstring parameter_name ) const
{
return m_arguments.find( parameter_name ) != m_arguments.end();
}
/// Provides types access to argument value by parameter name
template<typename T>
T const& get( cstring parameter_name ) const {
return const_cast<arguments_store*>(this)->get<T>( parameter_name );
}
template<typename T>
T& get( cstring parameter_name ) {
storage_type::const_iterator found = m_arguments.find( parameter_name );
BOOST_TEST_I_ASSRT( found != m_arguments.end(),
access_to_missing_argument()
<< "There is no argument provided for parameter "
<< parameter_name );
argument_ptr arg = found->second;
BOOST_TEST_I_ASSRT( arg->p_value_type == rtti::type_id<T>(),
arg_type_mismatch()
<< "Access with invalid type for argument corresponding to parameter "
<< parameter_name );
return static_cast<typed_argument<T>&>( *arg ).p_value.value;
}
/// Set's the argument value for specified parameter name
template<typename T>
void set( cstring parameter_name, T const& value )
{
m_arguments[parameter_name] = argument_ptr( new typed_argument<T>( value ) );
}
private:
// Data members
storage_type m_arguments;
};
} // namespace runtime
} // namespace network_boost
#include <boost/test/detail/enable_warnings.hpp>
#endif // BOOST_TEST_UTILS_RUNTIME_ARGUMENT_HPP
| 32.719697 | 102 | 0.542487 | [
"model"
] |
98222aeb5fe416f8a421d790a7d53d5a5c4d29a9 | 8,743 | hpp | C++ | lg/solvers/htd-master/include/htd/MultiHypergraph.hpp | vuphan314/dpo | e24fe63fc3321c0cd6d2179c3300596b91082ab5 | [
"MIT"
] | 14 | 2020-01-31T23:02:39.000Z | 2021-12-26T06:00:13.000Z | lg/solvers/htd-master/include/htd/MultiHypergraph.hpp | vuphan314/dpo | e24fe63fc3321c0cd6d2179c3300596b91082ab5 | [
"MIT"
] | 3 | 2020-06-27T21:11:46.000Z | 2020-06-27T21:11:47.000Z | lg/solvers/htd-master/include/htd/MultiHypergraph.hpp | vuphan314/dpo | e24fe63fc3321c0cd6d2179c3300596b91082ab5 | [
"MIT"
] | 2 | 2020-08-08T03:04:30.000Z | 2021-05-21T04:56:02.000Z | /*
* File: MultiHypergraph.hpp
*
* Author: ABSEHER Michael (abseher@dbai.tuwien.ac.at)
*
* Copyright 2015-2017, Michael Abseher
* E-Mail: <abseher@dbai.tuwien.ac.at>
*
* This file is part of htd.
*
* htd is free software: you can redistribute it and/or modify it under
* the terms of the GNU General Public License as published by the Free
* Software Foundation, either version 3 of the License, or (at your
* option) any later version.
*
* htd 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 General Public
* License for more details.
* You should have received a copy of the GNU General Public License
* along with htd. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef HTD_HTD_MULTIHYPERGRAPH_HPP
#define HTD_HTD_MULTIHYPERGRAPH_HPP
#include <htd/IMutableMultiHypergraph.hpp>
#include <htd/LibraryInstance.hpp>
#include <vector>
#include <unordered_set>
namespace htd
{
/**
* Default implementation of the IMutableMultiHypergraph interface.
*/
class MultiHypergraph : public virtual htd::IMutableMultiHypergraph
{
public:
/**
* Constructor for a multi-hypergraph.
*
* @param[in] manager The management instance to which the new multi-hypergraph belongs.
*/
HTD_API MultiHypergraph(const htd::LibraryInstance * const manager);
/**
* Constructor for a multi-hypergraph.
*
* @param[in] manager The management instance to which the new multi-hypergraph belongs.
* @param[in] initialSize The initial size of the created graph.
*/
HTD_API MultiHypergraph(const htd::LibraryInstance * const manager, std::size_t initialSize);
/**
* Copy constructor for a multi-hypergraph.
*
* @param[in] original The original multi-hypergraph.
*/
HTD_API MultiHypergraph(const MultiHypergraph & original);
/**
* Copy constructor for a multi-hypergraph.
*
* @param[in] original The original multi-hypergraph.
*/
HTD_API MultiHypergraph(const htd::IMultiHypergraph & original);
HTD_API virtual ~MultiHypergraph();
HTD_API std::size_t vertexCount(void) const HTD_OVERRIDE;
HTD_API std::size_t edgeCount(void) const HTD_OVERRIDE;
HTD_API std::size_t edgeCount(htd::vertex_t vertex) const HTD_OVERRIDE;
HTD_API bool isVertex(htd::vertex_t vertex) const HTD_OVERRIDE;
HTD_API bool isEdge(htd::id_t edgeId) const HTD_OVERRIDE;
HTD_API bool isEdge(htd::vertex_t vertex1, htd::vertex_t vertex2) const HTD_OVERRIDE;
HTD_API bool isEdge(const std::vector<htd::vertex_t> & elements) const HTD_OVERRIDE;
HTD_API bool isEdge(const htd::ConstCollection<htd::vertex_t> & elements) const HTD_OVERRIDE;
HTD_API htd::ConstCollection<htd::id_t> associatedEdgeIds(htd::vertex_t vertex1, htd::vertex_t vertex2) const HTD_OVERRIDE;
HTD_API htd::ConstCollection<htd::id_t> associatedEdgeIds(const std::vector<htd::vertex_t> & elements) const HTD_OVERRIDE;
HTD_API htd::ConstCollection<htd::id_t> associatedEdgeIds(const htd::ConstCollection<htd::vertex_t> & elements) const HTD_OVERRIDE;
HTD_API htd::ConstCollection<htd::vertex_t> vertices(void) const HTD_OVERRIDE;
/**
* Access the vector of all vertices in the tree.
*
* @return The vector of all vertices in the tree sorted in ascending order.
*/
HTD_API const std::vector<htd::vertex_t> & vertexVector(void) const;
HTD_API void copyVerticesTo(std::vector<htd::vertex_t> & target) const HTD_OVERRIDE;
HTD_API htd::vertex_t vertexAtPosition(htd::index_t index) const HTD_OVERRIDE;
HTD_API bool isConnected(void) const HTD_OVERRIDE;
HTD_API bool isConnected(htd::vertex_t vertex1, htd::vertex_t vertex2) const HTD_OVERRIDE;
HTD_API bool isNeighbor(htd::vertex_t vertex, htd::vertex_t neighbor) const HTD_OVERRIDE;
HTD_API std::size_t neighborCount(htd::vertex_t vertex) const HTD_OVERRIDE;
HTD_API htd::ConstCollection<htd::vertex_t> neighbors(htd::vertex_t vertex) const HTD_OVERRIDE;
HTD_API void copyNeighborsTo(htd::vertex_t vertex, std::vector<htd::vertex_t> & target) const HTD_OVERRIDE;
HTD_API htd::vertex_t neighborAtPosition(htd::vertex_t vertex, htd::index_t index) const HTD_OVERRIDE;
HTD_API std::size_t isolatedVertexCount(void) const HTD_OVERRIDE;
HTD_API htd::ConstCollection<htd::vertex_t> isolatedVertices(void) const HTD_OVERRIDE;
HTD_API htd::vertex_t isolatedVertexAtPosition(htd::index_t index) const HTD_OVERRIDE;
HTD_API bool isIsolatedVertex(htd::vertex_t vertex) const HTD_OVERRIDE;
HTD_API htd::ConstCollection<htd::Hyperedge> hyperedges(void) const HTD_OVERRIDE;
HTD_API htd::ConstCollection<htd::Hyperedge> hyperedges(htd::vertex_t vertex) const HTD_OVERRIDE;
HTD_API const htd::Hyperedge & hyperedge(htd::id_t edgeId) const HTD_OVERRIDE;
HTD_API const htd::Hyperedge & hyperedgeAtPosition(htd::index_t index) const HTD_OVERRIDE;
HTD_API const htd::Hyperedge & hyperedgeAtPosition(htd::index_t index, htd::vertex_t vertex) const HTD_OVERRIDE;
HTD_API htd::FilteredHyperedgeCollection hyperedgesAtPositions(const std::vector<htd::index_t> & indices) const HTD_OVERRIDE;
HTD_API htd::FilteredHyperedgeCollection hyperedgesAtPositions(std::vector<htd::index_t> && indices) const HTD_OVERRIDE;
HTD_API htd::vertex_t nextVertex(void) const HTD_OVERRIDE;
HTD_API htd::id_t nextEdgeId(void) const HTD_OVERRIDE;
HTD_API htd::vertex_t addVertex(void) HTD_OVERRIDE;
HTD_API htd::vertex_t addVertices(std::size_t count) HTD_OVERRIDE;
HTD_API void removeVertex(htd::vertex_t vertex) HTD_OVERRIDE;
HTD_API htd::id_t addEdge(htd::vertex_t vertex1, htd::vertex_t vertex2) HTD_OVERRIDE;
HTD_API htd::id_t addEdge(const std::vector<htd::vertex_t> & elements) HTD_OVERRIDE;
HTD_API htd::id_t addEdge(std::vector<htd::vertex_t> && elements) HTD_OVERRIDE;
HTD_API htd::id_t addEdge(const htd::ConstCollection<htd::vertex_t> & elements) HTD_OVERRIDE;
HTD_API htd::id_t addEdge(const htd::Hyperedge & hyperedge) HTD_OVERRIDE;
HTD_API htd::id_t addEdge(htd::Hyperedge && hyperedge) HTD_OVERRIDE;
HTD_API void removeEdge(htd::id_t edgeId) HTD_OVERRIDE;
HTD_API const htd::LibraryInstance * managementInstance(void) const HTD_NOEXCEPT HTD_OVERRIDE;
HTD_API void setManagementInstance(const htd::LibraryInstance * const manager) HTD_OVERRIDE;
#ifndef HTD_USE_VISUAL_STUDIO_COMPATIBILITY_MODE
HTD_API MultiHypergraph * clone(void) const HTD_OVERRIDE;
#else
/**
* Create a deep copy of the current mutable multi-hypergraph.
*
* @return A new MultiHypergraph object identical to the current mutable multi-hypergraph.
*/
HTD_API MultiHypergraph * clone(void) const;
HTD_API htd::IGraphStructure * cloneGraphStructure(void) const HTD_OVERRIDE;
HTD_API htd::IMultiHypergraph * cloneMultiHypergraph(void) const HTD_OVERRIDE;
HTD_API htd::IMutableMultiHypergraph * cloneMutableMultiHypergraph(void) const HTD_OVERRIDE;
#endif
/**
* Copy assignment operator for a mutable multi-hypergraph.
*
* @param[in] original The original multi-hypergraph.
*/
HTD_API MultiHypergraph & operator=(const MultiHypergraph & original);
#ifndef HTD_USE_VISUAL_STUDIO_COMPATIBILITY_MODE
HTD_API MultiHypergraph & operator=(const htd::IMultiHypergraph & original) HTD_OVERRIDE;
#else
HTD_API MultiHypergraph & operator=(const htd::IMultiHypergraph & original);
HTD_API void assign(const htd::IMultiHypergraph & original) HTD_OVERRIDE;
#endif
private:
struct Implementation;
std::unique_ptr<Implementation> implementation_;
};
}
#endif /* HTD_HTD_MULTIHYPERGRAPH_HPP */
| 41.240566 | 143 | 0.669335 | [
"object",
"vector"
] |
982dddcf7d82a8db9ee5b3ac13670949411a308f | 989 | cpp | C++ | Cpp/Kattis/Naive/flexible.cpp | kchevali/OnlineJudge | c1d1894078fa45eef05c8785aba29758d9adf0c6 | [
"MIT"
] | null | null | null | Cpp/Kattis/Naive/flexible.cpp | kchevali/OnlineJudge | c1d1894078fa45eef05c8785aba29758d9adf0c6 | [
"MIT"
] | null | null | null | Cpp/Kattis/Naive/flexible.cpp | kchevali/OnlineJudge | c1d1894078fa45eef05c8785aba29758d9adf0c6 | [
"MIT"
] | null | null | null | #include <bits/stdc++.h>
#define PB emplace_back
#define C cout <<
#define E << "\n"
#define _ << " " <<
#define gc getchar_unlocked
#define fpp(i, a, b) for (i = a; i < b; i++)
using namespace std;
typedef long long l;
typedef vector<l> vl;
typedef vector<bool> vb;
typedef vector<vl> vvl;
void read(l &x) { // cannot be use with cin or something
l c = gc();
x = 0;
int neg = 0;
for (; ((c < 48 || c > 57) && c != '-'); c = gc())
;
if (c == '-') {
neg = 1;
c = gc();
}
for (; c > 47 && c < 58; c = gc()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (neg) x = -x;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
l w, n, i, j;
read(w);
read(n);
vl v = vl(n + 2, 0);
fpp(i, 0, n) { read(v[i + 1]); }
v[n + 1] = w;
vb ans = vb(w + 1, 0);
fpp(i, 0, n + 2) {
fpp(j, i + 1, n + 2) { ans[v[j] - v[i]] = 1; }
}
string s = "";
fpp(i, 0, w + 1) {
if (ans[i]) {
s += to_string(i) + " ";
}
}
C s E;
}
| 18.314815 | 57 | 0.450961 | [
"vector"
] |
9830c85fb40b119c7ab8f5282a88aedc3ef87e8d | 13,559 | cxx | C++ | main/sc/source/ui/docshell/docsh6.cxx | Grosskopf/openoffice | 93df6e8a695d5e3eac16f3ad5e9ade1b963ab8d7 | [
"Apache-2.0"
] | 679 | 2015-01-06T06:34:58.000Z | 2022-03-30T01:06:03.000Z | main/sc/source/ui/docshell/docsh6.cxx | Grosskopf/openoffice | 93df6e8a695d5e3eac16f3ad5e9ade1b963ab8d7 | [
"Apache-2.0"
] | 102 | 2017-11-07T08:51:31.000Z | 2022-03-17T12:13:49.000Z | main/sc/source/ui/docshell/docsh6.cxx | Grosskopf/openoffice | 93df6e8a695d5e3eac16f3ad5e9ade1b963ab8d7 | [
"Apache-2.0"
] | 331 | 2015-01-06T11:40:55.000Z | 2022-03-14T04:07:51.000Z | /**************************************************************
*
* 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
*
* 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.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sc.hxx"
// System - Includes -----------------------------------------------------
#ifndef PCH
#include "scitems.hxx"
#include <svx/pageitem.hxx>
#include <vcl/virdev.hxx>
#include <sfx2/linkmgr.hxx>
#endif
// INCLUDE ---------------------------------------------------------------
//#include <svxlink.hxx>
#include "docsh.hxx"
#include "stlsheet.hxx"
#include "stlpool.hxx"
#include "global.hxx"
#include "viewdata.hxx"
#include "tabvwsh.hxx"
#include "tablink.hxx"
#include "collect.hxx"
struct ScStylePair
{
SfxStyleSheetBase *pSource;
SfxStyleSheetBase *pDest;
};
// STATIC DATA -----------------------------------------------------------
//----------------------------------------------------------------------
//
// Ole
//
void __EXPORT ScDocShell::SetVisArea( const Rectangle & rVisArea )
{
// with the SnapVisArea call in SetVisAreaOrSize, it's safe to always
// use both the size and position of the VisArea
SetVisAreaOrSize( rVisArea, sal_True );
}
void lcl_SetTopRight( Rectangle& rRect, const Point& rPos )
{
Size aSize = rRect.GetSize();
rRect.Right() = rPos.X();
rRect.Left() = rPos.X() - aSize.Width() + 1;
rRect.Top() = rPos.Y();
rRect.Bottom() = rPos.Y() + aSize.Height() - 1;
}
void ScDocShell::SetVisAreaOrSize( const Rectangle& rVisArea, sal_Bool bModifyStart )
{
sal_Bool bNegativePage = aDocument.IsNegativePage( aDocument.GetVisibleTab() );
Rectangle aArea = rVisArea;
if (bModifyStart)
{
// when loading, don't check for negative values, because the sheet orientation
// might be set later
if ( !aDocument.IsImportingXML() )
{
if ( ( bNegativePage ? (aArea.Right() > 0) : (aArea.Left() < 0) ) || aArea.Top() < 0 )
{
// VisArea start position can't be negative.
// Move the VisArea, otherwise only the upper left position would
// be changed in SnapVisArea, and the size would be wrong.
Point aNewPos( 0, Max( aArea.Top(), (long) 0 ) );
if ( bNegativePage )
{
aNewPos.X() = Min( aArea.Right(), (long) 0 );
lcl_SetTopRight( aArea, aNewPos );
}
else
{
aNewPos.X() = Max( aArea.Left(), (long) 0 );
aArea.SetPos( aNewPos );
}
}
}
}
else
{
Rectangle aOldVisArea = SfxObjectShell::GetVisArea();
if ( bNegativePage )
lcl_SetTopRight( aArea, aOldVisArea.TopRight() );
else
aArea.SetPos( aOldVisArea.TopLeft() );
}
// hier Position anpassen!
// #92248# when loading an ole object, the VisArea is set from the document's
// view settings and must be used as-is (document content may not be complete yet).
if ( !aDocument.IsImportingXML() )
aDocument.SnapVisArea( aArea );
//TODO/LATER: it's unclear which IPEnv is used here
/*
SvInPlaceEnvironment* pEnv = GetIPEnv();
if (pEnv)
{
Window* pWin = pEnv->GetEditWin();
pEnv->MakeScale( aArea.GetSize(), MAP_100TH_MM,
pWin->LogicToPixel( aArea.GetSize() ) );
} */
//TODO/LATER: formerly in SvInplaceObject
SfxObjectShell::SetVisArea( aArea );
if (bIsInplace) // Zoom in der InPlace View einstellen
{
ScTabViewShell* pViewSh = ScTabViewShell::GetActiveViewShell();
if (pViewSh)
{
if (pViewSh->GetViewData()->GetDocShell() == this)
pViewSh->UpdateOleZoom();
}
//else
// DataChanged( SvDataType() ); // fuer Zuppeln wenn nicht IP-aktiv
}
if (aDocument.IsEmbedded())
{
ScRange aOld;
aDocument.GetEmbedded( aOld);
aDocument.SetEmbedded( aArea );
ScRange aNew;
aDocument.GetEmbedded( aNew);
if (aOld != aNew)
PostPaint(0,0,0,MAXCOL,MAXROW,MAXTAB,PAINT_GRID);
//TODO/LATER: currently not implemented
//ViewChanged( ASPECT_CONTENT ); // auch im Container anzeigen
}
}
sal_Bool ScDocShell::IsOle()
{
return (GetCreateMode() == SFX_CREATE_MODE_EMBEDDED);
}
void ScDocShell::UpdateOle( const ScViewData* pViewData, sal_Bool bSnapSize )
{
// wenn's gar nicht Ole ist, kann man sich die Berechnungen sparen
// (VisArea wird dann beim Save wieder zurueckgesetzt)
if (GetCreateMode() == SFX_CREATE_MODE_STANDARD)
return;
DBG_ASSERT(pViewData,"pViewData==0 bei ScDocShell::UpdateOle");
Rectangle aOldArea = SfxObjectShell::GetVisArea();
Rectangle aNewArea = aOldArea;
sal_Bool bChange = sal_False;
sal_Bool bEmbedded = aDocument.IsEmbedded();
if (bEmbedded)
aNewArea = aDocument.GetEmbeddedRect();
else
{
SCTAB nTab = pViewData->GetTabNo();
if ( nTab != aDocument.GetVisibleTab() )
{
aDocument.SetVisibleTab( nTab );
bChange = sal_True;
}
sal_Bool bNegativePage = aDocument.IsNegativePage( nTab );
SCCOL nX = pViewData->GetPosX(SC_SPLIT_LEFT);
SCROW nY = pViewData->GetPosY(SC_SPLIT_BOTTOM);
Rectangle aMMRect = aDocument.GetMMRect( nX,nY, nX,nY, nTab );
if (bNegativePage)
lcl_SetTopRight( aNewArea, aMMRect.TopRight() );
else
aNewArea.SetPos( aMMRect.TopLeft() );
if (bSnapSize)
aDocument.SnapVisArea(aNewArea); // uses the new VisibleTab
}
if (aNewArea != aOldArea)
{
SetVisAreaOrSize( aNewArea, sal_True ); // hier muss auch der Start angepasst werden
bChange = sal_True;
}
// if (bChange)
// DataChanged( SvDataType() ); //! passiert auch bei SetModified
}
//
// Style-Krempel fuer Organizer etc.
//
SfxStyleSheetBasePool* __EXPORT ScDocShell::GetStyleSheetPool()
{
return (SfxStyleSheetBasePool*)aDocument.GetStyleSheetPool();
}
// nach dem Laden von Vorlagen aus einem anderen Dokment (LoadStyles, Insert)
// muessen die SetItems (ATTR_PAGE_HEADERSET, ATTR_PAGE_FOOTERSET) auf den richtigen
// Pool umgesetzt werden, bevor der Quell-Pool geloescht wird.
void lcl_AdjustPool( SfxStyleSheetBasePool* pStylePool )
{
pStylePool->SetSearchMask(SFX_STYLE_FAMILY_PAGE, 0xffff);
SfxStyleSheetBase *pStyle = pStylePool->First();
while ( pStyle )
{
SfxItemSet& rStyleSet = pStyle->GetItemSet();
const SfxPoolItem* pItem;
if (rStyleSet.GetItemState(ATTR_PAGE_HEADERSET,sal_False,&pItem) == SFX_ITEM_SET)
{
SfxItemSet& rSrcSet = ((SvxSetItem*)pItem)->GetItemSet();
SfxItemSet* pDestSet = new SfxItemSet(*rStyleSet.GetPool(),rSrcSet.GetRanges());
pDestSet->Put(rSrcSet);
rStyleSet.Put(SvxSetItem(ATTR_PAGE_HEADERSET,pDestSet));
}
if (rStyleSet.GetItemState(ATTR_PAGE_FOOTERSET,sal_False,&pItem) == SFX_ITEM_SET)
{
SfxItemSet& rSrcSet = ((SvxSetItem*)pItem)->GetItemSet();
SfxItemSet* pDestSet = new SfxItemSet(*rStyleSet.GetPool(),rSrcSet.GetRanges());
pDestSet->Put(rSrcSet);
rStyleSet.Put(SvxSetItem(ATTR_PAGE_FOOTERSET,pDestSet));
}
pStyle = pStylePool->Next();
}
}
void __EXPORT ScDocShell::LoadStyles( SfxObjectShell &rSource )
{
aDocument.StylesToNames();
SfxObjectShell::LoadStyles(rSource);
lcl_AdjustPool( GetStyleSheetPool() ); // SetItems anpassen
aDocument.UpdStlShtPtrsFrmNms();
UpdateAllRowHeights();
// Paint
PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB, PAINT_GRID | PAINT_LEFT );
}
void ScDocShell::LoadStylesArgs( ScDocShell& rSource, sal_Bool bReplace, sal_Bool bCellStyles, sal_Bool bPageStyles )
{
// similar to LoadStyles, but with selectable behavior for XStyleLoader::loadStylesFromURL call
if ( !bCellStyles && !bPageStyles ) // nothing to do
return;
ScStyleSheetPool* pSourcePool = rSource.GetDocument()->GetStyleSheetPool();
ScStyleSheetPool* pDestPool = aDocument.GetStyleSheetPool();
SfxStyleFamily eFamily = bCellStyles ?
( bPageStyles ? SFX_STYLE_FAMILY_ALL : SFX_STYLE_FAMILY_PARA ) :
SFX_STYLE_FAMILY_PAGE;
SfxStyleSheetIterator aIter( pSourcePool, eFamily );
sal_uInt16 nSourceCount = aIter.Count();
if ( nSourceCount == 0 )
return; // no source styles
ScStylePair* pStyles = new ScStylePair[ nSourceCount ];
sal_uInt16 nFound = 0;
// first create all new styles
SfxStyleSheetBase* pSourceStyle = aIter.First();
while (pSourceStyle)
{
String aName = pSourceStyle->GetName();
SfxStyleSheetBase* pDestStyle = pDestPool->Find( pSourceStyle->GetName(), pSourceStyle->GetFamily() );
if ( pDestStyle )
{
// touch existing styles only if replace flag is set
if ( bReplace )
{
pStyles[nFound].pSource = pSourceStyle;
pStyles[nFound].pDest = pDestStyle;
++nFound;
}
}
else
{
pStyles[nFound].pSource = pSourceStyle;
pStyles[nFound].pDest = &pDestPool->Make( aName, pSourceStyle->GetFamily(), pSourceStyle->GetMask() );
++nFound;
}
pSourceStyle = aIter.Next();
}
// then copy contents (after inserting all styles, for parent etc.)
for ( sal_uInt16 i = 0; i < nFound; ++i )
{
pStyles[i].pDest->GetItemSet().PutExtended(
pStyles[i].pSource->GetItemSet(), SFX_ITEM_DONTCARE, SFX_ITEM_DEFAULT);
if(pStyles[i].pSource->HasParentSupport())
pStyles[i].pDest->SetParent(pStyles[i].pSource->GetParent());
// follow is never used
}
lcl_AdjustPool( GetStyleSheetPool() ); // adjust SetItems
UpdateAllRowHeights();
PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB, PAINT_GRID | PAINT_LEFT ); // Paint
delete[] pStyles;
}
sal_Bool __EXPORT ScDocShell::Insert( SfxObjectShell &rSource,
sal_uInt16 nSourceIdx1, sal_uInt16 nSourceIdx2, sal_uInt16 nSourceIdx3,
sal_uInt16 &nIdx1, sal_uInt16 &nIdx2, sal_uInt16 &nIdx3, sal_uInt16 &rIdxDeleted )
{
sal_Bool bRet = SfxObjectShell::Insert( rSource, nSourceIdx1, nSourceIdx2, nSourceIdx3,
nIdx1, nIdx2, nIdx3, rIdxDeleted );
if (bRet)
lcl_AdjustPool( GetStyleSheetPool() ); // SetItems anpassen
return bRet;
}
void ScDocShell::UpdateLinks()
{
sfx2::LinkManager* pLinkManager = aDocument.GetLinkManager();
ScStrCollection aNames;
// nicht mehr benutzte Links raus
sal_uInt16 nCount = pLinkManager->GetLinks().Count();
for (sal_uInt16 k=nCount; k>0; )
{
--k;
::sfx2::SvBaseLink* pBase = *pLinkManager->GetLinks()[k];
if (pBase->ISA(ScTableLink))
{
ScTableLink* pTabLink = (ScTableLink*)pBase;
if (pTabLink->IsUsed())
{
StrData* pData = new StrData(pTabLink->GetFileName());
if (!aNames.Insert(pData))
delete pData;
}
else // nicht mehr benutzt -> loeschen
{
pTabLink->SetAddUndo(sal_True);
pLinkManager->Remove(k);
}
}
}
// neue Links eintragen
SCTAB nTabCount = aDocument.GetTableCount();
for (SCTAB i=0; i<nTabCount; i++)
if (aDocument.IsLinked(i))
{
String aDocName = aDocument.GetLinkDoc(i);
String aFltName = aDocument.GetLinkFlt(i);
String aOptions = aDocument.GetLinkOpt(i);
sal_uLong nRefresh = aDocument.GetLinkRefreshDelay(i);
sal_Bool bThere = sal_False;
for (SCTAB j=0; j<i && !bThere; j++) // im Dokument mehrfach?
if (aDocument.IsLinked(j)
&& aDocument.GetLinkDoc(j) == aDocName
&& aDocument.GetLinkFlt(j) == aFltName
&& aDocument.GetLinkOpt(j) == aOptions)
// Ignore refresh delay in compare, it should be the
// same for identical links and we don't want dupes
// if it ain't.
bThere = sal_True;
if (!bThere) // schon als Filter eingetragen?
{
StrData* pData = new StrData(aDocName);
if (!aNames.Insert(pData))
{
delete pData;
bThere = sal_True;
}
}
if (!bThere)
{
ScTableLink* pLink = new ScTableLink( this, aDocName, aFltName, aOptions, nRefresh );
pLink->SetInCreate( sal_True );
pLinkManager->InsertFileLink( *pLink, OBJECT_CLIENT_FILE, aDocName, &aFltName );
pLink->Update();
pLink->SetInCreate( sal_False );
}
}
}
sal_Bool ScDocShell::ReloadTabLinks()
{
sfx2::LinkManager* pLinkManager = aDocument.GetLinkManager();
sal_Bool bAny = sal_False;
sal_uInt16 nCount = pLinkManager->GetLinks().Count();
for (sal_uInt16 i=0; i<nCount; i++ )
{
::sfx2::SvBaseLink* pBase = *pLinkManager->GetLinks()[i];
if (pBase->ISA(ScTableLink))
{
ScTableLink* pTabLink = (ScTableLink*)pBase;
// pTabLink->SetAddUndo(sal_False); //! Undo's zusammenfassen
// Painting only after Update() makes no sense:
// ScTableLink::Refresh() will post a Paint only is bDoPaint is true
//pTabLink->SetPaint(sal_False); // Paint nur einmal am Ende
pTabLink->Update();
//pTabLink->SetPaint(sal_True);
// pTabLink->SetAddUndo(sal_True);
bAny = sal_True;
}
}
if ( bAny )
{
// Paint nur einmal
PostPaint( ScRange(0,0,0,MAXCOL,MAXROW,MAXTAB),
PAINT_GRID | PAINT_TOP | PAINT_LEFT );
SetDocumentModified();
}
return sal_True; //! Fehler erkennen
}
| 28.972222 | 117 | 0.664208 | [
"object"
] |
9837f9aeae49112aa39581340f52cbd6d25adaad | 1,179 | cpp | C++ | igl/snap_to_fixed_up.cpp | sabinaRachev/3D-Snake-Game-Final-Project | 5c1f2044d848f24d6ce60dc61411393b503c8da2 | [
"Apache-2.0"
] | null | null | null | igl/snap_to_fixed_up.cpp | sabinaRachev/3D-Snake-Game-Final-Project | 5c1f2044d848f24d6ce60dc61411393b503c8da2 | [
"Apache-2.0"
] | null | null | null | igl/snap_to_fixed_up.cpp | sabinaRachev/3D-Snake-Game-Final-Project | 5c1f2044d848f24d6ce60dc61411393b503c8da2 | [
"Apache-2.0"
] | null | null | null | // This file is part of libigl, a simple c++ geometry processing library.
//
// Copyright (C) 2013 Alec Jacobson <alecjacobson@gmail.com>
//
// This Source Code Form is subject to the terms of the Mozilla Public License
// v. 2.0. If a copy of the MPL was not distributed with this file, You can
// obtain one at http://mozilla.org/MPL/2.0/.
#include "snap_to_fixed_up.h"
template <typename Qtype>
IGL_INLINE void igl::snap_to_fixed_up(
const Eigen::Quaternion<Qtype> & q,
Eigen::Quaternion<Qtype> & s)
{
using namespace Eigen;
typedef Eigen::Matrix<Qtype,3,1> Vector3Q;
const Vector3Q up = q.matrix() * Vector3Q(0,1,0);
Vector3Q proj_up(0,up(1),up(2));
if(proj_up.norm() == 0)
{
proj_up = Vector3Q(0,1,0);
}
proj_up.normalize();
Quaternion<Qtype> dq;
dq = Quaternion<Qtype>::FromTwoVectors(up,proj_up);
s = dq * q;
}
#ifdef IGL_STATIC_LIBRARY
// Explicit template instantiations
template void igl::snap_to_fixed_up<float>(Eigen::Quaternion<float, 0> const&, Eigen::Quaternion<float, 0>&);
template void igl::snap_to_fixed_up<double>(Eigen::Quaternion<double, 0> const&, Eigen::Quaternion<double, 0>&);
#endif
| 34.676471 | 113 | 0.690416 | [
"geometry"
] |
983ab898e919d8fd11b04a758a2de1d6e8ebad2f | 1,861 | cc | C++ | mindspore/ccsrc/minddata/dataset/kernels/data/one_hot_op.cc | kungfu-team/mindspore-bert | 71501cf52ae01db9d6a73fb64bcfe68a6509dc32 | [
"Apache-2.0"
] | 1 | 2021-03-10T09:05:13.000Z | 2021-03-10T09:05:13.000Z | mindspore/ccsrc/minddata/dataset/kernels/data/one_hot_op.cc | kungfu-team/mindspore-bert | 71501cf52ae01db9d6a73fb64bcfe68a6509dc32 | [
"Apache-2.0"
] | null | null | null | mindspore/ccsrc/minddata/dataset/kernels/data/one_hot_op.cc | kungfu-team/mindspore-bert | 71501cf52ae01db9d6a73fb64bcfe68a6509dc32 | [
"Apache-2.0"
] | null | null | null | /**
* Copyright 2019 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 "minddata/dataset/kernels/data/one_hot_op.h"
#include "minddata/dataset/core/tensor.h"
#include "minddata/dataset/kernels/data/data_utils.h"
#include "minddata/dataset/kernels/tensor_op.h"
namespace mindspore {
namespace dataset {
Status OneHotOp::Compute(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output) {
IO_CHECK(input, output);
Status s = OneHotEncoding(input, output, num_classes_);
return s;
}
Status OneHotOp::OutputShape(const std::vector<TensorShape> &inputs, std::vector<TensorShape> &outputs) {
RETURN_IF_NOT_OK(TensorOp::OutputShape(inputs, outputs));
outputs.clear();
std::vector<TensorShape> inputs_copy;
inputs_copy.push_back(inputs[0].Squeeze());
if (inputs_copy[0].Rank() == 0) outputs.emplace_back(std::vector<dsize_t>{num_classes_});
if (inputs_copy[0].Rank() == 1) outputs.emplace_back(std::vector<dsize_t>{inputs_copy[0][0], num_classes_});
if (!outputs.empty()) return Status::OK();
return Status(StatusCode::kMDUnexpectedError, "OneHot: invalid input shape.");
}
Status OneHotOp::to_json(nlohmann::json *out_json) {
nlohmann::json args;
args["num_classes"] = num_classes_;
*out_json = args;
return Status::OK();
}
} // namespace dataset
} // namespace mindspore
| 37.979592 | 110 | 0.740999 | [
"shape",
"vector"
] |
983b62b4c665bab4b5e9f1158f264cbdb1a9026e | 10,940 | cpp | C++ | src/Pegasus/Compiler/cimmofMessages.cpp | ncultra/Pegasus-2.5 | 4a0b9a1b37e2eae5c8105fdea631582dc2333f9a | [
"MIT"
] | null | null | null | src/Pegasus/Compiler/cimmofMessages.cpp | ncultra/Pegasus-2.5 | 4a0b9a1b37e2eae5c8105fdea631582dc2333f9a | [
"MIT"
] | null | null | null | src/Pegasus/Compiler/cimmofMessages.cpp | ncultra/Pegasus-2.5 | 4a0b9a1b37e2eae5c8105fdea631582dc2333f9a | [
"MIT"
] | 1 | 2022-03-07T22:54:02.000Z | 2022-03-07T22:54:02.000Z | //%2005////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation, The Open Group.
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
// EMC Corporation; VERITAS Software Corporation; The Open Group.
//
// 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.
//
//==============================================================================
//
// Author: Bob Blair (bblair@bmc.com)
//
// Modified By: Gerarda Marquez (gmarquez@us.ibm.com)
// -- PEP 43 changes
//
//%/////////////////////////////////////////////////////////////////////////////
//
// implementation of cimmofMessages class
#include "cimmofMessages.h"
#include <cstdio>
#include <iostream> // for debug only
#include <Pegasus/Common/MessageLoader.h> //l10n
#include <Pegasus/Common/Formatter.h> //l10n
PEGASUS_NAMESPACE_BEGIN
PEGASUS_USING_STD;
const cimmofMessages::arglist cimmofMessages::EMPTYLIST;
//l10n replaced % sprintf style substitution with $ Formatter style substitution
static String _cimmofMessages[] = {
"OK", //CIM_ERR_SUCCESS
"$0:$1: $2 before '$3'", //PARSER_SYNTAX_ERROR
"Error applying parameter $0 to method $1: $2", //APPLY_PARAMETER_ERROR
"Error creating new CIMParameter object $0: $1", //NEW_PARAMETER_ERROR
//UNINTIALIZED_PARAMETER_ERROR
"Internal Error: Uninitialized parameter handle $0 in class $1",
//METHOD_ALREADY_EXISTS_WARNING
"Warning: CIMMethod $0 already exists for CIMClass $1",
"Error applying method $0 to CIMClass $1: $2:", //APPLY_METHOD_ERROR
"Error creating new CIMMethod $0: $1", //NEW_METHOD_ERROR
"ADD QUALIFIER: ", //ADD_QUALIFIER
"[Trace]", //TRACE
"Error adding qualifier declaration $0: $1", //ADD_QUALIFIER_DECL_ERROR
"\tOK", //TAB_OK
"Error creating new Qualifier $0: $1", //NEW_QUALIFIER_ERROR
"Error adding new Qualifier $0: $1", //ADD_QUALIFIER_ERROR
//NEW_QUALIFIER_DECLARATION_ERROR
"Error creating new Qualifier Declaration $0: $1",
// GET_QUALIFIER_DECL_ERROR
"Could not find declaration for Qualifier named $0",
"ADD INSTANCE: ", //ADD_INSTANCE
//UNINITIALIZED_PROPERTY_ERROR
"Internal Error: Uninitialized parameter $1 in class $0",
//PROPERTY_ALREADY_EXISTS_WARNING
"Warning: Property $1 already exists in class $0",
"Error applying property $1 to class $0: $2", //APPLYING_PROPERTY_ERROR
"Error creating new Property $0: $1", //NEW_PROPERTY_ERROR
"Error creating new Class Declaration $0: $1", //NEW_CLASS_ERROR
"ADD CLASS: ", //ADD_CLASS
"Warning: Class $0 already exists in the repository", //CLASS_EXISTS_WARNING
"Error adding class $0 to the repository: $1", //ADD_CLASS_ERROR
//SETREPOSITORY_NO_COMPILER_OPTIONS
"Internal Error: Compiler options not set before setting repository",
//SETREPOSITORY_BLANK_NAME
"Internal Error: No repository name was specified to setRepository",
//NAMESPACE_CREATE_ERROR
"Error trying to create repository name space $0: $1",
"Error trying to create Repository in path $0: $1", //REPOSITORY_CREATE_ERROR
"Error trying to create a reference to object $0: $1", //NEW_REFERENCE_ERROR
//FIND_CLASS_OF_INSTANCE_ERROR
"Error looking for class of current instance while looking up property $0: $1",
// FIND_PROPERTY_VALUE_ERROR
"Error looking up value of property $2 in class $1 (namespace $0): $3",
"Error cloning property $0: $1", // CLONING_PROPERTY_ERROR
// APPLY_INSTANCE_PROPERTY_ERROR
"Error applying property $0 to an instance of class $1: $2",
// GET_INSTANCE_PROPERTY_ERROR
"Error getting property $0 from an instance: $1",
"Error getting class $0 from name space $1: $2", //GET_CLASS_ERROR
"Error getting value of property $0: $1", //GET_PROPERTY_VALUE_ERROR
"Error creating new instance of class $0: $1", // NEW_INSTANCE_ERROR
// INSTANCE_PROPERTY_EXISTS_WARNING
"Warning: property $1 already exists for this instance of class $0",
// INSTANCE_EXISTS_WARNING
"Warning: the instance already exists.\nIn this"
" implementation, that means it cannot be changed.",
"Error adding an instance: $0", // ADD_INSTANCE_ERROR
"Error: $0", // GENERAL_ERROR
"Warning: Class $0 was not added or updated: $1", //CLASS_NOT_UPDATED
"Class has the same version", //SAME_VERSION
"Experimental update not allowed (set appropriate compiler option)", //NO_EXPERIMENTAL_UPDATE
"Version update not allowed (set appropriate compiler option)", //NO_VERSION_UPDATE
"Class update not allowed (set appropriate compiler option)", //NO_CLASS_UPDATE
"Invalid version format in mof class or repository class (valid format is m.n.u)", //INVALID_VERSION_FORMAT
""
};
//l10n
static String _cimmofMessagesKeys [] = {
"Compiler.cimmofMessages.CIM_ERR_SUCCESS",
"Compiler.cimmofMessages.PARSER_SYNTAX_ERROR",
"Compiler.cimmofMessages.APPLY_PARAMETER_ERROR",
"Compiler.cimmofMessages.NEW_PARAMETER_ERROR",
"Compiler.cimmofMessages.UNINITIALIZED_PARAMETER_ERROR",
"Compiler.cimmofMessages.METHOD_ALREADY_EXISTS_WARNING",
"Compiler.cimmofMessages.APPLY_METHOD_ERROR",
"Compiler.cimmofMessages.NEW_METHOD_ERROR",
"Compiler.cimmofMessages.ADD_QUALIFIER",
"Compiler.cimmofMessages.TRACE",
"Compiler.cimmofMessages.ADD_QUALIFIER_DECL_ERROR",
"Compiler.cimmofMessages.TAB_OK",
"Compiler.cimmofMessages.NEW_QUALIFIER_ERROR",
"Compiler.cimmofMessages.ADD_QUALIFIER_ERROR",
"Compiler.cimmofMessages.NEW_QUALIFIER_DECLARATION_ERROR",
"Compiler.cimmofMessages.GET_QUALIFIER_DECL_ERROR",
"Compiler.cimmofMessages.ADD_INSTANCE",
"Compiler.cimmofMessages.UNINITIALIZED_PROPERTY_ERROR",
"Compiler.cimmofMessages.PROPERTY_ALREADY_EXISTS_WARNING",
"Compiler.cimmofMessages.APPLYING_PROPERTY_ERROR",
"Compiler.cimmofMessages.NEW_PROPERTY_ERROR",
"Compiler.cimmofMessages.NEW_CLASS_ERROR",
"Compiler.cimmofMessages.ADD_CLASS",
"Compiler.cimmofMessages.CLASS_EXISTS_WARNING",
"Compiler.cimmofMessages.ADD_CLASS_ERROR",
"Compiler.cimmofMessages.SETREPOSITORY_NO_COMPILER_OPTIONS",
"Compiler.cimmofMessages.SETREPOSITORY_BLANK_NAME",
"Compiler.cimmofMessages.NAMESPACE_CREATE_ERROR",
"Compiler.cimmofMessages.REPOSITORY_CREATE_ERROR",
"Compiler.cimmofMessages.NEW_REFERENCE_ERROR",
"Compiler.cimmofMessages.FIND_CLASS_OF_INSTANCE_ERROR",
"Compiler.cimmofMessages.FIND_PROPERTY_VALUE_ERROR",
"Compiler.cimmofMessages.CLONING_PROPERTY_ERROR",
"Compiler.cimmofMessages.APPLY_INSTANCE_PROPERTY_ERROR",
"Compiler.cimmofMessages.GET_INSTANCE_PROPERTY_ERROR",
"Compiler.cimmofMessages.GET_CLASS_ERROR",
"Compiler.cimmofMessages.GET_PROPERTY_VALUE_ERROR",
"Compiler.cimmofMessages.NEW_INSTANCE_ERROR",
"Compiler.cimmofMessages.INSTANCE_PROPERTY_EXISTS_WARNING",
"Compiler.cimmofMessages.INSTANCE_EXISTS_WARNING",
"Compiler.cimmofMessages.ADD_INSTANCE_ERROR",
"Compiler.cimmofMessages.GENERAL_ERROR",
"Compiler.cimmofMessages.CLASS_NOT_UPDATED",
"Compiler.cimmofMessages.SAME_VERSION",
"Compiler.cimmofMessages.NO_EXPERIMENTAL_UPDATE",
"Compiler.cimmofMessages.NO_VERSION_UPDATE",
"Compiler.cimmofMessages.NO_CLASS_UPDATE",
"Compiler.cimmofMessages.INVALID_VERSION_FORMAT",
"Compiler.cimmofMessages.END"
};
const String &
cimmofMessages::msgCodeToString(MsgCode code)
{
return _cimmofMessages[(unsigned int)code];
}
static int
find(const String &haystack, const String &needle)
{
unsigned int size = haystack.size();
unsigned int npos = 0;
unsigned int nsize = needle.size();
for (unsigned int i = 0; i < size; i++) {
if (haystack[i] == '\\')
i++;
if (haystack[i] == needle[npos]) {
npos++;
if (npos >= nsize)
return ( (int)(i - nsize + 1) );
} else {
npos = 0;
}
}
return -1;
}
static void
replace(String &s, unsigned int pos, unsigned int len, const String &r)
{
String s1 = s.subString(0, pos) + r + s.subString(pos + len);
s = s1;
}
void
cimmofMessages::getMessage(String &out, MsgCode code, const arglist &args)
{
//l10n
Array<String> _args;
for (unsigned int i = 0; i < 10; i++) {
if(i < args.size())
_args.append(args[i]);
else
_args.append("");
}
MessageLoaderParms parms(_cimmofMessagesKeys[(unsigned int)code],
_cimmofMessages[(unsigned int)code],
_args[0],_args[1],_args[2],_args[3],_args[4],
_args[5],_args[6],_args[7],_args[8],_args[9]);
out = MessageLoader::getMessage(parms);
//String s = msgCodeToString(code);
//out = s;
//int pos;
//for (unsigned int i = 0; i < args.size(); i++) {
//int state = 0;
//char buf[40];
//sprintf(buf, "%d", i + 1);
//String srchstr = "%";
//srchstr.append(buf);
//if ( (pos = find(out, srchstr)) != -1 ) {
//replace(out, pos, srchstr.size(), args[i]);
//}
//}
}
PEGASUS_NAMESPACE_END
| 44.836066 | 109 | 0.66947 | [
"object"
] |
983b81c08ea7529f9e6a646093ff06c266138143 | 4,586 | cc | C++ | modules/perception/obstacle/camera/visualizer/gl_fusion_visualizer.cc | BaiduXLab/apollo | 2764e934b6d0da1342be781447348288ac84c5e9 | [
"Apache-2.0"
] | 22 | 2018-10-10T14:46:32.000Z | 2022-02-28T12:43:43.000Z | modules/perception/obstacle/camera/visualizer/gl_fusion_visualizer.cc | BaiduXLab/apollo | 2764e934b6d0da1342be781447348288ac84c5e9 | [
"Apache-2.0"
] | 5 | 2020-06-13T00:36:33.000Z | 2022-02-10T17:50:43.000Z | modules/perception/obstacle/camera/visualizer/gl_fusion_visualizer.cc | BaiduXLab/apollo | 2764e934b6d0da1342be781447348288ac84c5e9 | [
"Apache-2.0"
] | 12 | 2018-12-24T02:17:19.000Z | 2021-12-06T01:54:09.000Z | /******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#include "modules/perception/obstacle/camera/visualizer/gl_fusion_visualizer.h"
#include "modules/common/log.h"
namespace apollo {
namespace perception {
namespace lowcostvisualizer {
GLFusionVisualizer::GLFusionVisualizer() : name_("GLFusionVisualizer") {}
bool GLFusionVisualizer::init() {
opengl_vs_ = std::shared_ptr<GLFWFusionViewer>(new GLFWFusionViewer());
if (opengl_vs_ == nullptr) {
AINFO << "Failed to create opengl viewer";
return false;
}
if (opengl_vs_->initialize() == false) {
AINFO << "Failed to initialize opengl viewer";
return false;
}
set_background_color(0.05, 0.05, 0.05, 0.0f);
set_camera_position();
set_main_car_points();
AINFO << "Initialize GLFusionVisualizer successfully";
return true;
}
void GLFusionVisualizer::render(FrameContent *content) {
opengl_vs_->set_camera_para(camera_center_velodyne_, view_point_velodyne_,
up_velodyne_);
opengl_vs_->set_forward_dir(forward_world_);
opengl_vs_->set_main_car(main_car_world_);
opengl_vs_->set_frame_content(content);
opengl_vs_->spin_once();
AINFO << "GLFusionVisualizer spin_once";
}
void GLFusionVisualizer::set_background_color(float r, float g, float b,
float a) {
opengl_vs_->set_background_color(Eigen::Vector3d(r, g, b));
}
void GLFusionVisualizer::set_camera_position() {
up_velodyne_[0] = 0;
up_velodyne_[1] = 1;
up_velodyne_[2] = 0;
forward_velodyne_[0] = 1;
forward_velodyne_[1] = 0;
forward_velodyne_[2] = 0;
view_point_velodyne_[0] = 0;
view_point_velodyne_[1] = 0;
view_point_velodyne_[2] = 0;
camera_center_velodyne_[0] = 0;
camera_center_velodyne_[1] = 0;
camera_center_velodyne_[2] = 100;
}
void GLFusionVisualizer::set_main_car_points() {
main_car_.resize(4);
main_car_[0][0] = 2.0;
main_car_[0][1] = 1.0;
main_car_[0][2] = 0.0;
main_car_[1][0] = -2.0;
main_car_[1][1] = 1.0;
main_car_[1][2] = 0.0;
main_car_[2][0] = -2.0;
main_car_[2][1] = -1.0;
main_car_[2][2] = 0.0;
main_car_[3][0] = 2.0;
main_car_[3][1] = -1.0;
main_car_[3][2] = 0.0;
}
void GLFusionVisualizer::update_camera_system(FrameContent *content) {
Eigen::Matrix4d pose_v2w = Eigen::Matrix4d::Identity();
Eigen::Vector4d camera_center_w(camera_center_velodyne_[0],
camera_center_velodyne_[1],
camera_center_velodyne_[2], 0);
camera_center_w = pose_v2w * camera_center_w;
camera_center_world_[0] = camera_center_w[0];
camera_center_world_[1] = camera_center_w[1];
camera_center_world_[2] = camera_center_w[2];
Eigen::Vector4d view_point_w(view_point_velodyne_[0], view_point_velodyne_[1],
view_point_velodyne_[2], 0);
view_point_w = pose_v2w * view_point_w;
view_point_world_[0] = view_point_w[0];
view_point_world_[1] = view_point_w[1];
view_point_world_[2] = view_point_w[2];
Eigen::Vector4d up_w(up_velodyne_[0], up_velodyne_[1], up_velodyne_[2], 0);
up_w = pose_v2w * up_w;
up_world_[0] = up_w[0];
up_world_[1] = up_w[1];
up_world_[2] = up_w[2];
Eigen::Vector4d fd_w(forward_velodyne_[0], forward_velodyne_[1],
forward_velodyne_[2], 0);
fd_w = pose_v2w * fd_w;
forward_world_[0] = fd_w[0];
forward_world_[1] = fd_w[1];
forward_world_[2] = fd_w[2];
main_car_world_.resize(4);
for (size_t i = 0; i < 4; ++i) {
Eigen::Vector4d main_car_w(main_car_[i][0], main_car_[i][1],
main_car_[i][2], 0.0);
main_car_w = pose_v2w * main_car_w;
main_car_world_[i][0] = main_car_w[0];
main_car_world_[i][1] = main_car_w[1];
main_car_world_[i][2] = main_car_w[2];
}
}
} // namespace lowcostvisualizer
} // namespace perception
} // namespace apollo
| 32.524823 | 80 | 0.656782 | [
"render"
] |
983b8d20b75334b834316e8a06c807a93ec2c0fa | 368 | cc | C++ | 2017-10-14-Intro/sum1.cc | karinakozarova/Algo-course-TUES | b499f893251a1558b43f3c4e763a9153f354ebeb | [
"MIT"
] | 2 | 2017-12-11T22:20:15.000Z | 2019-11-17T02:52:20.000Z | 2017-10-14-Intro/sum1.cc | karinakozarova/Algo-course-TUES | b499f893251a1558b43f3c4e763a9153f354ebeb | [
"MIT"
] | null | null | null | 2017-10-14-Intro/sum1.cc | karinakozarova/Algo-course-TUES | b499f893251a1558b43f3c4e763a9153f354ebeb | [
"MIT"
] | null | null | null | #include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
//Дадено са естествени числа X и N.
// Да се намери по колко начина може
// X да се представи като сбор на
// N-ти степени на различни естествени числа.
int main() {
int x,n,count = 1; // every num on 1st = num
cin >> x,n;
cout << count;
}
| 19.368421 | 48 | 0.668478 | [
"vector"
] |
983c5c7621a639d8b7bb75e031f53deeeccfc691 | 2,521 | cpp | C++ | tests/pure/test_moving.cpp | vacing/flexcore | 08c08e98556f92d1993e2738cbcb975b3764fa2d | [
"Apache-2.0"
] | 47 | 2016-09-23T10:27:17.000Z | 2021-12-14T07:31:40.000Z | tests/pure/test_moving.cpp | vacing/flexcore | 08c08e98556f92d1993e2738cbcb975b3764fa2d | [
"Apache-2.0"
] | 10 | 2016-12-04T16:40:29.000Z | 2020-04-28T08:46:50.000Z | tests/pure/test_moving.cpp | vacing/flexcore | 08c08e98556f92d1993e2738cbcb975b3764fa2d | [
"Apache-2.0"
] | 20 | 2016-09-23T17:14:41.000Z | 2021-10-09T18:24:47.000Z | #include <boost/test/unit_test.hpp>
#include <flexcore/core/connection.hpp>
#include <flexcore/pure/pure_ports.hpp>
#include <algorithm>
#include <vector>
using namespace fc;
BOOST_AUTO_TEST_SUITE(test_tokens_testing)
namespace
{
/**
* token for testing that cannot be copied only moved.
*/
class move_token
{
public:
explicit move_token(std::string v) noexcept : value_(std::move(v)) {}
move_token() = default;
move_token(move_token&) = delete;
move_token(move_token&&) = default;
move_token& operator= (move_token&) = delete;
move_token& operator= (move_token&&) = default;
std::string& value() { return value_; }
const std::string& value() const { return value_; }
bool operator< (const move_token& other) const { return value_ < other.value_; }
private:
std::string value_;
};
}
BOOST_AUTO_TEST_CASE( move_token_ )
{
// no default constructor
// how to test for "does not compile"?
// move_token t;
// non-copyable
move_token t("foo");
move_token u(move_token("bar"));
std::vector<move_token> v(10);
std::sort(v.begin(), v.end());
v.push_back(move_token("foo"));
}
BOOST_AUTO_TEST_CASE( moving_events )
{
auto set_bar = [](auto&& t) { t.value() = "bar"; return std::move(t);};
pure::event_source<move_token&&> source;
move_token result{};
pure::event_sink<move_token> sink{[&result](move_token&& in){ result = std::move(in);}};
source >> set_bar >> sink;
move_token m{"foo"};
// source.fire(m); // should not compile
source.fire(std::move(m));
BOOST_CHECK_EQUAL(result.value(), "bar");
}
BOOST_AUTO_TEST_CASE( moving_state )
{
auto set_bar = [](auto&& t) { t.value() = "bar"; return std::move(t); };
pure::state_sink<move_token> sink;
pure::state_source<move_token> source([](){ return move_token("foo"); });
source >> set_bar >> sink;
const auto v = sink.get();
BOOST_CHECK_EQUAL(v.value(), "bar");
}
//test case to make sure objects are not move if we don't want them to be
BOOST_AUTO_TEST_CASE( non_moving )
{
using non_move = std::shared_ptr<int>; //shared_ptr is nulled after move, so we can check
pure::event_source<non_move> source{};
bool moved{false};
pure::event_sink<non_move> sink([&moved](non_move t){ moved = !t.operator bool() ;});
pure::event_sink<non_move> sink2([&moved](non_move t){ moved = !t.operator bool() ;});
source >> sink;
source.fire(std::make_shared<int>(1));
BOOST_CHECK(!moved);
source >> sink2; //now we have two connections
source.fire(std::make_shared<int>(1));
BOOST_CHECK(!moved);
}
BOOST_AUTO_TEST_SUITE_END()
| 24.715686 | 90 | 0.694169 | [
"vector"
] |
9849e8d99f28718359e1f206d3992cd8390dfcfb | 10,033 | cc | C++ | src/service/async_service_impl.cc | pewpewp3w/authservice | 449a9536e3213c9e56c2c1d6afbdd82a3c150e8e | [
"Apache-2.0"
] | 163 | 2019-05-13T19:01:01.000Z | 2022-03-30T20:31:01.000Z | src/service/async_service_impl.cc | pewpewp3w/authservice | 449a9536e3213c9e56c2c1d6afbdd82a3c150e8e | [
"Apache-2.0"
] | 203 | 2019-05-21T21:23:48.000Z | 2022-03-31T00:36:32.000Z | src/service/async_service_impl.cc | pewpewp3w/authservice | 449a9536e3213c9e56c2c1d6afbdd82a3c150e8e | [
"Apache-2.0"
] | 45 | 2019-05-10T00:31:37.000Z | 2022-02-07T01:31:43.000Z | #include "async_service_impl.h"
#include <grpcpp/server_builder.h>
#include <boost/asio.hpp>
#include <csignal>
#include <memory>
#include "boost/asio/io_context.hpp"
#include "boost/thread/detail/thread.hpp"
#include "src/common/http/http.h"
#include "src/config/get_config.h"
namespace authservice {
namespace service {
namespace {
constexpr uint16_t kHealthCheckServerPort = 10004;
}
ProcessingStateV2::ProcessingStateV2(
ProcessingStateFactory &parent,
envoy::service::auth::v2::Authorization::AsyncService &service)
: parent_(parent), service_(service), responder_(&ctx_) {
spdlog::warn(
"Creating V2 request processor state. V2 will be deprecated in 2021 "
"Q1");
service_.RequestCheck(&ctx_, &request_, &responder_, &parent_.cq_,
&parent_.cq_, this);
}
void ProcessingStateV2::Proceed() {
// Spawn a new instance to serve new clients while we process this one
// This will later be pulled off the queue for processing and ultimately
// deleted in the destructor of CompleteState
parent_.createV2(service_);
spdlog::trace("Launching V2 request processor worker");
boost::asio::spawn(
parent_.io_context_, [this](boost::asio::yield_context yield) {
spdlog::trace("Processing V2 request");
envoy::service::auth::v2::CheckResponse response;
authservice::service::Check(
request_, response, parent_.chains_, parent_.trigger_rules_config_,
parent_.allow_unmatched_requests_, parent_.io_context_, yield);
this->responder_.Finish(response, grpc::Status::OK,
new CompleteState(this));
spdlog::trace("Request processing complete");
});
}
ProcessingState::ProcessingState(
ProcessingStateFactory &parent,
envoy::service::auth::v3::Authorization::AsyncService &service)
: parent_(parent), service_(service), responder_(&ctx_) {
spdlog::trace("Creating V3 request processor state");
service_.RequestCheck(&ctx_, &request_, &responder_, &parent_.cq_,
&parent_.cq_, this);
}
void ProcessingState::Proceed() {
// Spawn a new instance to serve new clients while we process this one
// This will later be pulled off the queue for processing and ultimately
// deleted in the destructor of CompleteState
parent_.create(service_);
spdlog::trace("Launching request processor worker");
// The actual processing.
// Invokes this lambda on any available thread running the run() method of
// this io_context_ instance.
boost::asio::spawn(
parent_.io_context_, [this](boost::asio::yield_context yield) {
spdlog::trace("Processing request");
envoy::service::auth::v3::CheckResponse response;
authservice::service::Check(
request_, response, parent_.chains_, parent_.trigger_rules_config_,
parent_.allow_unmatched_requests_, parent_.io_context_, yield);
this->responder_.Finish(response, grpc::Status::OK,
new CompleteState(this));
spdlog::trace("Request processing complete");
});
}
void CompleteState::Proceed() {
spdlog::trace("Processing completion and deleting state");
delete processor_v2_;
delete processor_v3_;
delete this;
}
ProcessingStateFactory::ProcessingStateFactory(
std::vector<std::unique_ptr<filters::FilterChain>> &chains,
const google::protobuf::RepeatedPtrField<config::TriggerRule>
&trigger_rules_config,
bool allow_unmatched_requests, grpc::ServerCompletionQueue &cq,
boost::asio::io_context &io_context)
: cq_(cq),
io_context_(io_context),
chains_(chains),
trigger_rules_config_(trigger_rules_config),
allow_unmatched_requests_(allow_unmatched_requests) {}
ProcessingStateV2 *ProcessingStateFactory::createV2(
envoy::service::auth::v2::Authorization::AsyncService &service) {
return new ProcessingStateV2(*this, service);
}
ProcessingState *ProcessingStateFactory::create(
envoy::service::auth::v3::Authorization::AsyncService &service) {
return new ProcessingState(*this, service);
}
AsyncAuthServiceImpl::AsyncAuthServiceImpl(const config::Config &config)
: address_and_port_(
fmt::format("{}:{}", config.listen_address(), config.listen_port())),
config_(config),
io_context_(std::make_shared<boost::asio::io_context>()),
interval_in_seconds_(60),
timer_(*io_context_, interval_in_seconds_) {
for (const auto &chain_config : config_.chains()) {
auto chain = std::make_unique<filters::FilterChainImpl>(
*io_context_, chain_config, config_.threads());
chains_.push_back(std::move(chain));
}
grpc::ServerBuilder builder;
builder.AddListeningPort(address_and_port_,
grpc::InsecureServerCredentials());
builder.RegisterService(&service_);
builder.RegisterService(&service_v2_);
cq_ = builder.AddCompletionQueue();
server_ = builder.BuildAndStart();
state_factory_ = std::make_unique<ProcessingStateFactory>(
chains_, config_.trigger_rules(), config_.allow_unmatched_requests(),
*cq_, *io_context_);
}
void AsyncAuthServiceImpl::Run() {
// Add a work object to the IO service so it will not shut down when it has
// nothing left to do
work_ = std::make_unique<boost::asio::io_context::work>(*io_context_);
SchedulePeriodicCleanupTask();
// Spin up our worker threads
// Config validation should have already ensured that the number of threads
// is > 0
for (unsigned int i = 0; i < config_.threads(); ++i) {
thread_pool_.create_thread([this]() {
while (true) {
try {
// The asio library provides a guarantee that callback handlers will
// only be called from threads that are currently calling
// io_context::run(). The io_context::run() function will also
// continue to run while there is still "work" to do. Async methods
// which take a boost::asio::yield_context as an argument will use
// that yield as a callback handler when the async operation has
// completed. The yield_context will restore the stack, registers,
// and execution pointer of the calling method, effectively allowing
// that method to pick up right where it left off, and continue on
// any worker thread.
this->io_context_
->run(); // run the io_context's event processing loop
break;
} catch (std::exception &e) {
spdlog::error("Unexpected error in worker thread: {}", e.what());
}
}
});
}
spdlog::info("{}: Healthcheck Server listening on {}:{}", __func__,
config_.listen_address(), kHealthCheckServerPort);
health_server_ = std::make_unique<HealthcheckAsyncServer>(
*io_context_, chains_, config_.listen_address(), kHealthCheckServerPort);
health_server_->startAccept();
spdlog::info("{}: Server listening on {}", __func__, address_and_port_);
try {
// Spawn a new state instance to serve new clients
// This will later be pulled off the queue for processing and ultimately
// deleted in the destructor of CompleteState
state_factory_->create(service_);
state_factory_->createV2(service_v2_);
void *tag;
bool ok;
while (cq_->Next(&tag, &ok)) {
// Block waiting to read the next event from the completion queue. The
// event is uniquely identified by its tag, which in this case is the
// memory address of a CallData instance.
// The return value of Next should always be checked. This return value
// tells us whether there is any kind of event or cq_ is shutting down.
if (!ok) {
spdlog::error("{}: Unexpected error: !ok", __func__);
}
static_cast<ServiceState *>(tag)->Proceed();
}
} catch (const std::exception &e) {
spdlog::error("{}: Unexpected error: {}", __func__, e.what());
}
}
void AsyncAuthServiceImpl::SchedulePeriodicCleanupTask() {
timer_handler_function_ = [this](const boost::system::error_code &ec) {
spdlog::info("{}: Starting periodic cleanup (period of {} seconds)",
__func__, interval_in_seconds_.count());
for (const auto &chain : chains_) {
chain->DoPeriodicCleanup();
}
// Reset the timer for some seconds in the future
timer_.expires_at(std::chrono::steady_clock::now() + interval_in_seconds_);
// Schedule the next invocation of this same handler on the same timer
timer_.async_wait(timer_handler_function_);
};
// Schedule the first invocation of the handler on the timer
timer_.async_wait(timer_handler_function_);
}
void AsyncAuthServiceImpl::Shutdown() {
spdlog::info("Server shutting down");
// Start shutting down gRPC
if (server_ != nullptr) {
server_->Shutdown();
}
if (cq_ != nullptr) {
cq_->Shutdown();
// The destructor of the completion queue will abort if there are any
// outstanding events, so we must drain the queue before we allow that to
// happen
try {
void *tag;
bool ok;
while (cq_->Next(&tag, &ok)) {
delete static_cast<ServiceState *>(tag);
}
} catch (const std::exception &e) {
spdlog::error("{}: Unexpected error: {}", __func__, e.what());
}
}
// Start shutting down health server
health_server_.reset();
if (work_ != nullptr) {
// Reset the work item for the IO service will terminate once it finishes
// any outstanding jobs
work_.reset();
}
if (io_context_ != nullptr) {
// The `SchedulePeriodicCleanupTask` is scheduled with `timer_`,
// which is bound with the io_context_.
// Calling `stop()` explicitly ensures that the periodic task
// won't be further scheduled onto `io_context` internal scheduling queue.
// Therefore the thread running periodic task can be terminated and joined
// here.
io_context_->stop();
}
thread_pool_.join_all();
}
} // namespace service
} // namespace authservice | 35.704626 | 79 | 0.682049 | [
"object",
"vector"
] |
984f2e65d3d1cd14067620396b2c429a5650784d | 5,742 | cpp | C++ | samples/tools/grab.cpp | v4r-tuwien/v4r | ff3fbd6d2b298b83268ba4737868bab258262a40 | [
"BSD-1-Clause",
"BSD-2-Clause"
] | 2 | 2021-02-22T11:36:33.000Z | 2021-07-20T11:31:08.000Z | samples/tools/grab.cpp | v4r-tuwien/v4r | ff3fbd6d2b298b83268ba4737868bab258262a40 | [
"BSD-1-Clause",
"BSD-2-Clause"
] | null | null | null | samples/tools/grab.cpp | v4r-tuwien/v4r | ff3fbd6d2b298b83268ba4737868bab258262a40 | [
"BSD-1-Clause",
"BSD-2-Clause"
] | 3 | 2018-10-19T10:39:23.000Z | 2021-04-07T13:39:03.000Z | #include <iostream>
#include <boost/format.hpp>
#include <boost/program_options.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <v4r/common/unprojection.h>
#include <v4r/io/grabber.h>
#include <pcl/io/pcd_io.h>
#include <pcl/visualization/pcl_visualizer.h>
#include "program_options.h"
struct ProgramOptions : public ProgramOptionsBase {
std::string source = "";
bool print_info = false;
bool three_dee = false;
bool overlay = false;
void printDescription() override {
std::cout << "Grab RGB-D stream from a given source (camera or file) and visualize." << std::endl;
std::cout << std::endl;
std::cout << "On startup this tool will try to instantiate each grabber (available in the current V4R built), "
<< "passing it the provided source URI. The first successfully instantiated grabber will be used. "
<< "Refer to the grabber documentation regarding the supported URI formats. Note that an empty string is "
<< "a valid source URI that means \"any camera\"." << std::endl;
std::cout << std::endl;
std::cout << "How the RGB-D stream is visualized is controlled by the following options. By default (without any "
<< "options), color and depth streams are shown in separate windows. With the --overlay option, the "
<< "depth image will be overlaid on the color image. With the --3d option, the depth image will be "
<< "unprojected into 3D space and visualized as a point cloud." << std::endl;
std::cout << std::endl;
std::cout << "The --3d visualization mode supports saving unprojected point clouds to the disk by pressing \"s\" "
<< "(while the focus is on the visualization window)." << std::endl;
}
void addGeneral(po::options_description& desc) override {
desc.add_options()("print-info,i", po::bool_switch(&print_info), "Print information about created grabber");
desc.add_options()("3d", po::bool_switch(&three_dee), "Unproject RGB-D frames and visualize point cloud");
desc.add_options()("overlay", po::bool_switch(&overlay), "Overlay depth image on color image");
}
void addPositional(po::options_description& desc, po::positional_options_description& positional) override {
desc.add_options()("source-uri", po::value<std::string>(&source), "RGB-D stream source URI");
positional.add("source-uri", -1);
}
};
int main(int argc, const char** argv) {
ProgramOptions options;
if (!options.parse(argc, argv))
return 1;
auto grabber = v4r::io::createGrabber(options.source);
if (!grabber) {
std::cerr << "Failed to create a grabber for URI: \"" << options.source << "\"" << std::endl;
return 2;
}
if (options.print_info) {
grabber->printInfo();
std::cout << "Intrinsics: " << grabber->getCameraIntrinsics() << std::endl;
}
if (options.three_dee && !grabber->hasDepthStream()) {
std::cerr << "The grabber does not have a depth stream, impossible to visualize as a point cloud" << std::endl;
return 3;
}
if (options.three_dee && options.overlay) {
std::cerr << "Options --3d and --overlay are exclusive, only one of them can be supplied" << std::endl;
return 4;
}
if (options.overlay && !(grabber->hasColorStream() && grabber->hasDepthStream())) {
std::cerr << "The grabber should have both color and depth streams to visualize with overlaying" << std::endl;
return 5;
}
cv::Mat color, depth;
v4r::io::Grabber::Timestamp timestamp;
if (options.three_dee) {
pcl::visualization::PCLVisualizer visualizer;
pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZRGB>);
pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> handler(cloud);
auto keyboardCallback = [&](const pcl::visualization::KeyboardEvent& event) {
if (event.getKeySym() == "s" && event.keyUp()) {
std::string p = boost::str(boost::format("cloud_%08d.pcd") % timestamp);
std::cout << "Saving unprojected point cloud to \"" << p << "\"" << std::endl;
pcl::io::savePCDFileBinaryCompressed(p, *cloud);
}
};
visualizer.addPointCloud<pcl::PointXYZRGB>(cloud, handler);
visualizer.registerKeyboardCallback(keyboardCallback);
while (grabber->hasMoreFrames() && !visualizer.wasStopped()) {
timestamp = grabber->grabFrame(color, depth);
v4r::unproject(color, depth, grabber->getCameraIntrinsics(), *cloud);
pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> handler(cloud);
visualizer.updatePointCloud<pcl::PointXYZRGB>(cloud, handler);
visualizer.spinOnce(30);
}
} else {
const auto min_depth = 0.2f;
const auto max_depth = 3.4f;
const float scale = 255.0 / (max_depth - min_depth);
cv::Mat depth_u8, colormapped, mask;
int key = 0;
while (key != 27) {
if (grabber->hasMoreFrames())
timestamp = grabber->grabFrame(color, depth);
else
continue;
if (!color.empty())
if (!options.overlay)
cv::imshow("Color", color);
if (!depth.empty()) {
depth.convertTo(depth_u8, CV_8UC1, scale, -scale * min_depth);
#if CV_MAJOR_VERSION >= 3
cv::applyColorMap(depth_u8, colormapped, cv::COLORMAP_PARULA);
#else
colormapped = depth_u8;
#endif
if (!options.overlay)
cv::imshow("Depth", colormapped);
}
if (options.overlay) {
cv::threshold(depth, mask, 0, 255, cv::THRESH_BINARY);
mask.convertTo(mask, CV_8UC1);
colormapped.copyTo(color, mask);
cv::imshow("Overlaid", color);
}
key = cv::waitKey(30);
}
}
return 0;
}
| 40.153846 | 120 | 0.658481 | [
"3d"
] |
9853ec79f32c1e175d38cbe1da1891961a1cd2fa | 2,025 | cpp | C++ | Core/Utilities/QProgInfo/Visualization/Qvisualization.cpp | QianJianhua1/QPanda-2 | a13c7b733031b1d0007dceaf1dae6ad447bb969c | [
"Apache-2.0"
] | null | null | null | Core/Utilities/QProgInfo/Visualization/Qvisualization.cpp | QianJianhua1/QPanda-2 | a13c7b733031b1d0007dceaf1dae6ad447bb969c | [
"Apache-2.0"
] | null | null | null | Core/Utilities/QProgInfo/Visualization/Qvisualization.cpp | QianJianhua1/QPanda-2 | a13c7b733031b1d0007dceaf1dae6ad447bb969c | [
"Apache-2.0"
] | null | null | null | #include "Core/Utilities/QProgInfo/Visualization/QVisualization.h"
#include "Core/Utilities/QProgInfo/QCircuitInfo.h"
USING_QPANDA
using namespace std;
using namespace DRAW_TEXT_PIC;
string QPanda::draw_qprog(QProg prog, PIC_TYPE p /* = PIC_TYPE::TEXT */, bool with_logo /* = false */, uint32_t length /*= 100*/, const std::string &output_file /*= ""*/,
const NodeIter itr_start /* = NodeIter()*/, const NodeIter itr_end /* = NodeIter()*/)
{
DrawQProg test_text_pic(prog, itr_start, itr_end, output_file);
return test_text_pic.textDraw(LAYER, p, with_logo, length);
}
std::string QPanda::draw_qprog(QProg prog, LayeredTopoSeq &m_layer_info, PIC_TYPE p /* = PIC_TYPE::TEXT */, bool with_logo /* = false */, uint32_t length /*= 100*/,
const std::string &output_file /*= ""*/)
{
std::vector<int> quantum_bits_in_use;
std::vector<int> class_bits_in_use;
get_all_used_qubits(prog, quantum_bits_in_use);
get_all_used_class_bits(prog, class_bits_in_use);
if (quantum_bits_in_use.size() == 0)
{
return "Null";
}
AbstractDraw *drawer = nullptr;
if (PIC_TYPE::TEXT == p)
{
drawer = new DrawPicture(prog, m_layer_info, length);
}
else if (PIC_TYPE::LATEX == p)
{
drawer = new DrawLatex(prog, m_layer_info, length);
}
drawer->init(quantum_bits_in_use, class_bits_in_use);
drawer->draw_by_layer();
if (PIC_TYPE::LATEX == p && with_logo)
{
dynamic_cast<DrawLatex *>(drawer)->setLogo();
}
auto text_pic_str = drawer->present(output_file);
delete drawer;
drawer = nullptr;
return text_pic_str;
}
std::string QPanda::draw_qprog_with_clock(QProg prog, PIC_TYPE p /* = PIC_TYPE::TEXT */, const std::string config_data /*= CONFIG_PATH*/, bool with_logo /* = false */,
uint32_t length /*= 100*/, const std::string &output_file /*= ""*/, const NodeIter itr_start /* = NodeIter()*/, const NodeIter itr_end /*= NodeIter()*/)
{
DrawQProg test_text_pic(prog, itr_start, itr_end, output_file);
return test_text_pic.textDraw(TIME_SEQUENCE, p, with_logo, length, config_data);
}
| 34.322034 | 170 | 0.710123 | [
"vector"
] |
985cbd1b8a8370c1657f98f97c1e16571123320e | 8,322 | cpp | C++ | src/othello/ai/QLearningPlayer.cpp | Orfby/Othello-MMP | 72be0ee38a329eff536b17d1e5334353cfd58c6f | [
"MIT"
] | null | null | null | src/othello/ai/QLearningPlayer.cpp | Orfby/Othello-MMP | 72be0ee38a329eff536b17d1e5334353cfd58c6f | [
"MIT"
] | null | null | null | src/othello/ai/QLearningPlayer.cpp | Orfby/Othello-MMP | 72be0ee38a329eff536b17d1e5334353cfd58c6f | [
"MIT"
] | null | null | null | //Othello headers:
#include <othello/ai/QLearningPlayer.hpp>
namespace othello
{
namespace ai
{
////////////////////////////////////////////////////////////////
FANN::neural_net QLearningPlayer::mlp = {};
////////////////////////////////////////////////////////////////
QLearningPlayer::QLearningPlayer(const bool& training, const unsigned int& seed,
const unsigned int& numCycles, const unsigned int& numHiddenLayers,
const unsigned int& numHiddenNeurons, const fann_type& discountFactor,
const fann_type& learningRate, const fann_type& epsilon)
: training(training), randomNumberGenerator(seed),
discountFactor(discountFactor), epsilon(epsilon),
deltaEpsilon(-epsilon / numCycles)
{
//Disable their random number seeding (since we're using our own)
mlp.disable_seed_rand();
//Create a vector for the layers
std::vector<unsigned int> layers = {game::Board::BOARD_SIZE * game::Board::BOARD_SIZE};
//Insert the hidden layers
for (std::size_t i = 0; i < numHiddenLayers; ++i) {layers.emplace_back(numHiddenNeurons);}
//Insert the output layer
layers.emplace_back(game::Board::BOARD_SIZE * game::Board::BOARD_SIZE);
//Create the neural network with the given layers
mlp.create_standard_array(layers.size(), layers.data());
//Randomise the weights from -0.5 and 0.5
mlp.randomize_weights(-0.5f, 0.5f);
//Set the learning rate
mlp.set_learning_rate(learningRate);
//Set the activation function to sigmoid for the hidden and output layer
mlp.set_activation_function_hidden(FANN::SIGMOID_SYMMETRIC);
mlp.set_activation_function_output(FANN::SIGMOID_SYMMETRIC);
}
////////////////////////////////////////////////////////////////
const game::Move* QLearningPlayer::makeMove(const game::Game& game, const uint8_t& player,
const std::vector<game::Move>& possibleMoves)
{
//Create an input array of 0s
std::array<fann_type, game::Board::BOARD_SIZE * game::Board::BOARD_SIZE> input = {0};
//Iterate over the tiles of the board
std::size_t i = 0;
for (uint8_t y = 0; y < game::Board::BOARD_SIZE; ++y)
{
for (uint8_t x = 0; x < game::Board::BOARD_SIZE; ++x)
{
//If it's claimed
if (game.getBoard().getTile({x, y}).isClaimed)
{
//Claimed by "me" is 1
if (game.getBoard().getTile({x, y}).claimant == player) {input[i] = 1;}
//Claimed by the other player is -1
else {input[i] = -1;}
}
else {input[i] = 0;}
++i;
}
}
//Run the input into the nn
auto outputPtr = mlp.run(input.data());
//Create an output array
std::array<fann_type, game::Board::BOARD_SIZE * game::Board::BOARD_SIZE> output{};
std::copy(outputPtr, outputPtr + output.size(), output.begin());
//Create some variables for the selected move
std::size_t selectedMove_possibleMovesI = 0;
std::size_t selectedMove_nnI = 0;
fann_type selectedMove_intensity = std::numeric_limits<fann_type>::lowest();
//Iterate over the possible moves to get the one with the strongest signal in the NN
for (i = 0; i < possibleMoves.size(); ++i)
{
//Get the index of the move in the neural network's output
uint8_t index = (possibleMoves[i].diskPosition.y * game::Board::BOARD_SIZE) +
possibleMoves[i].diskPosition.x;
//If the neural network likes it more
if (output[index] > selectedMove_intensity)
{
selectedMove_possibleMovesI = i;
selectedMove_nnI = index;
selectedMove_intensity = output[index];
}
}
//If a random move should be picked
boost::random::uniform_real_distribution<> distribution(0, 1);
double randomNum = distribution(randomNumberGenerator);
if (training && randomNum <= epsilon)
{
//Create a uniform integer distribution
boost::random::uniform_int_distribution<> moveDistribution(0, possibleMoves.size() - 1);
//Get a random move
selectedMove_possibleMovesI = moveDistribution(randomNumberGenerator);
//Get its index in the nn
selectedMove_nnI = (possibleMoves[selectedMove_possibleMovesI].diskPosition.y * game::Board::BOARD_SIZE) +
possibleMoves[selectedMove_possibleMovesI].diskPosition.x;
}
//If we're in training mode
if (training)
{
//Add the state to the backlog
states.emplace_back(TurnState(input, selectedMove_nnI, selectedMove_intensity));
}
//Return the selected move
return &possibleMoves[selectedMove_possibleMovesI];
}
////////////////////////////////////////////////////////////////
void QLearningPlayer::gameFinished(const game::Game& game, const uint8_t& player)
{
//If we're training
if (training)
{
//Determine the reward
fann_type reward = 0;
//If this player won
if ((player == 0 && game.getScore().first > game.getScore().second) ||
(player == 1 && game.getScore().second > game.getScore().first))
{
reward = 1;
}
//If the other player won
else if ((player == 0 && game.getScore().second > game.getScore().first) ||
(player == 1 && game.getScore().first > game.getScore().second))
{
reward = 0;
}
//If it was a draw
else {reward = 0.5;}
//Iterate over the states
for (std::size_t i = 0; i < states.size(); ++i)
{
fann_type Qnew;
if (i < states.size() - 1)
{
//Calculate the Q new value
Qnew = (discountFactor * states.at(i + 1).QVal);
}
else {Qnew = reward;}
//Run the input into the nn
auto QPrevPtr = mlp.run(states.at(i).input.data());
//Create an output array
std::array<fann_type, game::Board::BOARD_SIZE * game::Board::BOARD_SIZE> QPrev{};
std::copy(QPrevPtr, QPrevPtr + QPrev.size(), QPrev.begin());
//Adjust the output of the played move
QPrev[states.at(i).playedMove] = Qnew;
//Train the network
mlp.train(states.at(i).input.data(), QPrev.data());
}
}
//Clear the state
states.clear();
}
////////////////////////////////////////////////////////////////
void QLearningPlayer::setTraining(const bool& trainingMode)
{
//Set the training mode
training = trainingMode;
//Modify epsilon if training mode is set to false
if (!training) {epsilon += deltaEpsilon;}
}
}
} | 43.34375 | 122 | 0.472963 | [
"vector"
] |
985ffb63917591e01a29e63089b02c914a6453db | 14,295 | cpp | C++ | cpp/src/TensorflowOperators/CudaRenderer/CudaRenderer.cpp | aytewari/GVV-Differentiable-CUDA-Renderer | 5da6bdab3fd44074ae752bd8192fc2aad9fb77e6 | [
"CC-BY-4.0"
] | 40 | 2020-10-09T06:13:32.000Z | 2021-04-09T21:48:29.000Z | cpp/src/TensorflowOperators/CudaRenderer/CudaRenderer.cpp | ayushtewari/GVV-Differentiable-CUDA-Renderer | 5da6bdab3fd44074ae752bd8192fc2aad9fb77e6 | [
"CC-BY-4.0"
] | 2 | 2020-10-10T07:16:33.000Z | 2021-03-27T09:07:57.000Z | cpp/src/TensorflowOperators/CudaRenderer/CudaRenderer.cpp | ayushtewari/GVV-Differentiable-CUDA-Renderer | 5da6bdab3fd44074ae752bd8192fc2aad9fb77e6 | [
"CC-BY-4.0"
] | 2 | 2021-06-29T15:40:03.000Z | 2022-01-31T16:09:44.000Z | #include "CudaRenderer.h"
//==============================================================================================//
REGISTER_OP("CudaRendererGpu")
.Input("vertex_pos: float")
.Input("vertex_color: float")
.Input("texture: float")
.Input("sh_coeff: float")
.Input("target_image: float")
.Input("extrinsics: float")
.Input("intrinsics: float")
.Output("barycentric_buffer: float")
.Output("face_buffer: int32")
.Output("render_buffer: float")
.Output("vertex_normal: float")
.Output("target_image_out: float")
.Output("normal_map: float")
.Attr("faces: list(int)")
.Attr("texture_coordinates: list(float)")
.Attr("number_of_vertices: int")
.Attr("number_of_cameras: int")
.Attr("render_resolution_u: int = 512")
.Attr("render_resolution_v: int = 512")
.Attr("albedo_mode: string")
.Attr("shading_mode: string")
.Attr("image_filter_size: int = 2")
.Attr("texture_filter_size: int = 2")
.Attr("compute_normal_map: bool = false");
//==============================================================================================//
CudaRenderer::CudaRenderer(OpKernelConstruction* context)
:
OpKernel(context)
{
std::vector<int> faces;
OP_REQUIRES_OK(context, context->GetAttr("faces", &faces));
std::vector<float> textureCoordinates;
OP_REQUIRES_OK(context, context->GetAttr("texture_coordinates", &textureCoordinates));
OP_REQUIRES_OK(context, context->GetAttr("number_of_vertices", &numberOfPoints));
OP_REQUIRES(context, numberOfPoints > 0, errors::InvalidArgument("number_of_vertices not set!", numberOfPoints));
OP_REQUIRES_OK(context, context->GetAttr("number_of_cameras", &numberOfCameras));
OP_REQUIRES(context, numberOfCameras > 0, errors::InvalidArgument("number_of_cameras not set!", numberOfCameras));
OP_REQUIRES_OK(context, context->GetAttr("render_resolution_u", &renderResolutionU));
OP_REQUIRES(context, renderResolutionU > 0, errors::InvalidArgument("render_resolution_u not set!", renderResolutionU));
OP_REQUIRES_OK(context, context->GetAttr("render_resolution_v", &renderResolutionV));
OP_REQUIRES(context, renderResolutionV > 0, errors::InvalidArgument("render_resolution_v not set!", renderResolutionV));
OP_REQUIRES_OK(context, context->GetAttr("albedo_mode", &albedoMode));
if (albedoMode != "vertexColor" && albedoMode != "textured" && albedoMode != "normal" && albedoMode != "foregroundMask" && albedoMode != "lighting")
{
std::cout << "INVALID ALBEDO MODE" << std::endl;
return;
}
OP_REQUIRES_OK(context, context->GetAttr("shading_mode", &shadingMode));
if (shadingMode != "shaded" && shadingMode != "shadeless")
{
std::cout << "INVALID SHADING MODE" << std::endl;
return;
}
if (albedoMode == "foregroundMask")
{
std::cout << "Automatically chose shading mode: shadeless" << std::endl;
shadingMode = "shadeless";
}
bool computeNormal;
OP_REQUIRES_OK(context, context->GetAttr("compute_normal_map", &computeNormal));
//---CONSOLE OUTPUT---
std::cout << std::endl;
std::cout << "|||||||||||||||||||||||||||||||||||||||||||||||||||||||||" << std::endl;
std::cout << std::endl;
/////////////////////////////////////////
/////////////////////////////////////////
std::cout << "OPERATOR: CudaRenderer" << std::endl;
/////////////////////////////////////////
/////////////////////////////////////////
//render mode
if (albedoMode == "vertexColor")
{
std::cout << "Albedo mode: vertexColor" << std::endl;
}
else if (albedoMode == "textured")
{
std::cout << "Albedo mode: textured" << std::endl;
}
else if (albedoMode == "normal")
{
std::cout << "Albedo mode: normal (note that gradients are zero now)" << std::endl;
}
else if (albedoMode == "lighting")
{
std::cout << "Albedo mode: lighting (note that gradients are zero now)" << std::endl;
}
else if (albedoMode == "foregroundMask")
{
std::cout << "Foreground mask mode: automatically choose shadeless" << std::endl;
}
std::cout << "Compute Normal : " << computeNormal << std::endl;
/////////////////////////////////////////
/////////////////////////////////////////
//shading mode
if (shadingMode == "shaded")
{
std::cout << "Shading mode: shaded" << std::endl;
}
else if (shadingMode == "shadeless")
{
std::cout << "Shading mode: shadeless" << std::endl;
}
/////////////////////////////////////////
/////////////////////////////////////////
//number of cameras
std::cout << "Number of cameras: " << std::to_string(numberOfCameras) << std::endl;
/////////////////////////////////////////
/////////////////////////////////////////
//render resolution
std::cout << "Resolution: " << std::to_string(renderResolutionU) << " x " << std::to_string(renderResolutionV) << std::endl;
/////////////////////////////////////////
/////////////////////////////////////////
//number of vertices
std::cout << "Number of vertices: " << std::to_string(numberOfPoints) << std::endl;
std::cout << std::endl;
std::cout << "|||||||||||||||||||||||||||||||||||||||||||||||||||||||||" << std::endl;
std::cout << std::endl;
cudaBasedRasterization = new CUDABasedRasterization(faces, textureCoordinates, numberOfPoints, numberOfCameras, renderResolutionU, renderResolutionV, albedoMode, shadingMode, computeNormal);
}
//==============================================================================================//
void CudaRenderer::setupInputOutputTensorPointers(OpKernelContext* context)
{
//---INPUT---
//[0]
//Grab the 3D vertex position
const Tensor& inputTensorVertexPos = context->input(0);
Eigen::TensorMap<Eigen::Tensor< const float, 1, 1, Eigen::DenseIndex>, 16> inputTensorVertexPosFlat = inputTensorVertexPos.flat_inner_dims<float, 1>();
d_inputVertexPos = inputTensorVertexPosFlat.data();
//[1]
//Grab the vertex color
const Tensor& inputTensorVertexColor = context->input(1);
Eigen::TensorMap<Eigen::Tensor< const float, 1, 1, Eigen::DenseIndex>, 16> inputTensorVertexColorFlat = inputTensorVertexColor.flat_inner_dims<float, 1>();
d_inputVertexColor = inputTensorVertexColorFlat.data();
//[2]
//Grab the texture
const Tensor& inputTensorTexture = context->input(2);
Eigen::TensorMap<Eigen::Tensor< const float, 1, 1, Eigen::DenseIndex>, 16> inputTensorTextureFlat = inputTensorTexture.flat_inner_dims<float, 1>();
d_inputTexture = inputTensorTextureFlat.data();
//[3]
//Grab the sh coeffs
const Tensor& inputTensorSHCoeff = context->input(3);
Eigen::TensorMap<Eigen::Tensor< const float, 1, 1, Eigen::DenseIndex>, 16> inputTensorSHCoeffFlat = inputTensorSHCoeff.flat_inner_dims<float, 1>();
d_inputSHCoeff = inputTensorSHCoeffFlat.data();
//[4]
//Grab the target image
const Tensor& inputTargetImage = context->input(4);
Eigen::TensorMap<Eigen::Tensor< const float, 1, 1, Eigen::DenseIndex>, 16> inputTargetImageFlat = inputTargetImage.flat_inner_dims<float, 1>();
d_inputTargetImage = inputTargetImageFlat.data();
//[5]
//Grab the extrinsics
const Tensor& inputExtrinsicsTensor = context->input(5);
Eigen::TensorMap<Eigen::Tensor< const float, 1, 1, Eigen::DenseIndex>, 16> inputExtrinsicsTensorFlat = inputExtrinsicsTensor.flat_inner_dims<float, 1>();
d_inputExtrinsics = inputExtrinsicsTensorFlat.data();
//[6]
//Grab the intrinsics
const Tensor& inputIntrinsicsTensor = context->input(6);
Eigen::TensorMap<Eigen::Tensor< const float, 1, 1, Eigen::DenseIndex>, 16> inputIntrinsicsTensorFlat = inputIntrinsicsTensor.flat_inner_dims<float, 1>();
d_inputIntrinsics = inputIntrinsicsTensorFlat.data();
//---MISC---
numberOfBatches = inputTensorTexture.dim_size(0);
textureResolutionV = inputTensorTexture.dim_size(1);
textureResolutionU = inputTensorTexture.dim_size(2);
//---OUTPUT---
//determine the output dimensions
std::vector<tensorflow::int64> channel1Dim;
channel1Dim.push_back(numberOfBatches);
channel1Dim.push_back(numberOfCameras);
channel1Dim.push_back(renderResolutionV);
channel1Dim.push_back(renderResolutionU);
tensorflow::gtl::ArraySlice<tensorflow::int64> channel1DimSize(channel1Dim);
std::vector<tensorflow::int64> channel2Dim;
channel2Dim.push_back(numberOfBatches);
channel2Dim.push_back(numberOfCameras);
channel2Dim.push_back(renderResolutionV);
channel2Dim.push_back(renderResolutionU);
channel2Dim.push_back(2);
tensorflow::gtl::ArraySlice<tensorflow::int64> channel2DimSize(channel2Dim);
std::vector<tensorflow::int64> channel3Dim;
channel3Dim.push_back(numberOfBatches);
channel3Dim.push_back(numberOfCameras);
channel3Dim.push_back(renderResolutionV);
channel3Dim.push_back(renderResolutionU);
channel3Dim.push_back(3);
tensorflow::gtl::ArraySlice<tensorflow::int64> channel3DimSize(channel3Dim);
std::vector<tensorflow::int64> vertexNormalDim;
vertexNormalDim.push_back(numberOfBatches);
vertexNormalDim.push_back(numberOfCameras);
vertexNormalDim.push_back(numberOfPoints);
vertexNormalDim.push_back(3);
tensorflow::gtl::ArraySlice<tensorflow::int64> vertexNormalDimSize(vertexNormalDim);
std::vector<tensorflow::int64> vertexNormalSingleDim;
vertexNormalSingleDim.push_back(numberOfBatches);
vertexNormalSingleDim.push_back(textureResolutionV);
vertexNormalSingleDim.push_back(textureResolutionU);
vertexNormalSingleDim.push_back(3);
tensorflow::gtl::ArraySlice<tensorflow::int64> vertexNormalSingleDimSize(vertexNormalSingleDim);
//[0]
//barycentric
tensorflow::Tensor* outputTensorBarycentric;
OP_REQUIRES_OK(context, context->allocate_output(0, tensorflow::TensorShape(channel2DimSize), &outputTensorBarycentric));
Eigen::TensorMap<Eigen::Tensor<float, 1, 1, Eigen::DenseIndex>, 16> outputTensorBarycentricFlat = outputTensorBarycentric->flat<float>();
d_outputBarycentricCoordinatesBuffer = outputTensorBarycentricFlat.data();
//[1]
//face
tensorflow::Tensor* outputTensorFace;
OP_REQUIRES_OK(context, context->allocate_output(1, tensorflow::TensorShape(channel1DimSize), &outputTensorFace));
Eigen::TensorMap<Eigen::Tensor<int, 1, 1, Eigen::DenseIndex>, 16> outputTensorFaceFlat = outputTensorFace->flat<int>();
d_outputFaceIDBuffer = outputTensorFaceFlat.data();
//[2]
//render
tensorflow::Tensor* outputTensorRender;
OP_REQUIRES_OK(context, context->allocate_output(2, tensorflow::TensorShape(channel3DimSize), &outputTensorRender));
Eigen::TensorMap<Eigen::Tensor<float, 1, 1, Eigen::DenseIndex>, 16> outputTensorRenderFlat = outputTensorRender->flat<float>();
d_outputRenderBuffer = outputTensorRenderFlat.data();
//[3]
//vertex normal
tensorflow::Tensor* outputTensorVertexNormal;
OP_REQUIRES_OK(context, context->allocate_output(3, tensorflow::TensorShape(vertexNormalDimSize), &outputTensorVertexNormal));
Eigen::TensorMap<Eigen::Tensor<float, 1, 1, Eigen::DenseIndex>, 16> outputTensorVertexNormalFlat = outputTensorVertexNormal->flat<float>();
d_outputVertexNormal = outputTensorVertexNormalFlat.data();
//[4]
//target
tensorflow::Tensor* outputTensorTarget;
OP_REQUIRES_OK(context, context->allocate_output(4, tensorflow::TensorShape(channel3DimSize), &outputTensorTarget));
Eigen::TensorMap<Eigen::Tensor<float, 1, 1, Eigen::DenseIndex>, 16> outputTensorTargetFlat = outputTensorTarget->flat<float>();
d_outputTargetImage = outputTensorTargetFlat.data();
cutilSafeCall(cudaMemcpy(d_outputTargetImage, d_inputTargetImage, sizeof(float) * numberOfBatches * numberOfCameras * renderResolutionV * renderResolutionU * 3, cudaMemcpyDeviceToDevice));
//[5]
//target
tensorflow::Tensor* outputTensorNormalMap;
OP_REQUIRES_OK(context, context->allocate_output(5, tensorflow::TensorShape(vertexNormalSingleDimSize), &outputTensorNormalMap));
Eigen::TensorMap<Eigen::Tensor<float, 1, 1, Eigen::DenseIndex>, 16> outputTensorNormalMapFlat = outputTensorNormalMap->flat<float>();
d_outputNormalMap = outputTensorNormalMapFlat.data();
}
//==============================================================================================//
void CudaRenderer::Compute(OpKernelContext* context)
{
try
{
//setup the input and output pointers of the tensor because they change from compute to compute call
setupInputOutputTensorPointers(context);
//set input
cudaBasedRasterization->setTextureWidth(textureResolutionU);
cudaBasedRasterization->setTextureHeight(textureResolutionV);
for (int b = 0; b < numberOfBatches; b++)
{
//set input
cudaBasedRasterization->set_D_vertices( (float3*) d_inputVertexPos + b * numberOfPoints );
cudaBasedRasterization->set_D_vertexColors( (float3*) d_inputVertexColor + b * numberOfPoints );
cudaBasedRasterization->set_D_textureMap( d_inputTexture + b * textureResolutionV * textureResolutionU * 3);
cudaBasedRasterization->set_D_shCoeff( d_inputSHCoeff + b * numberOfCameras * 27);
cudaBasedRasterization->set_D_extrinsics( d_inputExtrinsics + b * numberOfCameras * 12);
cudaBasedRasterization->set_D_intrinsics( d_inputIntrinsics + b * numberOfCameras * 9);
//set output
cudaBasedRasterization->set_D_barycentricCoordinatesBuffer( d_outputBarycentricCoordinatesBuffer + b * numberOfCameras * renderResolutionV * renderResolutionU * 2);
cudaBasedRasterization->set_D_faceIDBuffer( d_outputFaceIDBuffer + b * numberOfCameras * renderResolutionV * renderResolutionU);
cudaBasedRasterization->set_D_renderBuffer( d_outputRenderBuffer + b * numberOfCameras * renderResolutionV * renderResolutionU * 3);
cudaBasedRasterization->set_D_vertexNormal( (float3*) d_outputVertexNormal + b * numberOfCameras * numberOfPoints );
cudaBasedRasterization->set_D_normalMap( (float3*) d_outputNormalMap + b * textureResolutionU * textureResolutionV);
//render
cudaBasedRasterization->renderBuffers();
}
}
catch (std::exception e)
{
std::cerr << "Something went wrong during the forward rendering!" << std::endl;
}
}
//==============================================================================================//
REGISTER_KERNEL_BUILDER(Name("CudaRendererGpu").Device(DEVICE_GPU), CudaRenderer);
| 42.044118 | 192 | 0.678139 | [
"render",
"vector",
"3d"
] |
9861295c93e14c348704e3a7dd94d028d6ee999c | 3,461 | cc | C++ | cinn/frontend/decomposer/activation_test.cc | Xreki/CINN | 8a45557685224f4ff6699da155e2d7879e32e0d3 | [
"Apache-2.0"
] | null | null | null | cinn/frontend/decomposer/activation_test.cc | Xreki/CINN | 8a45557685224f4ff6699da155e2d7879e32e0d3 | [
"Apache-2.0"
] | null | null | null | cinn/frontend/decomposer/activation_test.cc | Xreki/CINN | 8a45557685224f4ff6699da155e2d7879e32e0d3 | [
"Apache-2.0"
] | null | null | null | // Copyright (c) 2021 CINN Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <gtest/gtest.h>
#include <random>
#include "cinn/frontend/decomposer/use_decomposer.h"
#include "cinn/frontend/decomposer_registry.h"
#include "cinn/frontend/net_builder.h"
#include "cinn/frontend/pass/use_program_pass.h"
#include "cinn/frontend/program_pass.h"
#include "cinn/hlir/framework/graph.h"
#include "cinn/hlir/framework/graph_compiler.h"
#include "cinn/hlir/framework/pass.h"
#include "cinn/hlir/framework/tensor.h"
#include "cinn/hlir/op/use_ops.h"
#include "cinn/hlir/pass/use_pass.h"
namespace cinn::frontend {
void SetRandData(hlir::framework::Tensor tensor, Target target) {
auto* data = tensor->mutable_data<float>(target);
std::random_device seed;
std::default_random_engine engine(seed());
std::uniform_real_distribution<float> dist(1.f, 2.f);
size_t num_ele = tensor->shape().numel();
std::vector<float> random_data(num_ele);
for (size_t i = 0; i < num_ele; i++) {
random_data[i] = dist(engine); // All random data
}
#ifdef CINN_WITH_CUDA
cudaMemcpy(data, random_data.data(), num_ele * sizeof(float), cudaMemcpyHostToDevice);
#else
std::copy(random_data.begin(), random_data.end(), data);
#endif
}
Target GetTarget() {
#ifdef CINN_WITH_CUDA
return common::DefaultNVGPUTarget();
#else
return common::DefaultHostTarget();
#endif
}
void RunProgram(NetBuilder& builder, const std::vector<std::string>& inputs) {
auto prog = builder.Build();
Target target = GetTarget();
LOG(INFO) << "===================== Before Decomposition =====================";
for (int i = 0; i < prog.size(); i++) {
LOG(INFO) << "instruction: " << prog[i];
}
ProgramPass::Apply(&prog, target, {"Decomposer"});
LOG(INFO) << "===================== After Decomposition =====================";
for (int i = 0; i < prog.size(); i++) {
LOG(INFO) << "instruction: " << prog[i];
}
auto graph = std::make_shared<hlir::framework::Graph>(prog, target);
hlir::framework::ApplyPass(graph.get(), "OpFusion");
auto scope = BuildScope(target, graph);
hlir::framework::GraphCompiler gc(target, scope, graph);
auto runtime_program = gc.Build();
for (auto& in : inputs) {
scope->Var<hlir::framework::Tensor>(in);
auto tensor = scope->GetTensor(in);
SetRandData(tensor, target);
}
runtime_program->Execute();
}
TEST(Decomposer, relu) {
NetBuilder builder("relu");
auto x = builder.CreateInput(Float(32), {20, 10});
auto out = builder.relu(x);
std::vector<std::string> inputs = {"X"};
RunProgram(builder, inputs);
}
TEST(Decomposer, relu_grad) {
NetBuilder builder("relu_grad");
auto dout = builder.CreateInput(Float(32), {20, 10});
auto out = builder.CreateInput(Float(32), {20, 10});
auto dx = builder.relu_grad(dout, out);
std::vector<std::string> inputs = {"Dout", "Out"};
RunProgram(builder, inputs);
}
} // namespace cinn::frontend
| 32.961905 | 88 | 0.681306 | [
"shape",
"vector"
] |
98630c6268f08d52282526020643bc6b57113108 | 5,497 | hh | C++ | cc/utils/messages.hh | skepner/ae | d53336a561df1a46a39debb143c9f9496b222a46 | [
"MIT"
] | null | null | null | cc/utils/messages.hh | skepner/ae | d53336a561df1a46a39debb143c9f9496b222a46 | [
"MIT"
] | null | null | null | cc/utils/messages.hh | skepner/ae | d53336a561df1a46a39debb143c9f9496b222a46 | [
"MIT"
] | null | null | null | #pragma once
#include <set>
#include <vector>
#include <string>
#include "ext/fmt.hh"
#include "virus/type-subtype.hh"
// ----------------------------------------------------------------------
namespace ae
{
struct MessageLocation
{
std::string filename{};
size_t line_no{0};
};
struct Message
{
enum message_type { //
unknown, //
unhandled_virus_name, //
unrecognized_passage, //
invalid_subtype, //
subtype_mismatch, //
lineage_mismatch, //
unrecognized_location, //
unrecognized_deletions, //
not_detected_insertions, //
garbage_at_the_end, //
invalid_sequence, //
invalid_year //
};
message_type type;
virus::type_subtype_t type_subtype{};
std::string value{};
std::string context{};
MessageLocation location;
static inline std::string_view format_short(message_type type)
{
switch (type) {
case unknown:
return "U";
case unrecognized_location:
return "L";
case unrecognized_passage:
return "P";
case unrecognized_deletions:
case not_detected_insertions:
case garbage_at_the_end:
return "D";
case invalid_subtype:
case subtype_mismatch:
return "S";
case lineage_mismatch:
return "V";
case invalid_year:
return "Y";
case unhandled_virus_name:
return "-";
case invalid_sequence:
return "X";
}
return "U";
}
static inline std::string_view format_long(message_type type)
{
switch (type) {
case unknown:
return "unknown";
case unrecognized_location:
return "unrecognized location";
case unrecognized_passage:
return "unrecognized passage";
case unrecognized_deletions:
return "unrecognized deletions";
case not_detected_insertions:
return "not detected insertions";
case invalid_subtype:
return "invalid subtype";
case subtype_mismatch:
return "subtype mismatch";
case lineage_mismatch:
return "lineage mismatch";
case invalid_year:
return "invalid year";
case unhandled_virus_name:
return "unhandled virus name";
case invalid_sequence:
return "invalid sequence";
case garbage_at_the_end:
return "garbage_at_the_end";
}
return "unknown";
}
};
class Messages
{
public:
Messages() = default;
Messages(const Messages&) = default;
Messages(Messages&&) = default;
std::string report() const;
bool empty() const { return messages_.empty(); }
constexpr const auto& messages() const { return messages_; }
const auto& unrecognized_locations() const { return unrecognized_locations_; }
void add(Message::message_type type, std::string_view value, std::string_view context, const MessageLocation& location = {})
{
messages_.push_back({type, virus::type_subtype_t{}, std::string{value}, std::string{context}, location});
switch (type) {
case Message::unrecognized_location:
unrecognized_locations_.emplace(value);
break;
case Message::unrecognized_passage:
case Message::unrecognized_deletions:
case Message::not_detected_insertions:
case Message::invalid_subtype:
case Message::subtype_mismatch:
case Message::lineage_mismatch:
case Message::invalid_year:
case Message::unhandled_virus_name:
case Message::invalid_sequence:
case Message::garbage_at_the_end:
case Message::unknown:
break;
}
}
void add(Message::message_type type, const virus::type_subtype_t& type_subtype, std::string_view value, std::string_view context, const MessageLocation& location = {})
{
add(type, value, context, location);
messages_.back().type_subtype = type_subtype;
}
private:
std::vector<Message> messages_{};
std::set<std::string> unrecognized_locations_{};
};
} // namespace ae
// ----------------------------------------------------------------------
template <> struct fmt::formatter<ae::Message::message_type> : fmt::formatter<ae::fmt_helper::default_formatter>
{
template <typename FormatCtx> auto format(ae::Message::message_type type, FormatCtx& ctx) { return format_to(ctx.out(), "{}", ae::Message::format_long(type)); }
};
// ----------------------------------------------------------------------
| 34.791139 | 175 | 0.504093 | [
"vector"
] |
98638c2e8fa57b37e5f71c1a0bffe860cc2f88cb | 23,825 | cpp | C++ | ql/experimental/models/gaussian1dfloatfloatswaptionengine.cpp | quantosaurosProject/quantLib | 84b49913d3940cf80d6de8f70185867373f45e8d | [
"BSD-3-Clause"
] | null | null | null | ql/experimental/models/gaussian1dfloatfloatswaptionengine.cpp | quantosaurosProject/quantLib | 84b49913d3940cf80d6de8f70185867373f45e8d | [
"BSD-3-Clause"
] | null | null | null | ql/experimental/models/gaussian1dfloatfloatswaptionengine.cpp | quantosaurosProject/quantLib | 84b49913d3940cf80d6de8f70185867373f45e8d | [
"BSD-3-Clause"
] | 1 | 2022-03-29T05:44:27.000Z | 2022-03-29T05:44:27.000Z | /* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
Copyright (C) 2013 Peter Caspers
This file is part of QuantLib, a free-software/open-source library
for financial quantitative analysts and developers - http://quantlib.org/
QuantLib is free software: you can redistribute it and/or modify it
under the terms of the QuantLib license. You should have received a
copy of the license along with this program; if not, please email
<quantlib-dev@lists.sf.net>. The license is also available online at
<http://quantlib.org/license.shtml>.
This program 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 license for more details.
*/
#include <ql/experimental/models/gaussian1dfloatfloatswaptionengine.hpp>
namespace QuantLib {
void Gaussian1dFloatFloatSwaptionEngine::calculate() const {
Date settlement = model_->termStructure()->referenceDate();
if (arguments_.exercise->dates().back() <=
settlement) { // swaption is expired, possibly generated swap is not
// valued
results_.value = 0.0;
return;
}
rebatedExercise_ =
boost::dynamic_pointer_cast<RebatedExercise>(arguments_.exercise);
std::pair<Real, Real> result =
npvs(settlement, 0.0, includeTodaysExercise_);
results_.value = result.first;
results_.additionalResults["underlyingValue"] = result.second;
}
const Real
Gaussian1dFloatFloatSwaptionEngine::underlyingNpv(const Date &expiry,
const Real y) const {
return npvs(expiry, y, true).second;
}
const VanillaSwap::Type
Gaussian1dFloatFloatSwaptionEngine::underlyingType() const {
return arguments_.swap->type();
}
const Date Gaussian1dFloatFloatSwaptionEngine::underlyingLastDate() const {
Date l1 = arguments_.leg1PayDates.back();
Date l2 = arguments_.leg2PayDates.back();
return l2 >= l1 ? l2 : l1;
}
const Disposable<Array>
Gaussian1dFloatFloatSwaptionEngine::initialGuess(const Date &expiry) const {
Size idx1 =
std::upper_bound(arguments_.leg1ResetDates.begin(),
arguments_.leg1ResetDates.end(), expiry - 1) -
arguments_.leg1ResetDates.begin();
// very simple initial guess
Array initial(3);
Real nominalSum1 = 0.0;
for (Size i = idx1; i < arguments_.leg1ResetDates.size(); i++) {
nominalSum1 += arguments_.nominal1[i];
}
Real nominalAvg1 = nominalSum1 /=
(arguments_.leg1ResetDates.size() - idx1);
Real weightedMaturity1 = 0.0;
for (Size i = idx1; i < arguments_.leg1ResetDates.size(); i++) {
weightedMaturity1 +=
arguments_.leg1AccrualTimes[i] * arguments_.nominal1[i];
}
weightedMaturity1 /= nominalAvg1;
initial[0] = nominalAvg1;
initial[1] = weightedMaturity1;
initial[2] = 0.03; // ???
return initial;
}
// calculate npv and underlying npv as of expiry date
const std::pair<Real, Real> Gaussian1dFloatFloatSwaptionEngine::npvs(
const Date &expiry, const Real y,
const bool includeExerciseOnExpiry) const {
// pricing
// event dates are coupon fixing dates and exercise dates
// we explicitly estimate cms and also libor coupons (although
// the latter could be calculated analytically) to make the code
// simpler
std::vector<Date> events;
events.insert(events.end(), arguments_.exercise->dates().begin(),
arguments_.exercise->dates().end());
events.insert(events.end(), arguments_.leg1FixingDates.begin(),
arguments_.leg1FixingDates.end());
events.insert(events.end(), arguments_.leg2FixingDates.begin(),
arguments_.leg2FixingDates.end());
std::sort(events.begin(), events.end());
std::vector<Date>::iterator it =
std::unique(events.begin(), events.end());
events.resize(std::distance(events.begin(), it));
// only events on or after expiry are of interest by definition of the
// deal part that is exericsed into.
std::vector<Date>::iterator filit =
std::upper_bound(events.begin(), events.end(),
expiry - (includeExerciseOnExpiry ? 1 : 0));
events.erase(events.begin(), filit);
int idx = events.size() - 1;
FloatFloatSwap swap = *arguments_.swap;
Option::Type type =
arguments_.type == VanillaSwap::Payer ? Option::Call : Option::Put;
Array npv0(2 * integrationPoints_ + 1, 0.0),
npv1(2 * integrationPoints_ + 1, 0.0); // arrays for npvs of the
// option
Array npv0a(2 * integrationPoints_ + 1, 0.0),
npv1a(2 * integrationPoints_ + 1, 0.0); // arrays for npvs of the
// underlying
Array z = model_->yGrid(stddevs_, integrationPoints_);
Array p(z.size(), 0.0), pa(z.size(), 0.0);
Date event1 = Null<Date>(), event0;
Time event1Time = Null<Real>(), event0Time;
bool isExercise, isLeg1Fixing, isLeg2Fixing;
boost::shared_ptr<IborIndex> ibor1 =
boost::dynamic_pointer_cast<IborIndex>(arguments_.index1);
boost::shared_ptr<SwapIndex> cms1 =
boost::dynamic_pointer_cast<SwapIndex>(arguments_.index1);
boost::shared_ptr<IborIndex> ibor2 =
boost::dynamic_pointer_cast<IborIndex>(arguments_.index2);
boost::shared_ptr<SwapIndex> cms2 =
boost::dynamic_pointer_cast<SwapIndex>(arguments_.index2);
QL_REQUIRE(ibor1 != NULL || cms1 != NULL,
"index1 must be ibor or swap index");
QL_REQUIRE(ibor2 != NULL || cms2 != NULL,
"index2 must be ibor or swap index");
do {
// we are at event0 date, which can be a structured coupon fixing
// date or an exercise date or both.
bool isEventDate = true;
if (idx == -1) {
event0 = expiry;
isEventDate = false;
} else {
event0 = events[idx];
if (event0 == expiry)
idx = -1; // avoid double roll back if expiry equal to
// earliest event date
}
if (std::find(arguments_.exercise->dates().begin(),
arguments_.exercise->dates().end(),
event0) != arguments_.exercise->dates().end())
isExercise = true;
else
isExercise = false;
if (std::find(arguments_.leg1FixingDates.begin(),
arguments_.leg1FixingDates.end(),
event0) != arguments_.leg1FixingDates.end())
isLeg1Fixing = true;
else
isLeg1Fixing = false;
if (std::find(arguments_.leg2FixingDates.begin(),
arguments_.leg2FixingDates.end(),
event0) != arguments_.leg2FixingDates.end())
isLeg2Fixing = true;
else
isLeg2Fixing = false;
event0Time = std::max(
model_->termStructure()->timeFromReference(event0), 0.0);
// iterate through the grid
for (Size k = 0; k < (event0 > expiry ? npv0.size() : 1); k++) {
// roll back
Real price = 0.0, pricea = 0.0;
if (event1Time != Null<Real>()) {
Real zSpreadDf = oas_.empty()
? 1.0
: std::exp(-oas_->value() *
(event1Time - event0Time));
Array yg =
model_->yGrid(stddevs_, integrationPoints_, event1Time,
event0Time, event0 > expiry ? z[k] : y);
CubicInterpolation payoff0(
z.begin(), z.end(), npv1.begin(),
CubicInterpolation::Spline, true,
CubicInterpolation::Lagrange, 0.0,
CubicInterpolation::Lagrange, 0.0);
CubicInterpolation payoff0a(
z.begin(), z.end(), npv1a.begin(),
CubicInterpolation::Spline, true,
CubicInterpolation::Lagrange, 0.0,
CubicInterpolation::Lagrange, 0.0);
for (Size i = 0; i < yg.size(); i++) {
p[i] = payoff0(yg[i], true);
pa[i] = payoff0a(yg[i], true);
}
CubicInterpolation payoff1(
z.begin(), z.end(), p.begin(),
CubicInterpolation::Spline, true,
CubicInterpolation::Lagrange, 0.0,
CubicInterpolation::Lagrange, 0.0);
CubicInterpolation payoff1a(
z.begin(), z.end(), pa.begin(),
CubicInterpolation::Spline, true,
CubicInterpolation::Lagrange, 0.0,
CubicInterpolation::Lagrange, 0.0);
for (Size i = 0; i < z.size() - 1; i++) {
price += model_->gaussianShiftedPolynomialIntegral(
0.0, payoff1.cCoefficients()[i],
payoff1.bCoefficients()[i],
payoff1.aCoefficients()[i], p[i], z[i],
z[i], z[i + 1]) *
zSpreadDf;
pricea += model_->gaussianShiftedPolynomialIntegral(
0.0, payoff1a.cCoefficients()[i],
payoff1a.bCoefficients()[i],
payoff1a.aCoefficients()[i], pa[i], z[i],
z[i], z[i + 1]) *
zSpreadDf;
}
if (extrapolatePayoff_) {
if (flatPayoffExtrapolation_) {
price +=
model_->gaussianShiftedPolynomialIntegral(
0.0, 0.0, 0.0, 0.0, p[z.size() - 2],
z[z.size() - 2], z[z.size() - 1], 100.0) *
zSpreadDf;
price += model_->gaussianShiftedPolynomialIntegral(
0.0, 0.0, 0.0, 0.0, p[0], z[0], -100.0,
z[0]) *
zSpreadDf;
pricea +=
model_->gaussianShiftedPolynomialIntegral(
0.0, 0.0, 0.0, 0.0, pa[z.size() - 2],
z[z.size() - 2], z[z.size() - 1], 100.0) *
zSpreadDf;
pricea += model_->gaussianShiftedPolynomialIntegral(
0.0, 0.0, 0.0, 0.0, pa[0], z[0],
-100.0, z[0]) *
zSpreadDf;
} else {
if (type == Option::Call)
price +=
model_->gaussianShiftedPolynomialIntegral(
0.0,
payoff1.cCoefficients()[z.size() - 2],
payoff1.bCoefficients()[z.size() - 2],
payoff1.aCoefficients()[z.size() - 2],
p[z.size() - 2], z[z.size() - 2],
z[z.size() - 1], 100.0) *
zSpreadDf;
if (type == Option::Put)
price +=
model_->gaussianShiftedPolynomialIntegral(
0.0, payoff1.cCoefficients()[0],
payoff1.bCoefficients()[0],
payoff1.aCoefficients()[0], p[0], z[0],
-100.0, z[0]) *
zSpreadDf;
if (type == Option::Call)
pricea +=
model_->gaussianShiftedPolynomialIntegral(
0.0,
payoff1a.cCoefficients()[z.size() - 2],
payoff1a.bCoefficients()[z.size() - 2],
payoff1a.aCoefficients()[z.size() - 2],
pa[z.size() - 2], z[z.size() - 2],
z[z.size() - 1], 100.0) *
zSpreadDf;
if (type == Option::Put)
pricea +=
model_->gaussianShiftedPolynomialIntegral(
0.0, payoff1a.cCoefficients()[0],
payoff1a.bCoefficients()[0],
payoff1a.aCoefficients()[0], pa[0],
z[0], -100.0, z[0]) *
zSpreadDf;
}
}
}
npv0[k] = price;
npv0a[k] = pricea;
// event date calculations
if (isEventDate) {
Real zk = event0 > expiry ? z[k] : y;
if (isLeg1Fixing) { // if event is a fixing date and
// exercise date,
// the coupon is part of the exercise into right (by
// definition)
Size j = std::find(arguments_.leg1FixingDates.begin(),
arguments_.leg1FixingDates.end(),
event0) -
arguments_.leg1FixingDates.begin();
Real zSpreadDf =
oas_.empty()
? 1.0
: std::exp(
-oas_->value() *
(model_->termStructure()
->dayCounter()
.yearFraction(
event0,
arguments_.leg1PayDates[j])));
bool done = false;
do {
Real amount;
if (arguments_.leg1IsRedemptionFlow[j]) {
amount = arguments_.leg1Coupons[j];
} else {
Real rate =
arguments_.leg1Spreads[j] +
arguments_.leg1Gearings[j] *
(ibor1 != NULL
? model_->forwardRate(
arguments_.leg1FixingDates
[j],
event0, zk, ibor1)
: model_->swapRate(
arguments_.leg1FixingDates
[j],
cms1->tenor(), event0, zk,
cms1));
if (arguments_.leg1CappedRates[j] !=
Null<Real>())
rate = std::min(
arguments_.leg1CappedRates[j], rate);
if (arguments_.leg1FlooredRates[j] !=
Null<Real>())
rate = std::max(
arguments_.leg1FlooredRates[j], rate);
amount = rate * arguments_.nominal1[j] *
arguments_.leg1AccrualTimes[j];
}
npv0a[k] -=
amount *
model_->zerobond(arguments_.leg1PayDates[j],
event0, zk, discountCurve_) /
model_->numeraire(event0Time, zk,
discountCurve_) *
zSpreadDf;
if (j < arguments_.leg1FixingDates.size() - 1) {
j++;
done =
(event0 != arguments_.leg1FixingDates[j]);
} else
done = true;
} while (!done);
}
if (isLeg2Fixing) { // if event is a fixing date and
// exercise date,
// the coupon is part of the exercise into right (by
// definition)
Size j = std::find(arguments_.leg2FixingDates.begin(),
arguments_.leg2FixingDates.end(),
event0) -
arguments_.leg2FixingDates.begin();
Real zSpreadDf =
oas_.empty()
? 1.0
: std::exp(
-oas_->value() *
(model_->termStructure()
->dayCounter()
.yearFraction(
event0,
arguments_.leg2PayDates[j])));
bool done;
do {
Real amount;
if (arguments_.leg2IsRedemptionFlow[j]) {
amount = arguments_.leg2Coupons[j];
} else {
Real rate =
arguments_.leg2Spreads[j] +
arguments_.leg2Gearings[j] *
(ibor2 != NULL
? model_->forwardRate(
arguments_.leg2FixingDates
[j],
event0, zk, ibor2)
: model_->swapRate(
arguments_.leg2FixingDates
[j],
cms2->tenor(), event0, zk,
cms1));
if (arguments_.leg2CappedRates[j] !=
Null<Real>())
rate = std::min(
arguments_.leg2CappedRates[j], rate);
if (arguments_.leg2FlooredRates[j] !=
Null<Real>())
rate = std::max(
arguments_.leg2FlooredRates[j], rate);
amount = rate * arguments_.nominal2[j] *
arguments_.leg2AccrualTimes[j];
}
npv0a[k] +=
amount *
model_->zerobond(arguments_.leg2PayDates[j],
event0, zk, discountCurve_) /
model_->numeraire(event0Time, zk,
discountCurve_) *
zSpreadDf;
if (j < arguments_.leg2FixingDates.size() - 1) {
j++;
done =
(event0 != arguments_.leg2FixingDates[j]);
} else
done = true;
} while (!done);
}
if (isExercise) {
Size j = std::find(arguments_.exercise->dates().begin(),
arguments_.exercise->dates().end(),
event0) -
arguments_.exercise->dates().begin();
Real rebate = 0.0;
Real zSpreadDf = 1.0;
Date rebateDate = event0;
if (rebatedExercise_ != NULL) {
rebate = rebatedExercise_->rebate(j);
rebateDate =
rebatedExercise_->rebatePaymentDate(j);
zSpreadDf =
oas_.empty()
? 1.0
: std::exp(-oas_->value() *
(model_->termStructure()
->dayCounter()
.yearFraction(event0,
rebateDate)));
}
npv0[k] = std::max(
npv0[k],
(type == Option::Call ? 1.0 : -1.0) * npv0a[k] +
rebate * model_->zerobond(rebateDate, event0) *
zSpreadDf /
model_->numeraire(event0Time, zk,
discountCurve_));
}
}
}
npv1.swap(npv0);
npv1a.swap(npv0a);
event1 = event0;
event1Time = event0Time;
} while (--idx >= -1);
std::pair<Real, Real> res(
npv1[0] * model_->numeraire(event1Time, y, discountCurve_),
npv1a[0] * model_->numeraire(event1Time, y, discountCurve_) *
(type == Option::Call ? 1.0 : -1.0));
return res;
}
}
| 47.365805 | 80 | 0.391815 | [
"vector"
] |
98650135ecd2ea81cdd57caa2f1f6e836cc1d482 | 4,276 | cpp | C++ | src/gui/qgsgeometryrubberband.cpp | dyna-mis/Hilabeling | cb7d5d4be29624a20c8a367162dbc6fd779b2b52 | [
"MIT"
] | null | null | null | src/gui/qgsgeometryrubberband.cpp | dyna-mis/Hilabeling | cb7d5d4be29624a20c8a367162dbc6fd779b2b52 | [
"MIT"
] | null | null | null | src/gui/qgsgeometryrubberband.cpp | dyna-mis/Hilabeling | cb7d5d4be29624a20c8a367162dbc6fd779b2b52 | [
"MIT"
] | 1 | 2021-12-25T08:40:30.000Z | 2021-12-25T08:40:30.000Z | /***************************************************************************
qgsgeometryrubberband.cpp
-------------------------
begin : December 2014
copyright : (C) 2014 by Marco Hugentobler
email : marco at sourcepole dot ch
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#include "qgsgeometryrubberband.h"
#include "qgsabstractgeometry.h"
#include "qgsmapcanvas.h"
#include "qgspoint.h"
#include <QPainter>
QgsGeometryRubberBand::QgsGeometryRubberBand( QgsMapCanvas *mapCanvas, QgsWkbTypes::GeometryType geomType ): QgsMapCanvasItem( mapCanvas ),
mIconSize( 5 ), mIconType( ICON_BOX ), mGeometryType( geomType )
{
mPen = QPen( QColor( 255, 0, 0 ) );
mBrush = QBrush( QColor( 255, 0, 0 ) );
}
QgsGeometryRubberBand::~QgsGeometryRubberBand()
{
delete mGeometry;
}
void QgsGeometryRubberBand::paint( QPainter *painter )
{
if ( !mGeometry || !painter )
{
return;
}
painter->save();
painter->translate( -pos() );
if ( mGeometryType == QgsWkbTypes::PolygonGeometry )
{
painter->setBrush( mBrush );
}
else
{
painter->setBrush( Qt::NoBrush );
}
painter->setPen( mPen );
QgsAbstractGeometry *paintGeom = mGeometry->clone();
paintGeom->transform( mMapCanvas->getCoordinateTransform()->transform() );
paintGeom->draw( *painter );
//draw vertices
QgsVertexId vertexId;
QgsPoint vertex;
while ( paintGeom->nextVertex( vertexId, vertex ) )
{
drawVertex( painter, vertex.x(), vertex.y() );
}
delete paintGeom;
painter->restore();
}
void QgsGeometryRubberBand::drawVertex( QPainter *p, double x, double y )
{
qreal s = ( mIconSize - 1 ) / 2.0;
switch ( mIconType )
{
case ICON_NONE:
break;
case ICON_CROSS:
p->drawLine( QLineF( x - s, y, x + s, y ) );
p->drawLine( QLineF( x, y - s, x, y + s ) );
break;
case ICON_X:
p->drawLine( QLineF( x - s, y - s, x + s, y + s ) );
p->drawLine( QLineF( x - s, y + s, x + s, y - s ) );
break;
case ICON_BOX:
p->drawLine( QLineF( x - s, y - s, x + s, y - s ) );
p->drawLine( QLineF( x + s, y - s, x + s, y + s ) );
p->drawLine( QLineF( x + s, y + s, x - s, y + s ) );
p->drawLine( QLineF( x - s, y + s, x - s, y - s ) );
break;
case ICON_FULL_BOX:
p->drawRect( x - s, y - s, mIconSize, mIconSize );
break;
case ICON_CIRCLE:
p->drawEllipse( x - s, y - s, mIconSize, mIconSize );
break;
}
}
void QgsGeometryRubberBand::setGeometry( QgsAbstractGeometry *geom )
{
delete mGeometry;
mGeometry = geom;
if ( mGeometry )
{
setRect( rubberBandRectangle() );
}
}
void QgsGeometryRubberBand::moveVertex( QgsVertexId id, const QgsPoint &newPos )
{
if ( mGeometry )
{
mGeometry->moveVertex( id, newPos );
setRect( rubberBandRectangle() );
}
}
void QgsGeometryRubberBand::setFillColor( const QColor &c )
{
mBrush.setColor( c );
}
void QgsGeometryRubberBand::setStrokeColor( const QColor &c )
{
mPen.setColor( c );
}
void QgsGeometryRubberBand::setStrokeWidth( int width )
{
mPen.setWidth( width );
}
void QgsGeometryRubberBand::setLineStyle( Qt::PenStyle penStyle )
{
mPen.setStyle( penStyle );
}
void QgsGeometryRubberBand::setBrushStyle( Qt::BrushStyle brushStyle )
{
mBrush.setStyle( brushStyle );
}
QgsRectangle QgsGeometryRubberBand::rubberBandRectangle() const
{
qreal scale = mMapCanvas->mapUnitsPerPixel();
qreal s = ( mIconSize - 1 ) / 2.0 * scale;
qreal p = mPen.width() * scale;
return mGeometry->boundingBox().buffered( s + p );
}
| 26.395062 | 139 | 0.551918 | [
"transform"
] |
98677e3e73011638331381bbcf353a3cdfdc6996 | 7,646 | cc | C++ | src/affilechooser-ui.cc | mpayrits/alarmfsck | 9586debf2d7b4cf3076a76576f0b76b9521b84c4 | [
"MIT"
] | null | null | null | src/affilechooser-ui.cc | mpayrits/alarmfsck | 9586debf2d7b4cf3076a76576f0b76b9521b84c4 | [
"MIT"
] | null | null | null | src/affilechooser-ui.cc | mpayrits/alarmfsck | 9586debf2d7b4cf3076a76576f0b76b9521b84c4 | [
"MIT"
] | null | null | null | #include "affilechooser.h"
#include "aflaunch.h"
#include "common.h"
#include <gtkmm/filechooserdialog.h>
#include <gtkmm/cellrenderertext.h>
#include <iostream>
#include <cstdlib>
const char FILE_DELIM = '/';
AlarmFsckFileChooser::AlarmFsckFileChooser(AlarmFsckLauncher& parent) :
addFilesButton("Add Files"),
addFolderButton("Add Folder"),
removeButton("Remove"),
importButton("Import"),
doneButton("Done"),
cancelButton("Cancel"),
bottomButtonHBox(Gtk::ORIENTATION_HORIZONTAL),
vBox(Gtk::ORIENTATION_VERTICAL, 5),
totalSize(0),
parentWindow{parent}
{
get_set_first_obj_ptr(this);
/* UI initialization {{{ */
set_border_width(10);
set_title("Choose Files to Scramble");
set_default_size(500, 400);
set_transient_for(parentWindow);
// Widget setup
bottomButtonHBox.set_layout(Gtk::BUTTONBOX_SPREAD);
bottomButtonHBox.set_spacing(40);
bottomButtonHBox.add(addFilesButton);
bottomButtonHBox.add(addFolderButton);
bottomButtonHBox.add(removeButton);
bottomButtonHBox.add(importButton);
bottomButtonHBox.add(doneButton);
bottomButtonHBox.add(cancelButton);
vBox.pack_start(fileScroll, Gtk::PACK_EXPAND_WIDGET);
vBox.pack_start(infoScroll, Gtk::PACK_SHRINK);
vBox.pack_start(bottomButtonHBox, Gtk::PACK_SHRINK);
add(vBox);
fileScroll.add(fileView);
fileScroll.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
infoScroll.add(infoTextView);
infoScroll.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
infoScroll.set_size_request(-1,80);
// TODO: make this autoscroll when new text appears
addFilesButton.signal_clicked().connect(sigc::bind<std::string>(sigc::mem_fun(*this,
&AlarmFsckFileChooser::on_add_button_clicked), "File"));
addFolderButton.signal_clicked().connect(sigc::bind<std::string>(sigc::mem_fun(*this,
&AlarmFsckFileChooser::on_add_button_clicked), "Folder"));
removeButton.signal_clicked().connect(sigc::mem_fun(*this,
&AlarmFsckFileChooser::on_remove_button_clicked));
cancelButton.signal_clicked().connect(sigc::mem_fun(*this,
&AlarmFsckFileChooser::on_cancel_button_clicked));
importButton.signal_clicked().connect(sigc::mem_fun(*this,
&AlarmFsckFileChooser::on_import_button_clicked));
doneButton.signal_clicked().connect(sigc::mem_fun(*this,
&AlarmFsckFileChooser::on_done_button_clicked));
// fileView,
filenameTreeStore = Gtk::TreeStore::create(fileViewColumnRecord);
fileView.set_model(filenameTreeStore);
// set up columns and their pretty printing
int nCols = fileView.append_column("Path", fileViewColumnRecord.nameCol);
Gtk::TreeViewColumn* column = fileView.get_column(nCols - 1);
column->set_cell_data_func(*(column->get_first_cell()),
sigc::mem_fun(*this, &AlarmFsckFileChooser::render_short_subpaths));
nCols = fileView.append_column("Size", fileViewColumnRecord.sizeCol);
(fileView.get_selection())->set_mode(Gtk::SELECTION_MULTIPLE);
column = fileView.get_column(nCols - 1);
column->set_cell_data_func(*(column->get_first_cell()),
sigc::mem_fun(*this, &AlarmFsckFileChooser::render_humanized_cumulative_byte_count));
// textBuffer
infoTextBuffer = infoTextView.get_buffer();
/* }}} UI initialization */
show_all_children();
infoScroll.hide();
}
void AlarmFsckFileChooser::render_humanized_cumulative_byte_count(Gtk::CellRenderer* render, const Gtk::TreeModel::iterator& iter){
if(Gtk::CellRendererText* textRend = dynamic_cast<Gtk::CellRendererText*>(render)){
if((*iter)[fileViewColumnRecord.isDir])
textRend->property_text() = "+ " + afCommon::humanize_byte_count(get_cumulative_size(iter));
else
textRend->property_text() = afCommon::humanize_byte_count((*iter)[fileViewColumnRecord.sizeCol]);
}
}
off_t AlarmFsckFileChooser::get_cumulative_size(const Gtk::TreeModel::iterator& iter){
if((*iter)[fileViewColumnRecord.hasCumSize])
return (*iter)[fileViewColumnRecord.sizeCol];
off_t cumSize = 0;
for(auto& child : iter->children())
cumSize += get_cumulative_size(child);
(*iter)[fileViewColumnRecord.hasCumSize] = true;
(*iter)[fileViewColumnRecord.sizeCol] = cumSize;
return cumSize;
}
void AlarmFsckFileChooser::render_short_subpaths(Gtk::CellRenderer* render, const Gtk::TreeModel::iterator& iter){
// only display the file/directory names for all but the top-level paths, which remain absolute
if(Gtk::CellRendererText* textRend = dynamic_cast<Gtk::CellRendererText*>(render)){
std::string filePath = (*iter)[fileViewColumnRecord.nameCol];
textRend->property_text() = (filenameTreeStore->iter_depth(iter) == 0) ?
filePath : filePath.substr(filePath.rfind(file_delim) + 1);
}
}
void AlarmFsckFileChooser::on_add_button_clicked(const std::string& typeStr)
{
Gtk::FileChooserAction fcAction = (typeStr == "File") ? Gtk::FILE_CHOOSER_ACTION_OPEN : Gtk::FILE_CHOOSER_ACTION_SELECT_FOLDER;
Gtk::FileChooserDialog dialog("Choose " + typeStr + "s to Add", fcAction);
dialog.set_transient_for(*this);
dialog.set_select_multiple(true);
dialog.add_button("_Cancel", Gtk::RESPONSE_CANCEL);
dialog.add_button("_Open", Gtk::RESPONSE_OK);
if(dialog.run() != Gtk::RESPONSE_OK) return;
// Now add selected files to our TreeView
populate_file_view(dialog.get_filenames());
}
void AlarmFsckFileChooser::populate_file_view(std::vector<std::string> fileList){
int valid = 0, invalid = 0;
for(auto it = fileList.begin(); it != fileList.end(); it++){
if(check_and_add_path(*it)) valid++;
else invalid++;
}
notify(std::to_string(valid) + " paths added, " + std::to_string(invalid) + " skipped.\n");
if(valid > 0) set_updated(true);
}
void AlarmFsckFileChooser::on_remove_button_clicked()
{
// this may only be called on top-level entries
std::vector<Gtk::TreeModel::Path> treePathList = (fileView.get_selection())->get_selected_rows();
Gtk::TreeModel::iterator iter;
std::string currFilePath;
int count = 0;
for(auto treePath = treePathList.begin(); treePath != treePathList.end(); treePath++){
iter = filenameTreeStore->get_iter(*treePath);
currFilePath = (*iter)[fileViewColumnRecord.nameCol];
if(filenameTreeStore->iter_depth(iter) != 0){
notify("Skipping " + currFilePath + ": only top-level entries can be erased\n");
continue;
}
// if the path has previously been removed
if(hashMap.count(currFilePath) == 0) continue;
// otherwise
erase_subtree(iter);
filenameTreeStore->erase(iter);
count++;
notify("Removed " + currFilePath +"\n");
}
notify("Erased " + std::to_string(count) + " top-level path" + ((count == 1)? "" : "s") + ".\n");
if(count > 0) set_updated(true);
}
void AlarmFsckFileChooser::on_import_button_clicked()
{
Gtk::FileChooserDialog dialog("Import from File", Gtk::FILE_CHOOSER_ACTION_OPEN);
dialog.set_transient_for(*this);
dialog.add_button("_Cancel", Gtk::RESPONSE_CANCEL);
dialog.add_button("_Open", Gtk::RESPONSE_OK);
if(dialog.run() != Gtk::RESPONSE_OK) return;
std::cout << "Importing file: " << dialog.get_filename() << std::endl;
try {
import_file(dialog.get_filename());
} catch (AfUserException& exc) {
notify(exc.what());
} catch (AfSystemException& exc) {
notify(exc.get_message() + ": " + exc.what() + ".\n");
}
}
void AlarmFsckFileChooser::on_done_button_clicked()
{
parentWindow.check_good_to_go();
hide();
}
void AlarmFsckFileChooser::notify(const std::string& message){
infoScroll.show();
infoTextBuffer->insert(infoTextBuffer->end(), message);
}
| 39.210256 | 131 | 0.721031 | [
"render",
"vector"
] |
986fd70c4b0d074feac8924c969764c7cfe2b846 | 2,056 | hpp | C++ | menoh/composite_backend/backend/generic/operator/mul.hpp | yuhonghong66/menoh | cdb33dfc8ba4c8dbb4c2bc70aae4f52433116402 | [
"MIT"
] | 284 | 2018-06-21T02:00:08.000Z | 2021-11-22T07:50:22.000Z | menoh/composite_backend/backend/generic/operator/mul.hpp | yuhonghong66/menoh | cdb33dfc8ba4c8dbb4c2bc70aae4f52433116402 | [
"MIT"
] | 174 | 2018-06-21T06:01:57.000Z | 2020-12-28T06:26:55.000Z | menoh/composite_backend/backend/generic/operator/mul.hpp | yuhonghong66/menoh | cdb33dfc8ba4c8dbb4c2bc70aae4f52433116402 | [
"MIT"
] | 33 | 2018-06-21T04:19:17.000Z | 2020-05-08T12:51:55.000Z | #ifndef MENOH_IMPL_COMPOSITE_BACKEND_BACKEND_GENERIC_OPERATOR_MUL_HPP
#define MENOH_IMPL_COMPOSITE_BACKEND_BACKEND_GENERIC_OPERATOR_MUL_HPP
#include <menoh/array.hpp>
#include <menoh/graph.hpp> // for dimension_mismatch error
#include <menoh/composite_backend/procedure.hpp>
namespace menoh_impl {
namespace composite_backend {
namespace generic_backend {
inline procedure make_mul(node const& node,
std::vector<array> const& input_list,
std::vector<array> const& output_list) {
assert(input_list.size() == 2);
assert(output_list.size() == 1);
for(auto const& input : input_list) {
if(input.dtype() != dtype_t::float_) {
throw invalid_dtype(
std::to_string(static_cast<int>(input.dtype())));
}
}
if(total_size(input_list.at(0)) !=
total_size(input_list.at(1))) {
throw dimension_mismatch(
node.op_type, node.output_name_list.front(),
"total size is invalid. broadcast is not supported yet",
std::to_string(total_size(input_list.at(0))),
std::to_string(total_size(input_list.at(1))));
}
auto procedure = [input_a = input_list.at(0),
input_b = input_list.at(1),
output = output_list.at(0)]() {
for(decltype(total_size(input_a)) i = 0;
i < total_size(input_a); ++i) {
fat(output, i) = fat(input_a, i) * fat(input_b, i);
}
};
return procedure;
}
} // namespace generic_backend
} // namespace composite_backend
} // namespace menoh_impl
#endif // MENOH_IMPL_COMPOSITE_BACKEND_BACKEND_GENERIC_OPERATOR_MUL_HPP
| 41.959184 | 78 | 0.524805 | [
"vector"
] |
987499d0aca97b7b57e4cbf8cdd0e1a3cb4cc378 | 3,114 | cpp | C++ | platforms/cuda/src/CudaPYKernelFactory.cpp | chemalot/openmm-py | 256dd76f6dc06ef0b99a11b8dca77588b1d9459e | [
"MIT",
"Unlicense"
] | 1 | 2019-01-25T16:32:19.000Z | 2019-01-25T16:32:19.000Z | platforms/cuda/src/CudaPYKernelFactory.cpp | chemalot/openmm-py | 256dd76f6dc06ef0b99a11b8dca77588b1d9459e | [
"MIT",
"Unlicense"
] | 1 | 2019-01-18T23:52:51.000Z | 2019-01-18T23:52:51.000Z | platforms/cuda/src/CudaPYKernelFactory.cpp | chemalot/openmm-py | 256dd76f6dc06ef0b99a11b8dca77588b1d9459e | [
"MIT",
"Unlicense"
] | null | null | null | /* -------------------------------------------------------------------------- *
* The MIT License
*
* SPDX short identifier: MIT
*
* Copyright 2019 Genentech Inc. South San Francisco
*
* 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.
* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- *
* Portions of this software were derived from code originally developed
* by Peter Eastman and copyrighted by Stanford University and the Authors
* -------------------------------------------------------------------------- */
#include <exception>
#include "CudaPYKernelFactory.h"
#include "CudaPYKernels.h"
#include "openmm/internal/windowsExport.h"
#include "openmm/internal/ContextImpl.h"
#include "openmm/OpenMMException.h"
#include <vector>
#include <iostream>
using namespace PYPlugin;
using namespace OpenMM;
using namespace std;
extern "C" OPENMM_EXPORT void registerPlatforms() {
}
extern "C" OPENMM_EXPORT void registerKernelFactories() {
try {
int argc = 0;
Platform& platform = Platform::getPlatformByName("CUDA");
CudaPYKernelFactory* factory = new CudaPYKernelFactory();
platform.registerKernelFactory(CalcPYForceKernel::Name(), factory);
}
catch (std::exception ex) {
cerr << "Exception in CudaPYKernelFactory.cpp\n";
}
}
extern "C" OPENMM_EXPORT void registerPYCudaKernelFactories() {
try {
Platform::getPlatformByName("CUDA");
}
catch (...) {
Platform::registerPlatform(new CudaPlatform());
}
registerKernelFactories();
}
KernelImpl* CudaPYKernelFactory::createKernelImpl(std::string name, const Platform& platform, ContextImpl& context) const {
CudaContext& cu = *static_cast<CudaPlatform::PlatformData*>(context.getPlatformData())->contexts[0];
if (name == CalcPYForceKernel::Name())
return new CudaCalcPYForceKernel(name, platform, cu);
throw OpenMMException((std::string("Tried to create kernel with illegal kernel name '")+name+"'").c_str());
}
| 39.923077 | 123 | 0.661529 | [
"vector"
] |
9875e1b4f12a13a38a821a30e1f296f187370ae6 | 10,817 | hxx | C++ | cpp/src/nvgraph/include/lanczos.hxx | rgsl888prabhu/cugraph | e030a2fe22ad308fba05d6146765a3c9aa865e5b | [
"Apache-2.0"
] | 16 | 2019-09-13T11:43:26.000Z | 2022-03-02T10:11:59.000Z | cpp/src/nvgraph/include/lanczos.hxx | rgsl888prabhu/cugraph | e030a2fe22ad308fba05d6146765a3c9aa865e5b | [
"Apache-2.0"
] | 5 | 2020-02-12T14:55:25.000Z | 2021-12-06T17:55:12.000Z | cpp/src/nvgraph/include/lanczos.hxx | rgsl888prabhu/cugraph | e030a2fe22ad308fba05d6146765a3c9aa865e5b | [
"Apache-2.0"
] | 6 | 2020-04-06T01:34:45.000Z | 2021-01-21T17:13:24.000Z | /*
* Copyright (c) 2019, NVIDIA CORPORATION.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include "nvgraph_error.hxx"
#include "matrix.hxx"
namespace nvgraph {
/// Compute smallest eigenvectors of symmetric matrix
/** Computes eigenvalues and eigenvectors that are least
* positive. If matrix is positive definite or positive
* semidefinite, the computed eigenvalues are smallest in
* magnitude.
*
* The largest eigenvalue is estimated by performing several
* Lanczos iterations. An implicitly restarted Lanczos method is
* then applied to A+s*I, where s is negative the largest
* eigenvalue.
*
* CNMEM must be initialized before calling this function.
*
* @param A Pointer to matrix object.
* @param nEigVecs Number of eigenvectors to compute.
* @param maxIter Maximum number of Lanczos steps. Does not include
* Lanczos steps used to estimate largest eigenvalue.
* @param restartIter Maximum size of Lanczos system before
* performing an implicit restart. Should be at least 4.
* @param tol Convergence tolerance. Lanczos iteration will
* terminate when the residual norm is less than tol*theta, where
* theta is an estimate for the smallest unwanted eigenvalue
* (i.e. the (nEigVecs+1)th smallest eigenvalue).
* @param reorthogonalize Whether to reorthogonalize Lanczos
* vectors.
* @param iter On exit, pointer to total number of Lanczos
* iterations performed. Does not include Lanczos steps used to
* estimate largest eigenvalue.
* @param eigVals_dev (Output, device memory, nEigVecs entries)
* Smallest eigenvalues of matrix.
* @param eigVecs_dev (Output, device memory, n*nEigVecs entries)
* Eigenvectors corresponding to smallest eigenvalues of
* matrix. Vectors are stored as columns of a column-major matrix
* with dimensions n x nEigVecs.
* @return NVGRAPH error flag.
*/
template <typename IndexType_, typename ValueType_>
NVGRAPH_ERROR computeSmallestEigenvectors(const Matrix<IndexType_,ValueType_> & A,
IndexType_ nEigVecs,
IndexType_ maxIter,
IndexType_ restartIter,
ValueType_ tol,
bool reorthogonalize,
IndexType_ & iter,
ValueType_ * __restrict__ eigVals_dev,
ValueType_ * __restrict__ eigVecs_dev);
/// Compute smallest eigenvectors of symmetric matrix
/** Computes eigenvalues and eigenvectors that are least
* positive. If matrix is positive definite or positive
* semidefinite, the computed eigenvalues are smallest in
* magnitude.
*
* The largest eigenvalue is estimated by performing several
* Lanczos iterations. An implicitly restarted Lanczos method is
* then applied to A+s*I, where s is negative the largest
* eigenvalue.
*
* @param A Pointer to matrix object.
* @param nEigVecs Number of eigenvectors to compute.
* @param maxIter Maximum number of Lanczos steps. Does not include
* Lanczos steps used to estimate largest eigenvalue.
* @param restartIter Maximum size of Lanczos system before
* performing an implicit restart. Should be at least 4.
* @param tol Convergence tolerance. Lanczos iteration will
* terminate when the residual norm is less than tol*theta, where
* theta is an estimate for the smallest unwanted eigenvalue
* (i.e. the (nEigVecs+1)th smallest eigenvalue).
* @param reorthogonalize Whether to reorthogonalize Lanczos
* vectors.
* @param iter On exit, pointer to final size of Lanczos system.
* @param totalIter On exit, pointer to total number of Lanczos
* iterations performed. Does not include Lanczos steps used to
* estimate largest eigenvalue.
* @param shift On exit, pointer to matrix shift.
* @param alpha_host (Output, host memory, restartIter entries)
* Diagonal entries of Lanczos system.
* @param beta_host (Output, host memory, restartIter entries)
* Off-diagonal entries of Lanczos system.
* @param lanczosVecs_dev (Output, device memory, n*(restartIter+1)
* entries) Lanczos vectors. Vectors are stored as columns of a
* column-major matrix with dimensions n x (restartIter+1).
* @param work_dev (Output, device memory,
* (n+restartIter)*restartIter entries) Workspace.
* @param eigVals_dev (Output, device memory, nEigVecs entries)
* Smallest eigenvalues of matrix.
* @param eigVecs_dev (Output, device memory, n*nEigVecs entries)
* Eigenvectors corresponding to smallest eigenvalues of
* matrix. Vectors are stored as columns of a column-major matrix
* with dimensions n x nEigVecs.
* @return NVGRAPH error flag.
*/
template <typename IndexType_, typename ValueType_>
NVGRAPH_ERROR computeSmallestEigenvectors(const Matrix<IndexType_,ValueType_> * A,
IndexType_ nEigVecs,
IndexType_ maxIter,
IndexType_ restartIter,
ValueType_ tol,
bool reorthogonalize,
IndexType_ * iter,
IndexType_ * totalIter,
ValueType_ * shift,
ValueType_ * __restrict__ alpha_host,
ValueType_ * __restrict__ beta_host,
ValueType_ * __restrict__ lanczosVecs_dev,
ValueType_ * __restrict__ work_dev,
ValueType_ * __restrict__ eigVals_dev,
ValueType_ * __restrict__ eigVecs_dev);
/// Compute largest eigenvectors of symmetric matrix
/** Computes eigenvalues and eigenvectors that are least
* positive. If matrix is positive definite or positive
* semidefinite, the computed eigenvalues are largest in
* magnitude.
*
* The largest eigenvalue is estimated by performing several
* Lanczos iterations. An implicitly restarted Lanczos method is
* then applied.
*
* @param A Matrix.
* @param nEigVecs Number of eigenvectors to compute.
* @param maxIter Maximum number of Lanczos steps.
* @param restartIter Maximum size of Lanczos system before
* performing an implicit restart. Should be at least 4.
* @param tol Convergence tolerance. Lanczos iteration will
* terminate when the residual norm is less than tol*theta, where
* theta is an estimate for the largest unwanted eigenvalue
* (i.e. the (nEigVecs+1)th largest eigenvalue).
* @param reorthogonalize Whether to reorthogonalize Lanczos
* vectors.
* @param effIter On exit, pointer to final size of Lanczos system.
* @param totalIter On exit, pointer to total number of Lanczos
* iterations performed.
* @param alpha_host (Output, host memory, restartIter entries)
* Diagonal entries of Lanczos system.
* @param beta_host (Output, host memory, restartIter entries)
* Off-diagonal entries of Lanczos system.
* @param lanczosVecs_dev (Output, device memory, n*(restartIter+1)
* entries) Lanczos vectors. Vectors are stored as columns of a
* column-major matrix with dimensions n x (restartIter+1).
* @param work_dev (Output, device memory,
* (n+restartIter)*restartIter entries) Workspace.
* @param eigVals_dev (Output, device memory, nEigVecs entries)
* Largest eigenvalues of matrix.
* @param eigVecs_dev (Output, device memory, n*nEigVecs entries)
* Eigenvectors corresponding to largest eigenvalues of
* matrix. Vectors are stored as columns of a column-major matrix
* with dimensions n x nEigVecs.
* @return NVGRAPH error flag.
*/
template <typename IndexType_, typename ValueType_>
NVGRAPH_ERROR computeLargestEigenvectors(const Matrix<IndexType_,ValueType_> * A,
IndexType_ nEigVecs,
IndexType_ maxIter,
IndexType_ restartIter,
ValueType_ tol,
bool reorthogonalize,
IndexType_ * effIter,
IndexType_ * totalIter,
ValueType_ * __restrict__ alpha_host,
ValueType_ * __restrict__ beta_host,
ValueType_ * __restrict__ lanczosVecs_dev,
ValueType_ * __restrict__ work_dev,
ValueType_ * __restrict__ eigVals_dev,
ValueType_ * __restrict__ eigVecs_dev);
/// Compute largest eigenvectors of symmetric matrix
/** Computes eigenvalues and eigenvectors that are least
* positive. If matrix is positive definite or positive
* semidefinite, the computed eigenvalues are largest in
* magnitude.
*
* The largest eigenvalue is estimated by performing several
* Lanczos iterations. An implicitly restarted Lanczos method is
* then applied to A+s*I, where s is negative the largest
* eigenvalue.
*
* CNMEM must be initialized before calling this function.
*
* @param A Matrix.
* @param nEigVecs Number of eigenvectors to compute.
* @param maxIter Maximum number of Lanczos steps. Does not include
* Lanczos steps used to estimate largest eigenvalue.
* @param restartIter Maximum size of Lanczos system before
* performing an implicit restart. Should be at least 4.
* @param tol Convergence tolerance. Lanczos iteration will
* terminate when the residual norm is less than tol*theta, where
* theta is an estimate for the largest unwanted eigenvalue
* (i.e. the (nEigVecs+1)th largest eigenvalue).
* @param reorthogonalize Whether to reorthogonalize Lanczos
* vectors.
* @param iter On exit, pointer to total number of Lanczos
* iterations performed. Does not include Lanczos steps used to
* estimate largest eigenvalue.
* @param eigVals_dev (Output, device memory, nEigVecs entries)
* Largest eigenvalues of matrix.
* @param eigVecs_dev (Output, device memory, n*nEigVecs entries)
* Eigenvectors corresponding to largest eigenvalues of
* matrix. Vectors are stored as columns of a column-major matrix
* with dimensions n x nEigVecs.
* @return NVGRAPH error flag.
*/
template <typename IndexType_, typename ValueType_>
NVGRAPH_ERROR computeLargestEigenvectors(const Matrix<IndexType_,ValueType_> & A,
IndexType_ nEigVecs,
IndexType_ maxIter,
IndexType_ restartIter,
ValueType_ tol,
bool reorthogonalize,
IndexType_ & iter,
ValueType_ * __restrict__ eigVals_dev,
ValueType_ * __restrict__ eigVecs_dev);
}
| 45.44958 | 84 | 0.710178 | [
"object"
] |
9878c571c66aae2b517eab40ffe8116da49e7830 | 27,239 | cpp | C++ | src/ttauri/text/text_shaper.cpp | RustWorks/ttauri | 4b093eb16465091d01d80159e23fd26e5d4e4c03 | [
"BSL-1.0"
] | null | null | null | src/ttauri/text/text_shaper.cpp | RustWorks/ttauri | 4b093eb16465091d01d80159e23fd26e5d4e4c03 | [
"BSL-1.0"
] | null | null | null | src/ttauri/text/text_shaper.cpp | RustWorks/ttauri | 4b093eb16465091d01d80159e23fd26e5d4e4c03 | [
"BSL-1.0"
] | null | null | null | // Copyright Take Vos 2021.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
#include "text_shaper.hpp"
#include "font_book.hpp"
#include "../unicode/unicode_line_break.hpp"
#include "../unicode/unicode_bidi.hpp"
#include "../unicode/unicode_word_break.hpp"
#include "../unicode/unicode_sentence_break.hpp"
#include "../log.hpp"
#include <numeric>
#include <ranges>
#include <algorithm>
#include <cmath>
namespace tt::inline v1 {
static void layout_lines_vertical_spacing(text_shaper::line_vector &lines, float line_spacing, float paragraph_spacing) noexcept
{
tt_axiom(not lines.empty());
auto prev = lines.begin();
prev->y = 0.0f;
for (auto it = prev + 1; it != lines.end(); ++it) {
ttlet height = prev->metrics.descender + std::max(prev->metrics.line_gap, it->metrics.line_gap) + it->metrics.ascender;
ttlet spacing = prev->last_category == unicode_general_category::Zp ? paragraph_spacing : line_spacing;
// Lines advance downward on the y-axis.
it->y = prev->y - spacing * height;
prev = it;
}
}
static void layout_lines_vertical_alignment(
text_shaper::line_vector &lines,
vertical_alignment alignment,
float base_line,
float min_y,
float max_y,
float sub_pixel_height) noexcept
{
tt_axiom(not lines.empty());
// Calculate the y-adjustment needed to position the base-line of the text to y=0
auto adjustment = [&]() {
if (alignment == vertical_alignment::top) {
return -lines.front().y;
} else if (alignment == vertical_alignment::bottom) {
return -lines.back().y;
} else {
ttlet mp_index = lines.size() / 2;
if (lines.size() % 2 == 1) {
return -lines[mp_index].y;
} else {
return -std::midpoint(lines[mp_index - 1].y, lines[mp_index].y);
}
}
}();
// Add the base-line to the adjustment.
adjustment += base_line;
// Clamp the adjustment between min_y and max_y.
// The text may not fit, prioritize to show the top lines.
if (lines.back().y + adjustment < min_y) {
adjustment = min_y - lines.back().y;
}
if (lines.front().y + adjustment > max_y) {
adjustment = max_y - lines.front().y;
}
// Reposition the lines, and round to sub-pixel boundary.
ttlet rcp_sub_pixel_height = 1.0f / sub_pixel_height;
for (auto &line : lines) {
line.y = std::round((line.y + adjustment) * rcp_sub_pixel_height) * sub_pixel_height;
}
}
/** Run the bidi-algorithm over the text and replace the columns of each line.
*
* @param[in,out] lines The lines to be modified
* @param[in,out] text The input text. non-const because modifications on the text is required.
* @param writing_direction The initial writing direction.
*/
static void
bidi_algorithm(text_shaper::line_vector &lines, text_shaper::char_vector &text, unicode_bidi_class writing_direction) noexcept
{
tt_axiom(not lines.empty());
// Create a list of all character indices.
auto char_its = std::vector<text_shaper::char_iterator>{};
// Make room for implicit line-separators.
char_its.reserve(text.size() + lines.size());
for (ttlet &line : lines) {
// Add all the characters of a line.
for (auto it = line.first; it != line.last; ++it) {
char_its.push_back(it);
}
if (not is_Zp_or_Zl(line.last_category)) {
// No explicit paragraph-separator or line-separator, at a virtual one.
char_its.push_back(text.end());
}
}
// Reorder the character indices based on the unicode bidi algorithm.
auto context = unicode_bidi_context{};
if (writing_direction == unicode_bidi_class::L) {
context.direction_mode = unicode_bidi_context::mode_type::auto_LTR;
} else if (writing_direction == unicode_bidi_class::R) {
context.direction_mode = unicode_bidi_context::mode_type::auto_RTL;
} else {
tt_no_default();
}
ttlet[char_its_last, paragraph_directions] = unicode_bidi(
char_its.begin(),
char_its.end(),
[&](text_shaper::char_const_iterator it) -> decltype(auto) {
if (it != text.end()) {
return *it->description;
} else {
return unicode_description::find(unicode_LS);
}
},
[&](text_shaper::char_iterator it, char32_t code_point) {
tt_axiom(it != text.end());
it->replace_glyph(code_point);
},
[&](text_shaper::char_iterator it, unicode_bidi_class direction) {
if (it != text.end()) {
it->direction = direction;
}
},
context);
// The unicode bidi algorithm may have deleted a few characters.
char_its.erase(char_its_last, char_its.cend());
// Add the paragraph direction for each line.
auto par_it = paragraph_directions.cbegin();
for (auto &line : lines) {
tt_axiom(par_it != paragraph_directions.cend());
line.paragraph_direction = *par_it;
if (line.last_category == unicode_general_category::Zp) {
par_it++;
}
}
tt_axiom(par_it <= paragraph_directions.cend());
// Add the character indices for each line in display order.
auto line_it = lines.begin();
line_it->columns.clear();
auto column_nr = 0_uz;
for (ttlet char_it : char_its) {
if (char_it == text.end()) {
// Ignore the virtual line separators.
continue;
} else if (char_it >= line_it->last) {
// Skip to the next line.
tt_axiom(line_it->columns.size() <= narrow_cast<size_t>(std::distance(line_it->first, line_it->last)));
++line_it;
line_it->columns.clear();
column_nr = 0_uz;
}
tt_axiom(line_it != lines.end());
tt_axiom(char_it >= line_it->first);
tt_axiom(char_it < line_it->last);
line_it->columns.push_back(char_it);
// Assign line_nr and column_nr, for quick back referencing.
char_it->line_nr = line_it->line_nr;
char_it->column_nr = column_nr++;
}
// All of the characters in the text must be positioned.
for (auto &c : text) {
tt_axiom(c.line_nr != std::numeric_limits<size_t>::max() and c.column_nr != std::numeric_limits<size_t>::max());
}
}
[[nodiscard]] text_shaper::text_shaper(
tt::font_book &font_book,
gstring const &text,
text_style const &style,
float dpi_scale,
unicode_script script) noexcept :
_font_book(&font_book), _dpi_scale(dpi_scale), _script(script)
{
ttlet &font = font_book.find_font(style.family_id, style.variant);
_initial_line_metrics = (style.size * dpi_scale) * font.metrics;
_text.reserve(text.size());
for (ttlet &c : text) {
ttlet clean_c = c == '\n' ? grapheme{unicode_PS} : c;
auto &tmp = _text.emplace_back(clean_c, style, dpi_scale);
tmp.initialize_glyph(font_book, font);
}
_line_break_opportunities = unicode_line_break(_text.begin(), _text.end(), [](ttlet &c) -> decltype(auto) {
tt_axiom(c.description != nullptr);
return *c.description;
});
_line_break_widths.reserve(text.size());
for (ttlet &c : _text) {
_line_break_widths.push_back(is_visible(c.description->general_category()) ? c.width : -c.width);
}
_word_break_opportunities = unicode_word_break(_text.begin(), _text.end(), [](ttlet &c) -> decltype(auto) {
tt_axiom(c.description != nullptr);
return *c.description;
});
_sentence_break_opportunities = unicode_sentence_break(_text.begin(), _text.end(), [](ttlet &c) -> decltype(auto) {
tt_axiom(c.description != nullptr);
return *c.description;
});
resolve_script();
}
[[nodiscard]] text_shaper::text_shaper(
font_book &font_book,
std::string_view text,
text_style const &style,
float dpi_scale,
unicode_script script) noexcept :
text_shaper(font_book, to_gstring(text), style, dpi_scale, script)
{
}
[[nodiscard]] text_shaper::line_vector text_shaper::make_lines(
aarectangle rectangle,
float base_line,
extent2 sub_pixel_size,
tt::vertical_alignment vertical_alignment,
unicode_bidi_class writing_direction,
float line_spacing,
float paragraph_spacing) noexcept
{
ttlet line_sizes = unicode_line_break(_line_break_opportunities, _line_break_widths, rectangle.width());
auto r = text_shaper::line_vector{};
r.reserve(line_sizes.size());
auto char_it = _text.begin();
auto width_it = _line_break_widths.begin();
auto line_nr = 0_uz;
for (ttlet line_size : line_sizes) {
tt_axiom(line_size > 0);
ttlet char_eol = char_it + line_size;
ttlet width_eol = width_it + line_size;
ttlet line_width = unicode_line_break_width(width_it, width_eol);
r.emplace_back(line_nr++, _text.begin(), char_it, char_eol, line_width, _initial_line_metrics);
char_it = char_eol;
width_it = width_eol;
}
if (r.empty() or is_Zp_or_Zl(r.back().last_category)) {
r.emplace_back(line_nr++, _text.begin(), _text.end(), _text.end(), 0.0f, _initial_line_metrics);
r.back().paragraph_direction = writing_direction;
}
layout_lines_vertical_spacing(r, line_spacing, paragraph_spacing);
layout_lines_vertical_alignment(
r, vertical_alignment, base_line, rectangle.bottom(), rectangle.top(), sub_pixel_size.height());
return r;
}
void text_shaper::position_glyphs(
aarectangle rectangle,
extent2 sub_pixel_size,
tt::horizontal_alignment horizontal_alignment,
unicode_bidi_class writing_direction) noexcept
{
tt_axiom(not _lines.empty());
// The bidi algorithm will reorder the characters on each line, and mirror the brackets in the text when needed.
bidi_algorithm(_lines, _text, writing_direction);
for (auto &line : _lines) {
// Position the glyphs on each line. Possibly morph glyphs to handle ligatures and calculate the bounding rectangles.
line.layout(horizontal_alignment, rectangle.left(), rectangle.right(), sub_pixel_size.width());
}
}
void text_shaper::resolve_script() noexcept
{
// Find the first script in the text if no script is found use the text_shaper's default script.
auto first_script = _script;
for (auto &c : _text) {
ttlet script = c.description->script();
if (script != unicode_script::Common or script == unicode_script::Unknown or script == unicode_script::Inherited) {
first_script = script;
break;
}
}
// Backward pass: fix start of words and open-brackets.
// After this pass unknown-script is no longer in the text.
// Close brackets will not be fixed, those will be fixed in the last forward pass.
auto word_script = unicode_script::Common;
auto previous_script = first_script;
for (auto i = std::ssize(_text) - 1; i >= 0; --i) {
auto &c = _text[i];
if (_word_break_opportunities[i + 1] != unicode_break_opportunity::no) {
word_script = unicode_script::Common;
}
c.script = c.description->script();
if (c.script == unicode_script::Common or c.script == unicode_script::Unknown) {
ttlet bracket_type = c.description->bidi_bracket_type();
// clang-format off
c.script =
bracket_type == unicode_bidi_bracket_type::o ? previous_script :
bracket_type == unicode_bidi_bracket_type::c ? unicode_script::Common :
word_script;
// clang-format on
} else if (c.script != unicode_script::Inherited) {
previous_script = word_script = c.script;
}
}
// Forward pass: fix all common and inherited with previous or first script.
previous_script = first_script;
for (auto i = 0_uz; i != _text.size(); ++i) {
auto &c = _text[i];
if (c.script == unicode_script::Common or c.script == unicode_script::Inherited) {
c.script = previous_script;
} else {
previous_script = c.script;
}
}
}
[[nodiscard]] std::pair<aarectangle, float> text_shaper::bounding_rectangle(
float maximum_line_width,
tt::vertical_alignment vertical_alignment,
float line_spacing,
float paragraph_spacing) noexcept
{
ttlet rectangle = aarectangle{
point2{0.0f, std::numeric_limits<float>::lowest()}, point2{maximum_line_width, std::numeric_limits<float>::max()}};
constexpr auto base_line = 0.0f;
constexpr auto sub_pixel_size = extent2{1.0f, 1.0f};
ttlet lines = make_lines(
rectangle, base_line, sub_pixel_size, vertical_alignment, unicode_bidi_class::L, line_spacing, paragraph_spacing);
tt_axiom(not lines.empty());
auto max_width = 0.0f;
for (auto &line : lines) {
inplace_max(max_width, line.width);
}
// clang-format off
ttlet cap_height =
vertical_alignment == vertical_alignment::bottom ? lines.back().metrics.cap_height :
vertical_alignment == vertical_alignment::top ? lines.front().metrics.cap_height :
lines[lines.size() / 2].metrics.cap_height;
// clang-format on
ttlet max_y = lines.front().y + std::ceil(lines.front().metrics.ascender);
ttlet min_y = lines.back().y - std::ceil(lines.back().metrics.descender);
return {aarectangle{point2{0.0f, min_y}, point2{std::ceil(max_width), max_y}}, cap_height};
}
[[nodiscard]] void text_shaper::layout(
aarectangle rectangle,
float base_line,
extent2 sub_pixel_size,
unicode_bidi_class writing_direction,
tt::alignment alignment,
float line_spacing,
float paragraph_spacing) noexcept
{
_rectangle = rectangle;
_lines = make_lines(
rectangle, base_line, sub_pixel_size, alignment.vertical(), writing_direction, line_spacing, paragraph_spacing);
tt_axiom(not _lines.empty());
position_glyphs(rectangle, sub_pixel_size, alignment.text(), writing_direction);
}
[[nodiscard]] text_shaper::char_const_iterator text_shaper::get_it(size_t index) const noexcept
{
if (static_cast<ptrdiff_t>(index) < 0) {
return begin();
} else if (index >= size()) {
return end();
}
return begin() + index;
}
[[nodiscard]] text_shaper::char_const_iterator text_shaper::get_it(size_t column_nr, size_t line_nr) const noexcept
{
tt_axiom(not _lines.empty());
if (static_cast<ptrdiff_t>(line_nr) < 0) {
return begin();
} else if (line_nr >= _lines.size()) {
return end();
}
ttlet left_of_line = static_cast<ptrdiff_t>(column_nr) < 0;
ttlet right_of_line = column_nr >= _lines[line_nr].size();
if (left_of_line or right_of_line) {
ttlet ltr = _lines[line_nr].paragraph_direction == unicode_bidi_class::L;
ttlet go_up = left_of_line == ltr;
if (go_up) {
// Go to line above.
if (static_cast<ptrdiff_t>(--line_nr) < 0) {
return begin();
} else {
// Go to end of line above.
return _lines[line_nr].paragraph_direction == unicode_bidi_class::L ? _lines[line_nr].back() :
_lines[line_nr].front();
}
} else {
// Go to the line below.
if (++line_nr >= _lines.size()) {
return end();
} else {
// Go to begin of line below.
return _lines[line_nr].paragraph_direction == unicode_bidi_class::L ? _lines[line_nr].front() :
_lines[line_nr].back();
}
}
}
return _lines[line_nr][column_nr];
}
[[nodiscard]] std::pair<size_t, size_t> text_shaper::get_column_line(text_shaper::char_const_iterator it) const noexcept
{
if (it != end()) {
return {it->column_nr, it->line_nr};
} else {
tt_axiom(not _lines.empty());
return {_lines.size() - 1, _lines.back().size()};
}
}
[[nodiscard]] size_t text_shaper::get_index(text_shaper::char_const_iterator it) const noexcept
{
return narrow<size_t>(std::distance(begin(), it));
}
[[nodiscard]] text_cursor text_shaper::get_begin_cursor() const noexcept
{
return {};
}
[[nodiscard]] text_cursor text_shaper::get_end_cursor() const noexcept
{
return {size() - 1, true, size()};
}
[[nodiscard]] text_cursor text_shaper::get_before_cursor(size_t index) const noexcept
{
return {index, false, size()};
}
[[nodiscard]] text_cursor text_shaper::get_after_cursor(size_t index) const noexcept
{
return {index, true, size()};
}
[[nodiscard]] text_cursor text_shaper::get_left_cursor(text_shaper::char_const_iterator it) const noexcept
{
if (it != end()) {
if (it->direction == unicode_bidi_class::L) {
return get_before_cursor(it);
} else {
return get_after_cursor(it);
}
} else {
return get_end_cursor();
}
}
[[nodiscard]] text_cursor text_shaper::get_right_cursor(text_shaper::char_const_iterator it) const noexcept
{
if (it != end()) {
if (it->direction == unicode_bidi_class::L) {
return get_after_cursor(it);
} else {
return get_before_cursor(it);
}
} else {
return get_end_cursor();
}
}
[[nodiscard]] bool text_shaper::is_on_left(text_cursor cursor) const noexcept
{
ttlet it = get_it(cursor);
if (it != end()) {
return (it->direction == unicode_bidi_class::L) == cursor.before();
} else {
tt_axiom(begin() == end());
return true;
}
}
[[nodiscard]] bool text_shaper::is_on_right(text_cursor cursor) const noexcept
{
ttlet it = get_it(cursor);
if (it != end()) {
return (it->direction == unicode_bidi_class::L) == cursor.after();
} else {
tt_axiom(begin() == end());
return true;
}
}
[[nodiscard]] text_cursor text_shaper::get_nearest_cursor(point2 position) const noexcept
{
if (_text.empty()) {
return {};
}
ttlet line_it = std::ranges::min_element(_lines, std::ranges::less{}, [position](ttlet &line) {
return std::abs(line.y - position.y());
});
if (line_it != _lines.end()) {
ttlet[char_it, after] = line_it->get_nearest(position);
return {narrow<size_t>(std::distance(_text.begin(), char_it)), after, size()};
} else {
return {};
}
}
[[nodiscard]] text_shaper::char_const_iterator text_shaper::move_left_char(text_shaper::char_const_iterator it) const noexcept
{
ttlet[column_nr, line_nr] = get_column_line(it);
return get_it(column_nr - 1, line_nr);
}
[[nodiscard]] text_shaper::char_const_iterator text_shaper::move_right_char(text_shaper::char_const_iterator it) const noexcept
{
ttlet[column_nr, line_nr] = get_column_line(it);
return get_it(column_nr + 1, line_nr);
}
[[nodiscard]] text_cursor text_shaper::move_left_char(text_cursor cursor, bool overwrite_mode) const noexcept
{
auto it = get_it(cursor);
if (overwrite_mode) {
it = move_left_char(it);
return get_before_cursor(it);
} else {
if (is_on_left(cursor)) {
// If the cursor is on the left side of a character, then move one character left.
it = move_left_char(it);
}
return get_left_cursor(it);
}
}
[[nodiscard]] text_cursor text_shaper::move_right_char(text_cursor cursor, bool overwrite_mode) const noexcept
{
auto it = get_it(cursor);
if (overwrite_mode) {
it = move_right_char(it);
return get_before_cursor(it);
} else {
if (is_on_right(cursor)) {
// If the cursor is on the left side of a character, then move one character left.
it = move_right_char(it);
}
return get_right_cursor(it);
}
}
[[nodiscard]] text_cursor text_shaper::move_down_char(text_cursor cursor, float &x) const noexcept
{
if (_text.empty()) {
return {};
}
auto [column_nr, line_nr] = get_column_line(cursor);
if (++line_nr == _lines.size()) {
return get_end_cursor();
}
if (std::isnan(x)) {
ttlet char_it = get_it(cursor);
tt_axiom(char_it != _text.end());
x = is_on_left(cursor) ? char_it->rectangle.left() : char_it->rectangle.right();
}
ttlet[new_char_it, after] = _lines[line_nr].get_nearest(point2{x, 0.0f});
return get_before_cursor(new_char_it);
}
[[nodiscard]] text_cursor text_shaper::move_up_char(text_cursor cursor, float &x) const noexcept
{
if (_text.empty()) {
return {};
}
auto [column_nr, line_nr] = get_column_line(cursor);
if (line_nr-- == 0) {
return {};
}
if (std::isnan(x)) {
auto char_it = get_it(cursor);
tt_axiom(char_it < _text.end());
x = is_on_left(cursor) ? char_it->rectangle.left() : char_it->rectangle.right();
}
ttlet[new_char_it, after] = _lines[line_nr].get_nearest(point2{x, 0.0f});
return get_before_cursor(new_char_it);
}
[[nodiscard]] text_cursor text_shaper::move_left_word(text_cursor cursor, bool overwrite_mode) const noexcept
{
cursor = move_left_char(cursor, overwrite_mode).before_neighbor(size());
auto it = get_it(cursor);
while (it != end()) {
if (*(it->description) != unicode_general_category::Zs and
_word_break_opportunities[get_index(it)] != unicode_break_opportunity::no) {
return get_before_cursor(it);
}
it = move_left_char(it);
}
return get_end_cursor();
}
[[nodiscard]] text_cursor text_shaper::move_right_word(text_cursor cursor, bool overwrite_mode) const noexcept
{
cursor = move_right_char(cursor, overwrite_mode).before_neighbor(size());
auto it = get_it(cursor);
while (it != end()) {
if (*(it->description) != unicode_general_category::Zs and
_word_break_opportunities[get_index(it)] != unicode_break_opportunity::no) {
return get_before_cursor(it);
}
it = move_right_char(it);
}
return get_end_cursor();
}
[[nodiscard]] text_cursor text_shaper::move_begin_line(text_cursor cursor) const noexcept
{
ttlet[column_nr, line_nr] = get_column_line(cursor);
ttlet &line = _lines[line_nr];
return get_before_cursor(line.first);
}
[[nodiscard]] text_cursor text_shaper::move_end_line(text_cursor cursor) const noexcept
{
ttlet[column_nr, line_nr] = get_column_line(cursor);
ttlet &line = _lines[line_nr];
auto it = line.last;
while (it != line.first) {
--it;
if (not it->is_trailing_white_space) {
break;
}
}
return get_after_cursor(it);
}
[[nodiscard]] text_cursor text_shaper::move_begin_sentence(text_cursor cursor) const noexcept
{
if (cursor.after()) {
cursor = {cursor.index(), false, size()};
} else if (cursor.index() != 0) {
cursor = {cursor.index() - 1, false, size()};
}
ttlet[first, last] = select_sentence(cursor);
return first.before_neighbor(size());
}
[[nodiscard]] text_cursor text_shaper::move_end_sentence(text_cursor cursor) const noexcept
{
if (cursor.before()) {
cursor = {cursor.index(), true, size()};
} else if (cursor.index() != _text.size() - 1) {
cursor = {cursor.index() + 1, true, size()};
}
ttlet[first, last] = select_sentence(cursor);
return last.before_neighbor(size());
}
[[nodiscard]] text_cursor text_shaper::move_begin_paragraph(text_cursor cursor) const noexcept
{
if (cursor.after()) {
cursor = {cursor.index(), false, size()};
} else if (cursor.index() != 0) {
cursor = {cursor.index() - 1, false, size()};
}
ttlet[first, last] = select_paragraph(cursor);
return first.before_neighbor(size());
}
[[nodiscard]] text_cursor text_shaper::move_end_paragraph(text_cursor cursor) const noexcept
{
if (cursor.before()) {
cursor = {cursor.index(), true, size()};
} else if (cursor.index() != _text.size() - 1) {
cursor = {cursor.index() + 1, true, size()};
}
ttlet[first, last] = select_paragraph(cursor);
return last.before_neighbor(size());
}
[[nodiscard]] text_cursor text_shaper::move_begin_document(text_cursor cursor) const noexcept
{
return {};
}
[[nodiscard]] text_cursor text_shaper::move_end_document(text_cursor cursor) const noexcept
{
if (_text.empty()) {
return {};
}
return get_end_cursor();
}
[[nodiscard]] std::pair<text_cursor, text_cursor>
text_shaper::get_selection_from_break(text_cursor cursor, unicode_break_vector const &break_opportunities) const noexcept
{
if (_text.empty()) {
return {{}, {}};
}
// In the algorithm below we search before and after the character that the cursor is at.
// We do not use the before/after differentiation.
ttlet first_index = [&]() {
auto i = cursor.index();
while (break_opportunities[i] == unicode_break_opportunity::no) {
--i;
}
return i;
}();
ttlet last_index = [&]() {
auto i = cursor.index();
while (break_opportunities[i + 1] == unicode_break_opportunity::no) {
++i;
}
return i;
}();
return {get_before_cursor(first_index), get_after_cursor(last_index)};
}
[[nodiscard]] std::pair<text_cursor, text_cursor> text_shaper::select_char(text_cursor cursor) const noexcept
{
ttlet index = cursor.index();
return {get_before_cursor(index), get_after_cursor(index)};
}
[[nodiscard]] std::pair<text_cursor, text_cursor> text_shaper::select_word(text_cursor cursor) const noexcept
{
return get_selection_from_break(cursor, _word_break_opportunities);
}
[[nodiscard]] std::pair<text_cursor, text_cursor> text_shaper::select_sentence(text_cursor cursor) const noexcept
{
return get_selection_from_break(cursor, _sentence_break_opportunities);
}
[[nodiscard]] std::pair<text_cursor, text_cursor> text_shaper::select_paragraph(text_cursor cursor) const noexcept
{
ttlet first_index = [&]() {
auto i = cursor.index();
while (i > 0) {
if (_text[i - 1].description->general_category() == unicode_general_category::Zp) {
return i;
}
--i;
}
return i;
}();
ttlet last_index = [&]() {
auto i = cursor.index();
while (i < _text.size()) {
if (_text[i].description->general_category() == unicode_general_category::Zp) {
return i;
}
++i;
}
return i;
}();
return {get_before_cursor(first_index), get_after_cursor(last_index)};
}
[[nodiscard]] std::pair<text_cursor, text_cursor> text_shaper::select_document(text_cursor cursor) const noexcept
{
if (_text.empty()) {
return {{}, {}};
}
return {{}, get_end_cursor()};
}
} // namespace tt::inline v1
| 33.01697 | 128 | 0.637028 | [
"vector"
] |
988dcf6eaa2185d21c2b55eca4e7c81b3ff5b426 | 1,209 | cpp | C++ | jeff/day-08/part-1.cpp | jeffphi/advent-of-code-2018 | 8e54bd23ebfe42fcbede315f0ab85db903551532 | [
"MIT"
] | 1 | 2018-12-23T01:40:07.000Z | 2018-12-23T01:40:07.000Z | jeff/day-08/part-1.cpp | jeffphi/advent-of-code-2018 | 8e54bd23ebfe42fcbede315f0ab85db903551532 | [
"MIT"
] | null | null | null | jeff/day-08/part-1.cpp | jeffphi/advent-of-code-2018 | 8e54bd23ebfe42fcbede315f0ab85db903551532 | [
"MIT"
] | null | null | null | #include <iostream>
#include <vector>
#include <string>
#include "jefflib.h"
#include <boost/tokenizer.hpp>
#include <map>
#include <set>
using namespace std;
using namespace boost;
void processNode(vector<int>& data, int& index, int& checksum);
int main()
{
vector<string> vect;
if(GetStringInput(vect)){
cout << "Got data!" << endl;
cout << endl;
}
else {
cout << "Failed to read input :( " << endl;
return -1;
}
char_separator<char> sep(" ");
tokenizer< char_separator<char> > tokens(vect[0], sep);
vector<string> v_temp(tokens.begin(), tokens.end());
vector<int> data;
for(auto s : v_temp){
data.push_back(stoi(s));
}
cout << "Data size: " << data.size() << endl;
int checksum = 0;
int index = 0;
processNode(data, index, checksum);
cout << "Checksum: " << checksum << endl;
}
void processNode(vector<int>& data, int& index, int& checksum){
int numChildren = data[index];
int numMeta = data[++index];
for(int i = 0; i < numChildren; i++){
processNode(data, ++index, checksum);
}
for(int i = 0; i < numMeta; i++){
checksum += data[++index];
}
}
| 21.210526 | 63 | 0.578164 | [
"vector"
] |
9891b0a4cdf9f3ad13f60810f2d4ca72adf92997 | 16,035 | cc | C++ | physicalrobots/player/server/drivers/position/lasersafe/lasersafe.cc | parasol-ppl/PPL_utils | 92728bb89692fda1705a0dee436592d97922a6cb | [
"BSD-3-Clause"
] | null | null | null | physicalrobots/player/server/drivers/position/lasersafe/lasersafe.cc | parasol-ppl/PPL_utils | 92728bb89692fda1705a0dee436592d97922a6cb | [
"BSD-3-Clause"
] | null | null | null | physicalrobots/player/server/drivers/position/lasersafe/lasersafe.cc | parasol-ppl/PPL_utils | 92728bb89692fda1705a0dee436592d97922a6cb | [
"BSD-3-Clause"
] | null | null | null | /*
* Player - One Hell of a Robot Server
* Copyright (C) 2006
* Toby Collett
*
*
* This library 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 2.1 of the License, or (at your option) any later version.
*
* This library 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 this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/** @ingroup drivers */
/** @{ */
/** @defgroup driver_lasersafe lasersafe
* @brief Bumper monitor
This is a low level safety 'driver' that temporarily disables
velocity commands if a laser range is detected within a specified
safe distance. It sits on top of @ref interface_laser and
@ref interface_position2d devices.
The general concept of this device is to not do much, but to provide
a last line of defense in the case that higher level drivers or client
software fails in its object avoidance.
When the laser scanner detects an obstacle within the safe distance, it
will prevent the robot from moving either forwards or backwards
(depending on which way the laser scanner is facing). For example, if
the laser scanner is facing forwards and it detects an obstacle, the
robot will only be able to back away, not continue forwards into the
obstacle.
@par Compile-time dependencies
- none
@par Provides
- @ref interface_position2d
@par Requires
- @ref interface_position2d : the underlying robot to be controlled
- @ref interface_laser : the laser to read from
@par Configuration requests
- PLAYER_POSITION2D_REQ_MOTOR_POWER : if motor is switched on then we
reset the 'safe state' so robot can move with a bump panel active
- all other requests are just passed on to the underlying @ref
interface_position2d device
@par Configuration file options
- safedistance
Default: 0.4m
The distance at which to stop
- step
Default: 5
The number of range readings to skip over. For example, the default
value will check readings 0, 5, 10, and so on. A value of 10 will
check readings 0, 10, 20, 30, ...
- history
Default: 3
The driver will use a moving average of range readings to help
overcome noise issues. This specifies the number of readings to
consider in total (so a value of 3 gives the current plus the two
previous readings).
If set to 1, only the most recent scan data will be used.
- forward
Default: 1
Indicates if the laser scanner is pointing forwards (1) or backwards (0).
- boxmode
Default: 1
If 1, the driver uses a box model for the safety area instead of a radius
distance from the laser scanner. This can allow you to, for example, ensure
that the robot can pass through narrow passages without driving into an
object ahead. Set to 0 to use the radius mode.
- boxwidth
Default: -1m
The width of the box. If less than zero, the position2d device will be
queried for the width of the robot and that will be used as the box width.
- boxsafety
default: 0.1
A safety margin to use if getting the width of the robot for box mode. Won't
be used if specifying the width of the box manually in the config file. The
default of 0.1 is a 10% safety margin, 0.25 would be 25%, and so on.
TODO: Make driver more advanced so that it can find the laser's pose and
allow movement in the opposite direction to the way the laser is pointing.
@par Example
@verbatim
driver
(
name "lasersafe"
provides ["position2d:0"]
requires ["position2d:1" "laser:0"]
safedistance 0.3
step 10
history 1
)
@endverbatim
@author Toby Collett, Geoffrey Biggs
*/
/** @} */
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <math.h>
#include <libplayercore/playercore.h>
class LaserSafe : public Driver
{
public:
// Constructor
LaserSafe (ConfigFile* cf, int section);
// Destructor
virtual ~LaserSafe () {};
// Setup/shutdown routines.
virtual int Setup ();
virtual int Shutdown ();
// Underlying devices
int SetupPosition ();
int ShutdownPosition ();
int SetupLaser ();
int ShutdownLaser ();
// Message Handler
int ProcessMessage (QueuePointer & resp_queue, player_msghdr * hdr, void * data);
private:
bool ScanInRange (double scanDistance, double scanAngle);
// state info
bool Blocked;
player_laser_data_t CurrentState;
player_laser_data_t *history;
// player_laser_data_t SafeState;
// Position device info
Device *position;
player_devaddr_t position_id;
int speed,turnrate;
double position_time;
bool position_subscribed;
// Laser device info
Device *laser;
player_devaddr_t laser_id;
double laser_time;
bool laser_subscribed;
// State info
double safeDistance;
unsigned int step;
unsigned int historyLength;
unsigned int currentHistSlot;
bool front;
bool boxMode;
double boxWidth;
double boxSafety;
bool needPoseInfo, gotPoseInfo;
};
// Initialization function
Driver* LaserSafe_Init (ConfigFile* cf, int section)
{
return ((Driver*) (new LaserSafe (cf, section)));
}
// a driver registration function
void lasersafe_Register(DriverTable* table)
{
table->AddDriver ("lasersafe", LaserSafe_Init);
return;
}
////////////////////////////////////////////////////////////////////////////////
// Set up the device (called by server thread).
int LaserSafe::Setup ()
{
// Initialise the underlying devices.
if (SetupPosition () != 0)
{
PLAYER_ERROR2 ("Laser safe failed to connect to undelying position2d device %d:%d\n", position_id.interf, position_id.index);
return -1;
}
if (SetupLaser () != 0)
{
PLAYER_ERROR2 ("Laser safe failed to connect to undelying laser device %d:%d\n", laser_id.interf, laser_id.index);
return -1;
}
Blocked = true;
// Create enough laser history
if (historyLength > 1)
{
if (!(history = new player_laser_data_t[historyLength - 1]))
{
PLAYER_WARN1 ("Laser safe failed to create history buffer for history length %d, falling back to no history\n", historyLength);
historyLength = 1;
history = NULL;
}
else
{
memset (history, 0, sizeof (player_laser_data_t) * (historyLength - 1));
}
currentHistSlot = 0;
}
// Send a request for the robot's width from the position driver if need it
if (needPoseInfo)
{
position->PutMsg (InQueue, PLAYER_MSGTYPE_REQ, PLAYER_POSITION2D_REQ_GET_GEOM, NULL, 0, NULL);
}
return 0;
}
////////////////////////////////////////////////////////////////////////////////
// Shutdown the device (called by server thread).
int LaserSafe::Shutdown ()
{
// Stop the laser
ShutdownPosition ();
// Stop the odom device.
ShutdownLaser ();
// Delete the history (if present)
if (history)
{
delete[] history;
history = NULL;
}
gotPoseInfo = false;
return 0;
}
////////////////////////////////////////////////////////////////////////////////
// Check if a laser scan distance is within warning distance
bool LaserSafe::ScanInRange (double scanDistance, double scanAngle)
{
if (boxMode)
{
double x, y;
x = scanDistance * cos (scanAngle);
y = scanDistance * sin (scanAngle);
if (x < safeDistance && fabs (y) < boxWidth) // Box is centered on laser
{
return true;
}
return false;
}
else
{
if (scanDistance < safeDistance)
return true;
return false;
}
}
////////////////////////////////////////////////////////////////////////////////
// Process an incoming message
int LaserSafe::ProcessMessage (QueuePointer & resp_queue, player_msghdr * hdr, void * data)
{
assert(hdr);
if (hdr->type==PLAYER_MSGTYPE_SYNCH)
{
return 0;
}
if(Message::MatchMessage (hdr, PLAYER_MSGTYPE_DATA, PLAYER_LASER_DATA_SCAN, laser_id))
{
// we got laser data, we need to deal with this
double time = hdr->timestamp;
bool hit = false;
// Dont do anything if this is old data.
if (time - laser_time < 0.001)
return 0;
laser_time = time;
CurrentState = *reinterpret_cast<player_laser_data *> (data);
if (history)
{
double accumulated = 0.0f;
double scanAngle = CurrentState.min_angle;
unsigned int ii = 0;
for (ii = 0; ii < CurrentState.ranges_count; ii += step)
{
accumulated = 0.0f;
for (unsigned int jj = 0; jj < historyLength - 1; jj++)
{
accumulated += history[jj].ranges[ii];
}
accumulated += CurrentState.ranges[ii];
if (ScanInRange (accumulated / static_cast<double> (historyLength), scanAngle))
{
hit = true;
break;
}
// The history buffer is circular, so the current data needs to go into the correct index
history[currentHistSlot].ranges[ii] = CurrentState.ranges[ii];
scanAngle += (CurrentState.resolution * step);
}
// Copy any remaining history after encountering a hit
for (; ii < CurrentState.ranges_count; ii += step)
history[currentHistSlot].ranges[ii] = CurrentState.ranges[ii];
// Increment the history slot counter and wrap it
currentHistSlot = (currentHistSlot + 1) % (historyLength - 1);
}
else
{
double scanAngle = CurrentState.min_angle;
// If no history then just check the current data
for (unsigned int ii = 0; ii < CurrentState.ranges_count; ii += step)
{
if (ScanInRange (CurrentState.ranges[ii], scanAngle))
{
hit = true;
break;
}
scanAngle += (CurrentState.resolution * step);
}
}
if (hit)
{
Blocked = true;
player_position2d_cmd_vel_t NullCmd = {{0}};
position->PutMsg (InQueue, PLAYER_MSGTYPE_CMD, PLAYER_POSITION2D_CMD_VEL, &NullCmd, sizeof (NullCmd), NULL);
}
else
{
Blocked = false;
}
return 0;
}
// set reply to value so the reply for this message goes straight to the given client
if (Device::MatchDeviceAddress (hdr->addr, device_addr) && hdr->type == PLAYER_MSGTYPE_REQ)
{
// Forward the message
position->PutMsg (InQueue, hdr, data);
// Store the return address for later use
ret_queue = resp_queue;
// Set the message filter to look for the response
InQueue->SetFilter (position_id.host,
position_id.robot,
position_id.interf,
position_id.index,
-1,
hdr->subtype);
// No response now; it will come later after we hear back from the
// laser
return 0;
}
// Forward responses (success or failure) from the position device
if (Device::MatchDeviceAddress (hdr->addr, position_id) &&
(hdr->type == PLAYER_MSGTYPE_RESP_ACK || hdr->type == PLAYER_MSGTYPE_RESP_NACK))
{
if (!gotPoseInfo && hdr->type == PLAYER_MSGTYPE_RESP_ACK && hdr->subtype == PLAYER_POSITION2D_REQ_GET_GEOM)
{
boxWidth = reinterpret_cast<player_position2d_geom_t*> (data)->size.sw;
boxWidth += boxWidth * boxSafety; // Add safety margin to the robot's width
boxWidth /= 2.0f;
gotPoseInfo = true;
}
else
{
// Copy in our address and forward the response
hdr->addr = device_addr;
Publish (ret_queue, hdr, data);
// Clear the filter
InQueue->ClearFilter ();
}
// No response to send; we just sent it ourselves
return 0;
}
// Forward data from the position device
if (Device::MatchDeviceAddress (hdr->addr, position_id) && hdr->type == PLAYER_MSGTYPE_DATA)
{
// Copy in our address and forward the response
hdr->addr = device_addr;
Publish (ret_queue, hdr, data);
// No response to send; we just sent it ourselves
return 0;
}
if (Message::MatchMessage (hdr, PLAYER_MSGTYPE_CMD, PLAYER_POSITION2D_CMD_VEL, device_addr))
{
assert (hdr->size == sizeof (player_position2d_cmd_vel_t));
bool fwdMove = reinterpret_cast<player_position2d_cmd_vel_t*> (data)->vel.px > 0 ? true : false;
if (!Blocked || (Blocked && front && !fwdMove) || (Blocked && !front && fwdMove))
{
position->PutMsg (InQueue, PLAYER_MSGTYPE_CMD, PLAYER_POSITION2D_CMD_VEL, data, hdr->size, &hdr->timestamp);
}
return 0;
}
if (Message::MatchMessage (hdr, PLAYER_MSGTYPE_CMD, PLAYER_POSITION2D_CMD_POS, device_addr))
{
assert (hdr->size == sizeof (player_position2d_cmd_pos_t));
bool fwdMove = reinterpret_cast<player_position2d_cmd_pos_t*> (data)->pos.px > 0 ? true : false;
if (!Blocked || (Blocked && front && !fwdMove) || (Blocked && !front && fwdMove))
{
position->PutMsg (InQueue, PLAYER_MSGTYPE_CMD, PLAYER_POSITION2D_CMD_POS, data, hdr->size, &hdr->timestamp);
}
return 0;
}
return -1;
}
////////////////////////////////////////////////////////////////////////////////
// Set up the underlying position device.
int LaserSafe::SetupPosition ()
{
// Subscribe to the position.
if (Device::MatchDeviceAddress (position_id, device_addr))
{
PLAYER_ERROR ("attempt to subscribe to self");
return -1;
}
if (!(position = deviceTable->GetDevice (position_id)))
{
PLAYER_ERROR ("unable to locate suitable position2d device");
return -1;
}
if (position->Subscribe (InQueue) != 0)
{
PLAYER_ERROR ("unable to subscribe to position2d device");
return -1;
}
return 0;
}
////////////////////////////////////////////////////////////////////////////////
// Shutdown the underlying position device.
int LaserSafe::ShutdownPosition ()
{
position->Unsubscribe (InQueue);
return 0;
}
////////////////////////////////////////////////////////////////////////////////
// Set up the bumper
int LaserSafe::SetupLaser ()
{
if (!(laser = deviceTable->GetDevice(laser_id)))
{
PLAYER_ERROR ("unable to locate suitable laser device");
return -1;
}
if (laser->Subscribe(InQueue) != 0)
{
PLAYER_ERROR ("unable to subscribe to laser device");
return -1;
}
return 0;
}
////////////////////////////////////////////////////////////////////////////////
// Shut down the bumper
int LaserSafe::ShutdownLaser () {
laser->Unsubscribe (InQueue);
return 0;
}
////////////////////////////////////////////////////////////////////////////////
// Constructor
LaserSafe::LaserSafe (ConfigFile* cf, int section)
: Driver (cf, section, true, PLAYER_MSGQUEUE_DEFAULT_MAXLEN, PLAYER_POSITION2D_CODE)
{
Blocked = false;
gotPoseInfo = false;
needPoseInfo = false;
position = NULL;
// Must have a position device
if (cf->ReadDeviceAddr (&position_id, section, "requires",
PLAYER_POSITION2D_CODE, -1, NULL) != 0)
{
SetError (-1);
return;
}
position_time = 0.0;
laser = NULL;
// Must have a laser device
if (cf->ReadDeviceAddr (&laser_id, section, "requires",
PLAYER_LASER_CODE, -1, NULL) != 0)
{
SetError (-1);
return;
}
laser_time = 0.0;
safeDistance = cf->ReadLength (section, "safedistance", 0.4);
step = cf->ReadInt (section, "step", 5);
historyLength = cf->ReadInt (section, "history", 1);
history = NULL;
int temp = cf->ReadInt (section, "forward", 1);
front = temp > 0 ? true : false;
temp = cf->ReadInt (section, "boxmode", 1);
boxMode = temp > 0 ? true : false;
boxWidth = cf->ReadLength (section, "boxwidth", -1.0f);
boxSafety = cf->ReadFloat (section, "boxsafety", 0.1);
if (boxWidth < 0.0f && boxMode)
needPoseInfo = true; // Don't need the pose info if not in box mode or specified in config
else
boxWidth /= 2.0f; // Box is always centred on laser
return;
}
| 29.048913 | 133 | 0.640287 | [
"object",
"model"
] |
98961d058c33a2afcefd04dc4ace17190c1e6f26 | 1,697 | cpp | C++ | src/JsonParser.cpp | developer-kikikaikai/linux_router | e4c29f407b5ace64298f798d6b1afabd81c2b6f5 | [
"MIT"
] | null | null | null | src/JsonParser.cpp | developer-kikikaikai/linux_router | e4c29f407b5ace64298f798d6b1afabd81c2b6f5 | [
"MIT"
] | 14 | 2018-07-22T19:12:21.000Z | 2018-08-21T08:54:49.000Z | src/JsonParser.cpp | developer-kikikaikai/linux_router | e4c29f407b5ace64298f798d6b1afabd81c2b6f5 | [
"MIT"
] | null | null | null | #include <string.h>
#include <fstream>
#include <iostream>
#include "JsonParser.hpp"
JsonParser::JsonParser(const char * input_setting) {
/*read file first*/
std::string input_string;
try {
/*openfile*/
std::ifstream ifs(input_setting, std::ios::binary);
/*read all*/
std::string buf;
while(getline(ifs, buf)) {
input_string += buf;
}
} catch (std::ifstream::failure e){
exit(-1);
}
json_error_t error;
_setting_master = json_loads(input_string.c_str(), 0, &error);
if ( _setting_master == NULL ) {
fputs(error.text, stderr);
exit(-1);
}
/*add data into map*/
const char *key;
json_t *value;
json_object_foreach(_setting_master, key, value) {
std::cout << key << std::endl;
if( key == _lan_name) {
lan_info = value;
} else {
plugin_map[key] = value;
}
}
std::cout << _lan_name << std::endl;
json_object_foreach((json_t *)lan_info, key, value) {
std::cout << " " << key << ":" << json_string_value(value) << std::endl;
}
for(auto itr = plugin_map.begin(); itr != plugin_map.end(); ++itr) {
std::cout << itr->first << std::endl;
json_object_foreach(itr->second, key, value) {
std::cout << " " << key << ":" << json_string_value(value) << std::endl;
}
}
}
JsonParser::~JsonParser() {
json_decref(_setting_master);
}
/*cpp side, it is not set "static"*/
const char * JsonParser::get_string(const json_t * object, const char * key) {
json_t * json_value = json_object_get(object, key);
if(json_value == NULL) goto errend;
{
const char * value = json_string_value(json_value);
if(value == NULL) goto errend;
return value;
}
errend:
fprintf(stderr, "setting error, please check key %s\n", key);
exit(-1);
}
| 23.246575 | 79 | 0.642899 | [
"object"
] |
989a43a57997cd196053e7637eba3798a328d802 | 2,103 | inl | C++ | src/cunumeric/matrix/trilu_template.inl | marcinz/cunumeric | c40b038d4eb0611f7bb16d5bd11891a633ef7892 | [
"Apache-2.0"
] | 118 | 2021-04-12T18:06:59.000Z | 2021-10-12T21:30:24.000Z | src/cunumeric/matrix/trilu_template.inl | marcinz/cunumeric | c40b038d4eb0611f7bb16d5bd11891a633ef7892 | [
"Apache-2.0"
] | 51 | 2021-04-21T10:40:13.000Z | 2021-09-10T22:09:26.000Z | src/cunumeric/matrix/trilu_template.inl | marcinz/cunumeric | c40b038d4eb0611f7bb16d5bd11891a633ef7892 | [
"Apache-2.0"
] | 9 | 2021-04-14T03:07:42.000Z | 2021-09-22T17:02:53.000Z | /* Copyright 2021 NVIDIA Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
#include "cunumeric/pitches.h"
namespace cunumeric {
using namespace Legion;
using namespace legate;
template <VariantKind KIND, LegateTypeCode CODE, int32_t DIM, bool LOWER>
struct TriluImplBody;
template <VariantKind KIND>
struct TriluImpl {
template <LegateTypeCode CODE, int32_t DIM, std::enable_if_t<(DIM >= 2)>* = nullptr>
void operator()(TriluArgs& args) const
{
using VAL = legate_type_of<CODE>;
auto shape = args.output.shape<DIM>();
Pitches<DIM - 1> pitches;
size_t volume = pitches.flatten(shape);
if (volume == 0) return;
auto out = args.output.write_accessor<VAL, DIM>(shape);
auto in = args.input.read_accessor<VAL, DIM>(shape);
if (args.lower)
TriluImplBody<KIND, CODE, DIM, true>()(out, in, pitches, shape.lo, volume, args.k);
else
TriluImplBody<KIND, CODE, DIM, false>()(out, in, pitches, shape.lo, volume, args.k);
}
template <LegateTypeCode CODE, int32_t DIM, std::enable_if_t<(DIM < 2)>* = nullptr>
void operator()(TriluArgs& args) const
{
assert(false);
}
};
template <VariantKind KIND>
static void trilu_template(TaskContext& context)
{
auto& scalars = context.scalars();
auto lower = scalars[0].value<bool>();
auto k = scalars[1].value<int32_t>();
auto& input = context.inputs()[0];
auto& output = context.outputs()[0];
TriluArgs args{lower, k, output, input};
double_dispatch(args.output.dim(), args.output.code(), TriluImpl<KIND>{}, args);
}
} // namespace cunumeric
| 30.478261 | 90 | 0.696148 | [
"shape"
] |
989c2a3e54ca202e7e72c0457ad107a09aab890b | 37,203 | cpp | C++ | services/distributeddataservice/libs/distributeddb/test/unittest/common/common/distributeddb_auto_launch_test.cpp | openharmony-gitee-mirror/distributeddatamgr_datamgr | 3f17e1a6a6e0f83f3a346e87073b39dd949b0c9e | [
"Apache-2.0"
] | null | null | null | services/distributeddataservice/libs/distributeddb/test/unittest/common/common/distributeddb_auto_launch_test.cpp | openharmony-gitee-mirror/distributeddatamgr_datamgr | 3f17e1a6a6e0f83f3a346e87073b39dd949b0c9e | [
"Apache-2.0"
] | null | null | null | services/distributeddataservice/libs/distributeddb/test/unittest/common/common/distributeddb_auto_launch_test.cpp | openharmony-gitee-mirror/distributeddatamgr_datamgr | 3f17e1a6a6e0f83f3a346e87073b39dd949b0c9e | [
"Apache-2.0"
] | 1 | 2021-09-13T12:07:54.000Z | 2021-09-13T12:07:54.000Z | /*
* Copyright (c) 2021 Huawei Device 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 <gtest/gtest.h>
#include "auto_launch.h"
#include "db_errno.h"
#include "log_print.h"
#include "db_common.h"
#include "kvdb_manager.h"
#include "distributeddb_tools_unit_test.h"
#include "vitural_communicator_aggregator.h"
#include "platform_specific.h"
#include "kv_store_nb_conflict_data.h"
#include "kvdb_pragma.h"
using namespace std;
using namespace testing::ext;
using namespace DistributedDB;
using namespace DistributedDBUnitTest;
namespace {
const std::string APP_ID = "appId";
const std::string USER_ID = "userId";
const std::string STORE_ID_0 = "storeId0";
const std::string STORE_ID_1 = "storeId1";
const std::string STORE_ID_2 = "storeId2";
const std::string STORE_ID_3 = "storeId3";
const std::string STORE_ID_4 = "storeId4";
const std::string STORE_ID_5 = "storeId5";
const std::string STORE_ID_6 = "storeId6";
const std::string STORE_ID_7 = "storeId7";
const std::string STORE_ID_8 = "storeId8";
string g_testDir;
KvStoreDelegateManager g_mgr(APP_ID, USER_ID);
KvStoreConfig g_config;
VirtualCommunicatorAggregator *g_communicatorAggregator = nullptr;
const int TEST_ENABLE_CNT = 10; // 10 time
const int TEST_ONLINE_CNT = 200; // 10 time
const int WAIT_TIME = 1000; // 1000ms
const int LIFE_CYCLE_TIME = 5000; // 5000ms
const int WAIT_SHORT_TIME = 200; // 20ms
const TimeStamp TIME_ADD = 1000; // not zero is ok
const std::string REMOTE_DEVICE_ID = "remote_device";
const std::string THIS_DEVICE = "real_device";
const Key KEY1{'k', 'e', 'y', '1'};
const Key KEY2{'k', 'e', 'y', '2'};
const Value VALUE1{'v', 'a', 'l', 'u', 'e', '1'};
const Value VALUE2{'v', 'a', 'l', 'u', 'e', '2'};
KvDBProperties g_propA;
KvDBProperties g_propB;
KvDBProperties g_propC;
KvDBProperties g_propD;
KvDBProperties g_propE;
KvDBProperties g_propF;
KvDBProperties g_propG;
KvDBProperties g_propH;
KvDBProperties g_propI;
std::string g_identifierA;
std::string g_identifierB;
std::string g_identifierC;
std::string g_identifierD;
std::string g_identifierE;
std::string g_identifierF;
std::string g_identifierG;
std::string g_identifierH;
std::string g_identifierI;
}
class DistributedDBAutoLaunchUnitTest : public testing::Test {
public:
static void SetUpTestCase(void);
static void TearDownTestCase(void);
void SetUp();
void TearDown() {};
};
void DistributedDBAutoLaunchUnitTest::SetUpTestCase(void)
{
DistributedDBToolsUnitTest::TestDirInit(g_testDir);
g_config.dataDir = g_testDir;
g_mgr.SetKvStoreConfig(g_config);
string dir = g_testDir;
DIR *dirTmp = opendir(dir.c_str());
if (dirTmp == nullptr) {
OS::MakeDBDirectory(dir);
} else {
closedir(dirTmp);
}
if (DistributedDBToolsUnitTest::RemoveTestDbFiles(
g_testDir + "/" + DBCommon::TransferStringToHex(g_identifierA) + "/single_ver") != 0) {
LOGE("rm test db files error!");
}
g_communicatorAggregator = new (std::nothrow) VirtualCommunicatorAggregator();
ASSERT_TRUE(g_communicatorAggregator != nullptr);
RuntimeContext::GetInstance()->SetCommunicatorAggregator(g_communicatorAggregator);
}
void DistributedDBAutoLaunchUnitTest::TearDownTestCase(void)
{
if (DistributedDBToolsUnitTest::RemoveTestDbFiles(
g_testDir + "/" + DBCommon::TransferStringToHex(g_identifierA) + "/single_ver") != 0) {
LOGE("rm test db files error!");
}
RuntimeContext::GetInstance()->SetCommunicatorAggregator(nullptr);
}
static void GetProperty(KvDBProperties &prop, std::string &identifier, std::string storeId)
{
prop.SetStringProp(KvDBProperties::USER_ID, USER_ID);
prop.SetStringProp(KvDBProperties::APP_ID, APP_ID);
prop.SetStringProp(KvDBProperties::STORE_ID, storeId);
identifier = DBCommon::TransferHashString(USER_ID + "-" + APP_ID + "-" + storeId);
prop.SetStringProp(KvDBProperties::IDENTIFIER_DATA, identifier);
std::string identifierDirA = DBCommon::TransferStringToHex(identifier);
prop.SetStringProp(KvDBProperties::IDENTIFIER_DIR, identifierDirA);
prop.SetStringProp(KvDBProperties::DATA_DIR, g_testDir);
prop.SetIntProp(KvDBProperties::DATABASE_TYPE, KvDBProperties::SINGLE_VER_TYPE);
prop.SetBoolProp(KvDBProperties::CREATE_IF_NECESSARY, true);
}
void DistributedDBAutoLaunchUnitTest::SetUp(void)
{
if (DistributedDBToolsUnitTest::RemoveTestDbFiles(
g_testDir + "/" + DBCommon::TransferStringToHex(g_identifierA) + "/single_ver") != 0) {
LOGE("rm test db files error!");
}
GetProperty(g_propA, g_identifierA, STORE_ID_0);
GetProperty(g_propB, g_identifierB, STORE_ID_1);
GetProperty(g_propC, g_identifierC, STORE_ID_2);
GetProperty(g_propD, g_identifierD, STORE_ID_3);
GetProperty(g_propE, g_identifierE, STORE_ID_4);
GetProperty(g_propF, g_identifierF, STORE_ID_5);
GetProperty(g_propG, g_identifierG, STORE_ID_6);
GetProperty(g_propH, g_identifierH, STORE_ID_7);
GetProperty(g_propI, g_identifierI, STORE_ID_8);
}
static void PutSyncData(const KvDBProperties &prop, const Key &key, const Value &value)
{
int errCode = E_OK;
auto kvStore = static_cast<SQLiteSingleVerNaturalStore *>(KvDBManager::OpenDatabase(prop, errCode));
ASSERT_NE(kvStore, nullptr);
auto *connection = kvStore->GetDBConnection(errCode);
ASSERT_NE(connection, nullptr);
if (kvStore != nullptr) {
std::vector<DataItem> vect;
TimeStamp time;
kvStore->GetMaxTimeStamp(time);
time += TIME_ADD;
LOGD("time:%lld", time);
vect.push_back({key, value, time, 0, DBCommon::TransferHashString(REMOTE_DEVICE_ID)});
EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(kvStore, vect, REMOTE_DEVICE_ID), E_OK);
}
RefObject::DecObjRef(kvStore);
connection->Close();
connection = nullptr;
}
static void SetLifeCycleTime(const KvDBProperties &prop)
{
int errCode = E_OK;
auto kvStore = static_cast<SQLiteSingleVerNaturalStore *>(KvDBManager::OpenDatabase(prop, errCode));
ASSERT_NE(kvStore, nullptr);
auto *connection = kvStore->GetDBConnection(errCode);
ASSERT_NE(connection, nullptr);
uint32_t time = LIFE_CYCLE_TIME;
EXPECT_EQ(connection->Pragma(PRAGMA_SET_AUTO_LIFE_CYCLE, static_cast<PragmaData>(&time)), E_OK);
RefObject::DecObjRef(kvStore);
connection->Close();
connection = nullptr;
}
/**
* @tc.name: AutoLaunch001
* @tc.desc: basic enable/disable func
* @tc.type: FUNC
* @tc.require: AR000E8S2T
* @tc.author: wangchuanqing
*/
HWTEST_F(DistributedDBAutoLaunchUnitTest, AutoLaunch001, TestSize.Level3)
{
/**
* @tc.steps: step1. right param A enable
* @tc.expected: step1. success.
*/
int errCode = RuntimeContext::GetInstance()->EnableKvStoreAutoLaunch(g_propA, nullptr, nullptr, 0, nullptr);
EXPECT_TRUE(errCode == E_OK);
/**
* @tc.steps: step2. wrong param B enable
* @tc.expected: step2. failed.
*/
g_propB.SetStringProp(KvDBProperties::IDENTIFIER_DATA, "");
errCode = RuntimeContext::GetInstance()->EnableKvStoreAutoLaunch(g_propB, nullptr, nullptr, 0, nullptr);
EXPECT_TRUE(errCode != E_OK);
/**
* @tc.steps: step3. right param C enable
* @tc.expected: step3. success.
*/
errCode = RuntimeContext::GetInstance()->EnableKvStoreAutoLaunch(g_propC, nullptr, nullptr, 0, nullptr);
EXPECT_TRUE(errCode == E_OK);
/**
* @tc.steps: step4. param A disable
* @tc.expected: step4. E_OK.
*/
errCode = RuntimeContext::GetInstance()->DisableKvStoreAutoLaunch(g_identifierA);
EXPECT_TRUE(errCode == E_OK);
/**
* @tc.steps: step5. param B disable
* @tc.expected: step5. -E_NOT_FOUND.
*/
errCode = RuntimeContext::GetInstance()->DisableKvStoreAutoLaunch(g_identifierB);
EXPECT_TRUE(errCode == -E_NOT_FOUND);
/**
* @tc.steps: step6. param C disable
* @tc.expected: step6. E_OK.
*/
errCode = RuntimeContext::GetInstance()->DisableKvStoreAutoLaunch(g_identifierC);
EXPECT_TRUE(errCode == E_OK);
}
/**
* @tc.name: AutoLaunch002
* @tc.desc: online callback
* @tc.type: FUNC
* @tc.require: AR000E8S2T
* @tc.author: wangchuanqing
*/
HWTEST_F(DistributedDBAutoLaunchUnitTest, AutoLaunch002, TestSize.Level3)
{
std::mutex cvMutex;
std::condition_variable cv;
bool finished = false;
std::map<const std::string, AutoLaunchStatus> statusMap;
auto notifier = [&cvMutex, &cv, &finished, &statusMap] (const std::string &userId, const std::string &appId,
const std::string &storeId, AutoLaunchStatus status) {
LOGD("int AutoLaunch002 notifier status:%d", status);
std::string identifier = DBCommon::TransferHashString(userId + "-" + appId + "-" + storeId);
std::unique_lock<std::mutex> lock(cvMutex);
statusMap[identifier] = status;
LOGD("int AutoLaunch002 notifier statusMap.size():%d", statusMap.size());
if (statusMap.size() == 2) { // A and B
finished = true;
cv.notify_one();
}
};
KvStoreObserverUnitTest *observer = new (std::nothrow) KvStoreObserverUnitTest;
ASSERT_TRUE(observer != nullptr);
/**
* @tc.steps: step1. right param A B enable
* @tc.expected: step1. success.
*/
int errCode = RuntimeContext::GetInstance()->EnableKvStoreAutoLaunch(g_propA, notifier, observer, 0, nullptr);
EXPECT_TRUE(errCode == E_OK);
errCode = RuntimeContext::GetInstance()->EnableKvStoreAutoLaunch(g_propB, notifier, observer, 0, nullptr);
EXPECT_TRUE(errCode == E_OK);
/**
* @tc.steps: step2. RunOnConnectCallback
* @tc.expected: step2. success.
*/
g_communicatorAggregator->RunOnConnectCallback(REMOTE_DEVICE_ID, true);
std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME));
/**
* @tc.steps: step3. PutSyncData
* @tc.expected: step3. notifier WRITE_OPENED
*/
PutSyncData(g_propA, KEY1, VALUE1);
PutSyncData(g_propB, KEY1, VALUE1);
{
std::unique_lock<std::mutex> lock(cvMutex);
cv.wait(lock, [&finished] {return finished;});
EXPECT_TRUE(statusMap[g_identifierA] == WRITE_OPENED);
EXPECT_TRUE(statusMap[g_identifierB] == WRITE_OPENED);
statusMap.clear();
finished = false;
}
EXPECT_TRUE(observer->GetCallCount() == 2); // A and B
delete observer;
/**
* @tc.steps: step4. param A B disable
* @tc.expected: step4. notifier WRITE_CLOSED
*/
errCode = RuntimeContext::GetInstance()->DisableKvStoreAutoLaunch(g_identifierA);
EXPECT_TRUE(errCode == E_OK);
errCode = RuntimeContext::GetInstance()->DisableKvStoreAutoLaunch(g_identifierB);
EXPECT_TRUE(errCode == E_OK);
std::unique_lock<std::mutex> lock(cvMutex);
cv.wait(lock, [&finished] {return finished;});
EXPECT_TRUE(statusMap[g_identifierA] == WRITE_CLOSED);
EXPECT_TRUE(statusMap[g_identifierB] == WRITE_CLOSED);
g_communicatorAggregator->RunOnConnectCallback(REMOTE_DEVICE_ID, false);
}
/**
* @tc.name: AutoLaunch003
* @tc.desc: CommunicatorLackCallback
* @tc.type: FUNC
* @tc.require: AR000E8S2T
* @tc.author: wangchuanqing
*/
HWTEST_F(DistributedDBAutoLaunchUnitTest, AutoLaunch003, TestSize.Level3)
{
std::mutex cvMutex;
std::condition_variable cv;
bool finished = false;
std::map<const std::string, AutoLaunchStatus> statusMap;
auto notifier = [&cvMutex, &cv, &finished, &statusMap] (const std::string &userId, const std::string &appId,
const std::string &storeId, AutoLaunchStatus status) {
LOGD("int AutoLaunch002 notifier status:%d", status);
std::string identifier = DBCommon::TransferHashString(userId + "-" + appId + "-" + storeId);
std::unique_lock<std::mutex> lock(cvMutex);
statusMap[identifier] = status;
LOGD("int AutoLaunch002 notifier statusMap.size():%d", statusMap.size());
finished = true;
cv.notify_one();
};
KvStoreObserverUnitTest *observer = new (std::nothrow) KvStoreObserverUnitTest;
ASSERT_TRUE(observer != nullptr);
/**
* @tc.steps: step1. right param A B enable
* @tc.expected: step1. success.
*/
int errCode = RuntimeContext::GetInstance()->EnableKvStoreAutoLaunch(g_propA, notifier, observer, 0, nullptr);
EXPECT_TRUE(errCode == E_OK);
errCode = RuntimeContext::GetInstance()->EnableKvStoreAutoLaunch(g_propB, notifier, observer, 0, nullptr);
EXPECT_TRUE(errCode == E_OK);
/**
* @tc.steps: step2. RunCommunicatorLackCallback
* @tc.expected: step2. success.
*/
LabelType label(g_identifierA.begin(), g_identifierA.end());
g_communicatorAggregator->RunCommunicatorLackCallback(label);
std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME));
/**
* @tc.steps: step3. PutSyncData
* @tc.expected: step3. notifier WRITE_OPENED
*/
PutSyncData(g_propA, KEY2, VALUE2);
{
std::unique_lock<std::mutex> lock(cvMutex);
cv.wait(lock, [&finished] {return finished;});
EXPECT_TRUE(statusMap[g_identifierA] == WRITE_OPENED);
statusMap.clear();
finished = false;
}
EXPECT_TRUE(observer->GetCallCount() == 1); // only A
delete observer;
/**
* @tc.steps: step4. param A B disable
* @tc.expected: step4. notifier WRITE_CLOSED
*/
errCode = RuntimeContext::GetInstance()->DisableKvStoreAutoLaunch(g_identifierB);
EXPECT_TRUE(errCode == E_OK);
std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME));
errCode = RuntimeContext::GetInstance()->DisableKvStoreAutoLaunch(g_identifierA);
EXPECT_TRUE(errCode == E_OK);
std::unique_lock<std::mutex> lock(cvMutex);
cv.wait(lock, [&finished] {return finished;});
EXPECT_TRUE(statusMap[g_identifierA] == WRITE_CLOSED);
EXPECT_TRUE(statusMap.size() == 1);
}
/**
* @tc.name: AutoLaunch004
* @tc.desc: basic enable/disable func
* @tc.type: FUNC
* @tc.require: AR000E8S2T
* @tc.author: wangchuanqing
*/
HWTEST_F(DistributedDBAutoLaunchUnitTest, AutoLaunch004, TestSize.Level3)
{
/**
* @tc.steps: step1. right param A~H enable
* @tc.expected: step1. success.
*/
int errCode = RuntimeContext::GetInstance()->EnableKvStoreAutoLaunch(g_propA, nullptr, nullptr, 0, nullptr);
EXPECT_TRUE(errCode == E_OK);
errCode = RuntimeContext::GetInstance()->EnableKvStoreAutoLaunch(g_propB, nullptr, nullptr, 0, nullptr);
EXPECT_TRUE(errCode == E_OK);
errCode = RuntimeContext::GetInstance()->EnableKvStoreAutoLaunch(g_propC, nullptr, nullptr, 0, nullptr);
EXPECT_TRUE(errCode == E_OK);
errCode = RuntimeContext::GetInstance()->EnableKvStoreAutoLaunch(g_propD, nullptr, nullptr, 0, nullptr);
EXPECT_TRUE(errCode == E_OK);
errCode = RuntimeContext::GetInstance()->EnableKvStoreAutoLaunch(g_propE, nullptr, nullptr, 0, nullptr);
EXPECT_TRUE(errCode == E_OK);
errCode = RuntimeContext::GetInstance()->EnableKvStoreAutoLaunch(g_propF, nullptr, nullptr, 0, nullptr);
EXPECT_TRUE(errCode == E_OK);
errCode = RuntimeContext::GetInstance()->EnableKvStoreAutoLaunch(g_propG, nullptr, nullptr, 0, nullptr);
EXPECT_TRUE(errCode == E_OK);
errCode = RuntimeContext::GetInstance()->EnableKvStoreAutoLaunch(g_propH, nullptr, nullptr, 0, nullptr);
EXPECT_TRUE(errCode == E_OK);
/**
* @tc.steps: step2. right param I enable
* @tc.expected: step2. -E_MAX_LIMITS.
*/
errCode = RuntimeContext::GetInstance()->EnableKvStoreAutoLaunch(g_propI, nullptr, nullptr, 0, nullptr);
EXPECT_TRUE(errCode == -E_MAX_LIMITS);
/**
* @tc.steps: step3. param A disable
* @tc.expected: step3. E_OK.
*/
errCode = RuntimeContext::GetInstance()->DisableKvStoreAutoLaunch(g_identifierA);
EXPECT_TRUE(errCode == E_OK);
/**
* @tc.steps: step4. right param I enable
* @tc.expected: step4. E_OK.
*/
errCode = RuntimeContext::GetInstance()->EnableKvStoreAutoLaunch(g_propI, nullptr, nullptr, 0, nullptr);
EXPECT_TRUE(errCode == E_OK);
/**
* @tc.steps: step6. param B~I disable
* @tc.expected: step6. E_OK.
*/
errCode = RuntimeContext::GetInstance()->DisableKvStoreAutoLaunch(g_identifierB);
EXPECT_TRUE(errCode == E_OK);
errCode = RuntimeContext::GetInstance()->DisableKvStoreAutoLaunch(g_identifierC);
EXPECT_TRUE(errCode == E_OK);
errCode = RuntimeContext::GetInstance()->DisableKvStoreAutoLaunch(g_identifierD);
EXPECT_TRUE(errCode == E_OK);
errCode = RuntimeContext::GetInstance()->DisableKvStoreAutoLaunch(g_identifierE);
EXPECT_TRUE(errCode == E_OK);
errCode = RuntimeContext::GetInstance()->DisableKvStoreAutoLaunch(g_identifierF);
EXPECT_TRUE(errCode == E_OK);
errCode = RuntimeContext::GetInstance()->DisableKvStoreAutoLaunch(g_identifierG);
EXPECT_TRUE(errCode == E_OK);
errCode = RuntimeContext::GetInstance()->DisableKvStoreAutoLaunch(g_identifierH);
EXPECT_TRUE(errCode == E_OK);
errCode = RuntimeContext::GetInstance()->DisableKvStoreAutoLaunch(g_identifierI);
EXPECT_TRUE(errCode == E_OK);
}
/**
* @tc.name: AutoLaunch005
* @tc.desc: online device before enable
* @tc.type: FUNC
* @tc.require: AR000E8S2T
* @tc.author: wangchuanqing
*/
HWTEST_F(DistributedDBAutoLaunchUnitTest, AutoLaunch005, TestSize.Level3)
{
std::mutex cvMutex;
std::condition_variable cv;
bool finished = false;
std::map<const std::string, AutoLaunchStatus> statusMap;
auto notifier = [&cvMutex, &cv, &finished, &statusMap] (const std::string &userId, const std::string &appId,
const std::string &storeId, AutoLaunchStatus status) {
LOGD("int AutoLaunch002 notifier status:%d", status);
std::string identifier = DBCommon::TransferHashString(userId + "-" + appId + "-" + storeId);
std::unique_lock<std::mutex> lock(cvMutex);
statusMap[identifier] = status;
LOGD("int AutoLaunch002 notifier statusMap.size():%d", statusMap.size());
finished = true;
cv.notify_one();
};
KvStoreObserverUnitTest *observer = new (std::nothrow) KvStoreObserverUnitTest;
ASSERT_TRUE(observer != nullptr);
/**
* @tc.steps: step1. RunOnConnectCallback
* @tc.expected: step1. success.
*/
g_communicatorAggregator->RunOnConnectCallback(REMOTE_DEVICE_ID, true);
std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME));
/**
* @tc.steps: step2. right param A enable
* @tc.expected: step2. success.
*/
int errCode = RuntimeContext::GetInstance()->EnableKvStoreAutoLaunch(g_propA, notifier, observer, 0, nullptr);
EXPECT_TRUE(errCode == E_OK);
/**
* @tc.steps: step3. PutSyncData
* @tc.expected: step3. notifier WRITE_OPENED
*/
PutSyncData(g_propA, KEY1, VALUE1);
{
std::unique_lock<std::mutex> lock(cvMutex);
cv.wait(lock, [&finished] {return finished;});
EXPECT_TRUE(statusMap[g_identifierA] == WRITE_OPENED);
statusMap.clear();
finished = false;
}
EXPECT_TRUE(observer->GetCallCount() == 1); // only A
/**
* @tc.steps: step4. param A disable
* @tc.expected: step4. notifier WRITE_CLOSED
*/
errCode = RuntimeContext::GetInstance()->DisableKvStoreAutoLaunch(g_identifierA);
EXPECT_TRUE(errCode == E_OK);
std::unique_lock<std::mutex> lock(cvMutex);
cv.wait(lock, [&finished] {return finished;});
EXPECT_TRUE(statusMap[g_identifierA] == WRITE_CLOSED);
delete observer;
g_communicatorAggregator->RunOnConnectCallback(REMOTE_DEVICE_ID, false);
}
/**
* @tc.name: AutoLaunch006
* @tc.desc: online callback
* @tc.type: FUNC
* @tc.require: AR000E8S2T
* @tc.author: wangchuanqing
*/
HWTEST_F(DistributedDBAutoLaunchUnitTest, AutoLaunch006, TestSize.Level3)
{
auto notifier = [] (const std::string &userId, const std::string &appId,
const std::string &storeId, AutoLaunchStatus status) {
LOGD("int AutoLaunch006 notifier status:%d", status);
};
KvStoreObserverUnitTest *observer = new (std::nothrow) KvStoreObserverUnitTest;
ASSERT_TRUE(observer != nullptr);
std::mutex cvLock;
std::condition_variable cv;
bool threadIsWorking = true;
thread thread([&cvLock, &cv, &threadIsWorking](){
LabelType label(g_identifierA.begin(), g_identifierA.end());
for (int i = 0; i < TEST_ONLINE_CNT; i++) {
g_communicatorAggregator->RunOnConnectCallback(REMOTE_DEVICE_ID, true);
std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_SHORT_TIME));
g_communicatorAggregator->RunOnConnectCallback(REMOTE_DEVICE_ID, false);
std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_SHORT_TIME));
g_communicatorAggregator->RunCommunicatorLackCallback(label);
std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_SHORT_TIME));
LOGD("AutoLaunch006 thread i:%d", i);
}
std::unique_lock<std::mutex> lock(cvLock);
threadIsWorking = false;
cv.notify_one();
});
thread.detach();
for (int i = 0; i < TEST_ENABLE_CNT; i++) {
int errCode = RuntimeContext::GetInstance()->EnableKvStoreAutoLaunch(g_propA, notifier, observer, 0, nullptr);
EXPECT_TRUE(errCode == E_OK);
errCode = RuntimeContext::GetInstance()->EnableKvStoreAutoLaunch(g_propB, notifier, observer, 0, nullptr);
EXPECT_TRUE(errCode == E_OK);
errCode = RuntimeContext::GetInstance()->DisableKvStoreAutoLaunch(g_identifierA);
EXPECT_TRUE(errCode == E_OK);
errCode = RuntimeContext::GetInstance()->DisableKvStoreAutoLaunch(g_identifierB);
EXPECT_TRUE(errCode == E_OK);
LOGD("AutoLaunch006 disable i:%d", i);
}
std::unique_lock<std::mutex> lock(cvLock);
cv.wait(lock, [&threadIsWorking]{return threadIsWorking == false;});
delete observer;
g_communicatorAggregator->RunOnConnectCallback(REMOTE_DEVICE_ID, false);
}
namespace {
std::mutex g_cvMutex;
std::condition_variable g_cv;
bool g_finished = false;
std::map<const std::string, AutoLaunchStatus> g_statusMap;
void ConflictNotifierCallback(const KvStoreNbConflictData &data)
{
LOGD("in ConflictNotifierCallback");
Key key;
Value oldValue;
Value newValue;
data.GetKey(key);
data.GetValue(KvStoreNbConflictData::ValueType::OLD_VALUE, oldValue);
data.GetValue(KvStoreNbConflictData::ValueType::NEW_VALUE, newValue);
EXPECT_TRUE(key == KEY1);
EXPECT_TRUE(oldValue == VALUE1);
EXPECT_TRUE(newValue == VALUE2);
g_finished = true;
g_cv.notify_one();
}
void TestAutoLaunchNotifier(const std::string &userId, const std::string &appId, const std::string &storeId,
AutoLaunchStatus status)
{
LOGD("int AutoLaunchNotifier, status:%d", status);
std::string identifier = DBCommon::TransferHashString(userId + "-" + appId + "-" + storeId);
std::unique_lock<std::mutex> lock(g_cvMutex);
g_statusMap[identifier] = status;
g_finished = true;
g_cv.notify_one();
};
bool AutoLaunchCallBack(const std::string &identifier, AutoLaunchParam ¶m, KvStoreObserverUnitTest *observer,
bool ret)
{
LOGD("int AutoLaunchCallBack");
EXPECT_TRUE(identifier == g_identifierA);
param.userId = USER_ID;
param.appId = APP_ID;
param.storeId = STORE_ID_0;
CipherPassword passwd;
param.option = {true, false, CipherType::DEFAULT, passwd, "", false, g_testDir, observer,
CONFLICT_FOREIGN_KEY_ONLY, ConflictNotifierCallback};
param.notifier = TestAutoLaunchNotifier;
return ret;
}
bool AutoLaunchCallBackBadParam(const std::string &identifier, AutoLaunchParam ¶m)
{
LOGD("int AutoLaunchCallBack");
EXPECT_TRUE(identifier == g_identifierA);
param.notifier = TestAutoLaunchNotifier;
return true;
}
}
/**
* @tc.name: AutoLaunch007
* @tc.desc: enhancement callback return true
* @tc.type: FUNC
* @tc.require: AR000EPARJ
* @tc.author: wangchuanqing
*/
HWTEST_F(DistributedDBAutoLaunchUnitTest, AutoLaunch007, TestSize.Level3)
{
KvStoreObserverUnitTest *observer = new (std::nothrow) KvStoreObserverUnitTest;
ASSERT_TRUE(observer != nullptr);
/**
* @tc.steps: step1. SetAutoLaunchRequestCallback
* @tc.expected: step1. success.
*/
RuntimeContext::GetInstance()->SetAutoLaunchRequestCallback(
std::bind(AutoLaunchCallBack, std::placeholders::_1, std::placeholders::_2, observer, true));
/**
* @tc.steps: step2. RunCommunicatorLackCallback
* @tc.expected: step2. success.
*/
LabelType label(g_identifierA.begin(), g_identifierA.end());
g_communicatorAggregator->RunCommunicatorLackCallback(label);
std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME));
/**
* @tc.steps: step3. PutSyncData key1 value1
* @tc.expected: step3. notifier WRITE_OPENED
*/
PutSyncData(g_propA, KEY1, VALUE1);
{
std::unique_lock<std::mutex> lock(g_cvMutex);
g_cv.wait(lock, [] {return g_finished;});
EXPECT_TRUE(g_statusMap[g_identifierA] == WRITE_OPENED);
g_statusMap.clear();
g_finished = false;
}
EXPECT_TRUE(observer->GetCallCount() == 1); // only A
/**
* @tc.steps: step4. PutSyncData key1 value2
* @tc.expected: step4. ConflictNotifierCallback
*/
PutSyncData(g_propA, KEY1, VALUE2);
{
std::unique_lock<std::mutex> lock(g_cvMutex);
g_cv.wait(lock, [] {return g_finished;});
g_finished = false;
}
/**
* @tc.steps: step5. wait life cycle ,db close
* @tc.expected: step5. notifier WRITE_CLOSED
*/
SetLifeCycleTime(g_propA);
{
std::unique_lock<std::mutex> lock(g_cvMutex);
g_cv.wait(lock, [] {return g_finished;});
EXPECT_TRUE(g_statusMap[g_identifierA] == WRITE_CLOSED);
g_statusMap.clear();
g_finished = false;
}
RuntimeContext::GetInstance()->SetAutoLaunchRequestCallback(nullptr);
delete observer;
}
/**
* @tc.name: AutoLaunch008
* @tc.desc: enhancement callback return false
* @tc.type: FUNC
* @tc.require: AR000EPARJ
* @tc.author: wangchuanqing
*/
HWTEST_F(DistributedDBAutoLaunchUnitTest, AutoLaunch008, TestSize.Level3)
{
KvStoreObserverUnitTest *observer = new (std::nothrow) KvStoreObserverUnitTest;
ASSERT_TRUE(observer != nullptr);
/**
* @tc.steps: step1. SetAutoLaunchRequestCallback
* @tc.expected: step1. success.
*/
RuntimeContext::GetInstance()->SetAutoLaunchRequestCallback(
std::bind(AutoLaunchCallBack, std::placeholders::_1, std::placeholders::_2, observer, false));
/**
* @tc.steps: step2. RunCommunicatorLackCallback
* @tc.expected: step2. success.
*/
LabelType label(g_identifierA.begin(), g_identifierA.end());
g_communicatorAggregator->RunCommunicatorLackCallback(label);
std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME));
/**
* @tc.steps: step3. PutSyncData key1 value1
* @tc.expected: step3. db not open
*/
PutSyncData(g_propA, KEY1, VALUE1);
PutSyncData(g_propA, KEY1, VALUE2);
std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME));
EXPECT_TRUE(observer->GetCallCount() == 0);
EXPECT_TRUE(g_finished == false);
RuntimeContext::GetInstance()->SetAutoLaunchRequestCallback(nullptr);
delete observer;
}
/**
* @tc.name: AutoLaunch009
* @tc.desc: enhancement callback return bad param
* @tc.type: FUNC
* @tc.require: AR000EPARJ
* @tc.author: wangchuanqing
*/
HWTEST_F(DistributedDBAutoLaunchUnitTest, AutoLaunch009, TestSize.Level3)
{
KvStoreObserverUnitTest *observer = new (std::nothrow) KvStoreObserverUnitTest;
ASSERT_TRUE(observer != nullptr);
/**
* @tc.steps: step1. SetAutoLaunchRequestCallback
* @tc.expected: step1. success.
*/
RuntimeContext::GetInstance()->SetAutoLaunchRequestCallback(AutoLaunchCallBackBadParam);
/**
* @tc.steps: step2. RunCommunicatorLackCallback
* @tc.expected: step2. success.
*/
LabelType label(g_identifierA.begin(), g_identifierA.end());
g_communicatorAggregator->RunCommunicatorLackCallback(label);
std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME));
/**
* @tc.steps: step3. PutSyncData key1 value1
* @tc.expected: step3. db not open, notify INVALID_PARAM
*/
PutSyncData(g_propA, KEY1, VALUE1);
PutSyncData(g_propA, KEY1, VALUE2);
std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME));
EXPECT_TRUE(observer->GetCallCount() == 0);
{
std::unique_lock<std::mutex> lock(g_cvMutex);
g_cv.wait(lock, [] {return g_finished;});
EXPECT_TRUE(g_statusMap[DBCommon::TransferHashString("--")] == INVALID_PARAM);
g_statusMap.clear();
g_finished = false;
}
RuntimeContext::GetInstance()->SetAutoLaunchRequestCallback(nullptr);
delete observer;
}
/**
* @tc.name: AutoLaunch010
* @tc.desc: enhancement nullptr callback
* @tc.type: FUNC
* @tc.require: AR000EPARJ
* @tc.author: wangchuanqing
*/
HWTEST_F(DistributedDBAutoLaunchUnitTest, AutoLaunch010, TestSize.Level3)
{
KvStoreObserverUnitTest *observer = new (std::nothrow) KvStoreObserverUnitTest;
ASSERT_TRUE(observer != nullptr);
/**
* @tc.steps: step1. SetAutoLaunchRequestCallback, then set nullptr
* @tc.expected: step1. success.
*/
RuntimeContext::GetInstance()->SetAutoLaunchRequestCallback(
std::bind(AutoLaunchCallBack, std::placeholders::_1, std::placeholders::_2, observer, false));
RuntimeContext::GetInstance()->SetAutoLaunchRequestCallback(nullptr);
/**
* @tc.steps: step2. RunCommunicatorLackCallback
* @tc.expected: step2. success.
*/
LabelType label(g_identifierA.begin(), g_identifierA.end());
g_communicatorAggregator->RunCommunicatorLackCallback(label);
std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME));
/**
* @tc.steps: step3. PutSyncData key1 value1
* @tc.expected: step3. db not open
*/
PutSyncData(g_propA, KEY1, VALUE1);
PutSyncData(g_propA, KEY1, VALUE2);
std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME));
EXPECT_TRUE(observer->GetCallCount() == 0);
EXPECT_TRUE(g_finished == false);
RuntimeContext::GetInstance()->SetAutoLaunchRequestCallback(nullptr);
delete observer;
}
/**
* @tc.name: AutoLaunch011
* @tc.desc: enhancement GetKvStoreIdentifier
* @tc.type: FUNC
* @tc.require: AR000EPARJ
* @tc.author: wangchuanqing
*/
HWTEST_F(DistributedDBAutoLaunchUnitTest, AutoLaunch011, TestSize.Level3)
{
EXPECT_EQ(KvStoreDelegateManager::GetKvStoreIdentifier("", APP_ID, STORE_ID_0), "");
EXPECT_EQ(KvStoreDelegateManager::GetKvStoreIdentifier(
USER_ID, APP_ID, STORE_ID_0), DBCommon::TransferHashString(USER_ID + "-" + APP_ID + "-" + STORE_ID_0));
}
/**
* @tc.name: AutoLaunch012
* @tc.desc: CommunicatorLackCallback
* @tc.type: FUNC
* @tc.require: AR000E8S2T
* @tc.author: wangchuanqing
*/
HWTEST_F(DistributedDBAutoLaunchUnitTest, AutoLaunch012, TestSize.Level3)
{
/**
* @tc.steps: step1. right param A B enable
* @tc.expected: step1. success.
*/
int errCode = RuntimeContext::GetInstance()->EnableKvStoreAutoLaunch(g_propA, TestAutoLaunchNotifier, nullptr,
CONFLICT_FOREIGN_KEY_ONLY, ConflictNotifierCallback);
EXPECT_TRUE(errCode == E_OK);
errCode = RuntimeContext::GetInstance()->EnableKvStoreAutoLaunch(g_propB, nullptr, nullptr, 0, nullptr);
EXPECT_TRUE(errCode == E_OK);
/**
* @tc.steps: step2. RunCommunicatorLackCallback
* @tc.expected: step2. success.
*/
LabelType label(g_identifierA.begin(), g_identifierA.end());
g_communicatorAggregator->RunCommunicatorLackCallback(label);
std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME));
PutSyncData(g_propA, KEY1, VALUE1);
{
std::unique_lock<std::mutex> lock(g_cvMutex);
g_cv.wait(lock, [] {return g_finished;});
EXPECT_TRUE(g_statusMap[g_identifierA] == WRITE_OPENED);
g_statusMap.clear();
g_finished = false;
}
/**
* @tc.steps: step3. PutSyncData key1 value2
* @tc.expected: step3. ConflictNotifierCallback
*/
PutSyncData(g_propA, KEY1, VALUE2);
{
std::unique_lock<std::mutex> lock(g_cvMutex);
g_cv.wait(lock, [] {return g_finished;});
g_finished = false;
}
/**
* @tc.steps: step4. wait life cycle ,db close
* @tc.expected: step4. notifier WRITE_CLOSED
*/
SetLifeCycleTime(g_propA);
{
std::unique_lock<std::mutex> lock(g_cvMutex);
g_cv.wait(lock, [] {return g_finished;});
EXPECT_TRUE(g_statusMap[g_identifierA] == WRITE_CLOSED);
g_statusMap.clear();
g_finished = false;
}
/**
* @tc.steps: step5. param A B disable
* @tc.expected: step5. OK
*/
errCode = RuntimeContext::GetInstance()->DisableKvStoreAutoLaunch(g_identifierB);
EXPECT_TRUE(errCode == E_OK);
errCode = RuntimeContext::GetInstance()->DisableKvStoreAutoLaunch(g_identifierA);
EXPECT_TRUE(errCode == E_OK);
}
/**
* @tc.name: AutoLaunch013
* @tc.desc: online callback
* @tc.type: FUNC
* @tc.require: AR000E8S2T
* @tc.author: wangchuanqing
*/
HWTEST_F(DistributedDBAutoLaunchUnitTest, AutoLaunch013, TestSize.Level3)
{
auto notifier = [] (const std::string &userId, const std::string &appId,
const std::string &storeId, AutoLaunchStatus status) {
LOGD("int AutoLaunch013 notifier status:%d", status);
};
/**
* @tc.steps: step1. right param b c enable, a SetAutoLaunchRequestCallback
* @tc.expected: step1. success.
*/
int errCode = RuntimeContext::GetInstance()->EnableKvStoreAutoLaunch(g_propB, notifier, nullptr, 0, nullptr);
EXPECT_TRUE(errCode == E_OK);
errCode = RuntimeContext::GetInstance()->EnableKvStoreAutoLaunch(g_propC, notifier, nullptr, 0, nullptr);
EXPECT_TRUE(errCode == E_OK);
KvStoreObserverUnitTest *observer = new (std::nothrow) KvStoreObserverUnitTest;
ASSERT_TRUE(observer != nullptr);
RuntimeContext::GetInstance()->SetAutoLaunchRequestCallback(
std::bind(AutoLaunchCallBack, std::placeholders::_1, std::placeholders::_2, observer, true));
/**
* @tc.steps: step2. RunOnConnectCallback RunCommunicatorLackCallback
* @tc.expected: step2. success.
*/
g_communicatorAggregator->RunOnConnectCallback(REMOTE_DEVICE_ID, true);
LabelType label(g_identifierA.begin(), g_identifierA.end());
g_communicatorAggregator->RunCommunicatorLackCallback(label);
std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME));
/**
* @tc.steps: step3. PutSyncData
* @tc.expected: step3. notifier WRITE_OPENED
*/
PutSyncData(g_propA, KEY1, VALUE1);
PutSyncData(g_propB, KEY1, VALUE1);
PutSyncData(g_propC, KEY1, VALUE1);
{
std::unique_lock<std::mutex> lock(g_cvMutex);
g_cv.wait(lock, [] {return g_finished;});
EXPECT_TRUE(g_statusMap[g_identifierA] == WRITE_OPENED);
g_statusMap.clear();
g_finished = false;
}
/**
* @tc.steps: step4. PutSyncData key1 value2
* @tc.expected: step4. ConflictNotifierCallback
*/
PutSyncData(g_propA, KEY1, VALUE2);
{
std::unique_lock<std::mutex> lock(g_cvMutex);
g_cv.wait(lock, [] {return g_finished;});
g_finished = false;
}
/**
* @tc.steps: step5. wait life cycle ,db close
* @tc.expected: step5. notifier WRITE_CLOSED
*/
SetLifeCycleTime(g_propA);
{
std::unique_lock<std::mutex> lock(g_cvMutex);
g_cv.wait(lock, [] {return g_finished;});
EXPECT_TRUE(g_statusMap[g_identifierA] == WRITE_CLOSED);
g_statusMap.clear();
g_finished = false;
}
RuntimeContext::GetInstance()->SetAutoLaunchRequestCallback(nullptr);
delete observer;
/**
* @tc.steps: step4. param A B disable
* @tc.expected: step4. notifier WRITE_CLOSED
*/
errCode = RuntimeContext::GetInstance()->DisableKvStoreAutoLaunch(g_identifierB);
EXPECT_TRUE(errCode == E_OK);
errCode = RuntimeContext::GetInstance()->DisableKvStoreAutoLaunch(g_identifierC);
EXPECT_TRUE(errCode == E_OK);
g_communicatorAggregator->RunOnConnectCallback(REMOTE_DEVICE_ID, false);
} | 37.731237 | 118 | 0.686665 | [
"vector"
] |
989f28e4caef654ac80ba043e4713c150b567b2c | 11,004 | cpp | C++ | wbsModels/EmeraldAshBorer/EmeraldAshBorerColdHardiness.cpp | RNCan/WeatherBasedSimulationFramework | 19df207d11b1dddf414d78e52bece77f31d45df8 | [
"MIT"
] | 6 | 2017-05-26T21:19:41.000Z | 2021-09-03T14:17:29.000Z | wbsModels/EmeraldAshBorer/EmeraldAshBorerColdHardiness.cpp | RNCan/WeatherBasedSimulationFramework | 19df207d11b1dddf414d78e52bece77f31d45df8 | [
"MIT"
] | 5 | 2016-02-18T12:39:58.000Z | 2016-03-13T12:57:45.000Z | wbsModels/EmeraldAshBorer/EmeraldAshBorerColdHardiness.cpp | RNCan/WeatherBasedSimulationFramework | 19df207d11b1dddf414d78e52bece77f31d45df8 | [
"MIT"
] | 1 | 2019-06-16T02:49:20.000Z | 2019-06-16T02:49:20.000Z | //**************************************************************************************************************
// 20/03/2019 1.0.2 Rémi Saint-Amant new equation of mortality based on logistic model
// 13/04/2018 1.0.1 Rémi Saint-Amant Compile with VS 2017
// 08/05/2017 1.0.0 Rémi Saint-Amant Create from articles Cuddington 2018
//**************************************************************************************************************
#include "ModelBase/EntryPoint.h"
#include "ModelBase/ContinuingRatio.h"
#include "EmeraldAshBorerColdHardiness.h"
#include "TreeMicroClimate.h"
using namespace std;
using namespace WBSF::HOURLY_DATA;
namespace WBSF
{
//links this class with the EntryPoint of the DLL
static const bool bRegistred =
CModelFactory::RegisterModel(CEmeraldAshBorerColdHardinessModel::CreateObject);
enum TColdHardinessH { O_TAIR, O_TBARK, O_H_WT, O_H_SCP, O_H_MORTALITY, O_H_DIFF_TMIN_SCP, NB_OUTPUTS_H };
enum TColdHardinessD { O_TMIN, O_TBARK_MIN, O_D_WT, O_D_SCP, O_D_MORTALITY, O_D_DIFF_TMIN_SCP, NB_OUTPUTS_D };
enum TColdHardinessA { O_A_TMIN, O_A_TBARK_MIN_L, O_A_TBARK_MIN_N, O_A_MORTALITY_L, O_A_MORTALITY_N, NB_OUTPUTS_A };
extern const char HEADER_H[] = "Tair,Tbark,wT,MDT,SCP,mortality";
extern const char HEADER_D[] = "Tmin,Tmax,Tbmin,Tbmax,wT,MDT,SCP,mortality";
extern const char HEADER_A[] = "TairMin,TbarkMinLinear,TbarkMinNonlinear,MortalityLinear,MortalityNonlinear";
CEmeraldAshBorerColdHardinessModel::CEmeraldAshBorerColdHardinessModel()
{
NB_INPUT_PARAMETER = -1;
VERSION = "1.0.2 (2019)";
m_n_Δt = 88;
m_λ = 0.0635;
m_wTº = 6.4;
m_wTmin = -8.2;
m_SCPᶫ = -37;
m_SCPᴴ = -14;//by Venette
}
CEmeraldAshBorerColdHardinessModel::~CEmeraldAshBorerColdHardinessModel()
{}
//this method is called to load the generic parameters vector into the specific class member
ERMsg CEmeraldAshBorerColdHardinessModel::ProcessParameters(const CParameterVector& parameters)
{
ERMsg msg;
size_t c = 0;
if (parameters.size() == 6)
{
m_n_Δt = parameters[c++].GetInt();
m_λ = parameters[c++].GetReal();
m_wTº = parameters[c++].GetReal();
m_wTmin = parameters[c++].GetReal();
m_SCPᶫ = parameters[c++].GetReal();
m_SCPᴴ = parameters[c++].GetReal();
}
return msg;
}
ERMsg CEmeraldAshBorerColdHardinessModel::OnExecuteAnnual()
{
ERMsg msg;
if (!m_weather.IsHourly())
m_weather.ComputeHourlyVariables();
ASSERT(m_weather.IsHourly());
m_output.Init(m_weather.GetEntireTPeriod(CTM::ANNUAL), NB_OUTPUTS_A, -999, HEADER_A);
for (size_t y = 1; y < m_weather.GetNbYears(); y++)
{
CTPeriod p = CTPeriod(CTRef(m_weather[y - 1].GetTRef().GetYear(), SEPTEMBER, FIRST_DAY, FIRST_HOUR), CTRef(m_weather[y].GetTRef().GetYear(), APRIL, LAST_DAY, LAST_HOUR));
CStatistic statA;
statA += m_weather[y - 1].GetStat(H_TMIN, p);
statA += m_weather[y].GetStat(H_TMIN, p);
double Tmin = statA[LOWEST];
m_output[y][O_A_TMIN] = Tmin;
m_output[y][O_A_TBARK_MIN_L] = Tair2Tbark(LINEAR, Tmin);
m_output[y][O_A_TBARK_MIN_N] = Tair2Tbark(NONLINEAR, Tmin);
m_output[y][O_A_MORTALITY_L] = Tbark2MortalityLogistic(m_output[y][O_A_TBARK_MIN_L]) * 100;
m_output[y][O_A_MORTALITY_N] = Tbark2MortalityLogistic(m_output[y][O_A_TBARK_MIN_N]) * 100;
}
return msg;
}
double get_w(int Δt, double a0)
{
double w = (1.0 / (1.0 + exp(-a0 * Δt)));
return w;
}
double get_wT(CModelStatVector& output, CTRef TRef, int n_Δt, double a0)
{
assert(TRef.GetTM().Type() == CTM::HOURLY);
assert(n_Δt > 0);
CStatistic T;
CStatistic W;
for (int Δt = -n_Δt; Δt <= 0; Δt++)
{
double w = 1.0 / n_Δt;
W += w;
T += w * output[TRef + Δt][O_TBARK];
}
double wT = W[SUM] > 0 ? T[SUM] / W[SUM] : -999;
return wT;
}
double get_SCP(double wT, double wTº, double λ, double SCPᶫ, double SCPᴴ)
{
ASSERT(SCPᶫ <= SCPᴴ);
double ΔSCP = SCPᴴ - SCPᶫ;
double SCP = SCPᶫ + ΔSCP * (1.0 / (1.0 + exp(-λ * (wT - wTº))));
return SCP;
}
void CEmeraldAshBorerColdHardinessModel::ExecuteDaily(CModelStatVector& outputD)
{
CModelStatVector outputH;
ExecuteHourly(outputH);
//transform hourly results into daily results
CTStatMatrix stats(outputH, CTM::DAILY);
outputD.Init(stats.m_period, NB_OUTPUTS_D, -999, HEADER_D);
for (CTRef TRef = stats.m_period.Begin(); TRef <= stats.m_period.End(); TRef++)
{
outputD[TRef][O_TMIN] = stats[TRef][O_TAIR][LOWEST];
outputD[TRef][O_TBARK_MIN] = stats[TRef][O_TBARK][LOWEST];
outputD[TRef][O_D_WT] = stats[TRef][O_H_WT][MEAN];
outputD[TRef][O_D_SCP] = stats[TRef][O_H_SCP][MEAN];
outputD[TRef][O_D_MORTALITY] = stats[TRef][O_H_MORTALITY][MEAN];
if (stats[TRef][O_TBARK].IsInit() && stats[TRef][O_H_SCP].IsInit())
outputD[TRef][O_D_DIFF_TMIN_SCP] = stats[TRef][O_TBARK][LOWEST] - stats[TRef][O_H_SCP][LOWEST];
}
}
CTRef GetLoTRef(CTPeriod p, CModelStatVector& output)
{
//get the minimum date pof the 28 days's mean
CTRef loTRef;
double lo_wT = 999;
for (CTRef TRef = p.Begin(); TRef <= p.End(); TRef++)
{
double wT = get_wT(output, TRef, 672, 0);
if (wT < lo_wT)
{
lo_wT = wT;
loTRef = TRef;
}
}
return loTRef;
}
double CEmeraldAshBorerColdHardinessModel::Tair2Tbark(TTUBark type, double Tair)
{
double Tbark = Tair;
//Annual bark temperature. Only valid lower -17.
if (Tair <= -17)
{
switch (type)
{
case LINEAR:Tbark = -2.38 + 0.747*Tair; break;
case NONLINEAR:Tbark = -44.6 + 62.4*exp(0.0398*Tair); break;
default: ASSERT(false);
}
}
return Tbark;
}
double CEmeraldAshBorerColdHardinessModel::Tbark2MortalityLogistic(double Tbark)
{
//calibrated with R by nls
static const double k = 2.013E-4;
static const double x0 = -2.418E4;
return 1.0 - 1.0 / (1.0 + exp(-(k * (pow(Tbark, 3.0) - x0))));
}
void CEmeraldAshBorerColdHardinessModel::ExecuteHourly(CModelStatVector& output)
{
if (!m_weather.IsHourly())
m_weather.ComputeHourlyVariables();
ASSERT(m_weather.IsHourly());
output.Init(m_weather.GetEntireTPeriod(), NB_OUTPUTS_H, -999, HEADER_H);
CTPeriod p = m_weather.GetEntireTPeriod(CTM::HOURLY);
//first step: compute Tair and Tbark from regression
for (CTRef TRef = p.Begin(); TRef <= p.End(); TRef++)
{
const CHourlyData& w = m_weather.GetHour(TRef);
double Tair = w[H_TAIR];
double Tbark = Tair2Tbark(NONLINEAR, Tair);//use nonlinear by default
output[TRef][O_TAIR] = Tair;
output[TRef][O_TBARK] = Tbark;
}
//second step: compute SCP and mortality
for (size_t y = 0; y < p.GetNbYears() - 1; y++)
{
CTPeriod p2 = CTPeriod(CTRef(m_weather[y].GetTRef().GetYear(), SEPTEMBER, FIRST_DAY, FIRST_HOUR), CTRef(m_weather[y + 1].GetTRef().GetYear(), APRIL, LAST_DAY, LAST_HOUR));
CTRef lowTRef = GetLoTRef(p2, output);
double cur_wT = get_wT(output, p2.Begin(), m_n_Δt, 0);
double cur_SCP = m_SCPᴴ;
double ΣwT = 0;
double mortality = 0;
TPhase phase = ACCLIMATATION;
for (CTRef TRef = p2.Begin(); TRef <= p2.End(); TRef++)
{
double wT = get_wT(output, TRef, m_n_Δt, 0);
wT = max(m_wTmin, wT);
double SCP = get_SCP(wT, m_wTº, m_λ, m_SCPᶫ, m_SCPᴴ);
cur_SCP = (phase == ACCLIMATATION) ? min(cur_SCP, SCP) : max(cur_SCP, SCP);
mortality = max(mortality, Tbark2MortalityLogistic(output[TRef][O_TBARK]));
if (phase == ACCLIMATATION && TRef >= lowTRef)
{
phase = DESACCLIMATATION;
}
output[TRef][O_H_WT] = wT;
output[TRef][O_H_SCP] = cur_SCP;
output[TRef][O_H_MORTALITY] = mortality * 100;
output[TRef][O_H_DIFF_TMIN_SCP] = output[TRef][O_TBARK] - output[TRef][O_H_SCP];
}//for all hours during the winter
}//for all years
}
//*****************************************************************************************************************
//Next 4 methods are for Simulated Annealing
enum TInput { I_SITE, I_YEAR, I_MONTH, I_DAY };
enum TInputCrosthwaite { Cr_SCP = I_DAY + 1, Cr_SCP_SME, NB_CROSTHWAITE_COLUMNS };
enum TInputChistianson { Ch_N = I_DAY + 1, Ch_SCP_MIN, CH_SCP_MEDIAN, Ch_SCP_MEAN, Ch_SCP_SME, NB_CHRISTIANSON_COLUMNS };
void CEmeraldAshBorerColdHardinessModel::AddDailyResult(const StringVector& header, const StringVector& data)
{
if (header.size() == 3)
{
std::vector<double> obs(3);
for (size_t i = 0; i < obs.size(); i++)
obs[i] = ToDouble(data[i]);
m_SAResult.push_back(CSAResult(CTRef(0, 0, 0, 0, CTM::ATEMPORAL), obs));
}
else if (header.size() == NB_CROSTHWAITE_COLUMNS)
{
CTRef TRef(ToInt(data[I_YEAR]), ToSizeT(data[I_MONTH]) - 1, ToSizeT(data[I_DAY]) - 1);
std::vector<double> obs(NB_CROSTHWAITE_COLUMNS);
for (size_t i = 0; i < obs.size(); i++)
obs[i] = ToDouble(data[i]);
m_SAResult.push_back(CSAResult(TRef, obs));
}
else if (header.size() == NB_CHRISTIANSON_COLUMNS)
{
std::vector<double> obs(NB_CHRISTIANSON_COLUMNS);
for (size_t i = 0; i < obs.size(); i++)
obs[i] = ToDouble(data[i]);
CTRef TRef(ToInt(data[I_YEAR]), ToSizeT(data[I_MONTH]) - 1, ToSizeT(data[I_DAY]) - 1);
m_SAResult.push_back(CSAResult(TRef, obs));
}
}
double CEmeraldAshBorerColdHardinessModel::logistic(double x, double k, double x0)
{
return 1.0 - 1.0 / (1.0 + exp(-(k * (pow(x, 3.0) - x0))));
}
double CEmeraldAshBorerColdHardinessModel::Logistic(double x, double K, double A, double R, double x0)
{
return (K*(1 / (1 + A * exp(-R * (x - x0)))));
}
double CEmeraldAshBorerColdHardinessModel::Weibull(double x, double k, double y, double x0)
{
return exp(-pow(max(0.0, (x - x0)) / y, k));
}
double CEmeraldAshBorerColdHardinessModel::SShaped(double x, double p, double k, double x0)
{
return (1.0 - 1.0 / (1.0 + exp(-k * pow(x - x0, p))));
}
void CEmeraldAshBorerColdHardinessModel::GetFValueDaily(CStatisticXY& stat)
{
ERMsg msg;
if (!m_weather.IsHourly())
m_weather.ComputeHourlyVariables();
if (m_SAResult.size() > 0)
{
if (m_SAResult[0].m_obs.size() == 3)
{
for (size_t i = 0; i < m_SAResult.size(); i++)
{
double obsV = m_SAResult[i].m_obs[2];
double simV = logistic(m_SAResult[i].m_obs[1], m_λ, m_wTº);
stat.Add(obsV, simV);
}
return;
}
//now compare simulation with observation data
if (m_SAResult[0].m_obs.size() == NB_CROSTHWAITE_COLUMNS)
{
CModelStatVector sim;
ExecuteDaily(sim);
for (size_t i = 0; i < m_SAResult.size(); i++)
{
if (m_SAResult[i].m_obs[Cr_SCP] > -999 &&
sim.IsInside(m_SAResult[i].m_ref))
{
double obsV = m_SAResult[i].m_obs[Cr_SCP];
double simV = sim[m_SAResult[i].m_ref][O_D_SCP];
stat.Add(simV, obsV);
}
}
}
}
}
} | 29.660377 | 175 | 0.630044 | [
"vector",
"model",
"transform"
] |
f0f9490805e26e547e86b152eb464d0b0ec1be48 | 4,967 | cpp | C++ | src/gui_algorithm/GuiAlgorithm.cpp | vakokako/play_cpp | ae7d9aa63d94e033a646df28206428231ae6e134 | [
"Unlicense"
] | null | null | null | src/gui_algorithm/GuiAlgorithm.cpp | vakokako/play_cpp | ae7d9aa63d94e033a646df28206428231ae6e134 | [
"Unlicense"
] | null | null | null | src/gui_algorithm/GuiAlgorithm.cpp | vakokako/play_cpp | ae7d9aa63d94e033a646df28206428231ae6e134 | [
"Unlicense"
] | null | null | null | // #include "GuiQt.hpp"
#include <QApplication>
#include <QDoubleSpinBox>
#include <QHBoxLayout>
#include <QLabel>
#include <QVBoxLayout>
#include <QWidget>
#include <iostream>
#include <tuple>
template <auto... T>
class ptype;
template <class T>
struct Property {
using ValueT = T;
// explicit Property(std::string aName) : name(std::move(aName)) {}
const std::string name;
T value;
};
template <class T>
auto* toWidget(const Property<T>& aProperty)
{
if constexpr (std::is_same_v<T, int>) {
auto* vSpinBox = new QSpinBox();
vSpinBox->setValue(aProperty.value);
auto* vWidget = new QWidget();
vWidget->setLayout(new QHBoxLayout());
vWidget->layout()->addWidget(
new QLabel(QString::fromStdString(aProperty.name)));
vWidget->layout()->addWidget(vSpinBox);
return vWidget;
} else {
return new QWidget();
}
}
template <class Alg, class = void>
struct has_properties : std::false_type {
};
template <class Alg>
struct has_properties<Alg,
std::void_t<decltype(std::declval<Alg>().properties())>>
: std::true_type {
};
template <class Alg>
constexpr bool has_properties_v = has_properties<Alg>::value;
template <class Alg, class = void>
struct has_algorithms : std::false_type {
};
template <class Alg>
struct has_algorithms<Alg,
std::void_t<decltype(std::declval<Alg>().algorithms())>>
: std::true_type {
};
template <class Alg>
constexpr bool has_algorithms_v = has_algorithms<Alg>::value;
template <class Derived>
struct Algorithm {
Derived& derived_cast() { return static_cast<Derived&>(*this); }
const Derived& derived_cast() const
{
return static_cast<const Derived&>(*this);
}
const auto& name() const { return derived_cast()._name; }
};
template <class Alg>
auto* toWidget(Algorithm<Alg>& aAlg)
{
auto& vAlgDerived = aAlg.derived_cast();
auto* vWidget = new QWidget();
vWidget->setObjectName(QString::fromStdString(vAlgDerived.name()));
vWidget->setStyleSheet(
QString::fromStdString("QWidget#" + vAlgDerived.name()
+ "{border:1px solid rgb(255, 0, 0);}"));
vWidget->setLayout(new QVBoxLayout());
vWidget->layout()->addWidget(
new QLabel(QString::fromStdString(vAlgDerived.name())));
if constexpr (has_properties_v<Alg>) {
std::apply(
[&](auto&&... aProperty) {
((vWidget->layout()->addWidget(toWidget(aProperty))), ...);
},
vAlgDerived.properties());
}
if constexpr (has_algorithms_v<Alg>) {
std::apply(
[&](auto&&... aAlgorithm) {
((vWidget->layout()->addWidget(toWidget(aAlgorithm))), ...);
},
vAlgDerived.algorithms());
}
return vWidget;
}
struct Alg1 : Algorithm<Alg1> {
friend Algorithm<Alg1>;
Property<int> size{"size", 0};
auto properties() { return std::tie(size); }
private:
const std::string _name{"Alg1"};
};
struct Alg2 : Algorithm<Alg2> {
friend Algorithm<Alg2>;
Property<int> count{"count", 0};
auto properties() { return std::tie(count); }
private:
const std::string _name{"Alg2"};
};
struct Alg3 : Algorithm<Alg3> {
friend Algorithm<Alg3>;
Property<int> size{"size", 0};
Property<int> count{"count", 0};
auto properties() { return std::tie(size, count); }
Alg1 alg1;
Alg2 alg2;
auto algorithms() { return std::tie(alg1, alg2); }
private:
const std::string _name{"Alg3"};
};
template <class Tuple1, class Tuple2, class F, std::size_t... I>
void for_each2_impl(Tuple1&& t1, Tuple2&& t2, F&& f, std::index_sequence<I...>)
{
(void)std::initializer_list<int>{
(std::forward<F>(f)(std::get<I>(std::forward<Tuple1>(t1)),
std::get<I>(std::forward<Tuple2>(t2))),
0)...};
}
template <class Tuple1, class Tuple2, class F>
constexpr void for_each2(Tuple1&& t1, Tuple2&& t2, F&& f)
{
for_each2_impl(
std::forward<Tuple1>(t1), std::forward<Tuple2>(t2), std::forward<F>(f),
std::make_index_sequence<
std::tuple_size<std::remove_reference_t<Tuple1>>::value>{});
}
int main(int argc, char* argv[])
{
auto tuple1 = std::make_tuple(1, std::string{"two"});
auto tuple2 = std::make_tuple(std::string{"one"}, 2);
for_each2(tuple1, tuple2,
[](auto&& i, auto&& s) { std::cout << i << '-' << s << '\n'; });
QApplication app(argc, argv);
QWidget dialog;
dialog.setLayout(new QVBoxLayout());
Alg3 alg;
std::apply(
[&](auto&&... aProperty) {
((std::cout << aProperty.name << "\n"), ...);
},
alg.properties());
dialog.layout()->addWidget(toWidget(alg));
dialog.show();
return QApplication::exec(); // this runs the main event loop and sees to
// it that cleanup is done
}
| 27.748603 | 79 | 0.60157 | [
"solid"
] |
f0fa255285658bf239ed69ae9c914efbc3b7c38d | 13,454 | cpp | C++ | lib/Common/Memory/RecyclerSweep.cpp | P1umer/ChakraCore | 6b471d9b9096ded789a924bc7f0518bbb000c320 | [
"MIT"
] | 3 | 2018-08-08T03:36:56.000Z | 2019-05-24T08:45:30.000Z | lib/Common/Memory/RecyclerSweep.cpp | P1umer/ChakraCore | 6b471d9b9096ded789a924bc7f0518bbb000c320 | [
"MIT"
] | 19 | 2019-03-15T17:40:15.000Z | 2019-03-20T18:26:35.000Z | lib/Common/Memory/RecyclerSweep.cpp | P1umer/ChakraCore | 6b471d9b9096ded789a924bc7f0518bbb000c320 | [
"MIT"
] | 6 | 2018-09-07T05:16:47.000Z | 2021-03-23T20:30:38.000Z | //-------------------------------------------------------------------------------------------------------
// Copyright (C) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
//-------------------------------------------------------------------------------------------------------
#include "CommonMemoryPch.h"
RecyclerSweepManager *
RecyclerSweep::GetManager() const
{
return this->recyclerSweepManager;
}
bool
RecyclerSweep::IsBackground() const
{
return GetManager()->IsBackground();
}
Recycler *
RecyclerSweep::GetRecycler() const
{
return recycler;
}
void
RecyclerSweep::BeginSweep(Recycler * recycler, RecyclerSweepManager * recyclerSweepManager, HeapInfo * heapInfo)
{
// RecyclerSweep may not be initialized till later in this function but
// GCETW relies on the recycler pointer being correctly set up
this->recycler = recycler;
this->recyclerSweepManager = recyclerSweepManager;
this->heapInfo = heapInfo;
// We might still have block that has disposed but not put back into the allocable
// heap block list yet, which happens if we finish disposing object during concurrent
// reset mark and can't
// modify the heap block lists
// CONCURRENT-TODO: Consider doing it during FinishDisposeObjects to get these block
// available sooner as well. We will still need it here as we only always get to
// finish dispose before sweep.
this->FlushPendingTransferDisposedObjects();
#if ENABLE_CONCURRENT_GC
// Take the small heap block new heap block list and store in RecyclerSweep temporary
// We get merge later before we start sweeping the bucket.
leafData.pendingMergeNewHeapBlockList = heapInfo->newLeafHeapBlockList;
normalData.pendingMergeNewHeapBlockList = heapInfo->newNormalHeapBlockList;
#ifdef RECYCLER_WRITE_BARRIER
withBarrierData.pendingMergeNewHeapBlockList = heapInfo->newNormalWithBarrierHeapBlockList;
finalizableWithBarrierData.pendingMergeNewHeapBlockList = heapInfo->newFinalizableWithBarrierHeapBlockList;
#endif
finalizableData.pendingMergeNewHeapBlockList = heapInfo->newFinalizableHeapBlockList;
#ifdef RECYCLER_VISITED_HOST
recyclerVisitedHostData.pendingMergeNewHeapBlockList = heapInfo->newRecyclerVisitedHostHeapBlockList;
#endif
mediumLeafData.pendingMergeNewHeapBlockList = heapInfo->newMediumLeafHeapBlockList;
mediumNormalData.pendingMergeNewHeapBlockList = heapInfo->newMediumNormalHeapBlockList;
#ifdef RECYCLER_WRITE_BARRIER
mediumWithBarrierData.pendingMergeNewHeapBlockList = heapInfo->newMediumNormalWithBarrierHeapBlockList;
mediumFinalizableWithBarrierData.pendingMergeNewHeapBlockList = heapInfo->newMediumFinalizableWithBarrierHeapBlockList;
#endif
mediumFinalizableData.pendingMergeNewHeapBlockList = heapInfo->newMediumFinalizableHeapBlockList;
#ifdef RECYCLER_VISITED_HOST
mediumRecyclerVisitedHostData.pendingMergeNewHeapBlockList = heapInfo->newMediumRecyclerVisitedHostHeapBlockList;
#endif
heapInfo->newLeafHeapBlockList = nullptr;
heapInfo->newNormalHeapBlockList = nullptr;
heapInfo->newFinalizableHeapBlockList = nullptr;
#ifdef RECYCLER_VISITED_HOST
heapInfo->newRecyclerVisitedHostHeapBlockList = nullptr;
#endif
#ifdef RECYCLER_WRITE_BARRIER
heapInfo->newNormalWithBarrierHeapBlockList = nullptr;
heapInfo->newFinalizableWithBarrierHeapBlockList = nullptr;
#endif
heapInfo->newMediumLeafHeapBlockList = nullptr;
heapInfo->newMediumNormalHeapBlockList = nullptr;
heapInfo->newMediumFinalizableHeapBlockList = nullptr;
#ifdef RECYCLER_VISITED_HOST
heapInfo->newMediumRecyclerVisitedHostHeapBlockList = nullptr;
#endif
#ifdef RECYCLER_WRITE_BARRIER
heapInfo->newMediumNormalWithBarrierHeapBlockList = nullptr;
heapInfo->newMediumFinalizableWithBarrierHeapBlockList = nullptr;
#endif
#endif
}
void
RecyclerSweep::ShutdownCleanup()
{
// REVIEW: Does this need to be controlled more granularly, say with ENABLE_PARTIAL_GC?
#if ENABLE_CONCURRENT_GC
SmallLeafHeapBucketT<SmallAllocationBlockAttributes>::DeleteHeapBlockList(this->leafData.pendingMergeNewHeapBlockList, recycler);
SmallNormalHeapBucket::DeleteHeapBlockList(this->normalData.pendingMergeNewHeapBlockList, recycler);
#ifdef RECYCLER_WRITE_BARRIER
SmallNormalWithBarrierHeapBucket::DeleteHeapBlockList(this->withBarrierData.pendingMergeNewHeapBlockList, recycler);
SmallFinalizableWithBarrierHeapBucket::DeleteHeapBlockList(this->finalizableWithBarrierData.pendingMergeNewHeapBlockList, recycler);
#endif
SmallFinalizableHeapBucket::DeleteHeapBlockList(this->finalizableData.pendingMergeNewHeapBlockList, recycler);
for (uint i = 0; i < HeapConstants::BucketCount; i++)
{
// For leaf, we can always reuse the page as we don't need to rescan them for partial GC
// It should have been swept immediately during Sweep
Assert(this->leafData.bucketData[i].pendingSweepList == nullptr);
SmallNormalHeapBucket::DeleteHeapBlockList(this->normalData.bucketData[i].pendingSweepList, recycler);
SmallFinalizableHeapBucket::DeleteHeapBlockList(this->finalizableData.bucketData[i].pendingSweepList, recycler);
#ifdef RECYCLER_WRITE_BARRIER
SmallFinalizableWithBarrierHeapBucket::DeleteHeapBlockList(this->finalizableWithBarrierData.bucketData[i].pendingSweepList, recycler);
#endif
SmallLeafHeapBucket::DeleteEmptyHeapBlockList(this->leafData.bucketData[i].pendingEmptyBlockList);
SmallNormalHeapBucket::DeleteEmptyHeapBlockList(this->normalData.bucketData[i].pendingEmptyBlockList);
#ifdef RECYCLER_WRITE_BARRIER
SmallNormalWithBarrierHeapBucket::DeleteEmptyHeapBlockList(this->withBarrierData.bucketData[i].pendingEmptyBlockList);
Assert(this->finalizableWithBarrierData.bucketData[i].pendingEmptyBlockList == nullptr);
#endif
Assert(this->finalizableData.bucketData[i].pendingEmptyBlockList == nullptr);
}
MediumLeafHeapBucket::DeleteHeapBlockList(this->mediumLeafData.pendingMergeNewHeapBlockList, recycler);
MediumNormalHeapBucket::DeleteHeapBlockList(this->mediumNormalData.pendingMergeNewHeapBlockList, recycler);
#ifdef RECYCLER_WRITE_BARRIER
MediumNormalWithBarrierHeapBucket::DeleteHeapBlockList(this->mediumWithBarrierData.pendingMergeNewHeapBlockList, recycler);
MediumFinalizableWithBarrierHeapBucket::DeleteHeapBlockList(this->mediumFinalizableWithBarrierData.pendingMergeNewHeapBlockList, recycler);
#endif
MediumFinalizableHeapBucket::DeleteHeapBlockList(this->mediumFinalizableData.pendingMergeNewHeapBlockList, recycler);
for (uint i = 0; i < HeapConstants::MediumBucketCount; i++)
{
// For leaf, we can always reuse the page as we don't need to rescan them for partial GC
// It should have been swept immediately during Sweep
Assert(this->mediumLeafData.bucketData[i].pendingSweepList == nullptr);
MediumNormalHeapBucket::DeleteHeapBlockList(this->mediumNormalData.bucketData[i].pendingSweepList, recycler);
MediumFinalizableHeapBucket::DeleteHeapBlockList(this->mediumFinalizableData.bucketData[i].pendingSweepList, recycler);
#ifdef RECYCLER_WRITE_BARRIER
MediumFinalizableWithBarrierHeapBucket::DeleteHeapBlockList(this->mediumFinalizableWithBarrierData.bucketData[i].pendingSweepList, recycler);
#endif
MediumLeafHeapBucket::DeleteEmptyHeapBlockList(this->mediumLeafData.bucketData[i].pendingEmptyBlockList);
MediumNormalHeapBucket::DeleteEmptyHeapBlockList(this->mediumNormalData.bucketData[i].pendingEmptyBlockList);
#ifdef RECYCLER_WRITE_BARRIER
MediumNormalWithBarrierHeapBucket::DeleteEmptyHeapBlockList(this->mediumWithBarrierData.bucketData[i].pendingEmptyBlockList);
Assert(this->mediumFinalizableWithBarrierData.bucketData[i].pendingEmptyBlockList == nullptr);
#endif
Assert(this->mediumFinalizableData.bucketData[i].pendingEmptyBlockList == nullptr);
}
#endif
}
void
RecyclerSweep::FlushPendingTransferDisposedObjects()
{
if (this->heapInfo->hasPendingTransferDisposedObjects)
{
// If recycler->inResolveExternalWeakReferences is true, the recycler isn't really disposing anymore
// so it's safe to call transferDisposedObjects
Assert(!recycler->inDispose || recycler->inResolveExternalWeakReferences);
Assert(!recycler->hasDisposableObject);
heapInfo->TransferDisposedObjects();
}
}
#if ENABLE_CONCURRENT_GC
template <typename TBlockType>
void
RecyclerSweep::MergePendingNewHeapBlockList()
{
TBlockType *& blockList = this->GetData<TBlockType>().pendingMergeNewHeapBlockList;
TBlockType * list = blockList;
blockList = nullptr;
HeapBlockList::ForEachEditing(list, [this](TBlockType * heapBlock)
{
auto& bucket = this->heapInfo->GetBucket<TBlockType::RequiredAttributes>(heapBlock->GetObjectSize());
bucket.MergeNewHeapBlock(heapBlock);
});
}
template void RecyclerSweep::MergePendingNewHeapBlockList<SmallLeafHeapBlock>();
template void RecyclerSweep::MergePendingNewHeapBlockList<SmallNormalHeapBlock>();
template void RecyclerSweep::MergePendingNewHeapBlockList<SmallFinalizableHeapBlock>();
#ifdef RECYCLER_VISITED_HOST
template void RecyclerSweep::MergePendingNewHeapBlockList<SmallRecyclerVisitedHostHeapBlock>();
#endif
#ifdef RECYCLER_WRITE_BARRIER
template void RecyclerSweep::MergePendingNewHeapBlockList<SmallNormalWithBarrierHeapBlock>();
template void RecyclerSweep::MergePendingNewHeapBlockList<SmallFinalizableWithBarrierHeapBlock>();
#endif
template <typename TBlockType>
void
RecyclerSweep::MergePendingNewMediumHeapBlockList()
{
TBlockType *& blockList = this->GetData<TBlockType>().pendingMergeNewHeapBlockList;
TBlockType * list = blockList;
blockList = nullptr;
HeapBlockList::ForEachEditing(list, [this](TBlockType * heapBlock)
{
auto& bucket = this->heapInfo->GetMediumBucket<TBlockType::RequiredAttributes>(heapBlock->GetObjectSize());
bucket.MergeNewHeapBlock(heapBlock);
});
}
template void RecyclerSweep::MergePendingNewMediumHeapBlockList<MediumLeafHeapBlock>();
template void RecyclerSweep::MergePendingNewMediumHeapBlockList<MediumNormalHeapBlock>();
template void RecyclerSweep::MergePendingNewMediumHeapBlockList<MediumFinalizableHeapBlock>();
#ifdef RECYCLER_VISITED_HOST
template void RecyclerSweep::MergePendingNewMediumHeapBlockList<MediumRecyclerVisitedHostHeapBlock>();
#endif
#ifdef RECYCLER_WRITE_BARRIER
template void RecyclerSweep::MergePendingNewMediumHeapBlockList<MediumNormalWithBarrierHeapBlock>();
template void RecyclerSweep::MergePendingNewMediumHeapBlockList<MediumFinalizableWithBarrierHeapBlock>();
#endif
bool
RecyclerSweep::HasPendingEmptyBlocks() const
{
return this->hasPendingEmptyBlocks;
}
bool
RecyclerSweep::HasPendingSweepSmallHeapBlocks() const
{
return this->hasPendingSweepSmallHeapBlocks;
}
void
RecyclerSweep::SetHasPendingSweepSmallHeapBlocks()
{
this->hasPendingSweepSmallHeapBlocks = true;
}
#if DBG
bool
RecyclerSweep::HasPendingNewHeapBlocks() const
{
return leafData.pendingMergeNewHeapBlockList != nullptr
|| normalData.pendingMergeNewHeapBlockList != nullptr
|| finalizableData.pendingMergeNewHeapBlockList != nullptr
#ifdef RECYCLER_WRITE_BARRIER
|| withBarrierData.pendingMergeNewHeapBlockList != nullptr
|| finalizableWithBarrierData.pendingMergeNewHeapBlockList != nullptr
#endif
|| mediumLeafData.pendingMergeNewHeapBlockList != nullptr
|| mediumNormalData.pendingMergeNewHeapBlockList != nullptr
|| mediumFinalizableData.pendingMergeNewHeapBlockList != nullptr
#ifdef RECYCLER_WRITE_BARRIER
|| mediumWithBarrierData.pendingMergeNewHeapBlockList != nullptr
|| mediumFinalizableWithBarrierData.pendingMergeNewHeapBlockList != nullptr
#endif
;
}
#endif
#if DBG || defined(RECYCLER_SLOW_CHECK_ENABLED)
size_t
RecyclerSweep::GetPendingMergeNewHeapBlockCount(HeapInfo const * heapInfo)
{
if (this->heapInfo != heapInfo)
{
return 0;
}
return HeapBlockList::Count(leafData.pendingMergeNewHeapBlockList)
+ HeapBlockList::Count(normalData.pendingMergeNewHeapBlockList)
+ HeapBlockList::Count(finalizableData.pendingMergeNewHeapBlockList)
#ifdef RECYCLER_VISITED_HOST
+ HeapBlockList::Count(recyclerVisitedHostData.pendingMergeNewHeapBlockList)
+ HeapBlockList::Count(mediumRecyclerVisitedHostData.pendingMergeNewHeapBlockList)
#endif
#ifdef RECYCLER_WRITE_BARRIER
+ HeapBlockList::Count(withBarrierData.pendingMergeNewHeapBlockList)
+ HeapBlockList::Count(finalizableWithBarrierData.pendingMergeNewHeapBlockList)
#endif
+ HeapBlockList::Count(mediumLeafData.pendingMergeNewHeapBlockList)
+ HeapBlockList::Count(mediumNormalData.pendingMergeNewHeapBlockList)
+ HeapBlockList::Count(mediumFinalizableData.pendingMergeNewHeapBlockList)
#ifdef RECYCLER_WRITE_BARRIER
+ HeapBlockList::Count(mediumWithBarrierData.pendingMergeNewHeapBlockList)
+ HeapBlockList::Count(mediumFinalizableWithBarrierData.pendingMergeNewHeapBlockList)
#endif
;
}
#endif
#endif
#if ENABLE_PARTIAL_GC
bool
RecyclerSweep::InPartialCollectMode() const
{
return GetRecycler()->inPartialCollectMode;
}
bool
RecyclerSweep::InPartialCollect() const
{
return GetManager()->InPartialCollect();
}
#endif
| 43.96732 | 149 | 0.790248 | [
"object"
] |
f0fceae474c7b1f200b00c2d5be7751c836a20c0 | 4,480 | cpp | C++ | libmime/util/token.cpp | Jim-CodeHub/libMIME | 5027372f2d30f72f357af2ae8cc8525e7925de2c | [
"Apache-2.0"
] | 1 | 2020-05-13T04:23:28.000Z | 2020-05-13T04:23:28.000Z | libmime/util/token.cpp | Jim-CodeHub/libMIME | 5027372f2d30f72f357af2ae8cc8525e7925de2c | [
"Apache-2.0"
] | null | null | null | libmime/util/token.cpp | Jim-CodeHub/libMIME | 5027372f2d30f72f357af2ae8cc8525e7925de2c | [
"Apache-2.0"
] | 1 | 2022-02-24T20:02:48.000Z | 2022-02-24T20:02:48.000Z | /**-----------------------------------------------------------------------------------------------------------------
* @file token.cpp
* @brief token utility tool
*
* Copyright (c) 2019-2019 Jim Zhang 303683086@qq.com
*------------------------------------------------------------------------------------------------------------------
*/
#include <libmime/util/token.hpp>
using namespace NS_LIBMIME;
/*
--------------------------------------------------------------------------------------------------------------------
*
* FUNCTIONS IMPLEMENT
*
--------------------------------------------------------------------------------------------------------------------
*/
/**
* @brief Split string
* @param[in] str - the string to be splited
* @param[in] delim - delimiter
* @param[out] None
* @return None
* @note *** TO BE SURE param 'str' has certain size info, If str contain '\0'
**/
void string_token::set(const string &str, const string &delim)
{
string::size_type _inx_prev = 0, _inx_next = 0;
while (string::npos != (_inx_next = str.find(delim, _inx_prev)))
{
this->stoks.push_back(str.substr(_inx_prev, _inx_next - _inx_prev));
_inx_prev = _inx_next + delim.size();
}
if ((string::npos == _inx_next) && (0 == _inx_prev))
this->stoks.push_back(""); /**< Push the empty string */
else
this->stoks.push_back(str.substr(_inx_prev, _inx_next - _inx_prev)); /**< Push the last substring */
return;
}
string_token::string_token(const string &str, const string &delim)
{
this->set(str, delim);
}
/**
* @brief Split string (MAY BE oct that contain '\0')
* @param[in] str - the string to be splited
* @param[in] _size - size of split string
* @param[in] delim - delimiter
* @param[out] None
* @return None
**/
void string_token::set(const char *str, string::size_type _size, const string &delim)
{
string _str(str, _size);
this->set(_str, delim );
return;
}
string_token::string_token(const char *str, string::size_type _size, const string &delim)
{
this->set(str, _size, delim);
}
/**
* @brief Split string (MAY BE oct that contain '\0')
* @param[in] str - the string to be splited
* @param[in] _size - size of split string
* @param[in] delim - delimiter
* @param[in] _dsize - size of delimeter
* @param[out] None
* @return None
**/
void string_token::set(const char *str, string::size_type _size, const char *delim, string::size_type _dsize)
{
const char *_big = str, *_nxt = str;
while ((_size >= 0) && (_size >= _dsize))
{
if (0 == memcmp(_nxt, delim, _dsize))
{
string str_tok; str_tok.assign(_big, _nxt - _big);
this->stoks.push_back(str_tok);
_nxt += _dsize; _size -= _dsize; _big = _nxt;
continue;
}
_nxt++, _size--;
}
string str_tok(_big, _nxt + _size - _big);
this->stoks.push_back(str_tok);
return;
}
string_token::string_token(const char *str, string::size_type _size, const char *delim, string::size_type _dsize)
{
this->set(str, _size, delim, _dsize);
}
/**
* @brief Split string from delim into two part
* @param[in] str - the string to be splited
* @param[in] delim - delimiter
* @param[out] None
* @return None
* @note *** TO BE SURE param 'str' has certain size info, If str contain '\0'
**/
void string_token::cut(const string &str, const string &delim)
{
string::size_type _inx_prev = 0, _inx_next = 0;
if (string::npos != (_inx_next = str.find(delim, _inx_prev)))
{
this->stoks.push_back(str.substr(_inx_prev, _inx_next - _inx_prev));
_inx_prev = _inx_next + delim.size();
}
if ((string::npos == _inx_next) && (0 == _inx_prev))
this->stoks.push_back(""); /**< Push the empty string */
else
this->stoks.push_back(str.substr(_inx_prev, _inx_next - _inx_prev)); /**< Push the last substring */
return;
}
/**
* @brief Split string from delim into two part
* @param[in] str - the string to be splited
* @param[in] delim - delimiter
* @param[out] None
* @return None
**/
void string_token::cut(const char *str, string::size_type _size, const string &delim)
{
string _str(str, _size);
this->set(_str, delim );
return;
}
/**
* @brief Get string token from token vector
* @param[in] pos - position of string in vector
* @param[out] None
* @return split string OR ""
* @note
**/
const string string_token::get_stok(string::size_type pos) const noexcept
{
return (pos >= stoks.size())?"":stoks.at(pos);
}
| 26.826347 | 116 | 0.576563 | [
"vector"
] |
0b02a048af6f082014db180ff55f71031d28f2e0 | 1,574 | cpp | C++ | src/ai/sensor/camera/kinect/SimKinect.cpp | icaros-usc/wecook | 27bbb6b78a48e04765a87d33cc8a5d3748d2d4cc | [
"BSD-3-Clause"
] | 15 | 2019-09-15T05:24:19.000Z | 2021-02-26T20:31:19.000Z | src/ai/sensor/camera/kinect/SimKinect.cpp | icaros-usc/wecook | 27bbb6b78a48e04765a87d33cc8a5d3748d2d4cc | [
"BSD-3-Clause"
] | 16 | 2019-10-10T23:27:00.000Z | 2020-05-14T02:30:56.000Z | src/ai/sensor/camera/kinect/SimKinect.cpp | icaros-usc/wecook | 27bbb6b78a48e04765a87d33cc8a5d3748d2d4cc | [
"BSD-3-Clause"
] | 2 | 2020-02-01T16:31:29.000Z | 2020-04-07T21:00:04.000Z | //
// Created by hejia on 11/29/19.
//
#include "ai/sensor/camera/kinect/SimKinect.h"
void updateObjectPoses(const Eigen::Affine3d &tf) {
}
void updateTree() {
}
cv::Point3d wecook::ai::sensor::camera::kinect::SimKinect::projectPixelTo3dRay(const cv::Point2f &uv_rect) const {
cv::Point3d ray;
ray.x = (uv_rect.x - m_params.m_cx) / m_params.m_fx;
ray.y = (uv_rect.y - m_params.m_cy) / m_params.m_fy;
ray.z = 1.0;
return ray;
}
/// Function that intersects rays with the object model at current state
void wecook::ai::sensor::camera::kinect::SimKinect::intersect(const Eigen::Affine3d &tf) {
cv::Mat disp(m_params.m_h, m_params.m_w, CV_32FC1);
disp.setTo(m_invalidDisp);
// go through the whole image and create a ray from a pixel -> dir
std::vector<cv::Point3f> vec;
vec.reserve(m_params.m_h * m_params.m_w);
for (std::size_t c = 0; c < m_params.m_w; ++c) {
for (std::size_t r = 0; r < m_params.m_h; ++r) {
// compute ray from pixel and camera configuration
cv::Point3f ray = projectPixelTo3dRay(cv::Point2f(c, r));
// check if there is any intersection of the ray with the object by do_intersect
uint32_t reach_mesh = m_search->m_tree.do_intersect(
CGAL::Simple_cartesian<double>::Ray_3(
CGAL::Simple_cartesian<double>::Point_3(0., 0., 0.),
CGAL::Simple_cartesian<double>::Point_3(ray.x, ray.y, ray.z)));
if (reach_mesh) {
// TODO
}
}
}
}
void ::wecook::ai::sensor::camera::kinect::SimKinect::measure(const Eigen::Affine3d &tf) {
intersect(tf);
}
| 30.862745 | 114 | 0.660737 | [
"object",
"vector",
"model"
] |
0b032914000b4ff1f0f2ec6fbd318117629ef090 | 16,522 | hpp | C++ | CAX/gm_cloudauthx/bootil/src/3rdParty/stlencoders/base16.hpp | kurozael/project-archive | dcac1a9a8dee65c11f4a631ec08d6eef320f5ad0 | [
"MIT"
] | 13 | 2021-06-30T15:47:33.000Z | 2021-09-18T15:44:34.000Z | lib/GWEN-master/gwen/src/3rdParty/stlencoders/base16.hpp | mpavlinsky/bobsgame | dd4c0713828594ef601c61785164b3fa41e27e2a | [
"Unlicense"
] | null | null | null | lib/GWEN-master/gwen/src/3rdParty/stlencoders/base16.hpp | mpavlinsky/bobsgame | dd4c0713828594ef601c61785164b3fa41e27e2a | [
"Unlicense"
] | 7 | 2021-06-30T17:14:41.000Z | 2021-10-14T01:41:18.000Z | /*
* Copyright (c) 2011, 2012 Thomas Kemmer <tkemmer@computer.org>
*
* 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.
*/
#ifndef STLENCODERS_BASE16_HPP
#define STLENCODERS_BASE16_HPP
#include "error.hpp"
#include "lookup.hpp"
#include "traits.hpp"
/**
* @file
*
* Implementation of the Base16 encoding scheme.
*/
namespace stlencoders {
namespace detail {
template<char C> struct base16_table { enum { value = 0x10 }; };
template<> struct base16_table<'0'> { enum { value = 0x00 }; };
template<> struct base16_table<'1'> { enum { value = 0x01 }; };
template<> struct base16_table<'2'> { enum { value = 0x02 }; };
template<> struct base16_table<'3'> { enum { value = 0x03 }; };
template<> struct base16_table<'4'> { enum { value = 0x04 }; };
template<> struct base16_table<'5'> { enum { value = 0x05 }; };
template<> struct base16_table<'6'> { enum { value = 0x06 }; };
template<> struct base16_table<'7'> { enum { value = 0x07 }; };
template<> struct base16_table<'8'> { enum { value = 0x08 }; };
template<> struct base16_table<'9'> { enum { value = 0x09 }; };
template<> struct base16_table<'A'> { enum { value = 0x0a }; };
template<> struct base16_table<'B'> { enum { value = 0x0b }; };
template<> struct base16_table<'C'> { enum { value = 0x0c }; };
template<> struct base16_table<'D'> { enum { value = 0x0d }; };
template<> struct base16_table<'E'> { enum { value = 0x0e }; };
template<> struct base16_table<'F'> { enum { value = 0x0f }; };
template<> struct base16_table<'a'> { enum { value = base16_table<'A'>::value }; };
template<> struct base16_table<'b'> { enum { value = base16_table<'B'>::value }; };
template<> struct base16_table<'c'> { enum { value = base16_table<'C'>::value }; };
template<> struct base16_table<'d'> { enum { value = base16_table<'D'>::value }; };
template<> struct base16_table<'e'> { enum { value = base16_table<'E'>::value }; };
template<> struct base16_table<'f'> { enum { value = base16_table<'F'>::value }; };
}
/**
* @em %base16 character encoding traits class template.
*
* @tparam charT the encoding character type
*/
template<class charT> struct base16_traits;
/**
* Character encoding traits specialization for @c char.
*
* This character encoding traits class defines the encoding
* alphabet for the @em %base16 encoding scheme as defined in RFC
* 4648 for the encoding character type @c char.
*/
template<>
struct base16_traits<char> {
/**
* The encoding character type.
*/
typedef char char_type;
/**
* An integral type representing an octet.
*/
typedef unsigned char int_type;
/**
* Returns whether the character @a lhs is to be treated equal
* to the character @a rhs.
*/
static bool eq(const char_type& lhs, const char_type& rhs) {
return lhs == rhs;
}
/**
* Returns whether the integral value @a lhs is to be treated
* equal to @a rhs.
*/
static bool eq_int_type(const int_type& lhs, const int_type& rhs) {
return lhs == rhs;
}
/**
* Returns the character representation of a 4-bit value.
*/
static char_type to_char_type(const int_type& c) {
return to_char_type_upper(c);
}
/**
* Returns the uppercase character representation of a 4-bit
* value.
*/
static char_type to_char_type_upper(const int_type& c) {
return "0123456789ABCDEF"[c];
}
/**
* Returns the lowercase character representation of a 4-bit
* value.
*/
static char_type to_char_type_lower(const int_type& c) {
return "0123456789abcdef"[c];
}
/**
* Returns the 4-bit value represented by a character, or
* inv() for characters not in the encoding alphabet.
*/
static int_type to_int_type(const char_type& c) {
return lookup<detail::base16_table, int_type>(c);
}
/**
* Returns an integral value represented by no character in
* the encoding alphabet.
*/
static int_type inv() {
return detail::base16_table<'\0'>::value;
}
};
/**
* Character encoding traits specialization for @c wchar_t.
*
* This character encoding traits class defines the encoding
* alphabet for the @em %base16 encoding scheme as defined in RFC
* 4648 for the encoding character type @c wchar_t.
*/
template<>
struct base16_traits<wchar_t>
: public portable_wchar_encoding_traits<base16_traits<char> > {
};
/**
* This class template implements the Base16 encoding as defined
* in RFC 4648 for a given character type and encoding alphabet.
*
* Base16 encoding is the standard case insensitive hexadecimal
* encoding.
*
* The encoding process represents 8-bit groups (octets) of input
* data as output strings of 2 encoded characters. Proceeding
* from left to right, an 8-bit input is taken from the input
* data. These 8 bits are then treated as 2 concatenated 4-bit
* groups, each of which is translated into a single character in
* the Base16 alphabet.
*
* @tparam charT the encoding character type
*
* @tparam traits the character encoding traits type
*/
template<class charT, class traits = base16_traits<charT> >
class base16 {
private:
struct noskip { };
public:
/**
* The encoding character type.
*/
typedef charT char_type;
/**
* The character encoding traits type.
*/
typedef traits traits_type;
/**
* An integral type representing an octet.
*/
typedef typename traits::int_type int_type;
/**
* Encodes a range of octets.
*
* @tparam InputIterator an iterator type satisfying input
* iterator requirements and referring to elements implicitly
* convertible to int_type
*
* @tparam OutputIterator an iterator type satisfying output
* iterator requirements
*
* @param first an input iterator to the first position in the
* octet range to be encoded
*
* @param last an input iterator to the final position in the
* octet range to be encoded
*
* @param result an output iterator to the encoded character
* range
*
* @return an output iterator referring to one past the last
* value assigned to the output range
*/
template<class InputIterator, class OutputIterator>
static OutputIterator encode(
InputIterator first, InputIterator last, OutputIterator result
)
{
for (; first != last; ++first) {
int_type c = *first;
*result = traits::to_char_type((c & 0xff) >> 4);
++result;
*result = traits::to_char_type((c & 0x0f));
++result;
}
return result;
}
/**
* Encodes a range of octets using the lowercase encoding
* alphabet.
*
* @tparam InputIterator an iterator type satisfying input
* iterator requirements and referring to elements implicitly
* convertible to int_type
*
* @tparam OutputIterator an iterator type satisfying output
* iterator requirements
*
* @param first an input iterator to the first position in the
* octet range to be encoded
*
* @param last an input iterator to the final position in the
* octet range to be encoded
*
* @param result an output iterator to the encoded character
* range
*
* @return an output iterator referring to one past the last
* value assigned to the output range
*/
template<class InputIterator, class OutputIterator>
static OutputIterator encode_lower(
InputIterator first, InputIterator last, OutputIterator result
)
{
typedef lower_char_encoding_traits<traits> lower_traits;
return base16<charT, lower_traits>::encode(first, last, result);
}
/**
* Encodes a range of octets using the uppercase encoding
* alphabet.
*
* @tparam InputIterator an iterator type satisfying input
* iterator requirements and referring to elements implicitly
* convertible to int_type
*
* @tparam OutputIterator an iterator type satisfying output
* iterator requirements
*
* @param first an input iterator to the first position in the
* octet range to be encoded
*
* @param last an input iterator to the final position in the
* octet range to be encoded
*
* @param result an output iterator to the encoded character
* range
*
* @return an output iterator referring to one past the last
* value assigned to the output range
*/
template<class InputIterator, class OutputIterator>
static OutputIterator encode_upper(
InputIterator first, InputIterator last, OutputIterator result
)
{
typedef upper_char_encoding_traits<traits> upper_traits;
return base16<charT, upper_traits>::encode(first, last, result);
}
/**
* Decodes a range of characters.
*
* @tparam InputIterator an iterator type satisfying input
* iterator requirements and referring to elements implicitly
* convertible to char_type
*
* @tparam OutputIterator an iterator type satisfying output
* iterator requirements
*
* @param first an input iterator to the first position in the
* character range to be decoded
*
* @param last an input iterator to the final position in the
* character range to be decoded
*
* @param result an output iterator to the decoded octet range
*
* @return an output iterator referring to one past the last
* value assigned to the output range
*
* @throw invalid_character if a character not in the encoding
* alphabet is encountered
*
* @throw invalid_length if the input range contains an odd
* number of encoding characters
*/
template<class InputIterator, class OutputIterator>
static OutputIterator decode(
InputIterator first, InputIterator last, OutputIterator result
)
{
return decode(first, last, result, noskip());
}
/**
* Decodes a range of characters.
*
* For every character @c c not in the encoding alphabet,
*
* - if @a skip(c) evaluates to @c true, the character is
* ignored
* - otherwise, throws invalid_character
*
* @tparam InputIterator an iterator type satisfying input
* iterator requirements and referring to elements implicitly
* convertible to char_type
*
* @tparam OutputIterator an iterator type satisfying output
* iterator requirements
*
* @tparam Predicate a predicate type
*
* @param first an input iterator to the first position in the
* character range to be decoded
*
* @param last an input iterator to the final position in the
* character range to be decoded
*
* @param result an output iterator to the decoded octet range
*
* @param skip a function object that, when applied to a value
* of type char_type, returns a value testable as @c true
*
* @return an output iterator referring to one past the last
* value assigned to the output range
*
* @throw invalid_character if a character not in the encoding
* alphabet is encountered
*
* @throw invalid_length if the input range contains an odd
* number of encoding characters
*/
template<class InputIterator, class OutputIterator, class Predicate>
static OutputIterator decode(
InputIterator first, InputIterator last, OutputIterator result,
Predicate skip
)
{
for (;;) {
int_type c0 = seek(first, last, skip);
if (traits::eq_int_type(c0, traits::inv())) {
return result;
}
int_type c1 = seek(first, last, skip);
if (traits::eq_int_type(c1, traits::inv())) {
throw invalid_length("base16 decode error");
}
*result = c0 << 4 | c1;
++result;
}
}
/**
* Computes the maximum length of an encoded character
* sequence.
*
* @tparam sizeT an integral type
*
* @param n the length of the input octet sequence
*
* @return the maximum length of the encoded character
* sequence
*/
template<class sizeT>
static sizeT max_encode_size(sizeT n) {
return n * 2;
}
/**
* Computes the maximum length of a decoded octet sequence.
*
* @tparam sizeT an integral type
*
* @param n the length of the input character sequence
*
* @return the maximum length of the decoded octet sequence
*/
template<class sizeT>
static sizeT max_decode_size(sizeT n) {
return n / 2;
}
private:
template<class InputIterator, class Predicate>
static int_type seek(
InputIterator& first, const InputIterator& last, Predicate& skip
)
{
while (first != last) {
char_type c = *first;
++first;
int_type v = traits::to_int_type(c);
if (!traits::eq_int_type(v, traits::inv())) {
return v;
} else if (!skip(c)) {
throw invalid_character("base16 decode error");
}
}
return traits::inv();
}
template<class InputIterator>
static int_type seek(
InputIterator& first, const InputIterator& last, noskip&
)
{
if (first != last) {
char_type c = *first;
++first;
int_type v = traits::to_int_type(c);
if (!traits::eq_int_type(v, traits::inv())) {
return v;
} else {
throw invalid_character("base16 decode error");
}
}
return traits::inv();
}
};
}
#endif
| 35.153191 | 91 | 0.579591 | [
"object"
] |
0b037f1b5bd8d01ec8ab2c2e8bc5f67950ce3a84 | 14,525 | cpp | C++ | src/optimizer/rule_impls.cpp | xinzhang1234/peloton | 9b11d92dd5a2a0b32d5c39a9ba0b1aa45fe0b654 | [
"Apache-2.0"
] | 2 | 2017-07-24T12:25:58.000Z | 2022-03-17T11:43:42.000Z | src/optimizer/rule_impls.cpp | xinzhang1234/peloton | 9b11d92dd5a2a0b32d5c39a9ba0b1aa45fe0b654 | [
"Apache-2.0"
] | 2 | 2016-10-01T00:36:16.000Z | 2016-11-05T23:40:07.000Z | src/optimizer/rule_impls.cpp | xinzhang1234/peloton | 9b11d92dd5a2a0b32d5c39a9ba0b1aa45fe0b654 | [
"Apache-2.0"
] | 3 | 2016-09-24T01:22:30.000Z | 2019-01-09T16:17:25.000Z | //===----------------------------------------------------------------------===//
//
// Peloton
//
// rule_impls.cpp
//
// Identification: src/optimizer/rule_impls.cpp
//
// Copyright (c) 2015-16, Carnegie Mellon University Database Group
//
//===----------------------------------------------------------------------===//
#include "optimizer/rule_impls.h"
#include "optimizer/operators.h"
#include <memory>
namespace peloton {
namespace optimizer {
///////////////////////////////////////////////////////////////////////////////
/// InnerJoinCommutativity
InnerJoinCommutativity::InnerJoinCommutativity() {
logical = true;
std::shared_ptr<Pattern> left_child(std::make_shared<Pattern>(OpType::Leaf));
std::shared_ptr<Pattern> right_child(std::make_shared<Pattern>(OpType::Leaf));
std::shared_ptr<Pattern> predicate(std::make_shared<Pattern>(OpType::Leaf));
match_pattern = std::make_shared<Pattern>(OpType::InnerJoin);
match_pattern->AddChild(left_child);
match_pattern->AddChild(right_child);
match_pattern->AddChild(predicate);
}
bool InnerJoinCommutativity::Check(
std::shared_ptr<OperatorExpression> expr) const {
(void)expr;
return true;
}
void InnerJoinCommutativity::Transform(
std::shared_ptr<OperatorExpression> input,
std::vector<std::shared_ptr<OperatorExpression>> &transformed) const {
auto result_plan =
std::make_shared<OperatorExpression>(LogicalInnerJoin::make());
std::vector<std::shared_ptr<OperatorExpression>> children = input->Children();
PL_ASSERT(children.size() == 2);
result_plan->PushChild(children[1]);
result_plan->PushChild(children[0]);
transformed.push_back(result_plan);
}
///////////////////////////////////////////////////////////////////////////////
/// GetToScan
GetToScan::GetToScan() {
physical = true;
match_pattern = std::make_shared<Pattern>(OpType::Get);
}
bool GetToScan::Check(std::shared_ptr<OperatorExpression> plan) const {
(void)plan;
return true;
}
void GetToScan::Transform(
std::shared_ptr<OperatorExpression> input,
std::vector<std::shared_ptr<OperatorExpression>> &transformed) const {
const LogicalGet *get = input->Op().As<LogicalGet>();
auto result_plan =
std::make_shared<OperatorExpression>(PhysicalScan::make(get->table));
UNUSED_ATTRIBUTE std::vector<std::shared_ptr<OperatorExpression>> children =
input->Children();
PL_ASSERT(children.size() == 0);
transformed.push_back(result_plan);
}
///////////////////////////////////////////////////////////////////////////////
/// SelectToFilter
LogicalFilterToPhysical::LogicalFilterToPhysical() {
physical = true;
std::shared_ptr<Pattern> child(std::make_shared<Pattern>(OpType::Leaf));
std::shared_ptr<Pattern> predicate(std::make_shared<Pattern>(OpType::Leaf));
match_pattern = std::make_shared<Pattern>(OpType::LogicalFilter);
match_pattern->AddChild(child);
match_pattern->AddChild(predicate);
}
bool LogicalFilterToPhysical::Check(
std::shared_ptr<OperatorExpression> plan) const {
(void)plan;
return true;
}
void LogicalFilterToPhysical::Transform(
std::shared_ptr<OperatorExpression> input,
std::vector<std::shared_ptr<OperatorExpression>> &transformed) const {
auto result = std::make_shared<OperatorExpression>(PhysicalFilter::make());
std::vector<std::shared_ptr<OperatorExpression>> children = input->Children();
PL_ASSERT(children.size() == 2);
result->PushChild(children[0]);
result->PushChild(children[1]);
transformed.push_back(result);
}
///////////////////////////////////////////////////////////////////////////////
/// InnerJoinToInnerNLJoin
InnerJoinToInnerNLJoin::InnerJoinToInnerNLJoin() {
physical = true;
// Make three node types for pattern matching
std::shared_ptr<Pattern> left_child(std::make_shared<Pattern>(OpType::Leaf));
std::shared_ptr<Pattern> right_child(std::make_shared<Pattern>(OpType::Leaf));
std::shared_ptr<Pattern> predicate(std::make_shared<Pattern>(OpType::Leaf));
// Initialize a pattern for optimizer to match
match_pattern = std::make_shared<Pattern>(OpType::InnerJoin);
// Add node - we match join relation R and S as well as the predicate exp
match_pattern->AddChild(left_child);
match_pattern->AddChild(right_child);
match_pattern->AddChild(predicate);
return;
}
bool InnerJoinToInnerNLJoin::Check(
std::shared_ptr<OperatorExpression> plan) const {
(void)plan;
return true;
}
void InnerJoinToInnerNLJoin::Transform(
std::shared_ptr<OperatorExpression> input,
std::vector<std::shared_ptr<OperatorExpression>> &transformed) const {
// first build an expression representing hash join
auto result_plan =
std::make_shared<OperatorExpression>(PhysicalInnerNLJoin::make());
std::vector<std::shared_ptr<OperatorExpression>> children = input->Children();
PL_ASSERT(children.size() == 3);
// Then push all children into the child list of the new operator
result_plan->PushChild(children[0]);
result_plan->PushChild(children[1]);
result_plan->PushChild(children[2]);
transformed.push_back(result_plan);
return;
}
///////////////////////////////////////////////////////////////////////////////
/// LeftJoinToLeftNLJoin
LeftJoinToLeftNLJoin::LeftJoinToLeftNLJoin() {
physical = true;
std::shared_ptr<Pattern> left_child(std::make_shared<Pattern>(OpType::Leaf));
std::shared_ptr<Pattern> right_child(std::make_shared<Pattern>(OpType::Leaf));
std::shared_ptr<Pattern> predicate(std::make_shared<Pattern>(OpType::Leaf));
match_pattern = std::make_shared<Pattern>(OpType::LeftJoin);
match_pattern->AddChild(left_child);
match_pattern->AddChild(right_child);
match_pattern->AddChild(predicate);
return;
}
bool LeftJoinToLeftNLJoin::Check(
std::shared_ptr<OperatorExpression> plan) const {
(void)plan;
return true;
}
void LeftJoinToLeftNLJoin::Transform(
std::shared_ptr<OperatorExpression> input,
std::vector<std::shared_ptr<OperatorExpression>> &transformed) const {
auto result_plan =
std::make_shared<OperatorExpression>(PhysicalLeftNLJoin::make());
std::vector<std::shared_ptr<OperatorExpression>> children = input->Children();
PL_ASSERT(children.size() == 3);
result_plan->PushChild(children[0]);
result_plan->PushChild(children[1]);
result_plan->PushChild(children[2]);
transformed.push_back(result_plan);
return;
}
///////////////////////////////////////////////////////////////////////////////
/// RightJoinToRightNLJoin
RightJoinToRightNLJoin::RightJoinToRightNLJoin() {
physical = true;
std::shared_ptr<Pattern> left_child(std::make_shared<Pattern>(OpType::Leaf));
std::shared_ptr<Pattern> right_child(std::make_shared<Pattern>(OpType::Leaf));
std::shared_ptr<Pattern> predicate(std::make_shared<Pattern>(OpType::Leaf));
match_pattern = std::make_shared<Pattern>(OpType::RightJoin);
match_pattern->AddChild(left_child);
match_pattern->AddChild(right_child);
match_pattern->AddChild(predicate);
return;
}
bool RightJoinToRightNLJoin::Check(
std::shared_ptr<OperatorExpression> plan) const {
(void)plan;
return true;
}
void RightJoinToRightNLJoin::Transform(
std::shared_ptr<OperatorExpression> input,
std::vector<std::shared_ptr<OperatorExpression>> &transformed) const {
auto result_plan =
std::make_shared<OperatorExpression>(PhysicalRightNLJoin::make());
std::vector<std::shared_ptr<OperatorExpression>> children = input->Children();
PL_ASSERT(children.size() == 3);
result_plan->PushChild(children[0]);
result_plan->PushChild(children[1]);
result_plan->PushChild(children[2]);
transformed.push_back(result_plan);
return;
}
///////////////////////////////////////////////////////////////////////////////
/// OuterJoinToOuterNLJoin
OuterJoinToOuterNLJoin::OuterJoinToOuterNLJoin() {
physical = true;
std::shared_ptr<Pattern> left_child(std::make_shared<Pattern>(OpType::Leaf));
std::shared_ptr<Pattern> right_child(std::make_shared<Pattern>(OpType::Leaf));
std::shared_ptr<Pattern> predicate(std::make_shared<Pattern>(OpType::Leaf));
match_pattern = std::make_shared<Pattern>(OpType::OuterJoin);
match_pattern->AddChild(left_child);
match_pattern->AddChild(right_child);
match_pattern->AddChild(predicate);
return;
}
bool OuterJoinToOuterNLJoin::Check(
std::shared_ptr<OperatorExpression> plan) const {
(void)plan;
return true;
}
void OuterJoinToOuterNLJoin::Transform(
std::shared_ptr<OperatorExpression> input,
std::vector<std::shared_ptr<OperatorExpression>> &transformed) const {
auto result_plan =
std::make_shared<OperatorExpression>(PhysicalOuterNLJoin::make());
std::vector<std::shared_ptr<OperatorExpression>> children = input->Children();
PL_ASSERT(children.size() == 3);
result_plan->PushChild(children[0]);
result_plan->PushChild(children[1]);
result_plan->PushChild(children[2]);
transformed.push_back(result_plan);
return;
}
///////////////////////////////////////////////////////////////////////////////
/// InnerJoinToInnerHashJoin
InnerJoinToInnerHashJoin::InnerJoinToInnerHashJoin() {
physical = true;
// Make three node types for pattern matching
std::shared_ptr<Pattern> left_child(std::make_shared<Pattern>(OpType::Leaf));
std::shared_ptr<Pattern> right_child(std::make_shared<Pattern>(OpType::Leaf));
std::shared_ptr<Pattern> predicate(std::make_shared<Pattern>(OpType::Leaf));
// Initialize a pattern for optimizer to match
match_pattern = std::make_shared<Pattern>(OpType::InnerJoin);
// Add node - we match join relation R and S as well as the predicate exp
match_pattern->AddChild(left_child);
match_pattern->AddChild(right_child);
match_pattern->AddChild(predicate);
return;
}
bool InnerJoinToInnerHashJoin::Check(
std::shared_ptr<OperatorExpression> plan) const {
(void)plan;
// TODO(abpoms): Figure out how to determine if the join condition is hashable
return false;
}
void InnerJoinToInnerHashJoin::Transform(
std::shared_ptr<OperatorExpression> input,
std::vector<std::shared_ptr<OperatorExpression>> &transformed) const {
// first build an expression representing hash join
auto result_plan =
std::make_shared<OperatorExpression>(PhysicalInnerHashJoin::make());
std::vector<std::shared_ptr<OperatorExpression>> children = input->Children();
PL_ASSERT(children.size() == 3);
// Then push all children into the child list of the new operator
result_plan->PushChild(children[0]);
result_plan->PushChild(children[1]);
result_plan->PushChild(children[2]);
transformed.push_back(result_plan);
return;
}
///////////////////////////////////////////////////////////////////////////////
/// LeftJoinToLeftHashJoin
LeftJoinToLeftHashJoin::LeftJoinToLeftHashJoin() {
physical = true;
std::shared_ptr<Pattern> left_child(std::make_shared<Pattern>(OpType::Leaf));
std::shared_ptr<Pattern> right_child(std::make_shared<Pattern>(OpType::Leaf));
std::shared_ptr<Pattern> predicate(std::make_shared<Pattern>(OpType::Leaf));
match_pattern = std::make_shared<Pattern>(OpType::LeftJoin);
match_pattern->AddChild(left_child);
match_pattern->AddChild(right_child);
match_pattern->AddChild(predicate);
return;
}
bool LeftJoinToLeftHashJoin::Check(
std::shared_ptr<OperatorExpression> plan) const {
(void)plan;
return false;
}
void LeftJoinToLeftHashJoin::Transform(
std::shared_ptr<OperatorExpression> input,
std::vector<std::shared_ptr<OperatorExpression>> &transformed) const {
auto result_plan =
std::make_shared<OperatorExpression>(PhysicalLeftHashJoin::make());
std::vector<std::shared_ptr<OperatorExpression>> children = input->Children();
PL_ASSERT(children.size() == 3);
result_plan->PushChild(children[0]);
result_plan->PushChild(children[1]);
result_plan->PushChild(children[2]);
transformed.push_back(result_plan);
return;
}
///////////////////////////////////////////////////////////////////////////////
/// RightJoinToRightHashJoin
RightJoinToRightHashJoin::RightJoinToRightHashJoin() {
physical = true;
std::shared_ptr<Pattern> left_child(std::make_shared<Pattern>(OpType::Leaf));
std::shared_ptr<Pattern> right_child(std::make_shared<Pattern>(OpType::Leaf));
std::shared_ptr<Pattern> predicate(std::make_shared<Pattern>(OpType::Leaf));
match_pattern = std::make_shared<Pattern>(OpType::RightJoin);
match_pattern->AddChild(left_child);
match_pattern->AddChild(right_child);
match_pattern->AddChild(predicate);
return;
}
bool RightJoinToRightHashJoin::Check(
std::shared_ptr<OperatorExpression> plan) const {
(void)plan;
return false;
}
void RightJoinToRightHashJoin::Transform(
std::shared_ptr<OperatorExpression> input,
std::vector<std::shared_ptr<OperatorExpression>> &transformed) const {
auto result_plan =
std::make_shared<OperatorExpression>(PhysicalRightHashJoin::make());
std::vector<std::shared_ptr<OperatorExpression>> children = input->Children();
PL_ASSERT(children.size() == 3);
result_plan->PushChild(children[0]);
result_plan->PushChild(children[1]);
result_plan->PushChild(children[2]);
transformed.push_back(result_plan);
return;
}
///////////////////////////////////////////////////////////////////////////////
/// OuterJoinToOuterHashJoin
OuterJoinToOuterHashJoin::OuterJoinToOuterHashJoin() {
physical = true;
std::shared_ptr<Pattern> left_child(std::make_shared<Pattern>(OpType::Leaf));
std::shared_ptr<Pattern> right_child(std::make_shared<Pattern>(OpType::Leaf));
std::shared_ptr<Pattern> predicate(std::make_shared<Pattern>(OpType::Leaf));
match_pattern = std::make_shared<Pattern>(OpType::OuterJoin);
match_pattern->AddChild(left_child);
match_pattern->AddChild(right_child);
match_pattern->AddChild(predicate);
return;
}
bool OuterJoinToOuterHashJoin::Check(
std::shared_ptr<OperatorExpression> plan) const {
(void)plan;
return false;
}
void OuterJoinToOuterHashJoin::Transform(
std::shared_ptr<OperatorExpression> input,
std::vector<std::shared_ptr<OperatorExpression>> &transformed) const {
auto result_plan =
std::make_shared<OperatorExpression>(PhysicalOuterHashJoin::make());
std::vector<std::shared_ptr<OperatorExpression>> children = input->Children();
PL_ASSERT(children.size() == 3);
result_plan->PushChild(children[0]);
result_plan->PushChild(children[1]);
result_plan->PushChild(children[2]);
transformed.push_back(result_plan);
return;
}
} /* namespace optimizer */
} /* namespace peloton */
| 32.064018 | 80 | 0.694664 | [
"vector",
"transform"
] |
0b039618406f80ea6b24f0978af51a7609d952de | 27,913 | cpp | C++ | src/providers/wfs/qgswfssourceselect.cpp | dyna-mis/Hilabeling | cb7d5d4be29624a20c8a367162dbc6fd779b2b52 | [
"MIT"
] | null | null | null | src/providers/wfs/qgswfssourceselect.cpp | dyna-mis/Hilabeling | cb7d5d4be29624a20c8a367162dbc6fd779b2b52 | [
"MIT"
] | null | null | null | src/providers/wfs/qgswfssourceselect.cpp | dyna-mis/Hilabeling | cb7d5d4be29624a20c8a367162dbc6fd779b2b52 | [
"MIT"
] | 1 | 2021-12-25T08:40:30.000Z | 2021-12-25T08:40:30.000Z | /***************************************************************************
qgswfssourceselect.cpp
-------------------
begin : August 25, 2006
copyright : (C) 2016 by Marco Hugentobler
email : marco dot hugentobler at karto dot baug dot ethz dot ch
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#include "qgswfsconstants.h"
#include "qgswfssourceselect.h"
#include "qgswfsconnection.h"
#include "qgswfscapabilities.h"
#include "qgswfsprovider.h"
#include "qgswfsdatasourceuri.h"
#include "qgswfsutils.h"
#include "qgswfsnewconnection.h"
#include "qgsprojectionselectiondialog.h"
#include "qgsproject.h"
#include "qgscoordinatereferencesystem.h"
#include "qgscoordinatetransform.h"
#include "qgslogger.h"
#include "qgsmanageconnectionsdialog.h"
#include "qgssqlstatement.h"
#include "qgssettings.h"
#include <QDomDocument>
#include <QListWidgetItem>
#include <QMessageBox>
#include <QFileDialog>
#include <QPainter>
enum
{
MODEL_IDX_TITLE,
MODEL_IDX_NAME,
MODEL_IDX_ABSTRACT,
MODEL_IDX_SQL
};
QgsWFSSourceSelect::QgsWFSSourceSelect( QWidget *parent, Qt::WindowFlags fl, QgsProviderRegistry::WidgetMode theWidgetMode )
: QgsAbstractDataSourceWidget( parent, fl, theWidgetMode )
{
setupUi( this );
connect( cmbConnections, static_cast<void ( QComboBox::* )( int )>( &QComboBox::activated ), this, &QgsWFSSourceSelect::cmbConnections_activated );
connect( btnSave, &QPushButton::clicked, this, &QgsWFSSourceSelect::btnSave_clicked );
connect( btnLoad, &QPushButton::clicked, this, &QgsWFSSourceSelect::btnLoad_clicked );
setupButtons( buttonBox );
connect( buttonBox, &QDialogButtonBox::helpRequested, this, &QgsWFSSourceSelect::showHelp );
if ( widgetMode() != QgsProviderRegistry::WidgetMode::None )
{
mHoldDialogOpen->hide();
}
mBuildQueryButton = new QPushButton( tr( "&Build query" ) );
mBuildQueryButton->setToolTip( tr( "Build query" ) );
mBuildQueryButton->setDisabled( true );
buttonBox->addButton( mBuildQueryButton, QDialogButtonBox::ActionRole );
connect( mBuildQueryButton, &QAbstractButton::clicked, this, &QgsWFSSourceSelect::buildQueryButtonClicked );
connect( buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject );
connect( btnNew, &QAbstractButton::clicked, this, &QgsWFSSourceSelect::addEntryToServerList );
connect( btnEdit, &QAbstractButton::clicked, this, &QgsWFSSourceSelect::modifyEntryOfServerList );
connect( btnDelete, &QAbstractButton::clicked, this, &QgsWFSSourceSelect::deleteEntryOfServerList );
connect( btnConnect, &QAbstractButton::clicked, this, &QgsWFSSourceSelect::connectToServer );
connect( btnChangeSpatialRefSys, &QAbstractButton::clicked, this, &QgsWFSSourceSelect::changeCRS );
connect( lineFilter, &QLineEdit::textChanged, this, &QgsWFSSourceSelect::filterChanged );
populateConnectionList();
mProjectionSelector = new QgsProjectionSelectionDialog( this );
mProjectionSelector->setMessage( QString() );
mItemDelegate = new QgsWFSItemDelegate( treeView );
treeView->setItemDelegate( mItemDelegate );
QgsSettings settings;
QgsDebugMsg( QStringLiteral( "restoring settings" ) );
restoreGeometry( settings.value( QStringLiteral( "Windows/WFSSourceSelect/geometry" ) ).toByteArray() );
cbxUseTitleLayerName->setChecked( settings.value( QStringLiteral( "Windows/WFSSourceSelect/UseTitleLayerName" ), false ).toBool() );
cbxFeatureCurrentViewExtent->setChecked( settings.value( QStringLiteral( "Windows/WFSSourceSelect/FeatureCurrentViewExtent" ), true ).toBool() );
mHoldDialogOpen->setChecked( settings.value( QStringLiteral( "Windows/WFSSourceSelect/HoldDialogOpen" ), false ).toBool() );
mModel = new QStandardItemModel();
mModel->setHorizontalHeaderItem( MODEL_IDX_TITLE, new QStandardItem( QStringLiteral( "Title" ) ) );
mModel->setHorizontalHeaderItem( MODEL_IDX_NAME, new QStandardItem( QStringLiteral( "Name" ) ) );
mModel->setHorizontalHeaderItem( MODEL_IDX_ABSTRACT, new QStandardItem( QStringLiteral( "Abstract" ) ) );
mModel->setHorizontalHeaderItem( MODEL_IDX_SQL, new QStandardItem( QStringLiteral( "Sql" ) ) );
mModelProxy = new QSortFilterProxyModel( this );
mModelProxy->setSourceModel( mModel );
mModelProxy->setSortCaseSensitivity( Qt::CaseInsensitive );
treeView->setModel( mModelProxy );
connect( treeView, &QAbstractItemView::doubleClicked, this, &QgsWFSSourceSelect::treeWidgetItemDoubleClicked );
connect( treeView->selectionModel(), &QItemSelectionModel::currentRowChanged, this, &QgsWFSSourceSelect::treeWidgetCurrentRowChanged );
}
QgsWFSSourceSelect::~QgsWFSSourceSelect()
{
QApplication::restoreOverrideCursor();
QgsSettings settings;
QgsDebugMsg( QStringLiteral( "saving settings" ) );
settings.setValue( QStringLiteral( "Windows/WFSSourceSelect/geometry" ), saveGeometry() );
settings.setValue( QStringLiteral( "Windows/WFSSourceSelect/UseTitleLayerName" ), cbxUseTitleLayerName->isChecked() );
settings.setValue( QStringLiteral( "Windows/WFSSourceSelect/FeatureCurrentViewExtent" ), cbxFeatureCurrentViewExtent->isChecked() );
settings.setValue( QStringLiteral( "Windows/WFSSourceSelect/HoldDialogOpen" ), mHoldDialogOpen->isChecked() );
delete mItemDelegate;
delete mProjectionSelector;
delete mCapabilities;
delete mModel;
delete mModelProxy;
delete mBuildQueryButton;
}
void QgsWFSSourceSelect::populateConnectionList()
{
QStringList keys = QgsWfsConnection::connectionList();
QStringList::Iterator it = keys.begin();
cmbConnections->clear();
while ( it != keys.end() )
{
cmbConnections->addItem( *it );
++it;
}
if ( keys.begin() != keys.end() )
{
// Connections available - enable various buttons
btnConnect->setEnabled( true );
btnEdit->setEnabled( true );
btnDelete->setEnabled( true );
btnSave->setEnabled( true );
}
else
{
// No connections available - disable various buttons
btnConnect->setEnabled( false );
btnEdit->setEnabled( false );
btnDelete->setEnabled( false );
btnSave->setEnabled( false );
}
//set last used connection
QString selectedConnection = QgsWfsConnection::selectedConnection();
int index = cmbConnections->findText( selectedConnection );
if ( index != -1 )
{
cmbConnections->setCurrentIndex( index );
}
QgsWfsConnection connection( cmbConnections->currentText() );
delete mCapabilities;
mCapabilities = new QgsWfsCapabilities( connection.uri().uri() );
connect( mCapabilities, &QgsWfsCapabilities::gotCapabilities, this, &QgsWFSSourceSelect::capabilitiesReplyFinished );
}
QString QgsWFSSourceSelect::getPreferredCrs( const QSet<QString> &crsSet ) const
{
if ( crsSet.size() < 1 )
{
return QString();
}
//first: project CRS
QgsCoordinateReferenceSystem projectRefSys = QgsProject::instance()->crs();
//convert to EPSG
QString ProjectCRS;
if ( projectRefSys.isValid() )
{
ProjectCRS = projectRefSys.authid();
}
if ( !ProjectCRS.isEmpty() && crsSet.contains( ProjectCRS ) )
{
return ProjectCRS;
}
//second: WGS84
if ( crsSet.contains( GEO_EPSG_CRS_AUTHID ) )
{
return GEO_EPSG_CRS_AUTHID;
}
//third: first entry in set
return *( crsSet.constBegin() );
}
void QgsWFSSourceSelect::refresh()
{
populateConnectionList();
}
void QgsWFSSourceSelect::capabilitiesReplyFinished()
{
QApplication::restoreOverrideCursor();
btnConnect->setEnabled( true );
if ( !mCapabilities )
return;
QgsWfsCapabilities::ErrorCode err = mCapabilities->errorCode();
if ( err != QgsWfsCapabilities::NoError )
{
QString title;
switch ( err )
{
case QgsWfsCapabilities::NetworkError:
title = tr( "Network Error" );
break;
case QgsWfsCapabilities::XmlError:
title = tr( "Capabilities document is not valid" );
break;
case QgsWfsCapabilities::ServerExceptionError:
title = tr( "Server Exception" );
break;
default:
title = tr( "Error" );
break;
}
// handle errors
QMessageBox *box = new QMessageBox( QMessageBox::Critical, title, mCapabilities->errorMessage(), QMessageBox::Ok, this );
box->setAttribute( Qt::WA_DeleteOnClose );
box->setModal( true );
box->setObjectName( QStringLiteral( "WFSCapabilitiesErrorBox" ) );
if ( !property( "hideDialogs" ).toBool() )
box->open();
emit enableButtons( false );
return;
}
mCaps = mCapabilities->capabilities();
mAvailableCRS.clear();
Q_FOREACH ( const QgsWfsCapabilities::FeatureType &featureType, mCaps.featureTypes )
{
// insert the typenames, titles and abstracts into the tree view
QStandardItem *titleItem = new QStandardItem( featureType.title );
QStandardItem *nameItem = new QStandardItem( featureType.name );
QStandardItem *abstractItem = new QStandardItem( featureType.abstract );
abstractItem->setToolTip( "<font color=black>" + featureType.abstract + "</font>" );
abstractItem->setTextAlignment( Qt::AlignLeft | Qt::AlignTop );
QStandardItem *filterItem = new QStandardItem();
typedef QList< QStandardItem * > StandardItemList;
mModel->appendRow( StandardItemList() << titleItem << nameItem << abstractItem << filterItem );
// insert the available CRS into mAvailableCRS
mAvailableCRS.insert( featureType.name, featureType.crslist );
}
if ( !mCaps.featureTypes.isEmpty() )
{
treeView->resizeColumnToContents( MODEL_IDX_TITLE );
treeView->resizeColumnToContents( MODEL_IDX_NAME );
treeView->resizeColumnToContents( MODEL_IDX_ABSTRACT );
for ( int i = MODEL_IDX_TITLE; i < MODEL_IDX_ABSTRACT; i++ )
{
if ( treeView->columnWidth( i ) > 300 )
{
treeView->setColumnWidth( i, 300 );
}
}
if ( treeView->columnWidth( MODEL_IDX_ABSTRACT ) > 150 )
{
treeView->setColumnWidth( MODEL_IDX_ABSTRACT, 150 );
}
btnChangeSpatialRefSys->setEnabled( true );
treeView->selectionModel()->setCurrentIndex( mModelProxy->index( 0, 0 ), QItemSelectionModel::SelectCurrent | QItemSelectionModel::Rows );
treeView->setFocus();
}
else
{
QMessageBox::information( nullptr, tr( "No Layers" ), tr( "capabilities document contained no layers." ) );
emit enableButtons( false );
mBuildQueryButton->setEnabled( false );
}
}
void QgsWFSSourceSelect::addEntryToServerList()
{
auto nc = new QgsWFSNewConnection( this );
nc->setAttribute( Qt::WA_DeleteOnClose );
nc->setWindowTitle( tr( "Create a New WFS Connection" ) );
// For testability, do not use exec()
if ( !property( "hideDialogs" ).toBool() )
nc->open();
connect( nc, &QDialog::accepted, this, &QgsWFSSourceSelect::populateConnectionList );
connect( nc, &QDialog::accepted, this, &QgsWFSSourceSelect::connectionsChanged );
}
void QgsWFSSourceSelect::modifyEntryOfServerList()
{
auto nc = new QgsWFSNewConnection( this, cmbConnections->currentText() );
nc->setAttribute( Qt::WA_DeleteOnClose );
nc->setWindowTitle( tr( "Modify WFS Connection" ) );
// For testability, do not use exec()
if ( !property( "hideDialogs" ).toBool() )
nc->open();
connect( nc, &QDialog::accepted, this, &QgsWFSSourceSelect::populateConnectionList );
connect( nc, &QDialog::accepted, this, &QgsWFSSourceSelect::connectionsChanged );
}
void QgsWFSSourceSelect::deleteEntryOfServerList()
{
QString msg = tr( "Are you sure you want to remove the %1 connection and all associated settings?" )
.arg( cmbConnections->currentText() );
QMessageBox::StandardButton result = QMessageBox::question( this, tr( "Confirm Delete" ), msg, QMessageBox::Yes | QMessageBox::No );
if ( result == QMessageBox::Yes )
{
QgsWfsConnection::deleteConnection( cmbConnections->currentText() );
cmbConnections->removeItem( cmbConnections->currentIndex() );
emit connectionsChanged();
if ( cmbConnections->count() > 0 )
{
// Connections available - enable various buttons
btnConnect->setEnabled( true );
btnEdit->setEnabled( true );
btnDelete->setEnabled( true );
btnSave->setEnabled( true );
}
else
{
// No connections available - disable various buttons
btnConnect->setEnabled( false );
btnEdit->setEnabled( false );
btnDelete->setEnabled( false );
btnSave->setEnabled( false );
}
}
}
void QgsWFSSourceSelect::connectToServer()
{
btnConnect->setEnabled( false );
if ( mModel )
{
mModel->removeRows( 0, mModel->rowCount() );
}
if ( mCapabilities )
{
const bool synchronous = false;
const bool forceRefresh = true;
mCapabilities->requestCapabilities( synchronous, forceRefresh );
QApplication::setOverrideCursor( Qt::WaitCursor );
}
}
void QgsWFSSourceSelect::addButtonClicked()
{
//get selected entry in treeview
QModelIndex currentIndex = treeView->selectionModel()->currentIndex();
if ( !currentIndex.isValid() )
{
return;
}
QgsWfsConnection connection( cmbConnections->currentText() );
QString pCrsString( labelCoordRefSys->text() );
//create layers that user selected from this WFS source
QModelIndexList list = treeView->selectionModel()->selectedRows();
for ( int i = 0; i < list.size(); i++ )
{
//add a wfs layer to the map
QModelIndex idx = mModelProxy->mapToSource( list[i] );
if ( !idx.isValid() )
{
continue;
}
int row = idx.row();
QString typeName = mModel->item( row, MODEL_IDX_NAME )->text(); //WFS repository's name for layer
QString titleName = mModel->item( row, MODEL_IDX_TITLE )->text(); //WFS type name title for layer name (if option is set)
QString sql = mModel->item( row, MODEL_IDX_SQL )->text(); //optional SqL specified by user
QString layerName = typeName;
if ( cbxUseTitleLayerName->isChecked() && !titleName.isEmpty() )
{
layerName = titleName;
}
QgsDebugMsg( "Layer " + typeName + " SQL is " + sql );
mUri = QgsWFSDataSourceURI::build( connection.uri().uri(), typeName, pCrsString,
sql, cbxFeatureCurrentViewExtent->isChecked() );
emit addVectorLayer( mUri, layerName );
}
if ( ! mHoldDialogOpen->isChecked() && widgetMode() == QgsProviderRegistry::WidgetMode::None )
{
accept();
}
}
QgsWFSValidatorCallback::QgsWFSValidatorCallback( QObject *parent,
const QgsWFSDataSourceURI &uri,
const QString &allSql,
const QgsWfsCapabilities::Capabilities &caps )
: QObject( parent )
, mURI( uri )
, mAllSql( allSql )
, mCaps( caps )
{
}
bool QgsWFSValidatorCallback::isValid( const QString &sqlStr, QString &errorReason, QString &warningMsg )
{
errorReason.clear();
if ( sqlStr.isEmpty() || sqlStr == mAllSql )
return true;
QgsWFSDataSourceURI uri( mURI );
uri.setSql( sqlStr );
QgsDataProvider::ProviderOptions options;
QgsWFSProvider p( uri.uri(), options, mCaps );
if ( !p.isValid() )
{
errorReason = p.processSQLErrorMsg();
return false;
}
warningMsg = p.processSQLWarningMsg();
return true;
}
QgsWFSTableSelectedCallback::QgsWFSTableSelectedCallback( QgsSQLComposerDialog *dialog,
const QgsWFSDataSourceURI &uri,
const QgsWfsCapabilities::Capabilities &caps )
: QObject( dialog )
, mDialog( dialog )
, mURI( uri )
, mCaps( caps )
{
}
void QgsWFSTableSelectedCallback::tableSelected( const QString &name )
{
QString typeName( QgsSQLStatement::stripQuotedIdentifier( name ) );
QString prefixedTypename( mCaps.addPrefixIfNeeded( typeName ) );
if ( prefixedTypename.isEmpty() )
return;
QgsWFSDataSourceURI uri( mURI );
uri.setTypeName( prefixedTypename );
QgsDataProvider::ProviderOptions providerOptions;
QgsWFSProvider p( uri.uri(), providerOptions, mCaps );
if ( !p.isValid() )
{
return;
}
QList< QgsSQLComposerDialog::PairNameType> fieldList;
QString fieldNamePrefix( QgsSQLStatement::quotedIdentifierIfNeeded( typeName ) + "." );
const auto constToList = p.fields().toList();
for ( const QgsField &field : constToList )
{
QString fieldName( fieldNamePrefix + QgsSQLStatement::quotedIdentifierIfNeeded( field.name() ) );
fieldList << QgsSQLComposerDialog::PairNameType( fieldName, field.typeName() );
}
if ( !p.geometryAttribute().isEmpty() )
{
QString fieldName( fieldNamePrefix + QgsSQLStatement::quotedIdentifierIfNeeded( p.geometryAttribute() ) );
fieldList << QgsSQLComposerDialog::PairNameType( fieldName, QStringLiteral( "geometry" ) );
}
fieldList << QgsSQLComposerDialog::PairNameType( fieldNamePrefix + "*", QString() );
mDialog->addColumnNames( fieldList, name );
}
void QgsWFSSourceSelect::buildQuery( const QModelIndex &index )
{
if ( !index.isValid() )
{
return;
}
const QString typeName = index.sibling( index.row(), MODEL_IDX_NAME ).data().toString();
//get available fields for wfs layer
QgsWfsConnection connection( cmbConnections->currentText() );
QgsWFSDataSourceURI uri( connection.uri().uri() );
uri.setTypeName( typeName );
QgsDataProvider::ProviderOptions providerOptions;
QgsWFSProvider p( uri.uri(), providerOptions, mCaps );
if ( !p.isValid() )
{
QMessageBox *box = new QMessageBox( QMessageBox::Critical, tr( "Server exception" ), tr( "DescribeFeatureType failed" ), QMessageBox::Ok, this );
box->setAttribute( Qt::WA_DeleteOnClose );
box->setModal( true );
box->setObjectName( QStringLiteral( "WFSFeatureTypeErrorBox" ) );
if ( !property( "hideDialogs" ).toBool() )
box->open();
return;
}
QModelIndex filterIndex = index.sibling( index.row(), MODEL_IDX_SQL );
QString sql( filterIndex.data().toString() );
QString displayedTypeName( typeName );
if ( !mCaps.setAmbiguousUnprefixedTypename.contains( QgsWFSUtils::removeNamespacePrefix( typeName ) ) )
displayedTypeName = QgsWFSUtils::removeNamespacePrefix( typeName );
QString allSql( "SELECT * FROM " + QgsSQLStatement::quotedIdentifierIfNeeded( displayedTypeName ) );
if ( sql.isEmpty() )
{
sql = allSql;
}
QgsSQLComposerDialog *d = new QgsSQLComposerDialog( this );
QgsWFSValidatorCallback *validatorCbk = new QgsWFSValidatorCallback( d, uri, allSql, mCaps );
d->setSQLValidatorCallback( validatorCbk );
QgsWFSTableSelectedCallback *tableSelectedCbk = new QgsWFSTableSelectedCallback( d, uri, mCaps );
d->setTableSelectedCallback( tableSelectedCbk );
const bool bSupportJoins = mCaps.featureTypes.size() > 1 && mCaps.supportsJoins;
d->setSupportMultipleTables( bSupportJoins, QgsSQLStatement::quotedIdentifierIfNeeded( displayedTypeName ) );
QMap< QString, QString > mapTypenameToTitle;
Q_FOREACH ( const QgsWfsCapabilities::FeatureType f, mCaps.featureTypes )
mapTypenameToTitle[f.name] = f.title;
QList< QgsSQLComposerDialog::PairNameTitle > tablenames;
tablenames << QgsSQLComposerDialog::PairNameTitle(
QgsSQLStatement::quotedIdentifierIfNeeded( displayedTypeName ), mapTypenameToTitle[typeName] );
if ( bSupportJoins )
{
for ( int i = 0; i < mModel->rowCount(); i++ )
{
const QString iterTypename = mModel->index( i, MODEL_IDX_NAME ).data().toString();
if ( iterTypename != typeName )
{
QString displayedIterTypename( iterTypename );
QString unprefixedIterTypename( QgsWFSUtils::removeNamespacePrefix( iterTypename ) );
if ( !mCaps.setAmbiguousUnprefixedTypename.contains( unprefixedIterTypename ) )
displayedIterTypename = unprefixedIterTypename;
tablenames << QgsSQLComposerDialog::PairNameTitle(
QgsSQLStatement::quotedIdentifierIfNeeded( displayedIterTypename ), mapTypenameToTitle[iterTypename] );
}
}
}
d->addTableNames( tablenames );
QList< QgsSQLComposerDialog::Function> functionList;
Q_FOREACH ( const QgsWfsCapabilities::Function &f, mCaps.functionList )
{
QgsSQLComposerDialog::Function dialogF;
dialogF.name = f.name;
dialogF.returnType = f.returnType;
dialogF.minArgs = f.minArgs;
dialogF.maxArgs = f.maxArgs;
Q_FOREACH ( const QgsWfsCapabilities::Argument &arg, f.argumentList )
{
dialogF.argumentList << QgsSQLComposerDialog::Argument( arg.name, arg.type );
}
functionList << dialogF;
}
d->addFunctions( functionList );
QList< QgsSQLComposerDialog::Function> spatialPredicateList;
Q_FOREACH ( const QgsWfsCapabilities::Function &f, mCaps.spatialPredicatesList )
{
QgsSQLComposerDialog::Function dialogF;
dialogF.name = f.name;
dialogF.returnType = f.returnType;
dialogF.minArgs = f.minArgs;
dialogF.maxArgs = f.maxArgs;
Q_FOREACH ( const QgsWfsCapabilities::Argument &arg, f.argumentList )
{
dialogF.argumentList << QgsSQLComposerDialog::Argument( arg.name, arg.type );
}
spatialPredicateList << dialogF;
}
d->addSpatialPredicates( spatialPredicateList );
QList< QgsSQLComposerDialog::PairNameType> fieldList;
QString fieldNamePrefix;
if ( bSupportJoins )
{
fieldNamePrefix = QgsSQLStatement::quotedIdentifierIfNeeded( displayedTypeName ) + ".";
}
const auto constToList = p.fields().toList();
for ( const QgsField &field : constToList )
{
QString fieldName( fieldNamePrefix + QgsSQLStatement::quotedIdentifierIfNeeded( field.name() ) );
fieldList << QgsSQLComposerDialog::PairNameType( fieldName, field.typeName() );
}
if ( !p.geometryAttribute().isEmpty() )
{
QString fieldName( fieldNamePrefix + QgsSQLStatement::quotedIdentifierIfNeeded( p.geometryAttribute() ) );
fieldList << QgsSQLComposerDialog::PairNameType( fieldName, QStringLiteral( "geometry" ) );
}
fieldList << QgsSQLComposerDialog::PairNameType( fieldNamePrefix + "*", QString() );
d->addColumnNames( fieldList, QgsSQLStatement::quotedIdentifierIfNeeded( displayedTypeName ) );
d->setSql( sql );
mSQLIndex = index;
mSQLComposerDialog = d;
// For testability, do not use exec()
if ( property( "hideDialogs" ).toBool() )
{
d->setAttribute( Qt::WA_DeleteOnClose );
d->setModal( true );
d->open();
connect( d, &QDialog::accepted, this, &QgsWFSSourceSelect::updateSql );
}
else
{
// But we need to use exec() for real GUI, otherwise it does not look
// right on Mac
if ( d->exec() )
{
updateSql();
}
delete d;
}
}
void QgsWFSSourceSelect::updateSql()
{
QgsDebugMsg( QStringLiteral( "updateSql called" ) );
Q_ASSERT( mSQLComposerDialog );
const QString typeName = mSQLIndex.sibling( mSQLIndex.row(), MODEL_IDX_NAME ).data().toString();
QModelIndex filterIndex = mSQLIndex.sibling( mSQLIndex.row(), MODEL_IDX_SQL );
QString sql = mSQLComposerDialog->sql();
mSQLComposerDialog = nullptr;
QString displayedTypeName( typeName );
if ( !mCaps.setAmbiguousUnprefixedTypename.contains( QgsWFSUtils::removeNamespacePrefix( typeName ) ) )
displayedTypeName = QgsWFSUtils::removeNamespacePrefix( typeName );
QString allSql( "SELECT * FROM " + QgsSQLStatement::quotedIdentifierIfNeeded( displayedTypeName ) );
if ( sql == allSql )
sql.clear();
QgsDebugMsg( "SQL text = " + sql );
mModelProxy->setData( filterIndex, QVariant( sql ) );
}
void QgsWFSSourceSelect::changeCRS()
{
if ( mProjectionSelector->exec() )
{
QString crsString = mProjectionSelector->crs().authid();
labelCoordRefSys->setText( crsString );
}
}
void QgsWFSSourceSelect::changeCRSFilter()
{
QgsDebugMsg( QStringLiteral( "changeCRSFilter called" ) );
//evaluate currently selected typename and set the CRS filter in mProjectionSelector
QModelIndex currentIndex = treeView->selectionModel()->currentIndex();
if ( currentIndex.isValid() )
{
QString currentTypename = currentIndex.sibling( currentIndex.row(), MODEL_IDX_NAME ).data().toString();
QgsDebugMsg( QStringLiteral( "the current typename is: %1" ).arg( currentTypename ) );
QMap<QString, QStringList >::const_iterator crsIterator = mAvailableCRS.constFind( currentTypename );
if ( crsIterator != mAvailableCRS.constEnd() )
{
QSet<QString> crsNames( crsIterator->toSet() );
if ( mProjectionSelector )
{
mProjectionSelector->setOgcWmsCrsFilter( crsNames );
QString preferredCRS = getPreferredCrs( crsNames ); //get preferred EPSG system
if ( !preferredCRS.isEmpty() )
{
QgsCoordinateReferenceSystem refSys = QgsCoordinateReferenceSystem::fromOgcWmsCrs( preferredCRS );
mProjectionSelector->setCrs( refSys );
labelCoordRefSys->setText( preferredCRS );
}
}
}
}
}
void QgsWFSSourceSelect::cmbConnections_activated( int index )
{
Q_UNUSED( index );
QgsWfsConnection::setSelectedConnection( cmbConnections->currentText() );
QgsWfsConnection connection( cmbConnections->currentText() );
delete mCapabilities;
mCapabilities = new QgsWfsCapabilities( connection.uri().uri() );
connect( mCapabilities, &QgsWfsCapabilities::gotCapabilities, this, &QgsWFSSourceSelect::capabilitiesReplyFinished );
}
void QgsWFSSourceSelect::btnSave_clicked()
{
QgsManageConnectionsDialog dlg( this, QgsManageConnectionsDialog::Export, QgsManageConnectionsDialog::WFS );
dlg.exec();
}
void QgsWFSSourceSelect::btnLoad_clicked()
{
QString fileName = QFileDialog::getOpenFileName( this, tr( "Load Connections" ), QDir::homePath(),
tr( "XML files (*.xml *.XML)" ) );
if ( fileName.isEmpty() )
{
return;
}
QgsManageConnectionsDialog dlg( this, QgsManageConnectionsDialog::Import, QgsManageConnectionsDialog::WFS, fileName );
dlg.exec();
populateConnectionList();
emit connectionsChanged();
}
void QgsWFSSourceSelect::treeWidgetItemDoubleClicked( const QModelIndex &index )
{
QgsDebugMsg( QStringLiteral( "double-click called" ) );
buildQuery( index );
}
void QgsWFSSourceSelect::treeWidgetCurrentRowChanged( const QModelIndex ¤t, const QModelIndex &previous )
{
Q_UNUSED( previous )
QgsDebugMsg( QStringLiteral( "treeWidget_currentRowChanged called" ) );
changeCRSFilter();
mBuildQueryButton->setEnabled( current.isValid() );
emit enableButtons( current.isValid() );
}
void QgsWFSSourceSelect::buildQueryButtonClicked()
{
QgsDebugMsg( QStringLiteral( "mBuildQueryButton click called" ) );
buildQuery( treeView->selectionModel()->currentIndex() );
}
void QgsWFSSourceSelect::filterChanged( const QString &text )
{
QgsDebugMsg( "WFS FeatureType filter changed to :" + text );
QRegExp::PatternSyntax mySyntax = QRegExp::PatternSyntax( QRegExp::RegExp );
Qt::CaseSensitivity myCaseSensitivity = Qt::CaseInsensitive;
QRegExp myRegExp( text, myCaseSensitivity, mySyntax );
mModelProxy->setFilterRegExp( myRegExp );
mModelProxy->sort( mModelProxy->sortColumn(), mModelProxy->sortOrder() );
}
QSize QgsWFSItemDelegate::sizeHint( const QStyleOptionViewItem &option, const QModelIndex &index ) const
{
QVariant indexData;
indexData = index.data( Qt::DisplayRole );
if ( indexData.isNull() )
{
return QSize();
}
QString data = indexData.toString();
QSize size = option.fontMetrics.boundingRect( data ).size();
size.setHeight( size.height() + 2 );
return size;
}
void QgsWFSSourceSelect::showHelp()
{
QgsHelp::openHelp( QStringLiteral( "working_with_ogc/ogc_client_support.html" ) );
}
| 35.557962 | 149 | 0.700534 | [
"geometry"
] |
0b0c86e9446ebdb389d733e609970d9d256816f2 | 1,754 | cpp | C++ | Lessons/2-Arrays/cyclicRotation.cpp | Visn0/Codility | 51999e0f61bbc0ed8c30304cc8181e2adaf90c5b | [
"MIT"
] | null | null | null | Lessons/2-Arrays/cyclicRotation.cpp | Visn0/Codility | 51999e0f61bbc0ed8c30304cc8181e2adaf90c5b | [
"MIT"
] | null | null | null | Lessons/2-Arrays/cyclicRotation.cpp | Visn0/Codility | 51999e0f61bbc0ed8c30304cc8181e2adaf90c5b | [
"MIT"
] | null | null | null | /*
An array A consisting of N integers is given. Rotation of the array means that each element is
shifted right by one index, and the last element of the array is moved to the first place. For
example, the rotation of array A = [3, 8, 9, 7, 6] is [6, 3, 8, 9, 7] (elements are shifted right by
one index and 6 is moved to the first place).
The goal is to rotate array A K times; that is,
each element of A will be shifted to the right K times.
Write a function: vector<int> solution(vector<int> &A, int K);
that, given an array A consisting of N integers and an integer K,
returns the array A rotated K times.
For example, given
A = [3, 8, 9, 7, 6]
K = 3
the function should return [9, 7, 6, 3, 8]. Three rotations were made:
[3, 8, 9, 7, 6] -> [6, 3, 8, 9, 7]
[6, 3, 8, 9, 7] -> [7, 6, 3, 8, 9]
[7, 6, 3, 8, 9] -> [9, 7, 6, 3, 8]
For another example, given
A = [0, 0, 0]
K = 1
the function should return [0, 0, 0]
Given
A = [1, 2, 3, 4]
K = 4
the function should return [1, 2, 3, 4]
Assume that:
N and K are integers within the range [0..100];
each element of array A is an integer within the range [−1,000..1,000].
In your solution, focus on correctness.
The performance of your solution will not be the focus of the assessment.
*/
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
vector<int> solution(vector<int> &A, int K)
{
if (A.empty())
return A;
if (size_t(K) > A.size())
K = K % A.size();
std::rotate(A.begin(), A.end() - K, A.end());
return A;
}
int main()
{
vector<int> array({3, 8, 9, 7, 6});
for (int v : array)
{
cout << v << " ";
}
cout << endl;
for (int v : solution(array, 6))
{
cout << v << " ";
}
cout << endl;
}
| 24.361111 | 100 | 0.614595 | [
"vector"
] |
0b1c18ff41cbc485d2e11b3a4e04dd890df0b89c | 3,154 | hpp | C++ | cpp/src/copying/legacy/slice.hpp | wbo4958/cudf | b12f24d25815145a573a9d70f8c6140a8ab9d2cb | [
"Apache-2.0"
] | null | null | null | cpp/src/copying/legacy/slice.hpp | wbo4958/cudf | b12f24d25815145a573a9d70f8c6140a8ab9d2cb | [
"Apache-2.0"
] | null | null | null | cpp/src/copying/legacy/slice.hpp | wbo4958/cudf | b12f24d25815145a573a9d70f8c6140a8ab9d2cb | [
"Apache-2.0"
] | null | null | null | /*
* Copyright 2019 BlazingDB, Inc.
* Copyright 2019 Christian Noboa Mardini <christian@blazingdb.com>
* Copyright 2019 William Scott Malpica <william@blazingdb.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef COPYING_SLICE_HPP
#define COPYING_SLICE_HPP
#include <cudf/types.h>
#include <vector>
namespace cudf {
namespace detail {
/**
* @brief Slices a column (including null values) into a set of columns
* according to a set of indices.
*
* The "slice" function divides part of the input column into multiple intervals
* of rows using the indices values and it stores the intervals into the output
* columns. Regarding the interval of indices, a pair of values are taken from
* the indices array in a consecutive manner. The pair of indices are left-closed
* and right-open.
*
* The pairs of indices in the array are required to comply with the following
* conditions:
* a, b belongs to Range[0, input column size]
* a <= b, where the position of a is less or equal to the position of b.
* There is no relationship between the values of each pair of indices.
*
* Exceptional cases for the indices array are:
* When the values in the pair are equal, the function returns an empty column.
* When the values in the pair are 'strictly decreasing', the outcome is
* undefined.
* When any of the values in the pair don't belong to the range[0, input column
* size), the outcome is undefined.
*
* The output columns will be allocated by the function.
*
* It uses an vector of 'cudaStream_t' in order to process in a parallel manner
* the different output columns. In case of the size of the streams is less than
* the size of the output columns, it reassigns again the streams with the remaining
* output columns.
*
* Example:
* input: {10, 12, 14, 16, 18, 20, 22, 24, 26, 28}
* indices: {1, 3, 5, 9, 2, 4, 8, 8}
* output: {{12, 14}, {20, 22, 24, 26}, {14, 16}, {}}
*
* @param[in] input_column The input column whose rows will be sliced.
* @param[in] indices An array of indices that are used to take 'slices'
* of the input column.
* @param[in] streams An vector of 'cudaStream_t' in order to process every output
* @Returns output_columns A set of gdf_column*. Each column can have
* a different number of rows that are equal to the difference of two
* consecutive indices in the indices array.
*/
std::vector<gdf_column*> slice(
gdf_column const& input_column,
cudf::size_type const* indices,
cudf::size_type num_indices,
std::vector<cudaStream_t> const& streams = std::vector<cudaStream_t>{});
} // namespace detail
} // namespace cudf
#endif
| 39.425 | 88 | 0.723209 | [
"vector"
] |
0b20dde7f49d97722d203a2c14e6afa26e2af85f | 4,126 | cpp | C++ | src/render/mesh.cpp | ugozapad/pbr-sandbox | 07417cc68b9422ff01b4c293a42d8ce65f9297ca | [
"BSD-2-Clause"
] | null | null | null | src/render/mesh.cpp | ugozapad/pbr-sandbox | 07417cc68b9422ff01b4c293a42d8ce65f9297ca | [
"BSD-2-Clause"
] | null | null | null | src/render/mesh.cpp | ugozapad/pbr-sandbox | 07417cc68b9422ff01b4c293a42d8ce65f9297ca | [
"BSD-2-Clause"
] | null | null | null | #include "render/mesh.h"
#include "render/renderdevice.h"
#include "render/vertexbuffer.h"
#include "render/indexbuffer.h"
#include <string>
#include <glm/gtx/matrix_decompose.hpp>
#include "glad/glad.h"
inline static glm::mat4 ai_to_gl(const aiMatrix4x4& from)
{
return glm::mat4(
(double)from.a1, (double)from.b1, (double)from.c1, (double)from.d1,
(double)from.a2, (double)from.b2, (double)from.c2, (double)from.d2,
(double)from.a3, (double)from.b3, (double)from.c3, (double)from.d3,
(double)from.a4, (double)from.b4, (double)from.c4, (double)from.d4
);
}
Mesh* Mesh::createFromSceneNode(aiMesh* mesh, aiNode* node, const aiScene* scene)
{
std::vector<Vertex> vertices;
std::vector<uint32_t> indices;
for (uint32_t i = 0; i < mesh->mNumVertices; i++) {
Vertex vertex;
vertex.pos.x = mesh->mVertices[i].x;
vertex.pos.y = mesh->mVertices[i].y;
vertex.pos.z = mesh->mVertices[i].z;
if (mesh->HasNormals()) {
vertex.normal.x = mesh->mNormals[i].x;
vertex.normal.y = mesh->mNormals[i].y;
vertex.normal.z = mesh->mNormals[i].z;
}
//if (mesh->HasTextureCoords(0))
if (mesh->mTextureCoords[0]) {
vertex.texcoord.x = mesh->mTextureCoords[0][i].x;
vertex.texcoord.y = mesh->mTextureCoords[0][i].y;
} else {
vertex.texcoord = glm::vec2(0.0f, 0.0f);
}
vertices.push_back(vertex);
}
for (uint32_t i = 0; i < mesh->mNumFaces; i++) {
aiFace face = mesh->mFaces[i];
for (unsigned int j = 0; j < face.mNumIndices; j++)
indices.push_back(face.mIndices[j]);
}
MaterialCreationInfo material_info;
material_info.init();
aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex];
aiString ai_albedo_name;
if (material->GetTexture(aiTextureType_BASE_COLOR, 0, &ai_albedo_name) != aiReturn_SUCCESS)
material->GetTexture(aiTextureType_DIFFUSE, 0, &ai_albedo_name);
std::string albedo_name = "data/sponza/glTF/";
albedo_name += ai_albedo_name.C_Str();
material_info.m_albedo_filename = strdup(albedo_name.c_str());
aiString ai_normal_name;
material->GetTexture(aiTextureType_NORMALS, 0, &ai_normal_name);
std::string normalmap_name = ai_normal_name.C_Str();
if (!normalmap_name.empty())
{
normalmap_name.clear();
normalmap_name = "data/sponza/glTF/";
normalmap_name += ai_normal_name.C_Str();
material_info.m_normal_filename = strdup(normalmap_name.c_str());
}
glm::mat4 matr = glm::mat4(1.0f);
matr = ai_to_gl(node->mTransformation);
//matr = glm::scale(matr, glm::vec3(0.1f));
return new Mesh(material_info, vertices, indices, matr);
}
Mesh::Mesh(const MaterialCreationInfo& info,
const std::vector<Vertex>& vertices,
const std::vector<uint32_t>& indices,
const glm::mat4& mat)
{
m_vb_count = vertices.size();
m_vertex_buffer = RenderDevice::getInstance()->createVertexBuffer((void*)vertices.data(), vertices.size() * sizeof(Vertex), BufferAccess::Static);
m_ib_count = indices.size();
m_index_buffer = RenderDevice::getInstance()->createIndexBuffer((void*)indices.data(), indices.size() * sizeof(uint32_t), BufferAccess::Static);
m_material.init(info);
m_transform = mat;
updateInternalMatricesAndVectors();
}
Mesh::~Mesh()
{
m_material.release();
RenderDevice::getInstance()->deleteIndexBuffer(m_index_buffer);
RenderDevice::getInstance()->deleteVertexBuffer(m_vertex_buffer);
}
void Mesh::render()
{
RenderDevice::getInstance()->setVertexBuffer(m_vertex_buffer);
// position attribute
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);
// normal attribute
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
glEnableVertexAttribArray(1);
// texture coord attribute
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
glEnableVertexAttribArray(2);
RenderDevice::getInstance()->setIndexBuffer(m_index_buffer);
m_material.render(m_ib_count, m_transform);
}
void Mesh::updateInternalMatricesAndVectors()
{
glm::vec3 translation;
glm::vec3 skew;
glm::vec4 perspective;
glm::decompose(m_transform, m_scale, m_rot, m_pos, skew, perspective);
}
| 28.853147 | 147 | 0.721037 | [
"mesh",
"render",
"vector"
] |
0b216927a54cce75064232b65460713ded160087 | 654 | cpp | C++ | Oath3D/src/System/ECS/Entity.cpp | BertilBraun/Oath3D | e713f4f97bd1998d6c7a67414ff5f80d6d30e7f9 | [
"MIT"
] | 3 | 2019-01-10T18:39:45.000Z | 2022-01-11T01:33:57.000Z | Oath3D/src/System/ECS/Entity.cpp | BertilBraun/Oath3D | e713f4f97bd1998d6c7a67414ff5f80d6d30e7f9 | [
"MIT"
] | null | null | null | Oath3D/src/System/ECS/Entity.cpp | BertilBraun/Oath3D | e713f4f97bd1998d6c7a67414ff5f80d6d30e7f9 | [
"MIT"
] | 1 | 2019-12-23T19:37:00.000Z | 2019-12-23T19:37:00.000Z | #include "Common/Common.h"
#include "Entity.h"
#include "Manager.h"
namespace Oath {
ECS::Entity::Entity(Manager* ecs) : ecs(ecs), transform(this) { }
ECS::Entity::~Entity()
{
for (ECS::Entity* child : childs)
ecs->removeEntity(child);
}
void ECS::Entity::add(Entity * e) {
childs.push_back(e);
e->parent = this;
}
void ECS::Entity::add(Script * script) {
scripts.emplace_back(script);
try
{
script->Start();
}
catch (const std::exception& e)
{
LOGERROR(e.what());
}
}
ECS::BaseComponent * ECS::Entity::getComponentByType(ComponentID componentID)
{
return ecs->getComponentByType(this, componentID);
}
} | 17.210526 | 78 | 0.648318 | [
"transform"
] |
0b22b070fae94af0382e6bb8a20e8729d372e21c | 2,021 | hpp | C++ | include/Core/Utils/MapUtils.hpp | BestEggplant/ObEngine | 4543ff027cc05de0eddede8f55b28f0cf1138189 | [
"MIT"
] | 1 | 2020-07-23T14:23:59.000Z | 2020-07-23T14:23:59.000Z | include/Core/Utils/MapUtils.hpp | BestEggplant/ObEngine | 4543ff027cc05de0eddede8f55b28f0cf1138189 | [
"MIT"
] | null | null | null | include/Core/Utils/MapUtils.hpp | BestEggplant/ObEngine | 4543ff027cc05de0eddede8f55b28f0cf1138189 | [
"MIT"
] | null | null | null | #pragma once
#include <map>
#include <vector>
/**
* \brief Some functions to handle maps
*/
namespace obe::Utils::Map
{
/**
* \nobind
* \brief Check if the given value is found in the std::map
* \tparam MapType type of the std::map you want to search a value from
* \param item Value to search in the map
* \param map Reference to the map you want to search the value in
* \return true if the value has been found, false otherwise
*/
template <class MapType>
bool valueInMap(typename MapType::value_type item, MapType&& map);
/**
* \nobind
* \brief Check if the given key is found in the std::map
* \tparam MapType type of the std::map you want to search a key from
* \param item key to search in the map
* \param map Reference to the map you want to search the key in
* \return true if the key has been found, false otherwise
*/
template <class MapType>
bool keyInMap(typename MapType::key_type item, MapType&& map);
/**
* \nobind
*/
template <class MapType>
std::vector<typename std::decay_t<MapType>::key_type> getKeys(MapType&& map);
template <class MapType>
bool valueInMap(typename MapType::value_type item, MapType&& map)
{
for (const auto& [key, value] : map)
{
if (value == item)
return true;
}
return false;
}
template <class MapType> bool keyInMap(typename MapType::key_type item, MapType&& map)
{
for (const auto& [key, value] : map)
{
if (key == item)
return true;
}
return false;
}
template <class MapType>
std::vector<typename std::decay_t<MapType>::key_type> getKeys(MapType&& map)
{
std::vector<typename std::decay_t<MapType>::key_type> keys;
keys.reserve(map.size());
for (const auto& [key, value] : map)
keys.push_back(key);
return keys;
}
} // namespace obe::Utils::Map | 29.720588 | 90 | 0.602672 | [
"vector"
] |
0b2971908a4d3ace5cdc7a0437960b4df5dddb00 | 3,275 | cpp | C++ | Test/POP3/SmtpMailer.cpp | BartoszMilewski/CodeCoop | 7d29f53ccf65b0d29ea7d6781a74507b52c08d0d | [
"MIT"
] | 67 | 2018-03-02T10:50:02.000Z | 2022-03-23T18:20:29.000Z | Test/POP3/SmtpMailer.cpp | BartoszMilewski/CodeCoop | 7d29f53ccf65b0d29ea7d6781a74507b52c08d0d | [
"MIT"
] | null | null | null | Test/POP3/SmtpMailer.cpp | BartoszMilewski/CodeCoop | 7d29f53ccf65b0d29ea7d6781a74507b52c08d0d | [
"MIT"
] | 9 | 2018-03-01T16:38:28.000Z | 2021-03-02T16:17:09.000Z | // ---------------------------
// (c) Reliable Software, 2005
// ---------------------------
#include "precompiled.h"
#include "SmtpMailer.h"
#include "EmailMessage.h"
#include <Mail/Base64.h>
#include <Mail/SmtpMessage.h>
#include <Mail/SmtpUtils.h>
#include <Mail/MsgTree.h>
Smtp::Mailer::Mailer (
std::string const & server,
std::string const & user,
std::string const & password,
std::string const & senderAddress,
std::string const & domain)
: _connection (server, 25, false),
_session (_connection, domain, false), // don't use SSL
_senderAddress (senderAddress)
{
// this step is optional
_session.Authenticate (user, password);
}
void Smtp::Mailer::Send (
OutgoingMessage const & msg,
std::vector<std::string> const & addrVector,
std::string const & toFieldLabel)
{
// To: field
std::string toField;
if (!toFieldLabel.empty ())
{
// toField = toFieldLabel + ":;";
}
Socket & socket = _connection.GetSocket ();
// ================
// SMTP: MESSAGE ENVELOPE
// Sender
std::string mailFromCmd = "MAIL FROM: " + ToBracketedString (_senderAddress);
socket.SendLine (mailFromCmd.c_str ());
Smtp::Response mailfromResponse (socket);
if (mailfromResponse.GetStatus () != Smtp::Response::Ok)
throw Win::Exception ("SMTP error: cannot initiate send transaction.", mailfromResponse.c_str ());
// SMTP: MESSAGE ENVELOPE
// Recipient(s)
// Revisit: a list of recipients cannot be arbitrary long!
// Servers are obliged to handle at least 100 recipients
for (unsigned int i = 0; i < addrVector.size (); ++i)
{
// RCPT TO:
std::string bracketedAddr = ToBracketedString (addrVector [i]);
std::string rcptToCmd = "RCPT TO: " + bracketedAddr;
socket.SendLine (rcptToCmd.c_str ());
Smtp::Response rcpttoResponse (socket);
if (rcpttoResponse.GetStatus () != Smtp::Response::Ok)
throw Win::Exception ("SMTP error: server refused email address of recipient.", rcpttoResponse.c_str ());
}
// ===============
// SMTP: MESSAGE CONTENT
socket.SendLine ("DATA");
Smtp::Response dataResponse (socket);
if (dataResponse.GetStatus () != Smtp::Response::DataCmdOk)
throw Win::Exception ("SMTP error: server refused accepting message.", dataResponse.c_str ());
Smtp::Message smtpMsg ("Bartosz Milewski", _senderAddress, msg.GetSubject ());
if (!msg.UseBccRecipients ())
smtpMsg.SetToField (addrVector);
if (msg.GetAttachmentCount () > 0)
{
// Body
std::auto_ptr<MultipartMixedPart> body (new MultipartMixedPart ());
// Text part
std::auto_ptr<MessagePart> plainText (new PlainTextPart (msg.GetText ()));
body->AddPart (plainText);
// Binary parts
for (OutgoingMessage::AttPathIter attIter = msg.AttPathBegin ();
attIter != msg.AttPathEnd ();
++attIter)
{
std::auto_ptr<MessagePart> attachment (
new ApplicationOctetStreamPart (*attIter));
body->AddPart (attachment);
}
smtpMsg.AddBody (std::auto_ptr<MessagePart>(body));
}
else
{
std::auto_ptr<MessagePart> plainText (new PlainTextPart (msg.GetText ()));
smtpMsg.AddBody (plainText);
}
smtpMsg.Send (socket);
Smtp::Response dataendResponse (socket);
if (dataendResponse.GetStatus () != Smtp::Response::Ok)
throw Win::Exception ("SMTP error: server did not accept message.", dataendResponse.c_str ());
}
| 30.607477 | 108 | 0.679389 | [
"vector"
] |
0b2ebe58ed1076b7b40a85ceb5c459220d78a158 | 889 | cpp | C++ | HiringContests/CodeVita2017/mockvita_ram_and_chocolate.cpp | ysumit99/Compi-Coding | d0e96c4f024328b0bfb799fab927919dae367f7a | [
"MIT"
] | 1 | 2019-04-19T13:06:33.000Z | 2019-04-19T13:06:33.000Z | HiringContests/CodeVita2017/mockvita_ram_and_chocolate.cpp | ysumit99/Compi-Coding | d0e96c4f024328b0bfb799fab927919dae367f7a | [
"MIT"
] | null | null | null | HiringContests/CodeVita2017/mockvita_ram_and_chocolate.cpp | ysumit99/Compi-Coding | d0e96c4f024328b0bfb799fab927919dae367f7a | [
"MIT"
] | null | null | null | #include <bits/stdc++.h>
//using namespace std;
int main(int argc, char const *argv[])
{
int n,ele;
scanf("%d",&n);
int first = 0,rest = 0;
std::vector<int> v;
for (int i = 0; i < n; ++i)
{
scanf("%d",&ele);
v.push_back(ele);
if(i == 0 )
first = ele;
else
rest += ele;
}
//cout<<first<<" "<<rest<<endl;
int sn,left,flag = 0;
int result=1000000,offset,temp;
for (int i = 1; i <= 500; ++i)
{ left = rest;
sn = (2*i+((n-1)*3));
sn *= n;
sn /= 2;
//cout<<"sn = "<<sn<<endl;
//temp = first - i;
left+=(first-i);
if(sn - i == left)
{
flag = 1;//possible
temp = i;
offset = 0;
for (int j = 0; j < n ; ++j)
{
offset += abs(v[j]-temp);
temp+=3;
}
if((offset/2) < result)
result = offset/2;
//cout<<"offset = "<<offset/2<<endl;
}
}
if(flag == 0)
printf("No");
else
printf("Yes %d",result);
return 0;
} | 15.327586 | 39 | 0.490439 | [
"vector"
] |
0b314bb7694ddf08bd17cdd44b5c836a3618ebd5 | 10,859 | cpp | C++ | src/sampling.cpp | hsloot/cvalr | c5f9f9af607f73b30c40bd91a0cd4d855f5efb52 | [
"MIT"
] | 1 | 2021-05-13T21:32:31.000Z | 2021-05-13T21:32:31.000Z | src/sampling.cpp | hsloot/cvalr | c5f9f9af607f73b30c40bd91a0cd4d855f5efb52 | [
"MIT"
] | 27 | 2021-01-16T15:29:35.000Z | 2021-11-28T16:46:15.000Z | src/sampling.cpp | hsloot/cvalr | c5f9f9af607f73b30c40bd91a0cd4d855f5efb52 | [
"MIT"
] | 1 | 2021-05-13T21:32:14.000Z | 2021-05-13T21:32:14.000Z |
// clang-format off
#include <Rcpp.h>
#include <rmolib/random/r_engine.hpp> // must be included before <rmolib/*>
// clang-format on
#include "rmolib/algorithm/r_shuffle.hpp"
#include "rmolib/random/multivariate/armageddon_extmo_distribution.hpp"
#include "rmolib/random/multivariate/markovian_exmo_distribution.hpp"
#include "rmolib/random/univariate/exponential_distribution.hpp"
#include "rmolib/random/univariate/discrete_distribution.hpp"
#include "rmolib/random/univariate/uniform_int_distribution.hpp"
#include "rmolib/random/univariate/uniform_real_distribution.hpp"
#include <cvalr.hpp>
using namespace Rcpp;
static const R_xlen_t C_CHECK_USR_INTERRUP = 100000;
using exponential_distribution = rmolib::random::exponential_distribution<double>;
using uniform_real_distribution = rmolib::random::uniform_real_distribution<double>;
using uniform_int_distribution = rmolib::random::uniform_int_distribution<std::size_t>;
using discrete_distribution =
rmolib::random::discrete_distribution<std::size_t, double, uniform_real_distribution,
uniform_int_distribution>;
using armageddon_extmo_distribution =
rmolib::random::armageddon_extmo_distribution<double, exponential_distribution>;
using markovian_exmo_distribution =
rmolib::random::markovian_exmo_distribution<double, exponential_distribution,
uniform_int_distribution, discrete_distribution,
rmolib::algorithm::shuffler>;
struct no_shuffler {
template <typename _RandomAccessIterator, typename _Engine, typename _UniformIntDistribution>
void operator()(_RandomAccessIterator first, _RandomAccessIterator last, _Engine &&engine,
_UniformIntDistribution &&dist) const {
return;
}
};
using markovian_exmo_adcp_distribution = rmolib::random::markovian_exmo_distribution<
double, exponential_distribution, uniform_int_distribution, discrete_distribution, no_shuffler>;
// [[Rcpp::export]]
NumericMatrix Rcpp__rexmo_markovian_acdp(const std::size_t n, const NumericVector ×,
const std::size_t d, const NumericVector &ex_intensities) {
using dist_t = markovian_exmo_adcp_distribution;
using parm_t = typename dist_t::param_type;
auto engine = r_engine{};
const auto parm = parm_t{d, ex_intensities.begin(), ex_intensities.end()};
auto dist = dist_t{};
auto m = static_cast<std::size_t>(times.size());
auto out = NumericMatrix(no_init(n, m));
for (auto k = R_xlen_t{0}; k < n; ++k) {
if ((d * k) % C_CHECK_USR_INTERRUP == 0) Rcpp::checkUserInterrupt();
const auto values = dist(engine, parm);
cvalr::dt2adcp(values.cbegin(), values.cend(), times.cbegin(), times.cend(), out(k, _).begin());
}
return out;
}
// [[Rcpp::export]]
NumericMatrix Rcpp__rarmextmo_esm_adcp(const std::size_t n, const NumericVector ×,
const std::size_t d, const double alpha, const double beta) {
using dist_t = armageddon_extmo_distribution;
using parm_t = typename dist_t::param_type;
auto engine = r_engine{};
const auto parm = parm_t{d, alpha, beta};
auto dist = dist_t{};
auto m = static_cast<std::size_t>(times.size());
auto out = NumericMatrix(no_init(n, m));
for (auto k = R_xlen_t{0}; k < n; ++k) {
if ((d * k) % C_CHECK_USR_INTERRUP == 0) Rcpp::checkUserInterrupt();
const auto values = dist(engine, parm);
cvalr::dt2adcp(values.cbegin(), values.cend(), times.cbegin(), times.cend(), out(k, _).begin());
}
return out;
}
bool is_s4(SEXP x) { return ::Rf_isS4(x); }
S4 as_s4(SEXP x) {
if (!is_s4(x)) stop("Not an S4 object");
return S4(x);
}
template <typename _MODistribution>
typename _MODistribution::param_type extract_param(SEXP x, const double scale);
template <>
typename armageddon_extmo_distribution::param_type extract_param<armageddon_extmo_distribution>(
SEXP x, const double scale) {
using parm_t = typename armageddon_extmo_distribution::param_type;
const auto model = as_s4(x);
if (!model.is("ArmageddonExtMO2FParam")) stop("Not an ArmageddonExtMO2FParam");
const auto dim = as<std::size_t>(model.slot("dim"));
const auto lambda = as<double>(model.slot("lambda"));
const auto nu = as<double>(model.slot("nu"));
const auto alpha = lambda * (1. - nu) * scale;
const auto beta = lambda * nu * scale;
return parm_t{dim, alpha, beta};
}
template <>
typename markovian_exmo_distribution::param_type extract_param<markovian_exmo_distribution>(
SEXP x, const double scale) {
using parm_t = typename markovian_exmo_distribution::param_type;
const auto model = as_s4(x);
if (!model.is("ExMOParam")) stop("Not an ExMOParam");
auto ex_intensities = as<std::vector<double>>(NumericVector(model.slot("ex_intensities")));
std::transform(ex_intensities.cbegin(), ex_intensities.cend(), ex_intensities.begin(),
[scale](const auto val) { return scale * val; });
return parm_t{static_cast<std::size_t>(ex_intensities.size()), ex_intensities.cbegin(),
ex_intensities.cend()};
}
template <>
typename markovian_exmo_adcp_distribution::param_type extract_param<markovian_exmo_adcp_distribution>(
SEXP x, const double scale) {
using parm_t = typename markovian_exmo_adcp_distribution::param_type;
const auto model = as_s4(x);
if (!model.is("ExMOParam")) stop("Not an ExMOParam");
auto ex_intensities = as<std::vector<double>>(NumericVector(model.slot("ex_intensities")));
std::transform(ex_intensities.cbegin(), ex_intensities.cend(), ex_intensities.begin(),
[scale](const auto val) { return scale * val; });
return parm_t{static_cast<std::size_t>(ex_intensities.size()), ex_intensities.cbegin(),
ex_intensities.cend()};
}
template <typename _MODistribution>
typename _MODistribution::param_type extract_global_param(const List &models, const double scale) {
if (models.cbegin() == models.cend()) stop("Empty list");
return extract_param<_MODistribution>(models[0], scale);
}
template <typename _MODistribution>
std::vector<typename _MODistribution::param_type> extract_partition_params(const List &models,
const double scale) {
if (models.cbegin() == models.cend()) stop("Empty list");
if (++(models.cbegin()) == models.cend()) stop("One element list");
auto out = std::vector<typename _MODistribution::param_type>{};
for (auto [it, out_it] = std::make_pair(++(models.cbegin()), std::back_inserter(out));
it != models.cend(); ++it, ++out_it) {
*out_it = extract_param<_MODistribution>(*it, scale);
}
return out;
}
template <typename _MODistribution>
NumericMatrix Rcpp__rh2exmo_dt(const std::size_t n, const double fraction, const List &models) {
using dist_t = _MODistribution;
auto engine = r_engine{};
const auto global_parm = extract_global_param<dist_t>(models, fraction);
const auto partition_parms = extract_partition_params<dist_t>(models, 1. - fraction);
auto dist = dist_t{};
const auto d = global_parm.dim();
const auto partition_sum =
std::accumulate(partition_parms.cbegin(), partition_parms.cend(), std::size_t{0},
[](const auto acc, const auto &val) { return acc + val.dim(); });
if (!(d == partition_sum)) stop("Invalid partition");
auto out = NumericMatrix(no_init(n, d));
for (auto k = R_xlen_t{0}; k < n; ++k) {
if ((d * k) % C_CHECK_USR_INTERRUP == 0) Rcpp::checkUserInterrupt();
const auto global_values = dist(engine, global_parm);
auto partition_values = std::vector<double>{};
partition_values.reserve(d);
auto it = std::back_inserter(partition_values);
for (const auto &parm : partition_parms) {
const auto values = dist(engine, parm);
it = std::copy(values.cbegin(), values.cend(), it);
}
std::transform(global_values.cbegin(), global_values.cend(), partition_values.cbegin(),
out(k, _).begin(), [](const auto x, const auto y) { return std::min(x, y); });
}
return out;
}
// [[Rcpp::export]]
NumericMatrix Rcpp__rh2exmo_markovian_dt(const std::size_t n, const double fraction,
const List &models) {
return Rcpp__rh2exmo_dt<markovian_exmo_distribution>(n, fraction, models);
}
// [[Rcpp::export]]
NumericMatrix Rcpp__rh2extarmmo_esm_dt(const std::size_t n, const double fraction,
const List &models) {
return Rcpp__rh2exmo_dt<armageddon_extmo_distribution>(n, fraction, models);
}
template <typename _MODistribution>
NumericMatrix Rcpp__rh2exmo_adcp(const std::size_t n, const NumericVector ×,
const double fraction, const List &models) {
using dist_t = _MODistribution;
auto engine = r_engine{};
const auto global_parm = extract_global_param<dist_t>(models, fraction);
const auto partition_parms = extract_partition_params<dist_t>(models, 1. - fraction);
auto dist = dist_t{};
const auto d = global_parm.dim();
const auto partition_sum =
std::accumulate(partition_parms.cbegin(), partition_parms.cend(), std::size_t{0},
[](const auto acc, const auto &val) { return acc + val.dim(); });
if (!(d == partition_sum)) stop("Invalid partition");
auto m = static_cast<std::size_t>(times.size());
auto out = NumericMatrix(no_init(n, m));
for (auto k = R_xlen_t{0}; k < n; ++k) {
if ((d * k) % C_CHECK_USR_INTERRUP == 0) Rcpp::checkUserInterrupt();
const auto global_values = dist(engine, global_parm);
auto partition_values = std::vector<double>{};
partition_values.reserve(d);
auto it = std::back_inserter(partition_values);
for (const auto &parm : partition_parms) {
const auto values = dist(engine, parm);
it = std::copy(values.cbegin(), values.cend(), it);
}
auto values = std::vector<double>(d);
std::transform(global_values.cbegin(), global_values.cend(), partition_values.cbegin(),
values.begin(), [](const auto x, const auto y) { return std::min(x, y); });
cvalr::dt2adcp(values.cbegin(), values.cend(), times.cbegin(), times.cend(), out(k, _).begin());
}
return out;
}
// [[Rcpp::export]]
NumericMatrix Rcpp__rh2exmo_markovian_adcp(const std::size_t n, const NumericVector ×,
const double fraction, const List &models) {
return Rcpp__rh2exmo_adcp<markovian_exmo_adcp_distribution>(n, times, fraction, models);
}
// [[Rcpp::export]]
NumericMatrix Rcpp__rh2extarmmo_esm_adcp(const std::size_t n, const NumericVector ×,
const double fraction, const List &models) {
return Rcpp__rh2exmo_adcp<armageddon_extmo_distribution>(n, times, fraction, models);
}
| 42.920949 | 102 | 0.689198 | [
"object",
"vector",
"model",
"transform"
] |
0b32e1afac3f2bac68c1b463d0fd93c105383ab8 | 6,687 | cpp | C++ | Acodemia/source/manager/PhysicalManager.cpp | jackflower/Acodemia | 779d1ea76cf7c3841aa57e7a3f3c45591a5a2940 | [
"MIT"
] | 2 | 2019-11-26T09:50:56.000Z | 2019-11-30T19:40:42.000Z | Acodemia/source/manager/PhysicalManager.cpp | jackflower/Acodemia | 779d1ea76cf7c3841aa57e7a3f3c45591a5a2940 | [
"MIT"
] | null | null | null | Acodemia/source/manager/PhysicalManager.cpp | jackflower/Acodemia | 779d1ea76cf7c3841aa57e7a3f3c45591a5a2940 | [
"MIT"
] | null | null | null | ////////////////////////////////////////////////////////////
//
// Acodemia Copyright (C) Jacek Kwiatek
// e-mail: jackflower (at) poczta.onet.pl
// acodemia.pl
//
// To oprogramowanie dostarczane jest w postaci takiej,
// w jakiej jest, bez wyraźnych ani domniemanych gwarancji.
//
// W żadnym wypadku Autor nie ponosi odpowiedzialności
// za jakiekolwiek szkody powstałe w wyniku korzystania
// z tego oprogramowania.
//
// Zezwala się na korzystanie z tego oprogramowania
// w dowolnym celu, także komercyjnym. Można je zmienić
// i swobodnie rozpowszechniać.
//
// Zastrzega się następujące ograniczenia:
//
// 1. Jeśli używasz tego oprogramowania w swoich
// produktach, potwierdzenie pochodzenia tego
// oprogramowania w dokumentacji produktu,
// byłoby docenione, ale nie jest wymagane.
//
////////////////////////////////////////////////////////////
#include "PhysicalManager.h"
#include "../physicals/physical/Physical.h"
#include "../physicals/bullet/Bullet.h"
#include "../physicals/actor/Actor.h"
#include "../physicals/player/Player.h"
#include "../physicals/enemy/Enemy.h"
#include "../explosion/Explosion.h"
#include<iostream>
using namespace acodemia::physical;
//Konstruktor domyślny
PhysicalManager::PhysicalManager()
:
m_physicals(),
width(800),
height(600.f)
{
}
//Destruktor wirtualny
PhysicalManager::~PhysicalManager()
{
std::vector<Physical*>::iterator it;
for (it = m_physicals.begin(); it != m_physicals.end(); it++)
{
if((*it))
delete (*it);
}
m_physicals.clear();
}
//Metoda zwraca stałą referencję kontenera
const std::vector<Physical *> & PhysicalManager::getPhysicals()
{
return m_physicals;
}
//Metoda rejestruje w kontenerze wskaźniki na obiekty Physical
void PhysicalManager::registerPhysical(Physical * physical)
{
m_physicals.push_back(physical);
}
//Metoda tworzy obiekt klasy Physical i zwraca wskaźnik na ten obiekt
Physical *PhysicalManager::CreatePhysical()
{
return Create<Physical>();
}
//Metoda tworzy obiekt klasy Bullet i zwraca wskaźnik na ten obiekt
Bullet *PhysicalManager::CreateBullet()
{
return Create<Bullet>();
}
//Metoda tworzy obiekt klasy Actor i zwraca wskaźnik na ten obiekt
Actor *PhysicalManager::CreateActor()
{
return Create<Actor>();
}
//Metoda tworzy obiekt klasy Player i zwraca wskaźnik na ten obiekt
Player *PhysicalManager::CreatePlayer()
{
return Create<Player>();
}
//Metoda tworzy obiekt klasy Enemy i zwraca wskaźnik na ten obiekt
Enemy *PhysicalManager::CreateEnemy()
{
return Create<Enemy>();
}
//Metoda tworzy obiekt klasy Explosion i zwraca wskaźnik na ten obiekt
Explosion *PhysicalManager::CreateExplosion()
{
Explosion * p_explosion = new Explosion();
m_explosions.push_back(p_explosion);
return p_explosion;
}
//Metoda aktualizuje wskaźniki na obiekty Physical
void PhysicalManager::updatePhysical(float dt)
{
for (unsigned int i = 0; i < m_physicals.size(); i++)
{
checkCollision(m_physicals.at(i));//kolizje
m_physicals.at(i)->update(dt);
//jeśli obiekt jest oznaczony do zniszczaenia
if(m_physicals.at(i)->getDestruction())
{
delete m_physicals.at(i);
m_physicals.at(i) = nullptr;
m_physicals.erase(m_physicals.begin() + i);
}
}
//aktualizacja pojemnika z eksplozjami
for (unsigned int i = 0; i < m_explosions.size(); i++)
{
m_explosions.at(i)->update(dt);
if (m_explosions.at(i)->getDestruction())
{
delete m_explosions.at(i);
m_explosions.at(i) = nullptr;
m_explosions.erase(m_explosions.begin() + i);
}
}
}
//Wirtualna metoda rysująca obiekt
void PhysicalManager::draw(sf::RenderWindow & render) const
{
//draw physicals...
std::vector<Physical*>::const_iterator it;//iterator tego kontenera
for (it = m_physicals.begin(); it != m_physicals.end(); it++)
{
if ((*it) != nullptr)
if ((*it)->getUseDisplayable() and !(*it)->getDestruction())
(*it)->draw(render);
}
//draw explosions...
std::vector<acodemia::animation::Explosion*>::const_iterator iter;//iterator kontenera eksplozji
for (iter = m_explosions.begin(); iter != m_explosions.end(); iter++)
{
if ((*iter) != nullptr)
(*iter)->draw(render);
}
}
//Metoda sprawdza, czy nastąpiła jakaś kolizja
bool PhysicalManager::checkCollision(Physical *collider)
{
std::string typ = typeid(*collider).name();
//iterujemy po kontenerze ze wskaźnikami na obiekty klasy Physical
for (unsigned int i = 0; i < m_physicals.size(); i++)
{
if (m_physicals.at(i) != collider)//blokujemy kolizję "sam ze sobą"
{
//testy kolizji circle-circle (2019-04-10)
if (m_physicals.at(i)->getGlobalBounds().intersects(collider->getGlobalBounds()))
{
if (typ == "class acodemia::physical::Enemy")
{
updatePosition(m_physicals.at(i), collider);
return true;
}
if (typ == "class acodemia::physical::Player")
{
updatePosition(m_physicals.at(i), collider);
return true;
}
if (typ == "class acodemia::physical::Bullet")
{
m_physicals.at(i)->setHealt
(
m_physicals.at(i)->getHealt() - static_cast<Bullet*>(collider)->getCaliber()
);
collider->setDestruction(true);
static_cast<Bullet*>(collider)->explode();//eksplozja
return true;
}
}
}
}
return false;
}
//Szablon metody tworzenia obiektów
template<class T>
T* PhysicalManager::Create()
{
T* obj = new T();
m_physicals.push_back(obj);
return obj;
}
//prywatna metoda aktualizuje pozycję obiektu w wyniku kolizji
void PhysicalManager::updatePosition(Physical *object, Physical *collider)
{
//notatka:
//docelowo silnik obsługi kolizji uzależnić od wektora prędkości (motion)
//zasady dynamiki Newtona
sf::Vector2f new_object_position;
sf::Vector2f old_object_position;
old_object_position = object->getPosition();//zapamiętujemy pozycję
sf::Vector2f new_collider_position;
sf::Vector2f old_collider_position;
old_collider_position = collider->getPosition();//zapamiętujemy pozycję
float factor = 0.1f; // współczynnik separacji
// x
if (object->getPosition().x <= collider->getPosition().x)
{
new_object_position.x = old_object_position.x - factor;
new_collider_position.x = old_collider_position.x + factor;
}
else
{
new_object_position.x = old_object_position.x + factor;
new_collider_position.x = old_collider_position.x - factor;
}
// y
if (object->getPosition().y <= collider->getPosition().y)
{
new_object_position.y = old_object_position.y - factor;
new_collider_position.y = old_collider_position.y + factor;
}
else
{
new_object_position.y = old_object_position.y + factor;
new_collider_position.y = old_collider_position.y - factor;
}
object->setPosition(new_object_position);
collider->setPosition(new_collider_position);
}
| 26.121094 | 97 | 0.706744 | [
"render",
"object",
"vector"
] |
0b366674e8526028d4e7e37952829870772ccbaf | 40,116 | cpp | C++ | srcs/simulate.cpp | colematt/apex-sim | 304dfdb8789729639099869e1222a2325fd2752f | [
"MIT"
] | 1 | 2017-09-23T04:55:23.000Z | 2017-09-23T04:55:23.000Z | srcs/simulate.cpp | colematt/apex-sim | 304dfdb8789729639099869e1222a2325fd2752f | [
"MIT"
] | 5 | 2016-11-21T23:49:10.000Z | 2016-12-11T23:05:37.000Z | srcs/simulate.cpp | colematt/apex-sim | 304dfdb8789729639099869e1222a2325fd2752f | [
"MIT"
] | 1 | 2018-11-17T03:40:04.000Z | 2018-11-17T03:40:04.000Z | #include <vector>
#include <string>
#include "cpu.h"
#include "apex.h"
// FORWARDING 1 : forwarding occurs
// FORWARDING 0 : forwarding does not occur
#define FORWARDING 1
int CPU::simulate(Code &mycode, Registers &myregisters, Data &mydata,
ROB &myrob, IQ &myiq){
/*FORWARDING PHASE************************************************************
******************************************************************************
*****************************************************************************/
// Defined at the top of this file
#if FORWARDING
/****B2 --> ****/
if (!B2.isEmpty()){
//--> B1 (B2.opcode is BAL (sets X) and X is in B1.srcs)
if (B2.opcode == "BAL"){
if ((B1.opcode == "BAL" || B1.opcode == "JUMP")
&& B1.operands.at(0) == "X"){
B1.values.at(0) = (B2.pc)+4;
B1.valids.at(0) = true;
}
}
//--> IQ (X is in IQ.entry.srcs)
if (B2.opcode == "BAL"){
for (auto &entry : myiq.issue_queue){
if (entry.opcode == "BAL" || entry.opcode == "JUMP"){
if (entry.operands.at(0) == "X"){
entry.values.at(0) = (B2.pc)+4;
entry.valids.at(0) = true;
}
}
}
}
}
/****ALU3 --> ****/
if (!ALU3.isEmpty()){
//SPECIAL CASE: due to program structure
// --> DRF2 (ALU3.dst == DRF2.srcs)
if (DRF2.opcode == "ADD" ||
DRF2.opcode == "SUB" ||
DRF2.opcode == "MUL" ||
DRF2.opcode == "AND" ||
DRF2.opcode == "OR" ||
DRF2.opcode == "EX-OR"){
std::string forwardReg = myregisters.translateReg(ALU3.operands.at(0));
if (DRF2.operands.at(1) == forwardReg){
DRF2.values.at(1) = ALU3.values.at(0);
DRF2.valids.at(1) = ALU3.valids.at(0);
}
if (DRF2.operands.at(2) == forwardReg){
DRF2.values.at(2) = ALU3.values.at(0);
DRF2.valids.at(2) = ALU3.valids.at(0);
}
}
// --> DRF2 (ALU3.dst == DRF2.srcs)
if (DRF2.opcode == "MUL"){
std::string forwardReg = myregisters.translateReg(ALU3.operands.at(0));
if (DRF2.operands.at(1) == forwardReg){
DRF2.values.at(1) = ALU3.values.at(0);
DRF2.valids.at(1) = ALU3.valids.at(0);
}
if (DRF2.operands.at(2) == forwardReg){
DRF2.values.at(2) = ALU3.values.at(0);
DRF2.valids.at(2) = ALU3.valids.at(0);
}
}
// --> DRF2 (DRF2.opcode == {BAL,JUMP}, ALU3.dst == DRF2.srcs)
if (DRF2.opcode == "BAL" || DRF2.opcode == "JUMP"){
std::string forwardReg = myregisters.translateReg(ALU3.operands.at(0));
if (DRF2.operands.at(0) == forwardReg){
DRF2.values.at(0) = ALU3.values.at(0);
DRF2.valids.at(0) = ALU3.valids.at(0);
}
}
// --> DRF2 (DRF2.opcode == {LOAD}, ALU3.dst == DRF2.srcs)
if (DRF2.opcode == "LOAD"){
std::string forwardReg = myregisters.translateReg(ALU3.operands.at(0));
if (DRF2.operands.at(1) == forwardReg){
DRF2.values.at(1) = ALU3.values.at(0);
DRF2.valids.at(1) = ALU3.valids.at(0);
}
}
// --> DRF2 (DRF2.opcode == {STORE}, ALU3.dst == DRF2.srcs)
if (DRF2.opcode == "STORE"){
std::string forwardReg = myregisters.translateReg(ALU3.operands.at(0));
if (DRF2.operands.at(0) == forwardReg){
DRF2.values.at(0) = ALU3.values.at(0);
DRF2.valids.at(0) = ALU3.valids.at(0);
}
if (DRF2.operands.at(1) == forwardReg){
DRF2.values.at(1) = ALU3.values.at(0);
DRF2.valids.at(1) = ALU3.valids.at(0);
}
}
// --> DRF2 (DRF2.opcode == {LOAD}, ALU3.dst == DRF2.srcs)
if (DRF2.opcode == "LOAD"){
std::string forwardReg = myregisters.translateReg(ALU2.operands.at(0));
if (DRF2.operands.at(1) == forwardReg){
DRF2.values.at(1) = ALU3.values.at(0);
DRF2.valids.at(1) = ALU3.valids.at(0);
}
}
// --> DRF2 (DRF2.opcode == {STORE}, ALU3.dst == DRF2.srcs)
if (DRF2.opcode == "STORE"){
std::string forwardReg = myregisters.translateReg(ALU2.operands.at(0));
if (DRF2.operands.at(0) == forwardReg){
DRF2.values.at(0) = ALU3.values.at(0);
DRF2.valids.at(0) = ALU3.valids.at(0);
}
if (DRF2.operands.at(1) == forwardReg){
DRF2.values.at(1) = ALU3.values.at(0);
DRF2.valids.at(1) = ALU3.valids.at(0);
}
}
//END SPECIAL CASE
// --> ALU1 (ALU3.dst == ALU1.srcs)
//MOVC has an empty source set
if (ALU1.opcode != "MOVC"){
std::string forwardReg = myregisters.translateReg(ALU3.operands.at(0));
if (ALU1.operands.at(1) == forwardReg){
ALU1.values.at(1) = ALU3.values.at(0);
ALU1.valids.at(1) = ALU3.valids.at(0);
}
if (ALU1.operands.at(2) == forwardReg){
ALU1.values.at(2) = ALU3.values.at(0);
ALU1.valids.at(2) = ALU3.valids.at(0);
}
}
// --> MUL1 (ALU3.dst == MUL1.srcs)
if (MUL1.opcode == "MUL"){
std::string forwardReg = myregisters.translateReg(ALU3.operands.at(0));
if (MUL1.operands.at(1) == forwardReg){
MUL1.values.at(1) = ALU3.values.at(0);
MUL1.valids.at(1) = ALU3.valids.at(0);
}
if (MUL1.operands.at(2) == forwardReg){
MUL1.values.at(2) = ALU3.values.at(0);
MUL1.valids.at(2) = ALU3.valids.at(0);
}
}
// --> B1 (B1.opcode == {BAL,JUMP}, ALU3.dst == B1.srcs)
if (B1.opcode == "BAL" || B1.opcode == "JUMP"){
std::string forwardReg = myregisters.translateReg(ALU3.operands.at(0));
if (B1.operands.at(0) == forwardReg){
B1.values.at(0) = ALU3.values.at(0);
B1.valids.at(0) = ALU3.valids.at(0);
}
}
// --> LSFU2 (LSFU2.opcode == {LOAD}, ALU3.dst == LSFU2.srcs)
if (LSFU2.opcode == "LOAD"){
std::string forwardReg = myregisters.translateReg(ALU3.operands.at(0));
if (LSFU2.operands.at(1) == forwardReg){
LSFU2.values.at(1) = ALU3.values.at(0);
LSFU2.valids.at(1) = ALU3.valids.at(0);
}
}
// --> LSFU2 (LSFU2.opcode == {STORE}, ALU3.dst == LSFU2.srcs)
if (LSFU2.opcode == "STORE"){
std::string forwardReg = myregisters.translateReg(ALU3.operands.at(0));
if (LSFU2.operands.at(0) == forwardReg){
LSFU2.values.at(0) = ALU3.values.at(0);
LSFU2.valids.at(0) = ALU3.valids.at(0);
}
if (LSFU2.operands.at(1) == forwardReg){
LSFU2.values.at(1) = ALU3.values.at(0);
LSFU2.valids.at(1) = ALU3.valids.at(0);
}
}
// --> LSFU1 (LSFU1.opcode == {LOAD}, ALU3.dst == LSFU1.srcs)
if (LSFU1.opcode == "LOAD"){
std::string forwardReg = myregisters.translateReg(ALU2.operands.at(0));
if (LSFU1.operands.at(1) == forwardReg){
LSFU1.values.at(1) = ALU3.values.at(0);
LSFU1.valids.at(1) = ALU3.valids.at(0);
}
}
// --> LSFU1 (LSFU1.opcode == {STORE}, ALU3.dst == LSFU1.srcs)
if (LSFU1.opcode == "STORE"){
std::string forwardReg = myregisters.translateReg(ALU2.operands.at(0));
if (LSFU1.operands.at(0) == forwardReg){
LSFU1.values.at(0) = ALU3.values.at(0);
LSFU1.valids.at(0) = ALU3.valids.at(0);
}
if (LSFU1.operands.at(1) == forwardReg){
LSFU1.values.at(1) = ALU3.values.at(0);
LSFU1.valids.at(1) = ALU3.valids.at(0);
}
}
// --> IQ (ALU3.dst = IQ.entry.src)
for (auto &entry : myiq.issue_queue){
std::string forwardReg = myregisters.translateReg(ALU3.operands.at(0));
if (entry.opcode == "ADD" ||
entry.opcode == "SUB" ||
entry.opcode == "MUL" ||
entry.opcode == "AND" ||
entry.opcode == "OR" ||
entry.opcode == "EX-OR"){
if (entry.operands.at(1) == forwardReg){
entry.values.at(1) = ALU3.values.at(0);
entry.valids.at(1) = ALU3.valids.at(0);
}
if (entry.operands.at(2) == forwardReg){
entry.values.at(2) = ALU3.values.at(0);
entry.valids.at(2) = ALU3.valids.at(0);
}
}
if (entry.opcode == "LOAD"){
if (entry.operands.at(1) == forwardReg){
entry.values.at(1) = ALU3.values.at(0);
entry.valids.at(1) = ALU3.valids.at(0);
}
}
if (entry.opcode == "STORE"){
if (entry.operands.at(0) == forwardReg){
entry.values.at(0) = ALU3.values.at(0);
entry.valids.at(0) = ALU3.valids.at(0);
}
if (entry.operands.at(1) == forwardReg){
entry.values.at(1) = ALU3.values.at(0);
entry.valids.at(1) = ALU3.valids.at(0);
}
}
if (entry.opcode == "BAL" || entry.opcode == "JUMP"){
if (entry.operands.at(0) == forwardReg){
entry.values.at(0) = ALU3.values.at(0);
entry.valids.at(0) = ALU3.valids.at(0);
}
}
}
}
/****ALU2 --> ****/
if (!ALU2.isEmpty()){
//SPECIAL CASE: due to program structure
// --> DRF2 (ALU2.dst == DRF2.srcs)
if (DRF2.opcode == "ADD" ||
DRF2.opcode == "SUB" ||
DRF2.opcode == "MUL" ||
DRF2.opcode == "AND" ||
DRF2.opcode == "OR" ||
DRF2.opcode == "EX-OR"){
std::string forwardReg = myregisters.translateReg(ALU2.operands.at(0));
if (DRF2.operands.at(1) == forwardReg){
DRF2.values.at(1) = ALU2.values.at(0);
DRF2.valids.at(1) = ALU2.valids.at(0);
}
if (DRF2.operands.at(2) == forwardReg){
DRF2.values.at(2) = ALU2.values.at(0);
DRF2.valids.at(2) = ALU2.valids.at(0);
}
}
// --> DRF2 (ALU2.dst == DRF2.srcs)
if (DRF2.opcode == "MUL"){
std::string forwardReg = myregisters.translateReg(ALU2.operands.at(0));
if (DRF2.operands.at(1) == forwardReg){
DRF2.values.at(1) = ALU2.values.at(0);
DRF2.valids.at(1) = ALU2.valids.at(0);
}
if (DRF2.operands.at(2) == forwardReg){
DRF2.values.at(2) = ALU2.values.at(0);
DRF2.valids.at(2) = ALU2.valids.at(0);
}
}
// --> DRF2 (DRF2.opcode == {BAL,JUMP}, ALU2.dst == DRF2.srcs)
if (DRF2.opcode == "BAL" || DRF2.opcode == "JUMP"){
std::string forwardReg = myregisters.translateReg(ALU2.operands.at(0));
if (DRF2.operands.at(0) == forwardReg){
DRF2.values.at(0) = ALU2.values.at(0);
DRF2.valids.at(0) = ALU2.valids.at(0);
}
}
// --> DRF2 (DRF2.opcode == {LOAD}, ALU2.dst == DRF2.srcs)
if (DRF2.opcode == "LOAD"){
std::string forwardReg = myregisters.translateReg(ALU2.operands.at(0));
if (DRF2.operands.at(1) == forwardReg){
DRF2.values.at(1) = ALU2.values.at(0);
DRF2.valids.at(1) = ALU2.valids.at(0);
}
}
// --> DRF2 (DRF2.opcode == {STORE}, ALU2.dst == DRF2.srcs)
if (DRF2.opcode == "STORE"){
std::string forwardReg = myregisters.translateReg(ALU2.operands.at(0));
if (DRF2.operands.at(0) == forwardReg){
DRF2.values.at(0) = ALU2.values.at(0);
DRF2.valids.at(0) = ALU2.valids.at(0);
}
if (DRF2.operands.at(1) == forwardReg){
DRF2.values.at(1) = ALU2.values.at(0);
DRF2.valids.at(1) = ALU2.valids.at(0);
}
}
// --> DRF2 (DRF2.opcode == {LOAD}, ALU2.dst == DRF2.srcs)
if (DRF2.opcode == "LOAD"){
std::string forwardReg = myregisters.translateReg(ALU2.operands.at(0));
if (DRF2.operands.at(1) == forwardReg){
DRF2.values.at(1) = ALU2.values.at(0);
DRF2.valids.at(1) = ALU2.valids.at(0);
}
}
// --> DRF2 (DRF2.opcode == {STORE}, ALU2.dst == DRF2.srcs)
if (DRF2.opcode == "STORE"){
std::string forwardReg = myregisters.translateReg(ALU2.operands.at(0));
if (DRF2.operands.at(0) == forwardReg){
DRF2.values.at(0) = ALU2.values.at(0);
DRF2.valids.at(0) = ALU2.valids.at(0);
}
if (DRF2.operands.at(1) == forwardReg){
DRF2.values.at(1) = ALU2.values.at(0);
DRF2.valids.at(1) = ALU2.valids.at(0);
}
}
//END SPECIAL CASE
// --> ALU1 (ALU2.dst == ALU1.srcs)
//MOVC has an empty source set
if (ALU1.opcode != "MOVC"){
std::string forwardReg = myregisters.translateReg(ALU2.operands.at(0));
if (ALU1.operands.at(1) == forwardReg){
ALU1.values.at(1) = ALU2.values.at(0);
ALU1.valids.at(1) = ALU2.valids.at(0);
}
if (ALU1.operands.at(2) == forwardReg){
ALU1.values.at(2) = ALU2.values.at(0);
ALU1.valids.at(2) = ALU2.valids.at(0);
}
}
// --> MUL1 (ALU2.dst == MUL1.srcs)
if (MUL1.opcode == "MUL"){
std::string forwardReg = myregisters.translateReg(ALU2.operands.at(0));
if (MUL1.operands.at(1) == forwardReg){
MUL1.values.at(1) = ALU2.values.at(0);
MUL1.valids.at(1) = ALU2.valids.at(0);
}
if (MUL1.operands.at(2) == forwardReg){
MUL1.values.at(2) = ALU2.values.at(0);
MUL1.valids.at(2) = ALU2.valids.at(0);
}
}
// --> B1 (B1.opcode == {BAL,JUMP}, ALU2.dst == B1.srcs)
if (B1.opcode == "BAL" || B1.opcode == "JUMP"){
std::string forwardReg = myregisters.translateReg(ALU2.operands.at(0));
if (B1.operands.at(0) == forwardReg){
B1.values.at(0) = ALU2.values.at(0);
B1.valids.at(0) = ALU2.valids.at(0);
}
}
// --> LSFU2 (LSFU2.opcode == {LOAD}, ALU2.dst == LSFU2.srcs)
if (LSFU2.opcode == "LOAD"){
std::string forwardReg = myregisters.translateReg(ALU2.operands.at(0));
if (LSFU2.operands.at(1) == forwardReg){
LSFU2.values.at(1) = ALU2.values.at(0);
LSFU2.valids.at(1) = ALU2.valids.at(0);
}
}
// --> LSFU2 (LSFU2.opcode == {STORE}, ALU2.dst == LSFU2.srcs)
if (LSFU2.opcode == "STORE"){
std::string forwardReg = myregisters.translateReg(ALU2.operands.at(0));
if (LSFU2.operands.at(0) == forwardReg){
LSFU2.values.at(0) = ALU2.values.at(0);
LSFU2.valids.at(0) = ALU2.valids.at(0);
}
}
// --> LSFU1 (LSFU1.opcode == {LOAD}, ALU2.dst == LSFU1.srcs)
if (LSFU1.opcode == "LOAD"){
std::string forwardReg = myregisters.translateReg(ALU2.operands.at(0));
if (LSFU1.operands.at(1) == forwardReg){
LSFU1.values.at(1) = ALU2.values.at(0);
LSFU1.valids.at(1) = ALU2.valids.at(0);
}
}
// --> LSFU1 (LSFU1.opcode == {STORE}, ALU2.dst == LSFU1.srcs)
if (LSFU1.opcode == "STORE"){
std::string forwardReg = myregisters.translateReg(ALU2.operands.at(0));
if (LSFU1.operands.at(0) == forwardReg){
LSFU1.values.at(0) = ALU2.values.at(0);
LSFU1.valids.at(0) = ALU2.valids.at(0);
}
if (LSFU1.operands.at(1) == forwardReg){
LSFU1.values.at(1) = ALU2.values.at(0);
LSFU1.valids.at(1) = ALU2.valids.at(0);
}
}
// --> IQ (ALU2.op[0] == IQ.entry.{srcs})
for (auto &entry: myiq.issue_queue){
std::string forwardReg = myregisters.translateReg(ALU2.operands.at(0));
if (entry.opcode == "ADD" ||
entry.opcode == "SUB" ||
entry.opcode == "MUL" ||
entry.opcode == "AND" ||
entry.opcode == "OR" ||
entry.opcode == "EX-OR"){
if (entry.operands.at(1) == forwardReg){
entry.values.at(1) = ALU2.values.at(0);
entry.valids.at(1) = ALU2.valids.at(0);
}
if (entry.operands.at(2) == forwardReg){
entry.values.at(2) = ALU2.values.at(0);
entry.valids.at(2) = ALU2.valids.at(0);
}
}
if (entry.opcode == "LOAD"){
if (entry.operands.at(1) == forwardReg){
entry.values.at(1) = ALU2.values.at(0);
entry.valids.at(1) = ALU2.valids.at(0);
}
}
if (entry.opcode == "STORE"){
if (entry.operands.at(0) == forwardReg){
entry.values.at(0) = ALU2.values.at(0);
entry.valids.at(0) = ALU2.valids.at(0);
}
if (entry.operands.at(1) == forwardReg){
entry.values.at(1) = ALU2.values.at(0);
entry.valids.at(1) = ALU2.valids.at(0);
}
}
if (entry.opcode == "BAL" || entry.opcode == "JUMP"){
if (entry.operands.at(0) == forwardReg){
entry.values.at(0) = ALU2.values.at(0);
entry.valids.at(0) = ALU2.valids.at(0);
}
}
}
}
/****MUL2 --> ****/
if (!MUL2.isEmpty()){
std::string forwardReg = myregisters.translateReg(MUL2.operands.at(0));
// --> ALU1 (MUL2.dst == ALU1.srcs)
//MOVC has an empty source set
if (ALU1.opcode != "MOVC"){
if (ALU1.operands.at(1) == forwardReg){
ALU1.values.at(1) = MUL2.values.at(0);
ALU1.valids.at(1) = MUL2.valids.at(0);
}
if (ALU1.operands.at(2) == forwardReg){
ALU1.values.at(2) = MUL2.values.at(0);
ALU1.valids.at(2) = MUL2.valids.at(0);
}
}
// --> B1 (MUL2.dst = B1.srcs)
if (B1.opcode == "BAL" || B1.opcode == "JUMP"){
if (B1.operands.at(0) == forwardReg){
B1.values.at(0) = MUL2.values.at(0);
B1.valids.at(0) = MUL2.valids.at(0);
}
}
// --> LSFU2 (MUL2.dst = LSFU2.srcs)
if (LSFU2.opcode == "LOAD"){
if (LSFU2.operands.at(1) == forwardReg){
LSFU2.values.at(1) = MUL2.values.at(0);
LSFU2.valids.at(1) = MUL2.valids.at(0);
}
}
// --> LSFU2 (LSFU2.opcode == {STORE}, MUL2.dst == LSFU2.srcs)
if (LSFU2.opcode == "STORE"){
if (LSFU2.operands.at(0) == forwardReg){
LSFU2.values.at(0) = MUL2.values.at(0);
LSFU2.valids.at(0) = MUL2.valids.at(0);
}
}
// --> LSFU1 (MUL2.dst = LSFU2.srcs)
if (LSFU1.opcode == "LOAD"){
if (LSFU1.operands.at(1) == forwardReg){
LSFU1.values.at(1) = MUL2.values.at(0);
LSFU1.valids.at(1) = MUL2.valids.at(0);
}
}
// --> LSFU2 (LSFU2.opcode == {STORE}, MUL2.dst == LSFU2.srcs)
if (LSFU1.opcode == "STORE"){
if (LSFU1.operands.at(0) == forwardReg){
LSFU1.values.at(0) = MUL2.values.at(0);
LSFU1.valids.at(0) = MUL2.valids.at(0);
}
if (LSFU1.operands.at(1) == forwardReg){
LSFU1.values.at(1) = MUL2.values.at(0);
LSFU1.valids.at(1) = MUL2.valids.at(0);
}
}
// --> IQ (MUL2.op[0] == IQ.entry.{srcs})
for (auto &entry: myiq.issue_queue){
std::string forwardReg = myregisters.translateReg(MUL2.operands.at(0));
if (entry.opcode == "ADD" ||
entry.opcode == "SUB" ||
entry.opcode == "MUL" ||
entry.opcode == "AND" ||
entry.opcode == "OR" ||
entry.opcode == "EX-OR"){
if (entry.operands.at(1) == forwardReg){
entry.values.at(1) = MUL2.values.at(0);
entry.valids.at(1) = MUL2.valids.at(0);
}
if (entry.operands.at(2) == forwardReg){
entry.values.at(2) = MUL2.values.at(0);
entry.valids.at(2) = MUL2.valids.at(0);
}
}
if (entry.opcode == "LOAD"){
if (entry.operands.at(1) == forwardReg){
entry.values.at(1) = MUL2.values.at(0);
entry.valids.at(1) = MUL2.valids.at(0);
}
}
if (entry.opcode == "STORE"){
if (entry.operands.at(0) == forwardReg){
entry.values.at(0) = MUL2.values.at(0);
entry.valids.at(0) = MUL2.valids.at(0);
}
if (entry.operands.at(1) == forwardReg){
entry.values.at(1) = MUL2.values.at(0);
entry.valids.at(1) = MUL2.valids.at(0);
}
}
if (entry.opcode == "BAL" || entry.opcode == "JUMP"){
if (entry.operands.at(0) == forwardReg){
entry.values.at(0) = MUL2.values.at(0);
entry.valids.at(0) = MUL2.valids.at(0);
}
}
}
}
/****MUL1 (when MUL1.lcounter == 0) --> ****/
if (!MUL1.isEmpty()){
if (MUL1.lcounter == 0){
std::string forwardReg = myregisters.translateReg(MUL1.operands.at(0));
// --> ALU1 (MUL1.dst == ALU1.srcs)
//MOVC has an empty source set
if (ALU1.opcode != "MOVC"){
if (ALU1.operands.at(1) == forwardReg){
ALU1.values.at(1) = MUL1.values.at(0);
ALU1.valids.at(1) = MUL1.valids.at(0);
}
if (ALU1.operands.at(2) == forwardReg){
ALU1.values.at(2) = MUL1.values.at(0);
ALU1.valids.at(2) = MUL1.valids.at(0);
}
}
// --> B1 (MUL1.dst = B1.srcs)
if (B1.opcode == "BAL" || B1.opcode == "JUMP"){
if (B1.operands.at(0) == forwardReg){
B1.values.at(0) = MUL1.values.at(0);
B1.valids.at(0) = MUL1.valids.at(0);
}
}
// --> LSFU2 (MUL1.dst = LSFU2.srcs)
if (LSFU2.opcode == "LOAD"){
if (LSFU2.operands.at(1) == forwardReg){
LSFU2.values.at(1) = MUL1.values.at(0);
LSFU2.valids.at(1) = MUL1.valids.at(0);
}
}
// --> LSFU2 (LSFU2.opcode == {STORE}, MUL1.dst == LSFU2.srcs)
if (LSFU2.opcode == "STORE"){
if (LSFU2.operands.at(0) == forwardReg){
LSFU2.values.at(0) = MUL1.values.at(0);
LSFU2.valids.at(0) = MUL1.valids.at(0);
}
}
// --> LSFU1 (MUL1.dst = LSFU2.srcs)
if (LSFU1.opcode == "LOAD"){
if (LSFU1.operands.at(1) == forwardReg){
LSFU1.values.at(1) = MUL1.values.at(0);
LSFU1.valids.at(1) = MUL1.valids.at(0);
}
}
// --> LSFU2 (LSFU2.opcode == {STORE}, MUL1.dst == LSFU2.srcs)
if (LSFU1.opcode == "STORE"){
if (LSFU1.operands.at(0) == forwardReg){
LSFU1.values.at(0) = MUL1.values.at(0);
LSFU1.valids.at(0) = MUL1.valids.at(0);
}
if (LSFU1.operands.at(1) == forwardReg){
LSFU1.values.at(1) = MUL1.values.at(0);
LSFU1.valids.at(1) = MUL1.valids.at(0);
}
}
/****MUL1 --> ****/
// --> IQ (MUL1.op[0] == IQ.entry.{srcs})
for (auto &entry: myiq.issue_queue){
std::string forwardReg = myregisters.translateReg(MUL1.operands.at(0));
if (entry.opcode == "ADD" ||
entry.opcode == "SUB" ||
entry.opcode == "MUL" ||
entry.opcode == "AND" ||
entry.opcode == "OR" ||
entry.opcode == "EX-OR"){
if (entry.operands.at(1) == forwardReg){
entry.values.at(1) = MUL1.values.at(0);
entry.valids.at(1) = MUL1.valids.at(0);
}
if (entry.operands.at(2) == forwardReg){
entry.values.at(2) = MUL1.values.at(0);
entry.valids.at(2) = MUL1.valids.at(0);
}
}
if (entry.opcode == "LOAD"){
if (entry.operands.at(1) == forwardReg){
entry.values.at(1) = MUL1.values.at(0);
entry.valids.at(1) = MUL1.valids.at(0);
}
}
if (entry.opcode == "STORE"){
if (entry.operands.at(0) == forwardReg){
entry.values.at(0) = MUL1.values.at(0);
entry.valids.at(0) = MUL1.valids.at(0);
}
}
if (entry.opcode == "BAL" || entry.opcode == "JUMP"){
if (entry.operands.at(0) == forwardReg){
entry.values.at(0) = MUL1.values.at(0);
entry.valids.at(0) = MUL1.valids.at(0);
}
}
}
}
}
/****LSFU3 --> ****/
if (!LSFU3.isEmpty()){
//Only LOAD instructions in the LSFU have a destination set
//That destination set is not computed until LSFU3
//(no forwarding from LSFU1, LSFU2)
if (LSFU3.opcode == "LOAD"){
std::string forwardReg = myregisters.translateReg(LSFU3.operands.at(0));
// --> LSFU2 (LSFU2.opcode == STORE, LSFU3.dst = LSFU2.srcs[0])
if (LSFU2.opcode == "STORE" &&
(LSFU2.operands.at(0) == forwardReg)){
LSFU2.values.at(0) = LSFU3.values.at(0);
LSFU2.valids.at(0) = LSFU3.valids.at(0);
}
// --> ALU1 (LSFU3.dst == ALU1.srcs)
// MOVC instructions have no source set
if (ALU1.opcode != "MOVC"){
if (ALU1.operands.at(1) == forwardReg){
ALU1.values.at(1) = LSFU3.values.at(0);
ALU1.valids.at(1) = LSFU3.valids.at(0);
}
if (ALU1.operands.at(2) == forwardReg){
ALU1.values.at(2) = LSFU3.values.at(0);
ALU1.valids.at(2) = LSFU3.valids.at(0);
}
}
// --> MUL1 (LSFU3.dst == MUL1.srcs)
if (MUL1.operands.at(1) == forwardReg){
MUL1.values.at(1) = LSFU3.values.at(0);
MUL1.valids.at(1) = LSFU3.valids.at(0);
}
if (MUL1.operands.at(2) == forwardReg){
MUL1.values.at(2) = LSFU3.values.at(0);
MUL1.valids.at(2) = LSFU3.valids.at(0);
}
// --> LSFU2 (LSFU2.opcode == STORE, LSFU2.src[0] == LSFU3.dst)
if (LSFU2.opcode == "LOAD" &&
LSFU2.operands.at(0) == forwardReg){
LSFU2.values.at(0) = LSFU3.values.at(0);
LSFU2.valids.at(0) = LSFU3.valids.at(0);
}
// --> LSFU1 (LSFU1.opcode == STORE, LSFU1.src[0] == LSFU3.dst )
if (LSFU1.opcode == "LOAD" &&
LSFU1.operands.at(0) == forwardReg){
LSFU1.values.at(0) = LSFU3.values.at(0);
LSFU1.valids.at(0) = LSFU3.valids.at(0);
}
// --> IQ
for (auto &entry: myiq.issue_queue){
if (entry.opcode == "ADD" ||
entry.opcode == "SUB" ||
entry.opcode == "MUL" ||
entry.opcode == "AND" ||
entry.opcode == "OR" ||
entry.opcode == "EX-OR"){
if (entry.operands.at(1) == forwardReg){
entry.values.at(1) = LSFU3.values.at(0);
entry.valids.at(1) = LSFU3.valids.at(0);
}
if (entry.operands.at(2) == forwardReg){
entry.values.at(2) = LSFU3.values.at(0);
entry.valids.at(2) = LSFU3.valids.at(0);
}
}
if (entry.opcode == "LOAD"){
if (entry.operands.at(1) == forwardReg){
entry.values.at(1) = LSFU3.values.at(0);
entry.valids.at(1) = LSFU3.valids.at(0);
}
}
if (entry.opcode == "STORE"){
if (entry.operands.at(0) == forwardReg){
entry.values.at(0) = LSFU3.values.at(0);
entry.valids.at(0) = LSFU3.valids.at(0);
}
if (entry.operands.at(1) == forwardReg){
entry.values.at(1) = LSFU3.values.at(0);
entry.valids.at(1) = LSFU3.valids.at(0);
}
}
if (entry.opcode == "BAL" || entry.opcode == "JUMP"){
if (entry.operands.at(0) == forwardReg){
entry.values.at(0) = LSFU3.values.at(0);
entry.valids.at(0) = LSFU3.valids.at(0);
}
}
}
}
}
#endif
/*COMMITTING PHASE************************************************************
******************************************************************************
*****************************************************************************/
// Check to see if the ROB head matches the contents of either
// ALU3, MUL2, LSFU3, B2. If there's a match:
// 1. Commit ROB's head entry
// 2. Increment stats counters
// 3. Mark that FU stage empty (prepare to "advance" into that stage)
if (!myrob.isEmpty()){
if (ALU3.isReady() && myrob.match(ALU3)){
myrob.commit(myregisters);
committed++;
ALU3.empty = true;
}
else if (MUL2.isReady() && myrob.match(MUL2)){
myrob.commit(myregisters);
committed++;
MUL2.empty = true;
}
//For LSFU3 only, additionally check that LSFU3.src1 is valid.
//It may have issued from the IQ without src1 validity
//(in order to reduce bubbles)
else if (LSFU3.valids.at(0) == true && LSFU3.isReady() && myrob.match(LSFU3)){
myrob.commit(myregisters);
if (LSFU3.opcode == "LOAD"){
committed_load++;
committed++;
}
else {
committed_store++;
committed++;
//Perform memory access
mydata.writeMem(LSFU3.values.at(1), LSFU3.values.at(0));
}
LSFU3.empty = true;
}
else if (B2.isReady() && myrob.match(B2)){
myrob.commit(myregisters);
committed++;
B2.empty = true;
}
else{no_commit++;} // there were ROB contents, but they didn't match
}
else{no_commit++;} // there were no ROB contents
/*ADVANCEMENT PHASE***********************************************************
******************************************************************************
*****************************************************************************/
/****B2 STAGE****/
// Advanced by ROB COMMITTING
/****B1 STAGE****/
if (B1.isReady() && B2.isEmpty()){
B1.advance(B2);
}
/****ALU3 STAGE****/
// Advanced by ROB COMMITTING
/****ALU2 STAGE****/
if (ALU2.isReady() && ALU3.isEmpty()){
ALU2.advance(ALU3);
}
/****ALU1 STAGE****/
if (ALU1.isReady() && ALU2.isEmpty()){
ALU1.advance(ALU2);
}
/****MUL2 STAGE****/
// Advanced by ROB COMMITTING
/****MUL1 STAGE****/
if (MUL1.isReady() && MUL2.isEmpty()){
MUL1.advance(MUL2);
}
/****LSFU3 STAGE****/
// Advanced by ROB COMMITTING
/****LSFU2 STAGE****/
if (LSFU2.isReady() && LSFU3.isEmpty()){
LSFU2.advance(LSFU3);
}
/****LSFU1 STAGE****/
if (LSFU1.isReady() && LSFU2.isEmpty()){
LSFU1.advance(LSFU2);
}
/****IQ****/
int wakeup = -1;
// Up to 3 wakeup signals can occur per cycle.
for (wakeup = 0; wakeup < 3; wakeup++){
//If we can issue, do so, and increment stats
if (myiq.issue(ALU1, MUL1, LSFU1, B1)) {
issued++;
}
//If we can't issue, break out of the for-loop
else{
break;
}
}
// Now that we've finished wakeups,
// Determine if no successful issues occurred this cycle
if (wakeup == 0)
no_issued++;
/****DRF2 STAGE****/
// If HALT is in this stage, do not advance it. Its presence here is part of
// the STOPPING logic! There are no instructions behind it because
// F stage has stopped fetching. All other opcodes will advance into IQ.
if (DRF2.opcode == "HALT"){
//Dispatch fails
no_dispatch++;
}
else if (DRF2.opcode == "NOP"){
// NOP instructions do not advance into the IQ.
// NOP instructions do not get a ROB entry.
// Mark the stage empty so advancement can continue, dispatch failed
DRF2.empty = true;
no_dispatch++;
}
else if (DRF2.opcode == "BZ" ||
DRF2.opcode == "BNZ" ||
DRF2.opcode == "BAL" ||
DRF2.opcode == "JUMP"){
// Specification 2, Detail 2 states that no control flow instructions
// can be dispatched until any control flow instruction in the IQ has
// been issued.
bool inIQ = false;
bool inROB = false;
if (myiq.hasEntryWithOpcode("BZ") ||
myiq.hasEntryWithOpcode("BNZ") ||
myiq.hasEntryWithOpcode("BAL") ||
myiq.hasEntryWithOpcode("JUMP")){
//Dispatch stalls
no_dispatch++;
}
else {
if (DRF2.isReady() && !DRF2.isEmpty()){
//Advance the contents of DRF2 into the IQ
if( inIQ == false){
inIQ = myiq.dispatchInst(DRF2);
}
//Advance the contents of DRF2 into the ROB
if( inROB == false){
inROB = myrob.addStage(DRF2);
}
if( inIQ && inROB){
//Empty DRF2
DRF2.empty = true;
//Increment stats counters
dispatched++;
inIQ = false;
inROB = false;
}
}
else {no_dispatch++;}
}
} // DRF2 control flow instruction handling
else {
bool inIQ = false;
bool inROB = false;
if (DRF2.isReady() && !DRF2.isEmpty()){
//Advance the contents of DRF2 into the IQ
if( inIQ == false){
inIQ = myiq.dispatchInst(DRF2);
}
//Advance the contents of DRF2 into the ROB
if( inROB == false){
inROB = myrob.addStage(DRF2);
}
//Empty DRF2
DRF2.empty = true;
//Increment stats counters
dispatched++;
}
else {no_dispatch++;}
}
/****DRF1 STAGE****/
if (DRF1.isReady() && DRF2.isEmpty()){
DRF1.advance(DRF2);
}
/****F STAGE****/
if (F.isReady() && DRF1.isEmpty()){
F.advance(DRF1);
}
/*WORKING PHASE***************************************************************
******************************************************************************
*****************************************************************************/
/****ALU3 STAGE****/
if (--(ALU3.lcounter) <= 0 && !ALU3.isEmpty()) {
//Writeback
myregisters.write(ALU3.operands.at(0), ALU3.values.at(0), ALU3.valids.at(0));
ALU3.ready = true;
}
/****ALU2 STAGE****/
if (--(ALU2.lcounter) <= 0 && !ALU2.isEmpty()) {
//Perform arithmetic, set valid bit, set Z flag
if (ALU2.opcode == "ADD"){
if (!ALU2.valids.at(0)){
ALU2.values.at(0) = ALU2.values.at(1) + ALU2.values.at(2);
ALU2.valids.at(0) = true;
if (ALU2.c >= Zcycle){
Z = ALU2.values.at(0);
Zcycle = ALU2.c;
}
}
}
else if (ALU2.opcode == "SUB"){
if (!ALU2.valids.at(0)){
ALU2.values.at(0) = ALU2.values.at(1) - ALU2.values.at(2);
ALU2.valids.at(0) = true;
if (ALU2.c >= Zcycle){
Z = ALU2.values.at(0);
Zcycle = ALU2.c;
}
}
}
else if (ALU2.opcode == "MOVC"){
ALU2.values.at(0) = ALU2.values.at(1) + 0;
ALU2.valids.at(0) = true;
}
else if (ALU2.opcode == "AND"){
if (!ALU2.valids.at(0)){
ALU2.values.at(0) = ALU2.values.at(1) & ALU2.values.at(2);
ALU2.valids.at(0) = true;
if (ALU2.c >= Zcycle){
Z = ALU2.values.at(0);
Zcycle = ALU2.c;
}
}
}
else if (ALU2.opcode == "OR"){
if (!ALU2.valids.at(0)){
ALU2.values.at(0) = ALU2.values.at(1) | ALU2.values.at(2);
ALU2.valids.at(0) = true;
if (ALU2.c >= Zcycle){
Z = ALU2.values.at(0);
Zcycle = ALU2.c;
}
}
}
else if (ALU2.opcode == "EX-OR"){
if (!ALU2.valids.at(0)){
ALU2.values.at(0) = ALU2.values.at(1) ^ ALU2.values.at(2);
ALU2.valids.at(0) = true;
if (ALU2.c >= Zcycle){
Z = ALU2.values.at(0);
Zcycle = ALU2.c;
}
}
}
else {
std::cerr << "Unrecognized opcode " << ALU2.opcode << " at ALU2 WORKING phase" << std::endl;
}
ALU2.ready = true;
}
/****ALU1 STAGE****/
if (--(ALU1.lcounter) <= 0) {
ALU1.ready = true;
}
/****MUL2 STAGE****/
if (--(MUL2.lcounter) <= 0 && !MUL2.isEmpty()) {
//Writeback
myregisters.write(MUL2.operands.at(0), MUL2.values.at(0), MUL2.valids.at(0));
MUL2.ready = true;
}
/****MUL1 STAGE****/
if (--(MUL1.lcounter) <= 0 && !MUL1.isEmpty()) {
//Perform arithmetic, set valid bit, set Z flag
if (MUL1.opcode == "MUL") {
if (!ALU2.valids.at(0)){
ALU2.values.at(0) = ALU2.values.at(1) * ALU2.values.at(2);
ALU2.valids.at(0) = true;
if (ALU2.c >= Zcycle){
Z = ALU2.values.at(0);
Zcycle = ALU2.c;
}
}
}
else {
std::cerr << "Unrecognized opcode " << MUL1.opcode << " at MUL1 WORKING phase" << std::endl;
}
MUL1.ready = true;
}
/****B2 STAGE****/
if (--(B2.lcounter) <= 0 && !B2.isEmpty()) {
//Writeback X register
if (B2.opcode == "BAL") {
myregisters.write("X", (B2.pc)+4, true);
}
B2.ready = true;
}
/****B1 STAGE****/
if (--(B1.lcounter) <= 0 && !B1.isEmpty()) {
//Perform branching logic
//Branch conditional is true or unconditionally taken
if ((B1.opcode == "BZ" && Z == 0) ||
(B1.opcode == "BNZ" && Z != 0) ||
(B1.opcode == "BAL") ||
(B1.opcode == "JUMP")){
// Flush the ROB, IQ
myrob.flush(B1.c);
myiq.flush(B1.c, myregisters);
// For each non-branch stage,
// flush instructions if its timestamp
// is after B1 stage's timestamp
ALU3.flush(B1.c, myregisters);
ALU2.flush(B1.c, myregisters);
ALU1.flush(B1.c, myregisters);
MUL2.flush(B1.c, myregisters);
MUL1.flush(B1.c, myregisters);
LSFU3.flush(B1.c, myregisters);
LSFU2.flush(B1.c, myregisters);
LSFU1.flush(B1.c, myregisters);
DRF2.flush(B1.c, myregisters);
DRF1.flush(B1.c, myregisters);
F.flush(B1.c, myregisters);
is_halting = false;
//Set global pc based on B1.opcode (and local B1.pc)
if(B1.opcode == "BZ" || B1.opcode == "BNZ"){
pc = B1.pc + B1.values.at(0);
}
else if (B1.opcode == "BAL" || B1.opcode == "JUMP"){
pc = B1.values.at(0) + B1.values.at(1);
}
else {}
//Set B1 as ready
B1.ready = true;
}
//Branch conditional is false
else if ((B1.opcode == "BZ" && Z != 0) || (B1.opcode == "BNZ" && Z == 0)){
B1.ready = true;
}
//Opcode is not one of BZ, BNZ, BAL, JUMP
else{
std::cerr << "Unrecognized opcode " << B1.opcode << " at B1 WORKING phase" << std::endl;
B1.ready = false;
}
}
/****LSFU3 STAGE****/
if (--(LSFU3.lcounter) <= 0 && !LSFU3.isEmpty()) {
if (LSFU3.opcode == "LOAD") {
//Perform memory access
LSFU3.values.at(0) = mydata.readMem(LSFU3.values.at(1));
LSFU3.valids.at(0) = true;
//Writeback
myregisters.write(LSFU3.operands.at(0), LSFU3.values.at(0), LSFU3.valids.at(0));
}
else if (LSFU3.opcode == "STORE") {
//Perform memory access
//mydata.writeMem(LSFU3.values.at(1), LSFU3.values.at(0));
//No writeback (no destination registers)
}
else {
std::cerr << "Unrecognized opcode " << LSFU3.opcode << " at LSFU3 WORKING phase" << std::endl;
}
LSFU3.ready = true;
}
/****LSFU2 STAGE****/
if (--(LSFU2.lcounter) <= 0 && !LSFU2.isEmpty()) {
/*This phase reserved for TLB lookup (not implemented)*/
if (LSFU2.opcode == "LOAD"){
///Operand[0] need not be valid; it gets written to in LSFU3
LSFU2.ready = true;
}
else if (LSFU2.opcode == "STORE"){
if (LSFU2.valids.at(0))
LSFU2.ready = true;
else
LSFU2.ready = false;
}
else{
std::cerr << "Unrecognized opcode " << LSFU2.opcode << " at LSFU2 WORKING phase" << std::endl;
LSFU2.ready = false;
}
}
/****LSFU1 STAGE****/
if (--(LSFU1.lcounter) <= 0 && !LSFU1.isEmpty()) {
//Compute address, store in src1 (LOAD) or src2 (STORE)
if (LSFU1.opcode == "LOAD") {
LSFU1.values.at(1) = LSFU1.values.at(1) + LSFU1.values.at(2);
LSFU1.valids.at(1) = true;
} else if (LSFU1.opcode == "STORE") {
LSFU1.values.at(1) = LSFU1.values.at(1) + LSFU1.values.at(2);
LSFU1.valids.at(1) = true;
} else {
std::cerr << "Unrecognized opcode " << LSFU1.opcode << " at LSFU1 WORKING phase" << std::endl;
}
LSFU1.ready = true;
}
/****DRF2 STAGE****/
if (--(DRF2.lcounter) <= 0 && !DRF2.isEmpty()) {
// Readout available operands
if (DRF2.opcode == "ADD" ||
DRF2.opcode == "SUB" ||
DRF2.opcode == "MUL" ||
DRF2.opcode == "AND" ||
DRF2.opcode == "OR" ||
DRF2.opcode == "EX-OR"){
DRF2.values.at(0) = myregisters.physRead(DRF2.operands.at(0));
DRF2.valids.at(0) = myregisters.physIsValid(DRF2.operands.at(0));
DRF2.values.at(1) = myregisters.read(DRF2.operands.at(1));
DRF2.valids.at(1) = myregisters.isValid(DRF2.operands.at(1));
DRF2.values.at(2) = myregisters.read(DRF2.operands.at(2));
DRF2.valids.at(2) = myregisters.isValid(DRF2.operands.at(2));
DRF2.ready = true;
}
else if (DRF2.opcode == "MOVC"){
DRF2.values.at(0) = myregisters.physRead(DRF2.operands.at(0));
DRF2.valids.at(0) = myregisters.physIsValid(DRF2.operands.at(0));
DRF2.values.at(1) = DRF2.littoi(DRF2.operands.at(1));
DRF2.valids.at(1) = true;
//myregisters.write(DRF2.operands.at(0), DRF2.values.at(0), true);
DRF2.ready = true;
}
else if (DRF2.opcode == "STORE"){
DRF2.values.at(0) = myregisters.read(DRF2.operands.at(0));
DRF2.valids.at(0) = myregisters.isValid(DRF2.operands.at(0));
DRF2.values.at(1) = myregisters.read(DRF2.operands.at(1));
DRF2.valids.at(1) = myregisters.isValid(DRF2.operands.at(1));
DRF2.values.at(2) = DRF2.littoi(DRF2.operands.at(2));
DRF2.valids.at(2) = true;
if (DRF2.valids.at(1))
DRF2.ready = true;
}
else if (DRF2.opcode == "LOAD"){
DRF2.values.at(0) = myregisters.physRead(DRF2.operands.at(0));
DRF2.valids.at(0) = myregisters.physIsValid(DRF2.operands.at(0));
DRF2.values.at(1) = myregisters.read(DRF2.operands.at(1));
DRF2.valids.at(1) = myregisters.isValid(DRF2.operands.at(1));
DRF2.values.at(2) = DRF2.littoi(DRF2.operands.at(2));
DRF2.valids.at(2) = true;
DRF2.ready = true;
}
else if (DRF2.opcode == "BZ" ||
DRF2.opcode == "BNZ"){
DRF2.values.at(0) = DRF2.littoi(DRF2.operands.at(0));
DRF2.valids.at(0) = true;
DRF2.ready = true;
}
else if (DRF2.opcode == "BAL" ||
DRF2.opcode == "JUMP"){
DRF2.values.at(0) = myregisters.read(DRF2.operands.at(0));
DRF2.valids.at(0) = myregisters.isValid(DRF2.operands.at(0));
DRF2.values.at(1) = DRF2.littoi(DRF2.operands.at(1));
DRF2.valids.at(1) = true;
DRF2.ready = true;
}
else if (DRF2.opcode == "HALT"){
DRF2.ready = false;
is_halting = true;
}
else{
std::cerr << "Unresolvable opcode in DRF2: " << DRF2.opcode << std::endl;
exit(1);
}//End DRF Stage
DRF2.ready = true;
}
/****DRF1 STAGE****/
if (--(DRF1.lcounter) <= 0 && !DRF1.isEmpty()) {
if (DRF1.opcode == "ADD" ||
DRF1.opcode == "SUB" ||
DRF1.opcode == "MUL" ||
DRF1.opcode == "AND" ||
DRF1.opcode == "OR" ||
DRF1.opcode == "EX-OR" ||
DRF1.opcode == "MOVC" ||
DRF1.opcode == "LOAD"){
// Perform renaming
DRF1.operands.at(0) = myregisters.getRenamed(DRF1.operands.at(0));
DRF1.ready = true;
}
if (DRF1.opcode == "STORE" ||
DRF1.opcode == "BZ" ||
DRF1.opcode == "BNZ" ||
DRF1.opcode == "BAL" ||
DRF1.opcode == "JUMP" ||
DRF1.opcode == "HALT"){
DRF1.ready = true;
}
}
/****F STAGE****/
// If is_halting == true, do not fetch further instructions. Remain empty.
// If a HALT is fetched, set is_halting = true.
// These conditions are needed in the STOPPING PHASE.
if (!is_halting){
if (--(F.lcounter) <= 0) {
// Fetch the instruction at PC
if (F.isEmpty() == true){
F.initialize();
F.lcounter = 0;
std::vector<std::string> instr = mycode.getInstr(pc);
F.pc = pc;
F.opcode = instr.at(0);
for (int i=1;i<instr.size();i++){
if (instr.at(i) != " ")
F.operands.at(i - 1) = instr.at(i);
}
F.empty = false;
F.ready = true;
// Increment the PC
pc += 4;
}
// Check whether the is_halting flag should be set
if (F.opcode == "HALT")
is_halting = true;
}
}
/*STOPPING PHASE**************************************************************
******************************************************************************
*****************************************************************************/
//Stop execution (return code 0) if:
// 1. A HALT has been encountered (set with HALT in F, preventing fetch)
// 2. HALT reaches DRF2 (ensures no instructions need to be dispatched)
// 3. The IQ is empty (ensures no instructions need to be issued)
// 4. The ROB is empty (ensures no instructions need to be committed)
//Continue execution (return code 1) otherwise.
if (is_halting &&
DRF2.opcode == "HALT" &&
myiq.isEmpty() &&
myrob.isEmpty()){
cycle++;
return 0;
}
else{
cycle++;
return 1;
}
}
| 30.41395 | 97 | 0.569773 | [
"vector"
] |
0b37870577dc80a88381057533f9a64d1c6e43dc | 4,743 | cpp | C++ | src/aws_hls4ml.cpp | sznajder/hls4ml_c | ca104370f2029fab6fe0db0e775ab768fe01f3eb | [
"Unlicense"
] | 3 | 2019-06-12T15:40:49.000Z | 2021-12-03T20:44:08.000Z | src/aws_hls4ml.cpp | violatingcp/hls4ml_c | ca104370f2029fab6fe0db0e775ab768fe01f3eb | [
"Unlicense"
] | null | null | null | src/aws_hls4ml.cpp | violatingcp/hls4ml_c | ca104370f2029fab6fe0db0e775ab768fe01f3eb | [
"Unlicense"
] | 4 | 2019-02-06T15:49:40.000Z | 2022-01-04T20:33:26.000Z | /**********
Copyright (c) 2018, Xilinx, 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.
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.
**********/
/*******************************************************************************
Description:
HLS pragmas can be used to optimize the design : improve throughput, reduce latency and
device resource utilization of the resulting RTL code
This is a wrapper to be used with an hls4ml project to enable proper handling by SDAccel
*******************************************************************************/
#define PROJ_HDR <MYPROJ.h>
#include PROJ_HDR
#include "kernel_params.h"
/*
HLS4ML Kernel Implementation
Arguments:
in (input) --> Input Vector
out (output) --> Output Vector
*/
extern "C" {
void aws_hls4ml(
const data_t *in, // Read-Only Vector
data_t *out // Output Result
)
{
// SDAccel kernel must have one and only one s_axilite interface which will be used by host application to configure the kernel.
// Here bundle control is defined which is s_axilite interface and associated with all the arguments (in and out),
// control interface must also be associated with "return".
// All the global memory access arguments must be associated to one m_axi(AXI Master Interface). Here all two arguments(in, out) are
// associated to bundle gmem which means that a AXI master interface named "gmem" will be created in Kernel and all these variables will be
// accessing global memory through this interface.
// Multiple interfaces can also be created based on the requirements. For example when multiple memory accessing arguments need access to
// global memory simultaneously, user can create multiple master interfaces and can connect to different arguments.
#pragma HLS INTERFACE m_axi port=in offset=slave bundle=gmem
#pragma HLS INTERFACE m_axi port=out offset=slave bundle=gmem
#pragma HLS INTERFACE s_axilite port=in bundle=control
#pragma HLS INTERFACE s_axilite port=out bundle=control
#pragma HLS INTERFACE s_axilite port=return bundle=control
unsigned short insize, outsize;
//necessary for hls4ml kernel, not used
#ifdef IS_DENSE
input_t in_buf[STREAMSIZE][N_INPUTS];
#endif
#ifdef IS_CONV1D
input_t in_buf[STREAMSIZE][Y_INPUTS][N_CHAN];
#endif
result_t out_buf[STREAMSIZE][N_OUTPUTS];
//these will get partitioned properly in the hls4ml code
//getting data from axi stream and formatting properly
for (int i = 0; i < STREAMSIZE; i++) {
#pragma HLS LOOP UNROLL
#ifdef IS_DENSE
for (int j = 0; j < N_INPUTS; j++) {
#pragma HLS LOOP UNROLL
in_buf[i][j] = (input_t)in[i*N_INPUTS+j];
}
#endif
#ifdef IS_CONV1D
for (int j = 0; j < Y_INPUTS; j++) {
#pragma HLS LOOP UNROLL
for (int k = 0; k < N_CHAN; k++) {
#pragma HLS LOOP UNROLL
in_buf[i][j] = (input_t)in[i*Y_INPUTS*N_CHAN+j*N_CHAN+k];
}
}
#endif
}
//run inference
for (int i = 0; i < STREAMSIZE; i++) {
#pragma HLS dataflow
hls4ml: MYPROJ(in_buf[i],out_buf[i],insize,outsize);
}
//place output into axi stream output
for (int i = 0; i < STREAMSIZE; i++) {
#pragma HLS LOOP UNROLL
for (int j = 0; j < N_OUTPUTS; j++) {
#pragma HLS LOOP UNROLL
out[i*N_OUTPUTS+j] = (data_t)out_buf[i][j];
}
}
}
}
| 40.538462 | 140 | 0.701033 | [
"vector"
] |
0b39b6b098e8f8faf26a692f58310282c5138670 | 11,062 | hpp | C++ | turtlebot2/kobuki_base/kobuki_ros/kobuki_node/include/kobuki_node/kobuki_ros.hpp | RoboticsLabURJC/2021-tfg-carlos-caminero | e23991616cb971b9a0bd95b653789c54f571a930 | [
"Apache-2.0"
] | null | null | null | turtlebot2/kobuki_base/kobuki_ros/kobuki_node/include/kobuki_node/kobuki_ros.hpp | RoboticsLabURJC/2021-tfg-carlos-caminero | e23991616cb971b9a0bd95b653789c54f571a930 | [
"Apache-2.0"
] | null | null | null | turtlebot2/kobuki_base/kobuki_ros/kobuki_node/include/kobuki_node/kobuki_ros.hpp | RoboticsLabURJC/2021-tfg-carlos-caminero | e23991616cb971b9a0bd95b653789c54f571a930 | [
"Apache-2.0"
] | null | null | null | /*
* Copyright (c) 2012, Yujin Robot.
* 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 Yujin Robot nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/**
* @file /kobuki_node/include/kobuki_node/kobuki_ros.hpp
*
* @brief Wraps the kobuki driver in a ROS-specific library
*
**/
/*****************************************************************************
** Ifdefs
*****************************************************************************/
#ifndef KOBUKI_ROS_HPP_
#define KOBUKI_ROS_HPP_
/*****************************************************************************
** Includes
*****************************************************************************/
#include <memory>
#include <string>
#include <vector>
#include <diagnostic_updater/diagnostic_updater.hpp>
#include <nav_msgs/msg/odometry.hpp>
#include <rclcpp/rclcpp.hpp>
#include <sensor_msgs/msg/battery_state.hpp>
#include <sensor_msgs/msg/imu.hpp>
#include <sensor_msgs/msg/joint_state.hpp>
#include <std_msgs/msg/empty.hpp>
#include <std_msgs/msg/int16_multi_array.hpp>
#include <std_msgs/msg/string.hpp>
#include <tf2_ros/transform_broadcaster.h>
#include <ecl/sigslots.hpp>
#include <kobuki_ros_interfaces/msg/button_event.hpp>
#include <kobuki_ros_interfaces/msg/bumper_event.hpp>
#include <kobuki_ros_interfaces/msg/cliff_event.hpp>
#include <kobuki_ros_interfaces/msg/controller_info.hpp>
#include <kobuki_ros_interfaces/msg/digital_output.hpp>
#include <kobuki_ros_interfaces/msg/digital_input_event.hpp>
#include <kobuki_ros_interfaces/msg/external_power.hpp>
#include <kobuki_ros_interfaces/msg/dock_infra_red.hpp>
#include <kobuki_ros_interfaces/msg/led.hpp>
#include <kobuki_ros_interfaces/msg/motor_power.hpp>
#include <kobuki_ros_interfaces/msg/power_system_event.hpp>
#include <kobuki_ros_interfaces/msg/robot_state_event.hpp>
#include <kobuki_ros_interfaces/msg/sensor_state.hpp>
#include <kobuki_ros_interfaces/msg/sound.hpp>
#include <kobuki_ros_interfaces/msg/version_info.hpp>
#include <kobuki_ros_interfaces/msg/wheel_drop_event.hpp>
#include <kobuki_core/kobuki.hpp>
#include "diagnostics.hpp"
#include "odometry.hpp"
/*****************************************************************************
** Namespaces
*****************************************************************************/
namespace kobuki_node
{
class KobukiRos final : public rclcpp::Node
{
public:
explicit KobukiRos(const rclcpp::NodeOptions & options);
~KobukiRos() override;
KobukiRos(KobukiRos && c) = delete;
KobukiRos & operator=(KobukiRos && c) = delete;
KobukiRos(const KobukiRos & c) = delete;
KobukiRos & operator=(const KobukiRos & c) = delete;
EIGEN_MAKE_ALIGNED_OPERATOR_NEW
private:
void update();
/*********************
** Variables
**********************/
kobuki::Kobuki kobuki_;
sensor_msgs::msg::JointState joint_states_;
std::unique_ptr<Odometry> odometry_;
bool cmd_vel_timed_out_; // stops warning spam when cmd_vel flags as timed out more than once in a row
bool serial_timed_out_; // stops warning spam when serial connection timed out more than once in a row
std::unique_ptr<tf2_ros::TransformBroadcaster> odom_broadcaster_;
/*********************
** Ros Comms
**********************/
rclcpp::Publisher<kobuki_ros_interfaces::msg::VersionInfo>::SharedPtr version_info_publisher_;
rclcpp::Publisher<kobuki_ros_interfaces::msg::ControllerInfo>::SharedPtr controller_info_publisher_;
rclcpp::Publisher<sensor_msgs::msg::Imu>::SharedPtr imu_data_publisher_;
rclcpp::Publisher<kobuki_ros_interfaces::msg::SensorState>::SharedPtr sensor_state_publisher_;
rclcpp::Publisher<sensor_msgs::msg::JointState>::SharedPtr joint_state_publisher_;
rclcpp::Publisher<kobuki_ros_interfaces::msg::DockInfraRed>::SharedPtr dock_ir_publisher_;
rclcpp::Publisher<sensor_msgs::msg::BatteryState>::SharedPtr battery_state_publisher_;
rclcpp::Publisher<sensor_msgs::msg::Imu>::SharedPtr raw_imu_data_publisher_;
rclcpp::Publisher<kobuki_ros_interfaces::msg::ButtonEvent>::SharedPtr button_event_publisher_;
rclcpp::Publisher<kobuki_ros_interfaces::msg::DigitalInputEvent>::SharedPtr input_event_publisher_;
rclcpp::Publisher<kobuki_ros_interfaces::msg::RobotStateEvent>::SharedPtr robot_event_publisher_;
rclcpp::Publisher<kobuki_ros_interfaces::msg::BumperEvent>::SharedPtr bumper_event_publisher_;
rclcpp::Publisher<kobuki_ros_interfaces::msg::CliffEvent>::SharedPtr cliff_event_publisher_;
rclcpp::Publisher<kobuki_ros_interfaces::msg::WheelDropEvent>::SharedPtr wheel_event_publisher_;
rclcpp::Publisher<kobuki_ros_interfaces::msg::PowerSystemEvent>::SharedPtr power_event_publisher_;
rclcpp::Publisher<std_msgs::msg::String>::SharedPtr raw_data_command_publisher_;
rclcpp::Publisher<std_msgs::msg::String>::SharedPtr raw_data_stream_publisher_;
rclcpp::Publisher<std_msgs::msg::Int16MultiArray>::SharedPtr raw_control_command_publisher_;
rclcpp::Publisher<nav_msgs::msg::Odometry>::SharedPtr odom_publisher_;
rclcpp::Subscription<geometry_msgs::msg::Twist>::SharedPtr velocity_command_subscriber_;
rclcpp::Subscription<kobuki_ros_interfaces::msg::DigitalOutput>::SharedPtr digital_output_command_subscriber_;
rclcpp::Subscription<kobuki_ros_interfaces::msg::ExternalPower>::SharedPtr external_power_command_subscriber_;
rclcpp::Subscription<kobuki_ros_interfaces::msg::ControllerInfo>::SharedPtr controller_info_command_subscriber_;
rclcpp::Subscription<kobuki_ros_interfaces::msg::Led>::SharedPtr led1_command_subscriber_, led2_command_subscriber_;
rclcpp::Subscription<kobuki_ros_interfaces::msg::Sound>::SharedPtr sound_command_subscriber_;
rclcpp::Subscription<kobuki_ros_interfaces::msg::MotorPower>::SharedPtr motor_power_subscriber_;
rclcpp::Subscription<std_msgs::msg::Empty>::SharedPtr reset_odometry_subscriber_;
rclcpp::TimerBase::SharedPtr timer_;
/*********************
** Ros Callbacks
**********************/
void subscribeVelocityCommand(const std::shared_ptr<geometry_msgs::msg::Twist> msg);
void subscribeLed1Command(const std::shared_ptr<kobuki_ros_interfaces::msg::Led> msg);
void subscribeLed2Command(const std::shared_ptr<kobuki_ros_interfaces::msg::Led> msg);
void subscribeDigitalOutputCommand(const std::shared_ptr<kobuki_ros_interfaces::msg::DigitalOutput> msg);
void subscribeExternalPowerCommand(const std::shared_ptr<kobuki_ros_interfaces::msg::ExternalPower> msg);
void subscribeResetOdometry(const std::shared_ptr<std_msgs::msg::Empty> msg);
void subscribeSoundCommand(const std::shared_ptr<kobuki_ros_interfaces::msg::Sound> msg);
void subscribeMotorPower(const std::shared_ptr<kobuki_ros_interfaces::msg::MotorPower> msg);
void subscribeControllerInfoCommand(const std::shared_ptr<kobuki_ros_interfaces::msg::ControllerInfo> msg);
/*********************
** SigSlots
**********************/
ecl::Slot<const kobuki::VersionInfo&> slot_version_info_;
ecl::Slot<> slot_stream_data_;
ecl::Slot<> slot_controller_info_;
ecl::Slot<const kobuki::ButtonEvent&> slot_button_event_;
ecl::Slot<const kobuki::BumperEvent&> slot_bumper_event_;
ecl::Slot<const kobuki::CliffEvent&> slot_cliff_event_;
ecl::Slot<const kobuki::WheelEvent&> slot_wheel_event_;
ecl::Slot<const kobuki::PowerEvent&> slot_power_event_;
ecl::Slot<const kobuki::InputEvent&> slot_input_event_;
ecl::Slot<const kobuki::RobotEvent&> slot_robot_event_;
ecl::Slot<const std::string&> slot_debug_, slot_info_, slot_warn_, slot_error_;
ecl::Slot<kobuki::Command::Buffer&> slot_raw_data_command_;
ecl::Slot<kobuki::PacketFinder::BufferType&> slot_raw_data_stream_;
ecl::Slot<const std::vector<short>&> slot_raw_control_command_;
/*********************
** Slot Callbacks
**********************/
void processStreamData();
void publishWheelState();
void publishInertia();
void publishRawInertia();
void publishSensorState();
void publishDockIRData();
void publishBatteryState();
void publishVersionInfo(const kobuki::VersionInfo &version_info);
void publishControllerInfo();
void publishButtonEvent(const kobuki::ButtonEvent &event);
void publishBumperEvent(const kobuki::BumperEvent &event);
void publishCliffEvent(const kobuki::CliffEvent &event);
void publishWheelEvent(const kobuki::WheelEvent &event);
void publishPowerEvent(const kobuki::PowerEvent &event);
void publishInputEvent(const kobuki::InputEvent &event);
void publishRobotEvent(const kobuki::RobotEvent &event);
// debugging
void rosDebug(const std::string &msg) { RCLCPP_DEBUG(get_logger(), "%s", msg.c_str()); }
void rosInfo(const std::string &msg) { RCLCPP_INFO(get_logger(), "%s", msg.c_str()); }
void rosWarn(const std::string &msg) { RCLCPP_WARN(get_logger(), "%s", msg.c_str()); }
void rosError(const std::string &msg) { RCLCPP_ERROR(get_logger(), "%s", msg.c_str()); }
void publishRawDataCommand(kobuki::Command::Buffer &buffer);
void publishRawDataStream(kobuki::PacketFinder::BufferType &buffer);
void publishRawControlCommand(const std::vector<short> &velocity_commands);
/*********************
** Diagnostics
**********************/
diagnostic_updater::Updater updater_;
BatteryTask battery_diagnostics_;
WatchdogTask watchdog_diagnostics_;
CliffSensorTask cliff_diagnostics_;
WallSensorTask bumper_diagnostics_;
WheelDropTask wheel_diagnostics_;
MotorCurrentTask motor_diagnostics_;
MotorStateTask state_diagnostics_;
GyroSensorTask gyro_diagnostics_;
DigitalInputTask dinput_diagnostics_;
AnalogInputTask ainput_diagnostics_;
};
} // namespace kobuki_node
#endif /* KOBUKI_ROS_HPP_ */
| 47.681034 | 118 | 0.735491 | [
"vector"
] |
0b3eae881017a522ef253234b8571298f940b962 | 752 | cpp | C++ | Data Structure/Arrays/Sparse Arrays.cpp | pranayspeed/HackerRank-Solutions-C- | 54c3e1c567a96a22284ff079fb2c121ce68fe8b7 | [
"MIT"
] | null | null | null | Data Structure/Arrays/Sparse Arrays.cpp | pranayspeed/HackerRank-Solutions-C- | 54c3e1c567a96a22284ff079fb2c121ce68fe8b7 | [
"MIT"
] | null | null | null | Data Structure/Arrays/Sparse Arrays.cpp | pranayspeed/HackerRank-Solutions-C- | 54c3e1c567a96a22284ff079fb2c121ce68fe8b7 | [
"MIT"
] | null | null | null | #include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
/* Enter your code here. Read input from STDIN. Print output to STDOUT */
int N;
cin>>N;
vector<string> strList;
for(int i=0;i<N;i++)
{
string s;
cin>>s;
strList.push_back(s);
}
int Q;
cin>>Q;
vector<int> cnts;
for(int i=0;i<Q;i++)
{
string s;
cin>>s;
int c=0;
for(int i=0;i<strList.size();i++)
{
if(s.compare(strList[i])==0)
c++;
}
cnts.push_back(c);
}
for(int i=0;i<cnts.size();i++)
{
cout << cnts[i]<<endl;
}
return 0;
}
| 17.904762 | 78 | 0.470745 | [
"vector"
] |
0b3f358188a357bce97bdeaf3b43063eae33aa3f | 1,687 | hpp | C++ | src/algorithms/data_structures/array/min_subarray_equal_to_value.hpp | iamantony/CppNotes | 2707db6560ad80b0e5e286a04b2d46e5c0280b3f | [
"MIT"
] | 2 | 2020-07-31T14:13:56.000Z | 2021-02-03T09:51:43.000Z | src/algorithms/data_structures/array/min_subarray_equal_to_value.hpp | iamantony/CppNotes | 2707db6560ad80b0e5e286a04b2d46e5c0280b3f | [
"MIT"
] | 28 | 2015-09-22T07:38:21.000Z | 2018-10-02T11:00:58.000Z | src/algorithms/data_structures/array/min_subarray_equal_to_value.hpp | iamantony/CppNotes | 2707db6560ad80b0e5e286a04b2d46e5c0280b3f | [
"MIT"
] | 2 | 2018-10-11T14:10:50.000Z | 2021-02-27T08:53:50.000Z | #ifndef MIN_SUBARRAY_EQUAL_TO_VALUE_HPP
#define MIN_SUBARRAY_EQUAL_TO_VALUE_HPP
// https://leetcode.com/problems/minimum-size-subarray-sum/description/
/*
Given an array of n positive integers and a positive integer s, find the
minimal length of a contiguous subarray of which the sum ≥ s. If there isn't
one, return 0 instead.
Example:
Input: s = 7, nums = [2,3,1,2,4,3]
Output: 2
Explanation: the subarray [4,3] has the minimal length under the problem
constraint.
Follow up:
If you have figured out the O(n) solution, try coding another solution of
which the time complexity is O(n log n).
*/
#include <vector>
#include <limits>
namespace Algo::DS::Array {
class SubarrayEqualToValue {
public:
static int FindMinLengthSubarray(const int& s,
const std::vector<int>& nums) {
if (s <= 0 || nums.empty()) {
return 0;
}
size_t subArrStart = 0;
int currentSum = nums[subArrStart];
if (currentSum >= s) {
return 1;
}
int currentLength = 1, minLength = std::numeric_limits<int>::max();
for (size_t i = 1; i < nums.size(); ++i) {
currentSum += nums[i];
++currentLength;
if (currentSum >= s) {
while(currentSum - nums[subArrStart] >= s) {
currentSum -= nums[subArrStart];
++subArrStart;
--currentLength;
}
minLength = std::min(minLength, currentLength);
}
}
return minLength == std::numeric_limits<int>::max() ? 0 : minLength;
}
};
}
#endif // MIN_SUBARRAY_EQUAL_TO_VALUE_HPP
| 26.777778 | 76 | 0.589804 | [
"vector"
] |
0b421201397134330914540fa908e6adc98ff8a0 | 13,112 | cpp | C++ | tests/benchdnn/dnnl_memory.cpp | OpenImageDenoise/mkl-dnn | f53274c9fef211396655fc4340cb838452334089 | [
"Apache-2.0"
] | 4 | 2019-02-01T11:16:59.000Z | 2020-04-27T17:27:06.000Z | tests/benchdnn/dnnl_memory.cpp | OpenImageDenoise/mkl-dnn | f53274c9fef211396655fc4340cb838452334089 | [
"Apache-2.0"
] | null | null | null | tests/benchdnn/dnnl_memory.cpp | OpenImageDenoise/mkl-dnn | f53274c9fef211396655fc4340cb838452334089 | [
"Apache-2.0"
] | 5 | 2019-02-08T07:36:01.000Z | 2021-07-14T07:58:50.000Z | /*******************************************************************************
* Copyright 2019-2021 Intel Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*******************************************************************************/
#include <algorithm>
#include <atomic>
#include <memory>
#include <numeric>
#include <string>
#include "oneapi/dnnl/dnnl.h"
#ifdef DNNL_WITH_SYCL
#include "oneapi/dnnl/dnnl_sycl.hpp"
#endif
#include "dnn_types.hpp"
#include "dnnl_common.hpp"
#include "dnnl_memory.hpp"
#include "tests/test_thread.hpp"
int execute_reorder(const dnn_mem_t &src, dnn_mem_t &dst,
const_dnnl_primitive_attr_t attr) {
std::shared_ptr<const dnn_mem_t> r_src(&src, [](const dnn_mem_t *) {});
std::shared_ptr<dnn_mem_t> r_dst(&dst, [](dnn_mem_t *) {});
dnnl_primitive_desc_t r_pd = nullptr;
dnnl_primitive_t r {};
// Optimization to reduce testing time for GPU.
//
// For CPU <-> GPU reorders, the library creates GPU-side kernels.
// Benchdnn heavily relies on reorders and this greatly increases execution
// time because of big overhead on building OpenCL kernels.
//
// First, try to create CPU reorder for the requested GPU reorder. If
// succeeded, then create CPU memory object wrapping mapped pointers of
// source and destination and execute CPU reorder. If CPU reorder can't be
// create, then just execute a regular GPU reorder.
//
// This optimization is skipped when testing reorder, sum and concat
// primitives because they are used specifically to test GPU reorders.
#if (DNNL_GPU_RUNTIME == DNNL_RUNTIME_OCL) \
|| (DNNL_GPU_RUNTIME == DNNL_RUNTIME_SYCL)
std::string driver = std::string(driver_name);
bool is_reorder_related_driver = (driver == std::string("reorder")
|| driver == std::string("sum") || driver == std::string("concat"));
const auto &cpu_engine = get_cpu_engine();
if (!is_reorder_related_driver
&& (src.engine_kind() == dnnl_gpu
|| dst.engine_kind() == dnnl_gpu)) {
dnnl_status_t status = dnnl_reorder_primitive_desc_create(
&r_pd, &src.md_, cpu_engine, &dst.md_, cpu_engine, attr);
if (status == dnnl_success) {
// Create CPU memory objects wrapping mapped pointers of source and
// destination
r_src = std::make_shared<dnn_mem_t>(dnn_mem_t::create_from_host_ptr(
src.md_, cpu_engine, (void *)src));
r_dst = std::make_shared<dnn_mem_t>(dnn_mem_t::create_from_host_ptr(
dst.md_, cpu_engine, (void *)dst));
}
}
#endif
if (!r_pd) {
DNN_SAFE(dnnl_reorder_primitive_desc_create(&r_pd, &src.md_,
src.engine(), &dst.md_, dst.engine(), attr),
CRIT);
}
const auto q = [&](int index = 0) -> const dnnl_memory_desc_t & {
return *dnnl_primitive_desc_query_md(
r_pd, dnnl_query_exec_arg_md, index);
};
const auto &scratchpad_md = q(DNNL_ARG_SCRATCHPAD);
dnn_mem_t scratchpad(scratchpad_md, src.engine());
DNN_SAFE(dnnl_primitive_create(&r, r_pd), CRIT);
dnnl_status_t pd_destroy_status = dnnl_primitive_desc_destroy(r_pd);
if (pd_destroy_status != dnnl_success) {
dnnl_primitive_destroy(r);
DNN_SAFE(pd_destroy_status, CRIT);
}
args_t args;
args.set(DNNL_ARG_FROM, *r_src);
args.set(DNNL_ARG_TO, *r_dst);
args.set(DNNL_ARG_SCRATCHPAD, scratchpad);
SAFE(execute_and_wait(r, args), CRIT);
DNN_SAFE(dnnl_primitive_destroy(r), CRIT);
return OK;
}
int dnn_mem_t::reorder(const dnn_mem_t &rhs, const_dnnl_primitive_attr_t attr) {
if (this == &rhs) return OK;
return execute_reorder(rhs, *this, attr);
}
int dnn_mem_t::initialize_memory_create_sycl(const handle_info_t &handle_info) {
#ifdef DNNL_WITH_SYCL
if (is_nvidia_gpu(engine_)) {
// USM is not supported with Nvidia so ignore sycl_memory_kind and
// force SYCL buffers.
DNN_SAFE(dnnl_sycl_interop_memory_create(&m_, &md_, engine_,
dnnl_sycl_interop_buffer, handle_info.ptr),
CRIT);
return OK;
}
if (handle_info.is_host_ptr) {
// Ignore sycl_memory_kind with host pointers and force USM.
DNN_SAFE(dnnl_sycl_interop_memory_create(&m_, &md_, engine_,
dnnl_sycl_interop_usm, handle_info.ptr),
CRIT);
return OK;
}
switch (sycl_memory_kind) {
case sycl_memory_kind_ext_t::usm:
DNN_SAFE(dnnl_sycl_interop_memory_create(&m_, &md_, engine_,
dnnl_sycl_interop_usm, handle_info.ptr),
CRIT);
break;
case sycl_memory_kind_ext_t::buffer:
DNN_SAFE(dnnl_sycl_interop_memory_create(&m_, &md_, engine_,
dnnl_sycl_interop_buffer, handle_info.ptr),
CRIT);
break;
case sycl_memory_kind_ext_t::usm_device:
case sycl_memory_kind_ext_t::usm_shared: {
SAFE(handle_info.is_allocate() ? OK : FAIL, CRIT);
is_data_owner_ = true;
size_t sz = dnnl_memory_desc_get_size(&md_);
auto eng = dnnl::engine(engine_, true);
auto dev = dnnl::sycl_interop::get_device(eng);
auto ctx = dnnl::sycl_interop::get_context(eng);
if (sycl_memory_kind == sycl_memory_kind_ext_t::usm_device) {
data_ = cl::sycl::malloc_device(sz, dev, ctx);
} else {
data_ = cl::sycl::malloc_shared(sz, dev, ctx);
}
DNN_SAFE((sz > 0 && !data_) ? dnnl_out_of_memory : dnnl_success,
CRIT);
DNN_SAFE(dnnl_sycl_interop_memory_create(
&m_, &md_, engine_, dnnl_sycl_interop_usm, data_),
CRIT);
break;
}
default: assert(!"not expected");
}
#else
(void)handle_info;
#endif
return OK;
}
int dnn_mem_t::initialize_memory_create(const handle_info_t &handle_info) {
bool is_sycl = is_sycl_engine(engine_);
if (handle_info.is_host_ptr) {
// Host pointer can be used with CPU memory only.
// XXX: assumption is that SYCL can work with native host pointers.
SAFE(is_cpu(engine_) ? OK : FAIL, CRIT);
}
if (is_cpu(engine_) && handle_info.is_allocate() && !is_sycl) {
// Allocate memory for native runtime directly.
is_data_owner_ = true;
const size_t alignment = 2 * 1024 * 1024;
size_t sz = dnnl_memory_desc_get_size(&md_);
data_ = zmalloc(sz, alignment);
DNN_SAFE(!data_ ? dnnl_out_of_memory : dnnl_success, CRIT);
DNN_SAFE(dnnl_memory_create(&m_, &md_, engine_, data_), CRIT);
} else if (is_sycl) {
SAFE(initialize_memory_create_sycl(handle_info), CRIT);
} else {
is_data_owner_ = false;
data_ = nullptr;
DNN_SAFE(dnnl_memory_create(&m_, &md_, engine_, handle_info.ptr), CRIT);
}
return OK;
}
int dnn_mem_t::cleanup_sycl() {
#ifdef DNNL_WITH_SYCL
switch (sycl_memory_kind) {
case sycl_memory_kind_ext_t::usm_device:
case sycl_memory_kind_ext_t::usm_shared: {
auto eng = dnnl::engine(engine_, true);
auto ctx = dnnl::sycl_interop::get_context(eng);
cl::sycl::free(data_, ctx);
break;
}
default: break;
}
#endif
return OK;
}
dnn_mem_t dnn_mem_t::create_from_host_ptr(
const dnnl_memory_desc_t &md, dnnl_engine_t engine, void *host_ptr) {
return dnn_mem_t(md, engine, {true, host_ptr});
}
// Returns physical offset by logical one. Logical offset is represented by an
// array pos. If is_pos_padded is true pos represents the position in already
// padded area.
dnnl_dim_t md_off_v(const dnnl_memory_desc_t &md, const dnnl_dims_t pos,
bool is_pos_padded) {
assert(md.format_kind == dnnl_blocked);
const auto &blk = md.format_desc.blocking;
dnnl_dims_t pos_copy = {0};
for (int d = 0; d < md.ndims; ++d)
pos_copy[d] = pos[d] + (is_pos_padded ? 0 : md.padded_offsets[d]);
dnnl_dim_t phys_offset = md.offset0;
if (blk.inner_nblks > 0) {
dnnl_dim_t blk_stride = 1;
for (int iblk = blk.inner_nblks - 1; iblk >= 0; --iblk) {
const int d = blk.inner_idxs[iblk];
dnnl_dim_t p = pos_copy[d] % blk.inner_blks[iblk];
pos_copy[d] /= blk.inner_blks[iblk];
phys_offset += p * blk_stride;
blk_stride *= blk.inner_blks[iblk];
}
}
for (int d = 0; d < md.ndims; ++d) {
const dnnl_dim_t p = pos_copy[d];
phys_offset += p * blk.strides[d];
}
return phys_offset;
}
// Returns physical offset by logical one. logical offset is represented by a
// scalar l_offset. If is_pos_padded is true, l_offset represents logical
// offset in already padded area.
static dnnl_dim_t md_off_l(dnnl_dims_t _pos, const dnnl_memory_desc_t &md,
dnnl_dim_t l_offset, bool is_pos_padded = false) {
dnnl_dims_t pos;
for (int rd = 0; rd < md.ndims; ++rd) {
const int d = md.ndims - 1 - rd;
const dnnl_dim_t cur_dim
= is_pos_padded ? md.padded_dims[d] : md.dims[d];
pos[d] = l_offset % cur_dim;
if (_pos) _pos[d] = pos[d];
l_offset /= cur_dim;
}
return md_off_v(md, pos, is_pos_padded);
}
template <typename T>
int check_zero_padding_impl(const dnn_mem_t &mem, int arg, int *error_count) {
const int ndims = mem.md_.ndims;
const auto *dims = mem.md_.dims;
const auto *pdims = mem.md_.padded_dims;
if (ndims == 0) return OK;
if (mem.md_.format_kind != dnnl_blocked) return OK;
auto product = [](const dnnl_dim_t *beg, const dnnl_dim_t *end) {
return std::accumulate(
beg, end, (dnnl_dim_t)1, std::multiplies<dnnl_dim_t>());
};
int errors = 0;
std::atomic<int> ok(true);
const T *mem_ptr = (const T *)mem;
for (int dim_m_idx = 0; dim_m_idx < ndims; ++dim_m_idx) {
if (dims[dim_m_idx] == pdims[dim_m_idx]) continue;
auto dim_l = product(pdims, pdims + dim_m_idx);
auto dim_r = product(pdims + dim_m_idx + 1, pdims + ndims);
dnnl::impl::parallel_nd(dim_l, dim_r, [&](dnnl_dim_t l, dnnl_dim_t r) {
for (dnnl_dim_t m = dims[dim_m_idx]; m < pdims[dim_m_idx]; ++m) {
auto l_idx = (l * pdims[dim_m_idx] + m) * dim_r + r;
auto idx = md_off_l(nullptr, mem.md_, l_idx, true);
if (!(mem_ptr[idx] == 0)) ok = false;
}
});
// Run the check one more time to report incorrect elements. This check
// is sequential.
if (!ok) {
for_(dnnl_dim_t l = 0; l < dim_l; ++l)
for_(dnnl_dim_t m = dims[dim_m_idx]; m < pdims[dim_m_idx]; ++m)
for (dnnl_dim_t r = 0; r < dim_r; ++r) {
auto l_idx = (l * pdims[dim_m_idx] + m) * dim_r + r;
dnnl_dims_t pos = {};
auto idx = md_off_l(pos, mem.md_, l_idx, true);
bool idx_ok = (mem_ptr[idx] == 0);
if (!idx_ok) errors++;
const bool dump = (!idx_ok && (errors < 10 || verbose >= 10))
|| (verbose >= 99);
if (dump) {
BENCHDNN_PRINT(0,
"[%4ld][arg:%d]"
"[" IFMT "," IFMT "," IFMT "," IFMT "," IFMT
"," IFMT "] fp: 0.f dt:% 9.6g \n",
(long)idx, arg, pos[0], pos[1], pos[2], pos[3],
pos[4], pos[5], mem.get_elem(idx));
}
}
}
}
if (!ok) {
BENCHDNN_PRINT(0, "@@@ [arg:%d] check_zero_padding failed\n", arg);
}
if (error_count != nullptr) *error_count = errors;
return ok ? OK : FAIL;
}
int check_zero_padding(const dnn_mem_t &mem, int arg, int *error_count) {
#define CASE(dt, type) \
case dt: return check_zero_padding_impl<type>(mem, arg, error_count);
switch (mem.md_.data_type) {
case dnnl_data_type_undef:
return OK;
CASE(dnnl_bf16, bfloat16_t);
CASE(dnnl_f16, float16_t);
CASE(dnnl_f32, float);
CASE(dnnl_s32, int32_t);
CASE(dnnl_s8, int8_t);
CASE(dnnl_u8, uint8_t);
default: assert(!"bad data_type");
};
#undef CASE
return FAIL;
}
| 36.220994 | 80 | 0.598841 | [
"object"
] |
0b4acd8080225e4da2d6751d14e0130399bf843c | 6,086 | cpp | C++ | src/level/object.cpp | geoo89/Lix | 47dfd2317509ed5cb39b7b230b2de138dc613a6d | [
"CC0-1.0"
] | 1 | 2015-08-29T05:22:40.000Z | 2015-08-29T05:22:40.000Z | src/level/object.cpp | carvalhomb/AdaptiveLix | d7054c5f96fae54dccef23e48760851b4981a109 | [
"CC0-1.0"
] | null | null | null | src/level/object.cpp | carvalhomb/AdaptiveLix | d7054c5f96fae54dccef23e48760851b4981a109 | [
"CC0-1.0"
] | null | null | null | /*
* level/special.cpp
*
*/
#include "object.h"
#include "../graphic/glob_gfx.h" // colors for the selbox determination
#include "../other/file/io.h"
#include "../other/globals.h"
Object::Object(const Cutbit& c, Type t, int st)
:
cb (c),
type (t),
subtype (st),
selbox_x (cb.get_xl()), // Initializing these with the smallest selbox
selbox_y (cb.get_yl()), // starting at the furthest point is necessary
selbox_xl (0), // for determine_selbox().
selbox_yl (0),
trigger_x (0),
trigger_y (0),
trigger_xl(0),
trigger_yl(0),
trigger_xc(false),
trigger_yc(false),
sound (Sound::NOTHING)
{
switch (type) {
case HATCH:
trigger_x = cb.get_xl() / 2;
trigger_y = std::max(20, cb.get_yl() - 24);
special_x = 1;
break;
case GOAL:
trigger_x = cb.get_xl() / 2;
trigger_y = cb.get_yl() - 2;
trigger_xl = 12;
trigger_yl = 12;
trigger_xc = true;
trigger_yc = true;
break;
case TRAP:
trigger_x = cb.get_xl() / 2;
trigger_y = cb.get_yl() * 4 / 5;
trigger_xl = 4; // was 6 before July 2014, but 6 is not symmetric
trigger_yl = 6; // on a piece with width 16 and (lix-xl % 2 == 0)
trigger_xc = true;
trigger_yc = true;
sound = Sound::SPLAT;
break;
case WATER:
trigger_x = 0;
trigger_y = 20;
trigger_xl = cb.get_xl();
trigger_yl = cb.get_yl() - 20;
// Feuer?
if (subtype) {
trigger_y = 0;
trigger_yl = cb.get_yl();
}
break;
default:
break;
}
determine_selbox();
}
Object::~Object()
{
}
void Object::read_definitions_file(const Filename& filename)
{
// This assumes that the object's xl, yl, type, and subtype
// are all correctly set by the constructor or otherwise.
std::vector <IO::Line> lines;
if (! IO::fill_vector_from_file(lines, filename.get_rootful())) return;
for (IO::LineIt i = lines.begin(); i != lines.end(); ++i)
switch(i->type) {
case '#':
if (i->text1 == gloB->objdef_ta_absolute_x) {
trigger_x = i->nr1;
trigger_xc = false;
}
else if (i->text1 == gloB->objdef_ta_absolute_y) {
trigger_y = i->nr1;
trigger_yc = false;
}
else if (i->text1 == gloB->objdef_ta_from_center_x) {
trigger_x = cb.get_xl() / 2 + i->nr1;
trigger_xc = true;
}
else if (i->text1 == gloB->objdef_ta_from_center_y) {
trigger_y = cb.get_yl() / 2 + i->nr1;
trigger_yc = true;
}
else if (i->text1 == gloB->objdef_ta_from_bottom_y) {
trigger_y = cb.get_yl() - 2 + i->nr1;
trigger_yc = true;
}
else if (i->text1 == gloB->objdef_ta_xl) {
trigger_xl = i->nr1;
if (trigger_xl < 0) trigger_xl = 0;
}
else if (i->text1 == gloB->objdef_ta_yl) {
trigger_yl = i->nr1;
if (trigger_yl < 0) trigger_yl = 0;
}
else if (i->text1 == gloB->objdef_hatch_opening_frame) {
type = HATCH;
special_x = i->nr1;
}
else if (i->text1 == gloB->objdef_fling_nonpermanent) {
type = FLING;
subtype |= 2; // bit 1 nonpermanent trap
}
else if (i->text1 == gloB->objdef_fling_ignore_orient) {
type = FLING;
subtype |= 1; // bit 0 signifies fixed direction
}
else if (i->text1 == gloB->objdef_fling_x) {
type = FLING;
special_x = i->nr1;
}
else if (i->text1 == gloB->objdef_fling_y) {
type = FLING;
special_y = i->nr1;
}
else if (i->text1 == gloB->objdef_type_trampoline) {
type = TRAMPOLINE;
}
default:
break;
}
}
Object::Type Object::perm(const int n)
{
// don't start with 0 because most classes start with TERRAIN, not EMPTY.
return n == 1 ? Object::HATCH
: n == 2 ? Object::GOAL
: n == 3 ? Object::DECO
: n == 4 ? Object::TRAP
: n == 5 ? Object::WATER
: n == 6 ? Object::FLING
: n == 7 ? Object::TRAMPOLINE
: n == 8 ? Object::TERRAIN
//: n == 9 ? Object::ONEWAY
: Object::EMPTY; // Ich weiss keine Liste mehr -> TERRAIN
}
// This assumes that the selbox is initially starting at (0, 0) and stretching
// across the whole object. The selbox is set this way in the constructor.
void Object::determine_selbox()
{
if (!cb) return;
for (int xf = 0; xf < cb.get_x_frames(); ++xf)
for (int yf = 0; yf < cb.get_y_frames(); ++yf) {
int x_min = -1;
int x_max = cb.get_xl();
int y_min = -1;
int y_max = cb.get_yl();
bool stop = false;
while (!stop && x_max >= 0) {
x_max -= 1;
for (int y = 0; y < cb.get_yl(); y += 1)
if (cb.get_pixel(xf, yf, x_max, y) != color[COL_PINK]) stop=true;
}
stop = false;
while (!stop && x_min < x_max) {
x_min += 1;
for (int y = 0; y < cb.get_yl(); y += 1)
if (cb.get_pixel(xf, yf, x_min, y) != color[COL_PINK]) stop=true;
}
stop = false;
while (!stop && y_max >= 0) {
y_max -= 1;
for (int x = 0; x < cb.get_xl(); x += 1)
if (cb.get_pixel(xf, yf, x, y_max) != color[COL_PINK]) stop=true;
}
stop = false;
while (!stop && y_min < y_max) {
y_min += 1;
for (int x = 0; x < cb.get_xl(); x += 1)
if (cb.get_pixel(xf, yf, x, y_min) != color[COL_PINK]) stop=true;
}
selbox_x = std::min(selbox_x, x_min);
selbox_y = std::min(selbox_y, y_min);
selbox_xl = std::max(selbox_xl, x_max - x_min + 1);
selbox_yl = std::max(selbox_yl, y_max - y_min + 1);
}
}
| 29.687805 | 78 | 0.50608 | [
"object",
"vector"
] |
0b4e87be75f7f1127da5abb5eb7c3e32ffe12231 | 428 | cpp | C++ | Leet Code/268_missing_number.cpp | mishrakeshav/Competitive-Programming | b25dcfeec0fb9a9c71bf3a05644b619f4ca83dd2 | [
"MIT"
] | 2 | 2020-06-25T21:10:32.000Z | 2020-12-10T06:53:45.000Z | Leet Code/268_missing_number.cpp | mishrakeshav/Competitive-Programming | b25dcfeec0fb9a9c71bf3a05644b619f4ca83dd2 | [
"MIT"
] | null | null | null | Leet Code/268_missing_number.cpp | mishrakeshav/Competitive-Programming | b25dcfeec0fb9a9c71bf3a05644b619f4ca83dd2 | [
"MIT"
] | 3 | 2020-05-15T14:17:09.000Z | 2021-07-25T13:18:20.000Z | class Solution {
public:
int missingNumber(vector<int>& nums) {
int m = nums.size();
int s = 0;
for(int i = 0; i < m; i++){
s ^=(i+1)^(nums[i]);
}
return s;
}
};
class Solution {
public:
int missingNumber(vector<int>& nums) {
int m = nums.size();
int s = m*(m+1)/2;
for(int x:nums){
s -= x;
}
return s;
}
};
| 18.608696 | 42 | 0.418224 | [
"vector"
] |
0b4fe3fdd1ac9caae807e9f481c568741cb12a80 | 17,485 | cc | C++ | minios/screens/screen_network.cc | Toromino/chromiumos-platform2 | 97e6ba18f0e5ab6723f3448a66f82c1a07538d87 | [
"BSD-3-Clause"
] | null | null | null | minios/screens/screen_network.cc | Toromino/chromiumos-platform2 | 97e6ba18f0e5ab6723f3448a66f82c1a07538d87 | [
"BSD-3-Clause"
] | null | null | null | minios/screens/screen_network.cc | Toromino/chromiumos-platform2 | 97e6ba18f0e5ab6723f3448a66f82c1a07538d87 | [
"BSD-3-Clause"
] | null | null | null | // Copyright 2021 The Chromium OS 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 "minios/screens/screen_network.h"
#include <base/logging.h>
#include <dbus/minios/dbus-constants.h>
#include <dbus/shill/dbus-constants.h>
#include "minios/draw_utils.h"
#include "minios/error.h"
#include "minios/utils.h"
namespace minios {
namespace {
// Dropdown Item size
constexpr int kItemHeight = 40;
} // namespace
ScreenNetwork::ScreenNetwork(
std::shared_ptr<DrawInterface> draw_utils,
std::shared_ptr<NetworkManagerInterface> network_manager,
KeyReader* key_reader,
ScreenControllerInterface* screen_controller)
: ScreenBase(
/*button_count=*/4,
/*index_=*/1,
State::NETWORK_SCANNING,
draw_utils,
screen_controller),
network_manager_(network_manager),
key_reader_(key_reader),
state_(NetworkState::kDropdownClosed) {
if (network_manager_) {
network_manager_->AddObserver(this);
// Query for networks.
GetNetworks();
}
// Calculate how much room is left for the dropdown, leave some space for the
// back button.
items_per_page_ =
(draw_utils_->GetFreconCanvasSize() / 2 - kBtnYStep * 2) / kItemHeight -
1;
}
ScreenNetwork::~ScreenNetwork() {
if (network_manager_)
network_manager_->RemoveObserver(this);
}
void ScreenNetwork::Show() {
switch (state_) {
case NetworkState::kDropdownClosed:
case NetworkState::kDropdownOpen:
draw_utils_->MessageBaseScreen();
draw_utils_->ShowInstructions("title_MiniOS_dropdown");
draw_utils_->ShowStepper({"1-done", "2", "3"});
break;
case NetworkState::kGetPassword:
draw_utils_->MessageBaseScreen();
draw_utils_->ShowInstructionsWithTitle("MiniOS_password");
draw_utils_->ShowStepper({"done", "2-done", "3"});
SetState(State::NETWORK_CREDENTIALS);
break;
default:
break;
}
ShowButtons();
}
void ScreenNetwork::ShowButtons() {
const int frecon_canvas_size = draw_utils_->GetFreconCanvasSize();
const int btn_width = draw_utils_->GetDefaultButtonWidth();
const int kOffsetY = -frecon_canvas_size / 4 + kBtnYStep * 4;
switch (state_) {
case NetworkState::kDropdownClosed: {
draw_utils_->ShowLanguageMenu(index_ == 0);
ShowCollapsedNetworkDropDown(index_ == 1);
draw_utils_->ShowButton("btn_back", kOffsetY, (index_ == 2), btn_width,
false);
draw_utils_->ShowAdvancedOptionsButtons(index_ == 3);
break;
}
case NetworkState::kDropdownOpen: {
draw_utils_->ShowLanguageMenu(/*selected=*/false);
ShowCollapsedNetworkDropDown(false);
ShowNetworkDropdown(index_);
int dropdown_size =
std::min(items_per_page_, static_cast<int>(networks_.size()));
draw_utils_->ShowButton("btn_back", kOffsetY + (dropdown_size * 40),
(index_ == networks_.size()), btn_width, false);
break;
}
case NetworkState::kGetPassword: {
button_count_ = 4;
draw_utils_->ShowLanguageMenu(index_ == 0);
draw_utils_->ShowText(
"Network: " + chosen_network_.ssid, (-frecon_canvas_size / 2) + 10,
(-frecon_canvas_size / 2) + 280 + kBtnYStep * 2, "grey");
const int kBtnY = (-frecon_canvas_size / 2) + 318 + kBtnYStep * 2;
draw_utils_->ShowButton("Enter your password", kBtnY, false,
btn_width * 4, true);
draw_utils_->ShowButton("btn_back", kBtnY + kBtnYStep, index_ == 2,
btn_width, false);
draw_utils_->ShowAdvancedOptionsButtons(index_ == 3);
break;
}
default:
break;
}
}
void ScreenNetwork::GetNetworks() {
network_manager_->GetNetworks();
SetState(State::NETWORK_SCANNING);
}
void ScreenNetwork::Connect(const std::string& ssid,
const std::string& password) {
network_manager_->Connect(ssid, password);
state_ = NetworkState::kWaitForConnection;
WaitForConnection();
}
void ScreenNetwork::WaitForConnection() {
draw_utils_->MessageBaseScreen();
draw_utils_->ShowStepper({"done", "2-done", "3"});
draw_utils_->ShowLanguageMenu(false);
draw_utils_->ShowInstructions("title_MiniOS_wait_for_connection");
SetState(State::CONNECTING);
}
void ScreenNetwork::OnKeyPress(int key_changed) {
bool enter = false;
UpdateButtonsIndex(key_changed, &enter);
if (enter) {
if (state_ == NetworkState::kDropdownClosed) {
switch (index_) {
case 0:
screen_controller_->SwitchLocale(this);
break;
case 1:
// Update internal state from dropdown closed to open.
state_ = NetworkState::kDropdownOpen;
// Update button count for the dropdown items. Add one extra slot for
// the back button.
button_count_ = networks_.size() + 1;
index_ = 0;
Show();
break;
case 2:
screen_controller_->OnBackward(this);
break;
case 3:
TriggerShutdown();
break;
}
} else if (state_ == NetworkState::kDropdownOpen) {
if (index_ == networks_.size()) {
// Back button. Update internal state and re-query for networks.
Reset();
Show();
} else if (0 <= index_ && index_ < networks_.size()) {
chosen_network_ = networks_[index_];
LOG(INFO) << "Selected network: " << chosen_network_.ssid;
if (chosen_network_.ssid == kShillEthernetLabel) {
// User has chosen the Ethernet connection. No need to enter password.
screen_controller_->OnForward(this);
return;
}
if (chosen_network_.security == shill::kSecurityNone) {
// Network has no password. Just connect.
Connect(chosen_network_.ssid, "");
return;
}
// Update internal state and get password.
state_ = NetworkState::kGetPassword;
index_ = 1;
Show();
} else {
LOG(WARNING) << "Selected network index: " << index_
<< " not valid. Retry";
index_ = 0;
ShowButtons();
}
} else if (state_ == NetworkState::kGetPassword) {
switch (index_) {
case 0:
screen_controller_->SwitchLocale(this);
break;
case 1:
GetPassword();
break;
case 2:
// Back to network dropdown.
state_ = NetworkState::kDropdownOpen;
// Update button count for the dropdown items. Add one extra slot for
// the back button.
button_count_ = networks_.size() + 1;
index_ = 0;
chosen_network_ = NetworkManagerInterface::NetworkProperties{};
Show();
break;
case 3:
TriggerShutdown();
break;
}
}
} else if (key_changed == KEY_ESC) {
if (state_ == NetworkState::kDropdownOpen) {
// Cancel selection by ESC.
// Update internal state and re-query for networks.
Reset();
Show();
}
} else {
// No selection made. Just update the button or menu focuses.
ShowButtons();
}
}
void ScreenNetwork::Reset() {
if (state_ == NetworkState::kDropdownOpen) {
// Reset from `kExpandedNetworkDropDownScreen` is only called when going
// back to `kNetworkDropDownScreen`. Re-query for networks and reset
// `ScreenType`.
GetNetworks();
state_ = NetworkState::kDropdownClosed;
}
index_ = 1;
button_count_ = 4;
}
ScreenType ScreenNetwork::GetType() {
return ScreenType::kNetworkDropDownScreen;
}
std::string ScreenNetwork::GetName() {
switch (state_) {
case NetworkState::kDropdownClosed:
return "ScreenNetwork";
case NetworkState::kDropdownOpen:
return "ScreenExpandedNetwork";
case NetworkState::kGetPassword:
return "ScreenPassword";
case NetworkState::kWaitForConnection:
return "ScreenWaitForConnection";
default:
return "";
}
}
void ScreenNetwork::OnGetNetworks(
const std::vector<NetworkManagerInterface::NetworkProperties>& networks,
brillo::Error* error) {
if (error) {
LOG(ERROR) << "Could not get networks. ErrorCode=" << error->GetCode()
<< "ErrorMessage=" << error->GetMessage();
networks_.clear();
index_ = 1;
button_count_ = 4;
state_ = NetworkState::kDropdownClosed;
screen_controller_->OnError(ScreenType::kNetworkError);
return;
}
LOG(INFO) << "Trying to update network list.";
networks_ = networks;
// Sort in descending order by signal strength. If the network list has
// Ethernet, move it to the front.
std::sort(networks_.begin(), networks_.end(),
[](NetworkManagerInterface::NetworkProperties lhs,
NetworkManagerInterface::NetworkProperties rhs) {
if (lhs.ssid == kShillEthernetLabel)
return true;
if (rhs.ssid == kShillEthernetLabel)
return false;
return lhs.strength > rhs.strength;
});
SetState(State::NETWORK_SELECTION);
// If already waiting on the dropdown screen, refresh.
if (state_ == NetworkState::kDropdownOpen) {
button_count_ = networks_.size() + 1;
index_ = 0;
ShowButtons();
}
}
void ScreenNetwork::OnConnect(const std::string& ssid, brillo::Error* error) {
if (error) {
LOG(ERROR) << "Could not connect to " << ssid
<< ". ErrorCode=" << error->GetCode()
<< " ErrorMessage=" << error->GetMessage();
if (error->GetCode() == shill::kErrorResultInvalidPassphrase) {
state_ = NetworkState::kGetPassword;
screen_controller_->OnError(ScreenType::kPasswordError);
} else {
// General network error.
Reset();
screen_controller_->OnError(ScreenType::kConnectionError);
}
return;
}
LOG(INFO) << "Successfully connected to " << ssid;
screen_controller_->OnForward(this);
}
void ScreenNetwork::GetPassword() {
int frecon_canvas_size = draw_utils_->GetFreconCanvasSize();
const int kTitleY = (-frecon_canvas_size / 2) + 238;
const int kBtnY = kTitleY + 80 + kBtnYStep * 2;
const int kButtonWidth = draw_utils_->GetDefaultButtonWidth();
draw_utils_->ShowButton("Begin typing", kBtnY, false, kButtonWidth * 4, true);
draw_utils_->ShowImage(
draw_utils_->GetScreenPath().Append("visibility_off.png"),
-frecon_canvas_size / 2 + (kButtonWidth * 4) + 32, kBtnY);
CHECK(!chosen_network_.ssid.empty()) << "Cannot connect to an empty network.";
if (!key_reader_ || !key_reader_->InputSetUp()) {
LOG(ERROR) << "Unable to set up key reader.";
screen_controller_->OnError(ScreenType::kGeneralError);
return;
}
bool enter = false;
bool show_password = false;
std::string input;
std::string plain_text_password;
key_reader_->StopWatcher();
do {
if (!key_reader_->GetUserInput(&enter, &show_password, &input))
continue;
plain_text_password = input;
if (!show_password) {
input = std::string(input.size(), '*');
}
draw_utils_->ShowButton(input, kBtnY, false, kButtonWidth * 4, true);
auto visibility =
show_password ? "visibility_on.png" : "visibility_off.png";
draw_utils_->ShowImage(draw_utils_->GetScreenPath().Append(visibility),
-frecon_canvas_size / 2 + (kButtonWidth * 4) + 32,
kBtnY);
} while (!enter);
key_reader_->StartWatcher();
// Wait to connect to network.
Connect(chosen_network_.ssid, plain_text_password);
}
void ScreenNetwork::ShowCollapsedNetworkDropDown(bool is_selected) {
const int frecon_canvas_size = draw_utils_->GetFreconCanvasSize();
const int kOffsetY = -frecon_canvas_size / 4 + kBtnYStep * 2;
const int kBgX = -frecon_canvas_size / 2 + 145;
const int kGlobeX = -frecon_canvas_size / 2 + 20;
const int kArrowX = -frecon_canvas_size / 2 + 268;
const int kTextX = -frecon_canvas_size / 2 + 100;
base::FilePath screens_path = draw_utils_->GetScreenPath();
// Currently using language and globe icons as placeholders.
base::FilePath menu_background =
is_selected ? screens_path.Append("language_menu_bg_focused.png")
: screens_path.Append("language_menu_bg.png");
draw_utils_->ShowImage(menu_background, kBgX, kOffsetY);
draw_utils_->ShowImage(screens_path.Append("ic_wifi_filled-bg.png"), kGlobeX,
kOffsetY);
draw_utils_->ShowImage(screens_path.Append("ic_dropdown.png"), kArrowX,
kOffsetY);
draw_utils_->ShowMessage("btn_MiniOS_display_options", kTextX, kOffsetY);
}
void ScreenNetwork::ShowNetworkDropdown(int current_index) {
const int frecon_canvas_size = draw_utils_->GetFreconCanvasSize();
int offset_y = -frecon_canvas_size / 4 + kBtnYStep * 3;
const int kBackgroundX = -frecon_canvas_size / 2 + 360;
const int kOffsetX =
-frecon_canvas_size / 2 + (draw_utils_->IsLocaleRightToLeft() ? 400 : 60);
if (networks_.empty()) {
// Okay to return here as there will be a callback to refresh the dropdown
// once the networks are found.
draw_utils_->ShowBox(kBackgroundX, offset_y, 718, 38,
kMenuDropdownBackgroundBlack);
draw_utils_->ShowText("Please wait while we find available networks.",
kOffsetX, offset_y, "dropdown_grey");
LOG(ERROR) << "No available networks.";
return;
}
// Pick begin index such that the selected index is centered on the screen.
// If there are not enough items for a full page then start at 0.
int begin_index = 0;
int page_difference = networks_.size() - items_per_page_;
if (page_difference >= 0) {
begin_index =
std::clamp(current_index - items_per_page_ / 2, 0, page_difference);
}
for (int i = begin_index;
i < (begin_index + items_per_page_) && i < networks_.size(); i++) {
if (current_index == i) {
draw_utils_->ShowBox(kBackgroundX, offset_y, 720, 40, kMenuBlue);
draw_utils_->ShowText(networks_[i].ssid, kOffsetX, offset_y, "black");
} else {
draw_utils_->ShowBox(kBackgroundX, offset_y, 720, 40,
kMenuDropdownFrameNavy);
draw_utils_->ShowBox(kBackgroundX, offset_y, 718, 38,
kMenuDropdownBackgroundBlack);
draw_utils_->ShowText(networks_[i].ssid, kOffsetX, offset_y,
"dropdown_grey");
}
offset_y += kItemHeight;
}
}
void ScreenNetwork::SetStateForTest(NetworkState state) {
button_count_ =
(state == NetworkState::kDropdownOpen) ? networks_.size() + 1 : 4;
state_ = state;
}
bool ScreenNetwork::MoveForward(brillo::ErrorPtr* error) {
switch (state_) {
case NetworkState::kDropdownClosed:
FALLTHROUGH;
case NetworkState::kDropdownOpen: {
if (ssid_.empty()) {
Error::AddTo(error, FROM_HERE, error::kFailedGoToNextScreen,
"SSID has not been set.");
screen_controller_->OnError(ScreenType::kConnectionError);
return false;
}
if (!GetNetworkIndex(ssid_, &index_)) {
Error::AddTo(error, FROM_HERE, error::kFailedGoToNextScreen,
"Network not found.");
screen_controller_->OnError(ScreenType::kConnectionError);
return false;
}
state_ = NetworkState::kDropdownOpen;
button_count_ = networks_.size() + 1;
OnKeyPress(KEY_ENTER);
return true;
}
case NetworkState::kGetPassword: {
if (password_.empty()) {
Error::AddTo(error, FROM_HERE, error::kFailedGoToNextScreen,
"Password has not been set.");
screen_controller_->OnError(ScreenType::kPasswordError);
return false;
}
Connect(ssid_, password_);
return true;
}
default: {
Error::AddTo(error, FROM_HERE, error::kFailedGoToNextScreen,
"Not supported for screen: " + GetName());
screen_controller_->OnError(ScreenType::kGeneralError);
return false;
}
}
}
bool ScreenNetwork::MoveBackward(brillo::ErrorPtr* error) {
switch (state_) {
case NetworkState::kDropdownClosed:
FALLTHROUGH;
case NetworkState::kGetPassword: {
index_ = 2;
OnKeyPress(KEY_ENTER);
return true;
}
case NetworkState::kDropdownOpen: {
index_ = networks_.size();
OnKeyPress(KEY_ENTER);
return true;
}
default: {
Error::AddTo(error, FROM_HERE, error::kFailedGoToPrevScreen,
"Not supported for screen: " + GetName());
return false;
}
}
}
void ScreenNetwork::SeedCredentials(const std::string& ssid,
const std::string& password) {
ssid_ = ssid;
password_ = password;
}
bool ScreenNetwork::GetNetworkIndex(const std::string& ssid, int* index) const {
if (networks_.empty()) {
LOG(WARNING) << "No networks found.";
return false;
}
auto it = std::find_if(
networks_.begin(), networks_.end(),
[&ssid](const NetworkManagerInterface::NetworkProperties& props) {
return props.ssid == ssid;
});
if (it != networks_.end()) {
*index = it - networks_.begin();
LOG(INFO) << "Network " << ssid << " found at index " << *index;
return true;
}
LOG(ERROR) << "Network " << ssid << " not found.";
return false;
}
} // namespace minios
| 33.820116 | 80 | 0.639348 | [
"vector"
] |
0b5663f7d1aeba58b8d7e24a7f7a29dac3bbe80d | 10,936 | cpp | C++ | Plugin~/Src/MeshSync/SceneCache/msOSceneCacheImpl.cpp | leegoonz/MeshSync | 484be18431d20aa5056e010d62de62779ee3c3f4 | [
"Apache-2.0"
] | 1,047 | 2017-02-01T01:56:55.000Z | 2022-03-30T10:27:07.000Z | Plugin~/Src/MeshSync/SceneCache/msOSceneCacheImpl.cpp | leegoonz/MeshSync | 484be18431d20aa5056e010d62de62779ee3c3f4 | [
"Apache-2.0"
] | 112 | 2017-03-03T09:10:01.000Z | 2022-03-24T16:25:20.000Z | Plugin~/Src/MeshSync/SceneCache/msOSceneCacheImpl.cpp | leegoonz/MeshSync | 484be18431d20aa5056e010d62de62779ee3c3f4 | [
"Apache-2.0"
] | 120 | 2017-07-26T22:25:59.000Z | 2022-02-22T06:15:42.000Z | #include "pch.h"
#include "msOSceneCacheImpl.h"
#include "Utils/msDebug.h"
#include "MeshSync/NetworkData/msMeshDataFlags.h"
#include "MeshSync/SceneGraph/msMeshRefineFlags.h"
#include "MeshSync/SceneGraph/msTransform.h"
#include "MeshSync/SceneGraph/msMesh.h"
namespace ms {
OSceneCacheImpl::OSceneCacheImpl(StreamPtr ost, const OSceneCacheSettings& oscs)
{
m_ost = ost;
m_oscs = oscs;
if (!m_ost || !(*m_ost))
return;
m_encoder = CreateEncoder(m_oscs.encoding, m_oscs.encoder_settings);
if (!m_encoder) {
m_oscs.encoding = SceneCacheEncoding::Plain;
m_encoder = CreatePlainEncoder();
}
CacheFileHeader header;
header.oscs = m_oscs;
m_ost->write((char*)&header, sizeof(header));
}
OSceneCacheImpl::~OSceneCacheImpl()
{
if (!valid())
return;
flush();
{
// add terminator
auto terminator = CacheFileSceneHeader::terminator();
m_ost->write((char*)&terminator, sizeof(terminator));
}
{
// add meta data
mu::MemoryStream scene_buf;
for (auto& rec : m_entity_records) {
CacheFileEntityMeta meta{};
meta.id = rec.id;
meta.type = (uint32_t)rec.type;
meta.constant = rec.unchanged_count == m_scene_count_written - 1;
meta.constant_topology = rec.topology_unchanged_count == m_scene_count_written - 1;
scene_buf.write((char*)&meta, sizeof(meta));
}
scene_buf.flush();
RawVector<char> encoded_buf;
m_encoder->encode(encoded_buf, scene_buf.getBuffer());
CacheFileMetaHeader header;
header.size = encoded_buf.size();
m_ost->write((char*)&header, sizeof(header));
m_ost->write(encoded_buf.data(), encoded_buf.size());
}
}
bool OSceneCacheImpl::valid() const
{
return m_ost && (*m_ost);
}
static std::vector<ScenePtr> LoadBalancing(ScenePtr base, const int max_segments)
{
auto scene_settings = base->settings;
std::vector<uint64_t> vertex_counts;
std::vector<ScenePtr> segments;
// materials and non-geometry objects
{
auto segment = Scene::create();
segments.push_back(segment);
segment->assets = std::move(base->assets);
for (auto& e : base->entities) {
if (!e->isGeometry())
segment->entities.push_back(e);
}
}
// geometries
{
while (segments.size() < max_segments) {
auto s = Scene::create();
s->settings = scene_settings;
segments.push_back(s);
}
vertex_counts.resize(segments.size());
int segment_count = (int)segments.size();
auto add_geometry = [&](TransformPtr& entity) {
// add entity to the scene with lowest vertex count. this can improve encode & decode time.
int idx = 0;
uint64_t lowest = ~0u;
for (int si = 0; si < segment_count; ++si) {
if (vertex_counts[si] < lowest) {
idx = si;
lowest = vertex_counts[si];
}
}
segments[idx]->entities.push_back(entity);
vertex_counts[idx] += entity->vertexCount();
};
std::vector<TransformPtr> geometries;
geometries.reserve(base->entities.size());
for (auto& e : base->entities) {
if (e->isGeometry())
geometries.push_back(e);
}
std::sort(geometries.begin(), geometries.end(),
[](auto& a, auto& b) { return a->vertexCount() > b->vertexCount(); });
for (auto& g : geometries)
add_geometry(g);
}
return segments;
}
void OSceneCacheImpl::addScene(ScenePtr scene, float time)
{
while (m_scene_count_in_queue > 0 && ((m_oscs.strip_unchanged && !m_base_scene) || m_scene_count_in_queue >= m_oscs.max_queue_size)) {
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
auto rec_ptr = std::make_shared<SceneRecord>();
auto& rec = *rec_ptr;
rec.index = m_scene_count_queued++;
rec.time = time;
rec.scene = scene;
rec.task = std::async(std::launch::async, [this, &rec]() {
{
msProfileScope("OSceneCacheImpl: [%d] scene optimization", rec.index);
auto& scene = rec.scene;
std::sort(scene->entities.begin(), scene->entities.end(), [](auto& a, auto& b) { return a->id < b->id; });
if (m_oscs.flatten_hierarchy)
scene->flatternHierarchy();
if (m_oscs.strip_normals) {
scene->eachEntity<Mesh>([](Mesh& mesh) {
mesh.normals.clear();
mesh.md_flags.Set(MESH_DATA_FLAG_HAS_NORMALS , false);
mesh.refine_settings.flags.Set(MESH_REFINE_FLAG_GEN_NORMALS, false );
});
}
if (m_oscs.strip_tangents) {
scene->eachEntity<Mesh>([](Mesh& mesh) {
mesh.tangents.clear();
mesh.md_flags.Set(MESH_DATA_FLAG_HAS_TANGENTS,false);
mesh.refine_settings.flags.Set(MESH_REFINE_FLAG_GEN_TANGENTS, false);
});
}
if (m_oscs.apply_refinement)
scene->import(m_oscs);
if (m_oscs.strip_normals) {
scene->eachEntity<Mesh>([](Mesh& mesh) {
mesh.refine_settings.flags.Set(MESH_REFINE_FLAG_GEN_NORMALS, true);
});
}
if (m_oscs.strip_tangents) {
scene->eachEntity<Mesh>([](Mesh& mesh) {
mesh.refine_settings.flags.Set(MESH_REFINE_FLAG_GEN_TANGENTS, true);
});
}
// strip unchanged
if (m_oscs.strip_unchanged) {
if (!m_base_scene)
m_base_scene = scene;
else
scene->strip(*m_base_scene);
}
// split into segments
auto scene_segments = LoadBalancing(rec.scene, m_oscs.max_scene_segments);
size_t seg_count = scene_segments.size();
rec.segments.resize(seg_count);
for (size_t si = 0; si < seg_count; ++si) {
auto& seg = rec.segments[si];
seg.index = (int)si;
seg.segment = scene_segments[si];
seg.segment->settings = {};
}
}
for (auto& seg : rec.segments) {
seg.task = std::async(std::launch::async, [this, &rec, &seg]() {
msProfileScope("OSceneCacheImpl: [%d] serialize & encode segment (%d)", rec.index, seg.index);
mu::MemoryStream scene_buf;
seg.segment->serialize(scene_buf);
scene_buf.flush();
m_encoder->encode(seg.encoded_buf, scene_buf.getBuffer());
});
}
});
{
std::unique_lock<std::mutex> l(m_mutex);
m_queue.emplace_back(std::move(rec_ptr));
m_scene_count_in_queue = (int)m_queue.size();
}
doWrite();
}
void OSceneCacheImpl::flush()
{
doWrite();
if (m_task.valid())
m_task.wait();
}
bool OSceneCacheImpl::isWriting()
{
return m_task.valid() && m_task.wait_for(std::chrono::milliseconds(0)) == std::future_status::timeout;
}
int OSceneCacheImpl::getSceneCountWritten() const
{
return m_scene_count_written;
}
int OSceneCacheImpl::getSceneCountInQueue() const
{
return m_scene_count_in_queue;
}
void OSceneCacheImpl::doWrite()
{
auto body = [this]() {
for (;;) {
SceneRecordPtr rec_ptr;
{
std::unique_lock<std::mutex> l(m_mutex);
if (m_queue.empty()) {
break;
}
else {
rec_ptr = std::move(m_queue.back());
m_queue.pop_back();
m_scene_count_in_queue = (int)m_queue.size();
}
}
if (!rec_ptr)
break;
auto& rec = *rec_ptr;
if (rec.task.valid())
rec.task.wait();
{
// update entity record
auto& scene = *rec.scene;
size_t n = scene.entities.size();
m_entity_records.resize(n);
for (size_t i = 0; i < n; ++i) {
auto& e = scene.entities[i];
auto& er = m_entity_records[i];
if (er.type == EntityType::Unknown) {
er.type = e->getType();
er.id = e->id;
}
else if (er.id != e->id)
continue;
if (e->isUnchanged())
er.unchanged_count++;
if (e->isTopologyUnchanged())
er.topology_unchanged_count++;
}
}
// write
{
uint64_t total_buffer_size = 0;
RawVector<uint64_t> buffer_sizes;
for (auto& seg : rec.segments) {
if (seg.task.valid())
seg.task.wait();
buffer_sizes.push_back(seg.encoded_buf.size());
total_buffer_size += seg.encoded_buf.size();
}
msProfileScope("OSceneCacheImpl: [%d] write (%u byte)", rec.index, (uint32_t)total_buffer_size);
CacheFileSceneHeader header;
header.buffer_count = (uint32_t)buffer_sizes.size();
header.time = rec.time;
m_ost->write((char*)&header, sizeof(header));
m_ost->write((char*)buffer_sizes.cdata(), buffer_sizes.size_in_byte());
for (auto& seg : rec.segments)
m_ost->write(seg.encoded_buf.cdata(), seg.encoded_buf.size());
}
++m_scene_count_written;
}
};
{
std::unique_lock<std::mutex> l(m_mutex);
if (!m_queue.empty() && !isWriting()) {
m_task = std::async(std::launch::async, body);
}
}
}
OSceneCacheFile::OSceneCacheFile(const char *path, const OSceneCacheSettings& oscs)
: super(createStream(path), oscs)
{
}
OSceneCacheFile::StreamPtr OSceneCacheFile::createStream(const char *path)
{
auto ret = std::make_shared<std::ofstream>(path, std::ios::binary);
return *ret ? ret : nullptr;
}
OSceneCache* OpenOSceneCacheFileRaw(const char *path, const OSceneCacheSettings& oscs)
{
auto ret = new OSceneCacheFile(path, oscs);
if (ret->valid()) {
return ret;
}
else {
delete ret;
return nullptr;
}
}
OSceneCachePtr OpenOSceneCacheFile(const char *path, const OSceneCacheSettings& oscs)
{
return OSceneCachePtr(OpenOSceneCacheFileRaw(path, oscs));
}
} // namespace ms
| 31.335244 | 138 | 0.541057 | [
"mesh",
"geometry",
"vector"
] |
0b5cd14fdd1e716aa95c64ecbc4b9ddd17834cc8 | 608 | cpp | C++ | ArduinoTerminalReportBuilder.cpp | skmatik/piot-home | 97bd10487b36dbe190d0f21de2d7e131379edb61 | [
"Apache-2.0"
] | null | null | null | ArduinoTerminalReportBuilder.cpp | skmatik/piot-home | 97bd10487b36dbe190d0f21de2d7e131379edb61 | [
"Apache-2.0"
] | null | null | null | ArduinoTerminalReportBuilder.cpp | skmatik/piot-home | 97bd10487b36dbe190d0f21de2d7e131379edb61 | [
"Apache-2.0"
] | null | null | null | //
// Created by martin.maliska on 9/22/2019.
//
#include <sstream>
#include <utility>
#include "ArduinoTerminalReportBuilder.h"
vector<string> ArduinoTerminalReportBuilder::build() {
vector<string> report = vector<string>();
for (int i = 0 ; i < sensors->size() ; i++) {
string line = string(sensors->operator[](i)->getName());
line.append("-");
line.append(sensors->operator[](i)->getFormattedValue());
report.push_back(line);
}
return report;
}
ArduinoTerminalReportBuilder::ArduinoTerminalReportBuilder(vector<Sensor *> *sensors) : sensors(sensors) {}
| 28.952381 | 108 | 0.662829 | [
"vector"
] |
0b5ee89aa36124569cba689757de69aba49bd225 | 3,494 | cpp | C++ | samples/templet/templet.cpp | Templet-language/mpiruntime | e7b13366591d2ce296e99045434ebcb04f5ee5e9 | [
"Apache-2.0"
] | null | null | null | samples/templet/templet.cpp | Templet-language/mpiruntime | e7b13366591d2ce296e99045434ebcb04f5ee5e9 | [
"Apache-2.0"
] | null | null | null | samples/templet/templet.cpp | Templet-language/mpiruntime | e7b13366591d2ce296e99045434ebcb04f5ee5e9 | [
"Apache-2.0"
] | null | null | null | #include <iostream>
//#include <vector>
#include <queue>
#include <map>
#include <math.h>
using namespace std;
double x,sin2,cos2,one;
struct engine;
struct proc;
struct chan;
struct engine{
std::queue<chan*> ready;
std::map<int,chan*> chans;// channel id --> channel ref
std::map<int,proc*> procs;// process id --> process ref
std::map<int,int> pmap; // process id --> rank in MPI_COMM_WORLD
};
struct proc{
void(*recv)(chan*, proc*);
int id; // process ref in MPI message
void(*in) (proc*, std::istream&);
void(*out)(proc*, std::ostream&);
};
struct chan{
proc*p;
bool sending;
int id; // channel ref in MPI message
void(*in) (chan*, std::istream&);
void(*out)(chan*, std::ostream&);
};
inline void send(engine*e, chan*c, proc*p)
{
if (c->sending) return;
c->sending = true; c->p = p;
e->ready.push(c);
}
inline bool access(chan*c, proc*p)
{
return c->p == p && !c->sending;
}
inline void run(engine*e, int n = 1)
{
while (!e->ready.empty()){
chan*c = e->ready.front(); e->ready.pop();
c->sending = false;
c->p->recv(c, c->p);
}
}
engine e;
proc parent,child1,child2;
chan link0,link1,link2;
void Parent(chan*c, proc*p)
{
if(c==&link0){
// cin >> x;
send(&e,&link1,&child1);
send(&e,&link2,&child2);
}
if(access(&link1,p) && access(&link2,p)) one=sin2+cos2;
}
void inParent(proc*, std::istream&s)
{
s >> x >> one;
}
void outParent(proc*, std::ostream&s)
{
s << x << one;
}
void Child(chan*c, proc*)
{
if(c==&link1) sin2=sin(x)*sin(x);
else if(c==&link2)cos2=cos(x)*cos(x);
else cout << "something wrong";
send(&e,c,&parent);
}
void inChild1(proc*, std::istream&s){s >> sin2;}
void outChild1(proc*, std::ostream&s){s << sin2;}
void inChild2(proc*, std::istream&s){s >> cos2;}
void outChild2(proc*, std::ostream&s){s << cos2;}
void inLink0(chan*, std::istream&){}//passing no data
void outLink0(chan*, std::ostream&){}
void inLink1(chan*c, std::istream&s)
{
if(c->p==&child1 && c->sending){s >> x; }
if(c->p==&parent && c->sending){s >> sin2;}
}
void outLink1(chan*c, std::ostream&s)
{
if(c->p==&child1 && c->sending){s << x;}
if(c->p==&parent && c->sending){s << sin2;}
}
void inLink2(chan*c, std::istream&s)
{
if(c->p==&child2&& c->sending){s >> x;}
if(c->p==&parent && c->sending){s >> cos2;}
}
void outLink2(chan*c, std::ostream&s)
{
if(c->p==&child2 && c->sending){s << x;}
if(c->p==&parent && c->sending){s << sin2;}
}
void main()
{
//cin >> x;
//sin2=sin(x)*sin(x); /*//*/ cos2=cos(x)*cos(x);
//cout << endl << "sin2(x)+cos2(x)=" << one=sin2+cos2;
//assigning message handling procedures
parent.recv=&Parent;
child1.recv=child2.recv=&Child;
//assigning serialization procedures
parent.in=&inParent;
parent.out=&outParent;
child1.in=&inChild1;
child2.in=&inChild2;
child1.out=&outChild1;
child2.out=&outChild2;
//------------------------------
link0.in=&inLink0;
link0.out=&outLink0;
link1.in=&inLink1;
link1.out=&outLink1;
link2.in=&inLink2;
link2.out=&outLink2;
//assigning ids
parent.id=0;
child1.id=1;
child2.id=2;
//---------
link0.id=0;
link1.id=1;
link2.id=2;
//putting ids to engine database
e.procs[0]=&parent;
e.procs[1]=&child1;
e.procs[2]=&child2;
//---------
e.chans[0]=&link0;
e.chans[1]=&link1;
e.chans[2]=&link2;
//setting (proc) --> (MPI rank) mapping
e.pmap[0]=0;
e.pmap[1]=1;
e.pmap[2]=2;
cin >> x;
send(&e,&link0,&parent);
run(&e);
cout << endl << "sin2(x)+cos2(x)=" << one;
}
| 19.852273 | 69 | 0.593589 | [
"vector"
] |
0b694f71b93162b036143412251454b73a4b146c | 12,638 | cxx | C++ | Root/TauJetMatching.cxx | seangal/xAODAnaHelpers | 49f15c8525bf4aed9beceec2c58e58964d57e034 | [
"Apache-2.0"
] | 40 | 2015-05-19T17:55:42.000Z | 2021-06-22T07:40:41.000Z | Root/TauJetMatching.cxx | seangal/xAODAnaHelpers | 49f15c8525bf4aed9beceec2c58e58964d57e034 | [
"Apache-2.0"
] | 1,269 | 2015-05-19T21:39:26.000Z | 2022-03-21T06:18:10.000Z | Root/TauJetMatching.cxx | seangal/xAODAnaHelpers | 49f15c8525bf4aed9beceec2c58e58964d57e034 | [
"Apache-2.0"
] | 120 | 2015-05-25T15:14:48.000Z | 2022-03-04T20:39:25.000Z | // c++ include(s):
#include <iostream>
#include <typeinfo>
#include <map>
// EL include(s):
#include <EventLoop/Job.h>
#include <EventLoop/StatusCode.h>
#include <EventLoop/Worker.h>
// EDM include(s):
//#include "xAODCore/ShallowCopy.h"
//#include "AthContainers/ConstDataVector.h"
#include "xAODEventInfo/EventInfo.h"
#include "xAODTau/TauJetContainer.h"
#include "xAODJet/JetContainer.h"
// package include(s):
#include "xAODAnaHelpers/TauJetMatching.h"
#include "xAODAnaHelpers/HelperClasses.h"
#include "xAODAnaHelpers/HelperFunctions.h"
// ROOT include(s):
#include "TLorentzVector.h"
// this is needed to distribute the algorithm to the workers
ClassImp(TauJetMatching)
TauJetMatching :: TauJetMatching () :
Algorithm("TauJetMatching")
{
}
TauJetMatching::~TauJetMatching() {}
EL::StatusCode TauJetMatching :: setupJob (EL::Job& job)
{
// Here you put code that sets up the job on the submission object
// so that it is ready to work with your algorithm, e.g. you can
// request the D3PDReader service or add output files. Any code you
// put here could instead also go into the submission script. The
// sole advantage of putting it here is that it gets automatically
// activated/deactivated when you add/remove the algorithm from your
// job, which may or may not be of value to you.
ANA_MSG_INFO( "Calling setupJob");
job.useXAOD ();
xAOD::Init( "TauJetMatching" ).ignore(); // call before opening first file
return EL::StatusCode::SUCCESS;
}
EL::StatusCode TauJetMatching :: histInitialize ()
{
// Here you do everything that needs to be done at the very
// beginning on each worker node, e.g. create histograms and output
// trees. This method gets called before any input files are
// connected.
ANA_MSG_INFO( "Calling histInitialize");
ANA_CHECK( xAH::Algorithm::algInitialize());
//if ( this->numInstances() > 1 ) {
// m_isUsedBefore = true;
// ANA_MSG_INFO( "\t An algorithm of the same type has been already used " << numInstances() << " times" );
//}
return EL::StatusCode::SUCCESS;
}
EL::StatusCode TauJetMatching :: fileExecute ()
{
// Here you do everything that needs to be done exactly once for every
// single file, e.g. collect a list of all lumi-blocks processed
ANA_MSG_INFO( "Calling fileExecute");
return EL::StatusCode::SUCCESS;
}
EL::StatusCode TauJetMatching :: changeInput (bool /*firstFile*/)
{
// Here you do everything you need to do when we change input files,
// e.g. resetting branch addresses on trees. If you are using
// D3PDReader or a similar service this method is not needed.
ANA_MSG_INFO( "Calling changeInput");
return EL::StatusCode::SUCCESS;
}
EL::StatusCode TauJetMatching :: initialize ()
{
// Here you do everything that you need to do after the first input
// file has been connected and before the first event is processed,
// e.g. create additional histograms based on which variables are
// available in the input files. You can also create all of your
// histograms and trees in here, but be aware that this method
// doesn't get called if no events are processed. So any objects
// you create here won't be available in the output if you have no
// input events.
ANA_MSG_INFO( "Initializing TauJetMatching Interface... ");
// Let's see if the algorithm has been already used before:
// if yes, will write object cutflow in a different histogram!
//
// This is the case when the selector algorithm is used for
// preselecting objects, and then again for the final selection
//
ANA_MSG_INFO( "Algorithm name: " << m_name << " - of type " << m_className );
m_event = wk()->xaodEvent();
m_store = wk()->xaodStore();
ANA_MSG_INFO( "Number of events in file: " << m_event->getEntries() );
if ( m_inContainerName.empty() ){
ANA_MSG_ERROR( "InputContainer is empty!");
return EL::StatusCode::FAILURE;
}
if ( m_inJetContainerName.empty() ){
ANA_MSG_ERROR( "InputJetContainer is empty!");
return EL::StatusCode::FAILURE;
}
// ********************************
//
// Initialise TauJetMatchingTool
//
// ********************************
// IMPORTANT: if no working point is specified the one in this configuration will be used
ANA_MSG_INFO( "TauJetMatching Interface succesfully initialized!" );
return EL::StatusCode::SUCCESS;
}
EL::StatusCode TauJetMatching :: execute ()
{
// Here you do everything that needs to be done on every single
// events, e.g. read input variables, apply cuts, and fill
// histograms and trees. This is where most of your actual analysis
// code will go.
ANA_MSG_DEBUG( "Applying Tau Selection..." );
const xAOD::EventInfo* eventInfo(nullptr);
ANA_CHECK( HelperFunctions::retrieve(eventInfo, m_eventInfoContainerName, m_event, m_store, msg()) );
const xAOD::TauJetContainer* inTaus(nullptr);
const xAOD::JetContainer* inJets(nullptr);
ANA_CHECK( HelperFunctions::retrieve(inJets, m_inJetContainerName, m_event, m_store, msg()) );
// if input comes from xAOD, or just running one collection,
// then get the one collection and be done with it
//
if ( m_inputAlgoSystNames.empty() ) {
// this will be the collection processed - no matter what!!
//
ANA_CHECK( HelperFunctions::retrieve(inTaus, m_inContainerName, m_event, m_store, msg()) );
// fill truth-matching map
//
std::unordered_map<int, std::pair<const xAOD::TauJet*, const xAOD::Jet* > > match_map;
match_map = findBestMatchDR( inJets, inTaus, m_DeltaR );
executeDecoration(match_map, inTaus);
} else { // get the list of systematics to run over
// get vector of string giving the syst names of the upstream algo from TStore (rememeber: 1st element is a blank string: nominal case!)
//
std::vector< std::string >* systNames(nullptr);
ANA_CHECK( HelperFunctions::retrieve(systNames, m_inputAlgoSystNames, 0, m_store, msg()) );
ANA_MSG_DEBUG( " input list of syst size: " << static_cast<int>(systNames->size()) );
// loop over systematic sets
//
for ( auto systName : *systNames ) {
ANA_MSG_DEBUG( " syst name: " << systName << " input container name: " << m_inContainerName+systName );
ANA_CHECK( HelperFunctions::retrieve(inTaus, m_inContainerName + systName, m_event, m_store, msg()) );
ANA_CHECK( HelperFunctions::retrieve(inJets, m_inJetContainerName, m_event, m_store, msg()) );
std::unordered_map<int, std::pair<const xAOD::TauJet*, const xAOD::Jet* > > match_map_sys;
match_map_sys = findBestMatchDR( inJets, inTaus, m_DeltaR );
executeDecoration(match_map_sys, inTaus);
}
}
// look what we have in TStore
//
if(msgLvl(MSG::VERBOSE)) m_store->print();
return EL::StatusCode::SUCCESS;
}
bool TauJetMatching :: executeDecoration ( std::unordered_map<int, std::pair<const xAOD::TauJet*, const xAOD::Jet* > > match_map, const xAOD::TauJetContainer* inTaus)
{
static SG::AuxElement::Decorator< float > JetWidthDecor("JetWidth");
static SG::AuxElement::ConstAccessor<float> jetWidthAcc("Width");
static SG::AuxElement::Decorator< float > JetJvtDecor("JetJvt");
static SG::AuxElement::ConstAccessor<float> jetJvtAcc("Jvt");
ANA_MSG_DEBUG( "Initial Taus: " << static_cast<uint32_t>(inTaus->size()) );
int iTau = -1;
for ( auto tau_itr : *inTaus ) { // duplicated of basic loop
iTau++;
std::unordered_map<int, std::pair<const xAOD::TauJet*, const xAOD::Jet* > >::const_iterator it_map = match_map.find (iTau);
if (it_map != match_map.end()) {
// jet width
if (jetWidthAcc.isAvailable(*match_map[iTau].second)) {
JetWidthDecor(*tau_itr) = static_cast<float>( jetWidthAcc(*match_map[iTau].second) );
} else {
JetWidthDecor(*tau_itr) = -1.;
}
// jet jvt
if (jetJvtAcc.isAvailable(*match_map[iTau].second)) {
JetJvtDecor(*tau_itr) = static_cast<float>( jetJvtAcc(*match_map[iTau].second) );
} else {
JetJvtDecor(*tau_itr) = -1.;
}
} else {
JetWidthDecor(*tau_itr) = -1.;
JetJvtDecor(*tau_itr) = -1.;
}
}
ANA_MSG_DEBUG( "Left executeDecoration..." );
return true;
}
EL::StatusCode TauJetMatching :: postExecute ()
{
// Here you do everything that needs to be done after the main event
// processing. This is typically very rare, particularly in user
// code. It is mainly used in implementing the NTupleSvc.
ANA_MSG_DEBUG( "Calling postExecute");
return EL::StatusCode::SUCCESS;
}
EL::StatusCode TauJetMatching :: finalize ()
{
// This method is the mirror image of initialize(), meaning it gets
// called after the last event has been processed on the worker node
// and allows you to finish up any objects you created in
// initialize() before they are written to disk. This is actually
// fairly rare, since this happens separately for each worker node.
// Most of the time you want to do your post-processing on the
// submission node after all your histogram outputs have been
// merged. This is different from histFinalize() in that it only
// gets called on worker nodes that processed input events.
return EL::StatusCode::SUCCESS;
}
EL::StatusCode TauJetMatching :: histFinalize ()
{
// This method is the mirror image of histInitialize(), meaning it
// gets called after the last event has been processed on the worker
// node and allows you to finish up any objects you created in
// histInitialize() before they are written to disk. This is
// actually fairly rare, since this happens separately for each
// worker node. Most of the time you want to do your
// post-processing on the submission node after all your histogram
// outputs have been merged. This is different from finalize() in
// that it gets called on all worker nodes regardless of whether
// they processed input events.
ANA_MSG_INFO( "Calling histFinalize");
ANA_CHECK( xAH::Algorithm::algFinalize());
return EL::StatusCode::SUCCESS;
}
float TauJetMatching::getDR(float eta1, float eta2, float phi1, float phi2)
{
float deta = std::abs(eta1-eta2);
float dphi = std::abs(phi1-phi2);
dphi = ( dphi <= TMath::Pi() ) ? dphi : ( 2 * TMath::Pi() - dphi );
return sqrt(deta*deta + dphi*dphi);
}
std::unordered_map<int, std::pair<const xAOD::TauJet*, const xAOD::Jet* > > TauJetMatching::findBestMatchDR(const xAOD::JetContainer* jetCont,
const xAOD::TauJetContainer* tauCont,
float best_DR=1.0)
{
// Find tau that best matches a jet using DR.
// If matching is successful, returns a map where the key
// is the container index of the matched tau and the value
// is the pair of the matched tau and the corresponding jet
float default_best_DR = best_DR;
int ijet = -1;
int best_ijet = -1;
const xAOD::Jet* best_jet = nullptr;
std::unordered_map<int, std::pair<const xAOD::TauJet*, const xAOD::Jet*>> match_map;
for (const auto jet : *jetCont) {
++ijet;
int itau = -1;
int best_itau = -1;
const xAOD::TauJet* best_tau = nullptr;
float DR = 0;
for (const auto tau : *tauCont) {
++itau;
DR = this->getDR(tau->eta(),jet->eta(),tau->phi(),jet->phi());
if (DR < best_DR) {
best_DR = DR;
best_tau = tau;
best_jet = jet;
best_itau = itau;
best_ijet = ijet;
}
}
std::unordered_map<int, std::pair<const xAOD::TauJet*, const xAOD::Jet* > >::const_iterator got = match_map.find (best_itau);
// if a new match is found for a previous
// tau keep the new match if it is better
if (got == match_map.end() and best_itau != -1 and best_ijet != -1) {
match_map[best_itau] = std::pair<const xAOD::TauJet*, const xAOD::Jet*>(best_tau, best_jet);
}
else if (got != match_map.end() and best_itau != -1 and best_ijet != -1) {
float old_DR = this->getDR(match_map[best_itau].first->eta(), match_map[best_itau].second->eta(),match_map[best_itau].first->phi(), match_map[best_itau].second->phi());
if (old_DR > best_DR) {
match_map[best_itau] = std::pair<const xAOD::TauJet*, const xAOD::Jet*>(best_tau, best_jet);
}
}
// reset the best_DR to the default value
best_DR = default_best_DR;
}
return match_map;
}
| 33.170604 | 176 | 0.664979 | [
"object",
"vector"
] |
0b6e666819e5299c8fdb0380a3cf656b075c5fc3 | 16,583 | cpp | C++ | src/kits/storage/Resources.cpp | stasinek/BHAPI | 5d9aa61665ae2cc5c6e34415957d49a769325b2b | [
"BSD-3-Clause",
"MIT"
] | 3 | 2018-05-21T15:32:32.000Z | 2019-03-21T13:34:55.000Z | src/kits/storage/Resources.cpp | stasinek/BHAPI | 5d9aa61665ae2cc5c6e34415957d49a769325b2b | [
"BSD-3-Clause",
"MIT"
] | null | null | null | src/kits/storage/Resources.cpp | stasinek/BHAPI | 5d9aa61665ae2cc5c6e34415957d49a769325b2b | [
"BSD-3-Clause",
"MIT"
] | null | null | null | /*
* Copyright 2001-2006, Ingo Weinhold <bonefish@cs.tu-berlin.de>.
* Copyright 2013 Haiku, Inc.
* All Rights Reserved. Distributed under the terms of the MIT License.
*
* Authors:
* John Scipione, jscipione@gmail.com
* Ingo Weinhold, bonefish@cs.tu-berlin.de
*/
#include <Resources.h>
#include <new>
#include <ResourceFile.h>
#include <ResourceItem.h>
#include <ResourcesContainer.h>
using namespace BPrivate::Storage;
using namespace std;
// debugging
//#define DBG(x) x
#define DBG(x)
#define OUT printf
// Creates an unitialized BResources object.
BResources::BResources()
:
fFile(),
fContainer(NULL),
fResourceFile(NULL),
fReadOnly(false)
{
fContainer = new(nothrow) ResourcesContainer;
}
// Creates a BResources object that represents the resources of the
// supplied file.
BResources::BResources(const BFile* file, bool clobber)
:
fFile(),
fContainer(NULL),
fResourceFile(NULL),
fReadOnly(false)
{
fContainer = new(nothrow) ResourcesContainer;
SetTo(file, clobber);
}
// Creates a BResources object that represents the resources of the
// file referenced by the supplied path.
BResources::BResources(const char* path, bool clobber)
:
fFile(),
fContainer(NULL),
fResourceFile(NULL),
fReadOnly(false)
{
fContainer = new(nothrow) ResourcesContainer;
SetTo(path, clobber);
}
// Creates a BResources object that represents the resources of the
// file referenced by the supplied ref.
BResources::BResources(const entry_ref* ref, bool clobber)
:
fFile(),
fContainer(NULL),
fResourceFile(NULL),
fReadOnly(false)
{
fContainer = new(nothrow) ResourcesContainer;
SetTo(ref, clobber);
}
// Frees all resources associated with this object
BResources::~BResources()
{
Unset();
delete fContainer;
}
// Initialized the BResources object to represent the resources of
// the supplied file.
status_t BResources::SetTo(const BFile* file, bool clobber)
{
Unset();
status_t error = B_OK;
if (file) {
error = file->InitCheck();
if (error == B_OK) {
fFile = *file;
error = fFile.InitCheck();
}
if (error == B_OK) {
fReadOnly = !fFile.IsWritable();
fResourceFile = new(nothrow) ResourceFile;
if (fResourceFile)
error = fResourceFile->SetTo(&fFile, clobber);
else
error = B_NO_MEMORY;
}
if (error == B_OK) {
if (fContainer)
error = fResourceFile->InitContainer(*fContainer);
else
error = B_NO_MEMORY;
}
}
if (error != B_OK) {
delete fResourceFile;
fResourceFile = NULL;
if (fContainer)
fContainer->MakeEmpty();
}
return error;
}
// Initialized the BResources object to represent the resources of
// the file referred to by the supplied path.
status_t BResources::SetTo(const char* path, bool clobber)
{
if (!path)
return B_BAD_VALUE;
// open file
BFile file;
status_t error = file.SetTo(path, B_READ_WRITE);
if (error != B_OK && error != B_ENTRY_NOT_FOUND)
error = file.SetTo(path, B_READ_ONLY);
if (error != B_OK) {
Unset();
return error;
}
// delegate the actual work
return SetTo(&file, clobber);
}
// Initialized the BResources object to represent the resources of the
// file referenced by the supplied ref.
status_t BResources::SetTo(const entry_ref* ref, bool clobber)
{
if (!ref)
return B_BAD_VALUE;
// open file
BFile file;
status_t error = file.SetTo(ref, B_READ_WRITE);
if (error != B_OK && error != B_ENTRY_NOT_FOUND)
error = file.SetTo(ref, B_READ_ONLY);
if (error != B_OK) {
Unset();
return error;
}
// delegate the actual work
return SetTo(&file, clobber);
}
// Initialized the BResources object to represent the resources of
// the file from which the specified image has been loaded.
status_t BResources::SetToImage(image_id image, bool clobber)
{
#ifdef HAIKU_TARGET_PLATFORM_HAIKU
// get an image info
image_info info;
status_t error = get_image_info(image, &info);
if (error != B_OK) {
Unset();
return error;
}
// delegate the actual work
return SetTo(info.name, clobber);
#else // HAIKU_TARGET_PLATFORM_HAIKU
return B_NOT_SUPPORTED;
#endif
}
// Initialized the BResources object to represent the resources of
// the file from which the specified pointer has been loaded.
status_t BResources::SetToImage(const void* codeOrDataPointer, bool clobber)
{
#ifdef HAIKU_TARGET_PLATFORM_HAIKU
// iterate through the images and find the one in question
addr_t address = (addr_t)codeOrDataPointer;
image_info info;
int32 cookie = 0;
while (get_next_image_info(B_CURRENT_TEAM, &cookie, &info) == B_OK) {
if (address == 0
? info.type == B_APP_IMAGE
: (((addr_t)info.text <= address
&& address - (addr_t)info.text < (addr_t)info.text_size)
|| ((addr_t)info.data <= address
&& address - (addr_t)info.data < (addr_t)info.data_size))) {
return SetTo(info.name, clobber);
}
}
return B_ENTRY_NOT_FOUND;
#else // HAIKU_TARGET_PLATFORM_HAIKU
return B_NOT_SUPPORTED;
#endif
}
// Returns the BResources object to an uninitialized state.
void BResources::Unset()
{
if (fContainer && fContainer->IsModified())
Sync();
delete fResourceFile;
fResourceFile = NULL;
fFile.Unset();
if (fContainer)
fContainer->MakeEmpty();
else
fContainer = new(nothrow) ResourcesContainer;
fReadOnly = false;
}
// Gets the initialization status of the object.
status_t BResources::InitCheck() const
{
return (fContainer ? B_OK : B_NO_MEMORY);
}
// Gets a reference to the internal BFile object.
const BFile&
BResources::File() const
{
return fFile;
}
// Loads a resource identified by type and id into memory.
const void* BResources::LoadResource(type_code type, int32 id, size_t* _size)
{
// find the resource
status_t error = InitCheck();
ResourceItem* resource = NULL;
if (error == B_OK) {
resource = fContainer->ResourceAt(fContainer->IndexOf(type, id));
if (!resource)
error = B_ENTRY_NOT_FOUND;
}
// load it, if necessary
if (error == B_OK && !resource->IsLoaded() && fResourceFile)
error = fResourceFile->ReadResource(*resource);
// return the result
const void *result = NULL;
if (error == B_OK) {
result = resource->Data();
if (_size)
*_size = resource->DataSize();
}
return result;
}
// Loads a resource identified by type and name into memory.
const void* BResources::LoadResource(type_code type, const char* name, size_t* _size)
{
// find the resource
status_t error = InitCheck();
ResourceItem* resource = NULL;
if (error == B_OK) {
resource = fContainer->ResourceAt(fContainer->IndexOf(type, name));
if (!resource)
error = B_ENTRY_NOT_FOUND;
}
// load it, if necessary
if (error == B_OK && !resource->IsLoaded() && fResourceFile)
error = fResourceFile->ReadResource(*resource);
// return the result
const void* result = NULL;
if (error == B_OK) {
result = resource->Data();
if (_size)
*_size = resource->DataSize();
}
return result;
}
// Loads all resources of the specified type into memory.
status_t BResources::PreloadResourceType(type_code type)
{
status_t error = InitCheck();
if (error == B_OK && fResourceFile) {
if (type == 0)
error = fResourceFile->ReadResources(*fContainer);
else {
int32 count = fContainer->CountResources();
int32 errorCount = 0;
for (int32 i = 0; i < count; i++) {
ResourceItem *resource = fContainer->ResourceAt(i);
if (resource->Type() == type) {
if (fResourceFile->ReadResource(*resource) != B_OK)
errorCount++;
}
}
error = -errorCount;
}
}
return error;
}
// Writes all changes to the resources to the file.
status_t BResources::Sync()
{
status_t error = InitCheck();
if (error == B_OK)
error = fFile.InitCheck();
if (error == B_OK) {
if (fReadOnly)
error = B_NOT_ALLOWED;
else if (!fResourceFile)
error = B_FILE_ERROR;
}
if (error == B_OK)
error = fResourceFile->ReadResources(*fContainer);
if (error == B_OK)
error = fResourceFile->WriteResources(*fContainer);
return error;
}
// Adds the resources of fromFile to the internal file of the
// BResources object.
status_t BResources::MergeFrom(BFile* fromFile)
{
status_t error = (fromFile ? B_OK : B_BAD_VALUE);
if (error == B_OK)
error = InitCheck();
if (error == B_OK) {
ResourceFile resourceFile;
error = resourceFile.SetTo(fromFile);
ResourcesContainer container;
if (error == B_OK)
error = resourceFile.InitContainer(container);
if (error == B_OK)
error = resourceFile.ReadResources(container);
if (error == B_OK)
fContainer->AssimilateResources(container);
}
return error;
}
// Writes the resources to a new file.
status_t BResources::WriteTo(BFile* file)
{
status_t error = (file ? B_OK : B_BAD_VALUE);
if (error == B_OK)
error = InitCheck();
// make sure, that all resources are loaded
if (error == B_OK && fResourceFile) {
error = fResourceFile->ReadResources(*fContainer);
fResourceFile->Unset();
}
// set the new file, but keep the old container
if (error == B_OK) {
ResourcesContainer *container = fContainer;
fContainer = new(nothrow) ResourcesContainer;
if (fContainer) {
error = SetTo(file, false);
delete fContainer;
} else
error = B_NO_MEMORY;
fContainer = container;
}
// write the resources
if (error == B_OK && fResourceFile)
error = fResourceFile->WriteResources(*fContainer);
return error;
}
// Adds a new resource to the file.
status_t BResources::AddResource(type_code type, int32 id, const void* data,
size_t length, const char* name)
{
status_t error = (data ? B_OK : B_BAD_VALUE);
if (error == B_OK)
error = InitCheck();
if (error == B_OK)
error = (fReadOnly ? B_NOT_ALLOWED : B_OK);
if (error == B_OK) {
ResourceItem* item = new(nothrow) ResourceItem;
if (!item)
error = B_NO_MEMORY;
if (error == B_OK) {
item->SetIdentity(type, id, name);
ssize_t written = item->WriteAt(0, data, length);
if (written < 0)
error = written;
else if (written != (ssize_t)length)
error = B_ERROR;
}
if (error == B_OK) {
if (!fContainer->AddResource(item))
error = B_NO_MEMORY;
}
if (error != B_OK)
delete item;
}
return error;
}
// Returns whether the file contains a resource with the specified
// type and id.
bool BResources::HasResource(type_code type, int32 id)
{
return (InitCheck() == B_OK && fContainer->IndexOf(type, id) >= 0);
}
// Returns whether the file contains a resource with the specified
// type and name.
bool BResources::HasResource(type_code type, const char* name)
{
return (InitCheck() == B_OK && fContainer->IndexOf(type, name) >= 0);
}
// Gets information about a resource identified by byindex.
bool BResources::GetResourceInfo(int32 byIndex, type_code* typeFound,
int32* idFound, const char** nameFound, size_t* lengthFound)
{
ResourceItem* item = NULL;
if (InitCheck() == B_OK)
item = fContainer->ResourceAt(byIndex);
if (item) {
if (typeFound)
*typeFound = item->Type();
if (idFound)
*idFound = item->ID();
if (nameFound)
*nameFound = item->Name();
if (lengthFound)
*lengthFound = item->DataSize();
}
return item;
}
// Gets information about a resource identified by byType and andIndex.
bool BResources::GetResourceInfo(type_code byType, int32 andIndex, int32* idFound,
const char** nameFound, size_t* lengthFound)
{
ResourceItem* item = NULL;
if (InitCheck() == B_OK) {
item = fContainer->ResourceAt(fContainer->IndexOfType(byType,
andIndex));
}
if (item) {
if (idFound)
*idFound = item->ID();
if (nameFound)
*nameFound = item->Name();
if (lengthFound)
*lengthFound = item->DataSize();
}
return item;
}
// Gets information about a resource identified by byType and andID.
bool BResources::GetResourceInfo(type_code byType, int32 andID,
const char** nameFound, size_t* lengthFound)
{
ResourceItem* item = NULL;
if (InitCheck() == B_OK)
item = fContainer->ResourceAt(fContainer->IndexOf(byType, andID));
if (item) {
if (nameFound)
*nameFound = item->Name();
if (lengthFound)
*lengthFound = item->DataSize();
}
return item;
}
// Gets information about a resource identified by byType and andName.
bool BResources::GetResourceInfo(type_code byType, const char* andName,
int32* idFound, size_t* lengthFound)
{
ResourceItem* item = NULL;
if (InitCheck() == B_OK)
item = fContainer->ResourceAt(fContainer->IndexOf(byType, andName));
if (item) {
if (idFound)
*idFound = item->ID();
if (lengthFound)
*lengthFound = item->DataSize();
}
return item;
}
// Gets information about a resource identified by byPointer.
bool BResources::GetResourceInfo(const void* byPointer, type_code* typeFound,
int32* idFound, size_t* lengthFound, const char** nameFound)
{
ResourceItem* item = NULL;
if (InitCheck() == B_OK)
item = fContainer->ResourceAt(fContainer->IndexOf(byPointer));
if (item) {
if (typeFound)
*typeFound = item->Type();
if (idFound)
*idFound = item->ID();
if (nameFound)
*nameFound = item->Name();
if (lengthFound)
*lengthFound = item->DataSize();
}
return item;
}
// Removes a resource identified by its data pointer.
status_t BResources::RemoveResource(const void* resource)
{
status_t error = (resource ? B_OK : B_BAD_VALUE);
if (error == B_OK)
error = InitCheck();
if (error == B_OK)
error = (fReadOnly ? B_NOT_ALLOWED : B_OK);
if (error == B_OK) {
ResourceItem* item
= fContainer->RemoveResource(fContainer->IndexOf(resource));
if (item)
delete item;
else
error = B_BAD_VALUE;
}
return error;
}
// Removes a resource identified by type and id.
status_t BResources::RemoveResource(type_code type, int32 id)
{
status_t error = InitCheck();
if (error == B_OK)
error = (fReadOnly ? B_NOT_ALLOWED : B_OK);
if (error == B_OK) {
ResourceItem* item
= fContainer->RemoveResource(fContainer->IndexOf(type, id));
if (item)
delete item;
else
error = B_BAD_VALUE;
}
return error;
}
// #pragma mark - deprecated methods
// Writes data into an existing resource
// (deprecated, use AddResource() instead).
status_t BResources::WriteResource(type_code type, int32 id, const void* data,
off_t offset, size_t length)
{
status_t error = (data && offset >= 0 ? B_OK : B_BAD_VALUE);
if (error == B_OK)
error = InitCheck();
if (error == B_OK)
error = (fReadOnly ? B_NOT_ALLOWED : B_OK);
if (error != B_OK)
return error;
ResourceItem *item = fContainer->ResourceAt(fContainer->IndexOf(type, id));
if (!item)
return B_BAD_VALUE;
if (fResourceFile) {
error = fResourceFile->ReadResource(*item);
if (error != B_OK)
return error;
}
ssize_t written = item->WriteAt(offset, data, length);
if (written < 0)
error = written;
else if (written != (ssize_t)length)
error = B_ERROR;
return error;
}
// Reads data from an existing resource
// (deprecated, use LoadResource() instead).
status_t BResources::ReadResource(type_code type, int32 id, void* data, off_t offset,
size_t length)
{
status_t error = (data && offset >= 0 ? B_OK : B_BAD_VALUE);
if (error == B_OK)
error = InitCheck();
ResourceItem* item = NULL;
if (error == B_OK) {
item = fContainer->ResourceAt(fContainer->IndexOf(type, id));
if (!item)
error = B_BAD_VALUE;
}
if (error == B_OK && fResourceFile)
error = fResourceFile->ReadResource(*item);
if (error == B_OK) {
if (item) {
ssize_t read = item->ReadAt(offset, data, length);
if (read < 0)
error = read;
} else
error = B_BAD_VALUE;
}
return error;
}
// Finds a resource by type and id and returns a pointer to a copy of
// its data (deprecated, use LoadResource() instead).
void* BResources::FindResource(type_code type, int32 id, size_t* lengthFound)
{
void* result = NULL;
size_t size = 0;
const void* data = LoadResource(type, id, &size);
if (data != NULL) {
if ((result = malloc(size)))
memcpy(result, data, size);
}
if (lengthFound)
*lengthFound = size;
return result;
}
// Finds a resource by type and name and returns a pointer to a copy of
// its data (deprecated, use LoadResource() instead).
void* BResources::FindResource(type_code type, const char* name, size_t* lengthFound)
{
void* result = NULL;
size_t size = 0;
const void *data = LoadResource(type, name, &size);
if (data != NULL) {
if ((result = malloc(size)))
memcpy(result, data, size);
}
if (lengthFound)
*lengthFound = size;
return result;
}
// FBC
void BResources::_ReservedResources1() {}
void BResources::_ReservedResources2() {}
void BResources::_ReservedResources3() {}
void BResources::_ReservedResources4() {}
void BResources::_ReservedResources5() {}
void BResources::_ReservedResources6() {}
void BResources::_ReservedResources7() {}
void BResources::_ReservedResources8() {}
| 23.929293 | 87 | 0.694567 | [
"object"
] |
0b71a9b70cf06fb92233d876397bdce99f67c1fa | 811 | cpp | C++ | 931/main.cpp | JanaSabuj/Leetcode-solutions | 78d10926b15252a969df598fbf1f9b69b2760b79 | [
"MIT"
] | 13 | 2019-10-12T14:36:32.000Z | 2021-06-08T04:26:30.000Z | 931/main.cpp | JanaSabuj/Leetcode-solutions | 78d10926b15252a969df598fbf1f9b69b2760b79 | [
"MIT"
] | 1 | 2020-02-29T14:02:39.000Z | 2020-02-29T14:02:39.000Z | 931/main.cpp | JanaSabuj/Leetcode-solutions | 78d10926b15252a969df598fbf1f9b69b2760b79 | [
"MIT"
] | 3 | 2020-02-08T12:04:28.000Z | 2020-03-17T11:53:00.000Z | class Solution {
public:
int minFallingPathSum(vector<vector<int>>& A) {
int n = A.size();
int m = A[0].size();
vector<vector<int>> f(n, vector<int>(m, 0));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i == 0)
f[i][j] = A[i][j];
else {
int val = f[i - 1][j];
for (int k = j - 1; k <= j + 1; k++)
if (k >= 0 and k < m)
val = min(val, f[i - 1][k]);
f[i][j] = val + A[i][j];
}
}
}
int ans = INT_MAX;
for (int j = 0; j < m; j++)
ans = min(ans, f[n - 1][j]);
return ans;
}
}; | 27.033333 | 57 | 0.293465 | [
"vector"
] |
0b7a5eb15663d5c4b8801509b87497c56b8f9b6a | 2,183 | cpp | C++ | src/shape.cpp | mfirmin/c5sc | 66b06061bf0f1a53c435f4109cd7fa636466c353 | [
"MIT"
] | 1 | 2015-01-05T07:49:33.000Z | 2015-01-05T07:49:33.000Z | src/shape.cpp | mfirmin/c5sc | 66b06061bf0f1a53c435f4109cd7fa636466c353 | [
"MIT"
] | null | null | null | src/shape.cpp | mfirmin/c5sc | 66b06061bf0f1a53c435f4109cd7fa636466c353 | [
"MIT"
] | null | null | null |
#define dSINGLE
#include "shape.h"
#include "globals.h"
#include <ode/ode.h>
#include <iostream>
void Shape::initialize(dBodyID& body, dGeomID& geom) const
{
dMatrix3 R;
dBodySetPosition(body, pos.x, pos.y, pos.z);
dBodySetLinearVel(body, vel.x, vel.y, vel.z);
dRFromAxisAndAngle(R, rot[0], rot[1], rot[2], rot[3]);
dBodySetRotation(body, R);
}
void Shape::reset(dBodyID& body)
{
dBodySetPosition(body, pos.x, pos.y, pos.z);
dMatrix3 R;
dRFromAxisAndAngle(R, rot[0], rot[1], rot[2], rot[3]);
dBodySetRotation(body, R);
dBodySetLinearVel(body, vel.x, vel.y, vel.z);
dBodySetAngularVel(body, 0,0,0);
}
Capsule::Capsule(dReal m, VECTOR p, VECTOR v, dReal rotation[4], dReal l, dReal r1, dReal r2)
{
type = CAPSULE;
mass = m;
pos = p;
vel = v;
for (int i = 0; i < 4; i++)
rot[i] = rotation[i];
length = l;
rad1 = r1;
if (r2 == -1)
{
rad2 = r1;
}
else
{
rad2 = r2;
}
}
Box::Box(dReal m, VECTOR p, VECTOR v, dReal* rotation, VECTOR s)
{
type = BOX;
mass = m;
pos = p;
vel = v;
for (int i = 0; i < 4; i++)
rot[i] = rotation[i];
sides.x = s.x; sides.y = s.y; sides.z = s.z;
}
Sphere::Sphere(dReal m, VECTOR p, VECTOR v, dReal* rotation, dReal rad)
{
type = SPHERE;
mass = m;
pos = p;
vel = v;
for (int i = 0; i < 4; i++)
rot[i] = rotation[i];
radius = rad;
}
void Capsule::initialize(dBodyID& body, dGeomID& geom) const
{
Shape::initialize(body, geom);
dMatrix3 R;
dMass m;
dReal rad_avg = (rad1+rad2)/2.0;
dMassSetCapsuleTotal(&m, mass, 3, rad_avg, length);
geom = dCreateCapsule(Space, rad_avg, length);
dBodySetMass(body, &m);
dGeomSetBody(geom, body);
}
void Sphere::initialize(dBodyID& body, dGeomID& geom) const
{
Shape::initialize(body, geom);
dMatrix3 R;
dMass m;
dMassSetSphereTotal(&m, mass, radius);
geom = dCreateSphere(Space, radius);
dBodySetMass(body, &m);
dGeomSetBody(geom, body);
}
void Box::initialize(dBodyID& body, dGeomID& geom) const
{
Shape::initialize(body, geom);
dMatrix3 R;
dMass m;
dMassSetBoxTotal(&m, mass, sides.x, sides.y, sides.z);
geom = dCreateBox(Space, sides.x, sides.y, sides.z);
dBodySetMass(body, &m);
dGeomSetBody(geom, body);
}
| 18.191667 | 93 | 0.638571 | [
"shape",
"vector"
] |
0b8164c366f874d1d6d6463cd95922f787401548 | 1,510 | cpp | C++ | AtCoder/abc222/D.cpp | noobie7/Codes | 4d8265f4b7042bd7e8c0e0402d417c7e160ae6d4 | [
"MIT"
] | 2 | 2021-09-14T15:57:24.000Z | 2022-03-18T14:11:04.000Z | AtCoder/abc222/D.cpp | noobie7/Codes | 4d8265f4b7042bd7e8c0e0402d417c7e160ae6d4 | [
"MIT"
] | null | null | null | AtCoder/abc222/D.cpp | noobie7/Codes | 4d8265f4b7042bd7e8c0e0402d417c7e160ae6d4 | [
"MIT"
] | null | null | null | /*
"An anomaly, I'm Muhammad Ali
Cause I know one day I'm gonna be the"
- Greatest, Eminem
*/
#pragma GCC optimize ("O3")
#pragma GCC target ("sse4")
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define ff first
#define Shazam ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define ss second
#define all(c) c.begin(),c.end()
#define endl "\n"
#define test() int t; cin>>t; while(t--)
#define fl(i,a,b) for(int i = a ; i <b ;i++)
#define get(a) fl(i,0,a.size()) cin>>a[i];
#define pra(a) fl(i,0,a.size()) cout<<a[i]<<" "; cout<<endl;
#define pr(a,n) fl(i,0,n) cout<<a[i]<<" "; cout<<endl;
const ll INF = 2e18;
const int inf = 2e9;
const int mod = 998244353;
int main(){
Shazam;
int n; cin >> n;
vector<int> s(n), t(n);
get(s);
get(t);
vector<pair<int,int>> a(n);
for(int i = 0; i < n; i++){
a[i].ff = s[i];
a[i].ss = t[i];
}
vector<vector<ll>> dp(n, vector<ll> (3004));
for(int i = a[0].ff; i <= a[0].ss; i++){
dp[0][i] = 1;
}
auto add = [&](ll &a, ll b){
a = (a%mod + b%mod)%mod;
};
for(int i = 1; i < n; i++){
for(int j = 1; j < 3004; j++){
add(dp[i - 1][j], dp[i - 1][j - 1]);
}
for(int j = a[i].ff; j <= a[i].ss; j++){
add(dp[i][j], dp[i - 1][j]);
}
}
ll ans = 0;
for(int j = 0; j <= 3004; j++){
add(ans, dp[n - 1][j]);
}
cout << ans << endl;
return 0;
} | 25.166667 | 81 | 0.483444 | [
"vector"
] |
0b81ba1cde1ccc86f5934a137b2923444ae940fa | 18,410 | cc | C++ | src/as_helper.cc | gkvs/gkvs-cpp | c11adc759d5aeaf7877b085434a742f0bca634bd | [
"Apache-2.0"
] | null | null | null | src/as_helper.cc | gkvs/gkvs-cpp | c11adc759d5aeaf7877b085434a742f0bca634bd | [
"Apache-2.0"
] | null | null | null | src/as_helper.cc | gkvs/gkvs-cpp | c11adc759d5aeaf7877b085434a742f0bca634bd | [
"Apache-2.0"
] | null | null | null | /*
*
* Copyright 2018-present GKVS authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
#include <aerospike/aerospike_key.h>
#include <citrusleaf/cf_byte_order.h>
#include <aerospike/as_serializer.h>
#include <aerospike/as_msgpack.h>
#include <aerospike/as_record_iterator.h>
#include <aerospike/as_map_iterator.h>
#include <aerospike/as_hashmap_iterator.h>
#include <unordered_map>
#include <sstream>
#include <algorithm>
#include <stdlib.h>
#include <msgpack.h>
#include <msgpack.hpp>
#include <msgpack/object.h>
#include "as_driver.h"
/**
void gkvs::as_record_ser::pack_val_ser(as_val* val) {
as_buffer buffer;
as_buffer_init(&buffer);
as_serializer ser;
as_msgpack_init(&ser);
as_serializer_serialize(&ser, val, &buffer);
as_serializer_destroy(&ser);
msgpack_pack_v4raw(&pk_, buffer.size);
msgpack_pack_v4raw_body(&pk_, buffer.data, buffer.size);
as_buffer_destroy(&buffer);
}
**/
void gkvs::as_record_ser::pack_list(as_list* list) {
uint32_t size = as_list_size(list);
msgpack_pack_array(&pk_, size);
as_arraylist_iterator it;
as_arraylist_iterator_init(&it, (as_arraylist*) list);
while (as_arraylist_iterator_has_next(&it)) {
as_val *val = (as_val*) as_arraylist_iterator_next(&it);
pack_val(val);
}
}
void gkvs::as_record_ser::pack_map(as_map* map) {
uint32_t size = as_map_size(map);
msgpack_pack_map(&pk_, size);
as_hashmap_iterator it;
as_hashmap_iterator_init(&it, (as_hashmap*) map);
while (as_hashmap_iterator_has_next(&it)) {
as_val *el = (as_val*) as_hashmap_iterator_next(&it);
if (el != nullptr && el->type == AS_PAIR) {
as_pair *kv = (as_pair *) el;
pack_val(as_pair_1(kv));
pack_val(as_pair_2(kv));
}
}
}
void gkvs::as_record_ser::pack_val(as_val* value) {
if (value == nullptr) {
msgpack_pack_nil(&pk_);
return;
}
as_val_t type = as_val_type(value);
switch(type) {
case AS_NIL:
msgpack_pack_nil(&pk_);
break;
case AS_BOOLEAN:
if (((as_boolean*) value)->value) {
msgpack_pack_true(&pk_);
}
else {
msgpack_pack_false(&pk_);
}
break;
case AS_INTEGER:
msgpack_pack_int64(&pk_, ((as_integer*) value)->value);
break;
case AS_DOUBLE:
msgpack_pack_double(&pk_, ((as_double*) value)->value);
break;
case AS_STRING: {
as_string* str = (as_string*) value;
size_t len = strlen(str->value);
msgpack_pack_str(&pk_, len);
msgpack_pack_str_body(&pk_, str->value, len);
break;
}
case AS_BYTES: {
as_bytes* bytes = (as_bytes*) value;
msgpack_pack_v4raw(&pk_, bytes->size);
msgpack_pack_v4raw_body(&pk_, bytes->value, bytes->size);
break;
}
case AS_LIST:
pack_list((as_list*) value);
break;
case AS_MAP:
pack_map((as_map*) value);
break;
case AS_GEOJSON: {
as_geojson* geo = (as_geojson*) value;
size_t len = strlen(geo->value);
msgpack_pack_str(&pk_, len);
msgpack_pack_str_body(&pk_, geo->value, len);
break;
}
default: {
char* str = as_val_tostring(value);
size_t len = strlen(str);
msgpack_pack_str(&pk_, len);
msgpack_pack_str_body(&pk_, str, len);
cf_free(str);
break;
}
}
}
void gkvs::as_record_ser::pack_bin_value(as_bin_value *value) {
as_val_t type = as_val_type(value);
switch(type) {
case AS_NIL:
msgpack_pack_nil(&pk_);
break;
case AS_INTEGER:
msgpack_pack_int64(&pk_, value->integer.value);
break;
case AS_DOUBLE:
msgpack_pack_double(&pk_, value->dbl.value);
break;
case AS_STRING: {
size_t len = strlen(value->string.value);
msgpack_pack_str(&pk_, len);
msgpack_pack_str_body(&pk_, value->string.value, len);
break;
}
case AS_BYTES:
msgpack_pack_v4raw(&pk_, value->bytes.size);
msgpack_pack_v4raw_body(&pk_, value->bytes.value, value->bytes.size);
break;
case AS_LIST:
pack_list(&value->list);
break;
case AS_MAP:
pack_map(&value->map);
break;
default: {
char *str = as_val_tostring(value);
size_t len = strlen(str);
msgpack_pack_str(&pk_, len);
msgpack_pack_str_body(&pk_, str, len);
cf_free(str);
break;
}
}
}
bool gkvs::as_record_ser::pack_record(as_record *rec, bool single_bin) {
if (rec_free_) {
as_record_destroy(rec_);
}
rec_ = rec;
rec_free_ = false;
if (!sbuf_free_) {
msgpack_sbuffer_init(&sbuf_);
sbuf_free_ = true;
msgpack_packer_init(&pk_, &sbuf_, msgpack_sbuffer_write);
}
sbuf_pos_ = sbuf_.size;
uint16_t size = as_record_numbins(rec_);
if (single_bin) {
if (size >= 1) {
as_bin_value *value = as_bin_get_value(rec_->bins.entries);
pack_bin_value(value);
}
return true;
}
if (size == 1) {
char* str = as_bin_get_name(rec_->bins.entries);
int first_len = strlen(str);
if (first_len == 0) {
as_bin_value *value = as_bin_get_value(rec_->bins.entries);
pack_bin_value(value);
return true;
}
}
msgpack_pack_map(&pk_, size);
as_record_iterator it;
as_record_iterator_init(&it, rec_);
while (as_record_iterator_has_next(&it)) {
const as_bin* bin = as_record_iterator_next(&it);
char* key = as_bin_get_name(bin);
size_t key_len = strlen(key);
msgpack_pack_str(&pk_, key_len);
msgpack_pack_str_body(&pk_, key, key_len);
as_bin_value* value = as_bin_get_value(bin);
pack_bin_value(value);
}
return true;
}
as_list* gkvs::as_record_ser::unpack_list(const msgpack_object &val_obj) {
const msgpack_object_array &array = val_obj.via.array;
as_list* list = (as_list*) as_arraylist_new(array.size, array.size);
for (uint32_t i = 0; i < array.size; ++i) {
msgpack_object& val_obj = array.ptr[i];
as_list_append(list, unpack_val(val_obj));
}
return list;
}
as_map* gkvs::as_record_ser::unpack_map(const msgpack_object &val_obj) {
const msgpack_object_map &map = val_obj.via.map;
as_map* hashmap = (as_map*) as_hashmap_new(map.size);
for (uint32_t i = 0; i < map.size; ++i) {
msgpack_object& key_obj = map.ptr[i].key;
msgpack_object& val_obj = map.ptr[i].val;
as_map_set(hashmap, unpack_val(key_obj), unpack_val(val_obj));
}
return hashmap;
}
as_val* gkvs::as_record_ser::unpack_val(const msgpack_object &val_obj) {
switch (val_obj.type) {
case MSGPACK_OBJECT_NIL:
return (as_val*) &as_nil;
case MSGPACK_OBJECT_BOOLEAN:
return as_boolean_toval(as_boolean_new(val_obj.via.boolean));
case MSGPACK_OBJECT_POSITIVE_INTEGER:
return as_integer_toval(as_integer_new(val_obj.via.u64));
case MSGPACK_OBJECT_NEGATIVE_INTEGER:
return as_integer_toval(as_integer_new(val_obj.via.i64));
case MSGPACK_OBJECT_FLOAT32:
case MSGPACK_OBJECT_FLOAT64:
return as_double_toval(as_double_new(val_obj.via.f64));
case MSGPACK_OBJECT_STR: {
/**
*
* DO NOT ALLOCATE IN HEAP
*
int len = val_obj.via.str.size;
char* buf = (char*) cf_malloc(len+1);
memcpy(buf, val_obj.via.str.ptr, len);
buf[len] = 0;
return as_string_toval(as_string_new(buf, true));
**/
return as_string_toval(as_string_new_wlen((char*)val_obj.via.str.ptr, val_obj.via.str.size, false));
}
case MSGPACK_OBJECT_BIN: {
/**
*
* DO NOT ALLOCATE IN HEAP
*
int len = val_obj.via.bin.size;
uint8_t* buf = (uint8_t*) cf_malloc(len);
memcpy(buf, val_obj.via.bin.ptr, len);
return as_bytes_toval(as_bytes_new_wrap(buf, len, true));
**/
return as_bytes_toval(as_bytes_new_wrap((uint8_t *)val_obj.via.bin.ptr, val_obj.via.bin.size, false));
}
case MSGPACK_OBJECT_ARRAY:
return as_list_toval(unpack_list(val_obj));
case MSGPACK_OBJECT_MAP:
return as_map_toval(unpack_map(val_obj));
default:
return (as_val*) &as_nil;
}
}
void gkvs::as_record_ser::record_set(const char* key, const msgpack_object& val_obj) {
switch (val_obj.type) {
case MSGPACK_OBJECT_NIL:
as_record_set_nil(rec_, key);
break;
case MSGPACK_OBJECT_BOOLEAN:
as_record_set_int64(rec_, key, val_obj.via.boolean ? 1 : 0);
break;
case MSGPACK_OBJECT_POSITIVE_INTEGER:
as_record_set_int64(rec_, key, val_obj.via.u64);
break;
case MSGPACK_OBJECT_NEGATIVE_INTEGER:
as_record_set_int64(rec_, key, val_obj.via.i64);
break;
case MSGPACK_OBJECT_FLOAT32:
case MSGPACK_OBJECT_FLOAT64:
as_record_set_double(rec_, key, val_obj.via.f64);
break;
case MSGPACK_OBJECT_STR: {
int len = val_obj.via.str.size;
char* buf = (char*) cf_malloc(len+1);
memcpy(buf, val_obj.via.str.ptr, len);
buf[len] = 0;
as_record_set_strp(rec_, key, buf, true);
break;
}
case MSGPACK_OBJECT_BIN: {
/**
*
* DO NOT ALLOCATE IN HEAP
*
int len = val_obj.via.bin.size;
uint8_t* buf = (uint8_t*) cf_malloc(len);
memcpy(buf, val_obj.via.bin.ptr, len);
as_record_set_rawp(rec_, key, buf, len, true);
**/
// msgpack val_obj reference on unpacker buffer
as_record_set_raw(rec_, key, (uint8_t*) val_obj.via.bin.ptr, val_obj.via.bin.size);
break;
}
case MSGPACK_OBJECT_ARRAY:
as_record_set_list(rec_, key, unpack_list(val_obj));
break;
case MSGPACK_OBJECT_MAP:
as_record_set_map(rec_, key, unpack_map(val_obj));
break;
default: {
if (!sbuf_free_) {
msgpack_sbuffer_init(&sbuf_);
sbuf_free_ = true;
msgpack_packer_init(&pk_, &sbuf_, msgpack_sbuffer_write);
}
sbuf_pos_ = sbuf_.size;
msgpack_pack_object(&pk_, val_obj);
as_record_set_raw(rec_, key, (uint8_t *) this->data(), this->size());
break;
}
}
}
as_record* gkvs::as_record_ser::alloc_rec(size_t size) {
if (rec_free_) {
as_record_destroy(rec_);
}
rec_ = as_record_new(size);
rec_free_ = true;
return rec_;
}
void gkvs::as_record_ser::stringify(msgpack_object& obj, char* buf, uint32_t size) {
switch(obj.type) {
case MSGPACK_OBJECT_STR: {
size_t len = std::min(size - 1, obj.via.str.size);
memcpy(buf, obj.via.str.ptr, len);
buf[len] = 0;
break;
}
case MSGPACK_OBJECT_POSITIVE_INTEGER:
snprintf(buf, size, "%lu", obj.via.u64);
break;
case MSGPACK_OBJECT_NEGATIVE_INTEGER:
snprintf(buf, size, "%ld", obj.via.i64);
break;
default:
msgpack_object_print_buffer(buf, size, obj);
break;
}
}
as_record* gkvs::as_record_ser::unpack_record(const char* data, size_t size, bool single_bin) {
if (!mempool_free_) {
msgpack_zone_init(&mempool_, 2048);
mempool_free_ = true;
}
msgpack_object deserialized;
msgpack_unpack(data, size, NULL, &mempool_, &deserialized);
//msgpack_object_print(stdout, deserialized);
if (single_bin || deserialized.type != MSGPACK_OBJECT_MAP) {
// use default column "" and single value
alloc_rec(1);
record_set((char*)"", deserialized);
return rec_;
}
msgpack_object_map map = deserialized.via.map;
alloc_rec(map.size);
for (uint32_t i = 0; i < map.size; ++i) {
msgpack_object& key_obj = map.ptr[i].key;
msgpack_object& val_obj = map.ptr[i].val;
char bin[AS_BIN_NAME_MAX_SIZE];
stringify(key_obj, bin, sizeof(bin));
record_set(bin, val_obj);
}
return rec_;
}
void gkvs::as_value_ser::set_integer(as_integer* i) {
_size = sizeof(uint64_t);
_buf = _stack_buf;
_free = false;
*(uint64_t*) _buf = cf_swap_to_le64(i->value);
}
void gkvs::as_value_ser::set_double(as_double* d) {
_size = sizeof(double);
_buf = _stack_buf;
_free = false;
*(double*) _buf = cf_swap_to_little_float64(d->value);
}
void gkvs::as_value_ser::set_with_serializer(as_val* val) {
as_buffer buffer;
as_buffer_init(&buffer);
as_serializer ser;
as_msgpack_init(&ser);
as_serializer_serialize(&ser, val, &buffer);
as_serializer_destroy(&ser);
_size = buffer.size;
_buf = new uint8_t[_size];
_free = true;
memcpy(_buf, buffer.data, _size);
as_buffer_destroy(&buffer);
}
void gkvs::as_value_ser::set(as_key_value* value) {
reset();
if (value != nullptr) {
as_val_t type = as_val_type(value);
switch(type) {
case AS_INTEGER:
set_integer(&value->integer);
break;
case AS_STRING:
set_string(&value->string);
break;
case AS_BYTES:
set_bytes(&value->bytes);
break;
default:
set_with_serializer(&value->bytes._);
break;
}
}
}
void gkvs::as_value_ser::set(as_bin_value* value) {
reset();
if (value != nullptr) {
as_val_t type = as_val_type(value);
switch(type) {
case AS_NIL:
break;
case AS_INTEGER:
set_integer(&value->integer);
break;
case AS_DOUBLE:
set_double(&value->dbl);
break;
case AS_STRING:
set_string(&value->string);
break;
case AS_BYTES:
set_bytes(&value->bytes);
break;
case AS_LIST:
set_with_serializer(&value->list._);
break;
case AS_MAP:
set_with_serializer(&value->map._);
break;
default:
set_with_serializer(&value->bytes._);
break;
}
}
}
void gkvs::as_value_ser::set(as_val* value) {
reset();
if (value != nullptr) {
as_val_t type = as_val_type(value);
switch(type) {
case AS_UNDEF:
break;
case AS_NIL:
break;
case AS_BOOLEAN:
set_bool((as_boolean*) value);
break;
case AS_INTEGER:
set_integer((as_integer*) value);
break;
case AS_STRING:
set_string((as_string*) value);
break;
case AS_LIST:
case AS_MAP:
case AS_REC:
case AS_PAIR:
case AS_GEOJSON:
set_with_serializer(value);
break;
case AS_BYTES:
set_bytes((as_bytes*) value);
break;
case AS_DOUBLE:
set_double((as_double*) value);
break;
default:
set_with_serializer(value);
break;
}
}
}
size_t gkvs::as_key_hash::operator()(const as_key *key) const {
as_digest *digest = as_key_digest((as_key *) key);
if (digest) {
const as_digest_value &b = key->digest.value;
int size_len = sizeof(size_t);
size_t hash = 0;
for (int i = 1; i <= size_len; ++i) {
hash <<= 8;
hash |= b[size_len - i];
}
return hash;
}
return 0;
}
bool gkvs::as_key_equal::operator()(const as_key *lhs, const as_key *rhs) const {
if (lhs == rhs) {
return true;
}
as_digest *ldigest = as_key_digest((as_key *) lhs);
as_digest *rdigest = as_key_digest((as_key *) rhs);
if (!ldigest || !rdigest) {
return false;
}
const as_digest_value &lval = ldigest->value;
const as_digest_value &rval = rdigest->value;
for (int i = 0; i < AS_DIGEST_VALUE_SIZE; ++i) {
uint8_t lch = lval[i];
uint8_t rch = rval[i];
if (lch != rch) {
return false;
}
}
for (int i = 0; i < AS_NAMESPACE_MAX_SIZE; ++i) {
char lch = lhs->ns[i];
char rch = rhs->ns[i];
if (lch != rch) {
return false;
}
if (!lch) {
break;
}
}
for (int i = 0; i < AS_SET_MAX_SIZE; ++i) {
char lch = lhs->set[i];
char rch = rhs->set[i];
if (lch != rch) {
return false;
}
if (!lch) {
break;
}
}
return true;
}
| 23.070175 | 114 | 0.558012 | [
"object"
] |
0b841ac6610b22bcfb48d5e3294c65b9021ed210 | 285,913 | cpp | C++ | Sharing/Src/Source/Client/ClientWrapperAPI_CSharp.cpp | ScriptBox99/MixedRealityToolkit | 9c9e6557263001bcbc48b8396c84ac840eff7c4c | [
"MIT"
] | 300 | 2017-08-12T12:57:42.000Z | 2019-05-06T00:31:29.000Z | Sharing/Src/Source/Client/ClientWrapperAPI_CSharp.cpp | ScriptBox99/MixedRealityToolkit | 9c9e6557263001bcbc48b8396c84ac840eff7c4c | [
"MIT"
] | 84 | 2017-08-14T11:03:37.000Z | 2019-04-24T22:59:59.000Z | Sharing/Src/Source/Client/ClientWrapperAPI_CSharp.cpp | ScriptBox99/MixedRealityToolkit | 9c9e6557263001bcbc48b8396c84ac840eff7c4c | [
"MIT"
] | 114 | 2017-08-12T03:51:58.000Z | 2019-05-06T03:36:26.000Z | /* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 3.0.10
*
* This file is not intended to be easily readable and contains a number of
* coding conventions designed to improve portability and efficiency. Do not make
* changes to this file unless you know what you are doing--modify the SWIG
* interface file instead.
* ----------------------------------------------------------------------------- */
#ifndef SWIGCSHARP
#define SWIGCSHARP
#endif
#define SWIG_DIRECTORS
#ifdef __cplusplus
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
struct SwigMovePointer {
T *ptr;
SwigMovePointer(T *p) : ptr(p) { }
~SwigMovePointer() { delete ptr; }
SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
} pointer;
SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
SwigValueWrapper() : pointer(0) { }
SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
operator T&() const { return *pointer.ptr; }
T *operator&() { return pointer.ptr; }
};
template <typename T> T SwigValueInit() {
return T();
}
#endif
/* -----------------------------------------------------------------------------
* This section contains generic SWIG labels for method/variable
* declarations/attributes, and other compiler dependent labels.
* ----------------------------------------------------------------------------- */
/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
# define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
# define SWIGTEMPLATEDISAMBIGUATOR template
# else
# define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif
/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
# define SWIGINLINE inline
# else
# define SWIGINLINE
# endif
#endif
/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
# elif defined(__ICC)
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
#endif
#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
# pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
# define SWIGUNUSEDPARM(p)
# else
# define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif
/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif
/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif
/* exporting methods */
#if defined(__GNUC__)
# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
# ifndef GCC_HASCLASSVISIBILITY
# define GCC_HASCLASSVISIBILITY
# endif
# endif
#endif
#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# if defined(STATIC_LINKED)
# define SWIGEXPORT
# else
# define SWIGEXPORT __declspec(dllexport)
# endif
# else
# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
# define SWIGEXPORT __attribute__ ((visibility("default")))
# else
# define SWIGEXPORT
# endif
# endif
#endif
/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# define SWIGSTDCALL __stdcall
# else
# define SWIGSTDCALL
# endif
#endif
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif
/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif
/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif
/* Intel's compiler complains if a variable which was never initialised is
* cast to void, which is a common idiom which we use to indicate that we
* are aware a variable isn't used. So we just silence that warning.
* See: https://github.com/swig/swig/issues/192 for more discussion.
*/
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
/* Support for throwing C# exceptions from C/C++. There are two types:
* Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
typedef enum {
SWIG_CSharpApplicationException,
SWIG_CSharpArithmeticException,
SWIG_CSharpDivideByZeroException,
SWIG_CSharpIndexOutOfRangeException,
SWIG_CSharpInvalidCastException,
SWIG_CSharpInvalidOperationException,
SWIG_CSharpIOException,
SWIG_CSharpNullReferenceException,
SWIG_CSharpOutOfMemoryException,
SWIG_CSharpOverflowException,
SWIG_CSharpSystemException
} SWIG_CSharpExceptionCodes;
typedef enum {
SWIG_CSharpArgumentException,
SWIG_CSharpArgumentNullException,
SWIG_CSharpArgumentOutOfRangeException
} SWIG_CSharpExceptionArgumentCodes;
typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
typedef struct {
SWIG_CSharpExceptionCodes code;
SWIG_CSharpExceptionCallback_t callback;
} SWIG_CSharpException_t;
typedef struct {
SWIG_CSharpExceptionArgumentCodes code;
SWIG_CSharpExceptionArgumentCallback_t callback;
} SWIG_CSharpExceptionArgument_t;
static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
{ SWIG_CSharpApplicationException, NULL },
{ SWIG_CSharpArithmeticException, NULL },
{ SWIG_CSharpDivideByZeroException, NULL },
{ SWIG_CSharpIndexOutOfRangeException, NULL },
{ SWIG_CSharpInvalidCastException, NULL },
{ SWIG_CSharpInvalidOperationException, NULL },
{ SWIG_CSharpIOException, NULL },
{ SWIG_CSharpNullReferenceException, NULL },
{ SWIG_CSharpOutOfMemoryException, NULL },
{ SWIG_CSharpOverflowException, NULL },
{ SWIG_CSharpSystemException, NULL }
};
static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
{ SWIG_CSharpArgumentException, NULL },
{ SWIG_CSharpArgumentNullException, NULL },
{ SWIG_CSharpArgumentOutOfRangeException, NULL }
};
static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
callback = SWIG_csharp_exceptions[code].callback;
}
callback(msg);
}
static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
callback = SWIG_csharp_exceptions_argument[code].callback;
}
callback(msg, param_name);
}
#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_SharingClient(
SWIG_CSharpExceptionCallback_t applicationCallback,
SWIG_CSharpExceptionCallback_t arithmeticCallback,
SWIG_CSharpExceptionCallback_t divideByZeroCallback,
SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
SWIG_CSharpExceptionCallback_t invalidCastCallback,
SWIG_CSharpExceptionCallback_t invalidOperationCallback,
SWIG_CSharpExceptionCallback_t ioCallback,
SWIG_CSharpExceptionCallback_t nullReferenceCallback,
SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
SWIG_CSharpExceptionCallback_t overflowCallback,
SWIG_CSharpExceptionCallback_t systemCallback) {
SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
}
#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_SharingClient(
SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
}
/* Callback for returning strings to C# without leaking memory */
typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_SharingClient(SWIG_CSharpStringHelperCallback callback) {
SWIG_csharp_string_callback = callback;
}
/* Contract support */
#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
/* Errors in SWIG */
#define SWIG_UnknownError -1
#define SWIG_IOError -2
#define SWIG_RuntimeError -3
#define SWIG_IndexError -4
#define SWIG_TypeError -5
#define SWIG_DivisionByZero -6
#define SWIG_OverflowError -7
#define SWIG_SyntaxError -8
#define SWIG_ValueError -9
#define SWIG_SystemError -10
#define SWIG_AttributeError -11
#define SWIG_MemoryError -12
#define SWIG_NullReferenceError -13
/* -----------------------------------------------------------------------------
* director_common.swg
*
* This file contains support for director classes which is common between
* languages.
* ----------------------------------------------------------------------------- */
/*
Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
'Swig' namespace. This could be useful for multi-modules projects.
*/
#ifdef SWIG_DIRECTOR_STATIC
/* Force anonymous (static) namespace */
#define Swig
#endif
/* -----------------------------------------------------------------------------
* director.swg
*
* This file contains support for director classes so that C# proxy
* methods can be called from C++.
* ----------------------------------------------------------------------------- */
#if defined(DEBUG_DIRECTOR_OWNED)
#include <iostream>
#endif
#include <string>
#include <exception>
namespace Swig {
/* Director base class - not currently used in C# directors */
class Director {
};
/* Base class for director exceptions */
class DirectorException : public std::exception {
protected:
std::string swig_msg;
public:
DirectorException(const char *msg) : swig_msg(msg) {
}
DirectorException(const std::string &msg) : swig_msg(msg) {
}
virtual ~DirectorException() throw() {
}
const char *what() const throw() {
return swig_msg.c_str();
}
};
/* Pure virtual method exception */
class DirectorPureVirtualException : public DirectorException {
public:
DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
}
};
}
#include "../Common/Common.h"
#include "ClientWrapperAPI.h"
using namespace XTools;
#include <stdexcept>
#include <string>
#include <vector>
#include <algorithm>
#include <stdexcept>
#include <map>
#include <algorithm>
#include <stdexcept>
SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
if (code == SWIG_ValueError) {
SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
} else {
SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
switch(code) {
case SWIG_MemoryError:
exception_code = SWIG_CSharpOutOfMemoryException;
break;
case SWIG_IndexError:
exception_code = SWIG_CSharpIndexOutOfRangeException;
break;
case SWIG_DivisionByZero:
exception_code = SWIG_CSharpDivideByZeroException;
break;
case SWIG_IOError:
exception_code = SWIG_CSharpIOException;
break;
case SWIG_OverflowError:
exception_code = SWIG_CSharpOverflowException;
break;
case SWIG_RuntimeError:
case SWIG_TypeError:
case SWIG_SyntaxError:
case SWIG_SystemError:
case SWIG_UnknownError:
default:
exception_code = SWIG_CSharpApplicationException;
break;
}
SWIG_CSharpSetPendingException(exception_code, msg);
}
}
#include <stdexcept>
#include <utility>
/* ---------------------------------------------------
* C++ director class methods
* --------------------------------------------------- */
#include "ClientWrapperAPI_CSharp.h"
SwigDirector_LogWriter::SwigDirector_LogWriter() : XTools::LogWriter(), Swig::Director() {
swig_init_callbacks();
}
SwigDirector_LogWriter::~SwigDirector_LogWriter() {
}
void SwigDirector_LogWriter::WriteLogEntry(XTools::LogSeverity severity, std::string const &message) {
int jseverity ;
char * jmessage = 0 ;
if (!swig_callbackWriteLogEntry) {
XTools::LogWriter::WriteLogEntry(severity,message);
return;
} else {
jseverity = (int)severity;
jmessage = SWIG_csharp_string_callback((&message)->c_str());
swig_callbackWriteLogEntry(jseverity, jmessage);
}
}
void SwigDirector_LogWriter::swig_connect_director(SWIG_Callback0_t callbackWriteLogEntry) {
swig_callbackWriteLogEntry = callbackWriteLogEntry;
}
void SwigDirector_LogWriter::swig_init_callbacks() {
swig_callbackWriteLogEntry = 0;
}
SwigDirector_NetworkConnectionListener::SwigDirector_NetworkConnectionListener() : XTools::NetworkConnectionListener(), Swig::Director() {
swig_init_callbacks();
}
SwigDirector_NetworkConnectionListener::~SwigDirector_NetworkConnectionListener() {
}
void SwigDirector_NetworkConnectionListener::OnConnected(XTools::NetworkConnectionPtr const &connection) {
void * jconnection = 0 ;
if (!swig_callbackOnConnected) {
XTools::NetworkConnectionListener::OnConnected(connection);
return;
} else {
// ref_ptr by reference directorin
if (connection) {
connection->AddRef();
}
jconnection = (&connection)->get();
swig_callbackOnConnected(jconnection);
}
}
void SwigDirector_NetworkConnectionListener::OnConnectFailed(XTools::NetworkConnectionPtr const &connection) {
void * jconnection = 0 ;
if (!swig_callbackOnConnectFailed) {
XTools::NetworkConnectionListener::OnConnectFailed(connection);
return;
} else {
// ref_ptr by reference directorin
if (connection) {
connection->AddRef();
}
jconnection = (&connection)->get();
swig_callbackOnConnectFailed(jconnection);
}
}
void SwigDirector_NetworkConnectionListener::OnDisconnected(XTools::NetworkConnectionPtr const &connection) {
void * jconnection = 0 ;
if (!swig_callbackOnDisconnected) {
XTools::NetworkConnectionListener::OnDisconnected(connection);
return;
} else {
// ref_ptr by reference directorin
if (connection) {
connection->AddRef();
}
jconnection = (&connection)->get();
swig_callbackOnDisconnected(jconnection);
}
}
void SwigDirector_NetworkConnectionListener::OnMessageReceived(XTools::NetworkConnectionPtr const &connection, XTools::NetworkInMessage &message) {
void * jconnection = 0 ;
void * jmessage = 0 ;
if (!swig_callbackOnMessageReceived) {
XTools::NetworkConnectionListener::OnMessageReceived(connection,message);
return;
} else {
// ref_ptr by reference directorin
if (connection) {
connection->AddRef();
}
jconnection = (&connection)->get();
jmessage = (XTools::NetworkInMessage *) &message;
swig_callbackOnMessageReceived(jconnection, jmessage);
}
}
void SwigDirector_NetworkConnectionListener::swig_connect_director(SWIG_Callback0_t callbackOnConnected, SWIG_Callback1_t callbackOnConnectFailed, SWIG_Callback2_t callbackOnDisconnected, SWIG_Callback3_t callbackOnMessageReceived) {
swig_callbackOnConnected = callbackOnConnected;
swig_callbackOnConnectFailed = callbackOnConnectFailed;
swig_callbackOnDisconnected = callbackOnDisconnected;
swig_callbackOnMessageReceived = callbackOnMessageReceived;
}
void SwigDirector_NetworkConnectionListener::swig_init_callbacks() {
swig_callbackOnConnected = 0;
swig_callbackOnConnectFailed = 0;
swig_callbackOnDisconnected = 0;
swig_callbackOnMessageReceived = 0;
}
SwigDirector_IntArrayListener::SwigDirector_IntArrayListener() : XTools::IntArrayListener(), Swig::Director() {
swig_init_callbacks();
}
SwigDirector_IntArrayListener::~SwigDirector_IntArrayListener() {
}
void SwigDirector_IntArrayListener::OnValueChanged(XTools::int32 index, XTools::int32 newValue) {
int jindex ;
int jnewValue ;
if (!swig_callbackOnValueChanged) {
XTools::IntArrayListener::OnValueChanged(index,newValue);
return;
} else {
jindex = index;
jnewValue = newValue;
swig_callbackOnValueChanged(jindex, jnewValue);
}
}
void SwigDirector_IntArrayListener::OnValueInserted(XTools::int32 index, XTools::int32 value) {
int jindex ;
int jvalue ;
if (!swig_callbackOnValueInserted) {
XTools::IntArrayListener::OnValueInserted(index,value);
return;
} else {
jindex = index;
jvalue = value;
swig_callbackOnValueInserted(jindex, jvalue);
}
}
void SwigDirector_IntArrayListener::OnValueRemoved(XTools::int32 index, XTools::int32 value) {
int jindex ;
int jvalue ;
if (!swig_callbackOnValueRemoved) {
XTools::IntArrayListener::OnValueRemoved(index,value);
return;
} else {
jindex = index;
jvalue = value;
swig_callbackOnValueRemoved(jindex, jvalue);
}
}
void SwigDirector_IntArrayListener::swig_connect_director(SWIG_Callback0_t callbackOnValueChanged, SWIG_Callback1_t callbackOnValueInserted, SWIG_Callback2_t callbackOnValueRemoved) {
swig_callbackOnValueChanged = callbackOnValueChanged;
swig_callbackOnValueInserted = callbackOnValueInserted;
swig_callbackOnValueRemoved = callbackOnValueRemoved;
}
void SwigDirector_IntArrayListener::swig_init_callbacks() {
swig_callbackOnValueChanged = 0;
swig_callbackOnValueInserted = 0;
swig_callbackOnValueRemoved = 0;
}
SwigDirector_FloatArrayListener::SwigDirector_FloatArrayListener() : XTools::FloatArrayListener(), Swig::Director() {
swig_init_callbacks();
}
SwigDirector_FloatArrayListener::~SwigDirector_FloatArrayListener() {
}
void SwigDirector_FloatArrayListener::OnValueChanged(XTools::int32 index, float newValue) {
int jindex ;
float jnewValue ;
if (!swig_callbackOnValueChanged) {
XTools::FloatArrayListener::OnValueChanged(index,newValue);
return;
} else {
jindex = index;
jnewValue = newValue;
swig_callbackOnValueChanged(jindex, jnewValue);
}
}
void SwigDirector_FloatArrayListener::OnValueInserted(XTools::int32 index, float value) {
int jindex ;
float jvalue ;
if (!swig_callbackOnValueInserted) {
XTools::FloatArrayListener::OnValueInserted(index,value);
return;
} else {
jindex = index;
jvalue = value;
swig_callbackOnValueInserted(jindex, jvalue);
}
}
void SwigDirector_FloatArrayListener::OnValueRemoved(XTools::int32 index, float value) {
int jindex ;
float jvalue ;
if (!swig_callbackOnValueRemoved) {
XTools::FloatArrayListener::OnValueRemoved(index,value);
return;
} else {
jindex = index;
jvalue = value;
swig_callbackOnValueRemoved(jindex, jvalue);
}
}
void SwigDirector_FloatArrayListener::swig_connect_director(SWIG_Callback0_t callbackOnValueChanged, SWIG_Callback1_t callbackOnValueInserted, SWIG_Callback2_t callbackOnValueRemoved) {
swig_callbackOnValueChanged = callbackOnValueChanged;
swig_callbackOnValueInserted = callbackOnValueInserted;
swig_callbackOnValueRemoved = callbackOnValueRemoved;
}
void SwigDirector_FloatArrayListener::swig_init_callbacks() {
swig_callbackOnValueChanged = 0;
swig_callbackOnValueInserted = 0;
swig_callbackOnValueRemoved = 0;
}
SwigDirector_StringArrayListener::SwigDirector_StringArrayListener() : XTools::StringArrayListener(), Swig::Director() {
swig_init_callbacks();
}
SwigDirector_StringArrayListener::~SwigDirector_StringArrayListener() {
}
void SwigDirector_StringArrayListener::OnValueChanged(XTools::int32 index, XTools::XStringPtr const &newValue) {
int jindex ;
void * jnewValue = 0 ;
if (!swig_callbackOnValueChanged) {
XTools::StringArrayListener::OnValueChanged(index,newValue);
return;
} else {
jindex = index;
// ref_ptr by reference directorin
if (newValue) {
newValue->AddRef();
}
jnewValue = (&newValue)->get();
swig_callbackOnValueChanged(jindex, jnewValue);
}
}
void SwigDirector_StringArrayListener::OnValueInserted(XTools::int32 index, XTools::XStringPtr const &value) {
int jindex ;
void * jvalue = 0 ;
if (!swig_callbackOnValueInserted) {
XTools::StringArrayListener::OnValueInserted(index,value);
return;
} else {
jindex = index;
// ref_ptr by reference directorin
if (value) {
value->AddRef();
}
jvalue = (&value)->get();
swig_callbackOnValueInserted(jindex, jvalue);
}
}
void SwigDirector_StringArrayListener::OnValueRemoved(XTools::int32 index, XTools::XStringPtr const &value) {
int jindex ;
void * jvalue = 0 ;
if (!swig_callbackOnValueRemoved) {
XTools::StringArrayListener::OnValueRemoved(index,value);
return;
} else {
jindex = index;
// ref_ptr by reference directorin
if (value) {
value->AddRef();
}
jvalue = (&value)->get();
swig_callbackOnValueRemoved(jindex, jvalue);
}
}
void SwigDirector_StringArrayListener::swig_connect_director(SWIG_Callback0_t callbackOnValueChanged, SWIG_Callback1_t callbackOnValueInserted, SWIG_Callback2_t callbackOnValueRemoved) {
swig_callbackOnValueChanged = callbackOnValueChanged;
swig_callbackOnValueInserted = callbackOnValueInserted;
swig_callbackOnValueRemoved = callbackOnValueRemoved;
}
void SwigDirector_StringArrayListener::swig_init_callbacks() {
swig_callbackOnValueChanged = 0;
swig_callbackOnValueInserted = 0;
swig_callbackOnValueRemoved = 0;
}
SwigDirector_ObjectElementListener::SwigDirector_ObjectElementListener() : XTools::ObjectElementListener(), Swig::Director() {
swig_init_callbacks();
}
SwigDirector_ObjectElementListener::~SwigDirector_ObjectElementListener() {
}
void SwigDirector_ObjectElementListener::OnBoolElementChanged(XTools::XGuid elementID, bool newValue) {
long long jelementID ;
unsigned int jnewValue ;
if (!swig_callbackOnBoolElementChanged) {
XTools::ObjectElementListener::OnBoolElementChanged(elementID,newValue);
return;
} else {
jelementID = elementID;
jnewValue = newValue;
swig_callbackOnBoolElementChanged(jelementID, jnewValue);
}
}
void SwigDirector_ObjectElementListener::OnIntElementChanged(XTools::XGuid elementID, XTools::int32 newValue) {
long long jelementID ;
int jnewValue ;
if (!swig_callbackOnIntElementChanged) {
XTools::ObjectElementListener::OnIntElementChanged(elementID,newValue);
return;
} else {
jelementID = elementID;
jnewValue = newValue;
swig_callbackOnIntElementChanged(jelementID, jnewValue);
}
}
void SwigDirector_ObjectElementListener::OnLongElementChanged(XTools::XGuid elementID, XTools::int64 newValue) {
long long jelementID ;
long long jnewValue ;
if (!swig_callbackOnLongElementChanged) {
XTools::ObjectElementListener::OnLongElementChanged(elementID,newValue);
return;
} else {
jelementID = elementID;
jnewValue = newValue;
swig_callbackOnLongElementChanged(jelementID, jnewValue);
}
}
void SwigDirector_ObjectElementListener::OnFloatElementChanged(XTools::XGuid elementID, float newValue) {
long long jelementID ;
float jnewValue ;
if (!swig_callbackOnFloatElementChanged) {
XTools::ObjectElementListener::OnFloatElementChanged(elementID,newValue);
return;
} else {
jelementID = elementID;
jnewValue = newValue;
swig_callbackOnFloatElementChanged(jelementID, jnewValue);
}
}
void SwigDirector_ObjectElementListener::OnDoubleElementChanged(XTools::XGuid elementID, double newValue) {
long long jelementID ;
double jnewValue ;
if (!swig_callbackOnDoubleElementChanged) {
XTools::ObjectElementListener::OnDoubleElementChanged(elementID,newValue);
return;
} else {
jelementID = elementID;
jnewValue = newValue;
swig_callbackOnDoubleElementChanged(jelementID, jnewValue);
}
}
void SwigDirector_ObjectElementListener::OnStringElementChanged(XTools::XGuid elementID, XTools::XStringPtr const &newValue) {
long long jelementID ;
void * jnewValue = 0 ;
if (!swig_callbackOnStringElementChanged) {
XTools::ObjectElementListener::OnStringElementChanged(elementID,newValue);
return;
} else {
jelementID = elementID;
// ref_ptr by reference directorin
if (newValue) {
newValue->AddRef();
}
jnewValue = (&newValue)->get();
swig_callbackOnStringElementChanged(jelementID, jnewValue);
}
}
void SwigDirector_ObjectElementListener::OnElementAdded(XTools::ElementPtr const &element) {
void * jelement = 0 ;
if (!swig_callbackOnElementAdded) {
XTools::ObjectElementListener::OnElementAdded(element);
return;
} else {
// ref_ptr by reference directorin
if (element) {
element->AddRef();
}
jelement = (&element)->get();
swig_callbackOnElementAdded(jelement);
}
}
void SwigDirector_ObjectElementListener::OnElementDeleted(XTools::ElementPtr const &element) {
void * jelement = 0 ;
if (!swig_callbackOnElementDeleted) {
XTools::ObjectElementListener::OnElementDeleted(element);
return;
} else {
// ref_ptr by reference directorin
if (element) {
element->AddRef();
}
jelement = (&element)->get();
swig_callbackOnElementDeleted(jelement);
}
}
void SwigDirector_ObjectElementListener::swig_connect_director(SWIG_Callback0_t callbackOnBoolElementChanged, SWIG_Callback1_t callbackOnIntElementChanged, SWIG_Callback2_t callbackOnLongElementChanged, SWIG_Callback3_t callbackOnFloatElementChanged, SWIG_Callback4_t callbackOnDoubleElementChanged, SWIG_Callback5_t callbackOnStringElementChanged, SWIG_Callback6_t callbackOnElementAdded, SWIG_Callback7_t callbackOnElementDeleted) {
swig_callbackOnBoolElementChanged = callbackOnBoolElementChanged;
swig_callbackOnIntElementChanged = callbackOnIntElementChanged;
swig_callbackOnLongElementChanged = callbackOnLongElementChanged;
swig_callbackOnFloatElementChanged = callbackOnFloatElementChanged;
swig_callbackOnDoubleElementChanged = callbackOnDoubleElementChanged;
swig_callbackOnStringElementChanged = callbackOnStringElementChanged;
swig_callbackOnElementAdded = callbackOnElementAdded;
swig_callbackOnElementDeleted = callbackOnElementDeleted;
}
void SwigDirector_ObjectElementListener::swig_init_callbacks() {
swig_callbackOnBoolElementChanged = 0;
swig_callbackOnIntElementChanged = 0;
swig_callbackOnLongElementChanged = 0;
swig_callbackOnFloatElementChanged = 0;
swig_callbackOnDoubleElementChanged = 0;
swig_callbackOnStringElementChanged = 0;
swig_callbackOnElementAdded = 0;
swig_callbackOnElementDeleted = 0;
}
SwigDirector_SyncListener::SwigDirector_SyncListener() : XTools::SyncListener(), Swig::Director() {
swig_init_callbacks();
}
SwigDirector_SyncListener::~SwigDirector_SyncListener() {
}
void SwigDirector_SyncListener::OnSyncChangesBegin() {
if (!swig_callbackOnSyncChangesBegin) {
XTools::SyncListener::OnSyncChangesBegin();
return;
} else {
swig_callbackOnSyncChangesBegin();
}
}
void SwigDirector_SyncListener::OnSyncChangesEnd() {
if (!swig_callbackOnSyncChangesEnd) {
XTools::SyncListener::OnSyncChangesEnd();
return;
} else {
swig_callbackOnSyncChangesEnd();
}
}
void SwigDirector_SyncListener::swig_connect_director(SWIG_Callback0_t callbackOnSyncChangesBegin, SWIG_Callback1_t callbackOnSyncChangesEnd) {
swig_callbackOnSyncChangesBegin = callbackOnSyncChangesBegin;
swig_callbackOnSyncChangesEnd = callbackOnSyncChangesEnd;
}
void SwigDirector_SyncListener::swig_init_callbacks() {
swig_callbackOnSyncChangesBegin = 0;
swig_callbackOnSyncChangesEnd = 0;
}
SwigDirector_SessionListener::SwigDirector_SessionListener() : XTools::SessionListener(), Swig::Director() {
swig_init_callbacks();
}
SwigDirector_SessionListener::~SwigDirector_SessionListener() {
}
void SwigDirector_SessionListener::OnJoiningSession() {
if (!swig_callbackOnJoiningSession) {
XTools::SessionListener::OnJoiningSession();
return;
} else {
swig_callbackOnJoiningSession();
}
}
void SwigDirector_SessionListener::OnJoinSucceeded() {
if (!swig_callbackOnJoinSucceeded) {
XTools::SessionListener::OnJoinSucceeded();
return;
} else {
swig_callbackOnJoinSucceeded();
}
}
void SwigDirector_SessionListener::OnJoinFailed() {
if (!swig_callbackOnJoinFailed) {
XTools::SessionListener::OnJoinFailed();
return;
} else {
swig_callbackOnJoinFailed();
}
}
void SwigDirector_SessionListener::OnSessionDisconnected() {
if (!swig_callbackOnSessionDisconnected) {
XTools::SessionListener::OnSessionDisconnected();
return;
} else {
swig_callbackOnSessionDisconnected();
}
}
void SwigDirector_SessionListener::swig_connect_director(SWIG_Callback0_t callbackOnJoiningSession, SWIG_Callback1_t callbackOnJoinSucceeded, SWIG_Callback2_t callbackOnJoinFailed, SWIG_Callback3_t callbackOnSessionDisconnected) {
swig_callbackOnJoiningSession = callbackOnJoiningSession;
swig_callbackOnJoinSucceeded = callbackOnJoinSucceeded;
swig_callbackOnJoinFailed = callbackOnJoinFailed;
swig_callbackOnSessionDisconnected = callbackOnSessionDisconnected;
}
void SwigDirector_SessionListener::swig_init_callbacks() {
swig_callbackOnJoiningSession = 0;
swig_callbackOnJoinSucceeded = 0;
swig_callbackOnJoinFailed = 0;
swig_callbackOnSessionDisconnected = 0;
}
SwigDirector_SessionManagerListener::SwigDirector_SessionManagerListener() : XTools::SessionManagerListener(), Swig::Director() {
swig_init_callbacks();
}
SwigDirector_SessionManagerListener::~SwigDirector_SessionManagerListener() {
}
void SwigDirector_SessionManagerListener::OnCreateSucceeded(XTools::SessionPtr const &newSession) {
void * jnewSession = 0 ;
if (!swig_callbackOnCreateSucceeded) {
XTools::SessionManagerListener::OnCreateSucceeded(newSession);
return;
} else {
// ref_ptr by reference directorin
if (newSession) {
newSession->AddRef();
}
jnewSession = (&newSession)->get();
swig_callbackOnCreateSucceeded(jnewSession);
}
}
void SwigDirector_SessionManagerListener::OnCreateFailed(XTools::XStringPtr const &reason) {
void * jreason = 0 ;
if (!swig_callbackOnCreateFailed) {
XTools::SessionManagerListener::OnCreateFailed(reason);
return;
} else {
// ref_ptr by reference directorin
if (reason) {
reason->AddRef();
}
jreason = (&reason)->get();
swig_callbackOnCreateFailed(jreason);
}
}
void SwigDirector_SessionManagerListener::OnSessionAdded(XTools::SessionPtr const &newSession) {
void * jnewSession = 0 ;
if (!swig_callbackOnSessionAdded) {
XTools::SessionManagerListener::OnSessionAdded(newSession);
return;
} else {
// ref_ptr by reference directorin
if (newSession) {
newSession->AddRef();
}
jnewSession = (&newSession)->get();
swig_callbackOnSessionAdded(jnewSession);
}
}
void SwigDirector_SessionManagerListener::OnSessionClosed(XTools::SessionPtr const &session) {
void * jsession = 0 ;
if (!swig_callbackOnSessionClosed) {
XTools::SessionManagerListener::OnSessionClosed(session);
return;
} else {
// ref_ptr by reference directorin
if (session) {
session->AddRef();
}
jsession = (&session)->get();
swig_callbackOnSessionClosed(jsession);
}
}
void SwigDirector_SessionManagerListener::OnUserJoinedSession(XTools::SessionPtr const &session, XTools::UserPtr const &newUser) {
void * jsession = 0 ;
void * jnewUser = 0 ;
if (!swig_callbackOnUserJoinedSession) {
XTools::SessionManagerListener::OnUserJoinedSession(session,newUser);
return;
} else {
// ref_ptr by reference directorin
if (session) {
session->AddRef();
}
jsession = (&session)->get();
// ref_ptr by reference directorin
if (newUser) {
newUser->AddRef();
}
jnewUser = (&newUser)->get();
swig_callbackOnUserJoinedSession(jsession, jnewUser);
}
}
void SwigDirector_SessionManagerListener::OnUserLeftSession(XTools::SessionPtr const &session, XTools::UserPtr const &user) {
void * jsession = 0 ;
void * juser = 0 ;
if (!swig_callbackOnUserLeftSession) {
XTools::SessionManagerListener::OnUserLeftSession(session,user);
return;
} else {
// ref_ptr by reference directorin
if (session) {
session->AddRef();
}
jsession = (&session)->get();
// ref_ptr by reference directorin
if (user) {
user->AddRef();
}
juser = (&user)->get();
swig_callbackOnUserLeftSession(jsession, juser);
}
}
void SwigDirector_SessionManagerListener::OnUserChanged(XTools::SessionPtr const &session, XTools::UserPtr const &user) {
void * jsession = 0 ;
void * juser = 0 ;
if (!swig_callbackOnUserChanged) {
XTools::SessionManagerListener::OnUserChanged(session,user);
return;
} else {
// ref_ptr by reference directorin
if (session) {
session->AddRef();
}
jsession = (&session)->get();
// ref_ptr by reference directorin
if (user) {
user->AddRef();
}
juser = (&user)->get();
swig_callbackOnUserChanged(jsession, juser);
}
}
void SwigDirector_SessionManagerListener::OnServerConnected() {
if (!swig_callbackOnServerConnected) {
XTools::SessionManagerListener::OnServerConnected();
return;
} else {
swig_callbackOnServerConnected();
}
}
void SwigDirector_SessionManagerListener::OnServerDisconnected() {
if (!swig_callbackOnServerDisconnected) {
XTools::SessionManagerListener::OnServerDisconnected();
return;
} else {
swig_callbackOnServerDisconnected();
}
}
void SwigDirector_SessionManagerListener::swig_connect_director(SWIG_Callback0_t callbackOnCreateSucceeded, SWIG_Callback1_t callbackOnCreateFailed, SWIG_Callback2_t callbackOnSessionAdded, SWIG_Callback3_t callbackOnSessionClosed, SWIG_Callback4_t callbackOnUserJoinedSession, SWIG_Callback5_t callbackOnUserLeftSession, SWIG_Callback6_t callbackOnUserChanged, SWIG_Callback7_t callbackOnServerConnected, SWIG_Callback8_t callbackOnServerDisconnected) {
swig_callbackOnCreateSucceeded = callbackOnCreateSucceeded;
swig_callbackOnCreateFailed = callbackOnCreateFailed;
swig_callbackOnSessionAdded = callbackOnSessionAdded;
swig_callbackOnSessionClosed = callbackOnSessionClosed;
swig_callbackOnUserJoinedSession = callbackOnUserJoinedSession;
swig_callbackOnUserLeftSession = callbackOnUserLeftSession;
swig_callbackOnUserChanged = callbackOnUserChanged;
swig_callbackOnServerConnected = callbackOnServerConnected;
swig_callbackOnServerDisconnected = callbackOnServerDisconnected;
}
void SwigDirector_SessionManagerListener::swig_init_callbacks() {
swig_callbackOnCreateSucceeded = 0;
swig_callbackOnCreateFailed = 0;
swig_callbackOnSessionAdded = 0;
swig_callbackOnSessionClosed = 0;
swig_callbackOnUserJoinedSession = 0;
swig_callbackOnUserLeftSession = 0;
swig_callbackOnUserChanged = 0;
swig_callbackOnServerConnected = 0;
swig_callbackOnServerDisconnected = 0;
}
SwigDirector_UserPresenceManagerListener::SwigDirector_UserPresenceManagerListener() : XTools::UserPresenceManagerListener(), Swig::Director() {
swig_init_callbacks();
}
SwigDirector_UserPresenceManagerListener::~SwigDirector_UserPresenceManagerListener() {
}
void SwigDirector_UserPresenceManagerListener::OnUserPresenceChanged(XTools::UserPtr const &user) {
void * juser = 0 ;
if (!swig_callbackOnUserPresenceChanged) {
XTools::UserPresenceManagerListener::OnUserPresenceChanged(user);
return;
} else {
// ref_ptr by reference directorin
if (user) {
user->AddRef();
}
juser = (&user)->get();
swig_callbackOnUserPresenceChanged(juser);
}
}
void SwigDirector_UserPresenceManagerListener::swig_connect_director(SWIG_Callback0_t callbackOnUserPresenceChanged) {
swig_callbackOnUserPresenceChanged = callbackOnUserPresenceChanged;
}
void SwigDirector_UserPresenceManagerListener::swig_init_callbacks() {
swig_callbackOnUserPresenceChanged = 0;
}
SwigDirector_RoomManagerListener::SwigDirector_RoomManagerListener() : XTools::RoomManagerListener(), Swig::Director() {
swig_init_callbacks();
}
SwigDirector_RoomManagerListener::~SwigDirector_RoomManagerListener() {
}
void SwigDirector_RoomManagerListener::OnRoomAdded(XTools::RoomPtr const &newRoom) {
void * jnewRoom = 0 ;
if (!swig_callbackOnRoomAdded) {
XTools::RoomManagerListener::OnRoomAdded(newRoom);
return;
} else {
// ref_ptr by reference directorin
if (newRoom) {
newRoom->AddRef();
}
jnewRoom = (&newRoom)->get();
swig_callbackOnRoomAdded(jnewRoom);
}
}
void SwigDirector_RoomManagerListener::OnRoomClosed(XTools::RoomPtr const &room) {
void * jroom = 0 ;
if (!swig_callbackOnRoomClosed) {
XTools::RoomManagerListener::OnRoomClosed(room);
return;
} else {
// ref_ptr by reference directorin
if (room) {
room->AddRef();
}
jroom = (&room)->get();
swig_callbackOnRoomClosed(jroom);
}
}
void SwigDirector_RoomManagerListener::OnUserJoinedRoom(XTools::RoomPtr const &room, XTools::UserID user) {
void * jroom = 0 ;
int juser ;
if (!swig_callbackOnUserJoinedRoom) {
XTools::RoomManagerListener::OnUserJoinedRoom(room,user);
return;
} else {
// ref_ptr by reference directorin
if (room) {
room->AddRef();
}
jroom = (&room)->get();
juser = user;
swig_callbackOnUserJoinedRoom(jroom, juser);
}
}
void SwigDirector_RoomManagerListener::OnUserLeftRoom(XTools::RoomPtr const &room, XTools::UserID user) {
void * jroom = 0 ;
int juser ;
if (!swig_callbackOnUserLeftRoom) {
XTools::RoomManagerListener::OnUserLeftRoom(room,user);
return;
} else {
// ref_ptr by reference directorin
if (room) {
room->AddRef();
}
jroom = (&room)->get();
juser = user;
swig_callbackOnUserLeftRoom(jroom, juser);
}
}
void SwigDirector_RoomManagerListener::OnAnchorsChanged(XTools::RoomPtr const &room) {
void * jroom = 0 ;
if (!swig_callbackOnAnchorsChanged) {
XTools::RoomManagerListener::OnAnchorsChanged(room);
return;
} else {
// ref_ptr by reference directorin
if (room) {
room->AddRef();
}
jroom = (&room)->get();
swig_callbackOnAnchorsChanged(jroom);
}
}
void SwigDirector_RoomManagerListener::OnAnchorsDownloaded(bool successful, XTools::AnchorDownloadRequestPtr const &request, XTools::XStringPtr const &failureReason) {
unsigned int jsuccessful ;
void * jrequest = 0 ;
void * jfailureReason = 0 ;
if (!swig_callbackOnAnchorsDownloaded) {
XTools::RoomManagerListener::OnAnchorsDownloaded(successful,request,failureReason);
return;
} else {
jsuccessful = successful;
// ref_ptr by reference directorin
if (request) {
request->AddRef();
}
jrequest = (&request)->get();
// ref_ptr by reference directorin
if (failureReason) {
failureReason->AddRef();
}
jfailureReason = (&failureReason)->get();
swig_callbackOnAnchorsDownloaded(jsuccessful, jrequest, jfailureReason);
}
}
void SwigDirector_RoomManagerListener::OnAnchorUploadComplete(bool successful, XTools::XStringPtr const &failureReason) {
unsigned int jsuccessful ;
void * jfailureReason = 0 ;
if (!swig_callbackOnAnchorUploadComplete) {
XTools::RoomManagerListener::OnAnchorUploadComplete(successful,failureReason);
return;
} else {
jsuccessful = successful;
// ref_ptr by reference directorin
if (failureReason) {
failureReason->AddRef();
}
jfailureReason = (&failureReason)->get();
swig_callbackOnAnchorUploadComplete(jsuccessful, jfailureReason);
}
}
void SwigDirector_RoomManagerListener::swig_connect_director(SWIG_Callback0_t callbackOnRoomAdded, SWIG_Callback1_t callbackOnRoomClosed, SWIG_Callback2_t callbackOnUserJoinedRoom, SWIG_Callback3_t callbackOnUserLeftRoom, SWIG_Callback4_t callbackOnAnchorsChanged, SWIG_Callback5_t callbackOnAnchorsDownloaded, SWIG_Callback6_t callbackOnAnchorUploadComplete) {
swig_callbackOnRoomAdded = callbackOnRoomAdded;
swig_callbackOnRoomClosed = callbackOnRoomClosed;
swig_callbackOnUserJoinedRoom = callbackOnUserJoinedRoom;
swig_callbackOnUserLeftRoom = callbackOnUserLeftRoom;
swig_callbackOnAnchorsChanged = callbackOnAnchorsChanged;
swig_callbackOnAnchorsDownloaded = callbackOnAnchorsDownloaded;
swig_callbackOnAnchorUploadComplete = callbackOnAnchorUploadComplete;
}
void SwigDirector_RoomManagerListener::swig_init_callbacks() {
swig_callbackOnRoomAdded = 0;
swig_callbackOnRoomClosed = 0;
swig_callbackOnUserJoinedRoom = 0;
swig_callbackOnUserLeftRoom = 0;
swig_callbackOnAnchorsChanged = 0;
swig_callbackOnAnchorsDownloaded = 0;
swig_callbackOnAnchorUploadComplete = 0;
}
SwigDirector_PairMaker::SwigDirector_PairMaker() : XTools::PairMaker(), Swig::Director() {
swig_init_callbacks();
}
SwigDirector_PairMaker::~SwigDirector_PairMaker() {
}
bool SwigDirector_PairMaker::IsReceiver() {
bool c_result = SwigValueInit< bool >() ;
unsigned int jresult = 0 ;
if (!swig_callbackIsReceiver) {
return XTools::PairMaker::IsReceiver();
} else {
jresult = (unsigned int) swig_callbackIsReceiver();
c_result = jresult ? true : false;
}
return c_result;
}
XTools::int32 SwigDirector_PairMaker::GetAddressCount() {
XTools::int32 c_result = SwigValueInit< XTools::int32 >() ;
int jresult = 0 ;
if (!swig_callbackGetAddressCount) {
throw Swig::DirectorPureVirtualException("XTools::PairMaker::GetAddressCount");
} else {
jresult = (int) swig_callbackGetAddressCount();
c_result = (XTools::int32)jresult;
}
return c_result;
}
XTools::XStringPtr SwigDirector_PairMaker::GetAddress(XTools::int32 index) {
XTools::XStringPtr c_result ;
void * jresult = 0 ;
int jindex ;
if (!swig_callbackGetAddress) {
return XTools::PairMaker::GetAddress(index);
} else {
jindex = index;
jresult = (void *) swig_callbackGetAddress(jindex);
if (!jresult) {
SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type XTools::XStringPtr", 0);
return c_result;
}
c_result = *(XTools::XStringPtr *)jresult;
}
return c_result;
}
XTools::uint16 SwigDirector_PairMaker::GetPort() {
XTools::uint16 c_result = SwigValueInit< XTools::uint16 >() ;
unsigned short jresult = 0 ;
if (!swig_callbackGetPort) {
return XTools::PairMaker::GetPort();
} else {
jresult = (unsigned short) swig_callbackGetPort();
c_result = (XTools::uint16)jresult;
}
return c_result;
}
void SwigDirector_PairMaker::Update() {
if (!swig_callbackUpdate) {
XTools::PairMaker::Update();
return;
} else {
swig_callbackUpdate();
}
}
bool SwigDirector_PairMaker::IsReadyToConnect() {
bool c_result = SwigValueInit< bool >() ;
unsigned int jresult = 0 ;
if (!swig_callbackIsReadyToConnect) {
return XTools::PairMaker::IsReadyToConnect();
} else {
jresult = (unsigned int) swig_callbackIsReadyToConnect();
c_result = jresult ? true : false;
}
return c_result;
}
XTools::int32 SwigDirector_PairMaker::GetLocalKey() {
XTools::int32 c_result = SwigValueInit< XTools::int32 >() ;
int jresult = 0 ;
if (!swig_callbackGetLocalKey) {
return XTools::PairMaker::GetLocalKey();
} else {
jresult = (int) swig_callbackGetLocalKey();
c_result = (XTools::int32)jresult;
}
return c_result;
}
XTools::int32 SwigDirector_PairMaker::GetRemoteKey() {
XTools::int32 c_result = SwigValueInit< XTools::int32 >() ;
int jresult = 0 ;
if (!swig_callbackGetRemoteKey) {
return XTools::PairMaker::GetRemoteKey();
} else {
jresult = (int) swig_callbackGetRemoteKey();
c_result = (XTools::int32)jresult;
}
return c_result;
}
void SwigDirector_PairMaker::swig_connect_director(SWIG_Callback0_t callbackIsReceiver, SWIG_Callback1_t callbackGetAddressCount, SWIG_Callback2_t callbackGetAddress, SWIG_Callback3_t callbackGetPort, SWIG_Callback4_t callbackUpdate, SWIG_Callback5_t callbackIsReadyToConnect, SWIG_Callback6_t callbackGetLocalKey, SWIG_Callback7_t callbackGetRemoteKey) {
swig_callbackIsReceiver = callbackIsReceiver;
swig_callbackGetAddressCount = callbackGetAddressCount;
swig_callbackGetAddress = callbackGetAddress;
swig_callbackGetPort = callbackGetPort;
swig_callbackUpdate = callbackUpdate;
swig_callbackIsReadyToConnect = callbackIsReadyToConnect;
swig_callbackGetLocalKey = callbackGetLocalKey;
swig_callbackGetRemoteKey = callbackGetRemoteKey;
}
void SwigDirector_PairMaker::swig_init_callbacks() {
swig_callbackIsReceiver = 0;
swig_callbackGetAddressCount = 0;
swig_callbackGetAddress = 0;
swig_callbackGetPort = 0;
swig_callbackUpdate = 0;
swig_callbackIsReadyToConnect = 0;
swig_callbackGetLocalKey = 0;
swig_callbackGetRemoteKey = 0;
}
SwigDirector_PairingListener::SwigDirector_PairingListener() : XTools::PairingListener(), Swig::Director() {
swig_init_callbacks();
}
SwigDirector_PairingListener::~SwigDirector_PairingListener() {
}
void SwigDirector_PairingListener::PairingConnectionSucceeded() {
if (!swig_callbackPairingConnectionSucceeded) {
XTools::PairingListener::PairingConnectionSucceeded();
return;
} else {
swig_callbackPairingConnectionSucceeded();
}
}
void SwigDirector_PairingListener::PairingConnectionFailed(XTools::PairingResult reason) {
int jreason ;
if (!swig_callbackPairingConnectionFailed) {
XTools::PairingListener::PairingConnectionFailed(reason);
return;
} else {
jreason = (int)reason;
swig_callbackPairingConnectionFailed(jreason);
}
}
void SwigDirector_PairingListener::swig_connect_director(SWIG_Callback0_t callbackPairingConnectionSucceeded, SWIG_Callback1_t callbackPairingConnectionFailed) {
swig_callbackPairingConnectionSucceeded = callbackPairingConnectionSucceeded;
swig_callbackPairingConnectionFailed = callbackPairingConnectionFailed;
}
void SwigDirector_PairingListener::swig_init_callbacks() {
swig_callbackPairingConnectionSucceeded = 0;
swig_callbackPairingConnectionFailed = 0;
}
SwigDirector_DiscoveryClientListener::SwigDirector_DiscoveryClientListener() : XTools::DiscoveryClientListener(), Swig::Director() {
swig_init_callbacks();
}
SwigDirector_DiscoveryClientListener::~SwigDirector_DiscoveryClientListener() {
}
void SwigDirector_DiscoveryClientListener::OnRemoteSystemDiscovered(XTools::DiscoveredSystemPtr const &remoteSystem) {
void * jremoteSystem = 0 ;
if (!swig_callbackOnRemoteSystemDiscovered) {
XTools::DiscoveryClientListener::OnRemoteSystemDiscovered(remoteSystem);
return;
} else {
// ref_ptr by reference directorin
if (remoteSystem) {
remoteSystem->AddRef();
}
jremoteSystem = (&remoteSystem)->get();
swig_callbackOnRemoteSystemDiscovered(jremoteSystem);
}
}
void SwigDirector_DiscoveryClientListener::OnRemoteSystemLost(XTools::DiscoveredSystemPtr const &remoteSystem) {
void * jremoteSystem = 0 ;
if (!swig_callbackOnRemoteSystemLost) {
XTools::DiscoveryClientListener::OnRemoteSystemLost(remoteSystem);
return;
} else {
// ref_ptr by reference directorin
if (remoteSystem) {
remoteSystem->AddRef();
}
jremoteSystem = (&remoteSystem)->get();
swig_callbackOnRemoteSystemLost(jremoteSystem);
}
}
void SwigDirector_DiscoveryClientListener::swig_connect_director(SWIG_Callback0_t callbackOnRemoteSystemDiscovered, SWIG_Callback1_t callbackOnRemoteSystemLost) {
swig_callbackOnRemoteSystemDiscovered = callbackOnRemoteSystemDiscovered;
swig_callbackOnRemoteSystemLost = callbackOnRemoteSystemLost;
}
void SwigDirector_DiscoveryClientListener::swig_init_callbacks() {
swig_callbackOnRemoteSystemDiscovered = 0;
swig_callbackOnRemoteSystemLost = 0;
}
#ifdef __cplusplus
extern "C" {
#endif
SWIGEXPORT unsigned long long SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_kInvalidSocketID_get___() {
unsigned long long jresult ;
XTools::SocketID result;
result = (XTools::SocketID)(XTools::SocketID)XTools::kInvalidSocketID;
jresult = result;
return jresult;
}
SWIGEXPORT unsigned long long SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_kInvalidConnectionGUID_get___() {
unsigned long long jresult ;
XTools::ConnectionGUID result;
result = (XTools::ConnectionGUID)(XTools::ConnectionGUID)XTools::kInvalidConnectionGUID;
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_Receipt___(void * jarg1) {
XTools::Receipt *arg1 = (XTools::Receipt *) 0 ;
arg1 = (XTools::Receipt *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Receipt_Clear___(void * jarg1) {
XTools::Receipt *arg1 = (XTools::Receipt *) 0 ;
arg1 = (XTools::Receipt *)jarg1;
(arg1)->Clear();
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_Receipt___() {
void * jresult ;
XTools::Receipt *result = 0 ;
result = (XTools::Receipt *)new XTools::Receipt();
jresult = (void *)result;
if(result) result->AddRef();
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_LogManager___(void * jarg1) {
XTools::LogManager *arg1 = (XTools::LogManager *) 0 ;
arg1 = (XTools::LogManager *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_LogManager_Log___(void * jarg1, int jarg2, char * jarg3) {
XTools::LogManager *arg1 = (XTools::LogManager *) 0 ;
XTools::LogSeverity arg2 ;
char *arg3 = (char *) 0 ;
arg1 = (XTools::LogManager *)jarg1;
arg2 = (XTools::LogSeverity)jarg2;
arg3 = (char *)jarg3;
(arg1)->Log(arg2,(char const *)arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_LogWriter___(void * jarg1) {
XTools::LogWriter *arg1 = (XTools::LogWriter *) 0 ;
arg1 = (XTools::LogWriter *)jarg1;
delete arg1;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_LogWriter_WriteLogEntry___(void * jarg1, int jarg2, char * jarg3) {
XTools::LogWriter *arg1 = (XTools::LogWriter *) 0 ;
XTools::LogSeverity arg2 ;
std::string *arg3 = 0 ;
arg1 = (XTools::LogWriter *)jarg1;
arg2 = (XTools::LogSeverity)jarg2;
if (!jarg3) {
SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
return ;
}
std::string arg3_str(jarg3);
arg3 = &arg3_str;
(arg1)->WriteLogEntry(arg2,(std::string const &)*arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_LogWriter_WriteLogEntrySwigExplicitLogWriter___(void * jarg1, int jarg2, char * jarg3) {
XTools::LogWriter *arg1 = (XTools::LogWriter *) 0 ;
XTools::LogSeverity arg2 ;
std::string *arg3 = 0 ;
arg1 = (XTools::LogWriter *)jarg1;
arg2 = (XTools::LogSeverity)jarg2;
if (!jarg3) {
SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
return ;
}
std::string arg3_str(jarg3);
arg3 = &arg3_str;
(arg1)->XTools::LogWriter::WriteLogEntry(arg2,(std::string const &)*arg3);
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_LogWriter___() {
void * jresult ;
XTools::LogWriter *result = 0 ;
result = (XTools::LogWriter *)new SwigDirector_LogWriter();
jresult = (void *)result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_LogWriter_director_connect___(void *objarg, SwigDirector_LogWriter::SWIG_Callback0_t callback0) {
XTools::LogWriter *obj = (XTools::LogWriter *)objarg;
SwigDirector_LogWriter *director = dynamic_cast<SwigDirector_LogWriter *>(obj);
if (director) {
director->swig_connect_director(callback0);
}
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Log_Info___(char * jarg1) {
char *arg1 = (char *) 0 ;
arg1 = (char *)jarg1;
XTools::Log::Info((char const *)arg1);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Log_Warning___(char * jarg1) {
char *arg1 = (char *) 0 ;
arg1 = (char *)jarg1;
XTools::Log::Warning((char const *)arg1);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Log_Error___(char * jarg1) {
char *arg1 = (char *) 0 ;
arg1 = (char *)jarg1;
XTools::Log::Error((char const *)arg1);
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_Log___() {
void * jresult ;
XTools::Log *result = 0 ;
result = (XTools::Log *)new XTools::Log();
jresult = (void *)result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_Log___(void * jarg1) {
XTools::Log *arg1 = (XTools::Log *) 0 ;
arg1 = (XTools::Log *)jarg1;
delete arg1;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_Listener___(void * jarg1) {
XTools::Listener *arg1 = (XTools::Listener *) 0 ;
arg1 = (XTools::Listener *)jarg1;
delete arg1;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Listener_UnregisterAll___(void * jarg1) {
XTools::Listener *arg1 = (XTools::Listener *) 0 ;
arg1 = (XTools::Listener *)jarg1;
(arg1)->UnregisterAll();
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Listener_IsRegistered___(void * jarg1) {
unsigned int jresult ;
XTools::Listener *arg1 = (XTools::Listener *) 0 ;
bool result;
arg1 = (XTools::Listener *)jarg1;
result = (bool)((XTools::Listener const *)arg1)->IsRegistered();
jresult = result;
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_Listener___() {
void * jresult ;
XTools::Listener *result = 0 ;
result = (XTools::Listener *)new XTools::Listener();
jresult = (void *)result;
return jresult;
}
SWIGEXPORT long long SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_kInvalidXGuid_get___() {
long long jresult ;
XTools::XGuid result;
result = (XTools::XGuid)(XTools::XGuid)XTools::kInvalidXGuid;
jresult = result;
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_XString__SWIG_0___() {
void * jresult ;
XTools::XString *result = 0 ;
result = (XTools::XString *)new XTools::XString();
jresult = (void *)result;
if(result) result->AddRef();
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_XString__SWIG_1___(char * jarg1) {
void * jresult ;
std::string *arg1 = 0 ;
XTools::XString *result = 0 ;
if (!jarg1) {
SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
return 0;
}
std::string arg1_str(jarg1);
arg1 = &arg1_str;
result = (XTools::XString *)new XTools::XString((std::string const &)*arg1);
jresult = (void *)result;
if(result) result->AddRef();
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_XString___(void * jarg1) {
XTools::XString *arg1 = (XTools::XString *) 0 ;
arg1 = (XTools::XString *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_XString_GetLength___(void * jarg1) {
unsigned int jresult ;
XTools::XString *arg1 = (XTools::XString *) 0 ;
XTools::uint32 result;
arg1 = (XTools::XString *)jarg1;
result = (XTools::uint32)((XTools::XString const *)arg1)->GetLength();
jresult = result;
return jresult;
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_XString_IsEqual___(void * jarg1, void * jarg2) {
unsigned int jresult ;
XTools::XString *arg1 = (XTools::XString *) 0 ;
XTools::ref_ptr< XTools::XString > *arg2 = 0 ;
XTools::ref_ptr< XTools::XString > tempnull2 ;
XTools::ref_ptr< XTools::XString > temp2 ;
XTools::XString *smartarg2 ;
bool result;
arg1 = (XTools::XString *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( XString **)&jarg2;
temp2 = XTools::ref_ptr< XString >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
result = (bool)((XTools::XString const *)arg1)->IsEqual((XTools::ref_ptr< XTools::XString > const &)*arg2);
jresult = result;
return jresult;
}
SWIGEXPORT char * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_XString_GetString___(void * jarg1) {
char * jresult ;
XTools::XString *arg1 = (XTools::XString *) 0 ;
std::string *result = 0 ;
arg1 = (XTools::XString *)jarg1;
result = (std::string *) &((XTools::XString const *)arg1)->GetString();
jresult = SWIG_csharp_string_callback(result->c_str());
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkOutMessage_Write__SWIG_0___(void * jarg1, unsigned char jarg2) {
XTools::NetworkOutMessage *arg1 = (XTools::NetworkOutMessage *) 0 ;
XTools::byte arg2 ;
arg1 = (XTools::NetworkOutMessage *)jarg1;
arg2 = (XTools::byte)jarg2;
(arg1)->Write(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkOutMessage_Write__SWIG_1___(void * jarg1, short jarg2) {
XTools::NetworkOutMessage *arg1 = (XTools::NetworkOutMessage *) 0 ;
XTools::int16 arg2 ;
arg1 = (XTools::NetworkOutMessage *)jarg1;
arg2 = (XTools::int16)jarg2;
(arg1)->Write(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkOutMessage_Write__SWIG_2___(void * jarg1, int jarg2) {
XTools::NetworkOutMessage *arg1 = (XTools::NetworkOutMessage *) 0 ;
XTools::int32 arg2 ;
arg1 = (XTools::NetworkOutMessage *)jarg1;
arg2 = (XTools::int32)jarg2;
(arg1)->Write(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkOutMessage_Write__SWIG_3___(void * jarg1, long long jarg2) {
XTools::NetworkOutMessage *arg1 = (XTools::NetworkOutMessage *) 0 ;
XTools::int64 arg2 ;
arg1 = (XTools::NetworkOutMessage *)jarg1;
arg2 = (XTools::int64)jarg2;
(arg1)->Write(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkOutMessage_Write__SWIG_4___(void * jarg1, float jarg2) {
XTools::NetworkOutMessage *arg1 = (XTools::NetworkOutMessage *) 0 ;
float arg2 ;
arg1 = (XTools::NetworkOutMessage *)jarg1;
arg2 = (float)jarg2;
(arg1)->Write(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkOutMessage_Write__SWIG_5___(void * jarg1, double jarg2) {
XTools::NetworkOutMessage *arg1 = (XTools::NetworkOutMessage *) 0 ;
double arg2 ;
arg1 = (XTools::NetworkOutMessage *)jarg1;
arg2 = (double)jarg2;
(arg1)->Write(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkOutMessage_Write__SWIG_6___(void * jarg1, void * jarg2) {
XTools::NetworkOutMessage *arg1 = (XTools::NetworkOutMessage *) 0 ;
XTools::XStringPtr *arg2 = 0 ;
XTools::XStringPtr tempnull2 ;
XTools::XStringPtr temp2 ;
XTools::XString *smartarg2 ;
arg1 = (XTools::NetworkOutMessage *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( XString **)&jarg2;
temp2 = XTools::ref_ptr< XString >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->Write((XTools::XStringPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkOutMessage_WriteArray___(void * jarg1, unsigned char* jarg2, unsigned int jarg3) {
XTools::NetworkOutMessage *arg1 = (XTools::NetworkOutMessage *) 0 ;
XTools::byte *arg2 = (XTools::byte *) 0 ;
XTools::uint32 arg3 ;
arg1 = (XTools::NetworkOutMessage *)jarg1;
arg2 = jarg2;
arg3 = (XTools::uint32)jarg3;
(arg1)->WriteArray((XTools::byte const *)arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkOutMessage_Reset___(void * jarg1) {
XTools::NetworkOutMessage *arg1 = (XTools::NetworkOutMessage *) 0 ;
arg1 = (XTools::NetworkOutMessage *)jarg1;
(arg1)->Reset();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_NetworkOutMessage___(void * jarg1) {
XTools::NetworkOutMessage *arg1 = (XTools::NetworkOutMessage *) 0 ;
arg1 = (XTools::NetworkOutMessage *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_NetworkInMessage___(void * jarg1) {
XTools::NetworkInMessage *arg1 = (XTools::NetworkInMessage *) 0 ;
arg1 = (XTools::NetworkInMessage *)jarg1;
delete arg1;
}
SWIGEXPORT unsigned char SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkInMessage_ReadByte___(void * jarg1) {
unsigned char jresult ;
XTools::NetworkInMessage *arg1 = (XTools::NetworkInMessage *) 0 ;
XTools::byte result;
arg1 = (XTools::NetworkInMessage *)jarg1;
result = (XTools::byte)(arg1)->ReadByte();
jresult = result;
return jresult;
}
SWIGEXPORT short SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkInMessage_ReadInt16___(void * jarg1) {
short jresult ;
XTools::NetworkInMessage *arg1 = (XTools::NetworkInMessage *) 0 ;
XTools::int16 result;
arg1 = (XTools::NetworkInMessage *)jarg1;
result = (XTools::int16)(arg1)->ReadInt16();
jresult = result;
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkInMessage_ReadInt32___(void * jarg1) {
int jresult ;
XTools::NetworkInMessage *arg1 = (XTools::NetworkInMessage *) 0 ;
XTools::int32 result;
arg1 = (XTools::NetworkInMessage *)jarg1;
result = (XTools::int32)(arg1)->ReadInt32();
jresult = result;
return jresult;
}
SWIGEXPORT long long SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkInMessage_ReadInt64___(void * jarg1) {
long long jresult ;
XTools::NetworkInMessage *arg1 = (XTools::NetworkInMessage *) 0 ;
XTools::int64 result;
arg1 = (XTools::NetworkInMessage *)jarg1;
result = (XTools::int64)(arg1)->ReadInt64();
jresult = result;
return jresult;
}
SWIGEXPORT float SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkInMessage_ReadFloat___(void * jarg1) {
float jresult ;
XTools::NetworkInMessage *arg1 = (XTools::NetworkInMessage *) 0 ;
float result;
arg1 = (XTools::NetworkInMessage *)jarg1;
result = (float)(arg1)->ReadFloat();
jresult = result;
return jresult;
}
SWIGEXPORT double SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkInMessage_ReadDouble___(void * jarg1) {
double jresult ;
XTools::NetworkInMessage *arg1 = (XTools::NetworkInMessage *) 0 ;
double result;
arg1 = (XTools::NetworkInMessage *)jarg1;
result = (double)(arg1)->ReadDouble();
jresult = result;
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkInMessage_ReadString___(void * jarg1) {
void * jresult ;
XTools::NetworkInMessage *arg1 = (XTools::NetworkInMessage *) 0 ;
XTools::XStringPtr result;
arg1 = (XTools::NetworkInMessage *)jarg1;
result = (arg1)->ReadString();
// ref_ptr by value out
if (result) {
result->AddRef();
*( XString **)&jresult = (&result)->get();
} else {
*( XString **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkInMessage_ReadArray___(void * jarg1, unsigned char* jarg2, unsigned int jarg3) {
XTools::NetworkInMessage *arg1 = (XTools::NetworkInMessage *) 0 ;
XTools::byte *arg2 = (XTools::byte *) 0 ;
XTools::uint32 arg3 ;
arg1 = (XTools::NetworkInMessage *)jarg1;
arg2 = jarg2;
arg3 = (XTools::uint32)jarg3;
(arg1)->ReadArray(arg2,arg3);
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkInMessage_GetUnreadBitsCount___(void * jarg1) {
int jresult ;
XTools::NetworkInMessage *arg1 = (XTools::NetworkInMessage *) 0 ;
XTools::int32 result;
arg1 = (XTools::NetworkInMessage *)jarg1;
result = (XTools::int32)((XTools::NetworkInMessage const *)arg1)->GetUnreadBitsCount();
jresult = result;
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkInMessage_GetSize___(void * jarg1) {
int jresult ;
XTools::NetworkInMessage *arg1 = (XTools::NetworkInMessage *) 0 ;
XTools::int32 result;
arg1 = (XTools::NetworkInMessage *)jarg1;
result = (XTools::int32)((XTools::NetworkInMessage const *)arg1)->GetSize();
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_NetworkConnectionListener___(void * jarg1) {
XTools::NetworkConnectionListener *arg1 = (XTools::NetworkConnectionListener *) 0 ;
arg1 = (XTools::NetworkConnectionListener *)jarg1;
delete arg1;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnectionListener_OnConnected___(void * jarg1, void * jarg2) {
XTools::NetworkConnectionListener *arg1 = (XTools::NetworkConnectionListener *) 0 ;
XTools::NetworkConnectionPtr *arg2 = 0 ;
XTools::NetworkConnectionPtr tempnull2 ;
XTools::NetworkConnectionPtr temp2 ;
XTools::NetworkConnection *smartarg2 ;
arg1 = (XTools::NetworkConnectionListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( NetworkConnection **)&jarg2;
temp2 = XTools::ref_ptr< NetworkConnection >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->OnConnected((XTools::NetworkConnectionPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnectionListener_OnConnectedSwigExplicitNetworkConnectionListener___(void * jarg1, void * jarg2) {
XTools::NetworkConnectionListener *arg1 = (XTools::NetworkConnectionListener *) 0 ;
XTools::NetworkConnectionPtr *arg2 = 0 ;
XTools::NetworkConnectionPtr tempnull2 ;
XTools::NetworkConnectionPtr temp2 ;
XTools::NetworkConnection *smartarg2 ;
arg1 = (XTools::NetworkConnectionListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( NetworkConnection **)&jarg2;
temp2 = XTools::ref_ptr< NetworkConnection >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->XTools::NetworkConnectionListener::OnConnected((XTools::NetworkConnectionPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnectionListener_OnConnectFailed___(void * jarg1, void * jarg2) {
XTools::NetworkConnectionListener *arg1 = (XTools::NetworkConnectionListener *) 0 ;
XTools::NetworkConnectionPtr *arg2 = 0 ;
XTools::NetworkConnectionPtr tempnull2 ;
XTools::NetworkConnectionPtr temp2 ;
XTools::NetworkConnection *smartarg2 ;
arg1 = (XTools::NetworkConnectionListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( NetworkConnection **)&jarg2;
temp2 = XTools::ref_ptr< NetworkConnection >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->OnConnectFailed((XTools::NetworkConnectionPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnectionListener_OnConnectFailedSwigExplicitNetworkConnectionListener___(void * jarg1, void * jarg2) {
XTools::NetworkConnectionListener *arg1 = (XTools::NetworkConnectionListener *) 0 ;
XTools::NetworkConnectionPtr *arg2 = 0 ;
XTools::NetworkConnectionPtr tempnull2 ;
XTools::NetworkConnectionPtr temp2 ;
XTools::NetworkConnection *smartarg2 ;
arg1 = (XTools::NetworkConnectionListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( NetworkConnection **)&jarg2;
temp2 = XTools::ref_ptr< NetworkConnection >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->XTools::NetworkConnectionListener::OnConnectFailed((XTools::NetworkConnectionPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnectionListener_OnDisconnected___(void * jarg1, void * jarg2) {
XTools::NetworkConnectionListener *arg1 = (XTools::NetworkConnectionListener *) 0 ;
XTools::NetworkConnectionPtr *arg2 = 0 ;
XTools::NetworkConnectionPtr tempnull2 ;
XTools::NetworkConnectionPtr temp2 ;
XTools::NetworkConnection *smartarg2 ;
arg1 = (XTools::NetworkConnectionListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( NetworkConnection **)&jarg2;
temp2 = XTools::ref_ptr< NetworkConnection >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->OnDisconnected((XTools::NetworkConnectionPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnectionListener_OnDisconnectedSwigExplicitNetworkConnectionListener___(void * jarg1, void * jarg2) {
XTools::NetworkConnectionListener *arg1 = (XTools::NetworkConnectionListener *) 0 ;
XTools::NetworkConnectionPtr *arg2 = 0 ;
XTools::NetworkConnectionPtr tempnull2 ;
XTools::NetworkConnectionPtr temp2 ;
XTools::NetworkConnection *smartarg2 ;
arg1 = (XTools::NetworkConnectionListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( NetworkConnection **)&jarg2;
temp2 = XTools::ref_ptr< NetworkConnection >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->XTools::NetworkConnectionListener::OnDisconnected((XTools::NetworkConnectionPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnectionListener_OnMessageReceived___(void * jarg1, void * jarg2, void * jarg3) {
XTools::NetworkConnectionListener *arg1 = (XTools::NetworkConnectionListener *) 0 ;
XTools::NetworkConnectionPtr *arg2 = 0 ;
XTools::NetworkInMessage *arg3 = 0 ;
XTools::NetworkConnectionPtr tempnull2 ;
XTools::NetworkConnectionPtr temp2 ;
XTools::NetworkConnection *smartarg2 ;
arg1 = (XTools::NetworkConnectionListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( NetworkConnection **)&jarg2;
temp2 = XTools::ref_ptr< NetworkConnection >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (XTools::NetworkInMessage *)jarg3;
if (!arg3) {
SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XTools::NetworkInMessage & type is null", 0);
return ;
}
(arg1)->OnMessageReceived((XTools::NetworkConnectionPtr const &)*arg2,*arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnectionListener_OnMessageReceivedSwigExplicitNetworkConnectionListener___(void * jarg1, void * jarg2, void * jarg3) {
XTools::NetworkConnectionListener *arg1 = (XTools::NetworkConnectionListener *) 0 ;
XTools::NetworkConnectionPtr *arg2 = 0 ;
XTools::NetworkInMessage *arg3 = 0 ;
XTools::NetworkConnectionPtr tempnull2 ;
XTools::NetworkConnectionPtr temp2 ;
XTools::NetworkConnection *smartarg2 ;
arg1 = (XTools::NetworkConnectionListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( NetworkConnection **)&jarg2;
temp2 = XTools::ref_ptr< NetworkConnection >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (XTools::NetworkInMessage *)jarg3;
if (!arg3) {
SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "XTools::NetworkInMessage & type is null", 0);
return ;
}
(arg1)->XTools::NetworkConnectionListener::OnMessageReceived((XTools::NetworkConnectionPtr const &)*arg2,*arg3);
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_NetworkConnectionListener___() {
void * jresult ;
XTools::NetworkConnectionListener *result = 0 ;
result = (XTools::NetworkConnectionListener *)new SwigDirector_NetworkConnectionListener();
jresult = (void *)result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnectionListener_director_connect___(void *objarg, SwigDirector_NetworkConnectionListener::SWIG_Callback0_t callback0, SwigDirector_NetworkConnectionListener::SWIG_Callback1_t callback1, SwigDirector_NetworkConnectionListener::SWIG_Callback2_t callback2, SwigDirector_NetworkConnectionListener::SWIG_Callback3_t callback3) {
XTools::NetworkConnectionListener *obj = (XTools::NetworkConnectionListener *)objarg;
SwigDirector_NetworkConnectionListener *director = dynamic_cast<SwigDirector_NetworkConnectionListener *>(obj);
if (director) {
director->swig_connect_director(callback0, callback1, callback2, callback3);
}
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_User_GetName___(void * jarg1) {
void * jresult ;
XTools::User *arg1 = (XTools::User *) 0 ;
XTools::XStringPtr *result = 0 ;
arg1 = (XTools::User *)jarg1;
result = (XTools::XStringPtr *) &((XTools::User const *)arg1)->GetName();
// ref_ptr by reference out
if (*result) {
result->get()->AddRef();
*( XString **)&jresult = result->get();
} else {
*( XString **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_User_GetID___(void * jarg1) {
int jresult ;
XTools::User *arg1 = (XTools::User *) 0 ;
XTools::UserID result;
arg1 = (XTools::User *)jarg1;
result = (XTools::UserID)((XTools::User const *)arg1)->GetID();
jresult = result;
return jresult;
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_User_IsValid___(void * jarg1) {
unsigned int jresult ;
XTools::User *arg1 = (XTools::User *) 0 ;
bool result;
arg1 = (XTools::User *)jarg1;
result = (bool)((XTools::User const *)arg1)->IsValid();
jresult = result;
return jresult;
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_User_GetMuteState___(void * jarg1) {
unsigned int jresult ;
XTools::User *arg1 = (XTools::User *) 0 ;
bool result;
arg1 = (XTools::User *)jarg1;
result = (bool)((XTools::User const *)arg1)->GetMuteState();
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_User___(void * jarg1) {
XTools::User *arg1 = (XTools::User *) 0 ;
arg1 = (XTools::User *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnection_IsConnected___(void * jarg1) {
unsigned int jresult ;
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
bool result;
arg1 = (XTools::NetworkConnection *)jarg1;
result = (bool)((XTools::NetworkConnection const *)arg1)->IsConnected();
jresult = result;
return jresult;
}
SWIGEXPORT unsigned long long SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnection_GetConnectionGUID___(void * jarg1) {
unsigned long long jresult ;
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
XTools::ConnectionGUID result;
arg1 = (XTools::NetworkConnection *)jarg1;
result = (XTools::ConnectionGUID)((XTools::NetworkConnection const *)arg1)->GetConnectionGUID();
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnection_Send__SWIG_0___(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, unsigned int jarg6) {
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
XTools::NetworkOutMessagePtr *arg2 = 0 ;
XTools::MessagePriority arg3 ;
XTools::MessageReliability arg4 ;
XTools::MessageChannel arg5 ;
bool arg6 ;
XTools::NetworkOutMessagePtr tempnull2 ;
XTools::NetworkOutMessagePtr temp2 ;
XTools::NetworkOutMessage *smartarg2 ;
arg1 = (XTools::NetworkConnection *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( NetworkOutMessage **)&jarg2;
temp2 = XTools::ref_ptr< NetworkOutMessage >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (XTools::MessagePriority)jarg3;
arg4 = (XTools::MessageReliability)jarg4;
arg5 = (XTools::MessageChannel)jarg5;
arg6 = jarg6 ? true : false;
(arg1)->Send((XTools::NetworkOutMessagePtr const &)*arg2,arg3,arg4,arg5,arg6);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnection_Send__SWIG_1___(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5) {
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
XTools::NetworkOutMessagePtr *arg2 = 0 ;
XTools::MessagePriority arg3 ;
XTools::MessageReliability arg4 ;
XTools::MessageChannel arg5 ;
XTools::NetworkOutMessagePtr tempnull2 ;
XTools::NetworkOutMessagePtr temp2 ;
XTools::NetworkOutMessage *smartarg2 ;
arg1 = (XTools::NetworkConnection *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( NetworkOutMessage **)&jarg2;
temp2 = XTools::ref_ptr< NetworkOutMessage >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (XTools::MessagePriority)jarg3;
arg4 = (XTools::MessageReliability)jarg4;
arg5 = (XTools::MessageChannel)jarg5;
(arg1)->Send((XTools::NetworkOutMessagePtr const &)*arg2,arg3,arg4,arg5);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnection_Send__SWIG_2___(void * jarg1, void * jarg2, int jarg3, int jarg4) {
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
XTools::NetworkOutMessagePtr *arg2 = 0 ;
XTools::MessagePriority arg3 ;
XTools::MessageReliability arg4 ;
XTools::NetworkOutMessagePtr tempnull2 ;
XTools::NetworkOutMessagePtr temp2 ;
XTools::NetworkOutMessage *smartarg2 ;
arg1 = (XTools::NetworkConnection *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( NetworkOutMessage **)&jarg2;
temp2 = XTools::ref_ptr< NetworkOutMessage >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (XTools::MessagePriority)jarg3;
arg4 = (XTools::MessageReliability)jarg4;
(arg1)->Send((XTools::NetworkOutMessagePtr const &)*arg2,arg3,arg4);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnection_Send__SWIG_3___(void * jarg1, void * jarg2, int jarg3) {
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
XTools::NetworkOutMessagePtr *arg2 = 0 ;
XTools::MessagePriority arg3 ;
XTools::NetworkOutMessagePtr tempnull2 ;
XTools::NetworkOutMessagePtr temp2 ;
XTools::NetworkOutMessage *smartarg2 ;
arg1 = (XTools::NetworkConnection *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( NetworkOutMessage **)&jarg2;
temp2 = XTools::ref_ptr< NetworkOutMessage >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (XTools::MessagePriority)jarg3;
(arg1)->Send((XTools::NetworkOutMessagePtr const &)*arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnection_Send__SWIG_4___(void * jarg1, void * jarg2) {
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
XTools::NetworkOutMessagePtr *arg2 = 0 ;
XTools::NetworkOutMessagePtr tempnull2 ;
XTools::NetworkOutMessagePtr temp2 ;
XTools::NetworkOutMessage *smartarg2 ;
arg1 = (XTools::NetworkConnection *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( NetworkOutMessage **)&jarg2;
temp2 = XTools::ref_ptr< NetworkOutMessage >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->Send((XTools::NetworkOutMessagePtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnection_SendTo__SWIG_0___(void * jarg1, void * jarg2, int jarg3, void * jarg4, int jarg5, int jarg6, int jarg7, unsigned int jarg8) {
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
XTools::UserPtr *arg2 = 0 ;
XTools::ClientRole arg3 ;
XTools::NetworkOutMessagePtr *arg4 = 0 ;
XTools::MessagePriority arg5 ;
XTools::MessageReliability arg6 ;
XTools::MessageChannel arg7 ;
bool arg8 ;
XTools::UserPtr tempnull2 ;
XTools::UserPtr temp2 ;
XTools::User *smartarg2 ;
XTools::NetworkOutMessagePtr tempnull4 ;
XTools::NetworkOutMessagePtr temp4 ;
XTools::NetworkOutMessage *smartarg4 ;
arg1 = (XTools::NetworkConnection *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( User **)&jarg2;
temp2 = XTools::ref_ptr< User >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (XTools::ClientRole)jarg3;
// ref_ptr by reference in
if ( jarg4 ) {
smartarg4 = *( NetworkOutMessage **)&jarg4;
temp4 = XTools::ref_ptr< NetworkOutMessage >(smartarg4);
arg4 = &temp4;
} else {
arg4 = &tempnull4;
}
arg5 = (XTools::MessagePriority)jarg5;
arg6 = (XTools::MessageReliability)jarg6;
arg7 = (XTools::MessageChannel)jarg7;
arg8 = jarg8 ? true : false;
(arg1)->SendTo((XTools::UserPtr const &)*arg2,arg3,(XTools::NetworkOutMessagePtr const &)*arg4,arg5,arg6,arg7,arg8);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnection_SendTo__SWIG_1___(void * jarg1, void * jarg2, int jarg3, void * jarg4, int jarg5, int jarg6, int jarg7) {
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
XTools::UserPtr *arg2 = 0 ;
XTools::ClientRole arg3 ;
XTools::NetworkOutMessagePtr *arg4 = 0 ;
XTools::MessagePriority arg5 ;
XTools::MessageReliability arg6 ;
XTools::MessageChannel arg7 ;
XTools::UserPtr tempnull2 ;
XTools::UserPtr temp2 ;
XTools::User *smartarg2 ;
XTools::NetworkOutMessagePtr tempnull4 ;
XTools::NetworkOutMessagePtr temp4 ;
XTools::NetworkOutMessage *smartarg4 ;
arg1 = (XTools::NetworkConnection *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( User **)&jarg2;
temp2 = XTools::ref_ptr< User >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (XTools::ClientRole)jarg3;
// ref_ptr by reference in
if ( jarg4 ) {
smartarg4 = *( NetworkOutMessage **)&jarg4;
temp4 = XTools::ref_ptr< NetworkOutMessage >(smartarg4);
arg4 = &temp4;
} else {
arg4 = &tempnull4;
}
arg5 = (XTools::MessagePriority)jarg5;
arg6 = (XTools::MessageReliability)jarg6;
arg7 = (XTools::MessageChannel)jarg7;
(arg1)->SendTo((XTools::UserPtr const &)*arg2,arg3,(XTools::NetworkOutMessagePtr const &)*arg4,arg5,arg6,arg7);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnection_SendTo__SWIG_2___(void * jarg1, void * jarg2, int jarg3, void * jarg4, int jarg5, int jarg6) {
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
XTools::UserPtr *arg2 = 0 ;
XTools::ClientRole arg3 ;
XTools::NetworkOutMessagePtr *arg4 = 0 ;
XTools::MessagePriority arg5 ;
XTools::MessageReliability arg6 ;
XTools::UserPtr tempnull2 ;
XTools::UserPtr temp2 ;
XTools::User *smartarg2 ;
XTools::NetworkOutMessagePtr tempnull4 ;
XTools::NetworkOutMessagePtr temp4 ;
XTools::NetworkOutMessage *smartarg4 ;
arg1 = (XTools::NetworkConnection *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( User **)&jarg2;
temp2 = XTools::ref_ptr< User >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (XTools::ClientRole)jarg3;
// ref_ptr by reference in
if ( jarg4 ) {
smartarg4 = *( NetworkOutMessage **)&jarg4;
temp4 = XTools::ref_ptr< NetworkOutMessage >(smartarg4);
arg4 = &temp4;
} else {
arg4 = &tempnull4;
}
arg5 = (XTools::MessagePriority)jarg5;
arg6 = (XTools::MessageReliability)jarg6;
(arg1)->SendTo((XTools::UserPtr const &)*arg2,arg3,(XTools::NetworkOutMessagePtr const &)*arg4,arg5,arg6);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnection_SendTo__SWIG_3___(void * jarg1, void * jarg2, int jarg3, void * jarg4, int jarg5) {
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
XTools::UserPtr *arg2 = 0 ;
XTools::ClientRole arg3 ;
XTools::NetworkOutMessagePtr *arg4 = 0 ;
XTools::MessagePriority arg5 ;
XTools::UserPtr tempnull2 ;
XTools::UserPtr temp2 ;
XTools::User *smartarg2 ;
XTools::NetworkOutMessagePtr tempnull4 ;
XTools::NetworkOutMessagePtr temp4 ;
XTools::NetworkOutMessage *smartarg4 ;
arg1 = (XTools::NetworkConnection *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( User **)&jarg2;
temp2 = XTools::ref_ptr< User >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (XTools::ClientRole)jarg3;
// ref_ptr by reference in
if ( jarg4 ) {
smartarg4 = *( NetworkOutMessage **)&jarg4;
temp4 = XTools::ref_ptr< NetworkOutMessage >(smartarg4);
arg4 = &temp4;
} else {
arg4 = &tempnull4;
}
arg5 = (XTools::MessagePriority)jarg5;
(arg1)->SendTo((XTools::UserPtr const &)*arg2,arg3,(XTools::NetworkOutMessagePtr const &)*arg4,arg5);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnection_SendTo__SWIG_4___(void * jarg1, void * jarg2, int jarg3, void * jarg4) {
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
XTools::UserPtr *arg2 = 0 ;
XTools::ClientRole arg3 ;
XTools::NetworkOutMessagePtr *arg4 = 0 ;
XTools::UserPtr tempnull2 ;
XTools::UserPtr temp2 ;
XTools::User *smartarg2 ;
XTools::NetworkOutMessagePtr tempnull4 ;
XTools::NetworkOutMessagePtr temp4 ;
XTools::NetworkOutMessage *smartarg4 ;
arg1 = (XTools::NetworkConnection *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( User **)&jarg2;
temp2 = XTools::ref_ptr< User >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (XTools::ClientRole)jarg3;
// ref_ptr by reference in
if ( jarg4 ) {
smartarg4 = *( NetworkOutMessage **)&jarg4;
temp4 = XTools::ref_ptr< NetworkOutMessage >(smartarg4);
arg4 = &temp4;
} else {
arg4 = &tempnull4;
}
(arg1)->SendTo((XTools::UserPtr const &)*arg2,arg3,(XTools::NetworkOutMessagePtr const &)*arg4);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnection_Broadcast__SWIG_0___(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, unsigned int jarg6) {
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
XTools::NetworkOutMessagePtr *arg2 = 0 ;
XTools::MessagePriority arg3 ;
XTools::MessageReliability arg4 ;
XTools::MessageChannel arg5 ;
bool arg6 ;
XTools::NetworkOutMessagePtr tempnull2 ;
XTools::NetworkOutMessagePtr temp2 ;
XTools::NetworkOutMessage *smartarg2 ;
arg1 = (XTools::NetworkConnection *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( NetworkOutMessage **)&jarg2;
temp2 = XTools::ref_ptr< NetworkOutMessage >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (XTools::MessagePriority)jarg3;
arg4 = (XTools::MessageReliability)jarg4;
arg5 = (XTools::MessageChannel)jarg5;
arg6 = jarg6 ? true : false;
(arg1)->Broadcast((XTools::NetworkOutMessagePtr const &)*arg2,arg3,arg4,arg5,arg6);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnection_Broadcast__SWIG_1___(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5) {
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
XTools::NetworkOutMessagePtr *arg2 = 0 ;
XTools::MessagePriority arg3 ;
XTools::MessageReliability arg4 ;
XTools::MessageChannel arg5 ;
XTools::NetworkOutMessagePtr tempnull2 ;
XTools::NetworkOutMessagePtr temp2 ;
XTools::NetworkOutMessage *smartarg2 ;
arg1 = (XTools::NetworkConnection *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( NetworkOutMessage **)&jarg2;
temp2 = XTools::ref_ptr< NetworkOutMessage >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (XTools::MessagePriority)jarg3;
arg4 = (XTools::MessageReliability)jarg4;
arg5 = (XTools::MessageChannel)jarg5;
(arg1)->Broadcast((XTools::NetworkOutMessagePtr const &)*arg2,arg3,arg4,arg5);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnection_Broadcast__SWIG_2___(void * jarg1, void * jarg2, int jarg3, int jarg4) {
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
XTools::NetworkOutMessagePtr *arg2 = 0 ;
XTools::MessagePriority arg3 ;
XTools::MessageReliability arg4 ;
XTools::NetworkOutMessagePtr tempnull2 ;
XTools::NetworkOutMessagePtr temp2 ;
XTools::NetworkOutMessage *smartarg2 ;
arg1 = (XTools::NetworkConnection *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( NetworkOutMessage **)&jarg2;
temp2 = XTools::ref_ptr< NetworkOutMessage >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (XTools::MessagePriority)jarg3;
arg4 = (XTools::MessageReliability)jarg4;
(arg1)->Broadcast((XTools::NetworkOutMessagePtr const &)*arg2,arg3,arg4);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnection_Broadcast__SWIG_3___(void * jarg1, void * jarg2, int jarg3) {
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
XTools::NetworkOutMessagePtr *arg2 = 0 ;
XTools::MessagePriority arg3 ;
XTools::NetworkOutMessagePtr tempnull2 ;
XTools::NetworkOutMessagePtr temp2 ;
XTools::NetworkOutMessage *smartarg2 ;
arg1 = (XTools::NetworkConnection *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( NetworkOutMessage **)&jarg2;
temp2 = XTools::ref_ptr< NetworkOutMessage >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (XTools::MessagePriority)jarg3;
(arg1)->Broadcast((XTools::NetworkOutMessagePtr const &)*arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnection_Broadcast__SWIG_4___(void * jarg1, void * jarg2) {
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
XTools::NetworkOutMessagePtr *arg2 = 0 ;
XTools::NetworkOutMessagePtr tempnull2 ;
XTools::NetworkOutMessagePtr temp2 ;
XTools::NetworkOutMessage *smartarg2 ;
arg1 = (XTools::NetworkConnection *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( NetworkOutMessage **)&jarg2;
temp2 = XTools::ref_ptr< NetworkOutMessage >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->Broadcast((XTools::NetworkOutMessagePtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnection_AddListener___(void * jarg1, unsigned char jarg2, void * jarg3) {
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
XTools::byte arg2 ;
XTools::NetworkConnectionListener *arg3 = (XTools::NetworkConnectionListener *) 0 ;
arg1 = (XTools::NetworkConnection *)jarg1;
arg2 = (XTools::byte)jarg2;
arg3 = (XTools::NetworkConnectionListener *)jarg3;
(arg1)->AddListener(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnection_RemoveListener___(void * jarg1, unsigned char jarg2, void * jarg3) {
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
XTools::byte arg2 ;
XTools::NetworkConnectionListener *arg3 = (XTools::NetworkConnectionListener *) 0 ;
arg1 = (XTools::NetworkConnection *)jarg1;
arg2 = (XTools::byte)jarg2;
arg3 = (XTools::NetworkConnectionListener *)jarg3;
(arg1)->RemoveListener(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnection_AddListenerAsync___(void * jarg1, unsigned char jarg2, void * jarg3) {
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
XTools::byte arg2 ;
XTools::NetworkConnectionListener *arg3 = (XTools::NetworkConnectionListener *) 0 ;
arg1 = (XTools::NetworkConnection *)jarg1;
arg2 = (XTools::byte)jarg2;
arg3 = (XTools::NetworkConnectionListener *)jarg3;
(arg1)->AddListenerAsync(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnection_RemoveListenerAsync___(void * jarg1, unsigned char jarg2, void * jarg3) {
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
XTools::byte arg2 ;
XTools::NetworkConnectionListener *arg3 = (XTools::NetworkConnectionListener *) 0 ;
arg1 = (XTools::NetworkConnection *)jarg1;
arg2 = (XTools::byte)jarg2;
arg3 = (XTools::NetworkConnectionListener *)jarg3;
(arg1)->RemoveListenerAsync(arg2,arg3);
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnection_CreateMessage___(void * jarg1, unsigned char jarg2) {
void * jresult ;
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
XTools::byte arg2 ;
XTools::NetworkOutMessagePtr result;
arg1 = (XTools::NetworkConnection *)jarg1;
arg2 = (XTools::byte)jarg2;
result = (arg1)->CreateMessage(arg2);
// ref_ptr by value out
if (result) {
result->AddRef();
*( NetworkOutMessage **)&jresult = (&result)->get();
} else {
*( NetworkOutMessage **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnection_ReturnMessage___(void * jarg1, void * jarg2) {
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
XTools::NetworkOutMessagePtr *arg2 = 0 ;
XTools::NetworkOutMessagePtr tempnull2 ;
XTools::NetworkOutMessagePtr temp2 ;
XTools::NetworkOutMessage *smartarg2 ;
arg1 = (XTools::NetworkConnection *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( NetworkOutMessage **)&jarg2;
temp2 = XTools::ref_ptr< NetworkOutMessage >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->ReturnMessage((XTools::NetworkOutMessagePtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnection_Disconnect___(void * jarg1) {
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
arg1 = (XTools::NetworkConnection *)jarg1;
(arg1)->Disconnect();
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnection_GetRemoteAddress___(void * jarg1) {
void * jresult ;
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
XTools::XStringPtr result;
arg1 = (XTools::NetworkConnection *)jarg1;
result = ((XTools::NetworkConnection const *)arg1)->GetRemoteAddress();
// ref_ptr by value out
if (result) {
result->AddRef();
*( XString **)&jresult = (&result)->get();
} else {
*( XString **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_NetworkConnection___(void * jarg1) {
XTools::NetworkConnection *arg1 = (XTools::NetworkConnection *) 0 ;
arg1 = (XTools::NetworkConnection *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Element_GetElementType___(void * jarg1) {
int jresult ;
XTools::Element *arg1 = (XTools::Element *) 0 ;
XTools::ElementType result;
arg1 = (XTools::Element *)jarg1;
result = (XTools::ElementType)((XTools::Element const *)arg1)->GetElementType();
jresult = (int)result;
return jresult;
}
SWIGEXPORT long long SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Element_GetGUID___(void * jarg1) {
long long jresult ;
XTools::Element *arg1 = (XTools::Element *) 0 ;
XTools::XGuid result;
arg1 = (XTools::Element *)jarg1;
result = (XTools::XGuid)((XTools::Element const *)arg1)->GetGUID();
jresult = result;
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Element_GetName___(void * jarg1) {
void * jresult ;
XTools::Element *arg1 = (XTools::Element *) 0 ;
XTools::XStringPtr *result = 0 ;
arg1 = (XTools::Element *)jarg1;
result = (XTools::XStringPtr *) &((XTools::Element const *)arg1)->GetName();
// ref_ptr by reference out
if (*result) {
result->get()->AddRef();
*( XString **)&jresult = result->get();
} else {
*( XString **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Element_GetParent___(void * jarg1) {
void * jresult ;
XTools::Element *arg1 = (XTools::Element *) 0 ;
XTools::ref_ptr< XTools::Element > result;
arg1 = (XTools::Element *)jarg1;
result = ((XTools::Element const *)arg1)->GetParent();
// ref_ptr by value out
if (result) {
result->AddRef();
*( Element **)&jresult = (&result)->get();
} else {
*( Element **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Element_IsValid___(void * jarg1) {
unsigned int jresult ;
XTools::Element *arg1 = (XTools::Element *) 0 ;
bool result;
arg1 = (XTools::Element *)jarg1;
result = (bool)((XTools::Element const *)arg1)->IsValid();
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_Element___(void * jarg1) {
XTools::Element *arg1 = (XTools::Element *) 0 ;
arg1 = (XTools::Element *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_BoolElement_Cast___(void * jarg1) {
void * jresult ;
XTools::ElementPtr *arg1 = 0 ;
XTools::ElementPtr tempnull1 ;
XTools::ElementPtr temp1 ;
XTools::Element *smartarg1 ;
XTools::ref_ptr< XTools::BoolElement > result;
// ref_ptr by reference in
if ( jarg1 ) {
smartarg1 = *( Element **)&jarg1;
temp1 = XTools::ref_ptr< Element >(smartarg1);
arg1 = &temp1;
} else {
arg1 = &tempnull1;
}
result = XTools::BoolElement::Cast((XTools::ref_ptr< XTools::Element > const &)*arg1);
// ref_ptr by value out
if (result) {
result->AddRef();
*( BoolElement **)&jresult = (&result)->get();
} else {
*( BoolElement **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_BoolElement_GetValue___(void * jarg1) {
unsigned int jresult ;
XTools::BoolElement *arg1 = (XTools::BoolElement *) 0 ;
bool result;
arg1 = (XTools::BoolElement *)jarg1;
result = (bool)((XTools::BoolElement const *)arg1)->GetValue();
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_BoolElement_SetValue___(void * jarg1, unsigned int jarg2) {
XTools::BoolElement *arg1 = (XTools::BoolElement *) 0 ;
bool arg2 ;
arg1 = (XTools::BoolElement *)jarg1;
arg2 = jarg2 ? true : false;
(arg1)->SetValue(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_BoolElement___(void * jarg1) {
XTools::BoolElement *arg1 = (XTools::BoolElement *) 0 ;
arg1 = (XTools::BoolElement *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_IntElement_Cast___(void * jarg1) {
void * jresult ;
XTools::ElementPtr *arg1 = 0 ;
XTools::ElementPtr tempnull1 ;
XTools::ElementPtr temp1 ;
XTools::Element *smartarg1 ;
XTools::ref_ptr< XTools::IntElement > result;
// ref_ptr by reference in
if ( jarg1 ) {
smartarg1 = *( Element **)&jarg1;
temp1 = XTools::ref_ptr< Element >(smartarg1);
arg1 = &temp1;
} else {
arg1 = &tempnull1;
}
result = XTools::IntElement::Cast((XTools::ref_ptr< XTools::Element > const &)*arg1);
// ref_ptr by value out
if (result) {
result->AddRef();
*( IntElement **)&jresult = (&result)->get();
} else {
*( IntElement **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_IntElement_GetValue___(void * jarg1) {
int jresult ;
XTools::IntElement *arg1 = (XTools::IntElement *) 0 ;
XTools::int32 result;
arg1 = (XTools::IntElement *)jarg1;
result = (XTools::int32)((XTools::IntElement const *)arg1)->GetValue();
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_IntElement_SetValue___(void * jarg1, int jarg2) {
XTools::IntElement *arg1 = (XTools::IntElement *) 0 ;
XTools::int32 arg2 ;
arg1 = (XTools::IntElement *)jarg1;
arg2 = (XTools::int32)jarg2;
(arg1)->SetValue(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_IntElement___(void * jarg1) {
XTools::IntElement *arg1 = (XTools::IntElement *) 0 ;
arg1 = (XTools::IntElement *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_LongElement_Cast___(void * jarg1) {
void * jresult ;
XTools::ElementPtr *arg1 = 0 ;
XTools::ElementPtr tempnull1 ;
XTools::ElementPtr temp1 ;
XTools::Element *smartarg1 ;
XTools::ref_ptr< XTools::LongElement > result;
// ref_ptr by reference in
if ( jarg1 ) {
smartarg1 = *( Element **)&jarg1;
temp1 = XTools::ref_ptr< Element >(smartarg1);
arg1 = &temp1;
} else {
arg1 = &tempnull1;
}
result = XTools::LongElement::Cast((XTools::ref_ptr< XTools::Element > const &)*arg1);
// ref_ptr by value out
if (result) {
result->AddRef();
*( LongElement **)&jresult = (&result)->get();
} else {
*( LongElement **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT long long SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_LongElement_GetValue___(void * jarg1) {
long long jresult ;
XTools::LongElement *arg1 = (XTools::LongElement *) 0 ;
XTools::int64 result;
arg1 = (XTools::LongElement *)jarg1;
result = (XTools::int64)((XTools::LongElement const *)arg1)->GetValue();
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_LongElement_SetValue___(void * jarg1, long long jarg2) {
XTools::LongElement *arg1 = (XTools::LongElement *) 0 ;
XTools::int64 arg2 ;
arg1 = (XTools::LongElement *)jarg1;
arg2 = (XTools::int64)jarg2;
(arg1)->SetValue(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_LongElement___(void * jarg1) {
XTools::LongElement *arg1 = (XTools::LongElement *) 0 ;
arg1 = (XTools::LongElement *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_FloatElement_Cast___(void * jarg1) {
void * jresult ;
XTools::ElementPtr *arg1 = 0 ;
XTools::ElementPtr tempnull1 ;
XTools::ElementPtr temp1 ;
XTools::Element *smartarg1 ;
XTools::ref_ptr< XTools::FloatElement > result;
// ref_ptr by reference in
if ( jarg1 ) {
smartarg1 = *( Element **)&jarg1;
temp1 = XTools::ref_ptr< Element >(smartarg1);
arg1 = &temp1;
} else {
arg1 = &tempnull1;
}
result = XTools::FloatElement::Cast((XTools::ref_ptr< XTools::Element > const &)*arg1);
// ref_ptr by value out
if (result) {
result->AddRef();
*( FloatElement **)&jresult = (&result)->get();
} else {
*( FloatElement **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT float SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_FloatElement_GetValue___(void * jarg1) {
float jresult ;
XTools::FloatElement *arg1 = (XTools::FloatElement *) 0 ;
float result;
arg1 = (XTools::FloatElement *)jarg1;
result = (float)((XTools::FloatElement const *)arg1)->GetValue();
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_FloatElement_SetValue___(void * jarg1, float jarg2) {
XTools::FloatElement *arg1 = (XTools::FloatElement *) 0 ;
float arg2 ;
arg1 = (XTools::FloatElement *)jarg1;
arg2 = (float)jarg2;
(arg1)->SetValue(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_FloatElement___(void * jarg1) {
XTools::FloatElement *arg1 = (XTools::FloatElement *) 0 ;
arg1 = (XTools::FloatElement *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DoubleElement_Cast___(void * jarg1) {
void * jresult ;
XTools::ElementPtr *arg1 = 0 ;
XTools::ElementPtr tempnull1 ;
XTools::ElementPtr temp1 ;
XTools::Element *smartarg1 ;
XTools::ref_ptr< XTools::DoubleElement > result;
// ref_ptr by reference in
if ( jarg1 ) {
smartarg1 = *( Element **)&jarg1;
temp1 = XTools::ref_ptr< Element >(smartarg1);
arg1 = &temp1;
} else {
arg1 = &tempnull1;
}
result = XTools::DoubleElement::Cast((XTools::ref_ptr< XTools::Element > const &)*arg1);
// ref_ptr by value out
if (result) {
result->AddRef();
*( DoubleElement **)&jresult = (&result)->get();
} else {
*( DoubleElement **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT double SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DoubleElement_GetValue___(void * jarg1) {
double jresult ;
XTools::DoubleElement *arg1 = (XTools::DoubleElement *) 0 ;
double result;
arg1 = (XTools::DoubleElement *)jarg1;
result = (double)((XTools::DoubleElement const *)arg1)->GetValue();
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DoubleElement_SetValue___(void * jarg1, double jarg2) {
XTools::DoubleElement *arg1 = (XTools::DoubleElement *) 0 ;
double arg2 ;
arg1 = (XTools::DoubleElement *)jarg1;
arg2 = (double)jarg2;
(arg1)->SetValue(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_DoubleElement___(void * jarg1) {
XTools::DoubleElement *arg1 = (XTools::DoubleElement *) 0 ;
arg1 = (XTools::DoubleElement *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_StringElement_Cast___(void * jarg1) {
void * jresult ;
XTools::ElementPtr *arg1 = 0 ;
XTools::ElementPtr tempnull1 ;
XTools::ElementPtr temp1 ;
XTools::Element *smartarg1 ;
XTools::ref_ptr< XTools::StringElement > result;
// ref_ptr by reference in
if ( jarg1 ) {
smartarg1 = *( Element **)&jarg1;
temp1 = XTools::ref_ptr< Element >(smartarg1);
arg1 = &temp1;
} else {
arg1 = &tempnull1;
}
result = XTools::StringElement::Cast((XTools::ref_ptr< XTools::Element > const &)*arg1);
// ref_ptr by value out
if (result) {
result->AddRef();
*( StringElement **)&jresult = (&result)->get();
} else {
*( StringElement **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_StringElement_GetValue___(void * jarg1) {
void * jresult ;
XTools::StringElement *arg1 = (XTools::StringElement *) 0 ;
XTools::XStringPtr *result = 0 ;
arg1 = (XTools::StringElement *)jarg1;
result = (XTools::XStringPtr *) &((XTools::StringElement const *)arg1)->GetValue();
// ref_ptr by reference out
if (*result) {
result->get()->AddRef();
*( XString **)&jresult = result->get();
} else {
*( XString **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_StringElement_SetValue___(void * jarg1, void * jarg2) {
XTools::StringElement *arg1 = (XTools::StringElement *) 0 ;
XTools::XStringPtr *arg2 = 0 ;
XTools::XStringPtr tempnull2 ;
XTools::XStringPtr temp2 ;
XTools::XString *smartarg2 ;
arg1 = (XTools::StringElement *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( XString **)&jarg2;
temp2 = XTools::ref_ptr< XString >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->SetValue((XTools::XStringPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_StringElement___(void * jarg1) {
XTools::StringElement *arg1 = (XTools::StringElement *) 0 ;
arg1 = (XTools::StringElement *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_IntArrayListener___(void * jarg1) {
XTools::IntArrayListener *arg1 = (XTools::IntArrayListener *) 0 ;
arg1 = (XTools::IntArrayListener *)jarg1;
delete arg1;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_IntArrayListener_OnValueChanged___(void * jarg1, int jarg2, int jarg3) {
XTools::IntArrayListener *arg1 = (XTools::IntArrayListener *) 0 ;
XTools::int32 arg2 ;
XTools::int32 arg3 ;
arg1 = (XTools::IntArrayListener *)jarg1;
arg2 = (XTools::int32)jarg2;
arg3 = (XTools::int32)jarg3;
(arg1)->OnValueChanged(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_IntArrayListener_OnValueChangedSwigExplicitIntArrayListener___(void * jarg1, int jarg2, int jarg3) {
XTools::IntArrayListener *arg1 = (XTools::IntArrayListener *) 0 ;
XTools::int32 arg2 ;
XTools::int32 arg3 ;
arg1 = (XTools::IntArrayListener *)jarg1;
arg2 = (XTools::int32)jarg2;
arg3 = (XTools::int32)jarg3;
(arg1)->XTools::IntArrayListener::OnValueChanged(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_IntArrayListener_OnValueInserted___(void * jarg1, int jarg2, int jarg3) {
XTools::IntArrayListener *arg1 = (XTools::IntArrayListener *) 0 ;
XTools::int32 arg2 ;
XTools::int32 arg3 ;
arg1 = (XTools::IntArrayListener *)jarg1;
arg2 = (XTools::int32)jarg2;
arg3 = (XTools::int32)jarg3;
(arg1)->OnValueInserted(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_IntArrayListener_OnValueInsertedSwigExplicitIntArrayListener___(void * jarg1, int jarg2, int jarg3) {
XTools::IntArrayListener *arg1 = (XTools::IntArrayListener *) 0 ;
XTools::int32 arg2 ;
XTools::int32 arg3 ;
arg1 = (XTools::IntArrayListener *)jarg1;
arg2 = (XTools::int32)jarg2;
arg3 = (XTools::int32)jarg3;
(arg1)->XTools::IntArrayListener::OnValueInserted(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_IntArrayListener_OnValueRemoved___(void * jarg1, int jarg2, int jarg3) {
XTools::IntArrayListener *arg1 = (XTools::IntArrayListener *) 0 ;
XTools::int32 arg2 ;
XTools::int32 arg3 ;
arg1 = (XTools::IntArrayListener *)jarg1;
arg2 = (XTools::int32)jarg2;
arg3 = (XTools::int32)jarg3;
(arg1)->OnValueRemoved(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_IntArrayListener_OnValueRemovedSwigExplicitIntArrayListener___(void * jarg1, int jarg2, int jarg3) {
XTools::IntArrayListener *arg1 = (XTools::IntArrayListener *) 0 ;
XTools::int32 arg2 ;
XTools::int32 arg3 ;
arg1 = (XTools::IntArrayListener *)jarg1;
arg2 = (XTools::int32)jarg2;
arg3 = (XTools::int32)jarg3;
(arg1)->XTools::IntArrayListener::OnValueRemoved(arg2,arg3);
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_IntArrayListener___() {
void * jresult ;
XTools::IntArrayListener *result = 0 ;
result = (XTools::IntArrayListener *)new SwigDirector_IntArrayListener();
jresult = (void *)result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_IntArrayListener_director_connect___(void *objarg, SwigDirector_IntArrayListener::SWIG_Callback0_t callback0, SwigDirector_IntArrayListener::SWIG_Callback1_t callback1, SwigDirector_IntArrayListener::SWIG_Callback2_t callback2) {
XTools::IntArrayListener *obj = (XTools::IntArrayListener *)objarg;
SwigDirector_IntArrayListener *director = dynamic_cast<SwigDirector_IntArrayListener *>(obj);
if (director) {
director->swig_connect_director(callback0, callback1, callback2);
}
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_IntArrayElement_Cast___(void * jarg1) {
void * jresult ;
XTools::ElementPtr *arg1 = 0 ;
XTools::ElementPtr tempnull1 ;
XTools::ElementPtr temp1 ;
XTools::Element *smartarg1 ;
XTools::ref_ptr< XTools::IntArrayElement > result;
// ref_ptr by reference in
if ( jarg1 ) {
smartarg1 = *( Element **)&jarg1;
temp1 = XTools::ref_ptr< Element >(smartarg1);
arg1 = &temp1;
} else {
arg1 = &tempnull1;
}
result = XTools::IntArrayElement::Cast((XTools::ref_ptr< XTools::Element > const &)*arg1);
// ref_ptr by value out
if (result) {
result->AddRef();
*( IntArrayElement **)&jresult = (&result)->get();
} else {
*( IntArrayElement **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_IntArrayElement_GetCount___(void * jarg1) {
int jresult ;
XTools::IntArrayElement *arg1 = (XTools::IntArrayElement *) 0 ;
XTools::int32 result;
arg1 = (XTools::IntArrayElement *)jarg1;
result = (XTools::int32)((XTools::IntArrayElement const *)arg1)->GetCount();
jresult = result;
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_IntArrayElement_GetValue___(void * jarg1, int jarg2) {
int jresult ;
XTools::IntArrayElement *arg1 = (XTools::IntArrayElement *) 0 ;
XTools::int32 arg2 ;
XTools::int32 result;
arg1 = (XTools::IntArrayElement *)jarg1;
arg2 = (XTools::int32)jarg2;
result = (XTools::int32)((XTools::IntArrayElement const *)arg1)->GetValue(arg2);
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_IntArrayElement_SetValue___(void * jarg1, int jarg2, int jarg3) {
XTools::IntArrayElement *arg1 = (XTools::IntArrayElement *) 0 ;
XTools::int32 arg2 ;
XTools::int32 arg3 ;
arg1 = (XTools::IntArrayElement *)jarg1;
arg2 = (XTools::int32)jarg2;
arg3 = (XTools::int32)jarg3;
(arg1)->SetValue(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_IntArrayElement_InsertValue___(void * jarg1, int jarg2, int jarg3) {
XTools::IntArrayElement *arg1 = (XTools::IntArrayElement *) 0 ;
XTools::int32 arg2 ;
XTools::int32 arg3 ;
arg1 = (XTools::IntArrayElement *)jarg1;
arg2 = (XTools::int32)jarg2;
arg3 = (XTools::int32)jarg3;
(arg1)->InsertValue(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_IntArrayElement_RemoveValue___(void * jarg1, int jarg2) {
XTools::IntArrayElement *arg1 = (XTools::IntArrayElement *) 0 ;
XTools::int32 arg2 ;
arg1 = (XTools::IntArrayElement *)jarg1;
arg2 = (XTools::int32)jarg2;
(arg1)->RemoveValue(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_IntArrayElement_AddListener___(void * jarg1, void * jarg2) {
XTools::IntArrayElement *arg1 = (XTools::IntArrayElement *) 0 ;
XTools::IntArrayListener *arg2 = (XTools::IntArrayListener *) 0 ;
arg1 = (XTools::IntArrayElement *)jarg1;
arg2 = (XTools::IntArrayListener *)jarg2;
(arg1)->AddListener(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_IntArrayElement_RemoveListener___(void * jarg1, void * jarg2) {
XTools::IntArrayElement *arg1 = (XTools::IntArrayElement *) 0 ;
XTools::IntArrayListener *arg2 = (XTools::IntArrayListener *) 0 ;
arg1 = (XTools::IntArrayElement *)jarg1;
arg2 = (XTools::IntArrayListener *)jarg2;
(arg1)->RemoveListener(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_IntArrayElement___(void * jarg1) {
XTools::IntArrayElement *arg1 = (XTools::IntArrayElement *) 0 ;
arg1 = (XTools::IntArrayElement *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_FloatArrayListener___(void * jarg1) {
XTools::FloatArrayListener *arg1 = (XTools::FloatArrayListener *) 0 ;
arg1 = (XTools::FloatArrayListener *)jarg1;
delete arg1;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_FloatArrayListener_OnValueChanged___(void * jarg1, int jarg2, float jarg3) {
XTools::FloatArrayListener *arg1 = (XTools::FloatArrayListener *) 0 ;
XTools::int32 arg2 ;
float arg3 ;
arg1 = (XTools::FloatArrayListener *)jarg1;
arg2 = (XTools::int32)jarg2;
arg3 = (float)jarg3;
(arg1)->OnValueChanged(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_FloatArrayListener_OnValueChangedSwigExplicitFloatArrayListener___(void * jarg1, int jarg2, float jarg3) {
XTools::FloatArrayListener *arg1 = (XTools::FloatArrayListener *) 0 ;
XTools::int32 arg2 ;
float arg3 ;
arg1 = (XTools::FloatArrayListener *)jarg1;
arg2 = (XTools::int32)jarg2;
arg3 = (float)jarg3;
(arg1)->XTools::FloatArrayListener::OnValueChanged(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_FloatArrayListener_OnValueInserted___(void * jarg1, int jarg2, float jarg3) {
XTools::FloatArrayListener *arg1 = (XTools::FloatArrayListener *) 0 ;
XTools::int32 arg2 ;
float arg3 ;
arg1 = (XTools::FloatArrayListener *)jarg1;
arg2 = (XTools::int32)jarg2;
arg3 = (float)jarg3;
(arg1)->OnValueInserted(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_FloatArrayListener_OnValueInsertedSwigExplicitFloatArrayListener___(void * jarg1, int jarg2, float jarg3) {
XTools::FloatArrayListener *arg1 = (XTools::FloatArrayListener *) 0 ;
XTools::int32 arg2 ;
float arg3 ;
arg1 = (XTools::FloatArrayListener *)jarg1;
arg2 = (XTools::int32)jarg2;
arg3 = (float)jarg3;
(arg1)->XTools::FloatArrayListener::OnValueInserted(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_FloatArrayListener_OnValueRemoved___(void * jarg1, int jarg2, float jarg3) {
XTools::FloatArrayListener *arg1 = (XTools::FloatArrayListener *) 0 ;
XTools::int32 arg2 ;
float arg3 ;
arg1 = (XTools::FloatArrayListener *)jarg1;
arg2 = (XTools::int32)jarg2;
arg3 = (float)jarg3;
(arg1)->OnValueRemoved(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_FloatArrayListener_OnValueRemovedSwigExplicitFloatArrayListener___(void * jarg1, int jarg2, float jarg3) {
XTools::FloatArrayListener *arg1 = (XTools::FloatArrayListener *) 0 ;
XTools::int32 arg2 ;
float arg3 ;
arg1 = (XTools::FloatArrayListener *)jarg1;
arg2 = (XTools::int32)jarg2;
arg3 = (float)jarg3;
(arg1)->XTools::FloatArrayListener::OnValueRemoved(arg2,arg3);
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_FloatArrayListener___() {
void * jresult ;
XTools::FloatArrayListener *result = 0 ;
result = (XTools::FloatArrayListener *)new SwigDirector_FloatArrayListener();
jresult = (void *)result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_FloatArrayListener_director_connect___(void *objarg, SwigDirector_FloatArrayListener::SWIG_Callback0_t callback0, SwigDirector_FloatArrayListener::SWIG_Callback1_t callback1, SwigDirector_FloatArrayListener::SWIG_Callback2_t callback2) {
XTools::FloatArrayListener *obj = (XTools::FloatArrayListener *)objarg;
SwigDirector_FloatArrayListener *director = dynamic_cast<SwigDirector_FloatArrayListener *>(obj);
if (director) {
director->swig_connect_director(callback0, callback1, callback2);
}
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_FloatArrayElement_Cast___(void * jarg1) {
void * jresult ;
XTools::ElementPtr *arg1 = 0 ;
XTools::ElementPtr tempnull1 ;
XTools::ElementPtr temp1 ;
XTools::Element *smartarg1 ;
XTools::ref_ptr< XTools::FloatArrayElement > result;
// ref_ptr by reference in
if ( jarg1 ) {
smartarg1 = *( Element **)&jarg1;
temp1 = XTools::ref_ptr< Element >(smartarg1);
arg1 = &temp1;
} else {
arg1 = &tempnull1;
}
result = XTools::FloatArrayElement::Cast((XTools::ref_ptr< XTools::Element > const &)*arg1);
// ref_ptr by value out
if (result) {
result->AddRef();
*( FloatArrayElement **)&jresult = (&result)->get();
} else {
*( FloatArrayElement **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_FloatArrayElement_GetCount___(void * jarg1) {
int jresult ;
XTools::FloatArrayElement *arg1 = (XTools::FloatArrayElement *) 0 ;
XTools::int32 result;
arg1 = (XTools::FloatArrayElement *)jarg1;
result = (XTools::int32)((XTools::FloatArrayElement const *)arg1)->GetCount();
jresult = result;
return jresult;
}
SWIGEXPORT float SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_FloatArrayElement_GetValue___(void * jarg1, int jarg2) {
float jresult ;
XTools::FloatArrayElement *arg1 = (XTools::FloatArrayElement *) 0 ;
XTools::int32 arg2 ;
float result;
arg1 = (XTools::FloatArrayElement *)jarg1;
arg2 = (XTools::int32)jarg2;
result = (float)((XTools::FloatArrayElement const *)arg1)->GetValue(arg2);
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_FloatArrayElement_SetValue___(void * jarg1, int jarg2, float jarg3) {
XTools::FloatArrayElement *arg1 = (XTools::FloatArrayElement *) 0 ;
XTools::int32 arg2 ;
float arg3 ;
arg1 = (XTools::FloatArrayElement *)jarg1;
arg2 = (XTools::int32)jarg2;
arg3 = (float)jarg3;
(arg1)->SetValue(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_FloatArrayElement_InsertValue___(void * jarg1, int jarg2, float jarg3) {
XTools::FloatArrayElement *arg1 = (XTools::FloatArrayElement *) 0 ;
XTools::int32 arg2 ;
float arg3 ;
arg1 = (XTools::FloatArrayElement *)jarg1;
arg2 = (XTools::int32)jarg2;
arg3 = (float)jarg3;
(arg1)->InsertValue(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_FloatArrayElement_RemoveValue___(void * jarg1, int jarg2) {
XTools::FloatArrayElement *arg1 = (XTools::FloatArrayElement *) 0 ;
XTools::int32 arg2 ;
arg1 = (XTools::FloatArrayElement *)jarg1;
arg2 = (XTools::int32)jarg2;
(arg1)->RemoveValue(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_FloatArrayElement_AddListener___(void * jarg1, void * jarg2) {
XTools::FloatArrayElement *arg1 = (XTools::FloatArrayElement *) 0 ;
XTools::FloatArrayListener *arg2 = (XTools::FloatArrayListener *) 0 ;
arg1 = (XTools::FloatArrayElement *)jarg1;
arg2 = (XTools::FloatArrayListener *)jarg2;
(arg1)->AddListener(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_FloatArrayElement_RemoveListener___(void * jarg1, void * jarg2) {
XTools::FloatArrayElement *arg1 = (XTools::FloatArrayElement *) 0 ;
XTools::FloatArrayListener *arg2 = (XTools::FloatArrayListener *) 0 ;
arg1 = (XTools::FloatArrayElement *)jarg1;
arg2 = (XTools::FloatArrayListener *)jarg2;
(arg1)->RemoveListener(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_FloatArrayElement___(void * jarg1) {
XTools::FloatArrayElement *arg1 = (XTools::FloatArrayElement *) 0 ;
arg1 = (XTools::FloatArrayElement *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_StringArrayListener___(void * jarg1) {
XTools::StringArrayListener *arg1 = (XTools::StringArrayListener *) 0 ;
arg1 = (XTools::StringArrayListener *)jarg1;
delete arg1;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_StringArrayListener_OnValueChanged___(void * jarg1, int jarg2, void * jarg3) {
XTools::StringArrayListener *arg1 = (XTools::StringArrayListener *) 0 ;
XTools::int32 arg2 ;
XTools::XStringPtr *arg3 = 0 ;
XTools::XStringPtr tempnull3 ;
XTools::XStringPtr temp3 ;
XTools::XString *smartarg3 ;
arg1 = (XTools::StringArrayListener *)jarg1;
arg2 = (XTools::int32)jarg2;
// ref_ptr by reference in
if ( jarg3 ) {
smartarg3 = *( XString **)&jarg3;
temp3 = XTools::ref_ptr< XString >(smartarg3);
arg3 = &temp3;
} else {
arg3 = &tempnull3;
}
(arg1)->OnValueChanged(arg2,(XTools::XStringPtr const &)*arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_StringArrayListener_OnValueChangedSwigExplicitStringArrayListener___(void * jarg1, int jarg2, void * jarg3) {
XTools::StringArrayListener *arg1 = (XTools::StringArrayListener *) 0 ;
XTools::int32 arg2 ;
XTools::XStringPtr *arg3 = 0 ;
XTools::XStringPtr tempnull3 ;
XTools::XStringPtr temp3 ;
XTools::XString *smartarg3 ;
arg1 = (XTools::StringArrayListener *)jarg1;
arg2 = (XTools::int32)jarg2;
// ref_ptr by reference in
if ( jarg3 ) {
smartarg3 = *( XString **)&jarg3;
temp3 = XTools::ref_ptr< XString >(smartarg3);
arg3 = &temp3;
} else {
arg3 = &tempnull3;
}
(arg1)->XTools::StringArrayListener::OnValueChanged(arg2,(XTools::XStringPtr const &)*arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_StringArrayListener_OnValueInserted___(void * jarg1, int jarg2, void * jarg3) {
XTools::StringArrayListener *arg1 = (XTools::StringArrayListener *) 0 ;
XTools::int32 arg2 ;
XTools::XStringPtr *arg3 = 0 ;
XTools::XStringPtr tempnull3 ;
XTools::XStringPtr temp3 ;
XTools::XString *smartarg3 ;
arg1 = (XTools::StringArrayListener *)jarg1;
arg2 = (XTools::int32)jarg2;
// ref_ptr by reference in
if ( jarg3 ) {
smartarg3 = *( XString **)&jarg3;
temp3 = XTools::ref_ptr< XString >(smartarg3);
arg3 = &temp3;
} else {
arg3 = &tempnull3;
}
(arg1)->OnValueInserted(arg2,(XTools::XStringPtr const &)*arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_StringArrayListener_OnValueInsertedSwigExplicitStringArrayListener___(void * jarg1, int jarg2, void * jarg3) {
XTools::StringArrayListener *arg1 = (XTools::StringArrayListener *) 0 ;
XTools::int32 arg2 ;
XTools::XStringPtr *arg3 = 0 ;
XTools::XStringPtr tempnull3 ;
XTools::XStringPtr temp3 ;
XTools::XString *smartarg3 ;
arg1 = (XTools::StringArrayListener *)jarg1;
arg2 = (XTools::int32)jarg2;
// ref_ptr by reference in
if ( jarg3 ) {
smartarg3 = *( XString **)&jarg3;
temp3 = XTools::ref_ptr< XString >(smartarg3);
arg3 = &temp3;
} else {
arg3 = &tempnull3;
}
(arg1)->XTools::StringArrayListener::OnValueInserted(arg2,(XTools::XStringPtr const &)*arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_StringArrayListener_OnValueRemoved___(void * jarg1, int jarg2, void * jarg3) {
XTools::StringArrayListener *arg1 = (XTools::StringArrayListener *) 0 ;
XTools::int32 arg2 ;
XTools::XStringPtr *arg3 = 0 ;
XTools::XStringPtr tempnull3 ;
XTools::XStringPtr temp3 ;
XTools::XString *smartarg3 ;
arg1 = (XTools::StringArrayListener *)jarg1;
arg2 = (XTools::int32)jarg2;
// ref_ptr by reference in
if ( jarg3 ) {
smartarg3 = *( XString **)&jarg3;
temp3 = XTools::ref_ptr< XString >(smartarg3);
arg3 = &temp3;
} else {
arg3 = &tempnull3;
}
(arg1)->OnValueRemoved(arg2,(XTools::XStringPtr const &)*arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_StringArrayListener_OnValueRemovedSwigExplicitStringArrayListener___(void * jarg1, int jarg2, void * jarg3) {
XTools::StringArrayListener *arg1 = (XTools::StringArrayListener *) 0 ;
XTools::int32 arg2 ;
XTools::XStringPtr *arg3 = 0 ;
XTools::XStringPtr tempnull3 ;
XTools::XStringPtr temp3 ;
XTools::XString *smartarg3 ;
arg1 = (XTools::StringArrayListener *)jarg1;
arg2 = (XTools::int32)jarg2;
// ref_ptr by reference in
if ( jarg3 ) {
smartarg3 = *( XString **)&jarg3;
temp3 = XTools::ref_ptr< XString >(smartarg3);
arg3 = &temp3;
} else {
arg3 = &tempnull3;
}
(arg1)->XTools::StringArrayListener::OnValueRemoved(arg2,(XTools::XStringPtr const &)*arg3);
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_StringArrayListener___() {
void * jresult ;
XTools::StringArrayListener *result = 0 ;
result = (XTools::StringArrayListener *)new SwigDirector_StringArrayListener();
jresult = (void *)result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_StringArrayListener_director_connect___(void *objarg, SwigDirector_StringArrayListener::SWIG_Callback0_t callback0, SwigDirector_StringArrayListener::SWIG_Callback1_t callback1, SwigDirector_StringArrayListener::SWIG_Callback2_t callback2) {
XTools::StringArrayListener *obj = (XTools::StringArrayListener *)objarg;
SwigDirector_StringArrayListener *director = dynamic_cast<SwigDirector_StringArrayListener *>(obj);
if (director) {
director->swig_connect_director(callback0, callback1, callback2);
}
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_StringArrayElement_Cast___(void * jarg1) {
void * jresult ;
XTools::ElementPtr *arg1 = 0 ;
XTools::ElementPtr tempnull1 ;
XTools::ElementPtr temp1 ;
XTools::Element *smartarg1 ;
XTools::ref_ptr< XTools::StringArrayElement > result;
// ref_ptr by reference in
if ( jarg1 ) {
smartarg1 = *( Element **)&jarg1;
temp1 = XTools::ref_ptr< Element >(smartarg1);
arg1 = &temp1;
} else {
arg1 = &tempnull1;
}
result = XTools::StringArrayElement::Cast((XTools::ref_ptr< XTools::Element > const &)*arg1);
// ref_ptr by value out
if (result) {
result->AddRef();
*( StringArrayElement **)&jresult = (&result)->get();
} else {
*( StringArrayElement **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_StringArrayElement_GetCount___(void * jarg1) {
int jresult ;
XTools::StringArrayElement *arg1 = (XTools::StringArrayElement *) 0 ;
XTools::int32 result;
arg1 = (XTools::StringArrayElement *)jarg1;
result = (XTools::int32)((XTools::StringArrayElement const *)arg1)->GetCount();
jresult = result;
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_StringArrayElement_GetValue___(void * jarg1, int jarg2) {
void * jresult ;
XTools::StringArrayElement *arg1 = (XTools::StringArrayElement *) 0 ;
XTools::int32 arg2 ;
XTools::XStringPtr result;
arg1 = (XTools::StringArrayElement *)jarg1;
arg2 = (XTools::int32)jarg2;
result = ((XTools::StringArrayElement const *)arg1)->GetValue(arg2);
// ref_ptr by value out
if (result) {
result->AddRef();
*( XString **)&jresult = (&result)->get();
} else {
*( XString **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_StringArrayElement_SetValue___(void * jarg1, int jarg2, void * jarg3) {
XTools::StringArrayElement *arg1 = (XTools::StringArrayElement *) 0 ;
XTools::int32 arg2 ;
XTools::XStringPtr *arg3 = 0 ;
XTools::XStringPtr tempnull3 ;
XTools::XStringPtr temp3 ;
XTools::XString *smartarg3 ;
arg1 = (XTools::StringArrayElement *)jarg1;
arg2 = (XTools::int32)jarg2;
// ref_ptr by reference in
if ( jarg3 ) {
smartarg3 = *( XString **)&jarg3;
temp3 = XTools::ref_ptr< XString >(smartarg3);
arg3 = &temp3;
} else {
arg3 = &tempnull3;
}
(arg1)->SetValue(arg2,(XTools::XStringPtr const &)*arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_StringArrayElement_InsertValue___(void * jarg1, int jarg2, void * jarg3) {
XTools::StringArrayElement *arg1 = (XTools::StringArrayElement *) 0 ;
XTools::int32 arg2 ;
XTools::XStringPtr *arg3 = 0 ;
XTools::XStringPtr tempnull3 ;
XTools::XStringPtr temp3 ;
XTools::XString *smartarg3 ;
arg1 = (XTools::StringArrayElement *)jarg1;
arg2 = (XTools::int32)jarg2;
// ref_ptr by reference in
if ( jarg3 ) {
smartarg3 = *( XString **)&jarg3;
temp3 = XTools::ref_ptr< XString >(smartarg3);
arg3 = &temp3;
} else {
arg3 = &tempnull3;
}
(arg1)->InsertValue(arg2,(XTools::XStringPtr const &)*arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_StringArrayElement_RemoveValue___(void * jarg1, int jarg2) {
XTools::StringArrayElement *arg1 = (XTools::StringArrayElement *) 0 ;
XTools::int32 arg2 ;
arg1 = (XTools::StringArrayElement *)jarg1;
arg2 = (XTools::int32)jarg2;
(arg1)->RemoveValue(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_StringArrayElement_AddListener___(void * jarg1, void * jarg2) {
XTools::StringArrayElement *arg1 = (XTools::StringArrayElement *) 0 ;
XTools::StringArrayListener *arg2 = (XTools::StringArrayListener *) 0 ;
arg1 = (XTools::StringArrayElement *)jarg1;
arg2 = (XTools::StringArrayListener *)jarg2;
(arg1)->AddListener(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_StringArrayElement_RemoveListener___(void * jarg1, void * jarg2) {
XTools::StringArrayElement *arg1 = (XTools::StringArrayElement *) 0 ;
XTools::StringArrayListener *arg2 = (XTools::StringArrayListener *) 0 ;
arg1 = (XTools::StringArrayElement *)jarg1;
arg2 = (XTools::StringArrayListener *)jarg2;
(arg1)->RemoveListener(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_StringArrayElement___(void * jarg1) {
XTools::StringArrayElement *arg1 = (XTools::StringArrayElement *) 0 ;
arg1 = (XTools::StringArrayElement *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_ObjectElementListener___(void * jarg1) {
XTools::ObjectElementListener *arg1 = (XTools::ObjectElementListener *) 0 ;
arg1 = (XTools::ObjectElementListener *)jarg1;
delete arg1;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElementListener_OnBoolElementChanged___(void * jarg1, long long jarg2, unsigned int jarg3) {
XTools::ObjectElementListener *arg1 = (XTools::ObjectElementListener *) 0 ;
XTools::XGuid arg2 ;
bool arg3 ;
arg1 = (XTools::ObjectElementListener *)jarg1;
arg2 = (XTools::XGuid)jarg2;
arg3 = jarg3 ? true : false;
(arg1)->OnBoolElementChanged(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElementListener_OnBoolElementChangedSwigExplicitObjectElementListener___(void * jarg1, long long jarg2, unsigned int jarg3) {
XTools::ObjectElementListener *arg1 = (XTools::ObjectElementListener *) 0 ;
XTools::XGuid arg2 ;
bool arg3 ;
arg1 = (XTools::ObjectElementListener *)jarg1;
arg2 = (XTools::XGuid)jarg2;
arg3 = jarg3 ? true : false;
(arg1)->XTools::ObjectElementListener::OnBoolElementChanged(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElementListener_OnIntElementChanged___(void * jarg1, long long jarg2, int jarg3) {
XTools::ObjectElementListener *arg1 = (XTools::ObjectElementListener *) 0 ;
XTools::XGuid arg2 ;
XTools::int32 arg3 ;
arg1 = (XTools::ObjectElementListener *)jarg1;
arg2 = (XTools::XGuid)jarg2;
arg3 = (XTools::int32)jarg3;
(arg1)->OnIntElementChanged(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElementListener_OnIntElementChangedSwigExplicitObjectElementListener___(void * jarg1, long long jarg2, int jarg3) {
XTools::ObjectElementListener *arg1 = (XTools::ObjectElementListener *) 0 ;
XTools::XGuid arg2 ;
XTools::int32 arg3 ;
arg1 = (XTools::ObjectElementListener *)jarg1;
arg2 = (XTools::XGuid)jarg2;
arg3 = (XTools::int32)jarg3;
(arg1)->XTools::ObjectElementListener::OnIntElementChanged(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElementListener_OnLongElementChanged___(void * jarg1, long long jarg2, long long jarg3) {
XTools::ObjectElementListener *arg1 = (XTools::ObjectElementListener *) 0 ;
XTools::XGuid arg2 ;
XTools::int64 arg3 ;
arg1 = (XTools::ObjectElementListener *)jarg1;
arg2 = (XTools::XGuid)jarg2;
arg3 = (XTools::int64)jarg3;
(arg1)->OnLongElementChanged(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElementListener_OnLongElementChangedSwigExplicitObjectElementListener___(void * jarg1, long long jarg2, long long jarg3) {
XTools::ObjectElementListener *arg1 = (XTools::ObjectElementListener *) 0 ;
XTools::XGuid arg2 ;
XTools::int64 arg3 ;
arg1 = (XTools::ObjectElementListener *)jarg1;
arg2 = (XTools::XGuid)jarg2;
arg3 = (XTools::int64)jarg3;
(arg1)->XTools::ObjectElementListener::OnLongElementChanged(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElementListener_OnFloatElementChanged___(void * jarg1, long long jarg2, float jarg3) {
XTools::ObjectElementListener *arg1 = (XTools::ObjectElementListener *) 0 ;
XTools::XGuid arg2 ;
float arg3 ;
arg1 = (XTools::ObjectElementListener *)jarg1;
arg2 = (XTools::XGuid)jarg2;
arg3 = (float)jarg3;
(arg1)->OnFloatElementChanged(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElementListener_OnFloatElementChangedSwigExplicitObjectElementListener___(void * jarg1, long long jarg2, float jarg3) {
XTools::ObjectElementListener *arg1 = (XTools::ObjectElementListener *) 0 ;
XTools::XGuid arg2 ;
float arg3 ;
arg1 = (XTools::ObjectElementListener *)jarg1;
arg2 = (XTools::XGuid)jarg2;
arg3 = (float)jarg3;
(arg1)->XTools::ObjectElementListener::OnFloatElementChanged(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElementListener_OnDoubleElementChanged___(void * jarg1, long long jarg2, double jarg3) {
XTools::ObjectElementListener *arg1 = (XTools::ObjectElementListener *) 0 ;
XTools::XGuid arg2 ;
double arg3 ;
arg1 = (XTools::ObjectElementListener *)jarg1;
arg2 = (XTools::XGuid)jarg2;
arg3 = (double)jarg3;
(arg1)->OnDoubleElementChanged(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElementListener_OnDoubleElementChangedSwigExplicitObjectElementListener___(void * jarg1, long long jarg2, double jarg3) {
XTools::ObjectElementListener *arg1 = (XTools::ObjectElementListener *) 0 ;
XTools::XGuid arg2 ;
double arg3 ;
arg1 = (XTools::ObjectElementListener *)jarg1;
arg2 = (XTools::XGuid)jarg2;
arg3 = (double)jarg3;
(arg1)->XTools::ObjectElementListener::OnDoubleElementChanged(arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElementListener_OnStringElementChanged___(void * jarg1, long long jarg2, void * jarg3) {
XTools::ObjectElementListener *arg1 = (XTools::ObjectElementListener *) 0 ;
XTools::XGuid arg2 ;
XTools::XStringPtr *arg3 = 0 ;
XTools::XStringPtr tempnull3 ;
XTools::XStringPtr temp3 ;
XTools::XString *smartarg3 ;
arg1 = (XTools::ObjectElementListener *)jarg1;
arg2 = (XTools::XGuid)jarg2;
// ref_ptr by reference in
if ( jarg3 ) {
smartarg3 = *( XString **)&jarg3;
temp3 = XTools::ref_ptr< XString >(smartarg3);
arg3 = &temp3;
} else {
arg3 = &tempnull3;
}
(arg1)->OnStringElementChanged(arg2,(XTools::XStringPtr const &)*arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElementListener_OnStringElementChangedSwigExplicitObjectElementListener___(void * jarg1, long long jarg2, void * jarg3) {
XTools::ObjectElementListener *arg1 = (XTools::ObjectElementListener *) 0 ;
XTools::XGuid arg2 ;
XTools::XStringPtr *arg3 = 0 ;
XTools::XStringPtr tempnull3 ;
XTools::XStringPtr temp3 ;
XTools::XString *smartarg3 ;
arg1 = (XTools::ObjectElementListener *)jarg1;
arg2 = (XTools::XGuid)jarg2;
// ref_ptr by reference in
if ( jarg3 ) {
smartarg3 = *( XString **)&jarg3;
temp3 = XTools::ref_ptr< XString >(smartarg3);
arg3 = &temp3;
} else {
arg3 = &tempnull3;
}
(arg1)->XTools::ObjectElementListener::OnStringElementChanged(arg2,(XTools::XStringPtr const &)*arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElementListener_OnElementAdded___(void * jarg1, void * jarg2) {
XTools::ObjectElementListener *arg1 = (XTools::ObjectElementListener *) 0 ;
XTools::ElementPtr *arg2 = 0 ;
XTools::ElementPtr tempnull2 ;
XTools::ElementPtr temp2 ;
XTools::Element *smartarg2 ;
arg1 = (XTools::ObjectElementListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Element **)&jarg2;
temp2 = XTools::ref_ptr< Element >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->OnElementAdded((XTools::ElementPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElementListener_OnElementAddedSwigExplicitObjectElementListener___(void * jarg1, void * jarg2) {
XTools::ObjectElementListener *arg1 = (XTools::ObjectElementListener *) 0 ;
XTools::ElementPtr *arg2 = 0 ;
XTools::ElementPtr tempnull2 ;
XTools::ElementPtr temp2 ;
XTools::Element *smartarg2 ;
arg1 = (XTools::ObjectElementListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Element **)&jarg2;
temp2 = XTools::ref_ptr< Element >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->XTools::ObjectElementListener::OnElementAdded((XTools::ElementPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElementListener_OnElementDeleted___(void * jarg1, void * jarg2) {
XTools::ObjectElementListener *arg1 = (XTools::ObjectElementListener *) 0 ;
XTools::ElementPtr *arg2 = 0 ;
XTools::ElementPtr tempnull2 ;
XTools::ElementPtr temp2 ;
XTools::Element *smartarg2 ;
arg1 = (XTools::ObjectElementListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Element **)&jarg2;
temp2 = XTools::ref_ptr< Element >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->OnElementDeleted((XTools::ElementPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElementListener_OnElementDeletedSwigExplicitObjectElementListener___(void * jarg1, void * jarg2) {
XTools::ObjectElementListener *arg1 = (XTools::ObjectElementListener *) 0 ;
XTools::ElementPtr *arg2 = 0 ;
XTools::ElementPtr tempnull2 ;
XTools::ElementPtr temp2 ;
XTools::Element *smartarg2 ;
arg1 = (XTools::ObjectElementListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Element **)&jarg2;
temp2 = XTools::ref_ptr< Element >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->XTools::ObjectElementListener::OnElementDeleted((XTools::ElementPtr const &)*arg2);
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_ObjectElementListener___() {
void * jresult ;
XTools::ObjectElementListener *result = 0 ;
result = (XTools::ObjectElementListener *)new SwigDirector_ObjectElementListener();
jresult = (void *)result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElementListener_director_connect___(void *objarg, SwigDirector_ObjectElementListener::SWIG_Callback0_t callback0, SwigDirector_ObjectElementListener::SWIG_Callback1_t callback1, SwigDirector_ObjectElementListener::SWIG_Callback2_t callback2, SwigDirector_ObjectElementListener::SWIG_Callback3_t callback3, SwigDirector_ObjectElementListener::SWIG_Callback4_t callback4, SwigDirector_ObjectElementListener::SWIG_Callback5_t callback5, SwigDirector_ObjectElementListener::SWIG_Callback6_t callback6, SwigDirector_ObjectElementListener::SWIG_Callback7_t callback7) {
XTools::ObjectElementListener *obj = (XTools::ObjectElementListener *)objarg;
SwigDirector_ObjectElementListener *director = dynamic_cast<SwigDirector_ObjectElementListener *>(obj);
if (director) {
director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
}
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElement_Cast___(void * jarg1) {
void * jresult ;
XTools::ElementPtr *arg1 = 0 ;
XTools::ElementPtr tempnull1 ;
XTools::ElementPtr temp1 ;
XTools::Element *smartarg1 ;
XTools::ref_ptr< XTools::ObjectElement > result;
// ref_ptr by reference in
if ( jarg1 ) {
smartarg1 = *( Element **)&jarg1;
temp1 = XTools::ref_ptr< Element >(smartarg1);
arg1 = &temp1;
} else {
arg1 = &tempnull1;
}
result = XTools::ObjectElement::Cast((XTools::ref_ptr< XTools::Element > const &)*arg1);
// ref_ptr by value out
if (result) {
result->AddRef();
*( ObjectElement **)&jresult = (&result)->get();
} else {
*( ObjectElement **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElement_CreateBoolElement___(void * jarg1, void * jarg2, unsigned int jarg3) {
void * jresult ;
XTools::ObjectElement *arg1 = (XTools::ObjectElement *) 0 ;
XTools::XStringPtr *arg2 = 0 ;
bool arg3 ;
XTools::XStringPtr tempnull2 ;
XTools::XStringPtr temp2 ;
XTools::XString *smartarg2 ;
XTools::BoolElementPtr result;
arg1 = (XTools::ObjectElement *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( XString **)&jarg2;
temp2 = XTools::ref_ptr< XString >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = jarg3 ? true : false;
result = (arg1)->CreateBoolElement((XTools::XStringPtr const &)*arg2,arg3);
// ref_ptr by value out
if (result) {
result->AddRef();
*( BoolElement **)&jresult = (&result)->get();
} else {
*( BoolElement **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElement_CreateIntElement___(void * jarg1, void * jarg2, int jarg3) {
void * jresult ;
XTools::ObjectElement *arg1 = (XTools::ObjectElement *) 0 ;
XTools::XStringPtr *arg2 = 0 ;
XTools::int32 arg3 ;
XTools::XStringPtr tempnull2 ;
XTools::XStringPtr temp2 ;
XTools::XString *smartarg2 ;
XTools::IntElementPtr result;
arg1 = (XTools::ObjectElement *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( XString **)&jarg2;
temp2 = XTools::ref_ptr< XString >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (XTools::int32)jarg3;
result = (arg1)->CreateIntElement((XTools::XStringPtr const &)*arg2,arg3);
// ref_ptr by value out
if (result) {
result->AddRef();
*( IntElement **)&jresult = (&result)->get();
} else {
*( IntElement **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElement_CreateLongElement___(void * jarg1, void * jarg2, long long jarg3) {
void * jresult ;
XTools::ObjectElement *arg1 = (XTools::ObjectElement *) 0 ;
XTools::XStringPtr *arg2 = 0 ;
XTools::int64 arg3 ;
XTools::XStringPtr tempnull2 ;
XTools::XStringPtr temp2 ;
XTools::XString *smartarg2 ;
XTools::LongElementPtr result;
arg1 = (XTools::ObjectElement *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( XString **)&jarg2;
temp2 = XTools::ref_ptr< XString >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (XTools::int64)jarg3;
result = (arg1)->CreateLongElement((XTools::XStringPtr const &)*arg2,arg3);
// ref_ptr by value out
if (result) {
result->AddRef();
*( LongElement **)&jresult = (&result)->get();
} else {
*( LongElement **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElement_CreateFloatElement___(void * jarg1, void * jarg2, float jarg3) {
void * jresult ;
XTools::ObjectElement *arg1 = (XTools::ObjectElement *) 0 ;
XTools::XStringPtr *arg2 = 0 ;
float arg3 ;
XTools::XStringPtr tempnull2 ;
XTools::XStringPtr temp2 ;
XTools::XString *smartarg2 ;
XTools::FloatElementPtr result;
arg1 = (XTools::ObjectElement *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( XString **)&jarg2;
temp2 = XTools::ref_ptr< XString >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (float)jarg3;
result = (arg1)->CreateFloatElement((XTools::XStringPtr const &)*arg2,arg3);
// ref_ptr by value out
if (result) {
result->AddRef();
*( FloatElement **)&jresult = (&result)->get();
} else {
*( FloatElement **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElement_CreateDoubleElement___(void * jarg1, void * jarg2, double jarg3) {
void * jresult ;
XTools::ObjectElement *arg1 = (XTools::ObjectElement *) 0 ;
XTools::XStringPtr *arg2 = 0 ;
double arg3 ;
XTools::XStringPtr tempnull2 ;
XTools::XStringPtr temp2 ;
XTools::XString *smartarg2 ;
XTools::DoubleElementPtr result;
arg1 = (XTools::ObjectElement *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( XString **)&jarg2;
temp2 = XTools::ref_ptr< XString >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (double)jarg3;
result = (arg1)->CreateDoubleElement((XTools::XStringPtr const &)*arg2,arg3);
// ref_ptr by value out
if (result) {
result->AddRef();
*( DoubleElement **)&jresult = (&result)->get();
} else {
*( DoubleElement **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElement_CreateStringElement___(void * jarg1, void * jarg2, void * jarg3) {
void * jresult ;
XTools::ObjectElement *arg1 = (XTools::ObjectElement *) 0 ;
XTools::XStringPtr *arg2 = 0 ;
XTools::XStringPtr *arg3 = 0 ;
XTools::XStringPtr tempnull2 ;
XTools::XStringPtr temp2 ;
XTools::XString *smartarg2 ;
XTools::XStringPtr tempnull3 ;
XTools::XStringPtr temp3 ;
XTools::XString *smartarg3 ;
XTools::StringElementPtr result;
arg1 = (XTools::ObjectElement *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( XString **)&jarg2;
temp2 = XTools::ref_ptr< XString >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
// ref_ptr by reference in
if ( jarg3 ) {
smartarg3 = *( XString **)&jarg3;
temp3 = XTools::ref_ptr< XString >(smartarg3);
arg3 = &temp3;
} else {
arg3 = &tempnull3;
}
result = (arg1)->CreateStringElement((XTools::XStringPtr const &)*arg2,(XTools::XStringPtr const &)*arg3);
// ref_ptr by value out
if (result) {
result->AddRef();
*( StringElement **)&jresult = (&result)->get();
} else {
*( StringElement **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElement_CreateObjectElement__SWIG_0___(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
void * jresult ;
XTools::ObjectElement *arg1 = (XTools::ObjectElement *) 0 ;
XTools::XStringPtr *arg2 = 0 ;
XTools::XStringPtr *arg3 = 0 ;
XTools::User *arg4 = (XTools::User *) 0 ;
XTools::XStringPtr tempnull2 ;
XTools::XStringPtr temp2 ;
XTools::XString *smartarg2 ;
XTools::XStringPtr tempnull3 ;
XTools::XStringPtr temp3 ;
XTools::XString *smartarg3 ;
XTools::ref_ptr< XTools::ObjectElement > result;
arg1 = (XTools::ObjectElement *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( XString **)&jarg2;
temp2 = XTools::ref_ptr< XString >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
// ref_ptr by reference in
if ( jarg3 ) {
smartarg3 = *( XString **)&jarg3;
temp3 = XTools::ref_ptr< XString >(smartarg3);
arg3 = &temp3;
} else {
arg3 = &tempnull3;
}
arg4 = (XTools::User *)jarg4;
result = (arg1)->CreateObjectElement((XTools::XStringPtr const &)*arg2,(XTools::XStringPtr const &)*arg3,(XTools::User const *)arg4);
// ref_ptr by value out
if (result) {
result->AddRef();
*( ObjectElement **)&jresult = (&result)->get();
} else {
*( ObjectElement **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElement_CreateObjectElement__SWIG_1___(void * jarg1, void * jarg2, void * jarg3) {
void * jresult ;
XTools::ObjectElement *arg1 = (XTools::ObjectElement *) 0 ;
XTools::XStringPtr *arg2 = 0 ;
XTools::XStringPtr *arg3 = 0 ;
XTools::XStringPtr tempnull2 ;
XTools::XStringPtr temp2 ;
XTools::XString *smartarg2 ;
XTools::XStringPtr tempnull3 ;
XTools::XStringPtr temp3 ;
XTools::XString *smartarg3 ;
XTools::ref_ptr< XTools::ObjectElement > result;
arg1 = (XTools::ObjectElement *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( XString **)&jarg2;
temp2 = XTools::ref_ptr< XString >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
// ref_ptr by reference in
if ( jarg3 ) {
smartarg3 = *( XString **)&jarg3;
temp3 = XTools::ref_ptr< XString >(smartarg3);
arg3 = &temp3;
} else {
arg3 = &tempnull3;
}
result = (arg1)->CreateObjectElement((XTools::XStringPtr const &)*arg2,(XTools::XStringPtr const &)*arg3);
// ref_ptr by value out
if (result) {
result->AddRef();
*( ObjectElement **)&jresult = (&result)->get();
} else {
*( ObjectElement **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElement_CreateIntArrayElement___(void * jarg1, void * jarg2) {
void * jresult ;
XTools::ObjectElement *arg1 = (XTools::ObjectElement *) 0 ;
XTools::XStringPtr *arg2 = 0 ;
XTools::XStringPtr tempnull2 ;
XTools::XStringPtr temp2 ;
XTools::XString *smartarg2 ;
XTools::IntArrayElementPtr result;
arg1 = (XTools::ObjectElement *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( XString **)&jarg2;
temp2 = XTools::ref_ptr< XString >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
result = (arg1)->CreateIntArrayElement((XTools::XStringPtr const &)*arg2);
// ref_ptr by value out
if (result) {
result->AddRef();
*( IntArrayElement **)&jresult = (&result)->get();
} else {
*( IntArrayElement **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElement_CreateFloatArrayElement___(void * jarg1, void * jarg2) {
void * jresult ;
XTools::ObjectElement *arg1 = (XTools::ObjectElement *) 0 ;
XTools::XStringPtr *arg2 = 0 ;
XTools::XStringPtr tempnull2 ;
XTools::XStringPtr temp2 ;
XTools::XString *smartarg2 ;
XTools::FloatArrayElementPtr result;
arg1 = (XTools::ObjectElement *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( XString **)&jarg2;
temp2 = XTools::ref_ptr< XString >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
result = (arg1)->CreateFloatArrayElement((XTools::XStringPtr const &)*arg2);
// ref_ptr by value out
if (result) {
result->AddRef();
*( FloatArrayElement **)&jresult = (&result)->get();
} else {
*( FloatArrayElement **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElement_CreateStringArrayElement___(void * jarg1, void * jarg2) {
void * jresult ;
XTools::ObjectElement *arg1 = (XTools::ObjectElement *) 0 ;
XTools::XStringPtr *arg2 = 0 ;
XTools::XStringPtr tempnull2 ;
XTools::XStringPtr temp2 ;
XTools::XString *smartarg2 ;
XTools::StringArrayElementPtr result;
arg1 = (XTools::ObjectElement *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( XString **)&jarg2;
temp2 = XTools::ref_ptr< XString >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
result = (arg1)->CreateStringArrayElement((XTools::XStringPtr const &)*arg2);
// ref_ptr by value out
if (result) {
result->AddRef();
*( StringArrayElement **)&jresult = (&result)->get();
} else {
*( StringArrayElement **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElement_GetElementCount___(void * jarg1) {
int jresult ;
XTools::ObjectElement *arg1 = (XTools::ObjectElement *) 0 ;
XTools::int32 result;
arg1 = (XTools::ObjectElement *)jarg1;
result = (XTools::int32)((XTools::ObjectElement const *)arg1)->GetElementCount();
jresult = result;
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElement_GetElement__SWIG_0___(void * jarg1, long long jarg2) {
void * jresult ;
XTools::ObjectElement *arg1 = (XTools::ObjectElement *) 0 ;
XTools::XGuid arg2 ;
XTools::ElementPtr result;
arg1 = (XTools::ObjectElement *)jarg1;
arg2 = (XTools::XGuid)jarg2;
result = ((XTools::ObjectElement const *)arg1)->GetElement(arg2);
// ref_ptr by value out
if (result) {
result->AddRef();
*( Element **)&jresult = (&result)->get();
} else {
*( Element **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElement_GetElement__SWIG_1___(void * jarg1, void * jarg2) {
void * jresult ;
XTools::ObjectElement *arg1 = (XTools::ObjectElement *) 0 ;
XTools::XStringPtr *arg2 = 0 ;
XTools::XStringPtr tempnull2 ;
XTools::XStringPtr temp2 ;
XTools::XString *smartarg2 ;
XTools::ElementPtr result;
arg1 = (XTools::ObjectElement *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( XString **)&jarg2;
temp2 = XTools::ref_ptr< XString >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
result = ((XTools::ObjectElement const *)arg1)->GetElement((XTools::XStringPtr const &)*arg2);
// ref_ptr by value out
if (result) {
result->AddRef();
*( Element **)&jresult = (&result)->get();
} else {
*( Element **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElement_GetElementAt___(void * jarg1, int jarg2) {
void * jresult ;
XTools::ObjectElement *arg1 = (XTools::ObjectElement *) 0 ;
XTools::int32 arg2 ;
XTools::ElementPtr result;
arg1 = (XTools::ObjectElement *)jarg1;
arg2 = (XTools::int32)jarg2;
result = ((XTools::ObjectElement const *)arg1)->GetElementAt(arg2);
// ref_ptr by value out
if (result) {
result->AddRef();
*( Element **)&jresult = (&result)->get();
} else {
*( Element **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElement_RemoveElement__SWIG_0___(void * jarg1, void * jarg2) {
XTools::ObjectElement *arg1 = (XTools::ObjectElement *) 0 ;
XTools::ElementPtr *arg2 = 0 ;
XTools::ElementPtr tempnull2 ;
XTools::ElementPtr temp2 ;
XTools::Element *smartarg2 ;
arg1 = (XTools::ObjectElement *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Element **)&jarg2;
temp2 = XTools::ref_ptr< Element >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->RemoveElement((XTools::ElementPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElement_RemoveElement__SWIG_1___(void * jarg1, long long jarg2) {
XTools::ObjectElement *arg1 = (XTools::ObjectElement *) 0 ;
XTools::XGuid arg2 ;
arg1 = (XTools::ObjectElement *)jarg1;
arg2 = (XTools::XGuid)jarg2;
(arg1)->RemoveElement(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElement_RemoveElementAt___(void * jarg1, int jarg2) {
XTools::ObjectElement *arg1 = (XTools::ObjectElement *) 0 ;
XTools::int32 arg2 ;
arg1 = (XTools::ObjectElement *)jarg1;
arg2 = (XTools::int32)jarg2;
(arg1)->RemoveElementAt(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElement_AddListener___(void * jarg1, void * jarg2) {
XTools::ObjectElement *arg1 = (XTools::ObjectElement *) 0 ;
XTools::ObjectElementListener *arg2 = (XTools::ObjectElementListener *) 0 ;
arg1 = (XTools::ObjectElement *)jarg1;
arg2 = (XTools::ObjectElementListener *)jarg2;
(arg1)->AddListener(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElement_RemoveListener___(void * jarg1, void * jarg2) {
XTools::ObjectElement *arg1 = (XTools::ObjectElement *) 0 ;
XTools::ObjectElementListener *arg2 = (XTools::ObjectElementListener *) 0 ;
arg1 = (XTools::ObjectElement *)jarg1;
arg2 = (XTools::ObjectElementListener *)jarg2;
(arg1)->RemoveListener(arg2);
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElement_GetOwnerID___(void * jarg1) {
int jresult ;
XTools::ObjectElement *arg1 = (XTools::ObjectElement *) 0 ;
XTools::UserID result;
arg1 = (XTools::ObjectElement *)jarg1;
result = (XTools::UserID)((XTools::ObjectElement const *)arg1)->GetOwnerID();
jresult = result;
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElement_GetObjectType___(void * jarg1) {
void * jresult ;
XTools::ObjectElement *arg1 = (XTools::ObjectElement *) 0 ;
XTools::XStringPtr *result = 0 ;
arg1 = (XTools::ObjectElement *)jarg1;
result = (XTools::XStringPtr *) &((XTools::ObjectElement const *)arg1)->GetObjectType();
// ref_ptr by reference out
if (*result) {
result->get()->AddRef();
*( XString **)&jresult = result->get();
} else {
*( XString **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_ObjectElement___(void * jarg1) {
XTools::ObjectElement *arg1 = (XTools::ObjectElement *) 0 ;
arg1 = (XTools::ObjectElement *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SyncListener_OnSyncChangesBegin___(void * jarg1) {
XTools::SyncListener *arg1 = (XTools::SyncListener *) 0 ;
arg1 = (XTools::SyncListener *)jarg1;
(arg1)->OnSyncChangesBegin();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SyncListener_OnSyncChangesBeginSwigExplicitSyncListener___(void * jarg1) {
XTools::SyncListener *arg1 = (XTools::SyncListener *) 0 ;
arg1 = (XTools::SyncListener *)jarg1;
(arg1)->XTools::SyncListener::OnSyncChangesBegin();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SyncListener_OnSyncChangesEnd___(void * jarg1) {
XTools::SyncListener *arg1 = (XTools::SyncListener *) 0 ;
arg1 = (XTools::SyncListener *)jarg1;
(arg1)->OnSyncChangesEnd();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SyncListener_OnSyncChangesEndSwigExplicitSyncListener___(void * jarg1) {
XTools::SyncListener *arg1 = (XTools::SyncListener *) 0 ;
arg1 = (XTools::SyncListener *)jarg1;
(arg1)->XTools::SyncListener::OnSyncChangesEnd();
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_SyncListener___() {
void * jresult ;
XTools::SyncListener *result = 0 ;
result = (XTools::SyncListener *)new SwigDirector_SyncListener();
jresult = (void *)result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_SyncListener___(void * jarg1) {
XTools::SyncListener *arg1 = (XTools::SyncListener *) 0 ;
arg1 = (XTools::SyncListener *)jarg1;
delete arg1;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SyncListener_director_connect___(void *objarg, SwigDirector_SyncListener::SWIG_Callback0_t callback0, SwigDirector_SyncListener::SWIG_Callback1_t callback1) {
XTools::SyncListener *obj = (XTools::SyncListener *)objarg;
SwigDirector_SyncListener *director = dynamic_cast<SwigDirector_SyncListener *>(obj);
if (director) {
director->swig_connect_director(callback0, callback1);
}
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_SessionListener___(void * jarg1) {
XTools::SessionListener *arg1 = (XTools::SessionListener *) 0 ;
arg1 = (XTools::SessionListener *)jarg1;
delete arg1;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionListener_OnJoiningSession___(void * jarg1) {
XTools::SessionListener *arg1 = (XTools::SessionListener *) 0 ;
arg1 = (XTools::SessionListener *)jarg1;
(arg1)->OnJoiningSession();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionListener_OnJoiningSessionSwigExplicitSessionListener___(void * jarg1) {
XTools::SessionListener *arg1 = (XTools::SessionListener *) 0 ;
arg1 = (XTools::SessionListener *)jarg1;
(arg1)->XTools::SessionListener::OnJoiningSession();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionListener_OnJoinSucceeded___(void * jarg1) {
XTools::SessionListener *arg1 = (XTools::SessionListener *) 0 ;
arg1 = (XTools::SessionListener *)jarg1;
(arg1)->OnJoinSucceeded();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionListener_OnJoinSucceededSwigExplicitSessionListener___(void * jarg1) {
XTools::SessionListener *arg1 = (XTools::SessionListener *) 0 ;
arg1 = (XTools::SessionListener *)jarg1;
(arg1)->XTools::SessionListener::OnJoinSucceeded();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionListener_OnJoinFailed___(void * jarg1) {
XTools::SessionListener *arg1 = (XTools::SessionListener *) 0 ;
arg1 = (XTools::SessionListener *)jarg1;
(arg1)->OnJoinFailed();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionListener_OnJoinFailedSwigExplicitSessionListener___(void * jarg1) {
XTools::SessionListener *arg1 = (XTools::SessionListener *) 0 ;
arg1 = (XTools::SessionListener *)jarg1;
(arg1)->XTools::SessionListener::OnJoinFailed();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionListener_OnSessionDisconnected___(void * jarg1) {
XTools::SessionListener *arg1 = (XTools::SessionListener *) 0 ;
arg1 = (XTools::SessionListener *)jarg1;
(arg1)->OnSessionDisconnected();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionListener_OnSessionDisconnectedSwigExplicitSessionListener___(void * jarg1) {
XTools::SessionListener *arg1 = (XTools::SessionListener *) 0 ;
arg1 = (XTools::SessionListener *)jarg1;
(arg1)->XTools::SessionListener::OnSessionDisconnected();
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_SessionListener___() {
void * jresult ;
XTools::SessionListener *result = 0 ;
result = (XTools::SessionListener *)new SwigDirector_SessionListener();
jresult = (void *)result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionListener_director_connect___(void *objarg, SwigDirector_SessionListener::SWIG_Callback0_t callback0, SwigDirector_SessionListener::SWIG_Callback1_t callback1, SwigDirector_SessionListener::SWIG_Callback2_t callback2, SwigDirector_SessionListener::SWIG_Callback3_t callback3) {
XTools::SessionListener *obj = (XTools::SessionListener *)objarg;
SwigDirector_SessionListener *director = dynamic_cast<SwigDirector_SessionListener *>(obj);
if (director) {
director->swig_connect_director(callback0, callback1, callback2, callback3);
}
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Session_GetMachineSessionState___(void * jarg1) {
int jresult ;
XTools::Session *arg1 = (XTools::Session *) 0 ;
XTools::MachineSessionState result;
arg1 = (XTools::Session *)jarg1;
result = (XTools::MachineSessionState)((XTools::Session const *)arg1)->GetMachineSessionState();
jresult = (int)result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Session_AddListener___(void * jarg1, void * jarg2) {
XTools::Session *arg1 = (XTools::Session *) 0 ;
XTools::SessionListener *arg2 = (XTools::SessionListener *) 0 ;
arg1 = (XTools::Session *)jarg1;
arg2 = (XTools::SessionListener *)jarg2;
(arg1)->AddListener(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Session_RemoveListener___(void * jarg1, void * jarg2) {
XTools::Session *arg1 = (XTools::Session *) 0 ;
XTools::SessionListener *arg2 = (XTools::SessionListener *) 0 ;
arg1 = (XTools::Session *)jarg1;
arg2 = (XTools::SessionListener *)jarg2;
(arg1)->RemoveListener(arg2);
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Session_IsJoined___(void * jarg1) {
unsigned int jresult ;
XTools::Session *arg1 = (XTools::Session *) 0 ;
bool result;
arg1 = (XTools::Session *)jarg1;
result = (bool)((XTools::Session const *)arg1)->IsJoined();
jresult = result;
return jresult;
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Session_Join___(void * jarg1) {
unsigned int jresult ;
XTools::Session *arg1 = (XTools::Session *) 0 ;
bool result;
arg1 = (XTools::Session *)jarg1;
result = (bool)(arg1)->Join();
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Session_Leave___(void * jarg1) {
XTools::Session *arg1 = (XTools::Session *) 0 ;
arg1 = (XTools::Session *)jarg1;
(arg1)->Leave();
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Session_GetUserCount___(void * jarg1) {
int jresult ;
XTools::Session *arg1 = (XTools::Session *) 0 ;
XTools::int32 result;
arg1 = (XTools::Session *)jarg1;
result = (XTools::int32)((XTools::Session const *)arg1)->GetUserCount();
jresult = result;
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Session_GetUser___(void * jarg1, int jarg2) {
void * jresult ;
XTools::Session *arg1 = (XTools::Session *) 0 ;
XTools::int32 arg2 ;
XTools::UserPtr result;
arg1 = (XTools::Session *)jarg1;
arg2 = (XTools::int32)jarg2;
result = (arg1)->GetUser(arg2);
// ref_ptr by value out
if (result) {
result->AddRef();
*( User **)&jresult = (&result)->get();
} else {
*( User **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Session_GetSessionType___(void * jarg1) {
int jresult ;
XTools::Session *arg1 = (XTools::Session *) 0 ;
XTools::SessionType result;
arg1 = (XTools::Session *)jarg1;
result = (XTools::SessionType)((XTools::Session const *)arg1)->GetSessionType();
jresult = (int)result;
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Session_GetName___(void * jarg1) {
void * jresult ;
XTools::Session *arg1 = (XTools::Session *) 0 ;
XTools::XStringPtr *result = 0 ;
arg1 = (XTools::Session *)jarg1;
result = (XTools::XStringPtr *) &((XTools::Session const *)arg1)->GetName();
// ref_ptr by reference out
if (*result) {
result->get()->AddRef();
*( XString **)&jresult = result->get();
} else {
*( XString **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Session_GetSessionNetworkConnection___(void * jarg1) {
void * jresult ;
XTools::Session *arg1 = (XTools::Session *) 0 ;
XTools::NetworkConnectionPtr result;
arg1 = (XTools::Session *)jarg1;
result = ((XTools::Session const *)arg1)->GetSessionNetworkConnection();
// ref_ptr by value out
if (result) {
result->AddRef();
*( NetworkConnection **)&jresult = (&result)->get();
} else {
*( NetworkConnection **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_Session___(void * jarg1) {
XTools::Session *arg1 = (XTools::Session *) 0 ;
arg1 = (XTools::Session *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_SessionManagerListener___(void * jarg1) {
XTools::SessionManagerListener *arg1 = (XTools::SessionManagerListener *) 0 ;
arg1 = (XTools::SessionManagerListener *)jarg1;
delete arg1;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManagerListener_OnCreateSucceeded___(void * jarg1, void * jarg2) {
XTools::SessionManagerListener *arg1 = (XTools::SessionManagerListener *) 0 ;
XTools::SessionPtr *arg2 = 0 ;
XTools::SessionPtr tempnull2 ;
XTools::SessionPtr temp2 ;
XTools::Session *smartarg2 ;
arg1 = (XTools::SessionManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Session **)&jarg2;
temp2 = XTools::ref_ptr< Session >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->OnCreateSucceeded((XTools::SessionPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManagerListener_OnCreateSucceededSwigExplicitSessionManagerListener___(void * jarg1, void * jarg2) {
XTools::SessionManagerListener *arg1 = (XTools::SessionManagerListener *) 0 ;
XTools::SessionPtr *arg2 = 0 ;
XTools::SessionPtr tempnull2 ;
XTools::SessionPtr temp2 ;
XTools::Session *smartarg2 ;
arg1 = (XTools::SessionManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Session **)&jarg2;
temp2 = XTools::ref_ptr< Session >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->XTools::SessionManagerListener::OnCreateSucceeded((XTools::SessionPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManagerListener_OnCreateFailed___(void * jarg1, void * jarg2) {
XTools::SessionManagerListener *arg1 = (XTools::SessionManagerListener *) 0 ;
XTools::XStringPtr *arg2 = 0 ;
XTools::XStringPtr tempnull2 ;
XTools::XStringPtr temp2 ;
XTools::XString *smartarg2 ;
arg1 = (XTools::SessionManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( XString **)&jarg2;
temp2 = XTools::ref_ptr< XString >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->OnCreateFailed((XTools::XStringPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManagerListener_OnCreateFailedSwigExplicitSessionManagerListener___(void * jarg1, void * jarg2) {
XTools::SessionManagerListener *arg1 = (XTools::SessionManagerListener *) 0 ;
XTools::XStringPtr *arg2 = 0 ;
XTools::XStringPtr tempnull2 ;
XTools::XStringPtr temp2 ;
XTools::XString *smartarg2 ;
arg1 = (XTools::SessionManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( XString **)&jarg2;
temp2 = XTools::ref_ptr< XString >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->XTools::SessionManagerListener::OnCreateFailed((XTools::XStringPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManagerListener_OnSessionAdded___(void * jarg1, void * jarg2) {
XTools::SessionManagerListener *arg1 = (XTools::SessionManagerListener *) 0 ;
XTools::SessionPtr *arg2 = 0 ;
XTools::SessionPtr tempnull2 ;
XTools::SessionPtr temp2 ;
XTools::Session *smartarg2 ;
arg1 = (XTools::SessionManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Session **)&jarg2;
temp2 = XTools::ref_ptr< Session >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->OnSessionAdded((XTools::SessionPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManagerListener_OnSessionAddedSwigExplicitSessionManagerListener___(void * jarg1, void * jarg2) {
XTools::SessionManagerListener *arg1 = (XTools::SessionManagerListener *) 0 ;
XTools::SessionPtr *arg2 = 0 ;
XTools::SessionPtr tempnull2 ;
XTools::SessionPtr temp2 ;
XTools::Session *smartarg2 ;
arg1 = (XTools::SessionManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Session **)&jarg2;
temp2 = XTools::ref_ptr< Session >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->XTools::SessionManagerListener::OnSessionAdded((XTools::SessionPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManagerListener_OnSessionClosed___(void * jarg1, void * jarg2) {
XTools::SessionManagerListener *arg1 = (XTools::SessionManagerListener *) 0 ;
XTools::SessionPtr *arg2 = 0 ;
XTools::SessionPtr tempnull2 ;
XTools::SessionPtr temp2 ;
XTools::Session *smartarg2 ;
arg1 = (XTools::SessionManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Session **)&jarg2;
temp2 = XTools::ref_ptr< Session >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->OnSessionClosed((XTools::SessionPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManagerListener_OnSessionClosedSwigExplicitSessionManagerListener___(void * jarg1, void * jarg2) {
XTools::SessionManagerListener *arg1 = (XTools::SessionManagerListener *) 0 ;
XTools::SessionPtr *arg2 = 0 ;
XTools::SessionPtr tempnull2 ;
XTools::SessionPtr temp2 ;
XTools::Session *smartarg2 ;
arg1 = (XTools::SessionManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Session **)&jarg2;
temp2 = XTools::ref_ptr< Session >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->XTools::SessionManagerListener::OnSessionClosed((XTools::SessionPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManagerListener_OnUserJoinedSession___(void * jarg1, void * jarg2, void * jarg3) {
XTools::SessionManagerListener *arg1 = (XTools::SessionManagerListener *) 0 ;
XTools::SessionPtr *arg2 = 0 ;
XTools::UserPtr *arg3 = 0 ;
XTools::SessionPtr tempnull2 ;
XTools::SessionPtr temp2 ;
XTools::Session *smartarg2 ;
XTools::UserPtr tempnull3 ;
XTools::UserPtr temp3 ;
XTools::User *smartarg3 ;
arg1 = (XTools::SessionManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Session **)&jarg2;
temp2 = XTools::ref_ptr< Session >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
// ref_ptr by reference in
if ( jarg3 ) {
smartarg3 = *( User **)&jarg3;
temp3 = XTools::ref_ptr< User >(smartarg3);
arg3 = &temp3;
} else {
arg3 = &tempnull3;
}
(arg1)->OnUserJoinedSession((XTools::SessionPtr const &)*arg2,(XTools::UserPtr const &)*arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManagerListener_OnUserJoinedSessionSwigExplicitSessionManagerListener___(void * jarg1, void * jarg2, void * jarg3) {
XTools::SessionManagerListener *arg1 = (XTools::SessionManagerListener *) 0 ;
XTools::SessionPtr *arg2 = 0 ;
XTools::UserPtr *arg3 = 0 ;
XTools::SessionPtr tempnull2 ;
XTools::SessionPtr temp2 ;
XTools::Session *smartarg2 ;
XTools::UserPtr tempnull3 ;
XTools::UserPtr temp3 ;
XTools::User *smartarg3 ;
arg1 = (XTools::SessionManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Session **)&jarg2;
temp2 = XTools::ref_ptr< Session >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
// ref_ptr by reference in
if ( jarg3 ) {
smartarg3 = *( User **)&jarg3;
temp3 = XTools::ref_ptr< User >(smartarg3);
arg3 = &temp3;
} else {
arg3 = &tempnull3;
}
(arg1)->XTools::SessionManagerListener::OnUserJoinedSession((XTools::SessionPtr const &)*arg2,(XTools::UserPtr const &)*arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManagerListener_OnUserLeftSession___(void * jarg1, void * jarg2, void * jarg3) {
XTools::SessionManagerListener *arg1 = (XTools::SessionManagerListener *) 0 ;
XTools::SessionPtr *arg2 = 0 ;
XTools::UserPtr *arg3 = 0 ;
XTools::SessionPtr tempnull2 ;
XTools::SessionPtr temp2 ;
XTools::Session *smartarg2 ;
XTools::UserPtr tempnull3 ;
XTools::UserPtr temp3 ;
XTools::User *smartarg3 ;
arg1 = (XTools::SessionManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Session **)&jarg2;
temp2 = XTools::ref_ptr< Session >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
// ref_ptr by reference in
if ( jarg3 ) {
smartarg3 = *( User **)&jarg3;
temp3 = XTools::ref_ptr< User >(smartarg3);
arg3 = &temp3;
} else {
arg3 = &tempnull3;
}
(arg1)->OnUserLeftSession((XTools::SessionPtr const &)*arg2,(XTools::UserPtr const &)*arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManagerListener_OnUserLeftSessionSwigExplicitSessionManagerListener___(void * jarg1, void * jarg2, void * jarg3) {
XTools::SessionManagerListener *arg1 = (XTools::SessionManagerListener *) 0 ;
XTools::SessionPtr *arg2 = 0 ;
XTools::UserPtr *arg3 = 0 ;
XTools::SessionPtr tempnull2 ;
XTools::SessionPtr temp2 ;
XTools::Session *smartarg2 ;
XTools::UserPtr tempnull3 ;
XTools::UserPtr temp3 ;
XTools::User *smartarg3 ;
arg1 = (XTools::SessionManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Session **)&jarg2;
temp2 = XTools::ref_ptr< Session >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
// ref_ptr by reference in
if ( jarg3 ) {
smartarg3 = *( User **)&jarg3;
temp3 = XTools::ref_ptr< User >(smartarg3);
arg3 = &temp3;
} else {
arg3 = &tempnull3;
}
(arg1)->XTools::SessionManagerListener::OnUserLeftSession((XTools::SessionPtr const &)*arg2,(XTools::UserPtr const &)*arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManagerListener_OnUserChanged___(void * jarg1, void * jarg2, void * jarg3) {
XTools::SessionManagerListener *arg1 = (XTools::SessionManagerListener *) 0 ;
XTools::SessionPtr *arg2 = 0 ;
XTools::UserPtr *arg3 = 0 ;
XTools::SessionPtr tempnull2 ;
XTools::SessionPtr temp2 ;
XTools::Session *smartarg2 ;
XTools::UserPtr tempnull3 ;
XTools::UserPtr temp3 ;
XTools::User *smartarg3 ;
arg1 = (XTools::SessionManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Session **)&jarg2;
temp2 = XTools::ref_ptr< Session >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
// ref_ptr by reference in
if ( jarg3 ) {
smartarg3 = *( User **)&jarg3;
temp3 = XTools::ref_ptr< User >(smartarg3);
arg3 = &temp3;
} else {
arg3 = &tempnull3;
}
(arg1)->OnUserChanged((XTools::SessionPtr const &)*arg2,(XTools::UserPtr const &)*arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManagerListener_OnUserChangedSwigExplicitSessionManagerListener___(void * jarg1, void * jarg2, void * jarg3) {
XTools::SessionManagerListener *arg1 = (XTools::SessionManagerListener *) 0 ;
XTools::SessionPtr *arg2 = 0 ;
XTools::UserPtr *arg3 = 0 ;
XTools::SessionPtr tempnull2 ;
XTools::SessionPtr temp2 ;
XTools::Session *smartarg2 ;
XTools::UserPtr tempnull3 ;
XTools::UserPtr temp3 ;
XTools::User *smartarg3 ;
arg1 = (XTools::SessionManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Session **)&jarg2;
temp2 = XTools::ref_ptr< Session >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
// ref_ptr by reference in
if ( jarg3 ) {
smartarg3 = *( User **)&jarg3;
temp3 = XTools::ref_ptr< User >(smartarg3);
arg3 = &temp3;
} else {
arg3 = &tempnull3;
}
(arg1)->XTools::SessionManagerListener::OnUserChanged((XTools::SessionPtr const &)*arg2,(XTools::UserPtr const &)*arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManagerListener_OnServerConnected___(void * jarg1) {
XTools::SessionManagerListener *arg1 = (XTools::SessionManagerListener *) 0 ;
arg1 = (XTools::SessionManagerListener *)jarg1;
(arg1)->OnServerConnected();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManagerListener_OnServerConnectedSwigExplicitSessionManagerListener___(void * jarg1) {
XTools::SessionManagerListener *arg1 = (XTools::SessionManagerListener *) 0 ;
arg1 = (XTools::SessionManagerListener *)jarg1;
(arg1)->XTools::SessionManagerListener::OnServerConnected();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManagerListener_OnServerDisconnected___(void * jarg1) {
XTools::SessionManagerListener *arg1 = (XTools::SessionManagerListener *) 0 ;
arg1 = (XTools::SessionManagerListener *)jarg1;
(arg1)->OnServerDisconnected();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManagerListener_OnServerDisconnectedSwigExplicitSessionManagerListener___(void * jarg1) {
XTools::SessionManagerListener *arg1 = (XTools::SessionManagerListener *) 0 ;
arg1 = (XTools::SessionManagerListener *)jarg1;
(arg1)->XTools::SessionManagerListener::OnServerDisconnected();
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_SessionManagerListener___() {
void * jresult ;
XTools::SessionManagerListener *result = 0 ;
result = (XTools::SessionManagerListener *)new SwigDirector_SessionManagerListener();
jresult = (void *)result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManagerListener_director_connect___(void *objarg, SwigDirector_SessionManagerListener::SWIG_Callback0_t callback0, SwigDirector_SessionManagerListener::SWIG_Callback1_t callback1, SwigDirector_SessionManagerListener::SWIG_Callback2_t callback2, SwigDirector_SessionManagerListener::SWIG_Callback3_t callback3, SwigDirector_SessionManagerListener::SWIG_Callback4_t callback4, SwigDirector_SessionManagerListener::SWIG_Callback5_t callback5, SwigDirector_SessionManagerListener::SWIG_Callback6_t callback6, SwigDirector_SessionManagerListener::SWIG_Callback7_t callback7, SwigDirector_SessionManagerListener::SWIG_Callback8_t callback8) {
XTools::SessionManagerListener *obj = (XTools::SessionManagerListener *)objarg;
SwigDirector_SessionManagerListener *director = dynamic_cast<SwigDirector_SessionManagerListener *>(obj);
if (director) {
director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7, callback8);
}
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManager_AddListener___(void * jarg1, void * jarg2) {
XTools::SessionManager *arg1 = (XTools::SessionManager *) 0 ;
XTools::SessionManagerListener *arg2 = (XTools::SessionManagerListener *) 0 ;
arg1 = (XTools::SessionManager *)jarg1;
arg2 = (XTools::SessionManagerListener *)jarg2;
(arg1)->AddListener(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManager_RemoveListener___(void * jarg1, void * jarg2) {
XTools::SessionManager *arg1 = (XTools::SessionManager *) 0 ;
XTools::SessionManagerListener *arg2 = (XTools::SessionManagerListener *) 0 ;
arg1 = (XTools::SessionManager *)jarg1;
arg2 = (XTools::SessionManagerListener *)jarg2;
(arg1)->RemoveListener(arg2);
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManager_CreateSession__SWIG_0___(void * jarg1, void * jarg2) {
unsigned int jresult ;
XTools::SessionManager *arg1 = (XTools::SessionManager *) 0 ;
XTools::XStringPtr *arg2 = 0 ;
XTools::XStringPtr tempnull2 ;
XTools::XStringPtr temp2 ;
XTools::XString *smartarg2 ;
bool result;
arg1 = (XTools::SessionManager *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( XString **)&jarg2;
temp2 = XTools::ref_ptr< XString >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
result = (bool)(arg1)->CreateSession((XTools::XStringPtr const &)*arg2);
jresult = result;
return jresult;
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManager_CreateSession__SWIG_1___(void * jarg1, void * jarg2, int jarg3) {
unsigned int jresult ;
XTools::SessionManager *arg1 = (XTools::SessionManager *) 0 ;
XTools::XStringPtr *arg2 = 0 ;
XTools::SessionType arg3 ;
XTools::XStringPtr tempnull2 ;
XTools::XStringPtr temp2 ;
XTools::XString *smartarg2 ;
bool result;
arg1 = (XTools::SessionManager *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( XString **)&jarg2;
temp2 = XTools::ref_ptr< XString >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (XTools::SessionType)jarg3;
result = (bool)(arg1)->CreateSession((XTools::XStringPtr const &)*arg2,arg3);
jresult = result;
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManager_GetSessionCount___(void * jarg1) {
int jresult ;
XTools::SessionManager *arg1 = (XTools::SessionManager *) 0 ;
XTools::int32 result;
arg1 = (XTools::SessionManager *)jarg1;
result = (XTools::int32)((XTools::SessionManager const *)arg1)->GetSessionCount();
jresult = result;
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManager_GetSession___(void * jarg1, int jarg2) {
void * jresult ;
XTools::SessionManager *arg1 = (XTools::SessionManager *) 0 ;
XTools::int32 arg2 ;
XTools::SessionPtr result;
arg1 = (XTools::SessionManager *)jarg1;
arg2 = (XTools::int32)jarg2;
result = (arg1)->GetSession(arg2);
// ref_ptr by value out
if (result) {
result->AddRef();
*( Session **)&jresult = (&result)->get();
} else {
*( Session **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManager_GetCurrentSession___(void * jarg1) {
void * jresult ;
XTools::SessionManager *arg1 = (XTools::SessionManager *) 0 ;
XTools::SessionPtr result;
arg1 = (XTools::SessionManager *)jarg1;
result = (arg1)->GetCurrentSession();
// ref_ptr by value out
if (result) {
result->AddRef();
*( Session **)&jresult = (&result)->get();
} else {
*( Session **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManager_GetCurrentUser___(void * jarg1) {
void * jresult ;
XTools::SessionManager *arg1 = (XTools::SessionManager *) 0 ;
XTools::UserPtr *result = 0 ;
arg1 = (XTools::SessionManager *)jarg1;
result = (XTools::UserPtr *) &((XTools::SessionManager const *)arg1)->GetCurrentUser();
// ref_ptr by reference out
if (*result) {
result->get()->AddRef();
*( User **)&jresult = result->get();
} else {
*( User **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManager_IsServerConnected___(void * jarg1) {
unsigned int jresult ;
XTools::SessionManager *arg1 = (XTools::SessionManager *) 0 ;
bool result;
arg1 = (XTools::SessionManager *)jarg1;
result = (bool)((XTools::SessionManager const *)arg1)->IsServerConnected();
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_SessionManager___(void * jarg1) {
XTools::SessionManager *arg1 = (XTools::SessionManager *) 0 ;
arg1 = (XTools::SessionManager *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_UserPresenceManagerListener___(void * jarg1) {
XTools::UserPresenceManagerListener *arg1 = (XTools::UserPresenceManagerListener *) 0 ;
arg1 = (XTools::UserPresenceManagerListener *)jarg1;
delete arg1;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_UserPresenceManagerListener_OnUserPresenceChanged___(void * jarg1, void * jarg2) {
XTools::UserPresenceManagerListener *arg1 = (XTools::UserPresenceManagerListener *) 0 ;
XTools::UserPtr *arg2 = 0 ;
XTools::UserPtr tempnull2 ;
XTools::UserPtr temp2 ;
XTools::User *smartarg2 ;
arg1 = (XTools::UserPresenceManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( User **)&jarg2;
temp2 = XTools::ref_ptr< User >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->OnUserPresenceChanged((XTools::UserPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_UserPresenceManagerListener_OnUserPresenceChangedSwigExplicitUserPresenceManagerListener___(void * jarg1, void * jarg2) {
XTools::UserPresenceManagerListener *arg1 = (XTools::UserPresenceManagerListener *) 0 ;
XTools::UserPtr *arg2 = 0 ;
XTools::UserPtr tempnull2 ;
XTools::UserPtr temp2 ;
XTools::User *smartarg2 ;
arg1 = (XTools::UserPresenceManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( User **)&jarg2;
temp2 = XTools::ref_ptr< User >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->XTools::UserPresenceManagerListener::OnUserPresenceChanged((XTools::UserPtr const &)*arg2);
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_UserPresenceManagerListener___() {
void * jresult ;
XTools::UserPresenceManagerListener *result = 0 ;
result = (XTools::UserPresenceManagerListener *)new SwigDirector_UserPresenceManagerListener();
jresult = (void *)result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_UserPresenceManagerListener_director_connect___(void *objarg, SwigDirector_UserPresenceManagerListener::SWIG_Callback0_t callback0) {
XTools::UserPresenceManagerListener *obj = (XTools::UserPresenceManagerListener *)objarg;
SwigDirector_UserPresenceManagerListener *director = dynamic_cast<SwigDirector_UserPresenceManagerListener *>(obj);
if (director) {
director->swig_connect_director(callback0);
}
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_UserPresenceManager_AddListener___(void * jarg1, void * jarg2) {
XTools::UserPresenceManager *arg1 = (XTools::UserPresenceManager *) 0 ;
XTools::UserPresenceManagerListener *arg2 = (XTools::UserPresenceManagerListener *) 0 ;
arg1 = (XTools::UserPresenceManager *)jarg1;
arg2 = (XTools::UserPresenceManagerListener *)jarg2;
(arg1)->AddListener(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_UserPresenceManager_RemoveListener___(void * jarg1, void * jarg2) {
XTools::UserPresenceManager *arg1 = (XTools::UserPresenceManager *) 0 ;
XTools::UserPresenceManagerListener *arg2 = (XTools::UserPresenceManagerListener *) 0 ;
arg1 = (XTools::UserPresenceManager *)jarg1;
arg2 = (XTools::UserPresenceManagerListener *)jarg2;
(arg1)->RemoveListener(arg2);
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_UserPresenceManager_GetMuteState___(void * jarg1) {
unsigned int jresult ;
XTools::UserPresenceManager *arg1 = (XTools::UserPresenceManager *) 0 ;
bool result;
arg1 = (XTools::UserPresenceManager *)jarg1;
result = (bool)((XTools::UserPresenceManager const *)arg1)->GetMuteState();
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_UserPresenceManager_SetMuteState___(void * jarg1, unsigned int jarg2) {
XTools::UserPresenceManager *arg1 = (XTools::UserPresenceManager *) 0 ;
bool arg2 ;
arg1 = (XTools::UserPresenceManager *)jarg1;
arg2 = jarg2 ? true : false;
(arg1)->SetMuteState(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_UserPresenceManager_SetName___(void * jarg1, void * jarg2) {
XTools::UserPresenceManager *arg1 = (XTools::UserPresenceManager *) 0 ;
XTools::XStringPtr *arg2 = 0 ;
XTools::XStringPtr tempnull2 ;
XTools::XStringPtr temp2 ;
XTools::XString *smartarg2 ;
arg1 = (XTools::UserPresenceManager *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( XString **)&jarg2;
temp2 = XTools::ref_ptr< XString >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->SetName((XTools::XStringPtr const &)*arg2);
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_UserPresenceManager_GetName___(void * jarg1) {
void * jresult ;
XTools::UserPresenceManager *arg1 = (XTools::UserPresenceManager *) 0 ;
XTools::XStringPtr result;
arg1 = (XTools::UserPresenceManager *)jarg1;
result = ((XTools::UserPresenceManager const *)arg1)->GetName();
// ref_ptr by value out
if (result) {
result->AddRef();
*( XString **)&jresult = (&result)->get();
} else {
*( XString **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_UserPresenceManager_SetUser___(void * jarg1, void * jarg2) {
XTools::UserPresenceManager *arg1 = (XTools::UserPresenceManager *) 0 ;
XTools::UserPtr *arg2 = 0 ;
XTools::UserPtr tempnull2 ;
XTools::UserPtr temp2 ;
XTools::User *smartarg2 ;
arg1 = (XTools::UserPresenceManager *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( User **)&jarg2;
temp2 = XTools::ref_ptr< User >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->SetUser((XTools::UserPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_UserPresenceManager___(void * jarg1) {
XTools::UserPresenceManager *arg1 = (XTools::UserPresenceManager *) 0 ;
arg1 = (XTools::UserPresenceManager *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_ClientConfig___(int jarg1) {
void * jresult ;
XTools::ClientRole arg1 ;
XTools::ClientConfig *result = 0 ;
arg1 = (XTools::ClientRole)jarg1;
result = (XTools::ClientConfig *)new XTools::ClientConfig(arg1);
jresult = (void *)result;
if(result) result->AddRef();
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ClientConfig_GetRole___(void * jarg1) {
int jresult ;
XTools::ClientConfig *arg1 = (XTools::ClientConfig *) 0 ;
XTools::ClientRole result;
arg1 = (XTools::ClientConfig *)jarg1;
result = (XTools::ClientRole)((XTools::ClientConfig const *)arg1)->GetRole();
jresult = (int)result;
return jresult;
}
SWIGEXPORT char * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ClientConfig_GetServerAddress___(void * jarg1) {
char * jresult ;
XTools::ClientConfig *arg1 = (XTools::ClientConfig *) 0 ;
std::string result;
arg1 = (XTools::ClientConfig *)jarg1;
result = ((XTools::ClientConfig const *)arg1)->GetServerAddress();
jresult = SWIG_csharp_string_callback((&result)->c_str());
return jresult;
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ClientConfig_SetServerAddress___(void * jarg1, char * jarg2) {
unsigned int jresult ;
XTools::ClientConfig *arg1 = (XTools::ClientConfig *) 0 ;
std::string *arg2 = 0 ;
bool result;
arg1 = (XTools::ClientConfig *)jarg1;
if (!jarg2) {
SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
return 0;
}
std::string arg2_str(jarg2);
arg2 = &arg2_str;
result = (bool)(arg1)->SetServerAddress((std::string const &)*arg2);
jresult = result;
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ClientConfig_GetServerPort___(void * jarg1) {
int jresult ;
XTools::ClientConfig *arg1 = (XTools::ClientConfig *) 0 ;
XTools::int32 result;
arg1 = (XTools::ClientConfig *)jarg1;
result = (XTools::int32)((XTools::ClientConfig const *)arg1)->GetServerPort();
jresult = result;
return jresult;
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ClientConfig_SetServerPort___(void * jarg1, int jarg2) {
unsigned int jresult ;
XTools::ClientConfig *arg1 = (XTools::ClientConfig *) 0 ;
XTools::int32 arg2 ;
bool result;
arg1 = (XTools::ClientConfig *)jarg1;
arg2 = (XTools::int32)jarg2;
result = (bool)(arg1)->SetServerPort(arg2);
jresult = result;
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ClientConfig_GetLogWriter___(void * jarg1) {
void * jresult ;
XTools::ClientConfig *arg1 = (XTools::ClientConfig *) 0 ;
XTools::LogWriter *result = 0 ;
arg1 = (XTools::ClientConfig *)jarg1;
result = (XTools::LogWriter *)((XTools::ClientConfig const *)arg1)->GetLogWriter();
jresult = (void *)result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ClientConfig_SetLogWriter___(void * jarg1, void * jarg2) {
XTools::ClientConfig *arg1 = (XTools::ClientConfig *) 0 ;
XTools::LogWriter *arg2 = (XTools::LogWriter *) 0 ;
arg1 = (XTools::ClientConfig *)jarg1;
arg2 = (XTools::LogWriter *)jarg2;
(arg1)->SetLogWriter(arg2);
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ClientConfig_GetIsAudioEndpoint___(void * jarg1) {
unsigned int jresult ;
XTools::ClientConfig *arg1 = (XTools::ClientConfig *) 0 ;
bool result;
arg1 = (XTools::ClientConfig *)jarg1;
result = (bool)((XTools::ClientConfig const *)arg1)->GetIsAudioEndpoint();
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ClientConfig_SetIsAudioEndpoint___(void * jarg1, unsigned int jarg2) {
XTools::ClientConfig *arg1 = (XTools::ClientConfig *) 0 ;
bool arg2 ;
arg1 = (XTools::ClientConfig *)jarg1;
arg2 = jarg2 ? true : false;
(arg1)->SetIsAudioEndpoint(arg2);
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ClientConfig_GetProfilerEnabled___(void * jarg1) {
unsigned int jresult ;
XTools::ClientConfig *arg1 = (XTools::ClientConfig *) 0 ;
bool result;
arg1 = (XTools::ClientConfig *)jarg1;
result = (bool)((XTools::ClientConfig const *)arg1)->GetProfilerEnabled();
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ClientConfig_SetProfilerEnabled___(void * jarg1, unsigned int jarg2) {
XTools::ClientConfig *arg1 = (XTools::ClientConfig *) 0 ;
bool arg2 ;
arg1 = (XTools::ClientConfig *)jarg1;
arg2 = jarg2 ? true : false;
(arg1)->SetProfilerEnabled(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_ClientConfig___(void * jarg1) {
XTools::ClientConfig *arg1 = (XTools::ClientConfig *) 0 ;
arg1 = (XTools::ClientConfig *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_AudioManager_SetMicrophoneEnabled___(void * jarg1, unsigned int jarg2) {
XTools::AudioManager *arg1 = (XTools::AudioManager *) 0 ;
bool arg2 ;
arg1 = (XTools::AudioManager *)jarg1;
arg2 = jarg2 ? true : false;
(arg1)->SetMicrophoneEnabled(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_AudioManager___(void * jarg1) {
XTools::AudioManager *arg1 = (XTools::AudioManager *) 0 ;
arg1 = (XTools::AudioManager *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_ProfileManager___(void * jarg1) {
XTools::ProfileManager *arg1 = (XTools::ProfileManager *) 0 ;
arg1 = (XTools::ProfileManager *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ProfileManager_BeginRange___(void * jarg1, char * jarg2) {
XTools::ProfileManager *arg1 = (XTools::ProfileManager *) 0 ;
std::string *arg2 = 0 ;
arg1 = (XTools::ProfileManager *)jarg1;
if (!jarg2) {
SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
return ;
}
std::string arg2_str(jarg2);
arg2 = &arg2_str;
(arg1)->BeginRange((std::string const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ProfileManager_EndRange___(void * jarg1) {
XTools::ProfileManager *arg1 = (XTools::ProfileManager *) 0 ;
arg1 = (XTools::ProfileManager *)jarg1;
(arg1)->EndRange();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ProfileManager_Log___(void * jarg1, int jarg2, char * jarg3) {
XTools::ProfileManager *arg1 = (XTools::ProfileManager *) 0 ;
XTools::LogSeverity arg2 ;
std::string *arg3 = 0 ;
arg1 = (XTools::ProfileManager *)jarg1;
arg2 = (XTools::LogSeverity)jarg2;
if (!jarg3) {
SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
return ;
}
std::string arg3_str(jarg3);
arg3 = &arg3_str;
(arg1)->Log(arg2,(std::string const &)*arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Profile_BeginRange___(char * jarg1) {
std::string *arg1 = 0 ;
if (!jarg1) {
SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
return ;
}
std::string arg1_str(jarg1);
arg1 = &arg1_str;
XTools::Profile::BeginRange((std::string const &)*arg1);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Profile_EndRange___() {
XTools::Profile::EndRange();
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_Profile___() {
void * jresult ;
XTools::Profile *result = 0 ;
result = (XTools::Profile *)new XTools::Profile();
jresult = (void *)result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_Profile___(void * jarg1) {
XTools::Profile *arg1 = (XTools::Profile *) 0 ;
arg1 = (XTools::Profile *)jarg1;
delete arg1;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Room_GetName___(void * jarg1) {
void * jresult ;
XTools::Room *arg1 = (XTools::Room *) 0 ;
XTools::XStringPtr result;
arg1 = (XTools::Room *)jarg1;
result = ((XTools::Room const *)arg1)->GetName();
// ref_ptr by value out
if (result) {
result->AddRef();
*( XString **)&jresult = (&result)->get();
} else {
*( XString **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT long long SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Room_GetID___(void * jarg1) {
long long jresult ;
XTools::Room *arg1 = (XTools::Room *) 0 ;
XTools::RoomID result;
arg1 = (XTools::Room *)jarg1;
result = (XTools::RoomID)((XTools::Room const *)arg1)->GetID();
jresult = result;
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Room_GetUserCount___(void * jarg1) {
int jresult ;
XTools::Room *arg1 = (XTools::Room *) 0 ;
XTools::int32 result;
arg1 = (XTools::Room *)jarg1;
result = (XTools::int32)(arg1)->GetUserCount();
jresult = result;
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Room_GetUserID___(void * jarg1, int jarg2) {
int jresult ;
XTools::Room *arg1 = (XTools::Room *) 0 ;
XTools::int32 arg2 ;
XTools::UserID result;
arg1 = (XTools::Room *)jarg1;
arg2 = (XTools::int32)jarg2;
result = (XTools::UserID)(arg1)->GetUserID(arg2);
jresult = result;
return jresult;
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Room_GetKeepOpen___(void * jarg1) {
unsigned int jresult ;
XTools::Room *arg1 = (XTools::Room *) 0 ;
bool result;
arg1 = (XTools::Room *)jarg1;
result = (bool)((XTools::Room const *)arg1)->GetKeepOpen();
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Room_SetKeepOpen___(void * jarg1, unsigned int jarg2) {
XTools::Room *arg1 = (XTools::Room *) 0 ;
bool arg2 ;
arg1 = (XTools::Room *)jarg1;
arg2 = jarg2 ? true : false;
(arg1)->SetKeepOpen(arg2);
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Room_GetAnchorCount___(void * jarg1) {
int jresult ;
XTools::Room *arg1 = (XTools::Room *) 0 ;
XTools::int32 result;
arg1 = (XTools::Room *)jarg1;
result = (XTools::int32)((XTools::Room const *)arg1)->GetAnchorCount();
jresult = result;
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Room_GetAnchorName___(void * jarg1, int jarg2) {
void * jresult ;
XTools::Room *arg1 = (XTools::Room *) 0 ;
XTools::int32 arg2 ;
XTools::XStringPtr *result = 0 ;
arg1 = (XTools::Room *)jarg1;
arg2 = (XTools::int32)jarg2;
result = (XTools::XStringPtr *) &((XTools::Room const *)arg1)->GetAnchorName(arg2);
// ref_ptr by reference out
if (*result) {
result->get()->AddRef();
*( XString **)&jresult = result->get();
} else {
*( XString **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_Room___(void * jarg1) {
XTools::Room *arg1 = (XTools::Room *) 0 ;
arg1 = (XTools::Room *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_AnchorDownloadRequest_GetAnchorName___(void * jarg1) {
void * jresult ;
XTools::AnchorDownloadRequest *arg1 = (XTools::AnchorDownloadRequest *) 0 ;
XTools::XStringPtr result;
arg1 = (XTools::AnchorDownloadRequest *)jarg1;
result = ((XTools::AnchorDownloadRequest const *)arg1)->GetAnchorName();
// ref_ptr by value out
if (result) {
result->AddRef();
*( XString **)&jresult = (&result)->get();
} else {
*( XString **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_AnchorDownloadRequest_GetRoom___(void * jarg1) {
void * jresult ;
XTools::AnchorDownloadRequest *arg1 = (XTools::AnchorDownloadRequest *) 0 ;
XTools::RoomPtr result;
arg1 = (XTools::AnchorDownloadRequest *)jarg1;
result = ((XTools::AnchorDownloadRequest const *)arg1)->GetRoom();
// ref_ptr by value out
if (result) {
result->AddRef();
*( Room **)&jresult = (&result)->get();
} else {
*( Room **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_AnchorDownloadRequest_GetDataSize___(void * jarg1) {
int jresult ;
XTools::AnchorDownloadRequest *arg1 = (XTools::AnchorDownloadRequest *) 0 ;
XTools::int32 result;
arg1 = (XTools::AnchorDownloadRequest *)jarg1;
result = (XTools::int32)((XTools::AnchorDownloadRequest const *)arg1)->GetDataSize();
jresult = result;
return jresult;
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_AnchorDownloadRequest_GetData___(void * jarg1, unsigned char* jarg2, int jarg3) {
unsigned int jresult ;
XTools::AnchorDownloadRequest *arg1 = (XTools::AnchorDownloadRequest *) 0 ;
XTools::byte *arg2 = (XTools::byte *) 0 ;
XTools::int32 arg3 ;
bool result;
arg1 = (XTools::AnchorDownloadRequest *)jarg1;
arg2 = jarg2;
arg3 = (XTools::int32)jarg3;
result = (bool)((XTools::AnchorDownloadRequest const *)arg1)->GetData(arg2,arg3);
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_AnchorDownloadRequest___(void * jarg1) {
XTools::AnchorDownloadRequest *arg1 = (XTools::AnchorDownloadRequest *) 0 ;
arg1 = (XTools::AnchorDownloadRequest *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_RoomManagerListener___(void * jarg1) {
XTools::RoomManagerListener *arg1 = (XTools::RoomManagerListener *) 0 ;
arg1 = (XTools::RoomManagerListener *)jarg1;
delete arg1;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManagerListener_OnRoomAdded___(void * jarg1, void * jarg2) {
XTools::RoomManagerListener *arg1 = (XTools::RoomManagerListener *) 0 ;
XTools::RoomPtr *arg2 = 0 ;
XTools::RoomPtr tempnull2 ;
XTools::RoomPtr temp2 ;
XTools::Room *smartarg2 ;
arg1 = (XTools::RoomManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Room **)&jarg2;
temp2 = XTools::ref_ptr< Room >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->OnRoomAdded((XTools::RoomPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManagerListener_OnRoomAddedSwigExplicitRoomManagerListener___(void * jarg1, void * jarg2) {
XTools::RoomManagerListener *arg1 = (XTools::RoomManagerListener *) 0 ;
XTools::RoomPtr *arg2 = 0 ;
XTools::RoomPtr tempnull2 ;
XTools::RoomPtr temp2 ;
XTools::Room *smartarg2 ;
arg1 = (XTools::RoomManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Room **)&jarg2;
temp2 = XTools::ref_ptr< Room >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->XTools::RoomManagerListener::OnRoomAdded((XTools::RoomPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManagerListener_OnRoomClosed___(void * jarg1, void * jarg2) {
XTools::RoomManagerListener *arg1 = (XTools::RoomManagerListener *) 0 ;
XTools::RoomPtr *arg2 = 0 ;
XTools::RoomPtr tempnull2 ;
XTools::RoomPtr temp2 ;
XTools::Room *smartarg2 ;
arg1 = (XTools::RoomManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Room **)&jarg2;
temp2 = XTools::ref_ptr< Room >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->OnRoomClosed((XTools::RoomPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManagerListener_OnRoomClosedSwigExplicitRoomManagerListener___(void * jarg1, void * jarg2) {
XTools::RoomManagerListener *arg1 = (XTools::RoomManagerListener *) 0 ;
XTools::RoomPtr *arg2 = 0 ;
XTools::RoomPtr tempnull2 ;
XTools::RoomPtr temp2 ;
XTools::Room *smartarg2 ;
arg1 = (XTools::RoomManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Room **)&jarg2;
temp2 = XTools::ref_ptr< Room >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->XTools::RoomManagerListener::OnRoomClosed((XTools::RoomPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManagerListener_OnUserJoinedRoom___(void * jarg1, void * jarg2, int jarg3) {
XTools::RoomManagerListener *arg1 = (XTools::RoomManagerListener *) 0 ;
XTools::RoomPtr *arg2 = 0 ;
XTools::UserID arg3 ;
XTools::RoomPtr tempnull2 ;
XTools::RoomPtr temp2 ;
XTools::Room *smartarg2 ;
arg1 = (XTools::RoomManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Room **)&jarg2;
temp2 = XTools::ref_ptr< Room >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (XTools::UserID)jarg3;
(arg1)->OnUserJoinedRoom((XTools::RoomPtr const &)*arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManagerListener_OnUserJoinedRoomSwigExplicitRoomManagerListener___(void * jarg1, void * jarg2, int jarg3) {
XTools::RoomManagerListener *arg1 = (XTools::RoomManagerListener *) 0 ;
XTools::RoomPtr *arg2 = 0 ;
XTools::UserID arg3 ;
XTools::RoomPtr tempnull2 ;
XTools::RoomPtr temp2 ;
XTools::Room *smartarg2 ;
arg1 = (XTools::RoomManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Room **)&jarg2;
temp2 = XTools::ref_ptr< Room >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (XTools::UserID)jarg3;
(arg1)->XTools::RoomManagerListener::OnUserJoinedRoom((XTools::RoomPtr const &)*arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManagerListener_OnUserLeftRoom___(void * jarg1, void * jarg2, int jarg3) {
XTools::RoomManagerListener *arg1 = (XTools::RoomManagerListener *) 0 ;
XTools::RoomPtr *arg2 = 0 ;
XTools::UserID arg3 ;
XTools::RoomPtr tempnull2 ;
XTools::RoomPtr temp2 ;
XTools::Room *smartarg2 ;
arg1 = (XTools::RoomManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Room **)&jarg2;
temp2 = XTools::ref_ptr< Room >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (XTools::UserID)jarg3;
(arg1)->OnUserLeftRoom((XTools::RoomPtr const &)*arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManagerListener_OnUserLeftRoomSwigExplicitRoomManagerListener___(void * jarg1, void * jarg2, int jarg3) {
XTools::RoomManagerListener *arg1 = (XTools::RoomManagerListener *) 0 ;
XTools::RoomPtr *arg2 = 0 ;
XTools::UserID arg3 ;
XTools::RoomPtr tempnull2 ;
XTools::RoomPtr temp2 ;
XTools::Room *smartarg2 ;
arg1 = (XTools::RoomManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Room **)&jarg2;
temp2 = XTools::ref_ptr< Room >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (XTools::UserID)jarg3;
(arg1)->XTools::RoomManagerListener::OnUserLeftRoom((XTools::RoomPtr const &)*arg2,arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManagerListener_OnAnchorsChanged___(void * jarg1, void * jarg2) {
XTools::RoomManagerListener *arg1 = (XTools::RoomManagerListener *) 0 ;
XTools::RoomPtr *arg2 = 0 ;
XTools::RoomPtr tempnull2 ;
XTools::RoomPtr temp2 ;
XTools::Room *smartarg2 ;
arg1 = (XTools::RoomManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Room **)&jarg2;
temp2 = XTools::ref_ptr< Room >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->OnAnchorsChanged((XTools::RoomPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManagerListener_OnAnchorsChangedSwigExplicitRoomManagerListener___(void * jarg1, void * jarg2) {
XTools::RoomManagerListener *arg1 = (XTools::RoomManagerListener *) 0 ;
XTools::RoomPtr *arg2 = 0 ;
XTools::RoomPtr tempnull2 ;
XTools::RoomPtr temp2 ;
XTools::Room *smartarg2 ;
arg1 = (XTools::RoomManagerListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Room **)&jarg2;
temp2 = XTools::ref_ptr< Room >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->XTools::RoomManagerListener::OnAnchorsChanged((XTools::RoomPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManagerListener_OnAnchorsDownloaded___(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
XTools::RoomManagerListener *arg1 = (XTools::RoomManagerListener *) 0 ;
bool arg2 ;
XTools::AnchorDownloadRequestPtr *arg3 = 0 ;
XTools::XStringPtr *arg4 = 0 ;
XTools::AnchorDownloadRequestPtr tempnull3 ;
XTools::AnchorDownloadRequestPtr temp3 ;
XTools::AnchorDownloadRequest *smartarg3 ;
XTools::XStringPtr tempnull4 ;
XTools::XStringPtr temp4 ;
XTools::XString *smartarg4 ;
arg1 = (XTools::RoomManagerListener *)jarg1;
arg2 = jarg2 ? true : false;
// ref_ptr by reference in
if ( jarg3 ) {
smartarg3 = *( AnchorDownloadRequest **)&jarg3;
temp3 = XTools::ref_ptr< AnchorDownloadRequest >(smartarg3);
arg3 = &temp3;
} else {
arg3 = &tempnull3;
}
// ref_ptr by reference in
if ( jarg4 ) {
smartarg4 = *( XString **)&jarg4;
temp4 = XTools::ref_ptr< XString >(smartarg4);
arg4 = &temp4;
} else {
arg4 = &tempnull4;
}
(arg1)->OnAnchorsDownloaded(arg2,(XTools::AnchorDownloadRequestPtr const &)*arg3,(XTools::XStringPtr const &)*arg4);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManagerListener_OnAnchorsDownloadedSwigExplicitRoomManagerListener___(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
XTools::RoomManagerListener *arg1 = (XTools::RoomManagerListener *) 0 ;
bool arg2 ;
XTools::AnchorDownloadRequestPtr *arg3 = 0 ;
XTools::XStringPtr *arg4 = 0 ;
XTools::AnchorDownloadRequestPtr tempnull3 ;
XTools::AnchorDownloadRequestPtr temp3 ;
XTools::AnchorDownloadRequest *smartarg3 ;
XTools::XStringPtr tempnull4 ;
XTools::XStringPtr temp4 ;
XTools::XString *smartarg4 ;
arg1 = (XTools::RoomManagerListener *)jarg1;
arg2 = jarg2 ? true : false;
// ref_ptr by reference in
if ( jarg3 ) {
smartarg3 = *( AnchorDownloadRequest **)&jarg3;
temp3 = XTools::ref_ptr< AnchorDownloadRequest >(smartarg3);
arg3 = &temp3;
} else {
arg3 = &tempnull3;
}
// ref_ptr by reference in
if ( jarg4 ) {
smartarg4 = *( XString **)&jarg4;
temp4 = XTools::ref_ptr< XString >(smartarg4);
arg4 = &temp4;
} else {
arg4 = &tempnull4;
}
(arg1)->XTools::RoomManagerListener::OnAnchorsDownloaded(arg2,(XTools::AnchorDownloadRequestPtr const &)*arg3,(XTools::XStringPtr const &)*arg4);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManagerListener_OnAnchorUploadComplete___(void * jarg1, unsigned int jarg2, void * jarg3) {
XTools::RoomManagerListener *arg1 = (XTools::RoomManagerListener *) 0 ;
bool arg2 ;
XTools::XStringPtr *arg3 = 0 ;
XTools::XStringPtr tempnull3 ;
XTools::XStringPtr temp3 ;
XTools::XString *smartarg3 ;
arg1 = (XTools::RoomManagerListener *)jarg1;
arg2 = jarg2 ? true : false;
// ref_ptr by reference in
if ( jarg3 ) {
smartarg3 = *( XString **)&jarg3;
temp3 = XTools::ref_ptr< XString >(smartarg3);
arg3 = &temp3;
} else {
arg3 = &tempnull3;
}
(arg1)->OnAnchorUploadComplete(arg2,(XTools::XStringPtr const &)*arg3);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManagerListener_OnAnchorUploadCompleteSwigExplicitRoomManagerListener___(void * jarg1, unsigned int jarg2, void * jarg3) {
XTools::RoomManagerListener *arg1 = (XTools::RoomManagerListener *) 0 ;
bool arg2 ;
XTools::XStringPtr *arg3 = 0 ;
XTools::XStringPtr tempnull3 ;
XTools::XStringPtr temp3 ;
XTools::XString *smartarg3 ;
arg1 = (XTools::RoomManagerListener *)jarg1;
arg2 = jarg2 ? true : false;
// ref_ptr by reference in
if ( jarg3 ) {
smartarg3 = *( XString **)&jarg3;
temp3 = XTools::ref_ptr< XString >(smartarg3);
arg3 = &temp3;
} else {
arg3 = &tempnull3;
}
(arg1)->XTools::RoomManagerListener::OnAnchorUploadComplete(arg2,(XTools::XStringPtr const &)*arg3);
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_RoomManagerListener___() {
void * jresult ;
XTools::RoomManagerListener *result = 0 ;
result = (XTools::RoomManagerListener *)new SwigDirector_RoomManagerListener();
jresult = (void *)result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManagerListener_director_connect___(void *objarg, SwigDirector_RoomManagerListener::SWIG_Callback0_t callback0, SwigDirector_RoomManagerListener::SWIG_Callback1_t callback1, SwigDirector_RoomManagerListener::SWIG_Callback2_t callback2, SwigDirector_RoomManagerListener::SWIG_Callback3_t callback3, SwigDirector_RoomManagerListener::SWIG_Callback4_t callback4, SwigDirector_RoomManagerListener::SWIG_Callback5_t callback5, SwigDirector_RoomManagerListener::SWIG_Callback6_t callback6) {
XTools::RoomManagerListener *obj = (XTools::RoomManagerListener *)objarg;
SwigDirector_RoomManagerListener *director = dynamic_cast<SwigDirector_RoomManagerListener *>(obj);
if (director) {
director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6);
}
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManager_AddListener___(void * jarg1, void * jarg2) {
XTools::RoomManager *arg1 = (XTools::RoomManager *) 0 ;
XTools::RoomManagerListener *arg2 = (XTools::RoomManagerListener *) 0 ;
arg1 = (XTools::RoomManager *)jarg1;
arg2 = (XTools::RoomManagerListener *)jarg2;
(arg1)->AddListener(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManager_RemoveListener___(void * jarg1, void * jarg2) {
XTools::RoomManager *arg1 = (XTools::RoomManager *) 0 ;
XTools::RoomManagerListener *arg2 = (XTools::RoomManagerListener *) 0 ;
arg1 = (XTools::RoomManager *)jarg1;
arg2 = (XTools::RoomManagerListener *)jarg2;
(arg1)->RemoveListener(arg2);
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManager_GetRoomCount___(void * jarg1) {
int jresult ;
XTools::RoomManager *arg1 = (XTools::RoomManager *) 0 ;
XTools::int32 result;
arg1 = (XTools::RoomManager *)jarg1;
result = (XTools::int32)((XTools::RoomManager const *)arg1)->GetRoomCount();
jresult = result;
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManager_GetRoom___(void * jarg1, int jarg2) {
void * jresult ;
XTools::RoomManager *arg1 = (XTools::RoomManager *) 0 ;
XTools::int32 arg2 ;
XTools::RoomPtr result;
arg1 = (XTools::RoomManager *)jarg1;
arg2 = (XTools::int32)jarg2;
result = (arg1)->GetRoom(arg2);
// ref_ptr by value out
if (result) {
result->AddRef();
*( Room **)&jresult = (&result)->get();
} else {
*( Room **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManager_GetCurrentRoom___(void * jarg1) {
void * jresult ;
XTools::RoomManager *arg1 = (XTools::RoomManager *) 0 ;
XTools::RoomPtr result;
arg1 = (XTools::RoomManager *)jarg1;
result = (arg1)->GetCurrentRoom();
// ref_ptr by value out
if (result) {
result->AddRef();
*( Room **)&jresult = (&result)->get();
} else {
*( Room **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManager_CreateRoom___(void * jarg1, void * jarg2, long long jarg3, unsigned int jarg4) {
void * jresult ;
XTools::RoomManager *arg1 = (XTools::RoomManager *) 0 ;
XTools::XStringPtr *arg2 = 0 ;
XTools::RoomID arg3 ;
bool arg4 ;
XTools::XStringPtr tempnull2 ;
XTools::XStringPtr temp2 ;
XTools::XString *smartarg2 ;
XTools::RoomPtr result;
arg1 = (XTools::RoomManager *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( XString **)&jarg2;
temp2 = XTools::ref_ptr< XString >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (XTools::RoomID)jarg3;
arg4 = jarg4 ? true : false;
result = (arg1)->CreateRoom((XTools::XStringPtr const &)*arg2,arg3,arg4);
// ref_ptr by value out
if (result) {
result->AddRef();
*( Room **)&jresult = (&result)->get();
} else {
*( Room **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManager_JoinRoom___(void * jarg1, void * jarg2) {
unsigned int jresult ;
XTools::RoomManager *arg1 = (XTools::RoomManager *) 0 ;
XTools::RoomPtr *arg2 = 0 ;
XTools::RoomPtr tempnull2 ;
XTools::RoomPtr temp2 ;
XTools::Room *smartarg2 ;
bool result;
arg1 = (XTools::RoomManager *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Room **)&jarg2;
temp2 = XTools::ref_ptr< Room >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
result = (bool)(arg1)->JoinRoom((XTools::RoomPtr const &)*arg2);
jresult = result;
return jresult;
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManager_LeaveRoom___(void * jarg1) {
unsigned int jresult ;
XTools::RoomManager *arg1 = (XTools::RoomManager *) 0 ;
bool result;
arg1 = (XTools::RoomManager *)jarg1;
result = (bool)(arg1)->LeaveRoom();
jresult = result;
return jresult;
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManager_DownloadAnchor___(void * jarg1, void * jarg2, void * jarg3) {
unsigned int jresult ;
XTools::RoomManager *arg1 = (XTools::RoomManager *) 0 ;
XTools::RoomPtr *arg2 = 0 ;
XTools::XStringPtr *arg3 = 0 ;
XTools::RoomPtr tempnull2 ;
XTools::RoomPtr temp2 ;
XTools::Room *smartarg2 ;
XTools::XStringPtr tempnull3 ;
XTools::XStringPtr temp3 ;
XTools::XString *smartarg3 ;
bool result;
arg1 = (XTools::RoomManager *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Room **)&jarg2;
temp2 = XTools::ref_ptr< Room >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
// ref_ptr by reference in
if ( jarg3 ) {
smartarg3 = *( XString **)&jarg3;
temp3 = XTools::ref_ptr< XString >(smartarg3);
arg3 = &temp3;
} else {
arg3 = &tempnull3;
}
result = (bool)(arg1)->DownloadAnchor((XTools::RoomPtr const &)*arg2,(XTools::XStringPtr const &)*arg3);
jresult = result;
return jresult;
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManager_UploadAnchor___(void * jarg1, void * jarg2, void * jarg3, unsigned char* jarg4, int jarg5) {
unsigned int jresult ;
XTools::RoomManager *arg1 = (XTools::RoomManager *) 0 ;
XTools::RoomPtr *arg2 = 0 ;
XTools::XStringPtr *arg3 = 0 ;
XTools::byte *arg4 = (XTools::byte *) 0 ;
XTools::int32 arg5 ;
XTools::RoomPtr tempnull2 ;
XTools::RoomPtr temp2 ;
XTools::Room *smartarg2 ;
XTools::XStringPtr tempnull3 ;
XTools::XStringPtr temp3 ;
XTools::XString *smartarg3 ;
bool result;
arg1 = (XTools::RoomManager *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( Room **)&jarg2;
temp2 = XTools::ref_ptr< Room >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
// ref_ptr by reference in
if ( jarg3 ) {
smartarg3 = *( XString **)&jarg3;
temp3 = XTools::ref_ptr< XString >(smartarg3);
arg3 = &temp3;
} else {
arg3 = &tempnull3;
}
arg4 = jarg4;
arg5 = (XTools::int32)jarg5;
result = (bool)(arg1)->UploadAnchor((XTools::RoomPtr const &)*arg2,(XTools::XStringPtr const &)*arg3,(XTools::byte const *)arg4,arg5);
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_RoomManager___(void * jarg1) {
XTools::RoomManager *arg1 = (XTools::RoomManager *) 0 ;
arg1 = (XTools::RoomManager *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_Settings___() {
void * jresult ;
XTools::Settings *result = 0 ;
result = (XTools::Settings *)new XTools::Settings();
jresult = (void *)result;
if(result) result->AddRef();
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Settings_GetServerAddress___(void * jarg1) {
void * jresult ;
XTools::Settings *arg1 = (XTools::Settings *) 0 ;
XTools::XStringPtr *result = 0 ;
arg1 = (XTools::Settings *)jarg1;
result = (XTools::XStringPtr *) &((XTools::Settings const *)arg1)->GetServerAddress();
// ref_ptr by reference out
if (*result) {
result->get()->AddRef();
*( XString **)&jresult = result->get();
} else {
*( XString **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Settings_GetServerPort___(void * jarg1) {
int jresult ;
XTools::Settings *arg1 = (XTools::Settings *) 0 ;
XTools::int32 result;
arg1 = (XTools::Settings *)jarg1;
result = (XTools::int32)((XTools::Settings const *)arg1)->GetServerPort();
jresult = result;
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Settings_GetViewerAddress___(void * jarg1) {
void * jresult ;
XTools::Settings *arg1 = (XTools::Settings *) 0 ;
XTools::XStringPtr *result = 0 ;
arg1 = (XTools::Settings *)jarg1;
result = (XTools::XStringPtr *) &((XTools::Settings const *)arg1)->GetViewerAddress();
// ref_ptr by reference out
if (*result) {
result->get()->AddRef();
*( XString **)&jresult = result->get();
} else {
*( XString **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Settings_GetViewerPort___(void * jarg1) {
int jresult ;
XTools::Settings *arg1 = (XTools::Settings *) 0 ;
XTools::int32 result;
arg1 = (XTools::Settings *)jarg1;
result = (XTools::int32)((XTools::Settings const *)arg1)->GetViewerPort();
jresult = result;
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_Settings_GetLocalUserName___(void * jarg1) {
void * jresult ;
XTools::Settings *arg1 = (XTools::Settings *) 0 ;
XTools::XStringPtr *result = 0 ;
arg1 = (XTools::Settings *)jarg1;
result = (XTools::XStringPtr *) &((XTools::Settings const *)arg1)->GetLocalUserName();
// ref_ptr by reference out
if (*result) {
result->get()->AddRef();
*( XString **)&jresult = result->get();
} else {
*( XString **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_Settings___(void * jarg1) {
XTools::Settings *arg1 = (XTools::Settings *) 0 ;
arg1 = (XTools::Settings *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairMaker_IsReceiver___(void * jarg1) {
unsigned int jresult ;
XTools::PairMaker *arg1 = (XTools::PairMaker *) 0 ;
bool result;
arg1 = (XTools::PairMaker *)jarg1;
result = (bool)(arg1)->IsReceiver();
jresult = result;
return jresult;
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairMaker_IsReceiverSwigExplicitPairMaker___(void * jarg1) {
unsigned int jresult ;
XTools::PairMaker *arg1 = (XTools::PairMaker *) 0 ;
bool result;
arg1 = (XTools::PairMaker *)jarg1;
result = (bool)(arg1)->XTools::PairMaker::IsReceiver();
jresult = result;
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairMaker_GetAddressCount___(void * jarg1) {
int jresult ;
XTools::PairMaker *arg1 = (XTools::PairMaker *) 0 ;
XTools::int32 result;
arg1 = (XTools::PairMaker *)jarg1;
result = (XTools::int32)(arg1)->GetAddressCount();
jresult = result;
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairMaker_GetAddress___(void * jarg1, int jarg2) {
void * jresult ;
XTools::PairMaker *arg1 = (XTools::PairMaker *) 0 ;
XTools::int32 arg2 ;
XTools::XStringPtr result;
arg1 = (XTools::PairMaker *)jarg1;
arg2 = (XTools::int32)jarg2;
result = (arg1)->GetAddress(arg2);
// ref_ptr by value out
if (result) {
result->AddRef();
*( XString **)&jresult = (&result)->get();
} else {
*( XString **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairMaker_GetAddressSwigExplicitPairMaker___(void * jarg1, int jarg2) {
void * jresult ;
XTools::PairMaker *arg1 = (XTools::PairMaker *) 0 ;
XTools::int32 arg2 ;
XTools::XStringPtr result;
arg1 = (XTools::PairMaker *)jarg1;
arg2 = (XTools::int32)jarg2;
result = (arg1)->XTools::PairMaker::GetAddress(arg2);
// ref_ptr by value out
if (result) {
result->AddRef();
*( XString **)&jresult = (&result)->get();
} else {
*( XString **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT unsigned short SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairMaker_GetPort___(void * jarg1) {
unsigned short jresult ;
XTools::PairMaker *arg1 = (XTools::PairMaker *) 0 ;
XTools::uint16 result;
arg1 = (XTools::PairMaker *)jarg1;
result = (XTools::uint16)(arg1)->GetPort();
jresult = result;
return jresult;
}
SWIGEXPORT unsigned short SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairMaker_GetPortSwigExplicitPairMaker___(void * jarg1) {
unsigned short jresult ;
XTools::PairMaker *arg1 = (XTools::PairMaker *) 0 ;
XTools::uint16 result;
arg1 = (XTools::PairMaker *)jarg1;
result = (XTools::uint16)(arg1)->XTools::PairMaker::GetPort();
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairMaker_Update___(void * jarg1) {
XTools::PairMaker *arg1 = (XTools::PairMaker *) 0 ;
arg1 = (XTools::PairMaker *)jarg1;
(arg1)->Update();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairMaker_UpdateSwigExplicitPairMaker___(void * jarg1) {
XTools::PairMaker *arg1 = (XTools::PairMaker *) 0 ;
arg1 = (XTools::PairMaker *)jarg1;
(arg1)->XTools::PairMaker::Update();
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairMaker_IsReadyToConnect___(void * jarg1) {
unsigned int jresult ;
XTools::PairMaker *arg1 = (XTools::PairMaker *) 0 ;
bool result;
arg1 = (XTools::PairMaker *)jarg1;
result = (bool)(arg1)->IsReadyToConnect();
jresult = result;
return jresult;
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairMaker_IsReadyToConnectSwigExplicitPairMaker___(void * jarg1) {
unsigned int jresult ;
XTools::PairMaker *arg1 = (XTools::PairMaker *) 0 ;
bool result;
arg1 = (XTools::PairMaker *)jarg1;
result = (bool)(arg1)->XTools::PairMaker::IsReadyToConnect();
jresult = result;
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairMaker_GetLocalKey___(void * jarg1) {
int jresult ;
XTools::PairMaker *arg1 = (XTools::PairMaker *) 0 ;
XTools::int32 result;
arg1 = (XTools::PairMaker *)jarg1;
result = (XTools::int32)(arg1)->GetLocalKey();
jresult = result;
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairMaker_GetLocalKeySwigExplicitPairMaker___(void * jarg1) {
int jresult ;
XTools::PairMaker *arg1 = (XTools::PairMaker *) 0 ;
XTools::int32 result;
arg1 = (XTools::PairMaker *)jarg1;
result = (XTools::int32)(arg1)->XTools::PairMaker::GetLocalKey();
jresult = result;
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairMaker_GetRemoteKey___(void * jarg1) {
int jresult ;
XTools::PairMaker *arg1 = (XTools::PairMaker *) 0 ;
XTools::int32 result;
arg1 = (XTools::PairMaker *)jarg1;
result = (XTools::int32)(arg1)->GetRemoteKey();
jresult = result;
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairMaker_GetRemoteKeySwigExplicitPairMaker___(void * jarg1) {
int jresult ;
XTools::PairMaker *arg1 = (XTools::PairMaker *) 0 ;
XTools::int32 result;
arg1 = (XTools::PairMaker *)jarg1;
result = (XTools::int32)(arg1)->XTools::PairMaker::GetRemoteKey();
jresult = result;
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_PairMaker___() {
void * jresult ;
XTools::PairMaker *result = 0 ;
result = (XTools::PairMaker *)new SwigDirector_PairMaker();
jresult = (void *)result;
if(result) result->AddRef();
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_PairMaker___(void * jarg1) {
XTools::PairMaker *arg1 = (XTools::PairMaker *) 0 ;
arg1 = (XTools::PairMaker *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairMaker_director_connect___(void *objarg, SwigDirector_PairMaker::SWIG_Callback0_t callback0, SwigDirector_PairMaker::SWIG_Callback1_t callback1, SwigDirector_PairMaker::SWIG_Callback2_t callback2, SwigDirector_PairMaker::SWIG_Callback3_t callback3, SwigDirector_PairMaker::SWIG_Callback4_t callback4, SwigDirector_PairMaker::SWIG_Callback5_t callback5, SwigDirector_PairMaker::SWIG_Callback6_t callback6, SwigDirector_PairMaker::SWIG_Callback7_t callback7) {
XTools::PairMaker *obj = (XTools::PairMaker *)objarg;
SwigDirector_PairMaker *director = dynamic_cast<SwigDirector_PairMaker *>(obj);
if (director) {
director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
}
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairingListener_PairingConnectionSucceeded___(void * jarg1) {
XTools::PairingListener *arg1 = (XTools::PairingListener *) 0 ;
arg1 = (XTools::PairingListener *)jarg1;
(arg1)->PairingConnectionSucceeded();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairingListener_PairingConnectionSucceededSwigExplicitPairingListener___(void * jarg1) {
XTools::PairingListener *arg1 = (XTools::PairingListener *) 0 ;
arg1 = (XTools::PairingListener *)jarg1;
(arg1)->XTools::PairingListener::PairingConnectionSucceeded();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairingListener_PairingConnectionFailed___(void * jarg1, int jarg2) {
XTools::PairingListener *arg1 = (XTools::PairingListener *) 0 ;
XTools::PairingResult arg2 ;
arg1 = (XTools::PairingListener *)jarg1;
arg2 = (XTools::PairingResult)jarg2;
(arg1)->PairingConnectionFailed(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairingListener_PairingConnectionFailedSwigExplicitPairingListener___(void * jarg1, int jarg2) {
XTools::PairingListener *arg1 = (XTools::PairingListener *) 0 ;
XTools::PairingResult arg2 ;
arg1 = (XTools::PairingListener *)jarg1;
arg2 = (XTools::PairingResult)jarg2;
(arg1)->XTools::PairingListener::PairingConnectionFailed(arg2);
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_PairingListener___() {
void * jresult ;
XTools::PairingListener *result = 0 ;
result = (XTools::PairingListener *)new SwigDirector_PairingListener();
jresult = (void *)result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_PairingListener___(void * jarg1) {
XTools::PairingListener *arg1 = (XTools::PairingListener *) 0 ;
arg1 = (XTools::PairingListener *)jarg1;
delete arg1;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairingListener_director_connect___(void *objarg, SwigDirector_PairingListener::SWIG_Callback0_t callback0, SwigDirector_PairingListener::SWIG_Callback1_t callback1) {
XTools::PairingListener *obj = (XTools::PairingListener *)objarg;
SwigDirector_PairingListener *director = dynamic_cast<SwigDirector_PairingListener *>(obj);
if (director) {
director->swig_connect_director(callback0, callback1);
}
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairingManager_HasPairingInfo___(void * jarg1) {
unsigned int jresult ;
XTools::PairingManager *arg1 = (XTools::PairingManager *) 0 ;
bool result;
arg1 = (XTools::PairingManager *)jarg1;
result = (bool)((XTools::PairingManager const *)arg1)->HasPairingInfo();
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairingManager_ClearPairingInfo___(void * jarg1) {
XTools::PairingManager *arg1 = (XTools::PairingManager *) 0 ;
arg1 = (XTools::PairingManager *)jarg1;
(arg1)->ClearPairingInfo();
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairingManager_BeginConnecting___(void * jarg1, void * jarg2) {
unsigned int jresult ;
XTools::PairingManager *arg1 = (XTools::PairingManager *) 0 ;
XTools::PairingListener *arg2 = (XTools::PairingListener *) 0 ;
bool result;
arg1 = (XTools::PairingManager *)jarg1;
arg2 = (XTools::PairingListener *)jarg2;
result = (bool)(arg1)->BeginConnecting(arg2);
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairingManager_CancelConnecting___(void * jarg1) {
XTools::PairingManager *arg1 = (XTools::PairingManager *) 0 ;
arg1 = (XTools::PairingManager *)jarg1;
(arg1)->CancelConnecting();
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairingManager_BeginPairing___(void * jarg1, void * jarg2, void * jarg3) {
int jresult ;
XTools::PairingManager *arg1 = (XTools::PairingManager *) 0 ;
XTools::PairMakerPtr *arg2 = 0 ;
XTools::PairingListener *arg3 = (XTools::PairingListener *) 0 ;
XTools::PairMakerPtr tempnull2 ;
XTools::PairMakerPtr temp2 ;
XTools::PairMaker *smartarg2 ;
XTools::PairingResult result;
arg1 = (XTools::PairingManager *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( PairMaker **)&jarg2;
temp2 = XTools::ref_ptr< PairMaker >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (XTools::PairingListener *)jarg3;
result = (XTools::PairingResult)(arg1)->BeginPairing((XTools::PairMakerPtr const &)*arg2,arg3);
jresult = (int)result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairingManager_CancelPairing___(void * jarg1) {
XTools::PairingManager *arg1 = (XTools::PairingManager *) 0 ;
arg1 = (XTools::PairingManager *)jarg1;
(arg1)->CancelPairing();
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairingManager_IsPairing___(void * jarg1) {
unsigned int jresult ;
XTools::PairingManager *arg1 = (XTools::PairingManager *) 0 ;
bool result;
arg1 = (XTools::PairingManager *)jarg1;
result = (bool)((XTools::PairingManager const *)arg1)->IsPairing();
jresult = result;
return jresult;
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairingManager_IsConnected___(void * jarg1) {
unsigned int jresult ;
XTools::PairingManager *arg1 = (XTools::PairingManager *) 0 ;
bool result;
arg1 = (XTools::PairingManager *)jarg1;
result = (bool)((XTools::PairingManager const *)arg1)->IsConnected();
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_PairingManager___(void * jarg1) {
XTools::PairingManager *arg1 = (XTools::PairingManager *) 0 ;
arg1 = (XTools::PairingManager *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SharingManager_Create___(void * jarg1) {
void * jresult ;
XTools::ClientConfigPtr *arg1 = 0 ;
XTools::ClientConfigPtr tempnull1 ;
XTools::ClientConfigPtr temp1 ;
XTools::ClientConfig *smartarg1 ;
XTools::ref_ptr< XTools::SharingManager > result;
// ref_ptr by reference in
if ( jarg1 ) {
smartarg1 = *( ClientConfig **)&jarg1;
temp1 = XTools::ref_ptr< ClientConfig >(smartarg1);
arg1 = &temp1;
} else {
arg1 = &tempnull1;
}
result = XTools::SharingManager::Create((XTools::ref_ptr< XTools::ClientConfig > const &)*arg1);
// ref_ptr by value out
if (result) {
result->AddRef();
*( SharingManager **)&jresult = (&result)->get();
} else {
*( SharingManager **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SharingManager_GetSessionManager___(void * jarg1) {
void * jresult ;
XTools::SharingManager *arg1 = (XTools::SharingManager *) 0 ;
XTools::SessionManagerPtr *result = 0 ;
arg1 = (XTools::SharingManager *)jarg1;
result = (XTools::SessionManagerPtr *) &((XTools::SharingManager const *)arg1)->GetSessionManager();
// ref_ptr by reference out
if (*result) {
result->get()->AddRef();
*( SessionManager **)&jresult = result->get();
} else {
*( SessionManager **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SharingManager_GetUserPresenceManager___(void * jarg1) {
void * jresult ;
XTools::SharingManager *arg1 = (XTools::SharingManager *) 0 ;
XTools::UserPresenceManagerPtr *result = 0 ;
arg1 = (XTools::SharingManager *)jarg1;
result = (XTools::UserPresenceManagerPtr *) &((XTools::SharingManager const *)arg1)->GetUserPresenceManager();
// ref_ptr by reference out
if (*result) {
result->get()->AddRef();
*( UserPresenceManager **)&jresult = result->get();
} else {
*( UserPresenceManager **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SharingManager_GetAudioManager___(void * jarg1) {
void * jresult ;
XTools::SharingManager *arg1 = (XTools::SharingManager *) 0 ;
XTools::AudioManagerPtr *result = 0 ;
arg1 = (XTools::SharingManager *)jarg1;
result = (XTools::AudioManagerPtr *) &((XTools::SharingManager const *)arg1)->GetAudioManager();
// ref_ptr by reference out
if (*result) {
result->get()->AddRef();
*( AudioManager **)&jresult = result->get();
} else {
*( AudioManager **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SharingManager_GetPairingManager___(void * jarg1) {
void * jresult ;
XTools::SharingManager *arg1 = (XTools::SharingManager *) 0 ;
XTools::PairingManagerPtr *result = 0 ;
arg1 = (XTools::SharingManager *)jarg1;
result = (XTools::PairingManagerPtr *) &((XTools::SharingManager const *)arg1)->GetPairingManager();
// ref_ptr by reference out
if (*result) {
result->get()->AddRef();
*( PairingManager **)&jresult = result->get();
} else {
*( PairingManager **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SharingManager_GetRoomManager___(void * jarg1) {
void * jresult ;
XTools::SharingManager *arg1 = (XTools::SharingManager *) 0 ;
XTools::RoomManagerPtr *result = 0 ;
arg1 = (XTools::SharingManager *)jarg1;
result = (XTools::RoomManagerPtr *) &((XTools::SharingManager const *)arg1)->GetRoomManager();
// ref_ptr by reference out
if (*result) {
result->get()->AddRef();
*( RoomManager **)&jresult = result->get();
} else {
*( RoomManager **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SharingManager_GetRootSyncObject___(void * jarg1) {
void * jresult ;
XTools::SharingManager *arg1 = (XTools::SharingManager *) 0 ;
XTools::ObjectElementPtr result;
arg1 = (XTools::SharingManager *)jarg1;
result = (arg1)->GetRootSyncObject();
// ref_ptr by value out
if (result) {
result->AddRef();
*( ObjectElement **)&jresult = (&result)->get();
} else {
*( ObjectElement **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SharingManager_RegisterSyncListener___(void * jarg1, void * jarg2) {
unsigned int jresult ;
XTools::SharingManager *arg1 = (XTools::SharingManager *) 0 ;
XTools::SyncListener *arg2 = (XTools::SyncListener *) 0 ;
bool result;
arg1 = (XTools::SharingManager *)jarg1;
arg2 = (XTools::SyncListener *)jarg2;
result = (bool)(arg1)->RegisterSyncListener(arg2);
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SharingManager_Update___(void * jarg1) {
XTools::SharingManager *arg1 = (XTools::SharingManager *) 0 ;
arg1 = (XTools::SharingManager *)jarg1;
(arg1)->Update();
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SharingManager_GetPairedConnection___(void * jarg1) {
void * jresult ;
XTools::SharingManager *arg1 = (XTools::SharingManager *) 0 ;
XTools::NetworkConnectionPtr result;
arg1 = (XTools::SharingManager *)jarg1;
result = (arg1)->GetPairedConnection();
// ref_ptr by value out
if (result) {
result->AddRef();
*( NetworkConnection **)&jresult = (&result)->get();
} else {
*( NetworkConnection **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SharingManager_GetServerConnection___(void * jarg1) {
void * jresult ;
XTools::SharingManager *arg1 = (XTools::SharingManager *) 0 ;
XTools::NetworkConnectionPtr result;
arg1 = (XTools::SharingManager *)jarg1;
result = (arg1)->GetServerConnection();
// ref_ptr by value out
if (result) {
result->AddRef();
*( NetworkConnection **)&jresult = (&result)->get();
} else {
*( NetworkConnection **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SharingManager_GetSettings___(void * jarg1) {
void * jresult ;
XTools::SharingManager *arg1 = (XTools::SharingManager *) 0 ;
XTools::SettingsPtr *result = 0 ;
arg1 = (XTools::SharingManager *)jarg1;
result = (XTools::SettingsPtr *) &(arg1)->GetSettings();
// ref_ptr by reference out
if (*result) {
result->get()->AddRef();
*( Settings **)&jresult = result->get();
} else {
*( Settings **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SharingManager_SetServerConnectionInfo___(void * jarg1, void * jarg2, unsigned int jarg3) {
XTools::SharingManager *arg1 = (XTools::SharingManager *) 0 ;
XTools::XStringPtr *arg2 = 0 ;
XTools::uint32 arg3 ;
XTools::XStringPtr tempnull2 ;
XTools::XStringPtr temp2 ;
XTools::XString *smartarg2 ;
arg1 = (XTools::SharingManager *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( XString **)&jarg2;
temp2 = XTools::ref_ptr< XString >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
arg3 = (XTools::uint32)jarg3;
(arg1)->SetServerConnectionInfo((XTools::XStringPtr const &)*arg2,arg3);
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SharingManager_GetLocalUser___(void * jarg1) {
void * jresult ;
XTools::SharingManager *arg1 = (XTools::SharingManager *) 0 ;
XTools::UserPtr result;
arg1 = (XTools::SharingManager *)jarg1;
result = (arg1)->GetLocalUser();
// ref_ptr by value out
if (result) {
result->AddRef();
*( User **)&jresult = (&result)->get();
} else {
*( User **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SharingManager_SetUserName___(void * jarg1, void * jarg2) {
XTools::SharingManager *arg1 = (XTools::SharingManager *) 0 ;
XTools::XStringPtr *arg2 = 0 ;
XTools::XStringPtr tempnull2 ;
XTools::XStringPtr temp2 ;
XTools::XString *smartarg2 ;
arg1 = (XTools::SharingManager *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( XString **)&jarg2;
temp2 = XTools::ref_ptr< XString >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->SetUserName((XTools::XStringPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_SharingManager___(void * jarg1) {
XTools::SharingManager *arg1 = (XTools::SharingManager *) 0 ;
arg1 = (XTools::SharingManager *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_DirectPairConnector__SWIG_0___() {
void * jresult ;
XTools::DirectPairConnector *result = 0 ;
result = (XTools::DirectPairConnector *)new XTools::DirectPairConnector();
jresult = (void *)result;
if(result) result->AddRef();
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_DirectPairConnector__SWIG_1___(void * jarg1) {
void * jresult ;
XTools::XStringPtr *arg1 = 0 ;
XTools::XStringPtr tempnull1 ;
XTools::XStringPtr temp1 ;
XTools::XString *smartarg1 ;
XTools::DirectPairConnector *result = 0 ;
// ref_ptr by reference in
if ( jarg1 ) {
smartarg1 = *( XString **)&jarg1;
temp1 = XTools::ref_ptr< XString >(smartarg1);
arg1 = &temp1;
} else {
arg1 = &tempnull1;
}
result = (XTools::DirectPairConnector *)new XTools::DirectPairConnector((XTools::XStringPtr const &)*arg1);
jresult = (void *)result;
if(result) result->AddRef();
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_DirectPairConnector__SWIG_2___(void * jarg1, unsigned short jarg2) {
void * jresult ;
XTools::XStringPtr *arg1 = 0 ;
XTools::uint16 arg2 ;
XTools::XStringPtr tempnull1 ;
XTools::XStringPtr temp1 ;
XTools::XString *smartarg1 ;
XTools::DirectPairConnector *result = 0 ;
// ref_ptr by reference in
if ( jarg1 ) {
smartarg1 = *( XString **)&jarg1;
temp1 = XTools::ref_ptr< XString >(smartarg1);
arg1 = &temp1;
} else {
arg1 = &tempnull1;
}
arg2 = (XTools::uint16)jarg2;
result = (XTools::DirectPairConnector *)new XTools::DirectPairConnector((XTools::XStringPtr const &)*arg1,arg2);
jresult = (void *)result;
if(result) result->AddRef();
return jresult;
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DirectPairConnector_IsReceiver___(void * jarg1) {
unsigned int jresult ;
XTools::DirectPairConnector *arg1 = (XTools::DirectPairConnector *) 0 ;
bool result;
arg1 = (XTools::DirectPairConnector *)jarg1;
result = (bool)(arg1)->IsReceiver();
jresult = result;
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DirectPairConnector_GetAddressCount___(void * jarg1) {
int jresult ;
XTools::DirectPairConnector *arg1 = (XTools::DirectPairConnector *) 0 ;
XTools::int32 result;
arg1 = (XTools::DirectPairConnector *)jarg1;
result = (XTools::int32)(arg1)->GetAddressCount();
jresult = result;
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DirectPairConnector_GetAddress___(void * jarg1, int jarg2) {
void * jresult ;
XTools::DirectPairConnector *arg1 = (XTools::DirectPairConnector *) 0 ;
XTools::int32 arg2 ;
XTools::XStringPtr result;
arg1 = (XTools::DirectPairConnector *)jarg1;
arg2 = (XTools::int32)jarg2;
result = (arg1)->GetAddress(arg2);
// ref_ptr by value out
if (result) {
result->AddRef();
*( XString **)&jresult = (&result)->get();
} else {
*( XString **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT unsigned short SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DirectPairConnector_GetPort___(void * jarg1) {
unsigned short jresult ;
XTools::DirectPairConnector *arg1 = (XTools::DirectPairConnector *) 0 ;
XTools::uint16 result;
arg1 = (XTools::DirectPairConnector *)jarg1;
result = (XTools::uint16)(arg1)->GetPort();
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DirectPairConnector_Update___(void * jarg1) {
XTools::DirectPairConnector *arg1 = (XTools::DirectPairConnector *) 0 ;
arg1 = (XTools::DirectPairConnector *)jarg1;
(arg1)->Update();
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DirectPairConnector_IsReadyToConnect___(void * jarg1) {
unsigned int jresult ;
XTools::DirectPairConnector *arg1 = (XTools::DirectPairConnector *) 0 ;
bool result;
arg1 = (XTools::DirectPairConnector *)jarg1;
result = (bool)(arg1)->IsReadyToConnect();
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DirectPairConnector_SetRemoteAddress___(void * jarg1, void * jarg2) {
XTools::DirectPairConnector *arg1 = (XTools::DirectPairConnector *) 0 ;
XTools::XStringPtr *arg2 = 0 ;
XTools::XStringPtr tempnull2 ;
XTools::XStringPtr temp2 ;
XTools::XString *smartarg2 ;
arg1 = (XTools::DirectPairConnector *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( XString **)&jarg2;
temp2 = XTools::ref_ptr< XString >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->SetRemoteAddress((XTools::XStringPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DirectPairConnector_SetRemotePort___(void * jarg1, unsigned short jarg2) {
XTools::DirectPairConnector *arg1 = (XTools::DirectPairConnector *) 0 ;
XTools::uint16 arg2 ;
arg1 = (XTools::DirectPairConnector *)jarg1;
arg2 = (XTools::uint16)jarg2;
(arg1)->SetRemotePort(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_DirectPairConnector___(void * jarg1) {
XTools::DirectPairConnector *arg1 = (XTools::DirectPairConnector *) 0 ;
arg1 = (XTools::DirectPairConnector *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_DirectPairReceiver__SWIG_0___() {
void * jresult ;
XTools::DirectPairReceiver *result = 0 ;
result = (XTools::DirectPairReceiver *)new XTools::DirectPairReceiver();
jresult = (void *)result;
if(result) result->AddRef();
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_DirectPairReceiver__SWIG_1___(unsigned short jarg1) {
void * jresult ;
XTools::uint16 arg1 ;
XTools::DirectPairReceiver *result = 0 ;
arg1 = (XTools::uint16)jarg1;
result = (XTools::DirectPairReceiver *)new XTools::DirectPairReceiver(arg1);
jresult = (void *)result;
if(result) result->AddRef();
return jresult;
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DirectPairReceiver_IsReceiver___(void * jarg1) {
unsigned int jresult ;
XTools::DirectPairReceiver *arg1 = (XTools::DirectPairReceiver *) 0 ;
bool result;
arg1 = (XTools::DirectPairReceiver *)jarg1;
result = (bool)(arg1)->IsReceiver();
jresult = result;
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DirectPairReceiver_GetAddressCount___(void * jarg1) {
int jresult ;
XTools::DirectPairReceiver *arg1 = (XTools::DirectPairReceiver *) 0 ;
XTools::int32 result;
arg1 = (XTools::DirectPairReceiver *)jarg1;
result = (XTools::int32)(arg1)->GetAddressCount();
jresult = result;
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DirectPairReceiver_GetAddress___(void * jarg1, int jarg2) {
void * jresult ;
XTools::DirectPairReceiver *arg1 = (XTools::DirectPairReceiver *) 0 ;
XTools::int32 arg2 ;
XTools::XStringPtr result;
arg1 = (XTools::DirectPairReceiver *)jarg1;
arg2 = (XTools::int32)jarg2;
result = (arg1)->GetAddress(arg2);
// ref_ptr by value out
if (result) {
result->AddRef();
*( XString **)&jresult = (&result)->get();
} else {
*( XString **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT unsigned short SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DirectPairReceiver_GetPort___(void * jarg1) {
unsigned short jresult ;
XTools::DirectPairReceiver *arg1 = (XTools::DirectPairReceiver *) 0 ;
XTools::uint16 result;
arg1 = (XTools::DirectPairReceiver *)jarg1;
result = (XTools::uint16)(arg1)->GetPort();
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DirectPairReceiver_Update___(void * jarg1) {
XTools::DirectPairReceiver *arg1 = (XTools::DirectPairReceiver *) 0 ;
arg1 = (XTools::DirectPairReceiver *)jarg1;
(arg1)->Update();
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DirectPairReceiver_IsReadyToConnect___(void * jarg1) {
unsigned int jresult ;
XTools::DirectPairReceiver *arg1 = (XTools::DirectPairReceiver *) 0 ;
bool result;
arg1 = (XTools::DirectPairReceiver *)jarg1;
result = (bool)(arg1)->IsReadyToConnect();
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DirectPairReceiver_SetIncomingPort___(void * jarg1, unsigned short jarg2) {
XTools::DirectPairReceiver *arg1 = (XTools::DirectPairReceiver *) 0 ;
XTools::uint16 arg2 ;
arg1 = (XTools::DirectPairReceiver *)jarg1;
arg2 = (XTools::uint16)jarg2;
(arg1)->SetIncomingPort(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_DirectPairReceiver___(void * jarg1) {
XTools::DirectPairReceiver *arg1 = (XTools::DirectPairReceiver *) 0 ;
arg1 = (XTools::DirectPairReceiver *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_TagImage_GetWidth___(void * jarg1) {
int jresult ;
XTools::TagImage *arg1 = (XTools::TagImage *) 0 ;
XTools::int32 result;
arg1 = (XTools::TagImage *)jarg1;
result = (XTools::int32)((XTools::TagImage const *)arg1)->GetWidth();
jresult = result;
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_TagImage_GetHeight___(void * jarg1) {
int jresult ;
XTools::TagImage *arg1 = (XTools::TagImage *) 0 ;
XTools::int32 result;
arg1 = (XTools::TagImage *)jarg1;
result = (XTools::int32)((XTools::TagImage const *)arg1)->GetHeight();
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_TagImage_CopyImageData___(void * jarg1, unsigned char* jarg2, int jarg3, int jarg4) {
XTools::TagImage *arg1 = (XTools::TagImage *) 0 ;
XTools::byte *arg2 = (XTools::byte *) 0 ;
XTools::int32 arg3 ;
XTools::int32 arg4 ;
arg1 = (XTools::TagImage *)jarg1;
arg2 = jarg2;
arg3 = (XTools::int32)jarg3;
arg4 = (XTools::int32)jarg4;
((XTools::TagImage const *)arg1)->CopyImageData(arg2,arg3,arg4);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_TagImage___(void * jarg1) {
XTools::TagImage *arg1 = (XTools::TagImage *) 0 ;
arg1 = (XTools::TagImage *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_VisualPairReceiver_Create___() {
void * jresult ;
XTools::ref_ptr< XTools::VisualPairReceiver > result;
result = XTools::VisualPairReceiver::Create();
// ref_ptr by value out
if (result) {
result->AddRef();
*( VisualPairReceiver **)&jresult = (&result)->get();
} else {
*( VisualPairReceiver **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_VisualPairReceiver_CreateTagImage___(void * jarg1) {
void * jresult ;
XTools::VisualPairReceiver *arg1 = (XTools::VisualPairReceiver *) 0 ;
XTools::TagImagePtr result;
arg1 = (XTools::VisualPairReceiver *)jarg1;
result = ((XTools::VisualPairReceiver const *)arg1)->CreateTagImage();
// ref_ptr by value out
if (result) {
result->AddRef();
*( TagImage **)&jresult = (&result)->get();
} else {
*( TagImage **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_VisualPairReceiver___(void * jarg1) {
XTools::VisualPairReceiver *arg1 = (XTools::VisualPairReceiver *) 0 ;
arg1 = (XTools::VisualPairReceiver *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_VisualPairConnector_Create___() {
void * jresult ;
XTools::ref_ptr< XTools::VisualPairConnector > result;
result = XTools::VisualPairConnector::Create();
// ref_ptr by value out
if (result) {
result->AddRef();
*( VisualPairConnector **)&jresult = (&result)->get();
} else {
*( VisualPairConnector **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_VisualPairConnector_ProcessImage___(void * jarg1, unsigned char* jarg2, int jarg3, int jarg4, int jarg5) {
unsigned int jresult ;
XTools::VisualPairConnector *arg1 = (XTools::VisualPairConnector *) 0 ;
XTools::byte *arg2 = (XTools::byte *) 0 ;
XTools::int32 arg3 ;
XTools::int32 arg4 ;
XTools::int32 arg5 ;
bool result;
arg1 = (XTools::VisualPairConnector *)jarg1;
arg2 = jarg2;
arg3 = (XTools::int32)jarg3;
arg4 = (XTools::int32)jarg4;
arg5 = (XTools::int32)jarg5;
result = (bool)(arg1)->ProcessImage(arg2,arg3,arg4,arg5);
jresult = result;
return jresult;
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_VisualPairConnector_IsProcessingImage___(void * jarg1) {
unsigned int jresult ;
XTools::VisualPairConnector *arg1 = (XTools::VisualPairConnector *) 0 ;
bool result;
arg1 = (XTools::VisualPairConnector *)jarg1;
result = (bool)((XTools::VisualPairConnector const *)arg1)->IsProcessingImage();
jresult = result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_VisualPairConnector___(void * jarg1) {
XTools::VisualPairConnector *arg1 = (XTools::VisualPairConnector *) 0 ;
arg1 = (XTools::VisualPairConnector *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_DiscoveredSystem___(char * jarg1, char * jarg2, int jarg3) {
void * jresult ;
std::string *arg1 = 0 ;
std::string *arg2 = 0 ;
XTools::SystemRole arg3 ;
XTools::DiscoveredSystem *result = 0 ;
if (!jarg1) {
SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
return 0;
}
std::string arg1_str(jarg1);
arg1 = &arg1_str;
if (!jarg2) {
SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
return 0;
}
std::string arg2_str(jarg2);
arg2 = &arg2_str;
arg3 = (XTools::SystemRole)jarg3;
result = (XTools::DiscoveredSystem *)new XTools::DiscoveredSystem((std::string const &)*arg1,(std::string const &)*arg2,arg3);
jresult = (void *)result;
if(result) result->AddRef();
return jresult;
}
SWIGEXPORT char * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DiscoveredSystem_GetName___(void * jarg1) {
char * jresult ;
XTools::DiscoveredSystem *arg1 = (XTools::DiscoveredSystem *) 0 ;
std::string result;
arg1 = (XTools::DiscoveredSystem *)jarg1;
result = ((XTools::DiscoveredSystem const *)arg1)->GetName();
jresult = SWIG_csharp_string_callback((&result)->c_str());
return jresult;
}
SWIGEXPORT char * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DiscoveredSystem_GetAddress___(void * jarg1) {
char * jresult ;
XTools::DiscoveredSystem *arg1 = (XTools::DiscoveredSystem *) 0 ;
std::string result;
arg1 = (XTools::DiscoveredSystem *)jarg1;
result = ((XTools::DiscoveredSystem const *)arg1)->GetAddress();
jresult = SWIG_csharp_string_callback((&result)->c_str());
return jresult;
}
SWIGEXPORT int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DiscoveredSystem_GetRole___(void * jarg1) {
int jresult ;
XTools::DiscoveredSystem *arg1 = (XTools::DiscoveredSystem *) 0 ;
XTools::SystemRole result;
arg1 = (XTools::DiscoveredSystem *)jarg1;
result = (XTools::SystemRole)((XTools::DiscoveredSystem const *)arg1)->GetRole();
jresult = (int)result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_DiscoveredSystem___(void * jarg1) {
XTools::DiscoveredSystem *arg1 = (XTools::DiscoveredSystem *) 0 ;
arg1 = (XTools::DiscoveredSystem *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_DiscoveryClientListener___(void * jarg1) {
XTools::DiscoveryClientListener *arg1 = (XTools::DiscoveryClientListener *) 0 ;
arg1 = (XTools::DiscoveryClientListener *)jarg1;
delete arg1;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DiscoveryClientListener_OnRemoteSystemDiscovered___(void * jarg1, void * jarg2) {
XTools::DiscoveryClientListener *arg1 = (XTools::DiscoveryClientListener *) 0 ;
XTools::DiscoveredSystemPtr *arg2 = 0 ;
XTools::DiscoveredSystemPtr tempnull2 ;
XTools::DiscoveredSystemPtr temp2 ;
XTools::DiscoveredSystem *smartarg2 ;
arg1 = (XTools::DiscoveryClientListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( DiscoveredSystem **)&jarg2;
temp2 = XTools::ref_ptr< DiscoveredSystem >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->OnRemoteSystemDiscovered((XTools::DiscoveredSystemPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DiscoveryClientListener_OnRemoteSystemDiscoveredSwigExplicitDiscoveryClientListener___(void * jarg1, void * jarg2) {
XTools::DiscoveryClientListener *arg1 = (XTools::DiscoveryClientListener *) 0 ;
XTools::DiscoveredSystemPtr *arg2 = 0 ;
XTools::DiscoveredSystemPtr tempnull2 ;
XTools::DiscoveredSystemPtr temp2 ;
XTools::DiscoveredSystem *smartarg2 ;
arg1 = (XTools::DiscoveryClientListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( DiscoveredSystem **)&jarg2;
temp2 = XTools::ref_ptr< DiscoveredSystem >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->XTools::DiscoveryClientListener::OnRemoteSystemDiscovered((XTools::DiscoveredSystemPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DiscoveryClientListener_OnRemoteSystemLost___(void * jarg1, void * jarg2) {
XTools::DiscoveryClientListener *arg1 = (XTools::DiscoveryClientListener *) 0 ;
XTools::DiscoveredSystemPtr *arg2 = 0 ;
XTools::DiscoveredSystemPtr tempnull2 ;
XTools::DiscoveredSystemPtr temp2 ;
XTools::DiscoveredSystem *smartarg2 ;
arg1 = (XTools::DiscoveryClientListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( DiscoveredSystem **)&jarg2;
temp2 = XTools::ref_ptr< DiscoveredSystem >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->OnRemoteSystemLost((XTools::DiscoveredSystemPtr const &)*arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DiscoveryClientListener_OnRemoteSystemLostSwigExplicitDiscoveryClientListener___(void * jarg1, void * jarg2) {
XTools::DiscoveryClientListener *arg1 = (XTools::DiscoveryClientListener *) 0 ;
XTools::DiscoveredSystemPtr *arg2 = 0 ;
XTools::DiscoveredSystemPtr tempnull2 ;
XTools::DiscoveredSystemPtr temp2 ;
XTools::DiscoveredSystem *smartarg2 ;
arg1 = (XTools::DiscoveryClientListener *)jarg1;
// ref_ptr by reference in
if ( jarg2 ) {
smartarg2 = *( DiscoveredSystem **)&jarg2;
temp2 = XTools::ref_ptr< DiscoveredSystem >(smartarg2);
arg2 = &temp2;
} else {
arg2 = &tempnull2;
}
(arg1)->XTools::DiscoveryClientListener::OnRemoteSystemLost((XTools::DiscoveredSystemPtr const &)*arg2);
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_new_DiscoveryClientListener___() {
void * jresult ;
XTools::DiscoveryClientListener *result = 0 ;
result = (XTools::DiscoveryClientListener *)new SwigDirector_DiscoveryClientListener();
jresult = (void *)result;
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DiscoveryClientListener_director_connect___(void *objarg, SwigDirector_DiscoveryClientListener::SWIG_Callback0_t callback0, SwigDirector_DiscoveryClientListener::SWIG_Callback1_t callback1) {
XTools::DiscoveryClientListener *obj = (XTools::DiscoveryClientListener *)objarg;
SwigDirector_DiscoveryClientListener *director = dynamic_cast<SwigDirector_DiscoveryClientListener *>(obj);
if (director) {
director->swig_connect_director(callback0, callback1);
}
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DiscoveryClient_Create___() {
void * jresult ;
XTools::ref_ptr< XTools::DiscoveryClient > result;
result = XTools::DiscoveryClient::Create();
// ref_ptr by value out
if (result) {
result->AddRef();
*( DiscoveryClient **)&jresult = (&result)->get();
} else {
*( DiscoveryClient **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DiscoveryClient_Ping___(void * jarg1) {
XTools::DiscoveryClient *arg1 = (XTools::DiscoveryClient *) 0 ;
arg1 = (XTools::DiscoveryClient *)jarg1;
(arg1)->Ping();
}
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DiscoveryClient_GetDiscoveredCount___(void * jarg1) {
unsigned int jresult ;
XTools::DiscoveryClient *arg1 = (XTools::DiscoveryClient *) 0 ;
XTools::uint32 result;
arg1 = (XTools::DiscoveryClient *)jarg1;
result = (XTools::uint32)((XTools::DiscoveryClient const *)arg1)->GetDiscoveredCount();
jresult = result;
return jresult;
}
SWIGEXPORT void * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DiscoveryClient_GetDiscoveredSystem___(void * jarg1, unsigned int jarg2) {
void * jresult ;
XTools::DiscoveryClient *arg1 = (XTools::DiscoveryClient *) 0 ;
XTools::uint32 arg2 ;
XTools::DiscoveredSystemPtr result;
arg1 = (XTools::DiscoveryClient *)jarg1;
arg2 = (XTools::uint32)jarg2;
result = ((XTools::DiscoveryClient const *)arg1)->GetDiscoveredSystem(arg2);
// ref_ptr by value out
if (result) {
result->AddRef();
*( DiscoveredSystem **)&jresult = (&result)->get();
} else {
*( DiscoveredSystem **)&jresult = 0;
}
return jresult;
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DiscoveryClient_Update___(void * jarg1) {
XTools::DiscoveryClient *arg1 = (XTools::DiscoveryClient *) 0 ;
arg1 = (XTools::DiscoveryClient *)jarg1;
(arg1)->Update();
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DiscoveryClient_AddListener___(void * jarg1, void * jarg2) {
XTools::DiscoveryClient *arg1 = (XTools::DiscoveryClient *) 0 ;
XTools::DiscoveryClientListener *arg2 = (XTools::DiscoveryClientListener *) 0 ;
arg1 = (XTools::DiscoveryClient *)jarg1;
arg2 = (XTools::DiscoveryClientListener *)jarg2;
(arg1)->AddListener(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DiscoveryClient_RemoveListener___(void * jarg1, void * jarg2) {
XTools::DiscoveryClient *arg1 = (XTools::DiscoveryClient *) 0 ;
XTools::DiscoveryClientListener *arg2 = (XTools::DiscoveryClientListener *) 0 ;
arg1 = (XTools::DiscoveryClient *)jarg1;
arg2 = (XTools::DiscoveryClientListener *)jarg2;
(arg1)->RemoveListener(arg2);
}
SWIGEXPORT void SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_delete_DiscoveryClient___(void * jarg1) {
XTools::DiscoveryClient *arg1 = (XTools::DiscoveryClient *) 0 ;
arg1 = (XTools::DiscoveryClient *)jarg1;
if(arg1) arg1->RemoveRef();
}
SWIGEXPORT XTools::Listener * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_NetworkConnectionListener_SWIGUpcast___(XTools::NetworkConnectionListener *jarg1) {
return (XTools::Listener *)jarg1;
}
SWIGEXPORT XTools::Element * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_BoolElement_SWIGUpcast___(XTools::BoolElement *jarg1) {
return (XTools::Element *)jarg1;
}
SWIGEXPORT XTools::Element * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_IntElement_SWIGUpcast___(XTools::IntElement *jarg1) {
return (XTools::Element *)jarg1;
}
SWIGEXPORT XTools::Element * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_LongElement_SWIGUpcast___(XTools::LongElement *jarg1) {
return (XTools::Element *)jarg1;
}
SWIGEXPORT XTools::Element * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_FloatElement_SWIGUpcast___(XTools::FloatElement *jarg1) {
return (XTools::Element *)jarg1;
}
SWIGEXPORT XTools::Element * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DoubleElement_SWIGUpcast___(XTools::DoubleElement *jarg1) {
return (XTools::Element *)jarg1;
}
SWIGEXPORT XTools::Element * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_StringElement_SWIGUpcast___(XTools::StringElement *jarg1) {
return (XTools::Element *)jarg1;
}
SWIGEXPORT XTools::Listener * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_IntArrayListener_SWIGUpcast___(XTools::IntArrayListener *jarg1) {
return (XTools::Listener *)jarg1;
}
SWIGEXPORT XTools::Element * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_IntArrayElement_SWIGUpcast___(XTools::IntArrayElement *jarg1) {
return (XTools::Element *)jarg1;
}
SWIGEXPORT XTools::Listener * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_FloatArrayListener_SWIGUpcast___(XTools::FloatArrayListener *jarg1) {
return (XTools::Listener *)jarg1;
}
SWIGEXPORT XTools::Element * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_FloatArrayElement_SWIGUpcast___(XTools::FloatArrayElement *jarg1) {
return (XTools::Element *)jarg1;
}
SWIGEXPORT XTools::Listener * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_StringArrayListener_SWIGUpcast___(XTools::StringArrayListener *jarg1) {
return (XTools::Listener *)jarg1;
}
SWIGEXPORT XTools::Element * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_StringArrayElement_SWIGUpcast___(XTools::StringArrayElement *jarg1) {
return (XTools::Element *)jarg1;
}
SWIGEXPORT XTools::Listener * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElementListener_SWIGUpcast___(XTools::ObjectElementListener *jarg1) {
return (XTools::Listener *)jarg1;
}
SWIGEXPORT XTools::Element * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_ObjectElement_SWIGUpcast___(XTools::ObjectElement *jarg1) {
return (XTools::Element *)jarg1;
}
SWIGEXPORT XTools::Listener * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SyncListener_SWIGUpcast___(XTools::SyncListener *jarg1) {
return (XTools::Listener *)jarg1;
}
SWIGEXPORT XTools::Listener * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionListener_SWIGUpcast___(XTools::SessionListener *jarg1) {
return (XTools::Listener *)jarg1;
}
SWIGEXPORT XTools::Listener * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_SessionManagerListener_SWIGUpcast___(XTools::SessionManagerListener *jarg1) {
return (XTools::Listener *)jarg1;
}
SWIGEXPORT XTools::Listener * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_UserPresenceManagerListener_SWIGUpcast___(XTools::UserPresenceManagerListener *jarg1) {
return (XTools::Listener *)jarg1;
}
SWIGEXPORT XTools::Listener * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_RoomManagerListener_SWIGUpcast___(XTools::RoomManagerListener *jarg1) {
return (XTools::Listener *)jarg1;
}
SWIGEXPORT XTools::Listener * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_PairingListener_SWIGUpcast___(XTools::PairingListener *jarg1) {
return (XTools::Listener *)jarg1;
}
SWIGEXPORT XTools::PairMaker * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DirectPairConnector_SWIGUpcast___(XTools::DirectPairConnector *jarg1) {
return (XTools::PairMaker *)jarg1;
}
SWIGEXPORT XTools::PairMaker * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DirectPairReceiver_SWIGUpcast___(XTools::DirectPairReceiver *jarg1) {
return (XTools::PairMaker *)jarg1;
}
SWIGEXPORT XTools::PairMaker * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_VisualPairReceiver_SWIGUpcast___(XTools::VisualPairReceiver *jarg1) {
return (XTools::PairMaker *)jarg1;
}
SWIGEXPORT XTools::PairMaker * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_VisualPairConnector_SWIGUpcast___(XTools::VisualPairConnector *jarg1) {
return (XTools::PairMaker *)jarg1;
}
SWIGEXPORT XTools::Listener * SWIGSTDCALL CSharp_MixedRealityToolkitfSharing_DiscoveryClientListener_SWIGUpcast___(XTools::DiscoveryClientListener *jarg1) {
return (XTools::Listener *)jarg1;
}
#ifdef __cplusplus
}
#endif
| 31.308914 | 706 | 0.719659 | [
"vector"
] |
0b8b194a74c3f761f957c15546b4d2e0d6fa72d1 | 13,454 | cpp | C++ | EmojicodeReal-TimeEngine/JSON.cpp | icodeing/emojicode | f39fa328763b9f48a5c18cada709da964371c2a4 | [
"Artistic-2.0"
] | 1 | 2017-04-24T01:57:00.000Z | 2017-04-24T01:57:00.000Z | EmojicodeReal-TimeEngine/JSON.cpp | icodeing/emojicode | f39fa328763b9f48a5c18cada709da964371c2a4 | [
"Artistic-2.0"
] | null | null | null | EmojicodeReal-TimeEngine/JSON.cpp | icodeing/emojicode | f39fa328763b9f48a5c18cada709da964371c2a4 | [
"Artistic-2.0"
] | null | null | null | //
// JSON.c
// Emojicode
//
// Created by Theo Weidmann on 16/12/15.
// Copyright © 2015 Theo Weidmann. All rights reserved.
//
#include <cmath>
#include "Engine.hpp"
#include "Dictionary.h"
#include "List.h"
#include "Thread.hpp"
namespace Emojicode {
enum JSONState {
JSON_NONE = 0,
JSON_STRING = 1,
JSON_STRING_ESCAPE = 2,
JSON_NUMBER = 3, JSON_DOUBLE = 4, JSON_EXPONENT = 5, JSON_EXPONENT_NO_PLUS = 6, JSON_EXPONENT_BACK_VALUE = 7,
JSON_NUMBER_NEGATIVE = 8, JSON_DOUBLE_NEGATIVE = 9, JSON_EXPONENT_NEGATIVE = 10,
JSON_EXPONENT_NO_PLUS_NEGATIVE = 11, JSON_EXPONENT_BACK_VALUE_NEGATIVE = 12,
JSON_OBJECT_KEY, JSON_OBJECT_KEY_BACK_VALUE, JSON_OBJECT_VALUE_BACK_VALUE,
JSON_ARRAY, JSON_ARRAY_BACK_VALUE, JSON_ARRAY_FIRST,
JSON_TRUE_T, JSON_TRUE_TR, JSON_TRUE_TRU,
JSON_FALSE_F, JSON_FALSE_FA, JSON_FALSE_FAL, JSON_FALSE_FALS,
JSON_NULL_N, JSON_NULL_NU, JSON_NULL_NUL
};
struct JSONStackFrame {
int state;
EmojicodeInteger integer;
int numberDigitsFraction;
Object *const *object;
Object *const *secondaryObject;
};
#define errorExit() destination->makeNothingness(); return;
#define upgrade(now, expect, ec) case now: if (c == ec) { stackCurrent->state = now ## expect; continue; } else { errorExit(); }
#define upgradeReturn(now, ec, r) case now: if (c == ec) { backValue = r; popTheStack(); } else { errorExit(); }
#define appendEscape(seq, c) case seq: *listAppendDestination(*stackCurrent->object, thread) = Box(T_SYMBOL, EmojicodeChar(c)); continue;
#define whitespaceCase case '\t': case '\n': case '\r': case ' ':
#define popTheStack() if (stackCurrent->secondaryObject) thread->release(1); if (stackCurrent->object) thread->release(1); stackCurrent--; continue;
#define pushTheStack() stackCurrent++; if (stackCurrent > stackLimit) { errorExit(); } stackCurrent->state = JSON_NONE; stackCurrent->secondaryObject = nullptr; stackCurrent->object = nullptr; continue;
#define returnArray() backValue = Box(T_OBJECT, *stackCurrent->object); popTheStack();
#define integerValue() Box(T_INTEGER, (stackCurrent->state == JSON_NUMBER_NEGATIVE) ? -stackCurrent->integer : stackCurrent->integer)
#define _doubleInternalValue() ((double)stackCurrent->integer/pow(10, stackCurrent->numberDigitsFraction))
#define doubleRawValue() ((stackCurrent->state == JSON_DOUBLE_NEGATIVE) ? -_doubleInternalValue() : _doubleInternalValue())
#define doubleValue() Box(T_DOUBLE, doubleRawValue())
#define jsonMaxDepth 256
void parseJSON(Thread *thread, Box *destination) {
const size_t length = thread->getThisObject()->val<String>()->length;
JSONStackFrame stack[jsonMaxDepth];
JSONStackFrame *stackLimit = stack + jsonMaxDepth - 1;
JSONStackFrame *stackCurrent = stack;
EmojicodeChar c;
Box backValue;
size_t i = 0;
stackCurrent->state = JSON_NONE;
stackCurrent->object = nullptr;
stackCurrent->secondaryObject = nullptr;
while (i < length) {
if (stackCurrent < stack) {
errorExit();
}
c = thread->getThisObject()->val<String>()->characters()[i++];
switch (stackCurrent->state) {
case JSON_STRING:
switch (c) {
case '\\':
stackCurrent->state = JSON_STRING_ESCAPE;
continue;
case '"': {
auto &stringObject = thread->retain(newObject(CL_STRING));
initStringFromSymbolList(stringObject->val<String>(), (*stackCurrent->object)->val<List>());
thread->release(1);
backValue = Box(T_OBJECT, stringObject);
popTheStack();
}
default:
if (c <= 0x1F) {
errorExit();
}
*listAppendDestination(*stackCurrent->object, thread) = Box(T_SYMBOL, c);
continue;
}
case JSON_STRING_ESCAPE:
stackCurrent->state = JSON_STRING;
switch (c) {
appendEscape('"', '"')
appendEscape('\\', '\\')
appendEscape('/', '/')
appendEscape('b', '\b')
appendEscape('f', '\f')
appendEscape('n', '\n')
appendEscape('r', '\r')
appendEscape('t', '\t')
case 'u': {
EmojicodeChar *chars = thread->getThisObject()->val<String>()->characters();
EmojicodeInteger x = 0, high = 0;
while (true) {
for (size_t e = i + 4; i < e; i++) {
if (i >= length) {
errorExit();
}
c = chars[i];
x *= 16;
if ('0' <= c && c <= '9')
x += c - '0';
else if ('A' <= c && c <= 'F')
x += c - 'A' + 10;
else if ('a' <= c && c <= 'f')
x += c - 'a' + 10;
else {
errorExit();
}
}
if (high)
x = (high << 10) + x + 0x10000 - (0xD800 << 10) - 0xDC00;
else if (0xD800 <= x && x <= 0xDBFF) {
if (i + 2 >= length || chars[i++] != '\\' || chars[i++] != 'u') {
errorExit();
}
high = x;
x = 0;
continue;
}
break;
}
*listAppendDestination(*stackCurrent->object, thread) = Box(T_SYMBOL, x);
continue;
}
}
errorExit();
case JSON_DOUBLE:
case JSON_DOUBLE_NEGATIVE:
stackCurrent->numberDigitsFraction++;
case JSON_NUMBER:
case JSON_NUMBER_NEGATIVE:
switch (c) {
case '.':
stackCurrent->state += 1;
stackCurrent->numberDigitsFraction = 0;
continue;
case 'E':
case 'e':
stack->numberDigitsFraction = 0;
stackCurrent->state += 2;
continue;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
stackCurrent->integer = stackCurrent->integer * 10 + c - '0';
continue;
default:
i--;
backValue = integerValue();
popTheStack();
}
case JSON_EXPONENT:
case JSON_EXPONENT_NEGATIVE:
stackCurrent->state++;
if (c == '+') continue;
case JSON_EXPONENT_NO_PLUS:
case JSON_EXPONENT_NO_PLUS_NEGATIVE:
stackCurrent->state++;
pushTheStack();
case JSON_EXPONENT_BACK_VALUE:
case JSON_EXPONENT_BACK_VALUE_NEGATIVE: {
if (backValue.type.raw != T_INTEGER) {
errorExit();
}
backValue = Box(T_DOUBLE, doubleRawValue() * pow(10, backValue.value1.raw));
}
case JSON_ARRAY_FIRST:
stackCurrent->state = JSON_ARRAY;
if (c == ']') {
returnArray();
}
case JSON_ARRAY:
i--;
stackCurrent->state = JSON_ARRAY_BACK_VALUE;
pushTheStack();
case JSON_ARRAY_BACK_VALUE:
*listAppendDestination(*stackCurrent->object, thread) = backValue;
switch (c) {
case ',':
stackCurrent->state = JSON_ARRAY;
continue;
case ']':
returnArray();
whitespaceCase
continue;
default:
errorExit();
}
case JSON_OBJECT_KEY:
i--;
stackCurrent->state = JSON_OBJECT_KEY_BACK_VALUE;
pushTheStack();
case JSON_OBJECT_KEY_BACK_VALUE:
if (backValue.type.raw != T_OBJECT || backValue.value1.object->klass != CL_STRING) {
errorExit();
}
stackCurrent->secondaryObject = &thread->retain(backValue.value1.object);
switch (c) {
case ':':
stackCurrent->state = JSON_OBJECT_VALUE_BACK_VALUE;
pushTheStack();
whitespaceCase
continue;
default:
errorExit();
}
case JSON_OBJECT_VALUE_BACK_VALUE:
dictionaryPutVal(*stackCurrent->object, *stackCurrent->secondaryObject, backValue, thread);
switch (c) {
case ',':
stackCurrent->state = JSON_OBJECT_KEY;
continue;
case '}':
backValue = Box(T_OBJECT, *stackCurrent->object);
popTheStack();
whitespaceCase
continue;
default:
errorExit();
}
upgrade(JSON_TRUE_T, R, 'r')
upgrade(JSON_TRUE_TR, U, 'u')
upgradeReturn(JSON_TRUE_TRU, 'e', Box(T_BOOLEAN, EmojicodeInteger(1)))
upgrade(JSON_FALSE_F, A, 'a')
upgrade(JSON_FALSE_FA, L, 'l')
upgrade(JSON_FALSE_FAL, S, 's')
upgradeReturn(JSON_FALSE_FALS, 'e', Box(T_BOOLEAN, EmojicodeInteger(0)))
upgrade(JSON_NULL_N, U, 'u')
upgrade(JSON_NULL_NU, L, 'l')
upgradeReturn(JSON_NULL_NUL, 'l', Box(T_NOTHINGNESS, EmojicodeInteger(0)))
case JSON_NONE:
switch (c) {
case '"': {
stackCurrent->state = JSON_STRING;
stackCurrent->object = &thread->retain(newObject(CL_LIST));
break;
}
case '{': {
stackCurrent->state = JSON_OBJECT_KEY;
stackCurrent->object = &thread->retain(newObject(CL_DICTIONARY));
dictionaryInit((*stackCurrent->object)->val<EmojicodeDictionary>());
break;
}
case '[': {
stackCurrent->state = JSON_ARRAY_FIRST;
stackCurrent->object = &thread->retain(newObject(CL_LIST));
break;
}
case 't':
stackCurrent->state = JSON_TRUE_T;
break;
case 'f':
stackCurrent->state = JSON_FALSE_F;
break;
case 'n':
stackCurrent->state = JSON_NULL_N;
break;
case '-':
stackCurrent->state = JSON_NUMBER_NEGATIVE;
stackCurrent->integer = 0;
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
stackCurrent->state = JSON_NUMBER;
stackCurrent->integer = c - '0';
break;
whitespaceCase
continue;
default:
errorExit();
}
}
}
if (stackCurrent == stack) {
switch (stackCurrent->state) {
case JSON_DOUBLE:
case JSON_DOUBLE_NEGATIVE:
*destination = doubleValue();
return;
case JSON_NUMBER:
case JSON_NUMBER_NEGATIVE:
*destination = integerValue();
return;
default:
break;
}
}
if (stackCurrent < stack) {
*destination = backValue;
return;
}
errorExit();
}
}
| 40.041667 | 202 | 0.44195 | [
"object"
] |
0b8bfbd40b5de7c74a53bc55437f3401af068690 | 966 | cpp | C++ | uva/156.cpp | btjanaka/competitive-programming-solutions | e3df47c18451802b8521ebe61ca71ee348e5ced7 | [
"MIT"
] | 3 | 2020-06-25T21:04:02.000Z | 2021-05-12T03:33:19.000Z | uva/156.cpp | btjanaka/competitive-programming-solutions | e3df47c18451802b8521ebe61ca71ee348e5ced7 | [
"MIT"
] | null | null | null | uva/156.cpp | btjanaka/competitive-programming-solutions | e3df47c18451802b8521ebe61ca71ee348e5ced7 | [
"MIT"
] | 1 | 2020-06-25T21:04:06.000Z | 2020-06-25T21:04:06.000Z | // Author: btjanaka (Bryon Tjanaka)
// Problem: (UVa) 156
#include <bits/stdc++.h>
#define GET(x) scanf("%d", &x)
#define GED(x) scanf("%lf", &x)
typedef long long ll;
using namespace std;
typedef pair<int, int> ii;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
// bool tells if this anagram has been seen multiple times
unordered_map<string, pair<string, bool>> words;
string s;
while (cin >> s && s != "#") {
string cpy = s;
for_each(cpy.begin(), cpy.end(), [](char& ch) { ch = tolower(ch); });
sort(cpy.begin(), cpy.end());
if (words.find(cpy) == words.end()) {
words[cpy] = {s, false};
} else {
words[cpy].second = true;
}
}
// output
vector<string> res;
for (const auto& x : words) {
if (!x.second.second) {
res.push_back(x.second.first);
}
}
sort(res.begin(), res.end());
for_each(res.begin(), res.end(), [](const string& x) { cout << x << endl; });
return 0;
}
| 24.15 | 79 | 0.57971 | [
"vector"
] |
0b8cad2c51ba42d74ac11890b667c66adabdd7aa | 13,872 | hpp | C++ | includes/rumal/declares.hpp | neel/rumal | 3348b936057457360f9a17b643b59f398667dd50 | [
"BSD-2-Clause"
] | null | null | null | includes/rumal/declares.hpp | neel/rumal | 3348b936057457360f9a17b643b59f398667dd50 | [
"BSD-2-Clause"
] | null | null | null | includes/rumal/declares.hpp | neel/rumal | 3348b936057457360f9a17b643b59f398667dd50 | [
"BSD-2-Clause"
] | 1 | 2019-11-25T12:47:14.000Z | 2019-11-25T12:47:14.000Z | /*
* Copyright (c) 2018, Sunanda Bose (Neel Basu) (neel.basu.z@gmail.com)
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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 RUMAL_DECLARES_H
#define RUMAL_DECLARES_H
#include <rumal/base.hpp>
#define DEFINE_HTML_ATTRIBUTE(name) template <typename T> auto _##name(T value){return rumal::html::attr(#name, value);}
#define DEFINE_LABELED_HTML_ATTRIBUTE(name, label) template <typename T> auto name(T value){return rumal::html::attr(label, value);}
#define DEFINE_CSS_ATTRIBUTE(name) template <typename T> auto name(T value){return rumal::css::prepared(#name, value);}
#define DEFINE_LABELED_CSS_ATTRIBUTE(name, label) template <typename T> auto name(T value){return rumal::css::prop(label, value);}
#define DEFINE_HTML_TAG(name) \
template <typename Args, typename... T> \
auto name(const Args& args, const T&... elems){ \
return tag<Args, T...>(#name, args, elems...); \
} \
template <typename... T> \
auto name(const T&... elems){ \
return tag<void, T...>(#name, elems...); \
}
namespace rumal{
namespace html{
namespace attrs{
DEFINE_HTML_ATTRIBUTE(accept)
DEFINE_HTML_ATTRIBUTE(accesskey)
DEFINE_HTML_ATTRIBUTE(action)
DEFINE_HTML_ATTRIBUTE(align)
DEFINE_HTML_ATTRIBUTE(allow)
DEFINE_HTML_ATTRIBUTE(alt)
DEFINE_HTML_ATTRIBUTE(async)
DEFINE_HTML_ATTRIBUTE(autocapitalize)
DEFINE_HTML_ATTRIBUTE(autocomplete)
DEFINE_HTML_ATTRIBUTE(autofocus)
DEFINE_HTML_ATTRIBUTE(autoplay)
DEFINE_HTML_ATTRIBUTE(background)
DEFINE_HTML_ATTRIBUTE(bgcolor)
DEFINE_HTML_ATTRIBUTE(border)
DEFINE_HTML_ATTRIBUTE(buffered)
DEFINE_HTML_ATTRIBUTE(challenge)
DEFINE_HTML_ATTRIBUTE(charset)
DEFINE_HTML_ATTRIBUTE(checked)
DEFINE_HTML_ATTRIBUTE(cite)
DEFINE_HTML_ATTRIBUTE(class)
DEFINE_HTML_ATTRIBUTE(code)
DEFINE_HTML_ATTRIBUTE(codebase)
DEFINE_HTML_ATTRIBUTE(color)
DEFINE_HTML_ATTRIBUTE(cols)
DEFINE_HTML_ATTRIBUTE(colspan)
DEFINE_HTML_ATTRIBUTE(content)
DEFINE_HTML_ATTRIBUTE(contenteditable)
DEFINE_HTML_ATTRIBUTE(contextmenu)
DEFINE_HTML_ATTRIBUTE(controls)
DEFINE_HTML_ATTRIBUTE(coords)
DEFINE_HTML_ATTRIBUTE(crossorigin)
DEFINE_HTML_ATTRIBUTE(csp)
DEFINE_HTML_ATTRIBUTE(data)
DEFINE_HTML_ATTRIBUTE(datetime)
DEFINE_HTML_ATTRIBUTE(decoding)
DEFINE_HTML_ATTRIBUTE(default)
DEFINE_HTML_ATTRIBUTE(defer)
DEFINE_HTML_ATTRIBUTE(dir)
DEFINE_HTML_ATTRIBUTE(dirname)
DEFINE_HTML_ATTRIBUTE(disabled)
DEFINE_HTML_ATTRIBUTE(download)
DEFINE_HTML_ATTRIBUTE(draggable)
DEFINE_HTML_ATTRIBUTE(dropzone)
DEFINE_HTML_ATTRIBUTE(enctype)
DEFINE_HTML_ATTRIBUTE(enterkeyhint)
DEFINE_HTML_ATTRIBUTE(for)
DEFINE_HTML_ATTRIBUTE(form)
DEFINE_HTML_ATTRIBUTE(formaction)
DEFINE_HTML_ATTRIBUTE(formenctype)
DEFINE_HTML_ATTRIBUTE(formmethod)
DEFINE_HTML_ATTRIBUTE(formnovalidate)
DEFINE_HTML_ATTRIBUTE(formtarget)
DEFINE_HTML_ATTRIBUTE(headers)
DEFINE_HTML_ATTRIBUTE(height)
DEFINE_HTML_ATTRIBUTE(hidden)
DEFINE_HTML_ATTRIBUTE(high)
DEFINE_HTML_ATTRIBUTE(href)
DEFINE_HTML_ATTRIBUTE(hreflang)
DEFINE_LABELED_HTML_ATTRIBUTE(http_equiv, "http-equiv")
DEFINE_HTML_ATTRIBUTE(icon)
DEFINE_HTML_ATTRIBUTE(id)
DEFINE_HTML_ATTRIBUTE(importance)
DEFINE_HTML_ATTRIBUTE(integrity)
DEFINE_HTML_ATTRIBUTE(intrinsicsize)
DEFINE_HTML_ATTRIBUTE(inputmode)
DEFINE_HTML_ATTRIBUTE(ismap)
DEFINE_HTML_ATTRIBUTE(itemprop)
DEFINE_HTML_ATTRIBUTE(keytype)
DEFINE_HTML_ATTRIBUTE(kind)
DEFINE_HTML_ATTRIBUTE(label)
DEFINE_HTML_ATTRIBUTE(lang)
DEFINE_HTML_ATTRIBUTE(language)
DEFINE_HTML_ATTRIBUTE(loading)
DEFINE_HTML_ATTRIBUTE(list)
DEFINE_HTML_ATTRIBUTE(loop)
DEFINE_HTML_ATTRIBUTE(low)
DEFINE_HTML_ATTRIBUTE(manifest)
DEFINE_HTML_ATTRIBUTE(max)
DEFINE_HTML_ATTRIBUTE(maxlength)
DEFINE_HTML_ATTRIBUTE(minlength)
DEFINE_HTML_ATTRIBUTE(media)
DEFINE_HTML_ATTRIBUTE(method)
DEFINE_HTML_ATTRIBUTE(min)
DEFINE_HTML_ATTRIBUTE(multiple)
DEFINE_HTML_ATTRIBUTE(muted)
DEFINE_HTML_ATTRIBUTE(name)
DEFINE_HTML_ATTRIBUTE(novalidate)
DEFINE_HTML_ATTRIBUTE(open)
DEFINE_HTML_ATTRIBUTE(optimum)
DEFINE_HTML_ATTRIBUTE(pattern)
DEFINE_HTML_ATTRIBUTE(ping)
DEFINE_HTML_ATTRIBUTE(placeholder)
DEFINE_HTML_ATTRIBUTE(poster)
DEFINE_HTML_ATTRIBUTE(preload)
DEFINE_HTML_ATTRIBUTE(radiogroup)
DEFINE_HTML_ATTRIBUTE(readonly)
DEFINE_HTML_ATTRIBUTE(referrerpolicy)
DEFINE_HTML_ATTRIBUTE(rel)
DEFINE_HTML_ATTRIBUTE(required)
DEFINE_HTML_ATTRIBUTE(reversed)
DEFINE_HTML_ATTRIBUTE(rows)
DEFINE_HTML_ATTRIBUTE(rowspan)
DEFINE_HTML_ATTRIBUTE(sandbox)
DEFINE_HTML_ATTRIBUTE(scope)
DEFINE_HTML_ATTRIBUTE(scoped)
DEFINE_HTML_ATTRIBUTE(selected)
DEFINE_HTML_ATTRIBUTE(shape)
DEFINE_HTML_ATTRIBUTE(size)
DEFINE_HTML_ATTRIBUTE(sizes)
DEFINE_HTML_ATTRIBUTE(slot)
DEFINE_HTML_ATTRIBUTE(span)
DEFINE_HTML_ATTRIBUTE(spellcheck)
DEFINE_HTML_ATTRIBUTE(src)
DEFINE_HTML_ATTRIBUTE(srcdoc)
DEFINE_HTML_ATTRIBUTE(srclang)
DEFINE_HTML_ATTRIBUTE(srcset)
DEFINE_HTML_ATTRIBUTE(start)
DEFINE_HTML_ATTRIBUTE(step)
DEFINE_HTML_ATTRIBUTE(style)
DEFINE_HTML_ATTRIBUTE(summary)
DEFINE_HTML_ATTRIBUTE(tabindex)
DEFINE_HTML_ATTRIBUTE(target)
DEFINE_HTML_ATTRIBUTE(title)
DEFINE_HTML_ATTRIBUTE(translate)
DEFINE_HTML_ATTRIBUTE(type)
DEFINE_HTML_ATTRIBUTE(usemap)
DEFINE_HTML_ATTRIBUTE(value)
DEFINE_HTML_ATTRIBUTE(width)
DEFINE_HTML_ATTRIBUTE(wrap)
}
namespace tags{
DEFINE_HTML_TAG(div)
DEFINE_HTML_TAG(h1)
DEFINE_HTML_TAG(h2)
DEFINE_HTML_TAG(h3)
DEFINE_HTML_TAG(h4)
DEFINE_HTML_TAG(h5)
DEFINE_HTML_TAG(h6)
DEFINE_HTML_TAG(span)
DEFINE_HTML_TAG(a)
DEFINE_HTML_TAG(b)
DEFINE_HTML_TAG(i)
DEFINE_HTML_TAG(u)
DEFINE_HTML_TAG(img)
DEFINE_HTML_TAG(script)
DEFINE_HTML_TAG(link)
}
}
namespace css{
namespace props{
DEFINE_LABELED_CSS_ATTRIBUTE(background, "background")
DEFINE_LABELED_CSS_ATTRIBUTE(backgroundAttachment, "background-attachment")
DEFINE_LABELED_CSS_ATTRIBUTE(backgroundColor, "background-color")
DEFINE_LABELED_CSS_ATTRIBUTE(backgroundImage, "background-image")
DEFINE_LABELED_CSS_ATTRIBUTE(backgroundPosition, "background-position")
DEFINE_LABELED_CSS_ATTRIBUTE(backgroundRepeat, "background-repeat")
DEFINE_LABELED_CSS_ATTRIBUTE(border, "border")
DEFINE_LABELED_CSS_ATTRIBUTE(borderBottom, "border-bottom")
DEFINE_LABELED_CSS_ATTRIBUTE(borderBottomColor, "border-bottom-color")
DEFINE_LABELED_CSS_ATTRIBUTE(borderBottomStyle, "border-bottom-style")
DEFINE_LABELED_CSS_ATTRIBUTE(borderBottomWidth, "border-bottom-width")
DEFINE_LABELED_CSS_ATTRIBUTE(borderColor, "border-color")
DEFINE_LABELED_CSS_ATTRIBUTE(borderLeft, "border-left")
DEFINE_LABELED_CSS_ATTRIBUTE(borderLeftColor, "border-left-color")
DEFINE_LABELED_CSS_ATTRIBUTE(borderLeftStyle, "border-left-style")
DEFINE_LABELED_CSS_ATTRIBUTE(borderLeftWidth, "border-left-width")
DEFINE_LABELED_CSS_ATTRIBUTE(borderRight, "border-right")
DEFINE_LABELED_CSS_ATTRIBUTE(borderRightColor, "border-right-color")
DEFINE_LABELED_CSS_ATTRIBUTE(borderRightStyle, "border-right-style")
DEFINE_LABELED_CSS_ATTRIBUTE(borderRightWidth, "border-right-width")
DEFINE_LABELED_CSS_ATTRIBUTE(borderStyle, "border-style")
DEFINE_LABELED_CSS_ATTRIBUTE(borderTop, "border-top")
DEFINE_LABELED_CSS_ATTRIBUTE(borderTopColor, "border-top-color")
DEFINE_LABELED_CSS_ATTRIBUTE(borderTopStyle, "border-top-style")
DEFINE_LABELED_CSS_ATTRIBUTE(borderTopWidth, "border-top-width")
DEFINE_LABELED_CSS_ATTRIBUTE(borderWidth, "border-width")
DEFINE_LABELED_CSS_ATTRIBUTE(clear, "clear")
DEFINE_LABELED_CSS_ATTRIBUTE(clip, "clip")
DEFINE_LABELED_CSS_ATTRIBUTE(color, "color")
DEFINE_LABELED_CSS_ATTRIBUTE(cursor, "cursor")
DEFINE_LABELED_CSS_ATTRIBUTE(display, "display")
DEFINE_LABELED_CSS_ATTRIBUTE(filter, "filter")
DEFINE_LABELED_CSS_ATTRIBUTE(cssFloat, "float")
DEFINE_LABELED_CSS_ATTRIBUTE(font, "font")
DEFINE_LABELED_CSS_ATTRIBUTE(fontFamily, "font-family")
DEFINE_LABELED_CSS_ATTRIBUTE(fontSize, "font-size")
DEFINE_LABELED_CSS_ATTRIBUTE(fontVariant, "font-variant")
DEFINE_LABELED_CSS_ATTRIBUTE(fontWeight, "font-weight")
DEFINE_LABELED_CSS_ATTRIBUTE(height, "height")
DEFINE_LABELED_CSS_ATTRIBUTE(left, "left")
DEFINE_LABELED_CSS_ATTRIBUTE(letterSpacing, "letter-spacing")
DEFINE_LABELED_CSS_ATTRIBUTE(lineHeight, "line-height")
DEFINE_LABELED_CSS_ATTRIBUTE(listStyle, "list-style")
DEFINE_LABELED_CSS_ATTRIBUTE(listStyleImage, "list-style-image")
DEFINE_LABELED_CSS_ATTRIBUTE(listStylePosition, "list-style-position")
DEFINE_LABELED_CSS_ATTRIBUTE(listStyleType, "list-style-type")
DEFINE_LABELED_CSS_ATTRIBUTE(margin, "margin")
DEFINE_LABELED_CSS_ATTRIBUTE(marginBottom, "margin-bottom")
DEFINE_LABELED_CSS_ATTRIBUTE(marginLeft, "margin-left")
DEFINE_LABELED_CSS_ATTRIBUTE(marginRight, "margin-right")
DEFINE_LABELED_CSS_ATTRIBUTE(marginTop, "margin-top")
DEFINE_LABELED_CSS_ATTRIBUTE(opacity, "opacity")
DEFINE_LABELED_CSS_ATTRIBUTE(overflow, "overflow")
DEFINE_LABELED_CSS_ATTRIBUTE(padding, "padding")
DEFINE_LABELED_CSS_ATTRIBUTE(paddingBottom, "padding-bottom")
DEFINE_LABELED_CSS_ATTRIBUTE(paddingLeft, "padding-left")
DEFINE_LABELED_CSS_ATTRIBUTE(paddingRight, "padding-right")
DEFINE_LABELED_CSS_ATTRIBUTE(paddingTop, "padding-top")
DEFINE_LABELED_CSS_ATTRIBUTE(pageBreakAfter, "page-break-after")
DEFINE_LABELED_CSS_ATTRIBUTE(pageBreakBefore, "page-break-before")
DEFINE_LABELED_CSS_ATTRIBUTE(position, "position")
DEFINE_LABELED_CSS_ATTRIBUTE(strokeDasharray, "stroke-dasharray")
DEFINE_LABELED_CSS_ATTRIBUTE(strokeDashoffset, "stroke-dashoffset")
DEFINE_LABELED_CSS_ATTRIBUTE(strokeWidth, "stroke-width")
DEFINE_LABELED_CSS_ATTRIBUTE(textAlign, "text-align")
DEFINE_LABELED_CSS_ATTRIBUTE(textDecoration, "text-decoration")
DEFINE_LABELED_CSS_ATTRIBUTE(textIndent, "text-indent")
DEFINE_LABELED_CSS_ATTRIBUTE(textTransform, "text-transform")
DEFINE_LABELED_CSS_ATTRIBUTE(top, "top")
DEFINE_LABELED_CSS_ATTRIBUTE(verticalAlign, "vertical-align")
DEFINE_LABELED_CSS_ATTRIBUTE(visibility, "visibility")
DEFINE_LABELED_CSS_ATTRIBUTE(width, "width")
DEFINE_LABELED_CSS_ATTRIBUTE(zIndex, "z-index")
}
}
}
#endif //RUMAL_DECLARES_H
| 50.079422 | 132 | 0.670487 | [
"shape",
"transform"
] |
0b8ea7ee7cbdc9a3cf1ddda8b93bf714cc0d2951 | 842 | cpp | C++ | geometry/geometry_tests/vector_test.cpp | bowlofstew/omim | 8045157c95244aa8f862d47324df42a19b87e335 | [
"Apache-2.0"
] | 2 | 2019-01-24T15:36:20.000Z | 2019-12-26T10:03:48.000Z | geometry/geometry_tests/vector_test.cpp | bowlofstew/omim | 8045157c95244aa8f862d47324df42a19b87e335 | [
"Apache-2.0"
] | 13 | 2015-09-28T13:59:23.000Z | 2015-10-08T20:12:45.000Z | geometry/geometry_tests/vector_test.cpp | bowlofstew/omim | 8045157c95244aa8f862d47324df42a19b87e335 | [
"Apache-2.0"
] | 1 | 2019-08-09T21:21:09.000Z | 2019-08-09T21:21:09.000Z | #include "testing/testing.hpp"
#include "geometry/avg_vector.hpp"
namespace
{
template <class T, size_t N> bool EqualArrays(T (&a1)[N], T (&a2)[N])
{
for (size_t i = 0; i < N; ++i)
if (!my::AlmostEqualULPs(a1[i], a2[i]))
return false;
return true;
}
}
UNIT_TEST(AvgVector_Smoke)
{
math::AvgVector<double, 3> holder(3);
double ethalon1[] = { 5, 5, 5 };
double ethalon2[] = { 5.5, 5.5, 5.5 };
double ethalon3[] = { 6, 6, 6 };
double arr1[] = { 5, 5, 5 };
double arr2[] = { 6, 6, 6 };
double arr3[] = { 5, 5, 5 };
double arr4[] = { 6, 6, 6 };
holder.Next(arr1);
TEST(EqualArrays(arr1, ethalon1), ());
holder.Next(arr2);
TEST(EqualArrays(arr2, ethalon2), ());
holder.Next(arr3);
TEST(EqualArrays(arr3, ethalon1), ());
holder.Next(arr4);
TEST(EqualArrays(arr4, ethalon3), ());
}
| 20.047619 | 69 | 0.577197 | [
"geometry"
] |
0b8eadaa5db45bb3edb7daa7d91a97db80899163 | 604 | cpp | C++ | boot32/plainvga32.cpp | leakingmemory/jeokernel | 7c2413921cc2d30eef2b340de4efed66d41afeb1 | [
"MIT"
] | null | null | null | boot32/plainvga32.cpp | leakingmemory/jeokernel | 7c2413921cc2d30eef2b340de4efed66d41afeb1 | [
"MIT"
] | null | null | null | boot32/plainvga32.cpp | leakingmemory/jeokernel | 7c2413921cc2d30eef2b340de4efed66d41afeb1 | [
"MIT"
] | null | null | null | //
// Created by sigsegv on 17.04.2021.
//
#include "plainvga32.h"
static _plainvga32buf_text &get_vgabuf() {
_plainvga32buf_text *vgabuf = (_plainvga32buf_text *) 0xB8000;
return *vgabuf;
}
plainvga32::plainvga32() : vgabuf(get_vgabuf()) {
}
void plainvga32::display(uint8_t line, uint8_t start, const char *str) {
uint16_t vector = ((uint16_t) line) * 80;
vector += start;
while (*str) {
_plainvga_letter &letter = vgabuf.chmem[vector % 2000];
letter.bg_color = 0;
letter.fg_color = 7;
letter.chr = *str;
vector++;
str++;
}
}
| 22.37037 | 72 | 0.620861 | [
"vector"
] |
0b9739dc7df679f296f6343e8adfec0084def838 | 1,175 | hpp | C++ | Board.hpp | LielBerniker/task_2_b_cpp | 0adea725f8a554d01af43fcd1b17e867f64ca641 | [
"MIT"
] | null | null | null | Board.hpp | LielBerniker/task_2_b_cpp | 0adea725f8a554d01af43fcd1b17e867f64ca641 | [
"MIT"
] | null | null | null | Board.hpp | LielBerniker/task_2_b_cpp | 0adea725f8a554d01af43fcd1b17e867f64ca641 | [
"MIT"
] | null | null | null | #pragma once
#include "Direction.hpp"
#include <string>
#include <vector>
#include <unordered_map>
#include <utility>
namespace ariel
{
const unsigned int FIVE = 5;
const std::string USI_ERROR = "unsgined int range";
class Board
{
public:
Board();
void post(unsigned int row, unsigned int col, ariel::Direction direc,const std::string advertis);
std::string read(unsigned int row, unsigned int col, ariel::Direction direc, unsigned int adv_len);
void show();
private:
std::unordered_map<std::string, char> board;
unsigned int left_lim;
unsigned int right_lim;
unsigned int up_lim;
unsigned int low_lim;
void post_to_board(unsigned int row, unsigned int col, ariel::Direction direc, const std::string advertis);
std::string read_from_board(unsigned int row, unsigned int col, ariel::Direction direc, unsigned int adv_len);
void update_limits(unsigned int row, unsigned int col, ariel::Direction direc, const unsigned int size);
int check_in_range(unsigned int row, unsigned int col, ariel::Direction direc, const unsigned int size);
};
}
| 35.606061 | 118 | 0.685106 | [
"vector"
] |
0b9e7c9e3c955b4026f32e776b158fbc8606d8c2 | 788 | cpp | C++ | 485-max-consecutive-ones/max-consecutive-ones.cpp | nagestx/MyLeetCode | ef2a98b48485a0cebc442bbbbdb2690ba51484e1 | [
"MIT"
] | 3 | 2018-12-15T14:07:12.000Z | 2020-07-19T23:18:09.000Z | 485-max-consecutive-ones/max-consecutive-ones.cpp | yangyangu/MyLeetCode | ef2a98b48485a0cebc442bbbbdb2690ba51484e1 | [
"MIT"
] | null | null | null | 485-max-consecutive-ones/max-consecutive-ones.cpp | yangyangu/MyLeetCode | ef2a98b48485a0cebc442bbbbdb2690ba51484e1 | [
"MIT"
] | null | null | null | // Given a binary array, find the maximum number of consecutive 1s in this array.
//
// Example 1:
//
// Input: [1,1,0,1,1,1]
// Output: 3
// Explanation: The first two digits or the last three digits are consecutive 1s.
// The maximum number of consecutive 1s is 3.
//
//
//
// Note:
//
// The input array will only contain 0 and 1.
// The length of input array is a positive integer and will not exceed 10,000
//
//
class Solution {
public:
int findMaxConsecutiveOnes(vector<int>& nums) {
if(nums.empty()) return 0;
for(int i = 1; i <= nums.size() - 1; ++i){
if(!nums[i]) continue;
else if(nums[i] && nums[i - 1]) nums[i] = nums[i - 1] + 1;
}
int t = 0;
for(int n : nums){
if(t < n) t = n;
}
return t;
}
};
| 22.514286 | 82 | 0.572335 | [
"vector"
] |
0ba457adcbfee9745cc64fd8005b70d7314ffe25 | 1,475 | cpp | C++ | lang/cpp/selection_sort_jayden.cpp | jaeyp/c3 | 69f294f7af4e34a5b40f0abe08086de86d0afd66 | [
"BSD-2-Clause"
] | 1 | 2019-06-08T17:12:54.000Z | 2019-06-08T17:12:54.000Z | lang/cpp/selection_sort_jayden.cpp | jaeyp/c3 | 69f294f7af4e34a5b40f0abe08086de86d0afd66 | [
"BSD-2-Clause"
] | 6 | 2019-06-15T13:15:37.000Z | 2022-02-18T07:03:24.000Z | lang/cpp/selection_sort_jayden.cpp | jaeyp/c3 | 69f294f7af4e34a5b40f0abe08086de86d0afd66 | [
"BSD-2-Clause"
] | null | null | null | #include <iostream>
#include <utility> // std::swap
#include <vector>
// O(n * n)
template<typename T>
void SelectionSort(T data[], int size)
{
for(int i = 0; i < size-1; i++)
{
int least = i;
for(int j = i+1; j < size; j++)
{
if(data[j] < data[least])
{
least = j;
}
}
if(i != least) // if the elements in data are large compound entities such as arrays or structures
{ // then one swap may take much time so using a conditional swap() is recommended.
std::swap(data[least], data[i]);
}
}
}
template<typename T>
void SelectionSort(std::vector<T>& data)
{
int size{ (int)data.size() };
for(int i = 0; i < size; i++)
{
int least = i;
for(int j = i+1; j < size; j++)
{
if(data[j] < data[least])
{
least = j;
}
}
if(i != least) // if the elements in data are large compound entities such as arrays or structures
{ // then one swap may take much time so using a conditional swap() is recommended.
std::swap(data[least], data[i]);
}
}
}
template<typename T>
void Swap(T& a, T&b) // same as std::swap()
{
T c{ std::move(a) };
a = std::move(b);
b = std::move(c);
}
int main()
{
int a1[7]{ 8, 6, 4, 4, 1, 9, 2 };
SelectionSort(a1, 7);
std::vector<int> a2{ 5, 3, 1, 2, 9, 8, 7 };
SelectionSort(a2);
for(int i = 0; i < 7; i++)
{
std::cout << a1[i] << ' ';
}
std::cout << '\n';
for(int i = 0; i < 7; i++)
{
std::cout << a2[i] << ' ';
}
std::cout << '\n';
}
| 19.155844 | 101 | 0.543051 | [
"vector"
] |
2437d8c96770d1e4898f4bb084a1715d433da115 | 19,758 | cpp | C++ | src/callm_db_val.cpp | zjshi/Maast | 01428afa8dad042cb8fcbba024b60f176b228898 | [
"MIT"
] | null | null | null | src/callm_db_val.cpp | zjshi/Maast | 01428afa8dad042cb8fcbba024b60f176b228898 | [
"MIT"
] | 8 | 2022-03-24T22:17:19.000Z | 2022-03-29T15:42:00.000Z | src/callm_db_val.cpp | zjshi/Maast | 01428afa8dad042cb8fcbba024b60f176b228898 | [
"MIT"
] | null | null | null | #if __linux__
#include <linux/version.h>
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,22)
#define _MAP_POPULATE_AVAILABLE
#endif
#endif
#ifdef _MAP_POPULATE_AVAILABLE
#define MMAP_FLAGS (MAP_PRIVATE | MAP_POPULATE)
#else
#define MMAP_FLAGS MAP_PRIVATE
#endif
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <iostream>
#include <fstream>
#include <vector>
#include <unordered_map>
#include <algorithm>
#include <chrono>
#include <cstring>
#include <thread>
#include <fcntl.h>
#include <unistd.h>
#include <assert.h>
using namespace std;
// this program scans its input (fastq text stream) for forward k mers,
// usage:
// g++ -O3 --std=c++11 -o vfkmrz_bunion vfkmrz_bunion.cpp
// ./vfkmrz_bunion -k1 </path/to/kmer_list1> -k2 </path/to/kmer_list2>
//
// standard fastq format only for input, otherwise failure is almost guaranteed.
// global variable declaration starts here
constexpr auto k = 31;
// set operation mode
// valid values: 0, 1, 2
// 0 is set union operation; 1 is set intersection operation; 2 is set difference([set1-set2]);
constexpr auto s_mod = 0;
// parameters for <unistd.h> file read; from the source of GNU coreutils wc
constexpr auto step_size = 256 * 1024 * 1024;
constexpr auto buffer_size = 256 * 1024 * 1024;
// output file path
constexpr auto out_path = "/dev/stdout";
// get time elapsed since when it all began in milliseconds.
long chrono_time() {
using namespace chrono;
return duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count();
}
// number of bits per single nucleotide base
constexpr int bpb = 2;
size_t get_fsize(const char* filename) {
struct stat st;
stat(filename, &st);
return st.st_size;
}
char* get_ftype(const char* filename) {
int fn_len = strlen(filename);
char *ftype = (char *)malloc(5);
for(int i = 0; i < 4; ++i) {
ftype[i] = filename[fn_len - 4 + i];
}
ftype[4] = '\0';
return ftype;
}
void make_comp_map(char* comp_map) {
comp_map['A'] = 'T';
comp_map['C'] = 'G';
comp_map['G'] = 'C';
comp_map['T'] = 'A';
}
template <class int_type>
int_type bit_encode(const char c) {
switch (c) {
case 'A': return 0;
case 'C': return 1;
case 'G': return 2;
case 'T': return 3;
}
assert(false);
}
template <class int_type>
char bit_decode(const int_type bit_code) {
switch (bit_code) {
case 0: return 'A';
case 1: return 'C';
case 2: return 'G';
case 3: return 'T';
}
assert(false);
}
template <class int_type>
void make_code_dict(int_type* code_dict) {
code_dict['A'] = bit_encode<int_type>('A');
code_dict['C'] = bit_encode<int_type>('C');
code_dict['G'] = bit_encode<int_type>('G');
code_dict['T'] = bit_encode<int_type>('T');
}
template <class int_type>
int_type seq_encode(const char* buf, int len, const int_type* code_dict, const int_type b_mask) {
int_type seq_code = 0;
for (int i=0; i < len; ++i) {
const int_type b_code = code_dict[buf[i]];
seq_code |= ((b_code & b_mask) << (bpb * (len - i - 1)));
}
return seq_code;
}
template <class int_type>
void seq_decode(char* buf, const int len, const int_type seq_code, int_type* code_dict, const int_type b_mask) {
for (int i=0; i < len-1; ++i) {
const int_type b_code = (seq_code >> (bpb * (len - i - 2))) & b_mask;
buf[i] = bit_decode<int_type>(b_code);
}
buf[len-1] = '\0';
}
template <class int_type>
void load_profile(const char* k_path, vector<char>& buffer, vector<int_type>& kv1, vector<int_type>& kv2, vector<int_type>& kv3, vector<int_type>& kv4, vector<tuple<int_type, int_type>>& k_info, int_type* code_dict, const int_type b_mask) {
auto t_start = chrono_time();
char* window = buffer.data();
uintmax_t n_lines = 0;
int fd;
fd = open(k_path, O_RDONLY);
int k_cur = 0;
int snp_cur = 0;
int pos_cur = 0;
char kbuf1[k];
char kbuf2[k];
char kbuf3[k];
char kbuf4[k];
char snp_pos[16];
char kmer_pos[4];
//auto fh = fstream(out_path, ios::out | ios::binary);
int cur_field = 0;
bool has_wildcard = false;
while (true) {
const ssize_t bytes_read = read(fd, window, step_size);
if (bytes_read == 0)
break;
if (bytes_read == (ssize_t) -1) {
cerr << "unknown fetal error when reading " << k_path << endl;
exit(EXIT_FAILURE);
}
for (int i = 0; i < bytes_read; ++i) {
char c = window[i];
if (c == '\n') {
++n_lines;
if (has_wildcard) {
has_wildcard = false;
continue;
}
auto code1 = seq_encode<int_type>(kbuf1, k, code_dict, b_mask);
auto code2 = seq_encode<int_type>(kbuf2, k, code_dict, b_mask);
auto code3 = seq_encode<int_type>(kbuf3, k, code_dict, b_mask);
auto code4 = seq_encode<int_type>(kbuf4, k, code_dict, b_mask);
kv1.push_back(code1);
kv2.push_back(code2);
kv3.push_back(code3);
kv4.push_back(code4);
snp_pos[snp_cur] = '\0';
int_type id_int = stoull(snp_pos);
kmer_pos[pos_cur] = '\0';
int_type k_pos = stoull(kmer_pos);
k_info.push_back(tuple<int_type, int_type>(id_int, k_pos));
k_cur = 0;
pos_cur = 0;
snp_cur = 0;
cur_field = 0;
} else if (c == '\t'){
++cur_field;
k_cur = 0;
} else {
if (c == 'N') {
has_wildcard = true;
}
if (cur_field == 0) {
snp_pos[snp_cur++] = c;
} else if (cur_field == 1) {
kmer_pos[pos_cur++] = c;
} else if (cur_field == 2) {
kbuf1[k_cur++] = c;
} else if (cur_field == 3) {
kbuf2[k_cur++] = c;
} else if (cur_field == 4) {
kbuf3[k_cur++] = c;
} else if (cur_field == 5) {
kbuf4[k_cur++] = c;
} else {
//do nothing;
}
}
}
}
assert(kv1.size() == k_info.size() && kv1.size() == kv2.size());
assert(kv1.size() == kv3.size() && kv1.size() == kv4.size());
auto timeit = chrono_time();
close(fd);
}
template <class int_type>
void fna_load_pool(const char* fna_path, vector<char>& buffer, unordered_map<int_type, int_type>& k_map, const int_type* code_dict, const int_type b_mask) {
auto t_start = chrono_time();
char comp_map[1 << (sizeof(char) * 8)];
make_comp_map(comp_map);
char* window = buffer.data();
uintmax_t n_lines = 0;
int fd;
fd = open(fna_path, O_RDONLY);
int cur_pos = 0;
vector<char> seq_buf(10*1000*1000);
char* bases = seq_buf.data();
char kmer_buff[k];
char rckmer_buff[k];
bool is_base = false;
bool has_wildcard = false;
while (true) {
const ssize_t bytes_read = read(fd, window, step_size);
if (bytes_read == 0)
break;
if (bytes_read == (ssize_t) -1) {
cerr << "unknown fetal error when reading " << fna_path << endl;
exit(EXIT_FAILURE);
}
for (int i = 0; i < bytes_read; ++i) {
char c = window[i];
if (c == '\n') {
if (!is_base) {
is_base = true;
}
continue;
} else if (c == '>') {
for (int j = 0; j < cur_pos-k+1; ++j) {
for (int l = 0; l < k; ++l) {
kmer_buff[l] = bases[j+l];
if (kmer_buff[l] == 'N') {
has_wildcard = true;
break;
}
}
if (has_wildcard) {
has_wildcard = false;
continue;
}
auto kmer_int = seq_encode<int_type>(kmer_buff, k, code_dict, b_mask);
if (k_map.find(kmer_int) == k_map.end()) {
k_map.insert({kmer_int, 1});
} else {
++k_map[kmer_int];
}
for (int l = k-1; l >= 0; --l) {
rckmer_buff[k-1-l] = comp_map[kmer_buff[l]];
}
/* not really necessary when rc kmers present
auto rckmer_int = seq_encode<int_type>(rckmer_buff, k, code_dict, b_mask);
if (k_map.find(rckmer_int) == k_map.end()) {
k_map.insert({rckmer_int, 1});
} else {
++k_map[rckmer_int];
}
*/
}
cur_pos = 0;
is_base = false;
++n_lines;
} else {
if (is_base) {
bases[cur_pos++] = toupper(c);
}
}
}
}
if (cur_pos >= k) {
for (int j = 0; j < cur_pos-k+1; ++j) {
for (int l = 0; l < k; ++l) {
kmer_buff[l] = bases[j+l];
if (kmer_buff[l] == 'N') {
has_wildcard = true;
break;
}
}
if (has_wildcard) {
has_wildcard = false;
continue;
}
auto kmer_int = seq_encode<int_type>(kmer_buff, k, code_dict, b_mask);
if (k_map.find(kmer_int) == k_map.end()) {
k_map.insert({kmer_int, 1});
} else {
++k_map[kmer_int];
}
/* not really necessary when rc kmers present
for (int l = k-1; l >= 0; --l) {
rckmer_buff[k-1-l] = comp_map[kmer_buff[l]];
}
auto rckmer_int = seq_encode<int_type>(rckmer_buff, k, code_dict, b_mask);
if (k_map.find(rckmer_int) == k_map.end()) {
k_map.insert({rckmer_int, 1});
} else {
++k_map[rckmer_int];
}
*/
}
cur_pos = 0;
++n_lines;
}
buffer.clear();
cerr << fna_path << endl;
cerr << "number of sequences " << n_lines/2 << endl;
cerr << "number of unique kmers: "<< k_map.size() << endl << endl;
auto timeit = chrono_time();
close(fd);
}
template <class int_type>
void bit_load_pool(const char* k_path, vector<char>& buffer, unordered_map<int_type, int_type>& k_map, const int_type* code_dict, const int_type b_mask) {
auto t_start = chrono_time();
char* window = buffer.data();
uintmax_t n_lines = 0;
int fd;
fd = open(k_path, O_RDONLY);
int cur_pos = 0;
int snp_pos = 0;
char seq_buf[k];
char snp_id[16];
//auto fh = fstream(out_path, ios::out | ios::binary);
bool id_switch = false;
bool has_wildcard = false;
while (true) {
const ssize_t bytes_read = read(fd, window, step_size);
if (bytes_read == 0)
break;
if (bytes_read == (ssize_t) -1) {
cerr << "unknown fetal error when reading " << k_path << endl;
exit(EXIT_FAILURE);
}
for (int i = 0; i < bytes_read; ++i) {
char c = toupper(window[i]);
if (c == '\n') {
++n_lines;
if (has_wildcard) {
has_wildcard = false;
continue;
}
auto kmer_int = seq_encode<int_type>(seq_buf, k, code_dict, b_mask);
snp_id[snp_pos] = '\0';
int_type kcount = stoull(snp_id);
assert(k_map.find(kmer_int) == k_map.end());
k_map.insert({kmer_int, kcount});
cur_pos = 0;
snp_pos = 0;
id_switch = false;
} else if (c == '\t'){
id_switch = true;
} else {
if (c == 'N') {
has_wildcard = true;
}
if (id_switch) {
snp_id[snp_pos++] = c;
} else {
seq_buf[cur_pos++] = c;
}
}
}
//fh.write(&kmers[0], kmers.size());
// cerr << n_lines << " lines were scanned after " << (chrono_time() - t_start) / 1000 << " seconds" << endl;
}
auto timeit = chrono_time();
close(fd);
}
template <class int_type>
void bin_load_pool(const char* p_path, unordered_map<int_type, int_type>& k_map) {
size_t filesize = get_fsize(p_path);
//Open file
int fd = open(p_path, O_RDONLY, 0);
assert(fd != -1);
//Execute mmap
//uint64_t* mmappedData = (uint64_t *) mmap(NULL, filesize, PROT_READ, MAP_PRIVATE | MAP_POPULATE, fd, 0);
int_type* mmappedData = (int_type *) mmap(NULL, filesize, PROT_READ, MMAP_FLAGS, fd, 0);
assert(mmappedData != MAP_FAILED);
//Write the mmapped data to stdout (= FD #1)
// write(1, mmappedData, filesize);
// char seq_buf[k+1];
auto l_start = chrono_time();
for (uint64_t i = 0; i < filesize/8; i=i+2) {
// seq_decode<uint_fast64_t>(seq_buf, k, mmappedData[i], b_mask);
auto kmer_int = mmappedData[i];
auto kcount = mmappedData[i+1];
assert(k_map.find(kmer_int) == k_map.end());
k_map.insert({kmer_int, kcount});
}
//Cleanup
int rc = munmap(mmappedData, filesize);
assert(rc == 0);
close(fd);
}
template <class int_type>
bool cmp_tuple(const tuple<int_type, int_type> &a, const tuple<int_type, int_type> &b){
return get<0>(a) < get<0>(b);
}
template <class int_type>
void set_kvecs(char* db_path, const int kv_n, vector<int_type>* kvecs, vector<tuple<int_type, int_type>>& kinfo) {
assert(kv_n == 4);
int_type lsb = 1;
int_type b_mask = (lsb << bpb) - lsb;
int_type code_dict[1 << (sizeof(char) * 8)];
make_code_dict<int_type>(code_dict);
vector<char> buffer(buffer_size);
load_profile<int_type>(db_path, buffer, kvecs[0], kvecs[1], kvecs[2], kvecs[3], kinfo, code_dict, b_mask);
cerr << "DB loading OK!" << endl;
}
template <class int_type>
void multi_dbval(int kv_n, vector<int_type>* kvecs, int n_path, vector<string>& kpaths, vector<tuple<int, int, int, int, int>>& prof_vec) {
assert(kv_n == 4);
int_type lsb = 1;
int_type b_mask = (lsb << bpb) - lsb;
int_type code_dict[1 << (sizeof(char) * 8)];
make_code_dict<int_type>(code_dict);
vector<char> buffer(buffer_size);
int64_t prof_size = kvecs[0].size();
vector<int> lc_vecs[4];
for (int i = 0; i < 4; ++i) {
lc_vecs[i].reserve(prof_size);
}
prof_vec.resize(prof_size, make_tuple(0,0,0,0,0));
unordered_map<int_type, int_type> kpool;
for (int i = 0; i < n_path; ++i) {
char* kp_type = get_ftype(kpaths[i].c_str());
if (strcmp(kp_type, ".bin") == 0) {
bin_load_pool<int_type>(kpaths[i].c_str(), kpool);
} else if (strcmp(kp_type, ".fna") == 0) {
fna_load_pool<int_type>(kpaths[i].c_str(), buffer, kpool, code_dict, b_mask);
} else {
bit_load_pool<int_type>(kpaths[i].c_str(), buffer, kpool, code_dict, b_mask);
}
// splitted loops
for (int j = 0; j < 4; ++j) {
for(auto it = kvecs[j].begin(); it != kvecs[j].end(); ++it) {
if(kpool.find(*it) == kpool.end()) {
lc_vecs[j].push_back(0);
} else {
lc_vecs[j].push_back(kpool[*it]);
}
}
}
assert(lc_vecs[0].size() == lc_vecs[1].size());
assert(lc_vecs[0].size() == lc_vecs[2].size());
assert(lc_vecs[0].size() == lc_vecs[3].size());
const int64_t lc_size = lc_vecs[0].size();
for (int64_t j = 0; j < lc_size; ++j) {
auto lc_sum = lc_vecs[0][j] + lc_vecs[1][j] + lc_vecs[2][j] + lc_vecs[3][j];
auto ref_sum = lc_vecs[0][j] + lc_vecs[2][j];
auto alt_sum = lc_vecs[1][j] + lc_vecs[3][j];
/*
if (strcmp(kp_type, ".fna") == 0) {
lc_sum = lc_sum / 2;
}
*/
if (lc_sum == 0) {
++get<0>(prof_vec[j]);
} else if (lc_sum == 1) {
++get<1>(prof_vec[j]);
} else {
++get<2>(prof_vec[j]);
}
if (ref_sum > 0) {
++get<3>(prof_vec[j]);
}
if (alt_sum > 0) {
++get<4>(prof_vec[j]);
}
}
for (int j = 0; j < 4; ++j) {
lc_vecs[j].clear();
}
kpool.clear();
}
auto timeit = chrono_time();
}
void display_usage(char *fname){
cout << "usage: " << fname << " -d profile_path -n identifier [-t n_threads] [-o output_path] [-L path to list of input] inpath1 [ inpath2 ...]\n";
}
int main(int argc, char** argv){
extern char *optarg;
extern int optind;
bool dbflag = false;
bool inflag = false;
bool idflag = false;
bool list_flag = false;
char* fname = argv[0];
char* db_path = (char *)"";
char* list_path = (char *)"";
char* oname = (char *)"/dev/stdout";
char* spe_id = (char *)"";
int n_threads = 1;
int opt;
while ((opt = getopt(argc, argv, "d:n:t:L:o:h")) != -1) {
switch (opt) {
case 'd':
dbflag = true;
db_path = optarg;
break;
case 'n':
idflag = true;
spe_id = optarg;
break;
case 't':
n_threads = stoi(optarg);
break;
case 'L':
list_flag = true;
list_path = optarg;
break;
case 'o':
oname = optarg;
break;
case 'h': case '?':
display_usage(fname);
exit(1);
}
}
cerr << fname << '\t' << db_path << '\t' << n_threads << endl;
if (!dbflag) {
cerr << "missing argument: -d <sckmerdb_path: string>\n";
display_usage(fname);
exit(1);
}
if (!idflag) {
cerr << "missing argument: -n <species identifier>\n";
display_usage(fname);
exit(1);
}
int in_pos = optind;
if (list_flag) {
cerr << "program reads a list of kmer pools for checking kmer uniqueness: " << list_path << endl;
} else {
if (optind == argc) {
cerr << "missing argument: input (>1)\n";
display_usage(fname);
exit(1);
}
}
vector<uint64_t> kvecs[4];
const int max_size = 100 * 1000 * 1000;
for (int i = 0; i < 4; ++i) {
kvecs[i].reserve(max_size);
}
vector<tuple<uint64_t, uint64_t>> kinfo;
set_kvecs<uint64_t>(db_path, 4, kvecs, kinfo);
vector<string> input_array[n_threads];
auto label = 0;
if (list_flag) {
ifstream file(list_path);
string line;
int l_count = 0;
while (getline(file, line)) {
label = l_count % n_threads;
string tmp_line = line;
input_array[label].push_back(tmp_line);
++l_count;
}
}
if (optind < argc) {
for(; optind < argc; optind++) {
auto slabel = (optind - in_pos + label) % n_threads;
input_array[slabel].push_back(string(argv[optind]));
}
}
vector<tuple<int, int, int, int, int>> prof_vecs[n_threads];
vector<thread> th_array;
for (int i = 0; i < n_threads; ++i) {
th_array.push_back(thread(multi_dbval<uint64_t>, 4, kvecs, input_array[i].size(), ref(input_array[i]), ref(prof_vecs[i])));
}
for (thread & ith : th_array) {
ith.join();
}
th_array.clear();
vector<tuple<int, int, int, int, int>> reduced_prof;
reduced_prof.resize(kvecs[0].size(), make_tuple(0,0,0,0,0));
uint64_t lsb = 1;
uint64_t b_mask = (lsb << bpb) - lsb;
uint64_t code_dict[1 << (sizeof(char) * 8)];
make_code_dict<uint64_t>(code_dict);
char sbuf1[k+1];
char sbuf2[k+1];
char sbuf3[k+1];
char sbuf4[k+1];
ofstream myfile;
myfile.open(oname);
for (int j = 0; j < kinfo.size(); ++j) {
for (int i = 0; i < n_threads; ++i) {
get<0>(reduced_prof[j]) += get<0>(prof_vecs[i][j]);
get<1>(reduced_prof[j]) += get<1>(prof_vecs[i][j]);
get<2>(reduced_prof[j]) += get<2>(prof_vecs[i][j]);
get<3>(reduced_prof[j]) += get<3>(prof_vecs[i][j]);
get<4>(reduced_prof[j]) += get<4>(prof_vecs[i][j]);
}
auto info_pair = kinfo[j];
seq_decode<uint64_t>(sbuf1, k+1, kvecs[0][j], code_dict, b_mask);
seq_decode<uint64_t>(sbuf2, k+1, kvecs[1][j], code_dict, b_mask);
seq_decode<uint64_t>(sbuf3, k+1, kvecs[2][j], code_dict, b_mask);
seq_decode<uint64_t>(sbuf4, k+1, kvecs[3][j], code_dict, b_mask);
myfile << get<0>(info_pair) << '\t' << get<1>(info_pair) << '\t' << sbuf1 << '\t' << sbuf2 << '\t' << sbuf3 << '\t' << sbuf4 << '\t' << get<0>(reduced_prof[j]) << '\t' << get<1>(reduced_prof[j]) << '\t'<< get<2>(reduced_prof[j]) << '\t' << spe_id << '\t' << get<3>(reduced_prof[j]) << '\t'<< get<4>(reduced_prof[j]) << '\n';
}
return 0;
}
| 24.915511 | 326 | 0.561899 | [
"vector"
] |
243c8935e6e7c784b16a32803f7bf7f77e6c8d9d | 1,543 | hpp | C++ | app/ui.hpp | cl-volume-renderer/cl-volume-renderer | 9d6bc470a97ece955778104081bc1b803b2cc77c | [
"Apache-2.0"
] | null | null | null | app/ui.hpp | cl-volume-renderer/cl-volume-renderer | 9d6bc470a97ece955778104081bc1b803b2cc77c | [
"Apache-2.0"
] | null | null | null | app/ui.hpp | cl-volume-renderer/cl-volume-renderer | 9d6bc470a97ece955778104081bc1b803b2cc77c | [
"Apache-2.0"
] | null | null | null | #pragma once
#include <SDL.h>
#include <SDL_opengl.h>
#include <imgui_impl_sdl.h>
#include <imgui_impl_opengl2.h>
#include <string>
#include "volume_block.hpp"
#include <clw_image.hpp>
#include <clw_context.hpp>
#include "common.hpp"
#include "reference_volume.hpp"
#include "env_map.hpp"
struct ui_state{
std::string path;
bool path_changed;
int height;
int width;
Position3D position; //0->x 1->y 3->z
float direction_look[2]; //this are two angles that you can adjust
bool cam_changed;
};
#include "tf_part.hpp"
class frame_emitter {
public:
virtual ~frame_emitter() { };
virtual void image_set(const reference_volume *volume, const env_map *map) = 0;
virtual void next_event_code_set(const std::string cl_code) = 0;
virtual void flush_changes() = 0;
virtual void* render_frame(struct ui_state &state, bool &frame_changed) = 0;
virtual void* render_tf(const unsigned int width, const unsigned int height) = 0;
};
class ui {
private:
clw_context &ctx;
SDL_Window *window;
SDL_GLContext gl_context;
GLuint frametexture;
GLuint tftexture;
std::string nrrd_path, env_map_path;
void flush_tf(frame_emitter *emitter, Volume_Stats stats, std::vector<tf_selection*> selection);
public:
ui(const char *path, const char *env_map, clw_context &c);
~ui();
void run(frame_emitter *emitter);
const GLuint frametexture_get(void);
void * gl_context_get(void);
void frametexture_fill(unsigned int width, unsigned int height, const void *data);
};
| 27.553571 | 100 | 0.715489 | [
"vector"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.