hexsha
stringlengths 40
40
| size
int64 7
1.05M
| ext
stringclasses 13
values | lang
stringclasses 1
value | max_stars_repo_path
stringlengths 4
269
| max_stars_repo_name
stringlengths 5
109
| max_stars_repo_head_hexsha
stringlengths 40
40
| max_stars_repo_licenses
listlengths 1
9
| max_stars_count
int64 1
191k
⌀ | max_stars_repo_stars_event_min_datetime
stringlengths 24
24
⌀ | max_stars_repo_stars_event_max_datetime
stringlengths 24
24
⌀ | max_issues_repo_path
stringlengths 4
269
| max_issues_repo_name
stringlengths 5
116
| max_issues_repo_head_hexsha
stringlengths 40
40
| max_issues_repo_licenses
listlengths 1
9
| max_issues_count
int64 1
48.5k
⌀ | max_issues_repo_issues_event_min_datetime
stringlengths 24
24
⌀ | max_issues_repo_issues_event_max_datetime
stringlengths 24
24
⌀ | max_forks_repo_path
stringlengths 4
269
| max_forks_repo_name
stringlengths 5
116
| max_forks_repo_head_hexsha
stringlengths 40
40
| max_forks_repo_licenses
listlengths 1
9
| max_forks_count
int64 1
105k
⌀ | max_forks_repo_forks_event_min_datetime
stringlengths 24
24
⌀ | max_forks_repo_forks_event_max_datetime
stringlengths 24
24
⌀ | content
stringlengths 7
1.05M
| avg_line_length
float64 1.21
330k
| max_line_length
int64 6
990k
| alphanum_fraction
float64 0.01
0.99
| author_id
stringlengths 2
40
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
f6f3b455dd68126270bdd7e38b4c4907c196bcfe
| 2,196
|
cc
|
C++
|
src/transport/FissionSource.cc
|
RLReed/libdetran
|
77637c788823e0a14aae7e40e476a291f6f3184b
|
[
"MIT"
] | null | null | null |
src/transport/FissionSource.cc
|
RLReed/libdetran
|
77637c788823e0a14aae7e40e476a291f6f3184b
|
[
"MIT"
] | null | null | null |
src/transport/FissionSource.cc
|
RLReed/libdetran
|
77637c788823e0a14aae7e40e476a291f6f3184b
|
[
"MIT"
] | null | null | null |
//----------------------------------*-C++-*----------------------------------//
/**
* @file FissionSource.cc
* @author robertsj
* @date Apr 10, 2012
* @brief FissionSource class definition.
*/
//---------------------------------------------------------------------------//
#include "transport/FissionSource.hh"
#include "utilities/MathUtilities.hh"
#include <iostream>
namespace detran
{
//---------------------------------------------------------------------------//
FissionSource::FissionSource(SP_state state,
SP_mesh mesh,
SP_material material)
: d_state(state)
, d_mesh(mesh)
, d_material(material)
, d_scale(1.0)
{
// Preconditions
Require(d_state);
Require(d_mesh);
Require(d_material);
d_number_groups = d_material->number_groups();
d_density.assign(d_mesh->number_cells(), 0.0);
d_source.resize(d_material->number_groups(),
moments_type(mesh->number_cells(), 0.0));
}
//---------------------------------------------------------------------------//
FissionSource::SP_fissionsource
FissionSource::Create(SP_state state, SP_mesh mesh, SP_material material)
{
SP_fissionsource p;
p = new FissionSource(state, mesh, material);
return p;
}
//---------------------------------------------------------------------------//
void FissionSource::initialize()
{
/*
* Define the density as the normalized sum of
* nu * fission cross section. Normalized
* using the L1 norm.
*/
vec_int mat_map = d_mesh->mesh_map("MATERIAL");
int ng = d_material->number_groups();
for (size_t cell = 0; cell < d_mesh->number_cells(); ++cell)
{
d_density[cell] = 0.0;
for (int g = 0; g < ng; g++)
{
d_density[cell] += d_material->nu_sigma_f(mat_map[cell], g);
}
}
double norm_density = detran_utilities::norm(d_density, "L1");
Require(norm_density > 0.0);
detran_utilities::vec_scale(d_density, 1.0/norm_density);
}
} // end namespace detran
//---------------------------------------------------------------------------//
// end of FissionSource.cc
//---------------------------------------------------------------------------//
| 29.675676
| 79
| 0.489982
|
RLReed
|
f6f64413d6b12049850d4d147806c3555d1b6098
| 995
|
cpp
|
C++
|
hw4/src/lib/AST/VariableReference.cpp
|
idoleat/P-Language-Compiler-CourseProject
|
57db735b349a0a3a30d78b927953e2d44b7c7d53
|
[
"MIT"
] | 7
|
2020-09-10T16:54:49.000Z
|
2022-03-15T12:39:23.000Z
|
hw4/src/lib/AST/VariableReference.cpp
|
idoleat/simple-P-compiler
|
57db735b349a0a3a30d78b927953e2d44b7c7d53
|
[
"MIT"
] | null | null | null |
hw4/src/lib/AST/VariableReference.cpp
|
idoleat/simple-P-compiler
|
57db735b349a0a3a30d78b927953e2d44b7c7d53
|
[
"MIT"
] | null | null | null |
#include "AST/VariableReference.hpp"
#include "visitor/AstNodeVisitor.hpp"
VariableReferenceNode::VariableReferenceNode(const uint32_t line,
const uint32_t col,
const char *p_name)
: ExpressionNode{line, col}, name(p_name) {}
VariableReferenceNode::VariableReferenceNode(const uint32_t line,
const uint32_t col,
const char *p_name,
Exprs *p_indices)
: ExpressionNode{line, col}, name(p_name), indices(std::move(*p_indices)) {}
const char *VariableReferenceNode::getNameCString() const {
return name.c_str();
}
void VariableReferenceNode::accept(AstNodeVisitor &p_visitor) {
p_visitor.visit(*this);
}
void VariableReferenceNode::visitChildNodes(AstNodeVisitor &p_visitor) {
for (auto &index : indices) {
index->accept(p_visitor);
}
}
| 35.535714
| 80
| 0.580905
|
idoleat
|
f6f81d27fca34b6cd9e7f5210d2847622ad87a4d
| 6,248
|
cpp
|
C++
|
modules/preprocessing/processors/glimageresampler.cpp
|
hmsgit/campvis
|
d97de6a86323866d6a8f81d2a641e3e0443a6b39
|
[
"ECL-2.0",
"Apache-2.0"
] | 5
|
2018-06-19T06:20:01.000Z
|
2021-07-31T05:54:25.000Z
|
modules/preprocessing/processors/glimageresampler.cpp
|
hmsgit/campvis
|
d97de6a86323866d6a8f81d2a641e3e0443a6b39
|
[
"ECL-2.0",
"Apache-2.0"
] | null | null | null |
modules/preprocessing/processors/glimageresampler.cpp
|
hmsgit/campvis
|
d97de6a86323866d6a8f81d2a641e3e0443a6b39
|
[
"ECL-2.0",
"Apache-2.0"
] | null | null | null |
// ================================================================================================
//
// This file is part of the CAMPVis Software Framework.
//
// If not explicitly stated otherwise: Copyright (C) 2012-2015, all rights reserved,
// Christian Schulte zu Berge <christian.szb@in.tum.de>
// Chair for Computer Aided Medical Procedures
// Technische Universitaet Muenchen
// Boltzmannstr. 3, 85748 Garching b. Muenchen, Germany
//
// For a full list of authors and contributors, please refer to the file "AUTHORS.txt".
//
// 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 "glimageresampler.h"
#include "cgt/logmanager.h"
#include "cgt/shadermanager.h"
#include "cgt/textureunit.h"
#include "cgt/texture.h"
#include "core/datastructures/imagedata.h"
#include "core/datastructures/imagerepresentationgl.h"
#include "core/datastructures/renderdata.h"
#include "core/tools/quadrenderer.h"
namespace campvis {
const std::string GlImageResampler::loggerCat_ = "CAMPVis.modules.classification.GlImageResampler";
GlImageResampler::GlImageResampler(IVec2Property* viewportSizeProp)
: VisualizationProcessor(viewportSizeProp)
, p_inputImage("InputImage", "Input Image", "", DataNameProperty::READ)
, p_outputImage("OutputImage", "Output Image", "GlImageResampler.out", DataNameProperty::WRITE)
, p_resampleScale("ResampleScale", "Resampling Scale", .5f, .01f, 10.f)
, p_targetSize("TargetSize", "Size of Resampled Image", cgt::ivec3(128), cgt::ivec3(1), cgt::ivec3(1024))
, _shader2D(0)
, _shader3D(0)
{
addProperty(p_inputImage, INVALID_RESULT | INVALID_PROPERTIES);
addProperty(p_outputImage);
addProperty(p_resampleScale, INVALID_RESULT | INVALID_PROPERTIES);
addProperty(p_targetSize);
}
GlImageResampler::~GlImageResampler() {
}
void GlImageResampler::init() {
VisualizationProcessor::init();
_shader2D = ShdrMgr.load("core/glsl/passthrough.vert", "modules/preprocessing/glsl/glimageresampler.frag", "#define GLRESAMPLER_2D\n");
_shader3D = ShdrMgr.load("core/glsl/passthrough.vert", "modules/preprocessing/glsl/glimageresampler.frag", "#define GLRESAMPLER_3D\n");
}
void GlImageResampler::deinit() {
ShdrMgr.dispose(_shader2D);
ShdrMgr.dispose(_shader3D);
VisualizationProcessor::deinit();
}
void GlImageResampler::updateResult(DataContainer& data) {
ImageRepresentationGL::ScopedRepresentation img(data, p_inputImage.getValue());
if (img != 0) {
cgt::vec3 originalSize(img->getSize());
cgt::ivec3 resampledSize = p_targetSize.getValue();
bool isTexture2D = img->getParent()->getDimensionality() == 2;
// 2D textures should not be scaled along the z axis
if (isTexture2D) {
resampledSize.z = 1;
}
cgt::TextureUnit inputUnit;
inputUnit.activate();
// create texture for result
cgt::Texture* resultTexture = new cgt::Texture(isTexture2D ? GL_TEXTURE_2D : GL_TEXTURE_3D, resampledSize, img->getTexture()->getInternalFormat(), cgt::Texture::LINEAR);
// Select the right shader for the 2D and 3D case
cgt::Shader *shader = isTexture2D ? _shader2D : _shader3D;
// activate shader and bind textures
shader->activate();
img->bind(shader, inputUnit);
// activate FBO and attach texture
_fbo->activate();
glViewport(0, 0, static_cast<GLsizei>(resampledSize.x), static_cast<GLsizei>(resampledSize.y));
// render quad to compute difference measure by shader
for (int z = 0; z < resampledSize.z; ++z) {
if (!isTexture2D) {
float zTexCoord = static_cast<float>(z)/static_cast<float>(resampledSize.z) + .5f/static_cast<float>(resampledSize.z);
shader->setUniform("_zTexCoord", zTexCoord);
}
_fbo->attachTexture(resultTexture, GL_COLOR_ATTACHMENT0, 0, z);
LGL_ERROR;
QuadRdr.renderQuad();
}
_fbo->detachAll();
_fbo->deactivate();
shader->deactivate();
// put resulting image into DataContainer
ImageData* id = new ImageData(img->getParent()->getDimensionality(), resampledSize, img->getParent()->getNumChannels());
ImageRepresentationGL::create(id, resultTexture);
const ImageMappingInformation& imi = img->getParent()->getMappingInformation();
id->setMappingInformation(ImageMappingInformation(img->getSize(), imi.getOffset(), imi.getVoxelSize() / p_resampleScale.getValue(), imi.getCustomTransformation()));
data.addData(p_outputImage.getValue(), id);
cgt::TextureUnit::setZeroUnit();
LGL_ERROR;
}
else {
LDEBUG("No suitable input image found.");
}
}
void GlImageResampler::updateProperties(DataContainer& dataContainer) {
ImageRepresentationGL::ScopedRepresentation img(dataContainer, p_inputImage.getValue());
if (img != 0) {
p_targetSize.setMaxValue(cgt::ivec3(img->getSize()) * int(p_resampleScale.getMaxValue()));
p_targetSize.setValue(cgt::ivec3(cgt::vec3(img->getSize()) * p_resampleScale.getValue()));
}
}
}
| 43.388889
| 182
| 0.618918
|
hmsgit
|
f6f8e76b81aa6bccd97a2f568a866c6ed92c3333
| 816
|
cc
|
C++
|
src/longest-prefix/t.cc
|
thinkoid/hacks
|
7c5887860bf9177e487e2f2f041629ddbd3c38fb
|
[
"MIT"
] | null | null | null |
src/longest-prefix/t.cc
|
thinkoid/hacks
|
7c5887860bf9177e487e2f2f041629ddbd3c38fb
|
[
"MIT"
] | null | null | null |
src/longest-prefix/t.cc
|
thinkoid/hacks
|
7c5887860bf9177e487e2f2f041629ddbd3c38fb
|
[
"MIT"
] | null | null | null |
// -*- mode: c++ -*-
#include <cassert>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>
#include <hacks/knuth-morris-pratt.hh>
using namespace std;
static inline size_t
longest_prefix (const string& s) {
const auto t (s + '$');
const auto kmp = knuth_morris_pratt< string::const_iterator > (
t.begin (), t.end ());
return kmp.table ().back ();
}
static void
test (const string& s, size_t n) {
const auto result = longest_prefix (s);
cout << s << " " << result << " " << n << " ";
if (result == n)
cout << "PASS";
else
cout << "FAIL";
cout << endl;
}
int main () {
#define T(s, n) test (#s, n)
T ( acax, 0);
T ( aca, 1);
T ( abcab, 2);
T ( abcabc, 3);
T (abcdabc, 3);
#undef T
return 0;
}
| 16.32
| 67
| 0.535539
|
thinkoid
|
f6f9beb1dbf89737dcec729f0e44ec3976e38652
| 8,561
|
cpp
|
C++
|
Engine/source/sfx/sfxBuffer.cpp
|
vbillet/Torque3D
|
ece8823599424ea675e5f79d9bcb44e42cba8cae
|
[
"MIT"
] | 2,113
|
2015-01-01T11:23:01.000Z
|
2022-03-28T04:51:46.000Z
|
Engine/source/sfx/sfxBuffer.cpp
|
Ashry00/Torque3D
|
33e3e41c8b7eb41c743a589558bc21302207ef97
|
[
"MIT"
] | 948
|
2015-01-02T01:50:00.000Z
|
2022-02-27T05:56:40.000Z
|
Engine/source/sfx/sfxBuffer.cpp
|
Ashry00/Torque3D
|
33e3e41c8b7eb41c743a589558bc21302207ef97
|
[
"MIT"
] | 944
|
2015-01-01T09:33:53.000Z
|
2022-03-15T22:23:03.000Z
|
//-----------------------------------------------------------------------------
// Copyright (c) 2012 GarageGames, LLC
//
// 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 "sfx/sfxBuffer.h"
#include "sfx/sfxVoice.h"
#include "sfx/sfxDescription.h"
#include "sfx/sfxInternal.h"
//#define DEBUG_SPEW
Signal< void( SFXBuffer* ) > SFXBuffer::smBufferDestroyedSignal;
//-----------------------------------------------------------------------------
SFXBuffer::SFXBuffer( const ThreadSafeRef< SFXStream >& stream, SFXDescription* description, bool createAsyncState )
: mStatus( STATUS_Null ),
mFormat( stream->getFormat() ),
mDuration( stream->getDuration() ),
mIsStreaming( description->mIsStreaming ),
mIsLooping( description->mIsLooping ),
mIsUnique( description->mIsStreaming ),
mIsDead( false ),
mUniqueVoice( NULL )
{
using namespace SFXInternal;
if( createAsyncState )
{
U32 packetLength = description->mStreamPacketSize;
U32 readAhead = description->mStreamReadAhead;
ThreadSafeRef< SFXStream > streamRef( stream );
mAsyncState = new AsyncState(
new SFXAsyncStream
( streamRef, mIsStreaming, packetLength, readAhead,
mIsStreaming ? description->mIsLooping : false ) );
}
}
//-----------------------------------------------------------------------------
SFXBuffer::SFXBuffer( SFXDescription* description )
: mStatus( STATUS_Ready ),
mDuration( 0 ), // Must be set by subclass.
mIsStreaming( false ), // Not streaming through our system.
mIsLooping( description->mIsLooping ),
mIsUnique( false ), // Must be set by subclass.
mIsDead( false ),
mUniqueVoice( NULL )
{
}
//-----------------------------------------------------------------------------
SFXBuffer::~SFXBuffer()
{
smBufferDestroyedSignal.trigger( this );
}
//-----------------------------------------------------------------------------
void SFXBuffer::load()
{
if( getStatus() == STATUS_Null )
{
AssertFatal( mAsyncState != NULL, "SFXBuffer::load() - no async state!" );
_setStatus( STATUS_Loading );
SFXInternal::UPDATE_LIST().add( this );
mAsyncState->mStream->start();
}
}
//-----------------------------------------------------------------------------
bool SFXBuffer::update()
{
using namespace SFXInternal;
if( isDead() )
{
// Buffer requested to finish its async operations.
// Kill our async state and put us on the dead buffer list.
mAsyncState->mStream->stop();
mAsyncState = NULL;
gDeadBufferList.pushFront( this );
return false;
}
else if( isAtEnd() && isStreaming() )
{
// Streaming buffers remain in the update loop even if they
// have played in full to allow for stream seeks.
return true;
}
AssertFatal( mAsyncState != NULL, "SFXBuffer::update() - async state has already been released" );
bool needFurtherUpdates = true;
if( !isStreaming() )
{
// Not a streaming buffer. If the async stream has its data
// ready, we load it and finish up on our async work.
SFXStreamPacket* packet;
while( mAsyncState->mStream->read( &packet, 1 ) )
{
bool isLast = packet->mIsLast;
// Write packet data into buffer.
write( &packet, 1 );
packet = NULL;
if( isLast )
{
// Release async state.
mAsyncState = NULL;
// Once loaded, non-streaming buffers disappear from the SFX
// update thread.
needFurtherUpdates = false;
// Signal that we are ready.
_setStatus( STATUS_Ready );
#ifdef DEBUG_SPEW
Platform::outputDebugString( "[SFXBuffer] Buffer ready" );
#endif
break;
}
}
}
else
{
// A streaming buffer.
//
// If we don't have a queue, construct one now. Note that when doing
// a stream seek on us, SFXVoice will drop our async stream and queue.
// Work on local copies of the pointers to allow having the async state
// be switched in parallel.
//
// Note that despite us being a streamed buffer, our unique voice may
// not yet have been assigned to us.
AsyncStatePtr state = mAsyncState;
if( !state->mQueue && !mUniqueVoice.isNull() )
{
// Make sure we have no data currently submitted to the device.
// This will stop and discard an outdated feed if we've been
// switching streams.
_setStatus( STATUS_Loading );
_flush();
// Create a new queue.
state->mQueue = new SFXAsyncQueue( mUniqueVoice, this, mIsLooping );
}
// Check the queue.
if( state->mQueue != NULL )
{
// Feed the queue, if necessary and possible.
while( state->mQueue->needPacket() )
{
// Try to read a packet.
SFXStreamPacket* packet;
if( !state->mStream->read( &packet, 1 ) )
break;
// Submit it.
state->mQueue->submitPacket( packet, packet->getSampleCount() );
#ifdef DEBUG_SPEW
Platform::outputDebugString( "[SFXBuffer] Stream packet queued" );
#endif
// Signal that the buffer has data ready.
_setStatus( STATUS_Ready );
}
// Detect buffer underrun and end-of-stream.
if( !isReady() && state->mQueue->isEmpty() )
{
#ifdef DEBUG_SPEW
Platform::outputDebugString( "[SFXBuffer] Stream blocked" );
#endif
_setStatus( STATUS_Blocked );
}
else if( state->mQueue->isAtEnd() )
{
#ifdef DEBUG_SPEW
Platform::outputDebugString( "[SFXBuffer] Stream at end" );
#endif
_setStatus( STATUS_AtEnd );
_flush();
}
}
}
return needFurtherUpdates;
}
//-----------------------------------------------------------------------------
void SFXBuffer::destroySelf()
{
AssertFatal( !isDead(), "SFXBuffer::destroySelf() - buffer already dead" );
mIsDead = true;
if( !mAsyncState )
{
// Easy way. This buffer has finished all its async
// processing, so we can just kill it.
delete this;
}
else
{
// Hard way. We will have to make the buffer finish
// all its concurrent stuff, so we mark it dead, make sure
// to see an update, and then wait for the buffer to surface
// on the dead buffer list.
SFXInternal::TriggerUpdate();
}
}
//-----------------------------------------------------------------------------
void SFXBuffer::_setStatus( Status status )
{
if( mStatus != status )
{
mOnStatusChange.trigger( this, status );
mStatus = status;
}
}
//-----------------------------------------------------------------------------
SFXBuffer::AsyncState::AsyncState()
: mQueue( NULL )
{
}
//-----------------------------------------------------------------------------
SFXBuffer::AsyncState::AsyncState( SFXInternal::SFXAsyncStream* stream )
: mStream( stream ), mQueue( NULL )
{
}
//-----------------------------------------------------------------------------
SFXBuffer::AsyncState::~AsyncState()
{
if( mQueue )
SAFE_DELETE( mQueue );
}
| 29.318493
| 116
| 0.550403
|
vbillet
|
f6fc221cbd0db245d84b04bbf998e51b7cd679ad
| 107,768
|
hpp
|
C++
|
ReactNativeFrontend/ios/Pods/boost/boost/preprocessor/seq/limits/fold_left_512.hpp
|
Harshitha91/Tmdb-react-native-node
|
e06e3f25a7ee6946ef07a1f524fdf62e48424293
|
[
"Apache-2.0"
] | 2,728
|
2015-01-01T10:06:45.000Z
|
2022-03-30T18:12:58.000Z
|
ReactNativeFrontend/ios/Pods/boost/boost/preprocessor/seq/limits/fold_left_512.hpp
|
Harshitha91/Tmdb-react-native-node
|
e06e3f25a7ee6946ef07a1f524fdf62e48424293
|
[
"Apache-2.0"
] | 1,192
|
2015-01-01T06:03:19.000Z
|
2022-03-31T09:14:36.000Z
|
ReactNativeFrontend/ios/Pods/boost/boost/preprocessor/seq/limits/fold_left_512.hpp
|
Harshitha91/Tmdb-react-native-node
|
e06e3f25a7ee6946ef07a1f524fdf62e48424293
|
[
"Apache-2.0"
] | 334
|
2015-01-08T20:47:03.000Z
|
2022-02-18T07:07:01.000Z
|
# /* **************************************************************************
# * *
# * (C) Copyright Paul Mensonides 2002.
# * 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)
# * *
# ************************************************************************** */
#
# /* Revised by Edward Diener (2020) */
#
# /* See http://www.boost.org for most recent version. */
#
# ifndef BOOST_PREPROCESSOR_SEQ_FOLD_LEFT_512_HPP
# define BOOST_PREPROCESSOR_SEQ_FOLD_LEFT_512_HPP
#
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_257(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_258(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_259(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_260(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_261(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_262(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_263(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_264(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_265(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_266(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_267(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_268(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_269(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_270(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_271(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_272(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_273(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_274(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_275(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_276(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_277(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_278(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_279(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_280(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_281(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_282(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_283(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_284(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_285(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_286(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_287(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_288(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_289(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_290(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_291(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_292(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_293(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_294(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_295(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_296(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_297(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_298(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_299(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_300(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_301(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_302(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_303(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_304(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_305(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_306(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_307(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_308(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_309(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_310(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_311(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_312(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_313(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_314(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_315(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_316(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_317(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_318(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_319(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_320(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_321(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_322(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_323(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_324(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_325(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_326(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_327(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_328(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_329(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_330(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_331(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_332(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_333(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_334(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_335(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_336(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_337(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_338(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_339(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_340(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_341(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_342(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_343(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_344(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_345(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_346(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_347(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_348(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_349(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_350(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_351(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_352(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_353(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_354(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_355(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_356(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_357(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_358(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_359(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_360(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_361(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_362(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_363(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_364(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_365(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_366(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_367(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_368(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_369(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_370(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_371(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_372(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_373(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_374(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_375(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_376(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_377(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_378(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_379(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_380(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_381(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_382(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_383(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_384(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_385(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_386(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_387(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_388(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_389(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_390(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_391(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_392(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_393(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_394(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_395(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_396(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_397(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_398(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_399(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_400(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_401(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_402(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_403(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_404(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_405(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_406(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_407(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_408(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_409(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_410(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_411(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_412(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_413(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_414(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_415(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_416(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_417(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_418(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_419(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_420(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_421(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_422(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_423(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_424(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_425(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_426(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_427(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_428(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_429(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_430(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_431(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_432(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_433(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_434(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_435(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_436(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_437(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_438(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_439(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_440(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_441(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_442(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_443(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_444(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_445(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_446(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_447(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_448(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_449(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_450(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_451(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_452(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_453(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_454(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_455(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_456(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_457(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_458(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_459(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_460(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_461(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_462(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_463(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_464(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_465(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_466(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_467(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_468(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_469(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_470(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_471(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_472(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_473(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_474(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_475(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_476(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_477(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_478(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_479(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_480(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_481(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_482(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_483(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_484(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_485(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_486(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_487(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_488(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_489(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_490(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_491(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_492(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_493(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_494(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_495(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_496(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_497(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_498(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_499(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_500(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_501(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_502(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_503(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_504(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_505(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_506(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_507(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_508(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_509(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_510(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_511(op, st, ss, sz) 0
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_512(op, st, ss, sz) 0
#
# define BOOST_PP_SEQ_FOLD_LEFT_257(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_257(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_258(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_258(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_259(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_259(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_260(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_260(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_261(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_261(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_262(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_262(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_263(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_263(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_264(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_264(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_265(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_265(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_266(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_266(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_267(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_267(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_268(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_268(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_269(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_269(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_270(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_270(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_271(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_271(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_272(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_272(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_273(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_273(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_274(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_274(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_275(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_275(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_276(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_276(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_277(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_277(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_278(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_278(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_279(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_279(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_280(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_280(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_281(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_281(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_282(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_282(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_283(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_283(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_284(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_284(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_285(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_285(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_286(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_286(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_287(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_287(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_288(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_288(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_289(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_289(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_290(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_290(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_291(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_291(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_292(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_292(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_293(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_293(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_294(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_294(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_295(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_295(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_296(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_296(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_297(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_297(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_298(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_298(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_299(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_299(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_300(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_300(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_301(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_301(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_302(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_302(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_303(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_303(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_304(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_304(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_305(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_305(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_306(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_306(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_307(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_307(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_308(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_308(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_309(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_309(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_310(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_310(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_311(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_311(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_312(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_312(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_313(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_313(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_314(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_314(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_315(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_315(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_316(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_316(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_317(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_317(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_318(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_318(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_319(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_319(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_320(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_320(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_321(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_321(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_322(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_322(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_323(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_323(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_324(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_324(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_325(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_325(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_326(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_326(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_327(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_327(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_328(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_328(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_329(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_329(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_330(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_330(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_331(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_331(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_332(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_332(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_333(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_333(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_334(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_334(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_335(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_335(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_336(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_336(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_337(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_337(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_338(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_338(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_339(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_339(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_340(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_340(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_341(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_341(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_342(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_342(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_343(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_343(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_344(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_344(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_345(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_345(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_346(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_346(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_347(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_347(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_348(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_348(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_349(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_349(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_350(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_350(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_351(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_351(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_352(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_352(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_353(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_353(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_354(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_354(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_355(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_355(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_356(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_356(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_357(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_357(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_358(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_358(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_359(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_359(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_360(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_360(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_361(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_361(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_362(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_362(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_363(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_363(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_364(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_364(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_365(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_365(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_366(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_366(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_367(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_367(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_368(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_368(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_369(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_369(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_370(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_370(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_371(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_371(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_372(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_372(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_373(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_373(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_374(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_374(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_375(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_375(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_376(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_376(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_377(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_377(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_378(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_378(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_379(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_379(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_380(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_380(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_381(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_381(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_382(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_382(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_383(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_383(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_384(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_384(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_385(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_385(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_386(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_386(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_387(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_387(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_388(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_388(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_389(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_389(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_390(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_390(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_391(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_391(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_392(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_392(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_393(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_393(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_394(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_394(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_395(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_395(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_396(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_396(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_397(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_397(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_398(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_398(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_399(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_399(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_400(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_400(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_401(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_401(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_402(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_402(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_403(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_403(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_404(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_404(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_405(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_405(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_406(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_406(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_407(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_407(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_408(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_408(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_409(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_409(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_410(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_410(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_411(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_411(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_412(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_412(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_413(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_413(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_414(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_414(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_415(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_415(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_416(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_416(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_417(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_417(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_418(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_418(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_419(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_419(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_420(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_420(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_421(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_421(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_422(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_422(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_423(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_423(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_424(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_424(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_425(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_425(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_426(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_426(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_427(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_427(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_428(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_428(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_429(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_429(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_430(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_430(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_431(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_431(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_432(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_432(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_433(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_433(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_434(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_434(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_435(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_435(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_436(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_436(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_437(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_437(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_438(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_438(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_439(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_439(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_440(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_440(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_441(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_441(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_442(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_442(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_443(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_443(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_444(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_444(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_445(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_445(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_446(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_446(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_447(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_447(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_448(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_448(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_449(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_449(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_450(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_450(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_451(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_451(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_452(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_452(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_453(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_453(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_454(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_454(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_455(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_455(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_456(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_456(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_457(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_457(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_458(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_458(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_459(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_459(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_460(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_460(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_461(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_461(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_462(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_462(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_463(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_463(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_464(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_464(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_465(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_465(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_466(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_466(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_467(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_467(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_468(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_468(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_469(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_469(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_470(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_470(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_471(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_471(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_472(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_472(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_473(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_473(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_474(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_474(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_475(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_475(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_476(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_476(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_477(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_477(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_478(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_478(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_479(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_479(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_480(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_480(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_481(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_481(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_482(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_482(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_483(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_483(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_484(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_484(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_485(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_485(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_486(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_486(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_487(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_487(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_488(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_488(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_489(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_489(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_490(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_490(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_491(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_491(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_492(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_492(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_493(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_493(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_494(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_494(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_495(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_495(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_496(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_496(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_497(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_497(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_498(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_498(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_499(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_499(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_500(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_500(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_501(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_501(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_502(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_502(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_503(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_503(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_504(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_504(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_505(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_505(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_506(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_506(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_507(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_507(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_508(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_508(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_509(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_509(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_510(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_510(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_511(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_511(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_512(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_512(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
#
# define BOOST_PP_SEQ_FOLD_LEFT_I_257(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_258, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(258, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_258(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_259, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(259, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_259(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_260, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(260, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_260(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_261, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(261, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_261(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_262, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(262, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_262(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_263, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(263, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_263(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_264, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(264, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_264(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_265, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(265, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_265(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_266, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(266, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_266(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_267, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(267, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_267(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_268, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(268, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_268(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_269, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(269, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_269(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_270, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(270, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_270(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_271, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(271, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_271(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_272, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(272, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_272(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_273, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(273, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_273(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_274, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(274, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_274(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_275, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(275, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_275(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_276, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(276, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_276(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_277, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(277, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_277(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_278, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(278, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_278(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_279, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(279, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_279(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_280, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(280, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_280(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_281, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(281, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_281(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_282, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(282, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_282(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_283, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(283, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_283(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_284, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(284, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_284(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_285, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(285, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_285(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_286, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(286, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_286(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_287, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(287, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_287(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_288, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(288, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_288(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_289, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(289, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_289(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_290, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(290, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_290(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_291, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(291, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_291(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_292, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(292, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_292(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_293, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(293, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_293(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_294, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(294, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_294(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_295, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(295, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_295(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_296, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(296, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_296(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_297, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(297, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_297(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_298, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(298, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_298(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_299, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(299, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_299(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_300, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(300, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_300(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_301, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(301, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_301(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_302, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(302, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_302(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_303, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(303, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_303(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_304, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(304, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_304(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_305, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(305, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_305(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_306, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(306, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_306(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_307, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(307, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_307(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_308, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(308, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_308(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_309, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(309, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_309(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_310, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(310, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_310(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_311, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(311, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_311(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_312, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(312, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_312(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_313, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(313, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_313(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_314, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(314, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_314(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_315, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(315, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_315(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_316, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(316, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_316(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_317, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(317, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_317(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_318, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(318, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_318(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_319, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(319, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_319(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_320, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(320, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_320(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_321, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(321, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_321(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_322, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(322, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_322(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_323, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(323, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_323(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_324, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(324, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_324(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_325, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(325, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_325(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_326, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(326, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_326(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_327, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(327, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_327(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_328, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(328, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_328(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_329, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(329, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_329(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_330, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(330, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_330(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_331, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(331, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_331(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_332, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(332, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_332(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_333, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(333, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_333(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_334, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(334, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_334(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_335, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(335, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_335(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_336, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(336, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_336(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_337, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(337, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_337(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_338, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(338, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_338(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_339, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(339, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_339(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_340, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(340, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_340(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_341, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(341, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_341(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_342, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(342, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_342(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_343, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(343, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_343(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_344, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(344, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_344(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_345, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(345, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_345(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_346, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(346, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_346(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_347, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(347, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_347(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_348, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(348, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_348(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_349, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(349, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_349(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_350, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(350, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_350(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_351, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(351, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_351(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_352, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(352, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_352(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_353, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(353, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_353(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_354, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(354, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_354(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_355, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(355, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_355(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_356, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(356, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_356(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_357, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(357, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_357(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_358, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(358, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_358(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_359, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(359, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_359(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_360, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(360, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_360(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_361, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(361, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_361(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_362, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(362, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_362(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_363, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(363, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_363(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_364, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(364, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_364(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_365, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(365, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_365(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_366, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(366, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_366(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_367, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(367, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_367(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_368, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(368, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_368(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_369, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(369, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_369(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_370, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(370, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_370(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_371, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(371, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_371(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_372, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(372, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_372(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_373, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(373, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_373(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_374, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(374, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_374(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_375, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(375, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_375(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_376, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(376, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_376(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_377, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(377, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_377(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_378, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(378, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_378(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_379, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(379, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_379(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_380, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(380, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_380(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_381, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(381, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_381(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_382, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(382, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_382(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_383, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(383, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_383(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_384, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(384, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_384(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_385, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(385, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_385(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_386, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(386, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_386(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_387, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(387, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_387(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_388, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(388, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_388(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_389, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(389, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_389(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_390, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(390, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_390(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_391, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(391, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_391(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_392, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(392, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_392(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_393, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(393, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_393(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_394, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(394, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_394(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_395, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(395, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_395(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_396, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(396, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_396(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_397, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(397, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_397(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_398, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(398, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_398(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_399, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(399, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_399(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_400, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(400, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_400(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_401, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(401, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_401(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_402, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(402, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_402(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_403, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(403, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_403(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_404, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(404, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_404(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_405, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(405, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_405(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_406, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(406, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_406(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_407, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(407, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_407(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_408, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(408, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_408(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_409, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(409, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_409(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_410, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(410, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_410(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_411, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(411, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_411(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_412, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(412, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_412(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_413, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(413, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_413(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_414, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(414, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_414(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_415, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(415, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_415(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_416, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(416, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_416(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_417, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(417, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_417(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_418, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(418, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_418(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_419, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(419, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_419(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_420, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(420, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_420(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_421, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(421, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_421(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_422, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(422, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_422(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_423, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(423, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_423(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_424, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(424, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_424(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_425, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(425, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_425(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_426, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(426, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_426(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_427, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(427, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_427(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_428, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(428, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_428(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_429, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(429, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_429(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_430, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(430, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_430(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_431, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(431, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_431(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_432, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(432, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_432(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_433, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(433, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_433(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_434, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(434, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_434(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_435, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(435, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_435(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_436, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(436, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_436(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_437, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(437, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_437(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_438, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(438, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_438(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_439, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(439, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_439(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_440, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(440, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_440(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_441, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(441, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_441(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_442, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(442, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_442(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_443, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(443, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_443(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_444, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(444, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_444(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_445, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(445, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_445(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_446, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(446, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_446(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_447, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(447, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_447(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_448, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(448, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_448(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_449, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(449, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_449(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_450, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(450, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_450(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_451, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(451, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_451(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_452, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(452, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_452(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_453, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(453, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_453(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_454, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(454, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_454(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_455, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(455, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_455(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_456, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(456, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_456(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_457, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(457, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_457(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_458, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(458, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_458(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_459, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(459, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_459(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_460, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(460, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_460(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_461, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(461, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_461(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_462, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(462, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_462(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_463, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(463, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_463(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_464, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(464, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_464(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_465, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(465, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_465(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_466, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(466, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_466(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_467, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(467, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_467(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_468, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(468, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_468(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_469, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(469, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_469(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_470, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(470, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_470(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_471, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(471, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_471(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_472, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(472, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_472(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_473, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(473, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_473(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_474, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(474, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_474(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_475, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(475, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_475(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_476, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(476, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_476(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_477, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(477, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_477(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_478, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(478, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_478(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_479, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(479, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_479(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_480, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(480, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_480(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_481, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(481, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_481(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_482, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(482, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_482(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_483, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(483, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_483(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_484, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(484, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_484(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_485, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(485, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_485(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_486, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(486, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_486(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_487, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(487, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_487(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_488, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(488, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_488(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_489, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(489, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_489(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_490, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(490, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_490(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_491, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(491, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_491(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_492, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(492, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_492(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_493, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(493, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_493(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_494, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(494, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_494(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_495, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(495, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_495(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_496, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(496, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_496(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_497, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(497, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_497(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_498, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(498, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_498(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_499, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(499, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_499(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_500, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(500, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_500(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_501, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(501, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_501(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_502, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(502, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_502(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_503, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(503, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_503(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_504, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(504, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_504(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_505, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(505, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_505(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_506, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(506, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_506(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_507, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(507, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_507(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_508, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(508, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_508(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_509, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(509, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_509(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_510, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(510, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_510(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_511, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(511, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_511(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_512, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(512, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
# define BOOST_PP_SEQ_FOLD_LEFT_I_512(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_513, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(513, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz))
#
# endif
| 136.588086
| 220
| 0.817627
|
Harshitha91
|
f6fc3853395e5aa108aa45576e0ce52451724c0a
| 632
|
hpp
|
C++
|
Source/Client/StateManager.hpp
|
ace13/LD35
|
7e48d956feeb9ffd6ebed48a255ee01a6581df2e
|
[
"MIT"
] | null | null | null |
Source/Client/StateManager.hpp
|
ace13/LD35
|
7e48d956feeb9ffd6ebed48a255ee01a6581df2e
|
[
"MIT"
] | null | null | null |
Source/Client/StateManager.hpp
|
ace13/LD35
|
7e48d956feeb9ffd6ebed48a255ee01a6581df2e
|
[
"MIT"
] | null | null | null |
#pragma once
#include "IState.hpp"
#include <list>
class Engine;
class StateManager
{
public:
StateManager();
StateManager(const StateManager&) = delete;
~StateManager();
StateManager& operator=(const StateManager&) = delete;
void pushState(IState* newState, bool removeCur = false);
void popState();
void tick(const Timespan& dt);
void update(const Timespan& dt);
void draw(sf::RenderTarget& rt);
void drawUI(sf::RenderTarget& rt);
Engine& getEngine() { return *mEngine; }
void setEngine(Engine& engine) { mEngine = &engine; }
private:
IState* mCurState;
std::list<IState*> mOldStates;
Engine* mEngine;
};
| 18.057143
| 58
| 0.71519
|
ace13
|
f6fc62774ab1791c7378f783364bfa785b014056
| 1,542
|
cpp
|
C++
|
tests/modules/shape.test.cpp
|
jsk89/projectx
|
1490af758078c61caacc16f3445403df3595b33c
|
[
"MIT"
] | 1
|
2021-08-29T17:12:23.000Z
|
2021-08-29T17:12:23.000Z
|
tests/modules/shape.test.cpp
|
jsk89/projectx
|
1490af758078c61caacc16f3445403df3595b33c
|
[
"MIT"
] | null | null | null |
tests/modules/shape.test.cpp
|
jsk89/projectx
|
1490af758078c61caacc16f3445403df3595b33c
|
[
"MIT"
] | null | null | null |
#include <catch.hpp>
#include <fundamental/macro.h>
#include <fundamental/shape.h>
#include <fundamental/transform/transform_slice.h>
using namespace core;
TEST_CASE("Shape - deduced", "[shape]"){
Shape shape(54, 2, 2, 3);
index_t results[SHAPE_MAX_DIM] = {3, 1, 1, 1};
index_t tesa[SHAPE_MAX_DIM];
shape.deduce_shape(3, 10, tesa); // s = 3, i = 10
SECTION("deduced"){
for (int i = 0; i < shape.dim; ++i)
REQUIRE(tesa[i] == results[i]);
}
SECTION("index"){
index_t s, i;
shape.index(s, i, tesa);
REQUIRE(s == 3);
REQUIRE(i == 10);
}
}
TEST_CASE("Shape - reshaped", "[shape]"){
Shape shape(54, 2, 2, 3);
Shape reshaped = shape.reshape(54, 2, -1);
REQUIRE(reshaped[0] == 54);
REQUIRE(reshaped[1] == 2);
REQUIRE(reshaped[2] == 6);
}
TEST_CASE("Shape - flatten", "[shape]"){
Shape shape(54, 2, 2, 3);
Shape flatten = shape.reshape(54, -1);
REQUIRE(flatten[0] == 54);
REQUIRE(flatten[1] == 12);
}
TEST_CASE("Shape - collapsed", "[shape]"){
Shape shape(54, 2, 2, 3);
Shape collaped = shape.collapse_to_dim(2);
REQUIRE(collaped[0] == 54);
REQUIRE(collaped[1] == 12);
}
TEST_CASE("Shape - sliced", "[shape]"){
Shape shape(54, 20, 10, 300);
SliceTransformer slice(shape, {0, -10,
1, 8,
1, 7,
10, 255} );
REQUIRE(slice.new_shape[0] == 44);
REQUIRE(slice.new_shape[1] == 7);
REQUIRE(slice.new_shape[2] == 6);
REQUIRE(slice.new_shape[3] == 245);
}
| 19.769231
| 51
| 0.565499
|
jsk89
|
f6fc8c0061b010deb37bf74da31bb6c7783b15bc
| 143
|
hpp
|
C++
|
lib/Structs/GamePacket.hpp
|
Alexander9673/c--gtps-wrapper
|
ab366668923eb56a3cde10a3a7ee7f7099b5341c
|
[
"MIT"
] | 2
|
2020-04-26T12:15:30.000Z
|
2020-04-30T08:48:38.000Z
|
lib/Structs/GamePacket.hpp
|
Alexander9673/c--gtps-wrapper
|
ab366668923eb56a3cde10a3a7ee7f7099b5341c
|
[
"MIT"
] | 1
|
2020-04-27T11:56:38.000Z
|
2020-04-27T14:46:49.000Z
|
lib/Structs/GamePacket.hpp
|
Alexander9673/c--gtps-wrapper
|
ab366668923eb56a3cde10a3a7ee7f7099b5341c
|
[
"MIT"
] | null | null | null |
#ifndef GAMEPACKET_HPP
#define GAMEPACKET_HPP
typedef unsigned char BYTE;
struct GamePacket
{
BYTE* data;
int len;
int indexes;
};
#endif
| 11
| 27
| 0.755245
|
Alexander9673
|
f6fdec8f0f70c41874a71a17711bd6cef98a1550
| 7,425
|
hpp
|
C++
|
ur_calibration/include/ur_calibration/calibration.hpp
|
mowito/Universal_Robots_ROS2_Driver
|
a5fbbb2e52b9d1111c46bb172c74f9f0063dabbd
|
[
"BSD-3-Clause"
] | null | null | null |
ur_calibration/include/ur_calibration/calibration.hpp
|
mowito/Universal_Robots_ROS2_Driver
|
a5fbbb2e52b9d1111c46bb172c74f9f0063dabbd
|
[
"BSD-3-Clause"
] | null | null | null |
ur_calibration/include/ur_calibration/calibration.hpp
|
mowito/Universal_Robots_ROS2_Driver
|
a5fbbb2e52b9d1111c46bb172c74f9f0063dabbd
|
[
"BSD-3-Clause"
] | null | null | null |
// -- BEGIN LICENSE BLOCK ----------------------------------------------
// Created on behalf of Universal Robots A/S
// Copyright 2019 FZI Forschungszentrum Informatik
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// * Neither the name of the {copyright_holder} nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
// -- END LICENSE BLOCK ------------------------------------------------
//----------------------------------------------------------------------
/*!\file
*
* \author Felix Exner exner@fzi.de
* \date 2019-01-10
* \author Lovro Ivanov lovro.ivanov@gmail.com
* \date 2021-09-22
*
*/
//----------------------------------------------------------------------
#ifndef UR_CALIBRATION__CALIBRATION_HPP_
#define UR_CALIBRATION__CALIBRATION_HPP_
#include <Eigen/Dense>
#include <fstream>
#include <string>
#include <vector>
#include "rclcpp/rclcpp.hpp"
#include "yaml-cpp/yaml.h"
namespace ur_calibration
{
/*!
* \brief An internal representation of a DH-parametrized link.
*
* Each segment consists of parameters a, d, alpha and theta.
*/
struct DHSegment
{
double d_;
double a_;
double theta_;
double alpha_;
/*!
* \brief Creates an element with defined elements.
*/
DHSegment(const double d, const double a, const double theta, const double alpha)
: d_(d), a_(a), theta_(theta), alpha_(alpha)
{
}
/*!
* \brief Creates a Segment with all elements equal to zero.
*/
DHSegment() : d_(0), a_(0), theta_(0), alpha_(0)
{
}
/*!
* \brief Adds another segment element-wise (a+a, d+d, alpha+alpha, theta+theta)
*
* \param other Other segment to add
*
* \returns Segment consisting of element-wise addition of \p this and \p other
*/
DHSegment operator+(const DHSegment& other)
{
return DHSegment(this->d_ + other.d_, this->a_ + other.a_, this->theta_ + other.theta_,
this->alpha_ + other.alpha_);
}
};
/*!
* \brief Internal representation of a robot based on DH parameters.
*
* Note that this representation doesn't contain a real DH parameter representation, but is used for
* a corrected model of calibrated UR robots. Shoulder and elbow axes are artificially shortened in
* the final representation, requiring a correction parameter in \p theta_2 and \p theta_3.
*/
struct DHRobot
{
std::vector<DHSegment> segments_;
double delta_theta_correction2_;
double delta_theta_correction3_;
/*!
* \brief Create a new robot representation giving a set of \ref DHSegment objects
*/
explicit DHRobot(const std::vector<DHSegment>& segments)
{
delta_theta_correction2_ = 0;
delta_theta_correction3_ = 0;
}
DHRobot() = default;
/*!
* \brief Adds another robot representation, by adding their segments element-wise. See \ref
* DHSegment::operator+ for details.
*/
DHRobot operator+(const DHRobot& other)
{
assert(this->segments_.size() == other.segments_.size());
DHRobot ret;
for (size_t i = 0; i < this->segments_.size(); ++i) {
ret.segments_.push_back(this->segments_[i] + other.segments_[i]);
}
return ret;
}
};
/*!
* \brief Class that handles the calibration correction for Universal Robots
*
* Universal robots provide a factory calibration of their DH parameters to exactly estimate their
* TCP pose using forward kinematics. However, those DH parameters construct a kinematic chain that
* can be very long, as upper arm and lower arm segments can be drawn out of their physical position
* by multiple meters (even above 100m can occur).
*
* This class helps creating a kinematic chain, that is as close as possible to the physical model,
* by dragging the upper and lower arm segments back to their zero position.
*/
class Calibration
{
public:
explicit Calibration(const DHRobot& robot);
virtual ~Calibration();
/*!
* \brief Corrects a UR kinematic chain in such a way that shoulder and elbow offsets are 0.
*/
void correctChain();
/*!
* \brief Get the transformation matrix representation of the chain as constructed by the
* DH parameters.
*
* This will contain twice as many transformation matrices as joints, as for each set of DH
* parameters two matrices are generated. If you'd like to receive one matrix per joint instead,
* use the getSimplified() function instead.
*
* \returns A vector of 4x4 transformation matrices, two for each joint going from the base to the
* tcp.
*/
std::vector<Eigen::Matrix4d> getChain()
{
return chain_;
}
/*!
* \brief Get the transformation matrix representation of the chain, where each joint is
* represented by one matrix.
*
* \returns Vector of 4x4 transformation matrices, one for each joint going from the base to the
* tcp.
*/
std::vector<Eigen::Matrix4d> getSimplified() const;
/*!
* \brief Generates a yaml representation of all transformation matrices as returned by
* getSimplified()
*
* \returns A YAML tree representing all transformation matrices.
*/
YAML::Node toYaml() const;
/*!
* \brief Calculates the forwart kinematics given a joint configuration with respect to the base
* link.
*
* \param joint_values Joint values for which the forward kinematics should be calculated.
* \param link_nr If given, the cartesian position for this joint (starting at 1) is returned. By
* default the 6th joint is used.
*
* \returns Transformation matrix giving the full pose of the requested link in base coordinates.
*/
Eigen::Matrix4d calcForwardKinematics(const Eigen::Matrix<double, 6, 1>& joint_values, const size_t link_nr = 6);
private:
// Corrects a single axis
void correctAxis(const size_t correction_index);
// Builds the chain from robot_parameters_
void buildChain();
DHRobot robot_parameters_;
std::vector<std::string> link_names_ = { "shoulder", "upper_arm", "forearm", "wrist_1", "wrist_2", "wrist_3" };
std::vector<Eigen::Matrix4d> chain_;
};
} // namespace ur_calibration
#endif // UR_CALIBRATION__CALIBRATION_HPP_
| 34.059633
| 115
| 0.693468
|
mowito
|
f6fdfece4c5dcbf43504e78dc985a13f655a342a
| 2,871
|
hpp
|
C++
|
OREData/ored/model/irlgmdata.hpp
|
nvolfango/Engine
|
a5ee0fc09d5a50ab36e50d55893b6e484d6e7004
|
[
"BSD-3-Clause"
] | 1
|
2021-03-30T17:24:17.000Z
|
2021-03-30T17:24:17.000Z
|
OREData/ored/model/irlgmdata.hpp
|
zhangjiayin/Engine
|
a5ee0fc09d5a50ab36e50d55893b6e484d6e7004
|
[
"BSD-3-Clause"
] | null | null | null |
OREData/ored/model/irlgmdata.hpp
|
zhangjiayin/Engine
|
a5ee0fc09d5a50ab36e50d55893b6e484d6e7004
|
[
"BSD-3-Clause"
] | 1
|
2022-02-07T02:04:10.000Z
|
2022-02-07T02:04:10.000Z
|
/*
Copyright (C) 2017 Quaternion Risk Management Ltd
All rights reserved.
This file is part of ORE, a free-software/open-source library
for transparent pricing and risk analysis - http://opensourcerisk.org
ORE is free software: you can redistribute it and/or modify it
under the terms of the Modified BSD License. You should have received a
copy of the license along with this program.
The license is also available online at <http://opensourcerisk.org>
This program is distributed on the basis that it will form a useful
contribution to risk analytics and model standardisation, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the license for more details.
*/
/*! \file model/irlgmdata.hpp
\brief IR component data for the cross asset model
\ingroup models
*/
#pragma once
#include <vector>
#include <ql/time/daycounters/actualactual.hpp>
#include <ql/types.hpp>
#include <qle/models/crossassetmodel.hpp>
#include <ored/configuration/conventions.hpp>
#include <ored/marketdata/market.hpp>
#include <ored/model/lgmdata.hpp>
#include <ored/utilities/xmlutils.hpp>
namespace ore {
namespace data {
using namespace QuantLib;
//! INF Model Parameters
/*!
Specification for a IR model component in the Cross Asset LGM (i.e. lognormal Inflation with
stochastic IR/FX differential).
The specification applies to the volatility component (sigma) of the IR model only.
\ingroup models
*/
class IrLgmData : public LgmData {
public:
//! Default constructor
IrLgmData() {}
//! Detailed constructor
IrLgmData(std::string currency, CalibrationType calibrationType, ReversionType revType, VolatilityType volType,
bool calibrateH, ParamType hType, std::vector<Time> hTimes, std::vector<Real> hValues, bool calibrateA,
ParamType aType, std::vector<Time> aTimes, std::vector<Real> aValues, Real shiftHorizon = 0.0,
Real scaling = 1.0, std::vector<std::string> optionExpiries = std::vector<std::string>(),
std::vector<std::string> optionTerms = std::vector<std::string>(),
std::vector<std::string> optionStrikes = std::vector<std::string>())
: LgmData(currency, calibrationType, revType, volType, calibrateH, hType, hTimes, hValues, calibrateA, aType,
aTimes, aValues, shiftHorizon, scaling, optionExpiries, optionTerms, optionStrikes),
ccy_(currency) {}
//! \name Setters/Getters
//@{
std::string& ccy() { return ccy_; }
//@}
//! \name Serialisation
//@{
void fromXML(XMLNode* node);
XMLNode* toXML(XMLDocument& doc);
//@}
void clear() { LgmData::clear(); }
void reset() {
LgmData::reset();
ccy_ = "";
}
private:
std::string ccy_;
};
} // namespace data
} // namespace ore
| 32.625
| 117
| 0.697666
|
nvolfango
|
f6fef2afd38fd18ef3dcea3fd08dc0d00b0e52d1
| 7,676
|
cpp
|
C++
|
demo/com/ipicture/test_ipicture.cpp
|
fox000002/ulib-win
|
628c4a0b8193d1ad771aa85598776ff42a45f913
|
[
"Apache-2.0"
] | 4
|
2016-09-07T07:02:52.000Z
|
2019-06-22T08:55:53.000Z
|
demo/com/ipicture/test_ipicture.cpp
|
fox000002/ulib-win
|
628c4a0b8193d1ad771aa85598776ff42a45f913
|
[
"Apache-2.0"
] | null | null | null |
demo/com/ipicture/test_ipicture.cpp
|
fox000002/ulib-win
|
628c4a0b8193d1ad771aa85598776ff42a45f913
|
[
"Apache-2.0"
] | 3
|
2019-06-22T16:00:39.000Z
|
2022-03-09T13:46:27.000Z
|
#include "resource.h"
#include <windows.h>
#include <tchar.h>
#include <ocidl.h>
#include <olectl.h>
#include "ubasewindow.h"
#include "uwinapp.h"
#include "ufile.h"
BOOL save2file(LPCSTR szFileName, IPicture *pPic)
{
// Create ILockBytes Buffer
ILockBytes *plkbyt = NULL;
CreateILockBytesOnHGlobal(NULL, TRUE, &plkbyt);
// Create IStorage
IStorage *pStorage = NULL;
HRESULT hr = ::StgCreateDocfileOnILockBytes(plkbyt,
STGM_SHARE_EXCLUSIVE | STGM_CREATE | STGM_READWRITE, 0, &pStorage);
if (FAILED(hr))
{
plkbyt->Release();
plkbyt = NULL;
return FALSE;
}
// Create IStream
IStream *pStream = NULL;
hr = pStorage->CreateStream(L"PICTURE",
STGM_SHARE_EXCLUSIVE | STGM_CREATE | STGM_READWRITE, 0, 0, &pStream);
if (FAILED(hr))
{
pStorage->Release();
pStorage = NULL;
plkbyt->Release();
plkbyt = NULL;
return FALSE;
}
// Copy Data Stream
long lSize;
hr = pPic->SaveAsFile(pStream, TRUE, &lSize);
if (FAILED(hr))
{
pStream->Release();
pStream = NULL;
pStorage->Release();
pStorage = NULL;
plkbyt->Release();
plkbyt = NULL;
return FALSE;
}
// Get Statistics For Final Size Of Byte Array
STATSTG statStg;
hr = plkbyt->Stat(&statStg, STATFLAG_NONAME);
if (FAILED(hr))
{
pStream->Release();
pStream = NULL;
pStorage->Release();
pStorage = NULL;
plkbyt->Release();
plkbyt = NULL;
return FALSE;
}
// calculate "Pure" Picture Data, Must Be In a 512 Blocks...
double dbSkipFloat = (double(lSize) / 512);
DWORD dwPicDataSize = 0;
if(dbSkipFloat > DWORD(dbSkipFloat))
{
dwPicDataSize = (DWORD)dbSkipFloat + 1;
}
else
{
dwPicDataSize = (DWORD)dbSkipFloat;
}
dwPicDataSize = dwPicDataSize * 512;
// Allocate Only The "Pure" Picture Data
BYTE *pPicDataBuffer = (BYTE*)malloc(dwPicDataSize);
if (pPicDataBuffer == NULL)
{
pStream->Release();
pStream = NULL;
plkbyt->Release();
pStorage->Release();
pStorage = NULL;
plkbyt = NULL;
return FALSE;
}
// Read "Pure" Picture Data to Buffer
_ULARGE_INTEGER ulOffset;
ulOffset.LowPart = 0;
ulOffset.HighPart = 0;
ulOffset.QuadPart = (DWORD)(statStg.cbSize.QuadPart - dwPicDataSize);
DWORD dwRealDataSize;
hr = plkbyt->ReadAt(ulOffset, pPicDataBuffer, dwPicDataSize, &dwRealDataSize);
if (FAILED(hr))
{
free(pPicDataBuffer);
pPicDataBuffer = NULL;
pStream->Release();
pStream = NULL;
pStorage->Release();
pStorage = NULL;
plkbyt->Release();
plkbyt = NULL;
return FALSE;
}
// Save "Pure" Picture Data to file
#if 0
CFile fBmp;
CFileException e;
if (!fBmp.Open(szFileName, CFile::typeBinary | CFile::modeCreate | CFile::modeWrite, &e))
{
free(pPicDataBuffer);
pPicDataBuffer = NULL;
pStream->Release();
pStream = NULL;
pStorage->Release();
pStorage = NULL;
plkbyt->Release();
plkbyt = NULL;
return FALSE;
}
fBmp.Write(pPicDataBuffer, dwRealDataSize);
fBmp.Close();
#endif
UFile fBmp;
if (!fBmp.create(szFileName))
{
free(pPicDataBuffer);
pPicDataBuffer = NULL;
pStream->Release();
pStream = NULL;
pStorage->Release();
pStorage = NULL;
plkbyt->Release();
plkbyt = NULL;
return FALSE;
}
fBmp.write(pPicDataBuffer, dwRealDataSize);
fBmp.close();
free(pPicDataBuffer);
pPicDataBuffer = NULL;
pStream->Release();
pStream = NULL;
pStorage->Release();
pStorage = NULL;
plkbyt->Release();
plkbyt = NULL;
return TRUE;
}
class UIPicWindow : public UBaseWindow
{
public:
UIPicWindow()
: UBaseWindow(NULL, ::GetModuleHandle(NULL)),
m_pIPic(0),
m_lWidth(0), m_lHeight(0)
{
this->setTitle(_T("IPicture Test 0.0.1"));
this->setPos(100, 100, 800, 600);
}
~UIPicWindow()
{
if ( m_pIPic )
{
m_pIPic->Release();
m_pIPic = 0;
}
}
BOOL onCreate()
{
this->setIconBig(IDI_APP);
if (!loadFile("back.jpg"))
{
return FALSE;
}
m_pIPic->get_Width(&m_lWidth);
m_pIPic->get_Height(&m_lHeight);
return UBaseWindow::onCreate();
}
//
virtual void onDraw(HDC hdc)
{
RECT rc = {0};
this->getClientRect(&rc);
if (0 != m_pIPic)
{
m_pIPic->Render(hdc, 0, 0, rc.right-rc.left, rc.bottom-rc.top,
0, m_lHeight, m_lWidth, -m_lHeight, NULL);
}
}
BOOL onChar(WPARAM wParam, LPARAM lParam)
{
switch (wParam)
{
case VK_ESCAPE:
return UBaseWindow::onClose();
default:
return UBaseWindow::onChar(wParam, lParam);
}
}
private:
IPicture *m_pIPic;
BOOL loadFile(const char *sFilename)
{
bool bResult = false;
if ( m_pIPic != NULL)
{
m_pIPic->Release();
m_pIPic = NULL;
}
UFile ufile;
if (ufile.open(sFilename))
{
long length = ufile.size();
HGLOBAL hGlobal = GlobalAlloc( GMEM_MOVEABLE, length );
void* p = GlobalLock(hGlobal);
DWORD dwRead;
ufile.read((LPBYTE)p, length, &dwRead);
ufile.close();
GlobalUnlock(hGlobal);
IStream* pStream = NULL;
if ( CreateStreamOnHGlobal(hGlobal, TRUE, &pStream) == S_OK)
{
HRESULT hr = ::OleLoadPicture( pStream,
length,
FALSE,
IID_IPicture,
(LPVOID *) &m_pIPic);
pStream->Release();
return TRUE;
}
}
return FALSE;
}
BOOL loadFileUrl(const char *szFileUrl)
{
OleLoadPicturePath((WCHAR *)szFileUrl,
(LPUNKNOWN)NULL,
0,
0,
IID_IPicture,
(LPVOID*)&m_pIPic);
return TRUE;
}
BOOL saveFile(const char *filename, int nWidth, int nHeight)
{
// create a new IPicture
OLE_HANDLE hPic = NULL;
if (FAILED(m_pIPic->get_Handle(&hPic)))
{
return FALSE;
}
HBITMAP hBmp = (HBITMAP)CopyImage((HANDLE)hPic,
IMAGE_BITMAP,
nWidth,
nWidth,
LR_CREATEDIBSECTION);
if (hBmp == NULL)
{
return FALSE;
}
PICTDESC picDesc;
picDesc.cbSizeofstruct = sizeof(PICTDESC);
picDesc.picType = PICTYPE_BITMAP;
picDesc.bmp.hbitmap = hBmp;
IPicture *pNewPic = NULL;
if (SUCCEEDED(OleCreatePictureIndirect(&picDesc, IID_IPicture, FALSE, (LPVOID *)&pNewPic)))
{
// Save to file
save2file(filename, pNewPic);
pNewPic->Release();
pNewPic = NULL;
DeleteObject(hBmp);
hBmp = NULL;
return TRUE;
}
DeleteObject(hBmp);
hBmp = NULL;
return FALSE;
return TRUE;
}
long m_lWidth;
long m_lHeight;
};
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR lpszCmdLine, int nCmdShow)
{
UWinApp app;
app.setMainWindow(new UIPicWindow);
app.init(hInstance);
return app.run();
}
| 23.120482
| 99
| 0.542861
|
fox000002
|
1000209981813c13d13ada79ec1e9ecb7f3dff6d
| 960
|
hpp
|
C++
|
test_apps/STM32Cube_FW_F4_V1.24.0/Projects/STM32469I_EVAL/Demonstrations/TouchGFX/Gui/gui/include/gui/common/ButtonWithMargin.hpp
|
hwiwonl/ACES
|
9b9a6766a177c531384b863854459a7e016dbdcc
|
[
"NCSA"
] | null | null | null |
test_apps/STM32Cube_FW_F4_V1.24.0/Projects/STM32469I_EVAL/Demonstrations/TouchGFX/Gui/gui/include/gui/common/ButtonWithMargin.hpp
|
hwiwonl/ACES
|
9b9a6766a177c531384b863854459a7e016dbdcc
|
[
"NCSA"
] | null | null | null |
test_apps/STM32Cube_FW_F4_V1.24.0/Projects/STM32469I_EVAL/Demonstrations/TouchGFX/Gui/gui/include/gui/common/ButtonWithMargin.hpp
|
hwiwonl/ACES
|
9b9a6766a177c531384b863854459a7e016dbdcc
|
[
"NCSA"
] | null | null | null |
/**
******************************************************************************
* This file is part of the TouchGFX 4.10.0 distribution.
*
* <h2><center>© Copyright (c) 2018 STMicroelectronics.
* All rights reserved.</center></h2>
*
* This software component is licensed by ST under Ultimate Liberty license
* SLA0044, the "License"; You may not use this file except in compliance with
* the License. You may obtain a copy of the License at:
* www.st.com/SLA0044
*
******************************************************************************
*/
#ifndef BUTTON_WITH_MARGIN_HPP
#define BUTTON_WITH_MARGIN_HPP
#include <touchgfx/widgets/Button.hpp>
class Button : public touchgfx::Button
{
public:
virtual void draw(const touchgfx::Rect& invalidatedArea) const;
virtual touchgfx::Rect getSolidRect() const;
private:
int16_t buttonX() const;
int16_t buttonY() const;
};
#endif
| 29.090909
| 80
| 0.573958
|
hwiwonl
|
100120e91480c96087db3a551129e9dcc6e97383
| 167
|
hpp
|
C++
|
include/Enumerators/EPlayerRole.hpp
|
BigETI/WhackAStoodentServer
|
05c670a9b745262ae926aebcb1fce0f1ecc5f4d2
|
[
"MIT"
] | 1
|
2021-04-28T20:32:57.000Z
|
2021-04-28T20:32:57.000Z
|
include/Enumerators/EPlayerRole.hpp
|
BigETI/WhackAStoodentServer
|
05c670a9b745262ae926aebcb1fce0f1ecc5f4d2
|
[
"MIT"
] | 7
|
2021-08-24T14:09:33.000Z
|
2021-08-30T12:47:40.000Z
|
include/Enumerators/EPlayerRole.hpp
|
BigETI/WhackAStoodentServer
|
05c670a9b745262ae926aebcb1fce0f1ecc5f4d2
|
[
"MIT"
] | null | null | null |
#pragma once
/// <summary>
/// Whack-A-Stoodent server namespace
/// </summary>
namespace WhackAStoodentServer
{
enum class EPlayerRole
{
Hitter,
Mole
};
}
| 11.133333
| 37
| 0.670659
|
BigETI
|
10083f7d7b772a26dc028f2876b985b7679fcde6
| 5,456
|
cpp
|
C++
|
IfcPlusPlus/src/ifcpp/IFC4/IfcFixedReferenceSweptAreaSolid.cpp
|
linsipese/ifcppstudy
|
e09f05d276b5e129fcb6be65800472979cd4c800
|
[
"MIT"
] | 1
|
2018-10-23T09:43:07.000Z
|
2018-10-23T09:43:07.000Z
|
IfcPlusPlus/src/ifcpp/IFC4/IfcFixedReferenceSweptAreaSolid.cpp
|
linsipese/ifcppstudy
|
e09f05d276b5e129fcb6be65800472979cd4c800
|
[
"MIT"
] | null | null | null |
IfcPlusPlus/src/ifcpp/IFC4/IfcFixedReferenceSweptAreaSolid.cpp
|
linsipese/ifcppstudy
|
e09f05d276b5e129fcb6be65800472979cd4c800
|
[
"MIT"
] | null | null | null |
/* -*-c++-*- IfcPlusPlus - www.ifcplusplus.com - Copyright (C) 2011 Fabian Gerold
*
* This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
* (at your option) any later version. The full license is in LICENSE file
* included with this distribution, and on the openscenegraph.org website.
*
* 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
* OpenSceneGraph Public License for more details.
*/
#include <sstream>
#include <limits>
#include "ifcpp/model/IfcPPException.h"
#include "ifcpp/model/IfcPPAttributeObject.h"
#include "ifcpp/model/IfcPPGuid.h"
#include "ifcpp/reader/ReaderUtil.h"
#include "ifcpp/writer/WriterUtil.h"
#include "ifcpp/IfcPPEntityEnums.h"
#include "include/IfcAxis2Placement3D.h"
#include "include/IfcCurve.h"
#include "include/IfcDirection.h"
#include "include/IfcFixedReferenceSweptAreaSolid.h"
#include "include/IfcParameterValue.h"
#include "include/IfcPresentationLayerAssignment.h"
#include "include/IfcProfileDef.h"
#include "include/IfcStyledItem.h"
// ENTITY IfcFixedReferenceSweptAreaSolid
IfcFixedReferenceSweptAreaSolid::IfcFixedReferenceSweptAreaSolid() { m_entity_enum = IFCFIXEDREFERENCESWEPTAREASOLID; }
IfcFixedReferenceSweptAreaSolid::IfcFixedReferenceSweptAreaSolid( int id ) { m_id = id; m_entity_enum = IFCFIXEDREFERENCESWEPTAREASOLID; }
IfcFixedReferenceSweptAreaSolid::~IfcFixedReferenceSweptAreaSolid() {}
shared_ptr<IfcPPObject> IfcFixedReferenceSweptAreaSolid::getDeepCopy( IfcPPCopyOptions& options )
{
shared_ptr<IfcFixedReferenceSweptAreaSolid> copy_self( new IfcFixedReferenceSweptAreaSolid() );
if( m_SweptArea )
{
if( options.shallow_copy_IfcProfileDef ) { copy_self->m_SweptArea = m_SweptArea; }
else { copy_self->m_SweptArea = dynamic_pointer_cast<IfcProfileDef>( m_SweptArea->getDeepCopy(options) ); }
}
if( m_Position ) { copy_self->m_Position = dynamic_pointer_cast<IfcAxis2Placement3D>( m_Position->getDeepCopy(options) ); }
if( m_Directrix ) { copy_self->m_Directrix = dynamic_pointer_cast<IfcCurve>( m_Directrix->getDeepCopy(options) ); }
if( m_StartParam ) { copy_self->m_StartParam = dynamic_pointer_cast<IfcParameterValue>( m_StartParam->getDeepCopy(options) ); }
if( m_EndParam ) { copy_self->m_EndParam = dynamic_pointer_cast<IfcParameterValue>( m_EndParam->getDeepCopy(options) ); }
if( m_FixedReference ) { copy_self->m_FixedReference = dynamic_pointer_cast<IfcDirection>( m_FixedReference->getDeepCopy(options) ); }
return copy_self;
}
void IfcFixedReferenceSweptAreaSolid::getStepLine( std::stringstream& stream ) const
{
stream << "#" << m_id << "= IFCFIXEDREFERENCESWEPTAREASOLID" << "(";
if( m_SweptArea ) { stream << "#" << m_SweptArea->m_id; } else { stream << "*"; }
stream << ",";
if( m_Position ) { stream << "#" << m_Position->m_id; } else { stream << "*"; }
stream << ",";
if( m_Directrix ) { stream << "#" << m_Directrix->m_id; } else { stream << "$"; }
stream << ",";
if( m_StartParam ) { m_StartParam->getStepParameter( stream ); } else { stream << "$"; }
stream << ",";
if( m_EndParam ) { m_EndParam->getStepParameter( stream ); } else { stream << "$"; }
stream << ",";
if( m_FixedReference ) { stream << "#" << m_FixedReference->m_id; } else { stream << "$"; }
stream << ");";
}
void IfcFixedReferenceSweptAreaSolid::getStepParameter( std::stringstream& stream, bool ) const { stream << "#" << m_id; }
void IfcFixedReferenceSweptAreaSolid::readStepArguments( const std::vector<std::wstring>& args, const boost::unordered_map<int,shared_ptr<IfcPPEntity> >& map )
{
const int num_args = (int)args.size();
if( num_args != 6 ){ std::stringstream err; err << "Wrong parameter count for entity IfcFixedReferenceSweptAreaSolid, expecting 6, having " << num_args << ". Entity ID: " << m_id << std::endl; throw IfcPPException( err.str().c_str() ); }
readEntityReference( args[0], m_SweptArea, map );
readEntityReference( args[1], m_Position, map );
readEntityReference( args[2], m_Directrix, map );
m_StartParam = IfcParameterValue::createObjectFromSTEP( args[3] );
m_EndParam = IfcParameterValue::createObjectFromSTEP( args[4] );
readEntityReference( args[5], m_FixedReference, map );
}
void IfcFixedReferenceSweptAreaSolid::getAttributes( std::vector<std::pair<std::string, shared_ptr<IfcPPObject> > >& vec_attributes )
{
IfcSweptAreaSolid::getAttributes( vec_attributes );
vec_attributes.push_back( std::make_pair( "Directrix", m_Directrix ) );
vec_attributes.push_back( std::make_pair( "StartParam", m_StartParam ) );
vec_attributes.push_back( std::make_pair( "EndParam", m_EndParam ) );
vec_attributes.push_back( std::make_pair( "FixedReference", m_FixedReference ) );
}
void IfcFixedReferenceSweptAreaSolid::getAttributesInverse( std::vector<std::pair<std::string, shared_ptr<IfcPPObject> > >& vec_attributes_inverse )
{
IfcSweptAreaSolid::getAttributesInverse( vec_attributes_inverse );
}
void IfcFixedReferenceSweptAreaSolid::setInverseCounterparts( shared_ptr<IfcPPEntity> ptr_self_entity )
{
IfcSweptAreaSolid::setInverseCounterparts( ptr_self_entity );
}
void IfcFixedReferenceSweptAreaSolid::unlinkFromInverseCounterparts()
{
IfcSweptAreaSolid::unlinkFromInverseCounterparts();
}
| 55.673469
| 239
| 0.745051
|
linsipese
|
100a58a26e3bf1f3847b1b4607135cee0b813062
| 351
|
cc
|
C++
|
src/flyweight.cc
|
alibenD/design_pattern_example_code
|
f78b2c2ac2ff3ce73cd404ea0e16d345d17b217f
|
[
"MIT"
] | null | null | null |
src/flyweight.cc
|
alibenD/design_pattern_example_code
|
f78b2c2ac2ff3ce73cd404ea0e16d345d17b217f
|
[
"MIT"
] | null | null | null |
src/flyweight.cc
|
alibenD/design_pattern_example_code
|
f78b2c2ac2ff3ce73cd404ea0e16d345d17b217f
|
[
"MIT"
] | null | null | null |
/**
* @Copyright (C) 2019 All rights reserved.
* @date: 2019
* @file: flyweight.cc
* @version: v0.0.1
* @author: aliben.develop@gmail.com
* @create_date: 2019-08-06 17:03:34
* @last_modified_date: 2019-08-06 17:05:19
* @brief: TODO
* @details: TODO
*/
//INCLUDE
#include <design_pattern/flyweight.hh>
#include <iostream>
//CODE
| 18.473684
| 44
| 0.646724
|
alibenD
|
100b399c1918ac3bb37815e8ba5d9e750679af2b
| 8,906
|
cpp
|
C++
|
src/autowiring/test/ScopeTest.cpp
|
CaseyCarter/autowiring
|
48e95a71308318c8ffb7ed1348e034fd9110f70c
|
[
"Apache-2.0"
] | 87
|
2015-01-18T00:43:06.000Z
|
2022-02-11T17:40:50.000Z
|
src/autowiring/test/ScopeTest.cpp
|
CaseyCarter/autowiring
|
48e95a71308318c8ffb7ed1348e034fd9110f70c
|
[
"Apache-2.0"
] | 274
|
2015-01-03T04:50:49.000Z
|
2021-03-08T09:01:09.000Z
|
src/autowiring/test/ScopeTest.cpp
|
CaseyCarter/autowiring
|
48e95a71308318c8ffb7ed1348e034fd9110f70c
|
[
"Apache-2.0"
] | 15
|
2015-09-30T20:58:43.000Z
|
2020-12-19T21:24:56.000Z
|
// Copyright (C) 2012-2018 Leap Motion, Inc. All rights reserved.
#include "stdafx.h"
#include "TestFixtures/SimpleObject.hpp"
#include <autowiring/autowiring.h>
#include <autowiring/GlobalCoreContext.h>
class ScopeTest:
public testing::Test
{};
TEST_F(ScopeTest, VerifyGlobalExists) {
// Verify that we at least get a global scope
AutoGlobalContext global;
ASSERT_TRUE(nullptr != global.get()) << "Failed to autowire the global context";
}
class A : public ContextMember {};
class B : public ContextMember {};
class C : public ContextMember {};
class D : public ContextMember {};
TEST_F(ScopeTest, VerifyInherit) {
AutoCurrentContext ctxt;
// Add a member to the current context
ctxt->Inject<A>();
// Create and switch to a sub-context
AutoCreateContext pContext(ctxt);
{
CurrentContextPusher pusher(pContext);
ASSERT_NE(ctxt.get(), pContext.get()) << "Failed to create a sub-context";
//try and autowire a member from the parent context
Autowired<A> autoA;
ASSERT_TRUE(autoA) << "Autowired member not wired from parent context";
//add a member in the subcontext
pContext->Inject<B>();
}
Autowired<B> autoB;
ASSERT_FALSE(autoB.get()) << "Autowired member wired from sub-context";
}
struct NoSimpleConstructor:
public ContextMember
{
NoSimpleConstructor(int val):
value(val)
{}
const int value;
};
TEST_F(ScopeTest, AddWithArguments){
//Add context member with non-simple constructor
AutoCurrentContext ctxt;
ctxt->Inject<NoSimpleConstructor>(10);
Autowired<NoSimpleConstructor> wired;
ASSERT_TRUE(wired.IsAutowired());
ASSERT_EQ(10, wired->value);
}
TEST_F(ScopeTest, StaticInject){
Autowired<A> preA;
Autowired<B> preB;
ASSERT_FALSE(preA.IsAutowired());
ASSERT_FALSE(preB.IsAutowired());
CoreContext::InjectCurrent<A>();
CoreContext::InjectCurrent<B>();
Autowired<A> a;
Autowired<B> b;
ASSERT_TRUE(a.IsAutowired());
ASSERT_TRUE(b.IsAutowired());
}
TEST_F(ScopeTest, VerifyAutowireSpecifiedContext){
AutoCurrentContext ctxt;
AutoCreateContext subCtxt;
subCtxt->Inject<A>();
Autowired<A> aWired(subCtxt);
ASSERT_TRUE(aWired) << "Autowired member not wired from the passed context";
}
TEST_F(ScopeTest, VerifyAutoRequireSpecifiedContext){
AutoCreateContext subCtxt;
AutoRequired<SimpleObject> aReq(subCtxt);
Autowired<SimpleObject> aWired(subCtxt);
Autowired<SimpleObject> aFail;
ASSERT_TRUE(aWired) << "Autorequired member not added to the passed context";
ASSERT_FALSE(aFail) << "Autorequired member added to the wrong context";
}
//This mangles the heap! why?? Using SimpleObject instead of A works fine!
//This beahvior was NOT introduced by the new context argument.
TEST_F(ScopeTest, AutowiringHeapMangle){
AutoRequired<A> creator;
Autowired<A> reference;
}
TEST_F(ScopeTest, AutowiringOrdering) {
AutoCurrentContext ctxt;
AutoCreateContext outer;
CurrentContextPusher outerPshr(outer);
AutoCreateContext inner1;
AutoCreateContext inner2;
AutoCreateContext inner3;
AutoCreateContext inner4;
// Autowire in outer context, AutoRequire in inner
Autowired<A> a;
{
CurrentContextPusher pshr(inner1);
AutoRequired<A> a2;
ASSERT_FALSE(a.IsAutowired());
}
// AutoRequire in outer context, Autowire in inner
AutoRequired<B> b;
{
CurrentContextPusher pshr(inner2);
Autowired<B> b2;
ASSERT_TRUE(b.IsAutowired());
ASSERT_EQ(b->GetContext(), outer);
}
// AutoRequire in outer context, AutoRequire in inner
AutoRequired<C> c;
{
CurrentContextPusher pshr(inner3);
AutoRequired<C> c2;
ASSERT_TRUE(c2.IsAutowired());
ASSERT_NE(c->GetContext(), c2->GetContext());
}
// Autowire in outer context, Autowire in inner
Autowired<D> d;
{
CurrentContextPusher pshr(inner4);
Autowired<D> d2;
// Verify preconditions and postconditions on autowiring:
ASSERT_FALSE(d.IsAutowired());
ASSERT_FALSE(d2.IsAutowired());
AutoRequired<D> derp(ctxt);
ASSERT_TRUE(d.IsAutowired()) << "Outer scope autowired field failed to be instantiated on an element created in an interior scope";
ASSERT_TRUE(d2.IsAutowired()) << "Interior scope field failed to be satisfied by a field initiated at an outer context";
ASSERT_EQ(d->GetContext(), d2->GetContext());
ASSERT_EQ(derp->GetContext(), d2->GetContext());
}
}
class InnerContext {};
class MiddleContext {};
TEST_F(ScopeTest, RequireVsWire) {
AutoCurrentContext ctxt_outer;
auto ctxt_middle = ctxt_outer->Create<MiddleContext>();
auto ctxt_inner = ctxt_middle->Create<InnerContext>();
CurrentContextPusher pshr(ctxt_inner);
Autowired<A> a_wired_inner;
ASSERT_FALSE(a_wired_inner.IsAutowired()) << "Autowired member became autowired too quickly";
AutoRequired<A> a_required_outer(ctxt_outer);
ASSERT_TRUE(a_required_outer.IsAutowired()) << "AutoRequired member unsatisfied after construction";
ASSERT_EQ(a_required_outer->GetContext(), ctxt_outer) << "AutoRequired member satisfied in the wrong context";
ASSERT_TRUE(a_wired_inner.IsAutowired()) << "AutoRequired member in parent did not satisfy Autowired member in child";
ASSERT_EQ(a_wired_inner.get(), a_required_outer.get()) << "Mismatch between Autowired and Autorequired members";
//this overrides the slot in the middle context;
AutoRequired<A> a_required_middle(ctxt_middle);
ASSERT_TRUE(a_required_middle) << "AutoRequired member not satisfied!";
ASSERT_EQ(ctxt_middle, a_required_middle->GetContext()) << "AutoRequired member not created in child context";
ASSERT_NE(a_required_middle, a_required_outer) << "AutoRequired member not constructed in child context";
Autowired<A> a_wired_inner2(ctxt_inner);
ASSERT_TRUE(a_wired_inner2.IsAutowired());
ASSERT_EQ(a_wired_inner2.get(), a_required_middle.get()) << "Autowired member did not redirect to the closest context";
ASSERT_EQ(a_wired_inner.get(), a_required_outer.get()) << "Autowired object changed after satisfaction!";
AutoRequired<B> b_required_middle(ctxt_middle);
AutoRequired<B> b_required_outer(ctxt_outer);
Autowired<B> b_wired_inner;
ASSERT_TRUE(b_wired_inner.IsAutowired()) << "Autowired failed to find member";
ASSERT_EQ(b_wired_inner.get(), b_required_middle.get()) << "Autorequiring overwrote a slot it shouldn't have!";
}
TEST_F(ScopeTest, RequireVsWireFast) {
AutoCurrentContext ctxt_outer;
auto ctxt_middle = ctxt_outer->Create<MiddleContext>();
auto ctxt_inner = ctxt_middle->Create<InnerContext>();
CurrentContextPusher pshr(ctxt_inner);
//This adds a memo for this type to the inner context
AutowiredFast<A> a_wired(ctxt_inner);
ASSERT_FALSE(a_wired.IsAutowired()) << "Autowired member became autowired too quickly";
//This satisfies the memo in the inner context
AutoRequired<A> a_required_outer(ctxt_outer);
ASSERT_TRUE(a_required_outer.IsAutowired()) << "AutoRequired member unsatisfied after construction";
ASSERT_EQ(a_required_outer->GetContext(), ctxt_outer) << "AutoRequired member satisfied in the wrong context";
ASSERT_FALSE(a_wired.IsAutowired()) << "AutowiredFast was satisfied after construction!";
//This overrides the memo in the middle context.
AutoRequired<A> a_required_middle(ctxt_middle);
ASSERT_TRUE(a_required_middle.IsAutowired()) << "AutoRequired member not satisfied!";
ASSERT_EQ(a_required_middle->GetContext(), ctxt_middle) << "AutoRequired member not created in child context";
ASSERT_NE(a_required_middle.get(), a_required_outer.get()) << "AutoRequired member not constructed in child context";
//This should direct to the middle context
AutowiredFast<A> a_wired2(ctxt_inner);
ASSERT_TRUE(a_wired2.IsAutowired());
ASSERT_EQ(a_wired2, a_required_middle) << "Autowired member did not grab the most derived object";
}
class ParentInjector : public ContextMember {
public:
ParentInjector(int v, bool inject = false) : ContextMember("Parent Injector"), value(v) {
if (!inject) {
return;
}
const auto ctxt = m_context.lock();
if (!ctxt) {
return;
}
auto parent = ctxt->GetParentContext();
if (!parent) {
return;
}
parent->Inject<ParentInjector>(9000, false);
}
int value;
};
TEST_F(ScopeTest, RecursiveInject) {
AutoCurrentContext ctxt_outer;
auto ctxt_inner = ctxt_outer->Create<InnerContext>();
CurrentContextPusher pshr(ctxt_inner);
AutoRequired<ParentInjector> a_inner(ctxt_inner, 1, true);
ASSERT_EQ(a_inner->GetContext(), ctxt_inner);
ASSERT_EQ(a_inner->value, 1);
AutoRequired<ParentInjector> a_inner_2(ctxt_inner, 2);
ASSERT_EQ(a_inner, a_inner_2);
ASSERT_EQ(a_inner->GetContext(), a_inner_2->GetContext());
}
TEST_F(ScopeTest, NoPostHocAfterReset) {
Autowired<SimpleObject> sobj;
sobj.reset();
AutoRequired<SimpleObject>();
ASSERT_FALSE(sobj.IsAutowired()) << "An autowired slot was incorrectly satisfied after having been reset";
}
| 31.469965
| 135
| 0.743431
|
CaseyCarter
|
10108bc1a086f9832b1599440d384818b8d99c0b
| 3,490
|
cpp
|
C++
|
gstd/src/io_Printer.cpp
|
georgephilipp/cppgstd_legacy
|
e130860da7700aae42b915bc36a7efa4cae06d56
|
[
"MIT"
] | null | null | null |
gstd/src/io_Printer.cpp
|
georgephilipp/cppgstd_legacy
|
e130860da7700aae42b915bc36a7efa4cae06d56
|
[
"MIT"
] | null | null | null |
gstd/src/io_Printer.cpp
|
georgephilipp/cppgstd_legacy
|
e130860da7700aae42b915bc36a7efa4cae06d56
|
[
"MIT"
] | null | null | null |
/*
* File: Printer.cpp
* Author: gschoenh
*
* Created on November 14, 2013, 6:21 PM
*/
#include "stdafx.h"
#include "Printer.h"
namespace msii810161816
{
namespace gstd
{
Printer::Printer()
{
lineend = true;
}
Printer::~Printer() {}
std::map<std::string, bool> initMute()
{
std::map<std::string, bool> res;
res["gstd::Timer::global"] = false;
return res;
}
std::map<std::string, bool> Printer::mute = initMute();
void Printer::newline()
{
content << std::endl;
lineend = true;
}
std::string Printer::get()
{
return content.str();
}
//Base Package
TypeName Printer::getTypeName()
{
return gstd::TypeNameGetter<Printer>::get();
}
void Printer::setInputs() {}
bool Printer::test()
{
//add,line,newline,append,get
{
Printer r;
r.add(1.3);
r.line("bling");
r.newline();
r.append(1, ':');
r.append(1, ':');
std::string res = r.get();
if(res != "1.3bling\n\n1:1")
{
r.reportFailure("Failed test is the first test");
return false;
}
}
//p
{
double input = 1.234;
std::string res = p(input);
if(res != "1.234")
{
gstd::Printer::c("Failed on static function p");
return false;
}
}
//vector / vp
{
std::vector<int> input = {1,2,3,4};
std::string res = vp(input,',');
if(res != "1,2,3,4")
{
gstd::Printer::c("Failed on static function vp");
return false;
}
}
//matrix / mp
{
std::vector<double> input = {1.1,1.2,2.1,2.2,3.1,3.2,4.1,4.2};
std::string res = mp(4,2,input,',');
if(res != "1.1,1.2\n2.1,2.2\n3.1,3.2\n4.1,4.2")
{
gstd::Printer::c("Failed on static function mp");
return false;
}
}
//map / mapp
{
std::map<int, double> input;
input[1] = 1.1;
input[2] = 2.2;
input[3] = 3.3;
std::string res = mapp(input,','," : ");
if(res != "1 : 1.1,2 : 2.2,3 : 3.3")
{
gstd::Printer::c("Failed on static function mapp");
return false;
}
}
return true;
}
std::string Printer::toString()
{
std::stringstream res;
res << "This is a gstd::Printer" << std::endl;
res << "mute is: " << mapp(mute) << std::endl;
res << "lineend is: " << lineend << std::endl;
res << "content is: " << content.str() << std::endl;
return res.str();
}
}
}
| 27.265625
| 78
| 0.35788
|
georgephilipp
|
1014cfd946000b7ba44e4e6bef8cd01c1b741731
| 1,548
|
hpp
|
C++
|
src/StreamUtils/Streams/MemoryStream.hpp
|
bblanchon/StreamUtils
|
dcbf6df80064b8ed73fab274963f8a054f97d55f
|
[
"MIT"
] | null | null | null |
src/StreamUtils/Streams/MemoryStream.hpp
|
bblanchon/StreamUtils
|
dcbf6df80064b8ed73fab274963f8a054f97d55f
|
[
"MIT"
] | null | null | null |
src/StreamUtils/Streams/MemoryStream.hpp
|
bblanchon/StreamUtils
|
dcbf6df80064b8ed73fab274963f8a054f97d55f
|
[
"MIT"
] | null | null | null |
// StreamUtils - github.com/bblanchon/ArduinoStreamUtils
// Copyright Benoit Blanchon 2019-2022
// MIT License
#pragma once
#include <Stream.h>
#include "../Buffers/CircularBuffer.hpp"
#include "../Configuration.hpp"
#include "../Ports/DefaultAllocator.hpp"
namespace StreamUtils {
template <typename TAllocator>
class BasicMemoryStream : public Stream {
public:
BasicMemoryStream(size_t capacity, TAllocator allocator = TAllocator())
: _buffer(capacity, allocator) {}
BasicMemoryStream(const BasicMemoryStream &src) : _buffer(src._buffer) {}
int available() override {
return static_cast<int>(_buffer.available());
}
int peek() override {
return _buffer.isEmpty() ? -1 : _buffer.peek();
}
int read() override {
return _buffer.isEmpty() ? -1 : _buffer.read();
}
#if STREAMUTILS_STREAM_READBYTES_IS_VIRTUAL
size_t readBytes(char *data, size_t size) override {
return _buffer.readBytes(data, size);
}
#endif
size_t write(uint8_t data) override {
return _buffer.isFull() ? 0 : _buffer.write(data);
}
#if STREAMUTILS_PRINT_WRITE_VOID_UINT32
size_t write(const void *p, uint32 size) override {
const uint8_t *data = reinterpret_cast<const uint8_t *>(p);
#else
size_t write(const uint8_t *data, size_t size) override {
#endif
return _buffer.write(data, size);
}
using Stream::write;
void flush() override {
_buffer.clear();
}
private:
CircularBuffer<TAllocator> _buffer;
};
using MemoryStream = BasicMemoryStream<DefaultAllocator>;
} // namespace StreamUtils
| 23.454545
| 75
| 0.718992
|
bblanchon
|
1016e4607e41555c926ea185ed951b29d536e8e5
| 36,226
|
cpp
|
C++
|
framework/opengl/gluShaderUtil.cpp
|
tarceri/VK-GL-CTS
|
22389a0e44f458492f594ca0553a5a67cf6c7ada
|
[
"Apache-2.0"
] | 1
|
2021-06-29T04:55:52.000Z
|
2021-06-29T04:55:52.000Z
|
framework/opengl/gluShaderUtil.cpp
|
tarceri/VK-GL-CTS
|
22389a0e44f458492f594ca0553a5a67cf6c7ada
|
[
"Apache-2.0"
] | null | null | null |
framework/opengl/gluShaderUtil.cpp
|
tarceri/VK-GL-CTS
|
22389a0e44f458492f594ca0553a5a67cf6c7ada
|
[
"Apache-2.0"
] | null | null | null |
/*-------------------------------------------------------------------------
* drawElements Quality Program OpenGL ES Utilities
* ------------------------------------------------
*
* Copyright 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*//*!
* \file
* \brief Shader utilities.
*//*--------------------------------------------------------------------*/
#include "gluShaderUtil.hpp"
#include "glwEnums.hpp"
#include "deArrayUtil.hpp"
namespace glu
{
// ShadingLanguageVersion
const char* getGLSLVersionName (GLSLVersion version)
{
static const char* s_names[] =
{
"GLSL ES 1.0",
"GLSL ES 3.0",
"GLSL ES 3.1",
"GLSL ES 3.2",
"GLSL 1.3",
"GLSL 1.4",
"GLSL 1.5",
"GLSL 3.3",
"GLSL 4.0",
"GLSL 4.1",
"GLSL 4.2",
"GLSL 4.3",
"GLSL 4.4",
"GLSL 4.5",
"GLSL 4.6",
};
return de::getSizedArrayElement<GLSL_VERSION_LAST>(s_names, version);
}
const char* getGLSLVersionDeclaration (GLSLVersion version)
{
static const char* s_decl[] =
{
"#version 100",
"#version 300 es",
"#version 310 es",
"#version 320 es",
"#version 130",
"#version 140",
"#version 150",
"#version 330",
"#version 400",
"#version 410",
"#version 420",
"#version 430",
"#version 440",
"#version 450",
"#version 460",
};
return de::getSizedArrayElement<GLSL_VERSION_LAST>(s_decl, version);
}
bool glslVersionUsesInOutQualifiers (GLSLVersion version)
{
return de::inRange<int>(version, GLSL_VERSION_300_ES, GLSL_VERSION_320_ES) || de::inRange<int>(version, GLSL_VERSION_330, GLSL_VERSION_460);
}
bool glslVersionIsES (GLSLVersion version)
{
DE_STATIC_ASSERT(GLSL_VERSION_LAST == 15);
DE_ASSERT(version != GLSL_VERSION_LAST);
if (version == GLSL_VERSION_100_ES ||
version == GLSL_VERSION_300_ES ||
version == GLSL_VERSION_310_ES ||
version == GLSL_VERSION_320_ES)
return true;
else
return false;
}
// \todo [2014-10-06 pyry] Export this.
static ApiType getMinAPIForGLSLVersion (GLSLVersion version)
{
static const ApiType s_minApi[] =
{
ApiType::es(2,0),
ApiType::es(3,0),
ApiType::es(3,1),
ApiType::es(3,2),
ApiType::core(3,0),
ApiType::core(3,1),
ApiType::core(3,2),
ApiType::core(3,3),
ApiType::core(4,0),
ApiType::core(4,1),
ApiType::core(4,2),
ApiType::core(4,3),
ApiType::core(4,4),
ApiType::core(4,5),
ApiType::core(4,6),
};
return de::getSizedArrayElement<GLSL_VERSION_LAST>(s_minApi, version);
}
bool isGLSLVersionSupported (ContextType type, GLSLVersion version)
{
return contextSupports(type, getMinAPIForGLSLVersion(version));
}
GLSLVersion getContextTypeGLSLVersion (ContextType type)
{
// \note From newer to older
for (int version = GLSL_VERSION_LAST-1; version >= 0; version--)
{
if (isGLSLVersionSupported(type, GLSLVersion(version)))
return GLSLVersion(version);
}
DE_ASSERT(false);
return GLSL_VERSION_LAST;
}
// ShaderType
const char* getShaderTypeName (ShaderType shaderType)
{
static const char* s_names[] =
{
"vertex",
"fragment",
"geometry",
"tess_control",
"tess_eval",
"compute",
"ray_gen",
"any_hit",
"closest_hit",
"miss",
"intersection",
"callable",
};
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == SHADERTYPE_LAST);
DE_ASSERT(deInBounds32((int)shaderType, 0, SHADERTYPE_LAST));
return s_names[(int)shaderType];
}
std::string getShaderTypePostfix (ShaderType shaderType)
{
return "_" + std::string(getShaderTypeName(shaderType));
}
// Precision
const char* getPrecisionName (Precision precision)
{
static const char* s_names[] =
{
"lowp",
"mediump",
"highp"
};
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == PRECISION_LAST);
DE_ASSERT(deInBounds32((int)precision, 0, PRECISION_LAST));
return s_names[(int)precision];
}
std::string getPrecisionPostfix (Precision precision)
{
return "_" + std::string(getPrecisionName(precision));
}
// DataType
const char* getDataTypeName (DataType dataType)
{
static const char* s_names[] =
{
"invalid",
"float",
"vec2",
"vec3",
"vec4",
"mat2",
"mat2x3",
"mat2x4",
"mat3x2",
"mat3",
"mat3x4",
"mat4x2",
"mat4x3",
"mat4",
"double",
"dvec2",
"dvec3",
"dvec4",
"dmat2",
"dmat2x3",
"dmat2x4",
"dmat3x2",
"dmat3",
"dmat3x4",
"dmat4x2",
"dmat4x3",
"dmat4",
"int",
"ivec2",
"ivec3",
"ivec4",
"uint",
"uvec2",
"uvec3",
"uvec4",
"bool",
"bvec2",
"bvec3",
"bvec4",
"sampler1D",
"sampler2D",
"samplerCube",
"sampler1DArray",
"sampler2DArray",
"sampler3D",
"samplerCubeArray",
"sampler1DShadow",
"sampler2DShadow",
"samplerCubeShadow",
"sampler1DArrayShadow",
"sampler2DArrayShadow",
"samplerCubeArrayShadow",
"isampler1D",
"isampler2D",
"isamplerCube",
"isampler1DArray",
"isampler2DArray",
"isampler3D",
"isamplerCubeArray",
"usampler1D",
"usampler2D",
"usamplerCube",
"usampler1DArray",
"usampler2DArray",
"usampler3D",
"usamplerCubeArray",
"sampler2DMS",
"isampler2DMS",
"usampler2DMS",
"image2D",
"imageCube",
"image2DArray",
"image3D",
"imageCubeArray",
"iimage2D",
"iimageCube",
"iimage2DArray",
"iimage3D",
"iimageCubeArray",
"uimage2D",
"uimageCube",
"uimage2DArray",
"uimage3D",
"uimageCubeArray",
"atomic_uint",
"samplerBuffer",
"isamplerBuffer",
"usamplerBuffer",
"sampler2DMSArray",
"isampler2DMSArray",
"usampler2DMSArray",
"imageBuffer",
"iimageBuffer",
"uimageBuffer",
"uint8_t",
"u8vec2",
"u8vec3",
"u8vec4",
"int8_t",
"i8vec2",
"i8vec3",
"i8vec4",
"uint16_t",
"u16vec2",
"u16vec3",
"u16vec4",
"int16_t",
"i16vec2",
"i16vec3",
"i16vec4",
"float16_t",
"f16vec2",
"f16vec3",
"f16vec4",
"f16mat2",
"f16mat2x3",
"f16mat2x4",
"f16mat3x2",
"f16mat3",
"f16mat3x4",
"f16mat4x2",
"f16mat4x3",
"f16mat4",
};
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == TYPE_LAST);
DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_names)));
return s_names[(int)dataType];
}
int getDataTypeScalarSize (DataType dataType)
{
static const int s_sizes[] =
{
-1, // invalid
1, // float
2, // vec2
3, // vec3
4, // vec4
4, // mat2
6, // mat2x3
8, // mat2x4
6, // mat3x2
9, // mat3
12, // mat3x4
8, // mat4x2
12, // mat4x3
16, // mat4
1, // double
2, // dvec2
3, // dvec3
4, // dvec4
4, // dmat2
6, // dmat2x3
8, // dmat2x4
6, // dmat3x2
9, // dmat3
12, // dmat3x4
8, // dmat4x2
12, // dmat4x3
16, // dmat4
1, // int
2, // ivec2
3, // ivec3
4, // ivec4
1, // uint
2, // uvec2
3, // uvec3
4, // uvec4
1, // bool
2, // bvec2
3, // bvec3
4, // bvec4
1, // sampler1D
1, // sampler2D
1, // samplerCube
1, // sampler1DArray
1, // sampler2DArray
1, // sampler3D
1, // samplerCubeArray
1, // sampler1DShadow
1, // sampler2DShadow
1, // samplerCubeShadow
1, // sampler1DArrayShadow
1, // sampler2DArrayShadow
1, // samplerCubeArrayShadow
1, // isampler1D
1, // isampler2D
1, // isamplerCube
1, // isampler1DArray
1, // isampler2DArray
1, // isampler3D
1, // isamplerCubeArray
1, // usampler1D
1, // usampler2D
1, // usamplerCube
1, // usampler1DArray
1, // usampler2DArray
1, // usampler3D
1, // usamplerCubeArray
1, // sampler2DMS
1, // isampler2DMS
1, // usampler2DMS
1, // image2D
1, // imageCube
1, // image2DArray
1, // image3D
1, // imageCubeArray
1, // iimage2D
1, // iimageCube
1, // iimage2DArray
1, // iimage3D
1, // iimageCubeArray
1, // uimage2D
1, // uimageCube
1, // uimage2DArray
1, // uimage3D
1, // uimageCubeArray
1, // atomic_uint
1, // samplerBuffer
1, // isamplerBuffer
1, // usamplerBuffer
1, // sampler2DMSArray
1, // isampler2DMSArray
1, // usampler2DMSArray
1, // imageBuffer
1, // iimageBuffer
1, // uimageBuffer
1, // uint8_t
2, // u8vec2
3, // u8vec3
4, // u8vec4
1, // int8_t
2, // i8vec2
3, // i8vec3
4, // i8vec4
1, // uint16_t
2, // u16vec2
3, // u16vec3
4, // u16vec4
1, // int16_t
2, // i16vec2
3, // i16vec3
4, // i16vec4
1, // float16_t
2, // f16vec2
3, // f16vec3
4, // f16vec4
4, // f16mat2
6, // f16mat2x3
8, // f16mat2x4
6, // f16mat3x2
9, // f16mat3
12, // f16mat3x4
8, // f16mat4x2
12, // f16mat4x3
16, // f16mat4
};
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_sizes) == TYPE_LAST);
DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_sizes)));
return s_sizes[(int)dataType];
}
DataType getDataTypeScalarType (DataType dataType)
{
static const DataType s_scalarTypes[] =
{
TYPE_INVALID, // invalid
TYPE_FLOAT, // float
TYPE_FLOAT, // vec2
TYPE_FLOAT, // vec3
TYPE_FLOAT, // vec4
TYPE_FLOAT, // mat2
TYPE_FLOAT, // mat2x3
TYPE_FLOAT, // mat2x4
TYPE_FLOAT, // mat3x2
TYPE_FLOAT, // mat3
TYPE_FLOAT, // mat3x4
TYPE_FLOAT, // mat4x2
TYPE_FLOAT, // mat4x3
TYPE_FLOAT, // mat4
TYPE_DOUBLE, // double
TYPE_DOUBLE, // dvec2
TYPE_DOUBLE, // dvec3
TYPE_DOUBLE, // dvec4
TYPE_DOUBLE, // dmat2
TYPE_DOUBLE, // dmat2x3
TYPE_DOUBLE, // dmat2x4
TYPE_DOUBLE, // dmat3x2
TYPE_DOUBLE, // dmat3
TYPE_DOUBLE, // dmat3x4
TYPE_DOUBLE, // dmat4x2
TYPE_DOUBLE, // dmat4x3
TYPE_DOUBLE, // dmat4
TYPE_INT, // int
TYPE_INT, // ivec2
TYPE_INT, // ivec3
TYPE_INT, // ivec4
TYPE_UINT, // uint
TYPE_UINT, // uvec2
TYPE_UINT, // uvec3
TYPE_UINT, // uvec4
TYPE_BOOL, // bool
TYPE_BOOL, // bvec2
TYPE_BOOL, // bvec3
TYPE_BOOL, // bvec4
TYPE_SAMPLER_1D, // sampler1D
TYPE_SAMPLER_2D, // sampler2D
TYPE_SAMPLER_CUBE, // samplerCube
TYPE_SAMPLER_1D_ARRAY, // sampler1DArray
TYPE_SAMPLER_2D_ARRAY, // sampler2DArray
TYPE_SAMPLER_3D, // sampler3D
TYPE_SAMPLER_CUBE_ARRAY, // samplerCubeArray
TYPE_SAMPLER_1D_SHADOW, // sampler1DShadow
TYPE_SAMPLER_2D_SHADOW, // sampler2DShadow
TYPE_SAMPLER_CUBE_SHADOW, // samplerCubeShadow
TYPE_SAMPLER_1D_ARRAY_SHADOW, // sampler1DArrayShadow
TYPE_SAMPLER_2D_ARRAY_SHADOW, // sampler2DArrayShadow
TYPE_SAMPLER_CUBE_ARRAY_SHADOW, // samplerCubeArrayShadow
TYPE_INT_SAMPLER_1D, // isampler1D
TYPE_INT_SAMPLER_2D, // isampler2D
TYPE_INT_SAMPLER_CUBE, // isamplerCube
TYPE_INT_SAMPLER_1D_ARRAY, // isampler1DArray
TYPE_INT_SAMPLER_2D_ARRAY, // isampler2DArray
TYPE_INT_SAMPLER_3D, // isampler3D
TYPE_INT_SAMPLER_CUBE_ARRAY, // isamplerCubeArray
TYPE_UINT_SAMPLER_1D, // usampler1D
TYPE_UINT_SAMPLER_2D, // usampler2D
TYPE_UINT_SAMPLER_CUBE, // usamplerCube
TYPE_UINT_SAMPLER_1D_ARRAY, // usampler1DArray
TYPE_UINT_SAMPLER_2D_ARRAY, // usampler2DArray
TYPE_UINT_SAMPLER_3D, // usampler3D
TYPE_UINT_SAMPLER_CUBE_ARRAY, // usamplerCubeArray
TYPE_SAMPLER_2D_MULTISAMPLE, // sampler2DMS
TYPE_INT_SAMPLER_2D_MULTISAMPLE, // isampler2DMS
TYPE_UINT_SAMPLER_2D_MULTISAMPLE, // usampler2DMS
TYPE_IMAGE_2D, // image2D
TYPE_IMAGE_CUBE, // imageCube
TYPE_IMAGE_2D_ARRAY, // image2DArray
TYPE_IMAGE_3D, // image3D
TYPE_IMAGE_CUBE_ARRAY, // imageCubeArray
TYPE_INT_IMAGE_2D, // iimage2D
TYPE_INT_IMAGE_CUBE, // iimageCube
TYPE_INT_IMAGE_2D_ARRAY, // iimage2DArray
TYPE_INT_IMAGE_3D, // iimage3D
TYPE_INT_IMAGE_CUBE_ARRAY, // iimageCubeArray
TYPE_UINT_IMAGE_2D, // uimage2D
TYPE_UINT_IMAGE_CUBE, // uimageCube
TYPE_UINT_IMAGE_2D_ARRAY, // uimage2DArray
TYPE_UINT_IMAGE_3D, // uimage3D
TYPE_UINT_IMAGE_CUBE_ARRAY, // uimageCubeArray
TYPE_UINT_ATOMIC_COUNTER, // atomic_uint
TYPE_SAMPLER_BUFFER, // samplerBuffer
TYPE_INT_SAMPLER_BUFFER, // isamplerBuffer
TYPE_UINT_SAMPLER_BUFFER, // usamplerBuffer
TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY, // sampler2DMSArray
TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY, // isampler2DMSArray
TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY, // usampler2DMSArray
TYPE_IMAGE_BUFFER, // imageBuffer
TYPE_INT_IMAGE_BUFFER, // iimageBuffer
TYPE_UINT_IMAGE_BUFFER, // uimageBuffer
TYPE_UINT8, // uint8_t
TYPE_UINT8, // u8vec2
TYPE_UINT8, // u8vec3
TYPE_UINT8, // u8vec4
TYPE_INT8, // int8_t
TYPE_INT8, // i8vec2
TYPE_INT8, // i8vec3
TYPE_INT8, // i8vec4
TYPE_UINT16, // uint16_t
TYPE_UINT16, // u16vec2
TYPE_UINT16, // u16vec3
TYPE_UINT16, // u16vec4
TYPE_INT16, // int16_t
TYPE_INT16, // i16vec2
TYPE_INT16, // i16vec3
TYPE_INT16, // i16vec4
TYPE_FLOAT16, // float16_t
TYPE_FLOAT16, // f16vec2
TYPE_FLOAT16, // f16vec3
TYPE_FLOAT16, // f16vec4
TYPE_FLOAT16, // f16mat2
TYPE_FLOAT16, // f16mat2x3
TYPE_FLOAT16, // f16mat2x4
TYPE_FLOAT16, // f16mat3x2
TYPE_FLOAT16, // f16mat3
TYPE_FLOAT16, // f16mat3x4
TYPE_FLOAT16, // f16mat4x2
TYPE_FLOAT16, // f16mat4x3
TYPE_FLOAT16, // f16mat4
};
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_scalarTypes) == TYPE_LAST);
DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_scalarTypes)));
return s_scalarTypes[(int)dataType];
}
DataType getDataTypeFloat16Scalars (DataType dataType)
{
static const DataType s_floatTypes[] =
{
TYPE_INVALID, // invalid
TYPE_FLOAT16, // float
TYPE_FLOAT16_VEC2, // vec2
TYPE_FLOAT16_VEC3, // vec3
TYPE_FLOAT16_VEC4, // vec4
TYPE_FLOAT16_MAT2, // mat2
TYPE_FLOAT16_MAT2X3, // mat2x3
TYPE_FLOAT16_MAT2X4, // mat2x4
TYPE_FLOAT16_MAT3X2, // mat3x2
TYPE_FLOAT16_MAT3, // mat3
TYPE_FLOAT16_MAT3X4, // mat3x4
TYPE_FLOAT16_MAT4X2, // mat4x2
TYPE_FLOAT16_MAT4X3, // mat4x3
TYPE_FLOAT16_MAT4, // mat4
TYPE_FLOAT16, // double
TYPE_FLOAT16_VEC2, // dvec2
TYPE_FLOAT16_VEC3, // dvec3
TYPE_FLOAT16_VEC4, // dvec4
TYPE_FLOAT16_MAT2, // dmat2
TYPE_FLOAT16_MAT2X3, // dmat2x3
TYPE_FLOAT16_MAT2X4, // dmat2x4
TYPE_FLOAT16_MAT3X2, // dmat3x2
TYPE_FLOAT16_MAT3, // dmat3
TYPE_FLOAT16_MAT3X4, // dmat3x4
TYPE_FLOAT16_MAT4X2, // dmat4x2
TYPE_FLOAT16_MAT4X3, // dmat4x3
TYPE_FLOAT16_MAT4, // dmat4
TYPE_FLOAT16, // int
TYPE_FLOAT16_VEC2, // ivec2
TYPE_FLOAT16_VEC3, // ivec3
TYPE_FLOAT16_VEC4, // ivec4
TYPE_FLOAT16, // uint
TYPE_FLOAT16_VEC2, // uvec2
TYPE_FLOAT16_VEC3, // uvec3
TYPE_FLOAT16_VEC4, // uvec4
TYPE_FLOAT16, // bool
TYPE_FLOAT16_VEC2, // bvec2
TYPE_FLOAT16_VEC3, // bvec3
TYPE_FLOAT16_VEC4, // bvec4
TYPE_INVALID, // sampler1D
TYPE_INVALID, // sampler2D
TYPE_INVALID, // samplerCube
TYPE_INVALID, // sampler1DArray
TYPE_INVALID, // sampler2DArray
TYPE_INVALID, // sampler3D
TYPE_INVALID, // samplerCubeArray
TYPE_INVALID, // sampler1DShadow
TYPE_INVALID, // sampler2DShadow
TYPE_INVALID, // samplerCubeShadow
TYPE_INVALID, // sampler1DArrayShadow
TYPE_INVALID, // sampler2DArrayShadow
TYPE_INVALID, // samplerCubeArrayShadow
TYPE_INVALID, // isampler1D
TYPE_INVALID, // isampler2D
TYPE_INVALID, // isamplerCube
TYPE_INVALID, // isampler1DArray
TYPE_INVALID, // isampler2DArray
TYPE_INVALID, // isampler3D
TYPE_INVALID, // isamplerCubeArray
TYPE_INVALID, // usampler1D
TYPE_INVALID, // usampler2D
TYPE_INVALID, // usamplerCube
TYPE_INVALID, // usampler1DArray
TYPE_INVALID, // usampler2DArray
TYPE_INVALID, // usampler3D
TYPE_INVALID, // usamplerCubeArray
TYPE_INVALID, // sampler2DMS
TYPE_INVALID, // isampler2DMS
TYPE_INVALID, // usampler2DMS
TYPE_INVALID, // image2D
TYPE_INVALID, // imageCube
TYPE_INVALID, // image2DArray
TYPE_INVALID, // image3D
TYPE_INVALID, // imageCubeArray
TYPE_INVALID, // iimage2D
TYPE_INVALID, // iimageCube
TYPE_INVALID, // iimage2DArray
TYPE_INVALID, // iimage3D
TYPE_INVALID, // iimageCubeArray
TYPE_INVALID, // uimage2D
TYPE_INVALID, // uimageCube
TYPE_INVALID, // uimage2DArray
TYPE_INVALID, // uimage3D
TYPE_INVALID, // uimageCubeArray
TYPE_INVALID, // atomic_uint
TYPE_INVALID, // samplerBuffer
TYPE_INVALID, // isamplerBuffer
TYPE_INVALID, // usamplerBuffer
TYPE_INVALID, // sampler2DMSArray
TYPE_INVALID, // isampler2DMSArray
TYPE_INVALID, // usampler2DMSArray
TYPE_INVALID, // imageBuffer
TYPE_INVALID, // iimageBuffer
TYPE_INVALID, // uimageBuffer
TYPE_FLOAT16, // uint8_t
TYPE_FLOAT16_VEC2, // u8vec2
TYPE_FLOAT16_VEC3, // u8vec3
TYPE_FLOAT16_VEC4, // u8vec4
TYPE_FLOAT16, // int8_t
TYPE_FLOAT16_VEC2, // i8vec2
TYPE_FLOAT16_VEC3, // i8vec3
TYPE_FLOAT16_VEC4, // i8vec4
TYPE_FLOAT16, // uint16_t
TYPE_FLOAT16_VEC2, // u16vec2
TYPE_FLOAT16_VEC3, // u16vec3
TYPE_FLOAT16_VEC4, // u16vec4
TYPE_FLOAT16, // int16_t
TYPE_FLOAT16_VEC2, // i16vec2
TYPE_FLOAT16_VEC3, // i16vec3
TYPE_FLOAT16_VEC4, // i16vec4
TYPE_FLOAT16, // float16_t
TYPE_FLOAT16_VEC2, // f16vec2
TYPE_FLOAT16_VEC3, // f16vec3
TYPE_FLOAT16_VEC4, // f16vec4
TYPE_FLOAT16_MAT2, // f16mat2
TYPE_FLOAT16_MAT2X3, // f16mat2x3
TYPE_FLOAT16_MAT2X4, // f16mat2x4
TYPE_FLOAT16_MAT3X2, // f16mat3x2
TYPE_FLOAT16_MAT3, // f16mat3
TYPE_FLOAT16_MAT3X4, // f16mat3x4
TYPE_FLOAT16_MAT4X2, // f16mat4x2
TYPE_FLOAT16_MAT4X3, // f16mat4x3
TYPE_FLOAT16_MAT4, // f16mat4
};
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == TYPE_LAST);
DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_floatTypes)));
return s_floatTypes[(int)dataType];
}
DataType getDataTypeFloatScalars (DataType dataType)
{
static const DataType s_floatTypes[] =
{
TYPE_INVALID, // invalid
TYPE_FLOAT, // float
TYPE_FLOAT_VEC2, // vec2
TYPE_FLOAT_VEC3, // vec3
TYPE_FLOAT_VEC4, // vec4
TYPE_FLOAT_MAT2, // mat2
TYPE_FLOAT_MAT2X3, // mat2x3
TYPE_FLOAT_MAT2X4, // mat2x4
TYPE_FLOAT_MAT3X2, // mat3x2
TYPE_FLOAT_MAT3, // mat3
TYPE_FLOAT_MAT3X4, // mat3x4
TYPE_FLOAT_MAT4X2, // mat4x2
TYPE_FLOAT_MAT4X3, // mat4x3
TYPE_FLOAT_MAT4, // mat4
TYPE_FLOAT, // double
TYPE_FLOAT_VEC2, // dvec2
TYPE_FLOAT_VEC3, // dvec3
TYPE_FLOAT_VEC4, // dvec4
TYPE_FLOAT_MAT2, // dmat2
TYPE_FLOAT_MAT2X3, // dmat2x3
TYPE_FLOAT_MAT2X4, // dmat2x4
TYPE_FLOAT_MAT3X2, // dmat3x2
TYPE_FLOAT_MAT3, // dmat3
TYPE_FLOAT_MAT3X4, // dmat3x4
TYPE_FLOAT_MAT4X2, // dmat4x2
TYPE_FLOAT_MAT4X3, // dmat4x3
TYPE_FLOAT_MAT4, // dmat4
TYPE_FLOAT, // int
TYPE_FLOAT_VEC2, // ivec2
TYPE_FLOAT_VEC3, // ivec3
TYPE_FLOAT_VEC4, // ivec4
TYPE_FLOAT, // uint
TYPE_FLOAT_VEC2, // uvec2
TYPE_FLOAT_VEC3, // uvec3
TYPE_FLOAT_VEC4, // uvec4
TYPE_FLOAT, // bool
TYPE_FLOAT_VEC2, // bvec2
TYPE_FLOAT_VEC3, // bvec3
TYPE_FLOAT_VEC4, // bvec4
TYPE_INVALID, // sampler1D
TYPE_INVALID, // sampler2D
TYPE_INVALID, // samplerCube
TYPE_INVALID, // sampler1DArray
TYPE_INVALID, // sampler2DArray
TYPE_INVALID, // sampler3D
TYPE_INVALID, // samplerCubeArray
TYPE_INVALID, // sampler1DShadow
TYPE_INVALID, // sampler2DShadow
TYPE_INVALID, // samplerCubeShadow
TYPE_INVALID, // sampler1DArrayShadow
TYPE_INVALID, // sampler2DArrayShadow
TYPE_INVALID, // samplerCubeArrayShadow
TYPE_INVALID, // isampler1D
TYPE_INVALID, // isampler2D
TYPE_INVALID, // isamplerCube
TYPE_INVALID, // isampler1DArray
TYPE_INVALID, // isampler2DArray
TYPE_INVALID, // isampler3D
TYPE_INVALID, // isamplerCubeArray
TYPE_INVALID, // usampler1D
TYPE_INVALID, // usampler2D
TYPE_INVALID, // usamplerCube
TYPE_INVALID, // usampler1DArray
TYPE_INVALID, // usampler2DArray
TYPE_INVALID, // usampler3D
TYPE_INVALID, // usamplerCubeArray
TYPE_INVALID, // sampler2DMS
TYPE_INVALID, // isampler2DMS
TYPE_INVALID, // usampler2DMS
TYPE_INVALID, // image2D
TYPE_INVALID, // imageCube
TYPE_INVALID, // image2DArray
TYPE_INVALID, // image3D
TYPE_INVALID, // imageCubeArray
TYPE_INVALID, // iimage2D
TYPE_INVALID, // iimageCube
TYPE_INVALID, // iimage2DArray
TYPE_INVALID, // iimage3D
TYPE_INVALID, // iimageCubeArray
TYPE_INVALID, // uimage2D
TYPE_INVALID, // uimageCube
TYPE_INVALID, // uimage2DArray
TYPE_INVALID, // uimage3D
TYPE_INVALID, // uimageCubeArray
TYPE_INVALID, // atomic_uint
TYPE_INVALID, // samplerBuffer
TYPE_INVALID, // isamplerBuffer
TYPE_INVALID, // usamplerBuffer
TYPE_INVALID, // sampler2DMSArray
TYPE_INVALID, // isampler2DMSArray
TYPE_INVALID, // usampler2DMSArray
TYPE_INVALID, // imageBuffer
TYPE_INVALID, // iimageBuffer
TYPE_INVALID, // uimageBuffer
TYPE_FLOAT, // uint8_t
TYPE_FLOAT_VEC2, // u8vec2
TYPE_FLOAT_VEC3, // u8vec3
TYPE_FLOAT_VEC4, // u8vec4
TYPE_FLOAT, // int8_t
TYPE_FLOAT_VEC2, // i8vec2
TYPE_FLOAT_VEC3, // i8vec3
TYPE_FLOAT_VEC4, // i8vec4
TYPE_FLOAT, // uint16_t
TYPE_FLOAT_VEC2, // u16vec2
TYPE_FLOAT_VEC3, // u16vec3
TYPE_FLOAT_VEC4, // u16vec4
TYPE_FLOAT, // int16_t
TYPE_FLOAT_VEC2, // i16vec2
TYPE_FLOAT_VEC3, // i16vec3
TYPE_FLOAT_VEC4, // i16vec4
TYPE_FLOAT, // float16_t
TYPE_FLOAT_VEC2, // f16vec2
TYPE_FLOAT_VEC3, // f16vec3
TYPE_FLOAT_VEC4, // f16vec4
TYPE_FLOAT_MAT2, // f16mat2
TYPE_FLOAT_MAT2X3, // f16mat2x3
TYPE_FLOAT_MAT2X4, // f16mat2x4
TYPE_FLOAT_MAT3X2, // f16mat3x2
TYPE_FLOAT_MAT3, // f16mat3
TYPE_FLOAT_MAT3X4, // f16mat3x4
TYPE_FLOAT_MAT4X2, // f16mat4x2
TYPE_FLOAT_MAT4X3, // f16mat4x3
TYPE_FLOAT_MAT4, // f16mat4
};
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == TYPE_LAST);
DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_floatTypes)));
return s_floatTypes[(int)dataType];
}
DataType getDataTypeDoubleScalars (DataType dataType)
{
static const DataType s_doubleTypes[] =
{
TYPE_INVALID, // invalid
TYPE_DOUBLE, // float
TYPE_DOUBLE_VEC2, // vec2
TYPE_DOUBLE_VEC3, // vec3
TYPE_DOUBLE_VEC4, // vec4
TYPE_DOUBLE_MAT2, // mat2
TYPE_DOUBLE_MAT2X3, // mat2x3
TYPE_DOUBLE_MAT2X4, // mat2x4
TYPE_DOUBLE_MAT3X2, // mat3x2
TYPE_DOUBLE_MAT3, // mat3
TYPE_DOUBLE_MAT3X4, // mat3x4
TYPE_DOUBLE_MAT4X2, // mat4x2
TYPE_DOUBLE_MAT4X3, // mat4x3
TYPE_DOUBLE_MAT4, // mat4
TYPE_DOUBLE, // double
TYPE_DOUBLE_VEC2, // dvec2
TYPE_DOUBLE_VEC3, // dvec3
TYPE_DOUBLE_VEC4, // dvec4
TYPE_DOUBLE_MAT2, // dmat2
TYPE_DOUBLE_MAT2X3, // dmat2x3
TYPE_DOUBLE_MAT2X4, // dmat2x4
TYPE_DOUBLE_MAT3X2, // dmat3x2
TYPE_DOUBLE_MAT3, // dmat3
TYPE_DOUBLE_MAT3X4, // dmat3x4
TYPE_DOUBLE_MAT4X2, // dmat4x2
TYPE_DOUBLE_MAT4X3, // dmat4x3
TYPE_DOUBLE_MAT4, // dmat4
TYPE_DOUBLE, // int
TYPE_DOUBLE_VEC2, // ivec2
TYPE_DOUBLE_VEC3, // ivec3
TYPE_DOUBLE_VEC4, // ivec4
TYPE_DOUBLE, // uint
TYPE_DOUBLE_VEC2, // uvec2
TYPE_DOUBLE_VEC3, // uvec3
TYPE_DOUBLE_VEC4, // uvec4
TYPE_DOUBLE, // bool
TYPE_DOUBLE_VEC2, // bvec2
TYPE_DOUBLE_VEC3, // bvec3
TYPE_DOUBLE_VEC4, // bvec4
TYPE_INVALID, // sampler1D
TYPE_INVALID, // sampler2D
TYPE_INVALID, // samplerCube
TYPE_INVALID, // sampler1DArray
TYPE_INVALID, // sampler2DArray
TYPE_INVALID, // sampler3D
TYPE_INVALID, // samplerCubeArray
TYPE_INVALID, // sampler1DShadow
TYPE_INVALID, // sampler2DShadow
TYPE_INVALID, // samplerCubeShadow
TYPE_INVALID, // sampler1DArrayShadow
TYPE_INVALID, // sampler2DArrayShadow
TYPE_INVALID, // samplerCubeArrayShadow
TYPE_INVALID, // isampler1D
TYPE_INVALID, // isampler2D
TYPE_INVALID, // isamplerCube
TYPE_INVALID, // isampler1DArray
TYPE_INVALID, // isampler2DArray
TYPE_INVALID, // isampler3D
TYPE_INVALID, // isamplerCubeArray
TYPE_INVALID, // usampler1D
TYPE_INVALID, // usampler2D
TYPE_INVALID, // usamplerCube
TYPE_INVALID, // usampler1DArray
TYPE_INVALID, // usampler2DArray
TYPE_INVALID, // usampler3D
TYPE_INVALID, // usamplerCubeArray
TYPE_INVALID, // sampler2DMS
TYPE_INVALID, // isampler2DMS
TYPE_INVALID, // usampler2DMS
TYPE_INVALID, // image2D
TYPE_INVALID, // imageCube
TYPE_INVALID, // image2DArray
TYPE_INVALID, // image3D
TYPE_INVALID, // imageCubeArray
TYPE_INVALID, // iimage2D
TYPE_INVALID, // iimageCube
TYPE_INVALID, // iimage2DArray
TYPE_INVALID, // iimage3D
TYPE_INVALID, // iimageCubeArray
TYPE_INVALID, // uimage2D
TYPE_INVALID, // uimageCube
TYPE_INVALID, // uimage2DArray
TYPE_INVALID, // uimage3D
TYPE_INVALID, // uimageCubeArray
TYPE_INVALID, // atomic_uint
TYPE_INVALID, // samplerBuffer
TYPE_INVALID, // isamplerBuffer
TYPE_INVALID, // usamplerBuffer
TYPE_INVALID, // sampler2DMSArray
TYPE_INVALID, // isampler2DMSArray
TYPE_INVALID, // usampler2DMSArray
TYPE_INVALID, // imageBuffer
TYPE_INVALID, // iimageBuffer
TYPE_INVALID, // uimageBuffer
TYPE_DOUBLE, // uint18_t
TYPE_DOUBLE_VEC2, // u8vec2
TYPE_DOUBLE_VEC3, // u8vec3
TYPE_DOUBLE_VEC4, // u8vec4
TYPE_DOUBLE, // int8_t
TYPE_DOUBLE_VEC2, // i8vec2
TYPE_DOUBLE_VEC3, // i8vec3
TYPE_DOUBLE_VEC4, // i8vec4
TYPE_DOUBLE, // uint16_t
TYPE_DOUBLE_VEC2, // u16vec2
TYPE_DOUBLE_VEC3, // u16vec3
TYPE_DOUBLE_VEC4, // u16vec4
TYPE_DOUBLE, // int16_t
TYPE_DOUBLE_VEC2, // i16vec2
TYPE_DOUBLE_VEC3, // i16vec3
TYPE_DOUBLE_VEC4, // i16vec4
TYPE_DOUBLE, // float16_t
TYPE_DOUBLE_VEC2, // f16vec2
TYPE_DOUBLE_VEC3, // f16vec3
TYPE_DOUBLE_VEC4, // f16vec4
TYPE_DOUBLE_MAT2, // f16mat2
TYPE_DOUBLE_MAT2X3, // f16mat2x3
TYPE_DOUBLE_MAT2X4, // f16mat2x4
TYPE_DOUBLE_MAT3X2, // f16mat3x2
TYPE_DOUBLE_MAT3, // f16mat3
TYPE_DOUBLE_MAT3X4, // f16mat3x4
TYPE_DOUBLE_MAT4X2, // f16mat4x2
TYPE_DOUBLE_MAT4X3, // f16mat4x3
TYPE_DOUBLE_MAT4, // f16mat4
};
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_doubleTypes) == TYPE_LAST);
DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_doubleTypes)));
return s_doubleTypes[(int)dataType];
}
DataType getDataTypeVector (DataType scalarType, int size)
{
DE_ASSERT(deInRange32(size, 1, 4));
switch (scalarType)
{
case TYPE_FLOAT:
case TYPE_DOUBLE:
case TYPE_INT:
case TYPE_UINT:
case TYPE_BOOL:
case TYPE_UINT8:
case TYPE_INT8:
case TYPE_UINT16:
case TYPE_INT16:
case TYPE_FLOAT16:
return (DataType)((int)scalarType + size - 1);
default:
return TYPE_INVALID;
}
}
DataType getDataTypeFloatVec (int vecSize)
{
return getDataTypeVector(TYPE_FLOAT, vecSize);
}
DataType getDataTypeIntVec (int vecSize)
{
return getDataTypeVector(TYPE_INT, vecSize);
}
DataType getDataTypeUintVec (int vecSize)
{
return getDataTypeVector(TYPE_UINT, vecSize);
}
DataType getDataTypeBoolVec (int vecSize)
{
return getDataTypeVector(TYPE_BOOL, vecSize);
}
DataType getDataTypeMatrix (int numCols, int numRows)
{
DE_ASSERT(de::inRange(numCols, 2, 4) && de::inRange(numRows, 2, 4));
return (DataType)((int)TYPE_FLOAT_MAT2 + (numCols-2)*3 + (numRows-2));
}
int getDataTypeMatrixNumRows (DataType dataType)
{
switch (dataType)
{
case TYPE_FLOAT_MAT2: return 2;
case TYPE_FLOAT_MAT2X3: return 3;
case TYPE_FLOAT_MAT2X4: return 4;
case TYPE_FLOAT_MAT3X2: return 2;
case TYPE_FLOAT_MAT3: return 3;
case TYPE_FLOAT_MAT3X4: return 4;
case TYPE_FLOAT_MAT4X2: return 2;
case TYPE_FLOAT_MAT4X3: return 3;
case TYPE_FLOAT_MAT4: return 4;
case TYPE_DOUBLE_MAT2: return 2;
case TYPE_DOUBLE_MAT2X3: return 3;
case TYPE_DOUBLE_MAT2X4: return 4;
case TYPE_DOUBLE_MAT3X2: return 2;
case TYPE_DOUBLE_MAT3: return 3;
case TYPE_DOUBLE_MAT3X4: return 4;
case TYPE_DOUBLE_MAT4X2: return 2;
case TYPE_DOUBLE_MAT4X3: return 3;
case TYPE_DOUBLE_MAT4: return 4;
case TYPE_FLOAT16_MAT2: return 2;
case TYPE_FLOAT16_MAT2X3: return 3;
case TYPE_FLOAT16_MAT2X4: return 4;
case TYPE_FLOAT16_MAT3X2: return 2;
case TYPE_FLOAT16_MAT3: return 3;
case TYPE_FLOAT16_MAT3X4: return 4;
case TYPE_FLOAT16_MAT4X2: return 2;
case TYPE_FLOAT16_MAT4X3: return 3;
case TYPE_FLOAT16_MAT4: return 4;
default:
DE_ASSERT(false);
return 0;
}
}
int getDataTypeMatrixNumColumns (DataType dataType)
{
switch (dataType)
{
case TYPE_FLOAT_MAT2: return 2;
case TYPE_FLOAT_MAT2X3: return 2;
case TYPE_FLOAT_MAT2X4: return 2;
case TYPE_FLOAT_MAT3X2: return 3;
case TYPE_FLOAT_MAT3: return 3;
case TYPE_FLOAT_MAT3X4: return 3;
case TYPE_FLOAT_MAT4X2: return 4;
case TYPE_FLOAT_MAT4X3: return 4;
case TYPE_FLOAT_MAT4: return 4;
case TYPE_DOUBLE_MAT2: return 2;
case TYPE_DOUBLE_MAT2X3: return 2;
case TYPE_DOUBLE_MAT2X4: return 2;
case TYPE_DOUBLE_MAT3X2: return 3;
case TYPE_DOUBLE_MAT3: return 3;
case TYPE_DOUBLE_MAT3X4: return 3;
case TYPE_DOUBLE_MAT4X2: return 4;
case TYPE_DOUBLE_MAT4X3: return 4;
case TYPE_DOUBLE_MAT4: return 4;
case TYPE_FLOAT16_MAT2: return 2;
case TYPE_FLOAT16_MAT2X3: return 2;
case TYPE_FLOAT16_MAT2X4: return 2;
case TYPE_FLOAT16_MAT3X2: return 3;
case TYPE_FLOAT16_MAT3: return 3;
case TYPE_FLOAT16_MAT3X4: return 3;
case TYPE_FLOAT16_MAT4X2: return 4;
case TYPE_FLOAT16_MAT4X3: return 4;
case TYPE_FLOAT16_MAT4: return 4;
default:
DE_ASSERT(false);
return 0;
}
}
int getDataTypeNumLocations (DataType dataType)
{
if (isDataTypeScalarOrVector(dataType))
return 1;
else if (isDataTypeMatrix(dataType))
return getDataTypeMatrixNumColumns(dataType);
DE_FATAL("Illegal datatype.");
return 0;
}
int getDataTypeNumComponents (DataType dataType)
{
if (isDataTypeScalarOrVector(dataType))
return getDataTypeScalarSize(dataType);
else if (isDataTypeMatrix(dataType))
return getDataTypeMatrixNumRows(dataType);
DE_FATAL("Illegal datatype.");
return 0;
}
DataType getDataTypeFromGLType (deUint32 glType)
{
switch (glType)
{
case GL_FLOAT: return TYPE_FLOAT;
case GL_FLOAT_VEC2: return TYPE_FLOAT_VEC2;
case GL_FLOAT_VEC3: return TYPE_FLOAT_VEC3;
case GL_FLOAT_VEC4: return TYPE_FLOAT_VEC4;
case GL_FLOAT_MAT2: return TYPE_FLOAT_MAT2;
case GL_FLOAT_MAT2x3: return TYPE_FLOAT_MAT2X3;
case GL_FLOAT_MAT2x4: return TYPE_FLOAT_MAT2X4;
case GL_FLOAT_MAT3x2: return TYPE_FLOAT_MAT3X2;
case GL_FLOAT_MAT3: return TYPE_FLOAT_MAT3;
case GL_FLOAT_MAT3x4: return TYPE_FLOAT_MAT3X4;
case GL_FLOAT_MAT4x2: return TYPE_FLOAT_MAT4X2;
case GL_FLOAT_MAT4x3: return TYPE_FLOAT_MAT4X3;
case GL_FLOAT_MAT4: return TYPE_FLOAT_MAT4;
case GL_DOUBLE: return TYPE_DOUBLE;
case GL_DOUBLE_VEC2: return TYPE_DOUBLE_VEC2;
case GL_DOUBLE_VEC3: return TYPE_DOUBLE_VEC3;
case GL_DOUBLE_VEC4: return TYPE_DOUBLE_VEC4;
case GL_DOUBLE_MAT2: return TYPE_DOUBLE_MAT2;
case GL_DOUBLE_MAT2x3: return TYPE_DOUBLE_MAT2X3;
case GL_DOUBLE_MAT2x4: return TYPE_DOUBLE_MAT2X4;
case GL_DOUBLE_MAT3x2: return TYPE_DOUBLE_MAT3X2;
case GL_DOUBLE_MAT3: return TYPE_DOUBLE_MAT3;
case GL_DOUBLE_MAT3x4: return TYPE_DOUBLE_MAT3X4;
case GL_DOUBLE_MAT4x2: return TYPE_DOUBLE_MAT4X2;
case GL_DOUBLE_MAT4x3: return TYPE_DOUBLE_MAT4X3;
case GL_DOUBLE_MAT4: return TYPE_DOUBLE_MAT4;
case GL_INT: return TYPE_INT;
case GL_INT_VEC2: return TYPE_INT_VEC2;
case GL_INT_VEC3: return TYPE_INT_VEC3;
case GL_INT_VEC4: return TYPE_INT_VEC4;
case GL_UNSIGNED_INT: return TYPE_UINT;
case GL_UNSIGNED_INT_VEC2: return TYPE_UINT_VEC2;
case GL_UNSIGNED_INT_VEC3: return TYPE_UINT_VEC3;
case GL_UNSIGNED_INT_VEC4: return TYPE_UINT_VEC4;
case GL_BOOL: return TYPE_BOOL;
case GL_BOOL_VEC2: return TYPE_BOOL_VEC2;
case GL_BOOL_VEC3: return TYPE_BOOL_VEC3;
case GL_BOOL_VEC4: return TYPE_BOOL_VEC4;
case GL_SAMPLER_1D: return TYPE_SAMPLER_1D;
case GL_SAMPLER_2D: return TYPE_SAMPLER_2D;
case GL_SAMPLER_CUBE: return TYPE_SAMPLER_CUBE;
case GL_SAMPLER_1D_ARRAY: return TYPE_SAMPLER_1D_ARRAY;
case GL_SAMPLER_2D_ARRAY: return TYPE_SAMPLER_2D_ARRAY;
case GL_SAMPLER_3D: return TYPE_SAMPLER_3D;
case GL_SAMPLER_CUBE_MAP_ARRAY: return TYPE_SAMPLER_CUBE_ARRAY;
case GL_SAMPLER_1D_SHADOW: return TYPE_SAMPLER_1D_SHADOW;
case GL_SAMPLER_2D_SHADOW: return TYPE_SAMPLER_2D_SHADOW;
case GL_SAMPLER_CUBE_SHADOW: return TYPE_SAMPLER_CUBE_SHADOW;
case GL_SAMPLER_1D_ARRAY_SHADOW: return TYPE_SAMPLER_1D_ARRAY_SHADOW;
case GL_SAMPLER_2D_ARRAY_SHADOW: return TYPE_SAMPLER_2D_ARRAY_SHADOW;
case GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW: return TYPE_SAMPLER_CUBE_ARRAY_SHADOW;
case GL_INT_SAMPLER_1D: return TYPE_INT_SAMPLER_1D;
case GL_INT_SAMPLER_2D: return TYPE_INT_SAMPLER_2D;
case GL_INT_SAMPLER_CUBE: return TYPE_INT_SAMPLER_CUBE;
case GL_INT_SAMPLER_1D_ARRAY: return TYPE_INT_SAMPLER_1D_ARRAY;
case GL_INT_SAMPLER_2D_ARRAY: return TYPE_INT_SAMPLER_2D_ARRAY;
case GL_INT_SAMPLER_3D: return TYPE_INT_SAMPLER_3D;
case GL_INT_SAMPLER_CUBE_MAP_ARRAY: return TYPE_INT_SAMPLER_CUBE_ARRAY;
case GL_UNSIGNED_INT_SAMPLER_1D: return TYPE_UINT_SAMPLER_1D;
case GL_UNSIGNED_INT_SAMPLER_2D: return TYPE_UINT_SAMPLER_2D;
case GL_UNSIGNED_INT_SAMPLER_CUBE: return TYPE_UINT_SAMPLER_CUBE;
case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY: return TYPE_UINT_SAMPLER_1D_ARRAY;
case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY: return TYPE_UINT_SAMPLER_2D_ARRAY;
case GL_UNSIGNED_INT_SAMPLER_3D: return TYPE_UINT_SAMPLER_3D;
case GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY: return TYPE_UINT_SAMPLER_CUBE_ARRAY;
case GL_SAMPLER_2D_MULTISAMPLE: return TYPE_SAMPLER_2D_MULTISAMPLE;
case GL_INT_SAMPLER_2D_MULTISAMPLE: return TYPE_INT_SAMPLER_2D_MULTISAMPLE;
case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE: return TYPE_UINT_SAMPLER_2D_MULTISAMPLE;
case GL_IMAGE_2D: return TYPE_IMAGE_2D;
case GL_IMAGE_CUBE: return TYPE_IMAGE_CUBE;
case GL_IMAGE_2D_ARRAY: return TYPE_IMAGE_2D_ARRAY;
case GL_IMAGE_3D: return TYPE_IMAGE_3D;
case GL_INT_IMAGE_2D: return TYPE_INT_IMAGE_2D;
case GL_INT_IMAGE_CUBE: return TYPE_INT_IMAGE_CUBE;
case GL_INT_IMAGE_2D_ARRAY: return TYPE_INT_IMAGE_2D_ARRAY;
case GL_INT_IMAGE_3D: return TYPE_INT_IMAGE_3D;
case GL_UNSIGNED_INT_IMAGE_2D: return TYPE_UINT_IMAGE_2D;
case GL_UNSIGNED_INT_IMAGE_CUBE: return TYPE_UINT_IMAGE_CUBE;
case GL_UNSIGNED_INT_IMAGE_2D_ARRAY: return TYPE_UINT_IMAGE_2D_ARRAY;
case GL_UNSIGNED_INT_IMAGE_3D: return TYPE_UINT_IMAGE_3D;
case GL_UNSIGNED_INT_ATOMIC_COUNTER: return TYPE_UINT_ATOMIC_COUNTER;
case GL_SAMPLER_BUFFER: return TYPE_SAMPLER_BUFFER;
case GL_INT_SAMPLER_BUFFER: return TYPE_INT_SAMPLER_BUFFER;
case GL_UNSIGNED_INT_SAMPLER_BUFFER: return TYPE_UINT_SAMPLER_BUFFER;
case GL_SAMPLER_2D_MULTISAMPLE_ARRAY: return TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY;
case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY: return TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY;
case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY: return TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY;
case GL_IMAGE_BUFFER: return TYPE_IMAGE_BUFFER;
case GL_INT_IMAGE_BUFFER: return TYPE_INT_IMAGE_BUFFER;
case GL_UNSIGNED_INT_IMAGE_BUFFER: return TYPE_UINT_IMAGE_BUFFER;
default:
return TYPE_LAST;
}
}
} // glu
| 28.65981
| 141
| 0.702286
|
tarceri
|
10198e4d514caaa5671a01595a1c88b94767219b
| 649
|
hpp
|
C++
|
include/RED4ext/Scripting/Natives/Generated/work/AnimClipWithItem.hpp
|
jackhumbert/RED4ext.SDK
|
2c55eccb83beabbbe02abae7945af8efce638fca
|
[
"MIT"
] | 42
|
2020-12-25T08:33:00.000Z
|
2022-03-22T14:47:07.000Z
|
include/RED4ext/Scripting/Natives/Generated/work/AnimClipWithItem.hpp
|
jackhumbert/RED4ext.SDK
|
2c55eccb83beabbbe02abae7945af8efce638fca
|
[
"MIT"
] | 38
|
2020-12-28T22:36:06.000Z
|
2022-02-16T11:25:47.000Z
|
include/RED4ext/Scripting/Natives/Generated/work/AnimClipWithItem.hpp
|
jackhumbert/RED4ext.SDK
|
2c55eccb83beabbbe02abae7945af8efce638fca
|
[
"MIT"
] | 20
|
2020-12-28T22:17:38.000Z
|
2022-03-22T17:19:01.000Z
|
#pragma once
// This file is generated from the Game's Reflection data
#include <cstdint>
#include <RED4ext/Common.hpp>
#include <RED4ext/DynArray.hpp>
#include <RED4ext/Handle.hpp>
#include <RED4ext/Scripting/Natives/Generated/work/AnimClip.hpp>
namespace RED4ext
{
namespace work { struct IWorkspotItemAction; }
namespace work {
struct AnimClipWithItem : work::AnimClip
{
static constexpr const char* NAME = "workAnimClipWithItem";
static constexpr const char* ALIAS = NAME;
DynArray<Handle<work::IWorkspotItemAction>> itemActions; // 48
};
RED4EXT_ASSERT_SIZE(AnimClipWithItem, 0x58);
} // namespace work
} // namespace RED4ext
| 24.961538
| 66
| 0.761171
|
jackhumbert
|
101a6c7b64bc85fe7068333c04aa2ea219f8c47f
| 1,786
|
cpp
|
C++
|
BOJ_solve/8193.cpp
|
python-programmer1512/Code_of_gunwookim
|
e72e6724fb9ee6ccf2e1064583956fa954ba0282
|
[
"MIT"
] | 4
|
2021-01-27T11:51:30.000Z
|
2021-01-30T17:02:55.000Z
|
BOJ_solve/8193.cpp
|
python-programmer1512/Code_of_gunwookim
|
e72e6724fb9ee6ccf2e1064583956fa954ba0282
|
[
"MIT"
] | null | null | null |
BOJ_solve/8193.cpp
|
python-programmer1512/Code_of_gunwookim
|
e72e6724fb9ee6ccf2e1064583956fa954ba0282
|
[
"MIT"
] | 5
|
2021-01-27T11:46:12.000Z
|
2021-05-06T05:37:47.000Z
|
#include <bits/stdc++.h>
#define x first
#define y second
#define pb push_back
#define all(v) v.begin(),v.end()
#pragma gcc optimize("O3")
#pragma gcc optimize("Ofast")
#pragma gcc optimize("unroll-loops")
using namespace std;
const int INF = 1e9;
const int TMX = 1 << 18;
const long long llINF = 2e18;
const long long mod = 1e18;
const long long hashmod = 100003;
typedef long long ll;
typedef long double ld;
typedef pair <int,int> pi;
typedef pair <ll,ll> pl;
typedef vector <int> vec;
typedef vector <pi> vecpi;
typedef long long ll;
int n,m,cs1,ce1,cnam;
int c[40005];
int ds1[40005],de1[40005],nam[40005];
vec v[40005];
pi edge[1000005];
int main() {
ios_base::sync_with_stdio(false); cin.tie(0);
cin >> n >> m;
for(int i = 1;i <= m;i++) {
int x,y; cin >> x >> y;
edge[i] = {x,y};
v[x].pb(y), v[y].pb(x);
}
queue <int> q;
memset(ds1,-1,sizeof(ds1));
memset(de1,-1,sizeof(de1));
ds1[1] = 0, q.push(1);
while(!q.empty()) {
int x = q.front(); q.pop();
for(int i : v[x]) {
if(ds1[i] == -1) {
ds1[i] = ds1[x]+1;
q.push(i);
}
}
}
de1[2] = 0, q.push(2);
while(!q.empty()) {
int x = q.front(); q.pop();
for(int i : v[x]) {
if(de1[i] == -1) {
de1[i] = de1[x]+1;
q.push(i);
}
}
}
for(int i = 3;i <= n;i++) {
if(ds1[i] == 1) {cs1++; c[i] = 1;}
else if(de1[i] == 1) {ce1++; c[i] = 2;}
else {cnam++; c[i] = 3;}
}
int ans = cs1*(cs1-1)/2+ce1*(ce1-1)/2+cnam*(cnam-1)/2;
for(int i = 1;i <= m;i++) {
int x = edge[i].x, y = edge[i].y;
if(c[x] == c[y]) ans--;
}
for(int i = 1;i <= n;i++) {
int cs = 0,ce = 0;
if(c[i] == 3) {
for(int j : v[i]) {
if(ds1[j] == 1) cs++;
if(de1[j] == 1) ce++;
}
if(!cs&&!ce) ans += max(cs1,ce1);
else if(!cs) ans += ce1-ce;
else ans += cs1-cs;
}
}
cout << ans;
}
| 21.780488
| 55
| 0.533595
|
python-programmer1512
|
101b5cd85fdb9264ebbfd21b7b89b41f473e9e73
| 5,174
|
hpp
|
C++
|
src/Core/Geometry/CatmullClarkSubdivider.hpp
|
Yasoo31/Radium-Engine
|
e22754d0abe192207fd946509cbd63c4f9e52dd4
|
[
"Apache-2.0"
] | 78
|
2017-12-01T12:23:22.000Z
|
2022-03-31T05:08:09.000Z
|
src/Core/Geometry/CatmullClarkSubdivider.hpp
|
Yasoo31/Radium-Engine
|
e22754d0abe192207fd946509cbd63c4f9e52dd4
|
[
"Apache-2.0"
] | 527
|
2017-09-25T13:05:32.000Z
|
2022-03-31T18:47:44.000Z
|
src/Core/Geometry/CatmullClarkSubdivider.hpp
|
Yasoo31/Radium-Engine
|
e22754d0abe192207fd946509cbd63c4f9e52dd4
|
[
"Apache-2.0"
] | 48
|
2018-01-04T22:08:08.000Z
|
2022-03-03T08:13:41.000Z
|
#pragma once
#include <Core/Geometry/deprecated/TopologicalMesh.hpp>
#include <OpenMesh/Tools/Subdivider/Uniform/SubdividerT.hh>
namespace Ra {
namespace Core {
namespace Geometry {
/**
* This class implements the Catmull-Clark subdivision algorithm
*
* This class extends OpenMesh's CatmullClarkT subdivider to handle attributes.
* \note We here consider that boundary halfedges do not store attributes.
*/
class RA_CORE_API CatmullClarkSubdivider
: public OpenMesh::Subdivider::Uniform::SubdividerT<deprecated::TopologicalMesh, Scalar>
{
using base = OpenMesh::Subdivider::Uniform::SubdividerT<deprecated::TopologicalMesh, Scalar>;
using V_OP = std::pair<Scalar, deprecated::TopologicalMesh::VertexHandle>;
using V_OPS = std::pair<deprecated::TopologicalMesh::VertexHandle, std::vector<V_OP>>;
using SV_OPS = std::vector<V_OPS>;
using P_OP = std::pair<Scalar, deprecated::TopologicalMesh::HalfedgeHandle>;
using P_OPS = std::pair<deprecated::TopologicalMesh::HalfedgeHandle, std::vector<P_OP>>;
using SP_OPS = std::vector<P_OPS>;
public:
CatmullClarkSubdivider() : base() {}
explicit CatmullClarkSubdivider( deprecated::TopologicalMesh& mesh ) : base() {
attach( mesh );
}
~CatmullClarkSubdivider() { detach(); }
public:
const char* name( void ) const override { return "CatmullClarkSubdivider"; }
/// In the case one wants to apply the subdivision on the same mesh topology,
/// but with a different geometry (e.g. for an animated character),
/// one may want to just reapply the subdivision operations instead
/// for performance reasons.
/// This can be achieved with the following code:
// clang-format off
/// \code
/// // 1- apply subdivision once
/// Ra::Core::Geometry::TriangleMesh triangleMesh;
/// Ra::Core::Geometry::deprecated::TopologicalMesh topoMesh( triangleMesh );
/// Ra::Core::CatmullClarkSubdivider subdiv( topoMesh );
/// subdiv( 2 );
/// // get back to TriangleMesh (mandatory before re-applying)
/// TriangleMesh subdividedMesh = topoMesh.toTriangleMesh();
///
/// // 2- re-apply operations on new geometry (new_vertices, new_normals)
/// m_subdivider.recompute( new_vertices, new_normals, subdividedMesh.vertices(),
/// subdividedMesh.normals(), topoMesh );
/// \endcode
// clang-format on
void recompute( const Vector3Array& newCoarseVertices,
const Vector3Array& newCoarseNormals,
Vector3Array& newSubdivVertices,
Vector3Array& newSubdivNormals,
deprecated::TopologicalMesh& mesh );
protected:
bool prepare( deprecated::TopologicalMesh& _m ) override;
bool cleanup( deprecated::TopologicalMesh& _m ) override;
bool subdivide( deprecated::TopologicalMesh& _m,
size_t _n,
const bool _update_points = true ) override;
private:
// topology helpers
/// Edge recomposition
void split_edge( deprecated::TopologicalMesh& mesh,
const deprecated::TopologicalMesh::EdgeHandle& eh,
size_t iter );
/// Face recomposition
void split_face( deprecated::TopologicalMesh& mesh,
const deprecated::TopologicalMesh::FaceHandle& fh,
size_t iter );
// geometry helpers
/// compute edge midpoint
void compute_midpoint( deprecated::TopologicalMesh& mesh,
const deprecated::TopologicalMesh::EdgeHandle& eh,
const bool update_points,
size_t iter );
/// smooth input vertices
void update_vertex( deprecated::TopologicalMesh& mesh,
const deprecated::TopologicalMesh::VertexHandle& vh,
size_t iter );
private:
/// crease weights
OpenMesh::EPropHandleT<Scalar> m_creaseWeights;
/// old vertex new position
OpenMesh::VPropHandleT<deprecated::TopologicalMesh::Point> m_vpPos;
/// new edge midpoint handle
OpenMesh::EPropHandleT<deprecated::TopologicalMesh::VertexHandle> m_epH;
/// new face point handle
OpenMesh::FPropHandleT<deprecated::TopologicalMesh::VertexHandle> m_fpH;
/// deal with normals on faces
OpenMesh::FPropHandleT<deprecated::TopologicalMesh::Normal> m_normalPropF;
/// deal with custom properties on faces
std::vector<OpenMesh::FPropHandleT<Scalar>> m_floatPropsF;
std::vector<OpenMesh::FPropHandleT<Vector2>> m_vec2PropsF;
std::vector<OpenMesh::FPropHandleT<Vector3>> m_vec3PropsF;
std::vector<OpenMesh::FPropHandleT<Vector4>> m_vec4PropsF;
/// list of vertices computations
std::vector<SV_OPS> m_oldVertexOps;
std::vector<SV_OPS> m_newFaceVertexOps;
std::vector<SV_OPS> m_newEdgeVertexOps;
std::vector<SP_OPS> m_newEdgePropOps;
std::vector<SP_OPS> m_newFacePropOps;
SP_OPS m_triangulationPropOps;
/// old vertex halfedges
OpenMesh::HPropHandleT<deprecated::TopologicalMesh::VertexHandle> m_hV;
};
} // namespace Geometry
} // namespace Core
} // namespace Ra
| 37.492754
| 99
| 0.676073
|
Yasoo31
|
101ccaebd0a01184432a4db39605542ba2003166
| 6,349
|
hpp
|
C++
|
websocket/socket.hpp
|
Matazure/websocket-cpp
|
492587a412ffe67c870098154a9e6869b3e10052
|
[
"MIT"
] | null | null | null |
websocket/socket.hpp
|
Matazure/websocket-cpp
|
492587a412ffe67c870098154a9e6869b3e10052
|
[
"MIT"
] | null | null | null |
websocket/socket.hpp
|
Matazure/websocket-cpp
|
492587a412ffe67c870098154a9e6869b3e10052
|
[
"MIT"
] | null | null | null |
#pragma once
#include <map>
#include <queue>
#include <functional>
#include <iostream>
#include <boost/signals2.hpp>
#include <boost/asio.hpp>
namespace websocket{
namespace asio = boost::asio;
using std::make_shared;
using std::shared_ptr;
using std::enable_shared_from_this;
using asio::io_service;
class server;
namespace detail{
class frame;
}
enum struct error_code{
null = 0,
closure = 1, //clode code not matched
protocol = 2,
transmition = 3
};
class socket: public enable_shared_from_this<socket>{
public:
enum struct state_code{
connecting,
open,
closing,
closed_clearnly,
closed_not_clearnly
};
public:
typedef detail::frame frame;
public:
//server connection signal when opening handshake
typedef boost::signals2::signal<void (shared_ptr<socket>)> connection_signal;
//socket connect signal
typedef boost::signals2::signal<void ()> open_signal;
typedef typename open_signal::slot_type open_slot;
//when asio socket close, emit
typedef boost::signals2::signal<void ()> close_signal;
typedef typename close_signal::slot_type close_slot;
typedef boost::signals2::signal<void (error_code)> error_signal;
typedef typename error_signal::slot_type error_slot;
typedef boost::signals2::signal<void (const std::string &)> message_signal;
typedef typename message_signal::slot_type message_slot;
typedef std::function<void (error_code ec)> send_callback_type;
public:
socket(asio::io_service &iosev)
: _iosev(iosev), _asio_socket(iosev)
, _state(state_code::connecting)
, _sp_open_signal(new open_signal)
, _sp_close_signal(new close_signal)
, _sp_error_signal(new error_signal)
, _sp_message_signal(new message_signal)
, _error_code(error_code::null)
{}
void connect(const std::string &url);
//send text payload data
void send(const std::string &msg);
void send(std::string &&msg);
void ping(const std::string &app_data);
void pong(const std::string &app_data);
//send disconnect control frame, then close.
void disconnect();
void disconnect(uint16_t code, const std::string &reason);
//if is client, the payload data will be masked
bool is_client() const { return _is_client; }
void is_client(bool v) { _is_client = v; }
bool is_open() const { return _state == state_code::open; }
bool is_closed() const {
return _state == state_code::closed_clearnly | _state == state_code::closed_not_clearnly;
}
std::string path() const{
return _url_info.at("path");
}
state_code state() const { return _state; }
void state(state_code state) { _state = state; }
error_code error() const { return _error_code; }
void error(error_code ec) { _error_code = ec; }
//emit after success to handshake
void on_open(open_slot f) { _sp_open_signal->connect(f); }
//emit when socket close(even occur error)
void on_close(close_slot f) { _sp_close_signal->connect(f); }
//emit when occuring error
void on_error(error_slot f) { _sp_error_signal->connect(f); }
//emit when receive text payload data.
void on_message(message_slot f) { _sp_message_signal->connect(f); }
~socket(){
std::cout << "Release socket. " << std::endl;
}
private:
void connect();
void send_frame(shared_ptr<frame>, send_callback_type callback = send_callback_type());
//emit error event(signal), then close
void abnormally_close(error_code);
//close asio socket, emit disconnect event(signal)
void close_tcp_socket();
void wait_handshake(shared_ptr<server> );
void handshake();
void do_read();
void do_write();
friend class server;
private:
void emit_error(error_code ec){
(*_sp_error_signal)(ec);
}
void emit_message(const std::string &msg){
(*_sp_message_signal)(msg);
}
void emit_open(){
(*_sp_open_signal)();
}
void emit_close(){
(*_sp_close_signal)();
}
private:
asio::io_service &_iosev;
bool _is_client;
state_code _state;
//
std::string _url;
std::map<std::string, std::string> _url_info;
std::map<std::string, std::string> _header;
asio::ip::tcp::resolver::iterator _endpoint_iterator;
asio::ip::tcp::socket _asio_socket;
std::queue<shared_ptr<frame>> _frames;
std::map<shared_ptr<frame>, send_callback_type> _write_callbacks;
asio::streambuf _read_buf;
shared_ptr<open_signal> _sp_open_signal;
shared_ptr<close_signal> _sp_close_signal;
shared_ptr<error_signal> _sp_error_signal;
shared_ptr<message_signal> _sp_message_signal;
uint16_t _close_code;
error_code _error_code;
};
}
| 33.592593
| 101
| 0.515514
|
Matazure
|
101ee731d792094b5a1357e7eba79e4508f42642
| 18,553
|
cc
|
C++
|
lib/wabt/src/type-checker.cc
|
paolosevMSFT/ChakraCore
|
e381509ce04eaee0517a668d5002d3eedf582b8b
|
[
"MIT"
] | 3
|
2018-08-08T03:36:56.000Z
|
2019-05-24T08:45:30.000Z
|
lib/wabt/src/type-checker.cc
|
paolosevMSFT/ChakraCore
|
e381509ce04eaee0517a668d5002d3eedf582b8b
|
[
"MIT"
] | null | null | null |
lib/wabt/src/type-checker.cc
|
paolosevMSFT/ChakraCore
|
e381509ce04eaee0517a668d5002d3eedf582b8b
|
[
"MIT"
] | null | null | null |
/*
* Copyright 2017 WebAssembly Community Group participants
*
* 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 "src/type-checker.h"
#include <cinttypes>
namespace wabt {
TypeChecker::Label::Label(LabelType label_type,
const TypeVector& sig,
size_t limit)
: label_type(label_type),
sig(sig),
type_stack_limit(limit),
unreachable(false) {}
TypeChecker::TypeChecker(const ErrorCallback& error_callback)
: error_callback_(error_callback) {}
void TypeChecker::PrintError(const char* fmt, ...) {
if (error_callback_) {
WABT_SNPRINTF_ALLOCA(buffer, length, fmt);
error_callback_(buffer);
}
}
Result TypeChecker::GetLabel(Index depth, Label** out_label) {
if (depth >= label_stack_.size()) {
assert(label_stack_.size() > 0);
PrintError("invalid depth: %" PRIindex " (max %" PRIzd ")", depth,
label_stack_.size() - 1);
*out_label = nullptr;
return Result::Error;
}
*out_label = &label_stack_[label_stack_.size() - depth - 1];
return Result::Ok;
}
Result TypeChecker::TopLabel(Label** out_label) {
return GetLabel(0, out_label);
}
bool TypeChecker::IsUnreachable() {
Label* label;
if (Failed(TopLabel(&label))) {
return true;
}
return label->unreachable;
}
void TypeChecker::ResetTypeStackToLabel(Label* label) {
type_stack_.resize(label->type_stack_limit);
}
Result TypeChecker::SetUnreachable() {
Label* label;
CHECK_RESULT(TopLabel(&label));
label->unreachable = true;
ResetTypeStackToLabel(label);
return Result::Ok;
}
void TypeChecker::PushLabel(LabelType label_type, const TypeVector& sig) {
label_stack_.emplace_back(label_type, sig, type_stack_.size());
}
Result TypeChecker::PopLabel() {
label_stack_.pop_back();
return Result::Ok;
}
Result TypeChecker::CheckLabelType(Label* label, LabelType label_type) {
return label->label_type == label_type ? Result::Ok : Result::Error;
}
Result TypeChecker::PeekType(Index depth, Type* out_type) {
Label* label;
CHECK_RESULT(TopLabel(&label));
if (label->type_stack_limit + depth >= type_stack_.size()) {
*out_type = Type::Any;
return label->unreachable ? Result::Ok : Result::Error;
}
*out_type = type_stack_[type_stack_.size() - depth - 1];
return Result::Ok;
}
Result TypeChecker::PeekAndCheckType(Index depth, Type expected) {
Type actual = Type::Any;
Result result = PeekType(depth, &actual);
return result | CheckType(actual, expected);
}
Result TypeChecker::DropTypes(size_t drop_count) {
Label* label;
CHECK_RESULT(TopLabel(&label));
if (label->type_stack_limit + drop_count > type_stack_.size()) {
if (label->unreachable) {
ResetTypeStackToLabel(label);
return Result::Ok;
}
return Result::Error;
}
type_stack_.erase(type_stack_.end() - drop_count, type_stack_.end());
return Result::Ok;
}
void TypeChecker::PushType(Type type) {
if (type != Type::Void) {
type_stack_.push_back(type);
}
}
void TypeChecker::PushTypes(const TypeVector& types) {
for (Type type : types) {
PushType(type);
}
}
Result TypeChecker::CheckTypeStackEnd(const char* desc) {
Label* label;
CHECK_RESULT(TopLabel(&label));
Result result = (type_stack_.size() == label->type_stack_limit)
? Result::Ok
: Result::Error;
PrintStackIfFailed(result, desc);
return result;
}
Result TypeChecker::CheckType(Type actual, Type expected) {
return (expected == actual || expected == Type::Any || actual == Type::Any)
? Result::Ok
: Result::Error;
}
Result TypeChecker::CheckSignature(const TypeVector& sig) {
Result result = Result::Ok;
for (size_t i = 0; i < sig.size(); ++i) {
result |= PeekAndCheckType(sig.size() - i - 1, sig[i]);
}
return result;
}
Result TypeChecker::PopAndCheckSignature(const TypeVector& sig,
const char* desc) {
Result result = CheckSignature(sig);
PrintStackIfFailed(result, desc, sig);
result |= DropTypes(sig.size());
return result;
}
Result TypeChecker::PopAndCheckCall(const TypeVector& param_types,
const TypeVector& result_types,
const char* desc) {
Result result = CheckSignature(param_types);
PrintStackIfFailed(result, desc, param_types);
result |= DropTypes(param_types.size());
PushTypes(result_types);
return result;
}
Result TypeChecker::PopAndCheck1Type(Type expected, const char* desc) {
Result result = Result::Ok;
result |= PeekAndCheckType(0, expected);
PrintStackIfFailed(result, desc, expected);
result |= DropTypes(1);
return result;
}
Result TypeChecker::PopAndCheck2Types(Type expected1,
Type expected2,
const char* desc) {
Result result = Result::Ok;
result |= PeekAndCheckType(0, expected2);
result |= PeekAndCheckType(1, expected1);
PrintStackIfFailed(result, desc, expected1, expected2);
result |= DropTypes(2);
return result;
}
Result TypeChecker::PopAndCheck3Types(Type expected1,
Type expected2,
Type expected3,
const char* desc) {
Result result = Result::Ok;
result |= PeekAndCheckType(0, expected3);
result |= PeekAndCheckType(1, expected2);
result |= PeekAndCheckType(2, expected1);
PrintStackIfFailed(result, desc, expected1, expected2, expected3);
result |= DropTypes(3);
return result;
}
Result TypeChecker::CheckOpcode1(Opcode opcode) {
Result result = PopAndCheck1Type(opcode.GetParamType1(), opcode.GetName());
PushType(opcode.GetResultType());
return result;
}
Result TypeChecker::CheckOpcode2(Opcode opcode) {
Result result = PopAndCheck2Types(opcode.GetParamType1(),
opcode.GetParamType2(), opcode.GetName());
PushType(opcode.GetResultType());
return result;
}
Result TypeChecker::CheckOpcode3(Opcode opcode) {
Result result =
PopAndCheck3Types(opcode.GetParamType1(), opcode.GetParamType2(),
opcode.GetParamType3(), opcode.GetName());
PushType(opcode.GetResultType());
return result;
}
static std::string TypesToString(const TypeVector& types,
const char* prefix = nullptr) {
std::string result = "[";
if (prefix) {
result += prefix;
}
for (size_t i = 0; i < types.size(); ++i) {
result += GetTypeName(types[i]);
if (i < types.size() - 1) {
result += ", ";
}
}
result += "]";
return result;
}
void TypeChecker::PrintStackIfFailed(Result result,
const char* desc,
const TypeVector& expected) {
if (Succeeded(result)) {
return;
}
size_t limit = 0;
Label* label;
if (Succeeded(TopLabel(&label))) {
limit = label->type_stack_limit;
}
TypeVector actual;
size_t max_depth = type_stack_.size() - limit;
// In general we want to print as many values of the actual stack as were
// expected. However, if the stack was expected to be empty, we should
// print some amount of the actual stack.
size_t actual_size;
if (expected.size() == 0) {
// Don't print too many elements if the stack is really deep.
const size_t kMaxActualStackToPrint = 4;
actual_size = std::min(kMaxActualStackToPrint, max_depth);
} else {
actual_size = std::min(expected.size(), max_depth);
}
bool incomplete_actual_stack = actual_size != max_depth;
for (size_t i = 0; i < actual_size; ++i) {
Type type;
Result result = PeekType(actual_size - i - 1, &type);
WABT_USE(result);
assert(Succeeded(result));
actual.push_back(type);
}
std::string message = "type mismatch in ";
message += desc;
message += ", expected ";
message += TypesToString(expected);
message += " but got ";
message += TypesToString(actual, incomplete_actual_stack ? "... " : nullptr);
PrintError("%s", message.c_str());
}
Result TypeChecker::BeginFunction(const TypeVector* sig) {
type_stack_.clear();
label_stack_.clear();
PushLabel(LabelType::Func, *sig);
return Result::Ok;
}
Result TypeChecker::OnAtomicLoad(Opcode opcode) {
return CheckOpcode1(opcode);
}
Result TypeChecker::OnAtomicStore(Opcode opcode) {
return CheckOpcode2(opcode);
}
Result TypeChecker::OnAtomicRmw(Opcode opcode) {
return CheckOpcode2(opcode);
}
Result TypeChecker::OnAtomicRmwCmpxchg(Opcode opcode) {
return CheckOpcode3(opcode);
}
Result TypeChecker::OnAtomicWait(Opcode opcode) {
return CheckOpcode3(opcode);
}
Result TypeChecker::OnAtomicWake(Opcode opcode) {
return CheckOpcode2(opcode);
}
Result TypeChecker::OnBinary(Opcode opcode) {
return CheckOpcode2(opcode);
}
Result TypeChecker::OnBlock(const TypeVector* sig) {
PushLabel(LabelType::Block, *sig);
return Result::Ok;
}
Result TypeChecker::OnBr(Index depth) {
Result result = Result::Ok;
Label* label;
CHECK_RESULT(GetLabel(depth, &label));
if (label->label_type != LabelType::Loop) {
result |= CheckSignature(label->sig);
}
PrintStackIfFailed(result, "br", label->sig);
CHECK_RESULT(SetUnreachable());
return result;
}
Result TypeChecker::OnBrIf(Index depth) {
Result result = PopAndCheck1Type(Type::I32, "br_if");
Label* label;
CHECK_RESULT(GetLabel(depth, &label));
if (label->label_type != LabelType::Loop) {
result |= PopAndCheckSignature(label->sig, "br_if");
PushTypes(label->sig);
}
return result;
}
Result TypeChecker::BeginBrTable() {
br_table_sig_ = Type::Any;
return PopAndCheck1Type(Type::I32, "br_table");
}
Result TypeChecker::OnBrTableTarget(Index depth) {
Result result = Result::Ok;
Label* label;
CHECK_RESULT(GetLabel(depth, &label));
Type label_sig;
if (label->label_type == LabelType::Loop) {
label_sig = Type::Void;
} else {
assert(label->sig.size() <= 1);
label_sig = label->sig.size() == 0 ? Type::Void : label->sig[0];
result |= CheckSignature(label->sig);
PrintStackIfFailed(result, "br_table", label_sig);
}
// Make sure this label's signature is consistent with the previous labels'
// signatures.
if (Failed(CheckType(br_table_sig_, label_sig))) {
result |= Result::Error;
PrintError("br_table labels have inconsistent types: expected %s, got %s",
GetTypeName(br_table_sig_), GetTypeName(label_sig));
}
br_table_sig_ = label_sig;
return result;
}
Result TypeChecker::EndBrTable() {
return SetUnreachable();
}
Result TypeChecker::OnCall(const TypeVector* param_types,
const TypeVector* result_types) {
return PopAndCheckCall(*param_types, *result_types, "call");
}
Result TypeChecker::OnCallIndirect(const TypeVector* param_types,
const TypeVector* result_types) {
Result result = PopAndCheck1Type(Type::I32, "call_indirect");
result |= PopAndCheckCall(*param_types, *result_types, "call_indirect");
return result;
}
Result TypeChecker::OnCompare(Opcode opcode) {
return CheckOpcode2(opcode);
}
Result TypeChecker::OnCatch() {
Result result = Result::Ok;
Label* label;
CHECK_RESULT(TopLabel(&label));
result |= CheckLabelType(label, LabelType::Try);
result |= PopAndCheckSignature(label->sig, "try block");
result |= CheckTypeStackEnd("try block");
ResetTypeStackToLabel(label);
label->label_type = LabelType::Catch;
label->unreachable = false;
PushType(Type::ExceptRef);
return result;
}
Result TypeChecker::OnConst(Type type) {
PushType(type);
return Result::Ok;
}
Result TypeChecker::OnConvert(Opcode opcode) {
return CheckOpcode1(opcode);
}
Result TypeChecker::OnCurrentMemory() {
PushType(Type::I32);
return Result::Ok;
}
Result TypeChecker::OnDrop() {
Result result = Result::Ok;
result |= DropTypes(1);
PrintStackIfFailed(result, "drop", Type::Any);
return result;
}
Result TypeChecker::OnElse() {
Result result = Result::Ok;
Label* label;
CHECK_RESULT(TopLabel(&label));
result |= CheckLabelType(label, LabelType::If);
result |= PopAndCheckSignature(label->sig, "if true branch");
result |= CheckTypeStackEnd("if true branch");
ResetTypeStackToLabel(label);
label->label_type = LabelType::Else;
label->unreachable = false;
return result;
}
Result TypeChecker::OnEnd(Label* label,
const char* sig_desc,
const char* end_desc) {
Result result = Result::Ok;
result |= PopAndCheckSignature(label->sig, sig_desc);
result |= CheckTypeStackEnd(end_desc);
ResetTypeStackToLabel(label);
PushTypes(label->sig);
PopLabel();
return result;
}
Result TypeChecker::OnEnd() {
Result result = Result::Ok;
static const char* s_label_type_name[] = {"function",
"block",
"loop",
"if",
"if false branch",
"if_except",
"if_except false branch",
"try",
"try catch"};
WABT_STATIC_ASSERT(WABT_ARRAY_SIZE(s_label_type_name) == kLabelTypeCount);
Label* label;
CHECK_RESULT(TopLabel(&label));
assert(static_cast<int>(label->label_type) < kLabelTypeCount);
if (label->label_type == LabelType::If ||
label->label_type == LabelType::IfExcept) {
if (label->sig.size() != 0) {
PrintError("if without else cannot have type signature.");
result = Result::Error;
}
}
const char* desc = s_label_type_name[static_cast<int>(label->label_type)];
result |= OnEnd(label, desc, desc);
return result;
}
Result TypeChecker::OnGrowMemory() {
return CheckOpcode1(Opcode::GrowMemory);
}
Result TypeChecker::OnIf(const TypeVector* sig) {
Result result = PopAndCheck1Type(Type::I32, "if");
PushLabel(LabelType::If, *sig);
return result;
}
Result TypeChecker::OnIfExcept(const TypeVector* sig,
const TypeVector* except_sig) {
Result result = PopAndCheck1Type(Type::ExceptRef, "if_except");
PushLabel(LabelType::IfExcept, *sig);
PushTypes(*except_sig);
return result;
}
Result TypeChecker::OnGetGlobal(Type type) {
PushType(type);
return Result::Ok;
}
Result TypeChecker::OnGetLocal(Type type) {
PushType(type);
return Result::Ok;
}
Result TypeChecker::OnLoad(Opcode opcode) {
return CheckOpcode1(opcode);
}
Result TypeChecker::OnLoop(const TypeVector* sig) {
PushLabel(LabelType::Loop, *sig);
return Result::Ok;
}
Result TypeChecker::OnRethrow() {
Result result = PopAndCheck1Type(Type::ExceptRef, "rethrow");
CHECK_RESULT(SetUnreachable());
return result;
}
Result TypeChecker::OnThrow(const TypeVector* sig) {
Result result = Result::Ok;
result |= PopAndCheckSignature(*sig, "throw");
CHECK_RESULT(SetUnreachable());
return result;
}
Result TypeChecker::OnReturn() {
Result result = Result::Ok;
Label* func_label;
CHECK_RESULT(GetLabel(label_stack_.size() - 1, &func_label));
result |= PopAndCheckSignature(func_label->sig, "return");
CHECK_RESULT(SetUnreachable());
return result;
}
Result TypeChecker::OnSelect() {
Result result = Result::Ok;
Type type = Type::Any;
result |= PeekAndCheckType(0, Type::I32);
result |= PeekType(1, &type);
result |= PeekAndCheckType(2, type);
PrintStackIfFailed(result, "select", Type::I32, type, type);
result |= DropTypes(3);
PushType(type);
return result;
}
Result TypeChecker::OnSetGlobal(Type type) {
return PopAndCheck1Type(type, "set_global");
}
Result TypeChecker::OnSetLocal(Type type) {
return PopAndCheck1Type(type, "set_local");
}
Result TypeChecker::OnStore(Opcode opcode) {
return CheckOpcode2(opcode);
}
Result TypeChecker::OnTry(const TypeVector* sig) {
PushLabel(LabelType::Try, *sig);
return Result::Ok;
}
Result TypeChecker::OnTeeLocal(Type type) {
Result result = Result::Ok;
result |= PopAndCheck1Type(type, "tee_local");
PushType(type);
return result;
}
Result TypeChecker::OnUnary(Opcode opcode) {
return CheckOpcode1(opcode);
}
Result TypeChecker::OnTernary(Opcode opcode) {
return CheckOpcode3(opcode);
}
Result TypeChecker::OnSimdLaneOp(Opcode opcode, uint64_t lane_idx) {
Result result = Result::Error;
uint32_t lane_count = opcode.GetSimdLaneCount();
if (lane_idx >= lane_count) {
PrintError("lane index must be less than %d (got %" PRIu64 ")", lane_count,
lane_idx);
}
switch (opcode) {
case Opcode::I8X16ExtractLaneS:
case Opcode::I8X16ExtractLaneU:
case Opcode::I16X8ExtractLaneS:
case Opcode::I16X8ExtractLaneU:
case Opcode::I32X4ExtractLane:
case Opcode::F32X4ExtractLane:
case Opcode::I64X2ExtractLane:
case Opcode::F64X2ExtractLane:
result = CheckOpcode1(opcode);
break;
case Opcode::I8X16ReplaceLane:
case Opcode::I16X8ReplaceLane:
case Opcode::I32X4ReplaceLane:
case Opcode::F32X4ReplaceLane:
case Opcode::I64X2ReplaceLane:
case Opcode::F64X2ReplaceLane:
result = CheckOpcode2(opcode);
break;
default:
WABT_UNREACHABLE;
}
return result;
}
Result TypeChecker::OnSimdShuffleOp(Opcode opcode, v128 lane_idx) {
Result result = Result::Error;
uint8_t simd_data[16];
memcpy(simd_data, &lane_idx, 16);
for (int i = 0; i < 16; i++) {
if (simd_data[i] >= 32) {
PrintError("lane index must be less than 32 (got %d)", simd_data[i]);
}
}
result = CheckOpcode2(opcode);
return result;
}
Result TypeChecker::OnUnreachable() {
return SetUnreachable();
}
Result TypeChecker::EndFunction() {
Result result = Result::Ok;
Label* label;
CHECK_RESULT(TopLabel(&label));
result |= CheckLabelType(label, LabelType::Func);
result |= OnEnd(label, "implicit return", "function");
return result;
}
} // namespace wabt
| 28.110606
| 79
| 0.665014
|
paolosevMSFT
|
101f784e325666cda51020e14fee793945097532
| 10,700
|
cpp
|
C++
|
Engine/source/gfx/video/videoCapture.cpp
|
Pecon/Torque3D-1
|
81777348c8ab2fa49cbc534315294c3bee7ae3aa
|
[
"MIT"
] | 417
|
2020-06-01T15:55:15.000Z
|
2022-03-31T12:50:51.000Z
|
Engine/source/gfx/video/videoCapture.cpp
|
Ashry00/Torque3D
|
33e3e41c8b7eb41c743a589558bc21302207ef97
|
[
"MIT"
] | 186
|
2020-06-02T19:12:39.000Z
|
2022-02-15T02:22:27.000Z
|
Engine/source/gfx/video/videoCapture.cpp
|
Ashry00/Torque3D
|
33e3e41c8b7eb41c743a589558bc21302207ef97
|
[
"MIT"
] | 84
|
2020-06-01T15:54:44.000Z
|
2022-03-24T13:52:59.000Z
|
//-----------------------------------------------------------------------------
// Copyright (c) 2012 GarageGames, LLC
//
// 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 "platform/platform.h"
#include "gfx/video/videoCapture.h"
#include "console/console.h"
#include "core/strings/stringFunctions.h"
#include "core/util/journal/journal.h"
#include "core/module.h"
#include "gui/core/guiCanvas.h"
#include "gfx/gfxTextureManager.h"
#include "console/engineAPI.h"
Vector<VideoCapture::EncoderFactory> VideoCapture::mEncoderFactoryFnList;
MODULE_BEGIN( VideoCapture )
MODULE_INIT_BEFORE( GFX )
MODULE_SHUTDOWN_BEFORE( GFX )
MODULE_INIT
{
ManagedSingleton< VideoCapture >::createSingleton();
}
MODULE_SHUTDOWN
{
VIDCAP->end();
ManagedSingleton< VideoCapture >::deleteSingleton();
}
MODULE_END;
VideoCapture::VideoCapture() :
mCapturedFramePos(-1.0f),
mEncoder(NULL),
mFrameGrabber(NULL),
mCanvas(NULL),
mIsRecording(false),
mVideoCaptureStartTime(0),
mNextFramePosition(0.0f),
mFrameRate(30.0f),
mMsPerFrame(1000.0f / mFrameRate),
mResolution(0,0),
mWaitingForCanvas(false),
mEncoderName("THEORA"),
mMsPerFrameError(0),
mFileName("")
{
}
S32 VideoCapture::getMsPerFrame()
{
//Add accumulated error to ms per frame before rounding
F32 roundTime = mFloor(mMsPerFrame + mMsPerFrameError + 0.5f);
//Accumulate the rounding errors
mMsPerFrameError += mMsPerFrame - roundTime;
return (S32)roundTime;
}
void VideoCapture::begin( GuiCanvas* canvas )
{
// No longer waiting for a canvas
mWaitingForCanvas = false;
// No specified file
if (mFileName.isEmpty())
{
Con::errorf("VideoCapture: no file specified!");
return;
}
// No framegrabber, cannot capture
if (mFrameGrabber == NULL)
{
Con::errorf("VideoCapture: cannot capture without a VideoFrameGrabber! One should be created in the GFXDevice initialization!");
return;
}
// Set the active encoder
if (!initEncoder(mEncoderName))
return;
// Store the canvas, so we know which one to capture from
mCanvas = canvas;
// If the resolution is zero, get the current video mode
if (mResolution.isZero())
mResolution = mCanvas->getPlatformWindow()->getVideoMode().resolution;
// Set the encoder file, framerate and resolution
mEncoder->setFile(mFileName);
mEncoder->setFramerate( &mFrameRate );
mEncoder->setResolution( &mResolution );
// The frame grabber must know about the resolution as well, since it'll do the resizing for us
mFrameGrabber->setOutResolution( mResolution );
// Calculate the ms per frame
mMsPerFrame = 1000.0f / mFrameRate;
// Start the encoder
if (!mEncoder->begin())
return;
// We're now recording
mIsRecording = true;
mNextFramePosition = 0.0f;
}
void VideoCapture::end()
{
if (!mIsRecording)
return;
if (mEncoder && !mEncoder->end())
Con::errorf("VideoCapture: an error has ocurred while closing the video stream");
// Garbage collect the processed bitmaps
deleteProcessedBitmaps();
delete mEncoder;
mEncoder = NULL;
mIsRecording = false;
}
void VideoCapture::capture()
{
// If this is the first frame, capture and encode it right away
if (mNextFramePosition == 0.0f)
{
mVideoCaptureStartTime = Platform::getVirtualMilliseconds();
mCapturedFramePos = -1.0f;
}
// Calculate the frame position for this captured frame
U32 frameTimeMs = Platform::getVirtualMilliseconds() - mVideoCaptureStartTime;
F32 framePosition = (F32)frameTimeMs / mMsPerFrame;
// Repeat until the current frame is captured
while (framePosition > mCapturedFramePos)
{
// If the frame position is closer to the next frame position
// than the previous one capture it
if ( mFabs(framePosition - mNextFramePosition) < mFabs(mCapturedFramePos - mNextFramePosition) )
{
mFrameGrabber->captureBackBuffer();
mCapturedFramePos = framePosition;
}
// If the new frame position is greater or equal than the next frame time
// tell the framegrabber to make bitmaps out from the last captured backbuffer until the video catches up
while ( framePosition >= mNextFramePosition )
{
mFrameGrabber->makeBitmap();
mNextFramePosition++;
}
}
// Fetch bitmaps from the framegrabber and encode them
GBitmap *bitmap = NULL;
while ( (bitmap = mFrameGrabber->fetchBitmap()) != NULL )
{
//mEncoder->pushProcessedBitmap(bitmap);
if (!mEncoder->pushFrame(bitmap))
{
Con::errorf("VideoCapture: an error occurred while encoding a frame. Recording aborted.");
end();
break;
}
}
// Garbage collect the processed bitmaps
deleteProcessedBitmaps();
}
void VideoCapture::registerEncoder( const char* name, VideoEncoderFactoryFn factoryFn )
{
mEncoderFactoryFnList.increment();
mEncoderFactoryFnList.last().name = name;
mEncoderFactoryFnList.last().factory = factoryFn;
}
bool VideoCapture::initEncoder( const char* name )
{
if ( mEncoder )
{
Con::errorf("VideoCapture:: cannot change video encoder while capturing! Stop the capture first!");
return false;
}
// Try creating an encoder based on the name
for (U32 i=0; i<mEncoderFactoryFnList.size(); i++)
{
if (dStricmp(name, mEncoderFactoryFnList[i].name) == 0)
{
mEncoder = mEncoderFactoryFnList[i].factory();
return true;
}
}
//If we got here there's no encoder matching the speficied name
Con::errorf("\"%s\" isn't a valid encoder!", name);
return false;
}
void VideoCapture::deleteProcessedBitmaps()
{
if (mEncoder == NULL)
return;
//Grab bitmaps processed by our encoder
GBitmap* bitmap = NULL;
while ( (bitmap = mEncoder->getProcessedBitmap()) != NULL )
mBitmapDeleteList.push_back(bitmap);
//Now delete them (or not... se below)
while ( mBitmapDeleteList.size() )
{
bitmap = mBitmapDeleteList[0];
mBitmapDeleteList.pop_front();
// Delete the bitmap only if it's the different than the next one (or it's the last one).
// This is done because repeated frames re-use the same GBitmap object
// and thus their pointers will appearl multiple times in the list
if (mBitmapDeleteList.size() == 0 || bitmap != mBitmapDeleteList[0])
delete bitmap;
}
}
///----------------------------------------------------------------------
///----------------------------------------------------------------------
void VideoEncoder::setFile( const char* path )
{
mPath = path;
}
GBitmap* VideoEncoder::getProcessedBitmap()
{
GBitmap* bitmap = NULL;
if (mProcessedBitmaps.tryPopFront(bitmap))
return bitmap;
return NULL;
}
void VideoEncoder::pushProcessedBitmap( GBitmap* bitmap )
{
mProcessedBitmaps.pushBack(bitmap);
}
///----------------------------------------------------------------------
///----------------------------------------------------------------------
GBitmap* VideoFrameGrabber::fetchBitmap()
{
if (mBitmapList.size() == 0)
return NULL;
GBitmap *bitmap = mBitmapList.first();
mBitmapList.pop_front();
return bitmap;
}
VideoFrameGrabber::VideoFrameGrabber()
{
GFXTextureManager::addEventDelegate( this, &VideoFrameGrabber::_onTextureEvent );
}
VideoFrameGrabber::~VideoFrameGrabber()
{
GFXTextureManager::removeEventDelegate( this, &VideoFrameGrabber::_onTextureEvent );
}
void VideoFrameGrabber::_onTextureEvent(GFXTexCallbackCode code)
{
if ( code == GFXZombify )
releaseTextures();
}
///----------------------------------------------------------------------
///----------------------------------------------------------------------
//WLE - Vince
//Changing the resolution to Point2I::Zero instead of the Point2I(0,0) better to use constants.
DefineEngineFunction( startVideoCapture, void,
( GuiCanvas *canvas, const char *filename, const char *encoder, F32 framerate, Point2I resolution ),
( "THEORA", 30.0f, Point2I::Zero ),
"Begins a video capture session.\n"
"@see stopVideoCapture\n"
"@ingroup Rendering\n" )
{
#ifdef TORQUE_DEBUG
Con::errorf("Recording video is disabled in debug!");
#else
if ( !canvas )
{
Con::errorf("startVideoCapture -Please specify a GuiCanvas object to record from!");
return;
}
VIDCAP->setFilename( filename );
VIDCAP->setEncoderName( encoder );
VIDCAP->setFramerate( framerate );
if ( !resolution.isZero() )
VIDCAP->setResolution(resolution);
VIDCAP->begin(canvas);
#endif
}
DefineEngineFunction( stopVideoCapture, void, (),,
"Stops the video capture session.\n"
"@see startVideoCapture\n"
"@ingroup Rendering\n" )
{
VIDCAP->end();
}
DefineEngineFunction( playJournalToVideo, void,
( const char *journalFile, const char *videoFile, const char *encoder, F32 framerate, Point2I resolution ),
( nullAsType<const char*>(), "THEORA", 30.0f, Point2I::Zero ),
"Load a journal file and capture it video.\n"
"@ingroup Rendering\n" )
{
if ( !videoFile )
videoFile = journalFile;
VIDCAP->setFilename( Torque::Path( videoFile ).getFileName() );
VIDCAP->setEncoderName( encoder );
VIDCAP->setFramerate( framerate );
if ( !resolution.isZero() )
VIDCAP->setResolution(resolution);
VIDCAP->waitForCanvas();
Journal::Play( journalFile );
}
| 28.99729
| 134
| 0.648411
|
Pecon
|
1021f500fcce6635853389251968823a7060d9d0
| 17,829
|
cpp
|
C++
|
RadeonRays/src/intersector/intersector_skip_links.cpp
|
pribault/RadeonRays_SDK
|
b9bda1fcdb806c5f0f157b17d473daa5f45e3ce1
|
[
"MIT"
] | 675
|
2019-02-07T01:23:19.000Z
|
2022-03-28T05:45:10.000Z
|
RadeonRays/src/intersector/intersector_skip_links.cpp
|
pribault/RadeonRays_SDK
|
b9bda1fcdb806c5f0f157b17d473daa5f45e3ce1
|
[
"MIT"
] | 843
|
2019-01-25T01:06:46.000Z
|
2022-03-16T11:15:53.000Z
|
RadeonRays/src/intersector/intersector_skip_links.cpp
|
pribault/RadeonRays_SDK
|
b9bda1fcdb806c5f0f157b17d473daa5f45e3ce1
|
[
"MIT"
] | 83
|
2019-02-20T06:18:46.000Z
|
2022-03-20T09:36:09.000Z
|
/**********************************************************************
Copyright (c) 2016 Advanced Micro Devices, Inc. All rights reserved.
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 "intersector_skip_links.h"
#include "../accelerator/bvh.h"
#include "../accelerator/split_bvh.h"
#include "../primitive/mesh.h"
#include "../primitive/instance.h"
#include "../world/world.h"
#include "../translator/plain_bvh_translator.h"
#include "device.h"
#include "executable.h"
#include <algorithm>
// Preferred work group size for Radeon devices
static int const kWorkGroupSize = 64;
namespace RadeonRays
{
struct IntersectorSkipLinks::GpuData
{
// Device
Calc::Device* device;
// BVH nodes
Calc::Buffer* bvh;
// Vertex positions
Calc::Buffer* vertices;
// Indices
Calc::Buffer* faces;
Calc::Executable* executable;
Calc::Function* isect_func;
Calc::Function* occlude_func;
GpuData(Calc::Device* d)
: device(d)
, bvh(nullptr)
, vertices(nullptr)
, faces(nullptr)
, executable(nullptr)
{
}
~GpuData()
{
device->DeleteBuffer(bvh);
device->DeleteBuffer(vertices);
device->DeleteBuffer(faces);
if (executable)
{
executable->DeleteFunction(isect_func);
executable->DeleteFunction(occlude_func);
device->DeleteExecutable(executable);
}
}
};
IntersectorSkipLinks::IntersectorSkipLinks(Calc::Device* device)
: Intersector(device)
, m_gpudata(new GpuData(device))
, m_bvh(nullptr)
{
std::string buildopts;
#ifdef RR_RAY_MASK
buildopts.append("-D RR_RAY_MASK ");
#endif
#ifdef RR_BACKFACE_CULL
buildopts.append("-D RR_BACKFACE_CULL ");
#endif // RR_BACKFACE_CULL
#ifdef USE_SAFE_MATH
buildopts.append("-D USE_SAFE_MATH ");
#endif
#ifndef RR_EMBED_KERNELS
if ( device->GetPlatform() == Calc::Platform::kOpenCL )
{
char const* headers[] = { "../RadeonRays/src/kernels/CL/common.cl" };
int numheaders = sizeof( headers ) / sizeof( char const* );
m_gpudata->executable = m_device->CompileExecutable( "../RadeonRays/src/kernels/CL/intersect_bvh2_skiplinks.cl", headers, numheaders, buildopts.c_str());
}
else
{
assert( device->GetPlatform() == Calc::Platform::kVulkan );
m_gpudata->executable = m_device->CompileExecutable( "../RadeonRays/src/kernels/GLSL/bvh.comp", nullptr, 0, buildopts.c_str());
}
#else
#if USE_OPENCL
if (device->GetPlatform() == Calc::Platform::kOpenCL)
{
m_gpudata->executable = m_device->CompileExecutable(g_intersect_bvh2_skiplinks_opencl, std::strlen(g_intersect_bvh2_skiplinks_opencl), buildopts.c_str());
}
#endif
#if USE_VULKAN
if (m_gpudata->executable == nullptr && device->GetPlatform() == Calc::Platform::kVulkan)
{
m_gpudata->executable = m_device->CompileExecutable(g_bvh_vulkan, std::strlen(g_bvh_vulkan), buildopts.c_str());
}
#endif
#endif
assert(m_gpudata->executable);
m_gpudata->isect_func = m_gpudata->executable->CreateFunction("intersect_main");
m_gpudata->occlude_func = m_gpudata->executable->CreateFunction("occluded_main");
}
void IntersectorSkipLinks::Process(World const& world)
{
// If something has been changed we need to rebuild BVH
if (!m_bvh || world.has_changed() || world.GetStateChange() != ShapeImpl::kStateChangeNone)
{
if (m_bvh)
{
m_device->DeleteBuffer(m_gpudata->bvh);
m_device->DeleteBuffer(m_gpudata->vertices);
m_device->DeleteBuffer(m_gpudata->faces);
}
int numshapes = (int)world.shapes_.size();
int numvertices = 0;
int numfaces = 0;
// This buffer tracks mesh start index for next stage as mesh face indices are relative to 0
std::vector<int> mesh_vertices_start_idx(numshapes);
std::vector<int> mesh_faces_start_idx(numshapes);
// Check options
auto builder = world.options_.GetOption("bvh.builder");
auto splits = world.options_.GetOption("bvh.sah.use_splits");
auto maxdepth = world.options_.GetOption("bvh.sah.max_split_depth");
auto overlap = world.options_.GetOption("bvh.sah.min_overlap");
auto tcost = world.options_.GetOption("bvh.sah.traversal_cost");
auto node_budget = world.options_.GetOption("bvh.sah.extra_node_budget");
auto nbins = world.options_.GetOption("bvh.sah.num_bins");
bool use_sah = false;
bool use_splits = false;
int max_split_depth = maxdepth ? (int)maxdepth->AsFloat() : 10;
int num_bins = nbins ? (int)nbins->AsFloat() : 64;
float min_overlap = overlap ? overlap->AsFloat() : 0.05f;
float traversal_cost = tcost ? tcost->AsFloat() : 10.f;
float extra_node_budget = node_budget ? node_budget->AsFloat() : 0.5f;
if (builder && builder->AsString() == "sah")
{
use_sah = true;
}
if (splits && splits->AsFloat() > 0.f)
{
use_splits = true;
}
m_bvh.reset( use_splits ?
new SplitBvh(traversal_cost, num_bins, max_split_depth, min_overlap, extra_node_budget) :
new Bvh(traversal_cost, num_bins, use_sah)
);
// Partition the array into meshes and instances
std::vector<Shape const*> shapes(world.shapes_);
auto firstinst = std::partition(shapes.begin(), shapes.end(),
[&](Shape const* shape)
{
return !static_cast<ShapeImpl const*>(shape)->is_instance();
});
// Count the number of meshes
int nummeshes = (int)std::distance(shapes.begin(), firstinst);
// Count the number of instances
int numinstances = (int)std::distance(firstinst, shapes.end());
for (int i = 0; i < nummeshes; ++i)
{
Mesh const* mesh = static_cast<Mesh const*>(shapes[i]);
mesh_faces_start_idx[i] = numfaces;
mesh_vertices_start_idx[i] = numvertices;
numfaces += mesh->num_faces();
numvertices += mesh->num_vertices();
}
for (int i = nummeshes; i < nummeshes + numinstances; ++i)
{
Instance const* instance = static_cast<Instance const*>(shapes[i]);
Mesh const* mesh = static_cast<Mesh const*>(instance->GetBaseShape());
mesh_faces_start_idx[i] = numfaces;
mesh_vertices_start_idx[i] = numvertices;
numfaces += mesh->num_faces();
numvertices += mesh->num_vertices();
}
// We can't avoild allocating it here, since bounds aren't stored anywhere
std::vector<bbox> bounds(numfaces);
// We handle meshes first collecting their world space bounds
#pragma omp parallel for
for (int i = 0; i < nummeshes; ++i)
{
Mesh const* mesh = static_cast<Mesh const*>(shapes[i]);
for (int j = 0; j < mesh->num_faces(); ++j)
{
// Here we directly get world space bounds
mesh->GetFaceBounds(j, false, bounds[mesh_faces_start_idx[i] + j]);
}
}
// Then we handle instances. Need to flatten them into actual geometry.
#pragma omp parallel for
for (int i = nummeshes; i < nummeshes + numinstances; ++i)
{
Instance const* instance = static_cast<Instance const*>(shapes[i]);
Mesh const* mesh = static_cast<Mesh const*>(instance->GetBaseShape());
// Instance is using its own transform for base shape geometry
// so we need to get object space bounds and transform them manually
matrix m, minv;
instance->GetTransform(m, minv);
for (int j = 0; j < mesh->num_faces(); ++j)
{
bbox tmp;
mesh->GetFaceBounds(j, true, tmp);
bounds[mesh_faces_start_idx[i] + j] = transform_bbox(tmp, m);
}
}
m_bvh->Build(&bounds[0], numfaces);
#ifdef RR_PROFILE
m_bvh->PrintStatistics(std::cout);
#endif
PlainBvhTranslator translator;
translator.Process(*m_bvh);
// Update GPU data
// Copy translated nodes first
m_gpudata->bvh = m_device->CreateBuffer(translator.nodes_.size() * sizeof(PlainBvhTranslator::Node), Calc::BufferType::kRead, &translator.nodes_[0]);
// Create vertex buffer
{
// Vertices
m_gpudata->vertices = m_device->CreateBuffer(numvertices * sizeof(float3), Calc::BufferType::kRead);
// Get the pointer to mapped data
float3* vertexdata = nullptr;
Calc::Event* e = nullptr;
m_device->MapBuffer(m_gpudata->vertices, 0, 0, numvertices * sizeof(float3), Calc::MapType::kMapWrite, (void**)&vertexdata, &e);
e->Wait();
m_device->DeleteEvent(e);
// Here we need to put data in world space rather than object space
// So we need to get the transform from the mesh and multiply each vertex
matrix m, minv;
#pragma omp parallel for
for (int i = 0; i < nummeshes; ++i)
{
// Get the mesh
Mesh const* mesh = static_cast<Mesh const*>(shapes[i]);
// Get vertex buffer of the current mesh
float3 const* myvertexdata = mesh->GetVertexData();
// Get mesh transform
mesh->GetTransform(m, minv);
//#pragma omp parallel for
// Iterate thru vertices multiply and append them to GPU buffer
for (int j = 0; j < mesh->num_vertices(); ++j)
{
vertexdata[mesh_vertices_start_idx[i] + j] = transform_point(myvertexdata[j], m);
}
}
#pragma omp parallel for
for (int i = nummeshes; i < nummeshes + numinstances; ++i)
{
Instance const* instance = static_cast<Instance const*>(shapes[i]);
// Get the mesh
Mesh const* mesh = static_cast<Mesh const*>(instance->GetBaseShape());
// Get vertex buffer of the current mesh
float3 const* myvertexdata = mesh->GetVertexData();
// Get mesh transform
instance->GetTransform(m, minv);
//#pragma omp parallel for
// Iterate thru vertices multiply and append them to GPU buffer
for (int j = 0; j < mesh->num_vertices(); ++j)
{
vertexdata[mesh_vertices_start_idx[i] + j] = transform_point(myvertexdata[j], m);
}
}
m_device->UnmapBuffer(m_gpudata->vertices, 0, vertexdata, &e);
e->Wait();
m_device->DeleteEvent(e);
}
// Create face buffer
{
struct Face
{
// Up to 3 indices
int idx[3];
// Shape ID
int shape_id;
// Primitive ID
int prim_id;
};
// This number is different from the number of faces for some BVHs
auto numindices = m_bvh->GetNumIndices();
// Create face buffer
m_gpudata->faces = m_device->CreateBuffer(numindices * sizeof(Face), Calc::BufferType::kRead);
// Get the pointer to mapped data
Face* facedata = nullptr;
Calc::Event* e = nullptr;
m_device->MapBuffer(m_gpudata->faces, 0, 0, numindices * sizeof(Face), Calc::BufferType::kWrite, (void**)&facedata, &e);
e->Wait();
m_device->DeleteEvent(e);
// Here the point is to add mesh starting index to actual index contained within the mesh,
// getting absolute index in the buffer.
// Besides that we need to permute the faces accorningly to BVH reordering, whihc
// is contained within bvh.primids_
int const* reordering = m_bvh->GetIndices();
for (size_t i = 0; i < numindices; ++i)
{
int indextolook4 = reordering[i];
// We need to find a shape corresponding to current face
auto iter = std::upper_bound(mesh_faces_start_idx.cbegin(), mesh_faces_start_idx.cend(), indextolook4);
// Find the index of the shape
int shapeidx = static_cast<int>(std::distance(mesh_faces_start_idx.cbegin(), iter) - 1);
// Get the mesh directly or out of instance
Mesh const* mesh = nullptr;
if (shapeidx < nummeshes)
{
mesh = static_cast<Mesh const*>(shapes[shapeidx]);
}
else
{
mesh = static_cast<Mesh const*>(static_cast<Instance const*>(shapes[shapeidx])->GetBaseShape());
}
// Get vertex buffer of the current mesh
Mesh::Face const* myfacedata = mesh->GetFaceData();
// Find face idx
int faceidx = indextolook4 - mesh_faces_start_idx[shapeidx];
// Find mesh start idx
int mystartidx = mesh_vertices_start_idx[shapeidx];
// Copy face data to GPU buffer
facedata[i].idx[0] = myfacedata[faceidx].idx[0] + mystartidx;
facedata[i].idx[1] = myfacedata[faceidx].idx[1] + mystartidx;
facedata[i].idx[2] = myfacedata[faceidx].idx[2] + mystartidx;
// Optimization: we are putting faceid here
facedata[i].shape_id = shapes[shapeidx]->GetId();
facedata[i].prim_id = faceidx;
}
m_device->UnmapBuffer(m_gpudata->faces, 0, facedata, &e);
e->Wait();
m_device->DeleteEvent(e);
}
// Make sure everything is commited
m_device->Finish(0);
}
}
void IntersectorSkipLinks::Intersect(std::uint32_t queueidx, Calc::Buffer const* rays, Calc::Buffer const* numrays, std::uint32_t maxrays, Calc::Buffer* hits, Calc::Event const* waitevent, Calc::Event** event) const
{
auto& func = m_gpudata->isect_func;
// Set args
int arg = 0;
func->SetArg(arg++, m_gpudata->bvh);
func->SetArg(arg++, m_gpudata->vertices);
func->SetArg(arg++, m_gpudata->faces);
func->SetArg(arg++, rays);
func->SetArg(arg++, numrays);
func->SetArg(arg++, hits);
size_t localsize = kWorkGroupSize;
size_t globalsize = ((maxrays + kWorkGroupSize - 1) / kWorkGroupSize) * kWorkGroupSize;
m_device->Execute(func, queueidx, globalsize, localsize, event);
}
void IntersectorSkipLinks::Occluded(std::uint32_t queueidx, Calc::Buffer const* rays, Calc::Buffer const* numrays, std::uint32_t maxrays, Calc::Buffer* hits, Calc::Event const* waitevent, Calc::Event** event) const
{
auto& func = m_gpudata->occlude_func;
// Set args
int arg = 0;
func->SetArg(arg++, m_gpudata->bvh);
func->SetArg(arg++, m_gpudata->vertices);
func->SetArg(arg++, m_gpudata->faces);
func->SetArg(arg++, rays);
func->SetArg(arg++, numrays);
func->SetArg(arg++, hits);
size_t localsize = kWorkGroupSize;
size_t globalsize = ((maxrays + kWorkGroupSize - 1) / kWorkGroupSize) * kWorkGroupSize;
m_device->Execute(func, queueidx, globalsize, localsize, event);
}
}
| 39.532151
| 219
| 0.557799
|
pribault
|
1023e203202f2245911dbdafd88c511eb1245620
| 26,212
|
cpp
|
C++
|
sdl1/xargon/libgamemusic/mus-tbsa-doofus.cpp
|
pdpdds/sdldualsystem
|
d74ea84cbea705fef62868ba8c693bf7d2555636
|
[
"BSD-2-Clause"
] | null | null | null |
sdl1/xargon/libgamemusic/mus-tbsa-doofus.cpp
|
pdpdds/sdldualsystem
|
d74ea84cbea705fef62868ba8c693bf7d2555636
|
[
"BSD-2-Clause"
] | null | null | null |
sdl1/xargon/libgamemusic/mus-tbsa-doofus.cpp
|
pdpdds/sdldualsystem
|
d74ea84cbea705fef62868ba8c693bf7d2555636
|
[
"BSD-2-Clause"
] | null | null | null |
/**
* @file mus-tbsa-doofus.hpp
* @brief Support for The Bone Shaker Architect used in Doofus.
*
* Copyright (C) 2010-2015 Adam Nielsen <malvineous@shikadi.net>
*
* 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 3 of the License, or
* (at your option) any later version.
*
* 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
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <boost/pointer_cast.hpp>
#include <camoto/iostream_helpers.hpp>
#include <camoto/stream_string.hpp>
#include <camoto/util.hpp>
#include <camoto/gamemusic/eventconverter-midi.hpp> // midiToFreq
#include <camoto/gamemusic/patch-opl.hpp>
#include <camoto/gamemusic/patch-pcm.hpp>
#include <camoto/gamemusic/util-opl.hpp>
#include "mus-tbsa-doofus.hpp"
using namespace camoto;
using namespace camoto::gamemusic;
/// Number of storage channels in TBSA file
#define TBSA_CHANNEL_COUNT 11
/// Fixed module tempo/bpm for all songs (but module 'speed' can change)
#define TBSA_TEMPO 66
/// Number of rows in a normal (full-length) pattern
#define TBSA_PATTERN_LENGTH 63
// Safety limits to avoid infinite loops
#define TBSA_MAX_ORDERS 256
#define TBSA_MAX_INSTS 256
#define TBSA_MAX_PATTS 4096
#define TBSA_MAX_ORD_LEN 256
#define TBSA_MAX_PATSEG_LEN 4096
class EventConverter_TBSA: virtual public EventHandler
{
public:
/// Prepare to convert events into TBSA data sent to a stream.
/**
* @param output
* Output stream the TBSA data will be written to.
*
* @param music
* Song parameters (patches, initial tempo, etc.) Events are not read
* from here, the EventHandler is used for that.
*/
EventConverter_TBSA(stream::output_sptr output, ConstMusicPtr music);
/// Destructor.
virtual ~EventConverter_TBSA();
// EventHandler overrides
virtual void endOfTrack(unsigned long delay);
virtual void endOfPattern(unsigned long delay);
virtual void handleEvent(unsigned long delay, unsigned int trackIndex,
unsigned int patternIndex, const TempoEvent *ev);
virtual void handleEvent(unsigned long delay, unsigned int trackIndex,
unsigned int patternIndex, const NoteOnEvent *ev);
virtual void handleEvent(unsigned long delay, unsigned int trackIndex,
unsigned int patternIndex, const NoteOffEvent *ev);
virtual void handleEvent(unsigned long delay, unsigned int trackIndex,
unsigned int patternIndex, const EffectEvent *ev);
virtual void handleEvent(unsigned long delay, unsigned int trackIndex,
unsigned int patternIndex, const GotoEvent *ev);
virtual void handleEvent(unsigned long delay, unsigned int trackIndex,
unsigned int patternIndex, const ConfigurationEvent *ev);
std::vector<stream::pos> offPatSeg; ///< Offset of each pattern
protected:
stream::output_sptr output; ///< Where to write data
ConstMusicPtr music; ///< Song being written
stream::string_sptr cachedEvent; ///< Event to be written out later
unsigned int cachedDelay; ///< Delay to write before next cachedEvent flush
unsigned int curAdvance; ///< Current advancement amount (rows incremented per event)
uint8_t curVolume; ///< Current volume on this track/channel
uint8_t curPatch; ///< Current instrument on this track/channel
int curFinetune; ///< Current finetune value
/// Write out the current delay
void flushEvent(bool final);
/// Write out a volume-change event
void setVolume(uint8_t newVolume);
};
std::string MusicType_TBSA::getCode() const
{
return "tbsa-doofus";
}
std::string MusicType_TBSA::getFriendlyName() const
{
return "The Bone Shaker Architect";
}
std::vector<std::string> MusicType_TBSA::getFileExtensions() const
{
std::vector<std::string> vcExtensions;
vcExtensions.push_back("bsa");
return vcExtensions;
}
unsigned long MusicType_TBSA::getCaps() const
{
return
InstEmpty
| InstOPL
| HasEvents
| HasPatterns
| HardwareOPL2
;
}
MusicType::Certainty MusicType_TBSA::isInstance(stream::input_sptr input) const
{
input->seekg(0, stream::start);
std::string sig;
input >> fixedLength(sig, 8);
// Invalid signature
// TESTED BY: mus_tbsa_doofus_isinstance_c01
if (sig.compare("TBSA0.01") != 0) return MusicType::DefinitelyNo;
// TESTED BY: mus_tbsa_doofus_isinstance_c00
return MusicType::DefinitelyYes;
}
MusicPtr MusicType_TBSA::read(stream::input_sptr input, SuppData& suppData) const
{
MusicPtr music(new Music());
PatchBankPtr patches(new PatchBank());
music->patches = patches;
// All TBSA files seem to be in 4/4 time?
music->initialTempo.beatsPerBar = 4;
music->initialTempo.beatLength = 4;
music->initialTempo.ticksPerBeat = 2;
music->ticksPerTrack = 64;
for (unsigned int c = 0; c < TBSA_CHANNEL_COUNT; c++) {
TrackInfo t;
if (c < 6) {
t.channelType = TrackInfo::OPLChannel;
t.channelIndex = c;
} else if (c < 11) {
t.channelType = TrackInfo::OPLPercChannel;
t.channelIndex = 4 - (c - 6);
} else {
t.channelType = TrackInfo::UnusedChannel;
t.channelIndex = c - 11;
}
music->trackInfo.push_back(t);
}
input->seekg(8, stream::start);
uint16_t offOrderPtrs, offUnknown2, offUnknown3, offUnknown4, offInstPtrs;
uint16_t offPattPtrs;
input
>> u16le(offOrderPtrs)
>> u16le(offUnknown2)
>> u16le(offUnknown3)
>> u16le(offUnknown4)
>> u16le(offInstPtrs)
>> u16le(offPattPtrs)
;
music->initialTempo.module(6, TBSA_TEMPO);
// Read the order list pointers
std::vector<stream::pos> offOrderLists;
input->seekg(offOrderPtrs, stream::start);
for (unsigned int i = 0; i < TBSA_MAX_ORDERS; i++) {
stream::pos p;
input >> u16le(p);
if (p == 0xFFFF) break;
offOrderLists.push_back(p);
}
// Read the instrument pointers
std::vector<stream::pos> offInsts;
input->seekg(offInstPtrs, stream::start);
for (unsigned int i = 0; i < TBSA_MAX_INSTS; i++) {
stream::pos p;
input >> u16le(p);
if (p == 0xFFFF) break;
offInsts.push_back(p);
}
// Read the pattern-segment pointers
std::vector<stream::pos> offPatts;
input->seekg(offPattPtrs, stream::start);
for (unsigned int i = 0; i < TBSA_MAX_PATTS; i++) {
stream::pos p;
input >> u16le(p);
if (p == 0xFFFF) break;
offPatts.push_back(p);
}
// Read the order pointers
std::vector<stream::pos> offOrders;
for (std::vector<stream::pos>::const_iterator
i = offOrderLists.begin(); i != offOrderLists.end(); i++
) {
input->seekg(*i, stream::start);
uint8_t orderCount, unknown;
input
>> u8(orderCount)
>> u8(unknown)
;
for (unsigned int j = 0; j < orderCount; j++) {
stream::pos p;
input >> u16le(p);
offOrders.push_back(p);
}
}
// Read the instruments
for (std::vector<stream::pos>::const_iterator
i = offInsts.begin(); i != offInsts.end(); i++
) {
input->seekg(*i, stream::start);
uint8_t inst[20];
input->read(inst, 20);
OPLPatchPtr patch(new OPLPatch());
patch->defaultVolume = 255;
patch->m.enableTremolo = inst[9] & 1;
patch->m.enableVibrato = inst[6] & 1;
patch->m.enableSustain = inst[2] & 1;
patch->m.enableKSR = inst[3] & 1;
patch->m.freqMult = inst[4] & 0x0F;
patch->m.scaleLevel = inst[8] & 3;
patch->m.outputLevel = inst[7] + 2;
patch->m.attackRate = inst[0] >> 4;
patch->m.decayRate = inst[0] & 0x0F;
patch->m.sustainRate = inst[1] >> 4;
patch->m.releaseRate = inst[1] & 0x0F;
patch->m.waveSelect = inst[11] & 0x07;
patch->c.enableTremolo = (inst[15] >> 3) & 1; // use overflow from KSR field
patch->c.enableVibrato = (inst[15] >> 2) & 1; // use overflow from KSR field
patch->c.enableSustain = inst[14] & 1;
patch->c.enableKSR = inst[15] & 1;
patch->c.freqMult = inst[16] & 0x0F;
patch->c.scaleLevel = inst[18] & 3;
patch->c.outputLevel = inst[17] + 2;
patch->c.attackRate = inst[12] >> 4;
patch->c.decayRate = inst[12] & 0x0F;
patch->c.sustainRate = inst[13] >> 4;
patch->c.releaseRate = inst[13] & 0x0F;
patch->c.waveSelect = inst[19] & 0x07;
patch->feedback = inst[5] & 0x07;
patch->connection = inst[10] & 1;
patch->rhythm = OPLPatch::Melodic;
patches->push_back(patch);
}
// Read the orders and patterns
std::map<std::string, unsigned int> patternCodes;
bool finished = false;
for (unsigned int order = 0; order < TBSA_MAX_ORD_LEN; order++) {
std::vector<uint8_t> patsegList;
for (std::vector<stream::pos>::const_iterator
i = offOrders.begin(); i != offOrders.end(); i++
) {
input->seekg(*i + order, stream::start);
uint8_t patsegIndex;
input >> u8(patsegIndex);
if (patsegIndex == 0xFE) {
finished = true;
break;
}
patsegList.push_back(patsegIndex);
}
if (finished) break;
// See if this combination of pattern segments has been loaded before
std::string key;
for (std::vector<uint8_t>::const_iterator
p = patsegList.begin(); p != patsegList.end(); p++
) {
key.append((char)*p, 1);
}
std::map<std::string, unsigned int>::const_iterator match = patternCodes.find(key);
if (match != patternCodes.end()) {
// Yes it has, so just reference that pattern instead
music->patternOrder.push_back(match->second);
continue;
}
// No, so add it to the list in case it gets referenced again
unsigned long patternIndex = music->patterns.size();
patternCodes[key] = patternIndex;
music->patternOrder.push_back(patternIndex);
PatternPtr pattern(new Pattern());
music->patterns.push_back(pattern);
// patsegList now contains a list of all the segments, one per track, that
// make up this pattern.
unsigned int trackIndex = 0;
unsigned int patternLength = 0;
for (std::vector<uint8_t>::const_iterator
p = patsegList.begin(); p != patsegList.end(); p++, trackIndex++
) {
if (*p >= offPatts.size()) {
std::cerr << "TBSA: Tried to load pattern segment " << *p
<< " but there are only " << offPatts.size()
<< " segments in the file!";
continue;
}
TrackPtr t(new Track());
pattern->push_back(t);
if ((patternIndex == 0) && (trackIndex == 0)) {
// Set standard settings
// OPL3 is off. We don't add an EnableOPL3 event with the value set
// to zero as that event requires an OPL3 to be present.
{
TrackEvent te;
te.delay = 0;
ConfigurationEvent *ev = new ConfigurationEvent();
te.event.reset(ev);
ev->configType = ConfigurationEvent::EnableDeepTremolo;
ev->value = 0;
t->push_back(te);
}
{
TrackEvent te;
te.delay = 0;
ConfigurationEvent *ev = new ConfigurationEvent();
te.event.reset(ev);
ev->configType = ConfigurationEvent::EnableDeepVibrato;
ev->value = 0;
t->push_back(te);
}
{
TrackEvent te;
te.delay = 0;
ConfigurationEvent *ev = new ConfigurationEvent();
te.event.reset(ev);
ev->configType = ConfigurationEvent::EnableWaveSel;
ev->value = 1;
t->push_back(te);
}
{
TrackEvent te;
te.delay = 0;
ConfigurationEvent *ev = new ConfigurationEvent();
te.event.reset(ev);
ev->configType = ConfigurationEvent::EnableRhythm;
ev->value = 1;
t->push_back(te);
}
}
// Decode the pattern segment
input->seekg(offPatts[*p], stream::start);
int lastVolume = -1, lastInstrument = 0, lastIncrement = 1;
double lastShift = 0.0;
int delay = 0;
bool noteOn = false;
unsigned int patsegLength = 0;
for (int row = 0; row < TBSA_MAX_PATSEG_LEN; row++) {
uint8_t code;
input >> u8(code);
if (code == 0xFF) break;
uint8_t command = code >> 5;
uint8_t value = code & 0x1F;
switch (command) {
case 0: // 0x,1x
case 1: // 2x,3x
case 2: { // 4x,5x: note
TrackEvent te;
te.delay = delay;
patsegLength += delay;
delay = lastIncrement;
NoteOnEvent *ev = new NoteOnEvent();
te.event.reset(ev);
ev->instrument = lastInstrument;
ev->milliHertz = midiToFreq(code+12+lastShift);
ev->velocity = lastVolume;
t->push_back(te);
noteOn = true;
break;
}
//case 3: // 6x,7x: ?
// break;
case 4: // 8x,9x: set instrument
lastInstrument = value;
break;
case 5: // Ax,Bx: set increment
lastIncrement = value + 1;
break;
case 6: // Cx,Dx: set increment
lastIncrement = 32+value + 1;
break;
case 7: // Ex,Fx: ?
switch (code) {
case 0xF4: // fine tune down
case 0xF5:
case 0xF6:
case 0xF7:
case 0xF8:
case 0xF9:
case 0xFA:
case 0xFB:
case 0xFC:
lastShift = 0.1 * (code - 0xFD) * 0.25;
break;
case 0xFD: // set volume
input >> u8(value);
lastVolume = log_volume_to_lin_velocity(value, 127);
if (noteOn) {
TrackEvent te;
te.delay = delay;
patsegLength += delay;
delay = 0;
EffectEvent *ev = new EffectEvent();
te.event.reset(ev);
ev->type = EffectEvent::Volume;
ev->data = lastVolume;
t->push_back(te);
}
break;
case 0xFE: { // note off
TrackEvent te;
te.delay = delay;
patsegLength += delay;
delay = lastIncrement;
NoteOffEvent *ev = new NoteOffEvent();
te.event.reset(ev);
t->push_back(te);
noteOn = false;
break;
}
default:
delay += lastIncrement;
std::cout << "TBSA: Unrecognised extended command: "
<< std::hex << (int)code << std::dec << "\n";
break;
}
break;
default:
std::cout << "TBSA: Unrecognised command: "
<< std::hex << (int)code << std::dec << "\n";
break;
}
} // for each byte in the pattern segment data
// If there's a trailing delay, include it in the calculation of the
// longest pattern length. We don't need to add a dummy event because
// the format is fixed at 64 rows per pattern.
if (delay) {
patsegLength += delay;
delay = 0;
/*
// Put a final placeholder to ensure the track is the correct length
TrackEvent te;
te.delay = delay;
patsegLength += delay;
delay = 0;
ConfigurationEvent *ev = new ConfigurationEvent();
te.event.reset(ev);
t->push_back(te);
*/
}
if (patsegLength > patternLength) patternLength = patsegLength;
} // for each pattern segment
// If this pattern is short, add a pattern-break event
if (patternLength < TBSA_PATTERN_LENGTH) {
TrackPtr t = pattern->at(0);
if (t) {
// Find out how long all the events in the track go for
unsigned int totalDelay = 0;
for (Track::iterator j = t->begin(); j != t->end(); j++) {
TrackEvent& te = *j;
totalDelay += te.delay;
}
// If this assertion fails, then somehow we didn't add up the length of
// the track correctly, as patternLength is supposed to be the largest
// value of all the pattern segment lengths.
assert(patternLength >= totalDelay);
// Now add a pattern break with enough of a delay that it will trigger
// the right amount of time after the last event on this track.
TrackEvent te;
te.delay = patternLength - totalDelay;
GotoEvent *ev = new GotoEvent();
te.event.reset(ev);
ev->type = GotoEvent::NextPattern;
ev->targetRow = 0;
t->push_back(te);
}
}
} // for each entry in the order list
oplDenormalisePerc(music, OPLPerc_CarFromMod);
return music;
}
void MusicType_TBSA::write(stream::output_sptr output, SuppData& suppData,
MusicPtr music, unsigned int flags) const
{
requirePatches<OPLPatch>(music->patches);
if (music->patches->size() >= 31) {
throw bad_patch("TBSA files have a maximum of 31 instruments.");
}
// Swap operators for required percussive patches
PatchBankPtr normPatches = oplNormalisePerc(music, OPLPerc_CarFromMod);
output
<< nullPadded("TBSA0.01", 8)
<< u16le(0xabcd) // placeholder
<< u16le(0xabcd) // placeholder
<< u16le(0xabcd) // placeholder
<< u16le(0xabcd) // placeholder
<< u16le(0xabcd) // placeholder
<< u16le(0xabcd) // placeholder
;
// Order list
stream::pos offOrderPtrs = output->tellp();
output
<< u16le(0xabcd) // placeholder
<< u16le(0xFFFF) // end-of-list
;
// Unknown list 1
stream::pos offUnknown1 = output->tellp();
output << u16le(0xFFFF); // end-of-list
// Unknown list 2
stream::pos offUnknown2 = output->tellp();
output << u16le(0xFFFF); // end-of-list
// Unknown list 3
stream::pos offUnknown3 = output->tellp();
output << u16le(0xFFFF); // end-of-list
// Instrument pointers
stream::pos offInstPtrs = output->tellp();
for (PatchBank::const_iterator i = music->patches->begin(); i != music->patches->end(); i++) {
output << u16le(0xaaaa); // placeholder
}
output << u16le(0xFFFF); // end-of-list
unsigned int numPatterns = music->patterns.size();
unsigned int numTracks = music->patterns[0]->size();
// Pattern segment pointers
stream::pos offPattPtrs = output->tellp();
unsigned long numPatternSegments = numPatterns * numTracks;
for (unsigned int i = 0; i < numPatternSegments; i++) {
output << u16le(0xbbbb); // placeholder
}
output << u16le(0xFFFF); // end-of-list
// Order pointers (which patsegs to play for each track)
stream::pos offOrderList = output->tellp();
output
<< u8(numTracks)
<< u8(0) // unknown
;
for (unsigned int i = 0; i < numTracks; i++) {
output << u16le(0xcccc); // placeholder
}
// Instruments
std::vector<stream::pos> offInsts;
for (PatchBank::const_iterator
i = normPatches->begin(); i != normPatches->end(); i++
) {
const OPLPatch *oplPatch = dynamic_cast<const OPLPatch *>(i->get());
if (!oplPatch) continue;
offInsts.push_back(output->tellp());
uint8_t inst[20];
inst[0] = (oplPatch->m.attackRate << 4) | oplPatch->m.decayRate;
inst[1] = (oplPatch->m.sustainRate << 4) | oplPatch->m.releaseRate;
inst[2] = oplPatch->m.enableSustain ? 1 : 0;
inst[3] = oplPatch->m.enableKSR ? 1 : 0;
inst[4] = oplPatch->m.freqMult;
inst[5] = oplPatch->feedback;
inst[6] = oplPatch->m.enableVibrato;
inst[7] = (oplPatch->m.outputLevel > 2) ? oplPatch->m.outputLevel - 2 : 0;
inst[8] = oplPatch->m.scaleLevel;
inst[9] = oplPatch->m.enableTremolo ? 1 : 0;
inst[10] = oplPatch->connection;
inst[11] = oplPatch->m.waveSelect;
inst[12] = (oplPatch->c.attackRate << 4) | oplPatch->c.decayRate;
inst[13] = (oplPatch->c.sustainRate << 4) | oplPatch->c.releaseRate;
inst[14] = oplPatch->c.enableSustain ? 1 : 0;
inst[15] = oplPatch->c.enableKSR ? 1 : 0;
inst[16] = oplPatch->c.freqMult;
inst[17] = (oplPatch->c.outputLevel > 2) ? oplPatch->c.outputLevel - 2 : 0;
inst[18] = oplPatch->c.scaleLevel;
inst[19] = oplPatch->c.waveSelect;
output->write(inst, 20);
}
// Track order numbers
std::vector<stream::pos> orderPointers;
for (unsigned int trackIndex = 0; trackIndex < numTracks; trackIndex++) {
// Write all the order index numbers for this track
orderPointers.push_back(output->tellp());
for (std::vector<unsigned int>::const_iterator
o = music->patternOrder.begin(); o != music->patternOrder.end(); o++
) {
const unsigned int& patternIndex = *o;
unsigned int targetPatSeg = patternIndex * numTracks + trackIndex;
output << u8(targetPatSeg);
}
output << u8(0xFE);
}
// Write out all the pattern segments
EventConverter_TBSA conv(output, music);
conv.offPatSeg.push_back(output->tellp());
conv.handleAllEvents(EventHandler::Pattern_Track_Row, music);
// Remove last element (it will point to EOF and we don't need to write it)
conv.offPatSeg.pop_back();
output->truncate_here();
// Go back and write out all the file pointers
output->seekp(8, stream::start);
output
<< u16le(offOrderPtrs)
<< u16le(offUnknown1)
<< u16le(offUnknown2)
<< u16le(offUnknown3)
<< u16le(offInstPtrs)
<< u16le(offPattPtrs)
;
output->seekp(offOrderPtrs, stream::start);
output << u16le(offOrderList);
output->seekp(offInstPtrs, stream::start);
for (std::vector<stream::pos>::const_iterator
i = offInsts.begin(); i != offInsts.end(); i++
) {
output << u16le(*i);
}
output->seekp(offOrderList + 2, stream::start);
for (std::vector<stream::pos>::const_iterator
i = orderPointers.begin(); i != orderPointers.end(); i++
) {
output << u16le(*i);
}
output->seekp(offPattPtrs, stream::start);
for (std::vector<stream::pos>::const_iterator
i = conv.offPatSeg.begin(); i != conv.offPatSeg.end(); i++
) {
output << u16le(*i);
}
return;
}
SuppFilenames MusicType_TBSA::getRequiredSupps(stream::input_sptr input,
const std::string& filenameMusic) const
{
// No supplemental types/empty list
return SuppFilenames();
}
Metadata::MetadataTypes MusicType_TBSA::getMetadataList() const
{
// No supported metadata
return Metadata::MetadataTypes();
}
EventConverter_TBSA::EventConverter_TBSA(stream::output_sptr output,
ConstMusicPtr music)
: output(output),
music(music),
cachedEvent(new stream::string),
cachedDelay(0),
curAdvance(255), // These values are all out of range
curVolume(255), // so that they'll get set/written
curPatch(255), // on the first note in the track
curFinetune(0)
{
}
EventConverter_TBSA::~EventConverter_TBSA()
{
}
void EventConverter_TBSA::endOfTrack(unsigned long delay)
{
this->cachedDelay += delay;
this->flushEvent(false);
this->output << u8(0xFF);
this->offPatSeg.push_back(this->output->tellp());
this->cachedDelay = 0;
// Reset for next track. These values are all out of range so the first
// note in the next track will cause the values to be written out to the file.
this->curAdvance = 255;
this->curVolume = 255;
this->curPatch = 255;
this->curFinetune = 0;
return;
}
void EventConverter_TBSA::endOfPattern(unsigned long delay)
{
return;
}
void EventConverter_TBSA::handleEvent(unsigned long delay,
unsigned int trackIndex, unsigned int patternIndex, const TempoEvent *ev)
{
this->cachedDelay += delay;
std::cerr << "TBSA: Does not support tempo changes\n";
return;
}
void EventConverter_TBSA::handleEvent(unsigned long delay,
unsigned int trackIndex, unsigned int patternIndex, const NoteOnEvent *ev)
{
this->cachedDelay += delay;
this->flushEvent(false);
double midiNote = freqToMIDI(ev->milliHertz);
if (midiNote < 12) midiNote = 0;
else if (midiNote > 127) midiNote = 127;
else midiNote -= 12;
// Handle any pitchbend
unsigned int midiNoteMain = ceil(midiNote);
double midiFrac = midiNote - midiNoteMain; // negative
midiFrac *= 40;
int step = round(midiFrac);
assert(step <= 0);
if ((step > -10) && (step < 0) && (step != this->curFinetune)) {
this->output << u8(0xFD + step);
this->curFinetune = step;
}
// Set patch
if (this->curPatch != ev->instrument) {
this->output << u8(0x80 | ev->instrument);
this->curPatch = ev->instrument;
}
assert(ev->velocity < 256);
this->setVolume(ev->velocity); // no-op if there's no change
this->cachedEvent
<< u8(midiNoteMain)
;
return;
}
void EventConverter_TBSA::handleEvent(unsigned long delay,
unsigned int trackIndex, unsigned int patternIndex, const NoteOffEvent *ev)
{
this->cachedDelay += delay;
this->flushEvent(false);
this->cachedEvent
<< u8(0xFE)
;
return;
}
void EventConverter_TBSA::handleEvent(unsigned long delay,
unsigned int trackIndex, unsigned int patternIndex, const EffectEvent *ev)
{
this->cachedDelay += delay;
switch (ev->type) {
case EffectEvent::PitchbendNote:
std::cerr << "TBSA: Pitch bends not supported, ignoring event\n";
break;
case EffectEvent::Volume:
this->setVolume(ev->data);
break;
}
return;
}
void EventConverter_TBSA::handleEvent(unsigned long delay,
unsigned int trackIndex, unsigned int patternIndex, const GotoEvent *ev)
{
this->cachedDelay += delay;
// Not supported by this format?
return;
}
void EventConverter_TBSA::handleEvent(unsigned long delay,
unsigned int trackIndex, unsigned int patternIndex,
const ConfigurationEvent *ev)
{
this->cachedDelay += delay;
switch (ev->configType) {
case ConfigurationEvent::EmptyEvent:
break;
case ConfigurationEvent::EnableOPL3:
if (ev->value != 0) std::cerr << "TBSA: OPL3 cannot be enabled, ignoring event.\n";
break;
case ConfigurationEvent::EnableDeepTremolo:
if (ev->value != 0) std::cerr << "TBSA: Deep tremolo cannot be enabled, ignoring event.\n";
break;
case ConfigurationEvent::EnableDeepVibrato:
if (ev->value != 0) std::cerr << "TBSA: Deep vibrato cannot be enabled, ignoring event.\n";
break;
case ConfigurationEvent::EnableRhythm:
if (ev->value != 0) std::cerr << "TBSA: Rhythm mode cannot be enabled, ignoring event.\n";
break;
case ConfigurationEvent::EnableWaveSel:
if (ev->value != 1) std::cerr << "TBSA: Wave selection registers cannot be disabled, ignoring event.\n";
break;
}
return;
}
void EventConverter_TBSA::flushEvent(bool final)
{
if (this->cachedDelay || final) {
uint8_t steps;
if (this->cachedDelay) steps = this->cachedDelay - 1; else steps = 0;
if (steps > 63) {
throw format_limitation(createString("TBSA: Cannot handle delays of "
"more than 64 rows (tried to write delay of " << this->cachedDelay
<< " rows)."));
}
if (steps != this->curAdvance) {
// Write the new delay before the cached event
if (steps < 32) {
this->output << u8(0xA0 | steps);
} else if (steps < 64) {
this->output << u8(0xC0 | (steps - 32));
}
this->curAdvance = steps;
}
this->cachedDelay = 0;
this->output << *this->cachedEvent->str();
this->cachedEvent->seekp(0, stream::start);
this->cachedEvent->str()->clear();
}
return;
}
void EventConverter_TBSA::setVolume(uint8_t newVolume)
{
newVolume >>= 1; // 0..255 -> 0..127
if (newVolume != this->curVolume) {
this->output
<< u8(0xFD)
<< u8(newVolume)
;
this->curVolume = newVolume;
}
return;
}
| 29.18931
| 107
| 0.665153
|
pdpdds
|
10292738543a5c8c987413807fd5703c56965bfc
| 9,367
|
cpp
|
C++
|
src/matrix.cpp
|
Seemos/simple-neural-network
|
829fb70589e21c2b95cef10322f7c00f367ade98
|
[
"Apache-2.0"
] | 1
|
2020-12-02T17:15:56.000Z
|
2020-12-02T17:15:56.000Z
|
src/matrix.cpp
|
Seemos/simple-neural-network
|
829fb70589e21c2b95cef10322f7c00f367ade98
|
[
"Apache-2.0"
] | null | null | null |
src/matrix.cpp
|
Seemos/simple-neural-network
|
829fb70589e21c2b95cef10322f7c00f367ade98
|
[
"Apache-2.0"
] | null | null | null |
#include <vector>
#include <iostream>
#include <random>
#include <cmath>
#include <assert.h>
#include "matrix.h"
matrix create_matrix(unsigned int n_rows, unsigned int n_cols)
{
matrix mat;
mat.n_cols = n_cols;
mat.n_rows = n_rows;
mat.values.resize(n_rows);
for (unsigned int i = 0; i < n_rows; i++) {
mat.values[i].resize(n_cols);
}
return mat;
}
matrix create_matrix(unsigned int n_rows, unsigned int n_cols, double value)
{
matrix mat;
mat.n_cols = n_cols;
mat.n_rows = n_rows;
mat.values.resize(n_rows);
for (unsigned int i = 0; i < n_rows; i++) {
mat.values[i].resize(n_cols, value);
}
return mat;
}
matrix create_random_matrix(unsigned int n_rows, unsigned int n_cols, double lower_bound, double upper_bound) {
std::uniform_real_distribution<double> distribution (lower_bound, upper_bound);
std::default_random_engine engine;
matrix mat_res = create_matrix(n_rows, n_cols);
for (unsigned i = 0; i < n_rows; i++) {
for (unsigned j = 0; j < n_cols; j++) {
mat_res.values[i][j] = distribution(engine);
}
}
return mat_res;
}
matrix create_matrix_from_vector(const std::vector<std::vector<long double>>& vec) {
unsigned rows = vec.size();
unsigned cols = vec[0].size();
matrix mat_res = create_matrix(rows, cols);
mat_res.values = vec;
return mat_res;
}
matrix diag(const std::vector<long double>& vec) {
unsigned n_rows = vec.size();
matrix mat_res = create_matrix(n_rows, n_rows, 0);
for (unsigned i = 0; i < n_rows; i++) {
mat_res.values[i][i] = vec[i];
}
return mat_res;
}
//----------------------------------------------------
//matrix operations on single matrix
//----------------------------------------------------
matrix transpose(const matrix& mat) {
unsigned rows = mat.n_rows;
unsigned cols = mat.n_cols;
matrix mat_res = create_matrix(cols, rows);
for (unsigned i = 0; i < cols; i++) {
for (unsigned j = 0; j < rows; j++) {
mat_res.values[i][j] = mat.values[j][i];
}
}
return mat_res;
}
matrix pow(const matrix& mat, double exponent) {
matrix mat_res = mat;
for (unsigned i = 0; i < mat.n_rows; i++) {
for (unsigned j = 0; j < mat.n_cols; j++)
{
mat_res.values[i][j] = pow(mat_res.values[i][j], exponent);
}
}
return mat_res;
}
long double trace(const matrix& mat) {
double val_traced = 0;
unsigned rows = mat.n_rows;
unsigned cols = mat.n_cols;
if (cols < rows) {
for (unsigned i = 0; i < cols; i++) {
val_traced += mat.values[i][i];
}
}
else
{
for (unsigned i = 0; i < rows; i++) {
val_traced += mat.values[i][i];
}
}
return val_traced;
}
long double frobenius_norm(const matrix& mat) {
long double norm = 0;
for (unsigned i = 0; i < mat.n_rows; i++) {
for (unsigned j = 0; j < mat.n_cols; j++) {
norm += pow(mat.values[i][j], 2);
}
}
return sqrt(norm);
}
//----------------------------------------------------
//matrix and matrix operators
//----------------------------------------------------
matrix dot(const matrix& mat_left, const matrix& mat_right) {
unsigned rows = mat_left.n_rows;
unsigned cols = mat_right.n_cols;
unsigned lost_dim = mat_right.n_rows;
matrix mat_res = create_matrix(rows, cols);
for (unsigned i = 0; i < rows; ++i) {
for (unsigned j = 0; j < cols; ++j) {
for (unsigned k = 0; k < lost_dim; ++k) {
mat_res.values[i][j] += mat_left.values[i][k] * mat_right.values[k][j];
}
}
}
return mat_res;
}
matrix operator+ (const matrix& mat_left, const matrix& mat_right) {
unsigned rows = mat_left.n_rows;
unsigned cols = mat_left.n_cols;
matrix mat_res = create_matrix(rows, cols);
for (unsigned int i = 0; i < rows; i++) {
for (unsigned int j = 0; j < cols; j++) {
mat_res.values[i][j] = mat_left.values[i][j] + mat_right.values[i][j];
}
}
return mat_res;
}
matrix operator- (const matrix& mat_left, const matrix& mat_right) {
unsigned rows = mat_left.n_rows;
unsigned cols = mat_left.n_cols;
matrix mat_res = create_matrix(rows, cols);
for (unsigned int i = 0; i < rows; i++) {
for (unsigned int j = 0; j < cols; j++) {
mat_res.values[i][j] = mat_left.values[i][j] - mat_right.values[i][j];
}
}
return mat_res;
}
matrix operator/ (const matrix& mat_left, const matrix& mat_right) {
unsigned rows = mat_left.n_rows;
unsigned cols = mat_left.n_cols;
matrix mat_res = create_matrix(rows, cols);
for (unsigned int i = 0; i < rows; i++) {
for (unsigned int j = 0; j < cols; j++) {
mat_res.values[i][j] = mat_left.values[i][j] / mat_right.values[i][j];
}
}
return mat_res;
}
matrix operator* (const matrix& mat_left, const matrix& mat_right) {
matrix mat_res = mat_left;
for (unsigned i = 0; i < mat_left.n_rows; ++i) {
for (unsigned j = 0; j < mat_left.n_cols; ++j) {
mat_res.values[i][j] *= mat_right.values[i][j];
}
}
return mat_res;
}
void operator+= (matrix& mat_left, const matrix& mat_right) {
unsigned rows = mat_left.n_rows;
unsigned cols = mat_left.n_cols;
for (unsigned i = 0; i < rows; i++) {
for (unsigned j = 0; j < cols; j++) {
mat_left.values[i][j] += mat_right.values[i][j];
}
}
}
void operator-= (matrix& mat_left, const matrix& mat_right) {
unsigned rows = mat_left.n_rows;
unsigned cols = mat_left.n_cols;
for (unsigned i = 0; i < rows; i++) {
for (unsigned j = 0; j < cols; j++) {
mat_left.values[i][j] -= mat_right.values[i][j];
}
}
}
void operator/= (matrix& mat_left, const matrix& mat_right) {
unsigned rows = mat_left.n_rows;
unsigned cols = mat_left.n_cols;
for (unsigned i = 0; i < rows; i++) {
for (unsigned j = 0; j < cols; j++) {
mat_left.values[i][j] /= mat_right.values[i][j];
}
}
}
//----------------------------------------------------
//matrix and vector operators
//----------------------------------------------------
matrix operator+ (const matrix& mat, const std::vector<long double>& vec) {
unsigned rows = mat.n_rows;
unsigned cols = mat.n_cols;
matrix mat_res = create_matrix(rows, cols);
for (unsigned int i = 0; i < rows; i++) {
for (unsigned int j = 0; j < cols; j++) {
mat_res.values[i][j] = mat.values[i][j] + vec[i];
}
}
return mat_res;
}
matrix operator- (const matrix& mat, const std::vector<long double>& vec) {
unsigned rows = mat.n_rows;
unsigned cols = mat.n_cols;
matrix mat_res = create_matrix(rows, cols);
for (unsigned int i = 0; i < rows; i++) {
for (unsigned int j = 0; j < cols; j++) {
mat_res.values[i][j] = mat.values[i][j] - vec[i];
}
}
return mat_res;
}
matrix operator* (const matrix& mat, const std::vector<long double>& vec) {
unsigned rows = mat.n_rows;
unsigned cols = mat.n_cols;
matrix mat_res = create_matrix(rows, cols);
for (unsigned int i = 0; i < rows; i++) {
for (unsigned int j = 0; j < cols; j++) {
mat_res.values[i][j] = mat.values[i][j] * vec[j];
}
}
return mat_res;
}
matrix operator/ (const matrix& mat, const std::vector<long double>& vec) {
unsigned rows = mat.n_rows;
unsigned cols = mat.n_cols;
matrix mat_res = create_matrix(rows, cols);
for (unsigned int i = 0; i < rows; i++) {
for (unsigned int j = 0; j < cols; j++) {
mat_res.values[i][j] = mat.values[i][j] / vec[i];
}
}
return mat_res;
}
//----------------------------------------------------
//matrix and scalar operators
//----------------------------------------------------
matrix operator+ (const matrix& mat, const long double scalar) {
unsigned rows = mat.n_rows;
unsigned cols = mat.n_cols;
matrix mat_res = mat;
for (unsigned int i = 0; i < rows; i++) {
for (unsigned int j = 0; j < cols; j++) {
mat_res.values[i][j] += scalar;
}
}
return mat_res;
}
matrix operator- (const matrix& mat, const long double scalar) {
unsigned rows = mat.n_rows;
unsigned cols = mat.n_cols;
matrix mat_res = mat;
for (unsigned int i = 0; i < rows; i++) {
for (unsigned int j = 0; j < cols; j++) {
mat_res.values[i][j] -= scalar;
}
}
return mat_res;
}
matrix operator* (const matrix& mat, const long double scalar) {
unsigned rows = mat.n_rows;
unsigned cols = mat.n_cols;
matrix mat_res = mat;
for (unsigned int i = 0; i < rows; i++) {
for (unsigned int j = 0; j < cols; j++) {
mat_res.values[i][j] *= scalar;
}
}
return mat_res;
}
matrix operator/ (const matrix& mat, const long double scalar) {
unsigned rows = mat.n_rows;
unsigned cols = mat.n_cols;
matrix mat_res = mat;
for (unsigned int i = 0; i < rows; i++) {
for (unsigned int j = 0; j < cols; j++) {
mat_res.values[i][j] /= scalar;
}
}
return mat_res;
}
matrix apply_function(const matrix& mat, long double(*function)(long double)) {
unsigned rows = mat.n_rows;
unsigned cols = mat.n_cols;
matrix mat_res = mat;
for (unsigned i = 0; i < rows; i++) {
for (unsigned j = 0; j < cols; j++) {
mat_res.values[i][j] = function(mat_res.values[i][j]);
}
}
return mat_res;
}
void print_matrix(const matrix& ref)
{
for (unsigned int i = 0; i < ref.n_rows; ++i) {
for (unsigned int j = 0; j < ref.n_cols; ++j) {
std::cout << ref.values[i][j] << ", ";
}
std::cout << std::endl;
}
}
| 25.316216
| 112
| 0.585246
|
Seemos
|
102927980e657195300e6ac9afd2eeba47b810cb
| 28,760
|
cpp
|
C++
|
src/openms/source/ANALYSIS/OPENSWATH/MRMFeatureFinderScoring.cpp
|
kreinert/OpenMS
|
45455356482ce5ab35e32e445609b291ec78a6d6
|
[
"Zlib",
"Apache-2.0"
] | 1
|
2016-12-09T01:45:03.000Z
|
2016-12-09T01:45:03.000Z
|
src/openms/source/ANALYSIS/OPENSWATH/MRMFeatureFinderScoring.cpp
|
kreinert/OpenMS
|
45455356482ce5ab35e32e445609b291ec78a6d6
|
[
"Zlib",
"Apache-2.0"
] | null | null | null |
src/openms/source/ANALYSIS/OPENSWATH/MRMFeatureFinderScoring.cpp
|
kreinert/OpenMS
|
45455356482ce5ab35e32e445609b291ec78a6d6
|
[
"Zlib",
"Apache-2.0"
] | null | null | null |
// --------------------------------------------------------------------------
// OpenMS -- Open-Source Mass Spectrometry
// --------------------------------------------------------------------------
// Copyright The OpenMS Team -- Eberhard Karls University Tuebingen,
// ETH Zurich, and Freie Universitaet Berlin 2002-2013.
//
// This software is released under a three-clause BSD license:
// * 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 any author or any participating institution
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
// For a full list of authors, refer to the file AUTHORS.
// --------------------------------------------------------------------------
// 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 ANY OF THE AUTHORS OR THE CONTRIBUTING
// INSTITUTIONS 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.
//
// --------------------------------------------------------------------------
// $Maintainer: Hannes Roest $
// $Authors: Hannes Roest $
// --------------------------------------------------------------------------
#include <OpenMS/ANALYSIS/OPENSWATH/MRMFeatureFinderScoring.h>
#include <OpenMS/ANALYSIS/OPENSWATH/DATAACCESS/DataAccessHelper.h>
// data access
#include <OpenMS/ANALYSIS/OPENSWATH/DATAACCESS/SimpleOpenMSSpectraAccessFactory.h>
#include <OpenMS/ANALYSIS/OPENSWATH/DATAACCESS/MRMFeatureAccessOpenMS.h>
#include <OpenMS/ANALYSIS/OPENSWATH/DATAACCESS/DataAccessHelper.h>
// peak picking & noise estimation
#include <OpenMS/FILTERING/NOISEESTIMATION/SignalToNoiseEstimatorMedian.h>
#include <OpenMS/ANALYSIS/OPENSWATH/MRMTransitionGroupPicker.h>
#define run_identifier "unique_run_identifier"
bool SortDoubleDoublePairFirst(const std::pair<double, double>& left, const std::pair<double, double>& right)
{
return left.first < right.first;
}
namespace OpenMS
{
MRMFeatureFinderScoring::MRMFeatureFinderScoring() :
DefaultParamHandler("MRMFeatureFinderScoring"),
ProgressLogger()
{
defaults_.setValue("stop_report_after_feature", -1, "Stop reporting after feature (ordered by quality; -1 means do not stop).");
defaults_.setValue("rt_extraction_window", -1.0, "Only extract RT around this value (-1 means extract over the whole range, a value of 500 means to extract around +/- 500 s of the expected elution). For this to work, the TraML input file needs to contain normalized RT values.");
defaults_.setValue("rt_normalization_factor", 1.0, "The normalized RT is expected to be between 0 and 1. If your normalized RT has a different range, pass this here (e.g. it goes from 0 to 100, set this value to 100)");
defaults_.setValue("quantification_cutoff", 0.0, "Cutoff below which peaks should not be used for quantification any more", ListUtils::create<String>("advanced"));
defaults_.setMinFloat("quantification_cutoff", 0.0);
defaults_.setValue("write_convex_hull", "false", "Whether to write out all points of all features into the featureXML", ListUtils::create<String>("advanced"));
defaults_.setValidStrings("write_convex_hull", ListUtils::create<String>("true,false"));
defaults_.setValue("add_up_spectra", 1, "Add up spectra around the peak apex (needs to be a non-even integer)", ListUtils::create<String>("advanced"));
defaults_.setMinInt("add_up_spectra", 1);
defaults_.setValue("spacing_for_spectra_resampling", 0.005, "If spectra are to be added, use this spacing to add them up", ListUtils::create<String>("advanced"));
defaults_.setMinFloat("spacing_for_spectra_resampling", 0.0);
defaults_.insert("TransitionGroupPicker:", MRMTransitionGroupPicker().getDefaults());
defaults_.insert("DIAScoring:", DIAScoring().getDefaults());
defaults_.insert("EMGScoring:", EmgScoring().getDefaults());
// One can turn on / off each score individually
Param scores_to_use;
scores_to_use.setValue("use_shape_score", "true", "Use the shape score (this score measures the similarity in shape of the transitions using a cross-correlation)", ListUtils::create<String>("advanced"));
scores_to_use.setValidStrings("use_shape_score", ListUtils::create<String>("true,false"));
scores_to_use.setValue("use_coelution_score", "true", "Use the coelution score (this score measures the similarity in coelution of the transitions using a cross-correlation)", ListUtils::create<String>("advanced"));
scores_to_use.setValidStrings("use_coelution_score", ListUtils::create<String>("true,false"));
scores_to_use.setValue("use_rt_score", "true", "Use the retention time score (this score measure the difference in retention time)", ListUtils::create<String>("advanced"));
scores_to_use.setValidStrings("use_rt_score", ListUtils::create<String>("true,false"));
scores_to_use.setValue("use_library_score", "true", "Use the library score", ListUtils::create<String>("advanced"));
scores_to_use.setValidStrings("use_library_score", ListUtils::create<String>("true,false"));
scores_to_use.setValue("use_elution_model_score", "true", "Use the elution model (EMG) score (this score fits a gaussian model to the peak and checks the fit)", ListUtils::create<String>("advanced"));
scores_to_use.setValidStrings("use_elution_model_score", ListUtils::create<String>("true,false"));
scores_to_use.setValue("use_intensity_score", "true", "Use the intensity score", ListUtils::create<String>("advanced"));
scores_to_use.setValidStrings("use_intensity_score", ListUtils::create<String>("true,false"));
scores_to_use.setValue("use_nr_peaks_score", "true", "Use the number of peaks score", ListUtils::create<String>("advanced"));
scores_to_use.setValidStrings("use_nr_peaks_score", ListUtils::create<String>("true,false"));
scores_to_use.setValue("use_total_xic_score", "true", "Use the total XIC score", ListUtils::create<String>("advanced"));
scores_to_use.setValidStrings("use_total_xic_score", ListUtils::create<String>("true,false"));
scores_to_use.setValue("use_sn_score", "true", "Use the SN (signal to noise) score", ListUtils::create<String>("advanced"));
scores_to_use.setValidStrings("use_sn_score", ListUtils::create<String>("true,false"));
scores_to_use.setValue("use_dia_scores", "true", "Use the DIA (SWATH) scores", ListUtils::create<String>("advanced"));
scores_to_use.setValidStrings("use_dia_scores", ListUtils::create<String>("true,false"));
defaults_.insert("Scores:", scores_to_use);
// write defaults into Param object param_
defaultsToParam_();
strict_ = true;
}
MRMFeatureFinderScoring::~MRMFeatureFinderScoring()
{
}
void MRMFeatureFinderScoring::pickExperiment(MSExperiment<Peak1D> & chromatograms,
FeatureMap<Feature>& output, TargetedExperiment& transition_exp_,
TransformationDescription trafo, MSExperiment<Peak1D>& swath_map)
{
OpenSwath::LightTargetedExperiment transition_exp;
OpenSwathDataAccessHelper::convertTargetedExp(transition_exp_, transition_exp);
TransitionGroupMapType transition_group_map;
boost::shared_ptr<MSExperiment<Peak1D> > sh_chromatograms = boost::make_shared<MSExperiment<Peak1D> >(chromatograms);
boost::shared_ptr<MSExperiment<Peak1D> > sh_swath_map = boost::make_shared<MSExperiment<Peak1D> >(swath_map);
OpenSwath::SpectrumAccessPtr chromatogram_ptr = SimpleOpenMSSpectraFactory::getSpectrumAccessOpenMSPtr(sh_chromatograms);
OpenSwath::SpectrumAccessPtr empty_swath_ptr = SimpleOpenMSSpectraFactory::getSpectrumAccessOpenMSPtr(sh_swath_map);
pickExperiment(chromatogram_ptr, output, transition_exp, trafo, empty_swath_ptr, transition_group_map);
}
void MRMFeatureFinderScoring::pickExperiment(OpenSwath::SpectrumAccessPtr input,
FeatureMap<Feature>& output, OpenSwath::LightTargetedExperiment& transition_exp,
TransformationDescription trafo, OpenSwath::SpectrumAccessPtr swath_map,
TransitionGroupMapType& transition_group_map)
{
updateMembers_();
//
// Step 1
//
// Store the peptide retention times in an intermediate map
prepareProteinPeptideMaps_(transition_exp);
// Store the proteins from the input in the output feature map
std::vector<ProteinHit> protein_hits;
for (Size i = 0; i < transition_exp.getProteins().size(); i++)
{
const ProteinType& prot = transition_exp.getProteins()[i];
ProteinHit prot_hit = ProteinHit();
prot_hit.setSequence(prot.sequence);
prot_hit.setAccession(prot.id);
protein_hits.push_back(prot_hit);
}
ProteinIdentification prot_id = ProteinIdentification();
prot_id.setHits(protein_hits);
prot_id.setIdentifier(run_identifier);
output.getProteinIdentifications().push_back(prot_id);
//
// Step 2
//
// Create all MRM transition groups from the individual transitions.
mapExperimentToTransitionList(input, transition_exp, transition_group_map, trafo, rt_extraction_window_);
int counter = 0;
for (TransitionGroupMapType::iterator trgroup_it = transition_group_map.begin(); trgroup_it != transition_group_map.end(); trgroup_it++)
{
if (trgroup_it->second.getChromatograms().size() > 0) {counter++; }
}
std::cout << "Will analyse " << counter << " peptides with a total of " << transition_exp.getTransitions().size() << " transitions " << std::endl;
//
// Step 3
//
// Go through all transition groups: first create consensus features, then score them
Size progress = 0;
startProgress(0, transition_group_map.size(), "picking peaks");
for (TransitionGroupMapType::iterator trgroup_it = transition_group_map.begin(); trgroup_it != transition_group_map.end(); trgroup_it++)
{
setProgress(++progress);
MRMTransitionGroupType& transition_group = trgroup_it->second;
if (transition_group.getChromatograms().size() == 0 || transition_group.getTransitions().size() == 0)
{
continue;
}
MRMTransitionGroupPicker trgroup_picker;
trgroup_picker.setParameters(param_.copy("TransitionGroupPicker:", true));
trgroup_picker.pickTransitionGroup(transition_group);
scorePeakgroups(trgroup_it->second, trafo, swath_map, output);
}
endProgress();
//output.sortByPosition(); // if the exact same order is needed
return;
}
void MRMFeatureFinderScoring::prepareProteinPeptideMaps_(OpenSwath::LightTargetedExperiment& transition_exp)
{
for (Size i = 0; i < transition_exp.getPeptides().size(); i++)
{
PeptideRefMap_[transition_exp.getPeptides()[i].id] = &transition_exp.getPeptides()[i];
}
for (Size i = 0; i < transition_exp.getProteins().size(); i++)
{
ProteinRefMap_[transition_exp.getProteins()[i].id] = &transition_exp.getProteins()[i];
}
}
void MRMFeatureFinderScoring::scorePeakgroups(MRMTransitionGroupType& transition_group,
TransformationDescription & trafo, OpenSwath::SpectrumAccessPtr swath_map,
FeatureMap<Feature>& output)
{
typedef MRMTransitionGroupType::PeakType PeakT;
std::vector<OpenSwath::ISignalToNoisePtr> signal_noise_estimators;
std::vector<MRMFeature> feature_list;
DoubleReal sn_win_len_ = (DoubleReal)param_.getValue("TransitionGroupPicker:PeakPickerMRM:sn_win_len");
unsigned int sn_bin_count_ = (unsigned int)param_.getValue("TransitionGroupPicker:PeakPickerMRM:sn_bin_count");
for (Size k = 0; k < transition_group.getChromatograms().size(); k++)
{
OpenSwath::ISignalToNoisePtr snptr(new OpenMS::SignalToNoiseOpenMS< PeakT >(transition_group.getChromatograms()[k], sn_win_len_, sn_bin_count_));
signal_noise_estimators.push_back(snptr);
}
const PeptideType* pep = PeptideRefMap_[transition_group.getTransitionGroupID()];
String protein_id = "";
if (!pep->protein_ref.empty())
{
protein_id = ProteinRefMap_[pep->protein_ref]->id;
}
// get the expected rt value for this peptide
double expected_rt = pep->rt;
TransformationDescription newtr = trafo;
newtr.invert();
expected_rt = newtr.apply(expected_rt);
OpenSwathScoring scorer;
scorer.initialize(rt_normalization_factor_, add_up_spectra_, spacing_for_spectra_resampling_, su_);
// Go through all peak groups (found MRM features) and score them
for (std::vector<MRMFeature>::iterator mrmfeature = transition_group.getFeaturesMuteable().begin();
mrmfeature != transition_group.getFeaturesMuteable().end(); mrmfeature++)
{
OpenSwath::IMRMFeature* imrmfeature;
imrmfeature = new MRMFeatureOpenMS(*mrmfeature);
LOG_DEBUG << "scoring feature " << (*mrmfeature) << " == " << mrmfeature->getMetaValue("PeptideRef") <<
" [ expected RT " << PeptideRefMap_[mrmfeature->getMetaValue("PeptideRef")]->rt << " / " << expected_rt << " ]" <<
" with " << transition_group.size() << " nr transitions and nr chromats " << transition_group.getChromatograms().size() << std::endl;
int group_size = boost::numeric_cast<int>(transition_group.size());
if (group_size == 0)
{
throw Exception::IllegalArgument(__FILE__, __LINE__, __PRETTY_FUNCTION__,
"Error: Transition group " + transition_group.getTransitionGroupID() + " has no chromatograms.");
}
if (group_size < 2)
{
LOG_ERROR << "Error: Transition group " << transition_group.getTransitionGroupID()
<< " has only one chromatogram." << std::endl;
delete imrmfeature; // free resources before continuing
continue;
}
///////////////////////////////////
// Call the scoring
///////////////////////////////////
std::vector<double> normalized_library_intensity;
transition_group.getLibraryIntensity(normalized_library_intensity);
OpenSwath::Scoring::normalize_sum(&normalized_library_intensity[0], boost::numeric_cast<int>(normalized_library_intensity.size()));
std::vector<std::string> native_ids;
for (Size i = 0; i < transition_group.size(); i++)
{
native_ids.push_back(transition_group.getTransitions()[i].getNativeID());
}
OpenSwath_Scores scores;
scorer.calculateChromatographicScores(imrmfeature, native_ids, normalized_library_intensity,
signal_noise_estimators, scores);
double normalized_experimental_rt = trafo.apply(imrmfeature->getRT());
scorer.calculateLibraryScores(imrmfeature, transition_group.getTransitions(), *pep, normalized_experimental_rt, scores);
if (swath_map->getNrSpectra() > 0 && su_.use_dia_scores_)
{
scorer.calculateDIAScores(imrmfeature, transition_group.getTransitions(),
swath_map, diascoring_, *pep, scores);
}
if (su_.use_coelution_score_) {
mrmfeature->addScore("var_xcorr_coelution", scores.xcorr_coelution_score);
mrmfeature->addScore("var_xcorr_coelution_weighted", scores.weighted_coelution_score); }
if (su_.use_shape_score_) {
mrmfeature->addScore("var_xcorr_shape", scores.xcorr_shape_score);
mrmfeature->addScore("var_xcorr_shape_weighted", scores.weighted_xcorr_shape); }
if (su_.use_library_score_) {
mrmfeature->addScore("var_library_corr", scores.library_corr);
mrmfeature->addScore("var_library_rmsd", scores.library_norm_manhattan);
mrmfeature->addScore("var_library_sangle", scores.library_sangle);
mrmfeature->addScore("var_library_rootmeansquare", scores.library_rootmeansquare);
mrmfeature->addScore("var_library_manhattan", scores.library_manhattan);
mrmfeature->addScore("var_library_dotprod", scores.library_dotprod);
}
if (su_.use_rt_score_) {
mrmfeature->addScore("delta_rt", mrmfeature->getRT() - expected_rt);
mrmfeature->addScore("assay_rt", expected_rt);
mrmfeature->addScore("norm_RT", scores.normalized_experimental_rt);
mrmfeature->addScore("rt_score", scores.raw_rt_score);
mrmfeature->addScore("var_norm_rt_score", scores.norm_rt_score); }
// TODO do we really want these intensity scores ?
if (su_.use_intensity_score_) { mrmfeature->addScore("var_intensity_score", mrmfeature->getIntensity() / (double)mrmfeature->getMetaValue("total_xic")); }
if (su_.use_total_xic_score_) { mrmfeature->addScore("total_xic", (double)mrmfeature->getMetaValue("total_xic")); }
if (su_.use_nr_peaks_score_) { mrmfeature->addScore("nr_peaks", scores.nr_peaks); }
if (su_.use_sn_score_) { mrmfeature->addScore("sn_ratio", scores.sn_ratio); mrmfeature->addScore("var_log_sn_score", scores.log_sn_score); }
// TODO get it working with imrmfeature
if (su_.use_elution_model_score_) {
scores.elution_model_fit_score = emgscoring_.calcElutionFitScore((*mrmfeature), transition_group);
mrmfeature->addScore("var_elution_model_fit_score", scores.elution_model_fit_score); }
double xx_lda_prescore = -scores.calculate_lda_prescore(scores);
bool swath_present = (swath_map->getNrSpectra() > 0);
if (!swath_present)
{
mrmfeature->addScore("main_var_xx_lda_prelim_score", xx_lda_prescore);
mrmfeature->setOverallQuality(xx_lda_prescore);
}
else
{
mrmfeature->addScore("xx_lda_prelim_score", xx_lda_prescore);
}
// Add the DIA / SWATH scores
if (swath_present && su_.use_dia_scores_)
{
mrmfeature->addScore("var_isotope_correlation_score", scores.isotope_correlation);
mrmfeature->addScore("var_isotope_overlap_score", scores.isotope_overlap);
mrmfeature->addScore("var_massdev_score", scores.massdev_score);
mrmfeature->addScore("var_massdev_score_weighted", scores.weighted_massdev_score);
mrmfeature->addScore("var_bseries_score", scores.bseries_score);
mrmfeature->addScore("var_yseries_score", scores.yseries_score);
mrmfeature->addScore("var_dotprod_score", scores.dotprod_score_dia);
mrmfeature->addScore("var_manhatt_score", scores.manhatt_score_dia);
double xx_swath_prescore = -scores.calculate_swath_lda_prescore(scores);
mrmfeature->addScore("main_var_xx_swath_prelim_score", xx_swath_prescore);
mrmfeature->setOverallQuality(xx_swath_prescore);
}
///////////////////////////////////////////////////////////////////////////
// add the peptide hit information to the feature
///////////////////////////////////////////////////////////////////////////
PeptideIdentification pep_id_ = PeptideIdentification();
PeptideHit pep_hit_ = PeptideHit();
if (pep->getChargeState() != -1)
{
pep_hit_.setCharge(pep->getChargeState());
}
pep_hit_.setScore(xx_lda_prescore);
if (swath_present)
{
pep_hit_.setScore(mrmfeature->getScore("xx_swath_prelim_score"));
}
pep_hit_.setSequence(AASequence(pep->sequence));
pep_hit_.addProteinAccession(protein_id);
pep_id_.insertHit(pep_hit_);
pep_id_.setIdentifier(run_identifier);
mrmfeature->getPeptideIdentifications().push_back(pep_id_);
mrmfeature->ensureUniqueId();
mrmfeature->setMetaValue("PrecursorMZ", transition_group.getTransitions()[0].getPrecursorMZ());
mrmfeature->setSubordinates(mrmfeature->getFeatures()); // add all the subfeatures as subordinates
double total_intensity = 0, total_peak_apices = 0;
for (std::vector<Feature>::iterator sub_it = mrmfeature->getSubordinates().begin(); sub_it != mrmfeature->getSubordinates().end(); sub_it++)
{
if (!write_convex_hull_) {sub_it->getConvexHulls().clear(); }
sub_it->ensureUniqueId();
if (sub_it->getMZ() > quantification_cutoff_)
{
total_intensity += sub_it->getIntensity();
total_peak_apices += (DoubleReal)sub_it->getMetaValue("peak_apex_int");
}
}
// overwrite the reported intensities with those above the m/z cutoff
mrmfeature->setIntensity(total_intensity);
mrmfeature->setMetaValue("peak_apices_sum", total_peak_apices);
feature_list.push_back((*mrmfeature));
delete imrmfeature;
}
// Order by quality
std::sort(feature_list.begin(), feature_list.end(), OpenMS::Feature::OverallQualityLess());
std::reverse(feature_list.begin(), feature_list.end());
for (Size i = 0; i < feature_list.size(); i++)
{
if (stop_report_after_feature_ >= 0 && i >= (Size)stop_report_after_feature_) {break;}
output.push_back(feature_list[i]);
}
}
void MRMFeatureFinderScoring::updateMembers_()
{
stop_report_after_feature_ = (int)param_.getValue("stop_report_after_feature");
rt_extraction_window_ = (DoubleReal)param_.getValue("rt_extraction_window");
rt_normalization_factor_ = (DoubleReal)param_.getValue("rt_normalization_factor");
quantification_cutoff_ = (DoubleReal)param_.getValue("quantification_cutoff");
write_convex_hull_ = param_.getValue("write_convex_hull").toBool();
add_up_spectra_ = param_.getValue("add_up_spectra");
spacing_for_spectra_resampling_ = param_.getValue("spacing_for_spectra_resampling");
diascoring_.setParameters(param_.copy("DIAScoring:", true));
emgscoring_.setFitterParam(param_.copy("EmgScoring:", true));
su_.use_coelution_score_ = param_.getValue("Scores:use_coelution_score").toBool();
su_.use_shape_score_ = param_.getValue("Scores:use_shape_score").toBool();
su_.use_rt_score_ = param_.getValue("Scores:use_rt_score").toBool();
su_.use_library_score_ = param_.getValue("Scores:use_library_score").toBool();
su_.use_elution_model_score_ = param_.getValue("Scores:use_elution_model_score").toBool();
su_.use_intensity_score_ = param_.getValue("Scores:use_intensity_score").toBool();
su_.use_total_xic_score_ = param_.getValue("Scores:use_total_xic_score").toBool();
su_.use_nr_peaks_score_ = param_.getValue("Scores:use_nr_peaks_score").toBool();
su_.use_sn_score_ = param_.getValue("Scores:use_sn_score").toBool();
su_.use_dia_scores_ = param_.getValue("Scores:use_dia_scores").toBool();
}
void MRMFeatureFinderScoring::mapExperimentToTransitionList(OpenSwath::SpectrumAccessPtr input,
TargetedExpType& transition_exp, TransitionGroupMapType& transition_group_map,
TransformationDescription trafo, double rt_extraction_window)
{
double rt_min, rt_max, expected_rt;
trafo.invert();
std::map<String, int> chromatogram_map;
Size nr_chromatograms = input->getNrChromatograms();
for (Size i = 0; i < input->getNrChromatograms(); i++)
{
chromatogram_map[input->getChromatogramNativeID(i)] = boost::numeric_cast<int>(i);
}
// Iterate thorugh all transitions and store the transition with the
// corresponding chromatogram in the corresponding transition group
Size progress = 0;
startProgress(0, nr_chromatograms, "Mapping transitions to chromatograms ");
for (Size i = 0; i < transition_exp.getTransitions().size(); i++)
{
// get the current transition and try to find the corresponding chromatogram
const TransitionType* transition = &transition_exp.getTransitions()[i];
if (chromatogram_map.find(transition->getNativeID()) == chromatogram_map.end())
{
std::cerr << "Error: Transition " + transition->getNativeID() + " from group " +
transition->getPeptideRef() + " does not have a corresponding chromatogram" << std::endl;
if (strict_)
{
throw Exception::IllegalArgument(__FILE__, __LINE__, __PRETTY_FUNCTION__,
"Error: Transition " + transition->getNativeID() + " from group " +
transition->getPeptideRef() + " does not have a corresponding chromatogram");
}
continue;
}
MSChromatogram<ChromatogramPeak> chromatogram_old;
OpenSwath::ChromatogramPtr cptr = input->getChromatogramById(chromatogram_map[transition->getNativeID()]);
OpenSwathDataAccessHelper::convertToOpenMSChromatogram(chromatogram_old, cptr);
RichPeakChromatogram chromatogram;
// Create the chromatogram information
// Get the expected retention time, apply the RT-transformation
// (which describes the normalization) and then take the difference.
// Note that we inverted the transformation in the beginning because
// we want to transform from normalized to real RTs here and not the
// other way round.
rt_max = rt_min = 0;
expected_rt = PeptideRefMap_[transition->getPeptideRef()]->rt;
double de_normalized_experimental_rt = trafo.apply(expected_rt);
rt_max = de_normalized_experimental_rt + rt_extraction_window;
rt_min = de_normalized_experimental_rt - rt_extraction_window;
for (MSChromatogram<ChromatogramPeak>::const_iterator it = chromatogram_old.begin(); it != chromatogram_old.end(); ++it)
{
if (rt_extraction_window >= 0 && (it->getRT() < rt_min || it->getRT() > rt_max))
{
continue;
}
ChromatogramPeak peak;
peak.setMZ(it->getRT());
peak.setIntensity(it->getIntensity());
chromatogram.push_back(peak);
}
if (chromatogram.empty())
{
std::cerr << "Error: Could not find any points for chromatogram " + transition->getNativeID() + \
". Maybe your retention time transformation is off?" << std::endl;
if (strict_)
{
throw Exception::IllegalArgument(__FILE__, __LINE__, __PRETTY_FUNCTION__,
"Error: Could not find any points for chromatogram " + transition->getNativeID() + \
". Maybe your retention time transformation is off?");
}
}
chromatogram.setMetaValue("product_mz", transition->getProductMZ());
chromatogram.setMetaValue("precursor_mz", transition->getPrecursorMZ());
chromatogram.setNativeID(transition->getNativeID());
// Create new transition group if there is none for this peptide
if (transition_group_map.find(transition->getPeptideRef()) == transition_group_map.end())
{
MRMTransitionGroupType transition_group;
transition_group.setTransitionGroupID(transition->getPeptideRef());
transition_group_map[transition->getPeptideRef()] = transition_group;
}
// Now add the transition and the chromatogram to the group
MRMTransitionGroupType& transition_group = transition_group_map[transition->getPeptideRef()];
transition_group.addTransition(*transition, transition->getNativeID());
transition_group.addChromatogram(chromatogram, chromatogram.getNativeID());
setProgress(++progress);
}
endProgress();
// The assumption is that for each transition that is in the TargetedExperiment we have exactly one chromatogram
for (TransitionGroupMapType::iterator trgroup_it = transition_group_map.begin(); trgroup_it != transition_group_map.end(); trgroup_it++)
{
if (trgroup_it->second.getChromatograms().size() > 0 && (trgroup_it->second.getChromatograms().size() != trgroup_it->second.getTransitions().size()))
{
throw Exception::IllegalArgument(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Error: Could not match all transition to all chromatograms:\nFor chromatogram " + \
trgroup_it->second.getTransitionGroupID() + " I found " + String(trgroup_it->second.getChromatograms().size()) + \
" chromatograms but " + String(trgroup_it->second.getTransitions().size()) + " transitions.");
}
}
}
}
| 53.358071
| 283
| 0.701739
|
kreinert
|
102a31d9246c28735b43dfc55d7e279ea1db5c4b
| 1,978
|
cpp
|
C++
|
Code/Game/Core/Player/GraphControllers/PlayerGraphController_Locomotion.cpp
|
JuanluMorales/KRG
|
f3a11de469586a4ef0db835af4bc4589e6b70779
|
[
"MIT"
] | 419
|
2022-01-27T19:37:43.000Z
|
2022-03-31T06:14:22.000Z
|
Code/Game/Core/Player/GraphControllers/PlayerGraphController_Locomotion.cpp
|
jagt/KRG
|
ba20cd8798997b0450491b0cc04dc817c4a4bc76
|
[
"MIT"
] | 2
|
2022-01-28T20:35:33.000Z
|
2022-03-13T17:42:52.000Z
|
Code/Game/Core/Player/GraphControllers/PlayerGraphController_Locomotion.cpp
|
jagt/KRG
|
ba20cd8798997b0450491b0cc04dc817c4a4bc76
|
[
"MIT"
] | 20
|
2022-01-27T20:41:02.000Z
|
2022-03-26T16:16:57.000Z
|
#include "PlayerGraphController_Locomotion.h"
//-------------------------------------------------------------------------
namespace KRG::Player
{
LocomotionGraphController::LocomotionGraphController( Animation::AnimationGraphComponent* pGraphComponent, Render::SkeletalMeshComponent* pMeshComponent )
: Animation::SubGraphController( pGraphComponent, pMeshComponent )
{
m_speedParam.TryBind( this );
m_headingParam.TryBind( this );
m_facingParam.TryBind( this );
m_isCrouchParam.TryBind( this );
m_isSlidingParam.TryBind( this );
}
void LocomotionGraphController::SetIdle()
{
m_speedParam.Set( this, 0.0f );
m_headingParam.Set( this, Vector::Zero );
m_facingParam.Set( this, Vector::WorldForward );
}
void LocomotionGraphController::SetLocomotionDesires( Seconds const deltaTime, Vector const& headingVelocityWS, Vector const& facingDirectionWS )
{
Vector const characterSpaceHeading = ConvertWorldSpaceVectorToCharacterSpace( headingVelocityWS );
float const speed = characterSpaceHeading.GetLength3();
m_headingParam.Set( this, characterSpaceHeading );
m_speedParam.Set( this, speed );
//-------------------------------------------------------------------------
if ( facingDirectionWS.IsZero3() )
{
m_facingParam.Set( this, Vector::WorldForward );
}
else
{
KRG_ASSERT( facingDirectionWS.IsNormalized3() );
Vector const characterSpaceFacing = ConvertWorldSpaceVectorToCharacterSpace( facingDirectionWS ).GetNormalized2();
m_facingParam.Set( this, characterSpaceFacing );
}
}
void LocomotionGraphController::SetCrouch( bool isCrouch )
{
m_isCrouchParam.Set( this, isCrouch );
}
void LocomotionGraphController::SetSliding( bool isSliding )
{
m_isSlidingParam.Set( this, isSliding );
}
}
| 35.963636
| 158
| 0.628413
|
JuanluMorales
|
102b660bb8f6800ceca6344b36d3eadfd8607316
| 1,378
|
cpp
|
C++
|
wallet/qt/ntp1/ntp1tokenlistfilterproxy.cpp
|
tahussle/bebbang
|
93be7665680d454f2f5a8c1124b1f1fa83f95960
|
[
"MIT"
] | null | null | null |
wallet/qt/ntp1/ntp1tokenlistfilterproxy.cpp
|
tahussle/bebbang
|
93be7665680d454f2f5a8c1124b1f1fa83f95960
|
[
"MIT"
] | 1
|
2019-04-19T03:20:52.000Z
|
2019-04-19T03:20:52.000Z
|
wallet/qt/ntp1/ntp1tokenlistfilterproxy.cpp
|
tahussle/bebbang
|
93be7665680d454f2f5a8c1124b1f1fa83f95960
|
[
"MIT"
] | null | null | null |
#include "ntp1tokenlistfilterproxy.h"
#include "ntp1tokenlistmodel.h"
NTP1TokenListFilterProxy::NTP1TokenListFilterProxy(QLineEdit* FilterLineEdit)
{
filterLineEdit = FilterLineEdit;
}
bool NTP1TokenListFilterProxy::filterAcceptsRow(int source_row, const QModelIndex& source_parent) const
{
if (filterLineEdit == NULL) {
return QSortFilterProxyModel::filterAcceptsRow(source_row, source_parent);
}
if (filterLineEdit->text().isEmpty()) {
return true;
}
QModelIndex columnsIndex = sourceModel()->index(source_row, 0, source_parent);
if (sourceModel()
->data(columnsIndex, NTP1TokenListModel::AmountRole)
.toString()
.contains(filterLineEdit->text(), Qt::CaseInsensitive) ||
sourceModel()
->data(columnsIndex, NTP1TokenListModel::TokenDescriptionRole)
.toString()
.contains(filterLineEdit->text(), Qt::CaseInsensitive) ||
sourceModel()
->data(columnsIndex, NTP1TokenListModel::TokenIdRole)
.toString()
.contains(filterLineEdit->text(), Qt::CaseInsensitive) ||
sourceModel()
->data(columnsIndex, NTP1TokenListModel::TokenNameRole)
.toString()
.contains(filterLineEdit->text(), Qt::CaseInsensitive)) {
return true;
} else {
return false;
}
}
| 33.609756
| 103
| 0.652395
|
tahussle
|
102c91f31f2a5fa34290da34bcd8dd0bac72ba00
| 1,550
|
cpp
|
C++
|
src/kits/storage/sniffer/Err.cpp
|
axeld/haiku
|
e3becd53eef5c093ee8c8f32bab51d40b0f2b8d4
|
[
"MIT"
] | 2
|
2020-09-26T13:18:36.000Z
|
2021-06-16T20:38:20.000Z
|
src/kits/storage/sniffer/Err.cpp
|
axeld/haiku
|
e3becd53eef5c093ee8c8f32bab51d40b0f2b8d4
|
[
"MIT"
] | null | null | null |
src/kits/storage/sniffer/Err.cpp
|
axeld/haiku
|
e3becd53eef5c093ee8c8f32bab51d40b0f2b8d4
|
[
"MIT"
] | 3
|
2018-12-17T13:07:38.000Z
|
2021-09-08T13:07:31.000Z
|
//----------------------------------------------------------------------
// This software is part of the OpenBeOS distribution and is covered
// by the MIT License.
//---------------------------------------------------------------------
/*!
\file Err.cpp
MIME sniffer Error class implementation
*/
#include <sniffer/Err.h>
#include <new>
#include <string.h>
using namespace BPrivate::Storage::Sniffer;
//------------------------------------------------------------------------------
// Err
//------------------------------------------------------------------------------
Err::Err(const char *msg, const ssize_t pos)
: fMsg(NULL)
, fPos(-1)
{
SetTo(msg, pos);
}
Err::Err(const std::string &msg, const ssize_t pos)
: fMsg(NULL)
, fPos(-1)
{
SetTo(msg, pos);
}
Err::Err(const Err &ref)
: fMsg(NULL)
, fPos(-1)
{
*this = ref;
}
Err::~Err() {
Unset();
}
Err&
Err::operator=(const Err &ref) {
SetTo(ref.Msg(), ref.Pos());
return *this;
}
status_t
Err::SetTo(const char *msg, const ssize_t pos) {
SetMsg(msg);
SetPos(pos);
return B_OK;
}
status_t
Err::SetTo(const std::string &msg, const ssize_t pos) {
return SetTo(msg.c_str(), pos);
}
void
Err::Unset() {
delete fMsg;
fMsg = NULL;
fPos = -1;
}
const char*
Err::Msg() const {
return fMsg;
}
ssize_t
Err::Pos() const {
return fPos;
}
void
Err::SetMsg(const char *msg) {
if (fMsg) {
delete fMsg;
fMsg = NULL;
}
if (msg) {
fMsg = new(std::nothrow) char[strlen(msg)+1];
if (fMsg)
strcpy(fMsg, msg);
}
}
void
Err::SetPos(ssize_t pos) {
fPos = pos;
}
| 15.5
| 80
| 0.505161
|
axeld
|
102da36abba0d8ebb37d3a8f260e01aecf41dd4e
| 260
|
cpp
|
C++
|
Learning Basics of C++/ASimpleProgram/prog.cpp
|
RyanPaulMcKenna/C-Basics
|
58943fb6ad123b4ffd82b624f1ceff88076816a0
|
[
"MIT"
] | null | null | null |
Learning Basics of C++/ASimpleProgram/prog.cpp
|
RyanPaulMcKenna/C-Basics
|
58943fb6ad123b4ffd82b624f1ceff88076816a0
|
[
"MIT"
] | null | null | null |
Learning Basics of C++/ASimpleProgram/prog.cpp
|
RyanPaulMcKenna/C-Basics
|
58943fb6ad123b4ffd82b624f1ceff88076816a0
|
[
"MIT"
] | null | null | null |
#include <iostream>
#define BOOK "C++ Programming"
#define NUM 200
#define RULE ***********************
using namespace std;
int main()
{
cout << endl << "NUM is:" << NUM << endl;
cout << "Double NUM: " << ((NUM) * 2) << endl;
system('pause');
return 0;
}
| 15.294118
| 46
| 0.546154
|
RyanPaulMcKenna
|
102df231499229a75d602781faf81009efaa1078
| 6,833
|
cpp
|
C++
|
src/chrono_models/vehicle/man/MAN_5t_Solid3LinkAxle.cpp
|
Ruochun/chrono
|
7b0f09242ef540ae56cfc8add3a5dc7985c654d2
|
[
"BSD-3-Clause"
] | 1
|
2020-01-18T02:39:17.000Z
|
2020-01-18T02:39:17.000Z
|
src/chrono_models/vehicle/man/MAN_5t_Solid3LinkAxle.cpp
|
Ruochun/chrono
|
7b0f09242ef540ae56cfc8add3a5dc7985c654d2
|
[
"BSD-3-Clause"
] | 7
|
2021-10-20T04:43:35.000Z
|
2021-12-24T08:44:31.000Z
|
src/chrono_models/vehicle/man/MAN_5t_Solid3LinkAxle.cpp
|
Ruochun/chrono
|
7b0f09242ef540ae56cfc8add3a5dc7985c654d2
|
[
"BSD-3-Clause"
] | 2
|
2021-12-09T05:32:31.000Z
|
2021-12-12T17:31:18.000Z
|
// =============================================================================
// PROJECT CHRONO - http://projectchrono.org
//
// Copyright (c) 2014 projectchrono.org
// All rights reserved.
//
// Use of this source code is governed by a BSD-style license that can be found
// in the LICENSE file at the top level of the distribution and at
// http://projectchrono.org/license-chrono.txt.
//
// =============================================================================
// Authors: Radu Serban, Rainer Gericke
// =============================================================================
//
// MAN 5t (front) steered and driven solid three link axle.
//
// =============================================================================
#include "chrono_models/vehicle/man/MAN_5t_Solid3LinkAxle.h"
namespace chrono {
namespace vehicle {
namespace man {
// -----------------------------------------------------------------------------
// Static variables
// -----------------------------------------------------------------------------
static const double in2m = 0.0254;
static const double lb2kg = 0.453592;
static const double lbf2N = 4.44822162;
static const double lbfpin2Npm = 175.12677;
const double MAN_5t_Solid3LinkAxle::m_axleTubeMass = 709;
const double MAN_5t_Solid3LinkAxle::m_spindleMass = 14.705 * 4.1;
const double MAN_5t_Solid3LinkAxle::m_triangleMass = 50.0;
const double MAN_5t_Solid3LinkAxle::m_linkMass = 25.0;
const double MAN_5t_Solid3LinkAxle::m_axleTubeRadius = 0.0476;
const double MAN_5t_Solid3LinkAxle::m_spindleRadius = 0.10;
const double MAN_5t_Solid3LinkAxle::m_spindleWidth = 0.06;
const ChVector<> MAN_5t_Solid3LinkAxle::m_axleTubeInertia(329.00, 16.46, 330.00);
const ChVector<> MAN_5t_Solid3LinkAxle::m_spindleInertia(0.04117 * 6.56, 0.07352 * 6.56, 0.04117 * 6.56);
const ChVector<> MAN_5t_Solid3LinkAxle::m_triangleInertia(0.2, 0.2, 0.2);
const ChVector<> MAN_5t_Solid3LinkAxle::m_linkInertia(0.05, 0.1, 0.1);
const double MAN_5t_Solid3LinkAxle::m_springDesignLength = 0.499924994;
const double MAN_5t_Solid3LinkAxle::m_springCoefficient1 = 178892.0; // linear
const double MAN_5t_Solid3LinkAxle::m_springCoefficient2 = 621618.0; // quadratic
const double MAN_5t_Solid3LinkAxle::m_springRestLength = 0.633;
const double MAN_5t_Solid3LinkAxle::m_springMinLength = 0.380;
const double MAN_5t_Solid3LinkAxle::m_springMaxLength = m_springDesignLength + 0.15;
const double MAN_5t_Solid3LinkAxle::m_damperCoefExpansion = 98727.9;
const double MAN_5t_Solid3LinkAxle::m_damperDegresExpansion = 4.77954;
const double MAN_5t_Solid3LinkAxle::m_damperCoefCompression = 52526.6;
const double MAN_5t_Solid3LinkAxle::m_damperDegresCompression = 3.0;
const double MAN_5t_Solid3LinkAxle::m_axleShaftInertia = 0.4 * 6.56;
const double MAN_5t_Solid3LinkAxle::m_twin_tire_dist = 0.0;
// ---------------------------------------------------------------------------------------
// MAN spring functor class - implements a linear spring + bump stop + rebound stop
// ---------------------------------------------------------------------------------------
class MAN_5t_SpringForceRear : public ChLinkTSDA::ForceFunctor {
public:
MAN_5t_SpringForceRear(double spring_constant1, double spring_coefficient2, double min_length, double max_length);
virtual double operator()(double time, double rest_length, double length, double vel, ChLinkTSDA* link) override;
private:
double m_spring_constant1;
double m_spring_constant2;
double m_min_length;
double m_max_length;
ChFunction_Recorder m_bump;
};
MAN_5t_SpringForceRear::MAN_5t_SpringForceRear(double spring_constant1,
double spring_constant2,
double min_length,
double max_length)
: m_spring_constant1(spring_constant1),
m_spring_constant2(spring_constant2),
m_min_length(min_length),
m_max_length(max_length) {
// From ADAMS/Car
m_bump.AddPoint(0.0, 0.0);
m_bump.AddPoint(2.0e-3, 200.0);
m_bump.AddPoint(4.0e-3, 400.0);
m_bump.AddPoint(6.0e-3, 600.0);
m_bump.AddPoint(8.0e-3, 800.0);
m_bump.AddPoint(10.0e-3, 1000.0);
m_bump.AddPoint(20.0e-3, 2500.0);
m_bump.AddPoint(30.0e-3, 4500.0);
m_bump.AddPoint(40.0e-3, 7500.0);
m_bump.AddPoint(50.0e-3, 12500.0);
}
double MAN_5t_SpringForceRear::operator()(double time,
double rest_length,
double length,
double vel,
ChLinkTSDA* link) {
/*
*
*/
double force = 0;
double defl_spring = rest_length - length;
double defl_bump = 0.0;
double defl_rebound = 0.0;
if (length < m_min_length) {
defl_bump = m_min_length - length;
}
if (length > m_max_length) {
defl_rebound = length - m_max_length;
}
force = defl_spring * m_spring_constant1 + defl_spring * std::abs(defl_spring) * m_spring_constant2 +
m_bump.Get_y(defl_bump) - m_bump.Get_y(defl_rebound);
return force;
}
MAN_5t_Solid3LinkAxle::MAN_5t_Solid3LinkAxle(const std::string& name) : ChSolidThreeLinkAxle(name) {
m_springForceCB = chrono_types::make_shared<MAN_5t_SpringForceRear>(m_springCoefficient1, m_springCoefficient2,
m_springMinLength, m_springMaxLength);
m_shockForceCB = chrono_types::make_shared<DegressiveDamperForce>(
m_damperCoefCompression, m_damperDegresCompression, m_damperCoefExpansion, m_damperDegresExpansion);
}
// -----------------------------------------------------------------------------
// Destructors
// -----------------------------------------------------------------------------
MAN_5t_Solid3LinkAxle::~MAN_5t_Solid3LinkAxle() {}
const ChVector<> MAN_5t_Solid3LinkAxle::getLocation(PointId which) {
switch (which) {
case SPRING_A:
return ChVector<>(0.000, 0.655, 0.090);
case SPRING_C:
return ChVector<>(0.000, 0.585, 0.585);
case SHOCK_A:
return ChVector<>(-0.246, 0.688, -0.125);
case SHOCK_C:
return ChVector<>(-0.250, 0.562, 0.570);
case SPINDLE:
return ChVector<>(0.0, 2.07 / 2.0, 0.0);
case TRIANGLE_A:
return ChVector<>(0.000, 0.000, 0.260);
case TRIANGLE_C:
return ChVector<>(-0.762, 0.420, 0.100);
case LINK_A:
return ChVector<>(0.115, 0.688, -0.090);
case LINK_C:
return ChVector<>(1.139, 0.400, 0.100);
default:
return ChVector<>(0, 0, 0);
}
}
} // namespace man
} // end namespace vehicle
} // end namespace chrono
| 39.959064
| 118
| 0.594907
|
Ruochun
|
1033d3fa6b558be3679599085578020d4d9d3735
| 15,198
|
cpp
|
C++
|
source/games/exhumed/src/exhumed.cpp
|
DosFreak/Raze
|
389f760d45748da28ba758f12be1be2a9ba9b4b2
|
[
"RSA-MD"
] | null | null | null |
source/games/exhumed/src/exhumed.cpp
|
DosFreak/Raze
|
389f760d45748da28ba758f12be1be2a9ba9b4b2
|
[
"RSA-MD"
] | null | null | null |
source/games/exhumed/src/exhumed.cpp
|
DosFreak/Raze
|
389f760d45748da28ba758f12be1be2a9ba9b4b2
|
[
"RSA-MD"
] | null | null | null |
//-------------------------------------------------------------------------
/*
Copyright (C) 2010-2019 EDuke32 developers and contributors
Copyright (C) 2019 sirlemonhead, Nuke.YKT
This file is part of PCExhumed.
PCExhumed is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License version 2
as published by the Free Software Foundation.
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 GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
//-------------------------------------------------------------------------
#include "ns.h"
#include "compat.h"
#include "engine.h"
#include "exhumed.h"
#include "sequence.h"
#include "names.h"
#include "player.h"
#include "input.h"
#include "sound.h"
#include "view.h"
#include "status.h"
#include "version.h"
#include "aistuff.h"
#include "mapinfo.h"
#include <string.h>
#include <cstdio> // for printf
#include <cstdlib>
#include <stdarg.h>
#include <ctype.h>
#include <time.h>
#include <assert.h>
#include "gamecvars.h"
#include "savegamehelp.h"
#include "c_dispatch.h"
#include "raze_sound.h"
#include "gamestate.h"
#include "screenjob.h"
#include "c_console.h"
#include "cheathandler.h"
#include "inputstate.h"
#include "d_protocol.h"
#include "texturemanager.h"
#include "razemenu.h"
#include "v_draw.h"
#include "interpolate.h"
BEGIN_PS_NS
DExhumedActor exhumedActors[MAXSPRITES];
static MapRecord* NextMap;
void uploadCinemaPalettes();
int32_t registerosdcommands(void);
void InitCheats();
int EndLevel = 0;
InputPacket localInput;
////////
void ResetEngine()
{
EraseScreen(-1);
resettiming();
}
void GameInterface::loadPalette()
{
paletteLoadFromDisk();
uploadCinemaPalettes();
LoadPaletteLookups();
}
void CopyTileToBitmap(short nSrcTile, short nDestTile, int xPos, int yPos);
// void TestSaveLoad();
void EraseScreen(int nVal);
void LoadStatus();
void MySetView(int x1, int y1, int x2, int y2);
char sHollyStr[40];
short nFontFirstChar;
short nBackgroundPic;
short nShadowPic;
short nCreaturesKilled = 0, nCreaturesTotal = 0;
short nFreeze;
short nSnakeCam = -1;
int nNetPlayerCount = 0;
short nClockVal;
short nRedTicks;
short nAlarmTicks;
short nButtonColor;
short nEnergyChan;
short bModemPlay = false;
int lCountDown = 0;
short nEnergyTowers = 0;
short nCfgNetPlayers = 0;
FILE *vcrfp = NULL;
int lLocalCodes = 0;
short bCoordinates = false;
int nNetTime = -1;
short nCodeMin = 0;
short nCodeMax = 0;
short nCodeIndex = 0;
//short nScreenWidth = 320;
//short nScreenHeight = 200;
int flash;
int totalmoves;
short nCurBodyNum = 0;
short nBodyTotal = 0;
short lastfps;
short nTotalPlayers = 1;
// TODO: Rename this (or make it static) so it doesn't conflict with library function
//short socket = 0;
short nFirstPassword = 0;
short nFirstPassInfo = 0;
short nPasswordCount = 0;
short bSnakeCam = false;
short bRecord = false;
short bPlayback = false;
short bInDemo = false;
short bSlipMode = false;
short bDoFlashes = true;
DExhumedActor* bestTarget;
short scan_char = 0;
int nStartLevel;
int nTimeLimit;
int bVanilla = 0;
void DebugOut(const char *fmt, ...)
{
#ifdef _DEBUG
va_list args;
va_start(args, fmt);
VPrintf(PRINT_HIGH, fmt, args);
#endif
}
void DoClockBeep()
{
ExhumedStatIterator it(407);
while (auto i = it.Next())
{
PlayFX2(StaticSound[kSound74], i);
}
}
void DoRedAlert(int nVal)
{
if (nVal)
{
nAlarmTicks = 69;
nRedTicks = 30;
}
ExhumedStatIterator it(405);
while (auto ac = it.Next())
{
if (nVal)
{
auto spri = &ac->s();
PlayFXAtXYZ(StaticSound[kSoundAlarm], spri->x, spri->y, spri->z, spri->sectnum);
AddFlash(spri->sectnum, spri->x, spri->y, spri->z, 192);
}
}
}
void DrawClock()
{
int ebp = 49;
auto pixels = TileFiles.tileMakeWritable(kTile3603);
memset(pixels, TRANSPARENT_INDEX, 4096);
if (lCountDown / 30 != nClockVal)
{
nClockVal = lCountDown / 30;
DoClockBeep();
}
int nVal = nClockVal;
while (nVal)
{
int v2 = nVal & 0xF;
int yPos = 32 - tileHeight(v2 + kClockSymbol1) / 2;
CopyTileToBitmap(v2 + kClockSymbol1, kTile3603, ebp - tileWidth(v2 + kClockSymbol1) / 2, yPos);
ebp -= 15;
nVal /= 16;
}
DoEnergyTile();
}
double calc_smoothratio()
{
if (bRecord || bPlayback || nFreeze != 0 || paused)
return MaxSmoothRatio;
return I_GetTimeFrac() * MaxSmoothRatio;
}
void DoGameOverScene(bool finallevel)
{
// todo: make these customizable later.
StartCutscene(finallevel ? "ExhumedCutscenes.BuildCinemaLose" : "ExhumedCutscenes.BuildGameoverScene", 0, [](bool)
{
gameaction = ga_mainmenu;
});
}
void GameMove(void)
{
FixPalette();
ExhumedSpriteIterator it;
while (auto ac = it.Next())
{
ac->s().backuploc();
}
if (currentLevel->gameflags & LEVEL_EX_COUNTDOWN)
{
if (lCountDown <= 0)
{
DoGameOverScene(true);
return;
}
// Pink section
lCountDown--;
DrawClock();
if (nRedTicks)
{
nRedTicks--;
if (nRedTicks <= 0) {
DoRedAlert(0);
}
}
nAlarmTicks--;
nButtonColor--;
if (nAlarmTicks <= 0) {
DoRedAlert(1);
}
}
// YELLOW SECTION
MoveThings();
obobangle = bobangle;
if (PlayerList[nLocalPlayer].totalvel == 0)
{
bobangle = 0;
}
else
{
bobangle += 56;
bobangle &= kAngleMask;
}
UpdateCreepySounds();
// loc_120E9:
totalmoves++;
}
static int SelectAltWeapon(int weap2)
{
// todo
return 0;
}
void GameInterface::Ticker()
{
if (paused)
{
r_NoInterpolate = true;
}
else if (EndLevel == 0)
{
inita &= kAngleMask;
for (int i = 0; i < 4; i++)
{
lPlayerXVel += localInput.fvel * bcos(inita) + localInput.svel * bsin(inita);
lPlayerYVel += localInput.fvel * bsin(inita) - localInput.svel * bcos(inita);
lPlayerXVel -= (lPlayerXVel >> 5) + (lPlayerXVel >> 6);
lPlayerYVel -= (lPlayerYVel >> 5) + (lPlayerYVel >> 6);
}
UpdateInterpolations();
if (localInput.actions & SB_INVPREV)
{
int nItem = PlayerList[nLocalPlayer].nItem;
int i;
for (i = 6; i > 0; i--)
{
nItem--;
if (nItem < 0) nItem = 5;
if (PlayerList[nLocalPlayer].items[nItem] != 0)
break;
}
if (i > 0) PlayerList[nLocalPlayer].nItem = nItem;
}
if (localInput.actions & SB_INVNEXT)
{
int nItem = PlayerList[nLocalPlayer].nItem;
int i;
for (i = 6; i > 0; i--)
{
nItem++;
if (nItem == 6) nItem = 0;
if (PlayerList[nLocalPlayer].items[nItem] != 0)
break;
}
if (i > 0) PlayerList[nLocalPlayer].nItem = nItem;
}
if (localInput.actions & SB_INVUSE)
{
if (PlayerList[nLocalPlayer].nItem != -1)
{
localInput.setItemUsed(PlayerList[nLocalPlayer].nItem);
}
}
for (int i = 0; i < 6; i++)
{
if (localInput.isItemUsed(i))
{
localInput.clearItemUsed(i);
if (PlayerList[nLocalPlayer].items[i] > 0)
{
if (nItemMagic[i] <= PlayerList[nLocalPlayer].nMagic)
{
sPlayerInput[nLocalPlayer].nItem = i;
break;
}
}
}
}
auto currWeap = PlayerList[nLocalPlayer].nCurrentWeapon;
int weap2 = localInput.getNewWeapon();
if (weap2 == WeaponSel_Next)
{
auto newWeap = currWeap == 6 ? 0 : currWeap + 1;
while (newWeap != 0 && (!(PlayerList[nLocalPlayer].nPlayerWeapons & (1 << newWeap)) || (PlayerList[nLocalPlayer].nPlayerWeapons & (1 << newWeap) && PlayerList[nLocalPlayer].nAmmo[newWeap] == 0)))
{
newWeap++;
if (newWeap > 6) newWeap = 0;
}
localInput.setNewWeapon(newWeap + 1);
}
else if (weap2 == WeaponSel_Prev)
{
auto newWeap = currWeap == 0 ? 6 : currWeap - 1;
while (newWeap != 0 && ((!(PlayerList[nLocalPlayer].nPlayerWeapons & (1 << newWeap)) || (PlayerList[nLocalPlayer].nPlayerWeapons & (1 << newWeap) && PlayerList[nLocalPlayer].nAmmo[newWeap] == 0))))
{
newWeap--;
}
localInput.setNewWeapon(newWeap + 1);
}
else if (weap2 == WeaponSel_Alt)
{
weap2 = SelectAltWeapon(weap2);
}
// make weapon selection persist until it gets used up.
int weap = sPlayerInput[nLocalPlayer].getNewWeapon();
if (weap2 <= 0 || weap2 > 7) sPlayerInput[nLocalPlayer].SetNewWeapon(weap);
auto oldactions = sPlayerInput[nLocalPlayer].actions;
sPlayerInput[nLocalPlayer].actions = localInput.actions;
if (oldactions & SB_CENTERVIEW) sPlayerInput[nLocalPlayer].actions |= SB_CENTERVIEW;
sPlayerInput[nLocalPlayer].xVel = lPlayerXVel;
sPlayerInput[nLocalPlayer].yVel = lPlayerYVel;
sPlayerInput[nLocalPlayer].buttons = lLocalCodes;
sPlayerInput[nLocalPlayer].pTarget = bestTarget;
sPlayerInput[nLocalPlayer].nAngle = localInput.avel;
sPlayerInput[nLocalPlayer].pan = localInput.horz;
Ra[nLocalPlayer].pTarget = bestTarget;
lLocalCodes = 0;
PlayClock += 4;
if (PlayClock == 8) gameaction = ga_autosave; // let the game run for 1 frame before saving.
GameMove();
r_NoInterpolate = false;
}
else
{
// Wait for the end of level sound to play out, but stop updating the playsim.
if (EndLevel == 13)
PlayLocalSound(StaticSound[59], 0, true, CHANF_UI);
if (EndLevel > 1) EndLevel--;
r_NoInterpolate = true;
int flash = 7 - abs(EndLevel - 7);
videoTintBlood(flash * 30, flash * 30, flash * 30);
if (EndLevel == 1)
{
if (!soundEngine->GetSoundPlayingInfo(SOURCE_None, nullptr, StaticSound[59] + 1))
{
videoTintBlood(0, 0, 0);
CompleteLevel(NextMap);
NextMap = nullptr;
EndLevel = 0;
}
}
}
}
void LevelFinished()
{
NextMap = FindNextMap(currentLevel);
EndLevel = 13;
}
#define x(a, b) registerName(#a, b);
static void SetTileNames()
{
auto registerName = [](const char* name, int index)
{
TexMan.AddAlias(name, tileGetTexture(index));
};
#include "namelist.h"
}
#undef x
void GameInterface::app_init()
{
#if 0
help_disabled = true;
#endif
InitCheats();
registerosdcommands();
if (nNetPlayerCount == -1)
{
nNetPlayerCount = nCfgNetPlayers - 1;
nTotalPlayers += nNetPlayerCount;
}
SetTileNames();
InitFX();
seq_LoadSequences();
InitStatus();
resettiming();
GrabPalette();
enginecompatibility_mode = ENGINECOMPATIBILITY_19950829;
}
void DeleteActor(DExhumedActor* actor)
{
if (!actor)
{
return;
}
FVector3 pos = GetSoundPos(&actor->s().pos);
soundEngine->RelinkSound(SOURCE_Actor, &actor->s(), nullptr, &pos);
deletesprite(actor->GetSpriteIndex());
actor->s().ox = 0x80000000;
if (actor == bestTarget) {
bestTarget = nullptr;
}
}
void CopyTileToBitmap(short nSrcTile, short nDestTile, int xPos, int yPos)
{
int nOffs = tileHeight(nDestTile) * xPos;
auto pixels = TileFiles.tileMakeWritable(nDestTile);
uint8_t *pDest = pixels + nOffs + yPos;
uint8_t *pDestB = pDest;
tileLoad(nSrcTile);
int destYSize = tileHeight(nDestTile);
int srcYSize = tileHeight(nSrcTile);
const uint8_t *pSrc = tilePtr(nSrcTile);
for (int x = 0; x < tileWidth(nSrcTile); x++)
{
pDest += destYSize;
for (int y = 0; y < srcYSize; y++)
{
uint8_t val = *pSrc;
if (val != TRANSPARENT_INDEX) {
*pDestB = val;
}
pDestB++;
pSrc++;
}
// reset pDestB
pDestB = pDest;
}
TileFiles.InvalidateTile(nDestTile);
}
void EraseScreen(int nVal)
{
// There's no other values than 0 ever coming through here.
twod->ClearScreen();
}
bool GameInterface::CanSave()
{
return gamestate == GS_LEVEL && !bRecord && !bPlayback && !bInDemo && nTotalPlayers == 1 && nFreeze == 0;
}
::GameStats GameInterface::getStats()
{
return { nCreaturesKilled, nCreaturesTotal, 0, 0, PlayClock / 120, 0 };
}
::GameInterface* CreateInterface()
{
return new GameInterface;
}
extern short cPupData[300];
extern uint8_t* Worktile;
extern int lHeadStartClock;
extern short* pPupData;
FSerializer& Serialize(FSerializer& arc, const char* keyname, DExhumedActor& w, DExhumedActor* def)
{
if (arc.BeginObject(keyname))
{
arc("phase", w.nPhase)
("health", w.nHealth)
("frame", w.nFrame)
("action", w.nAction)
("target", w.pTarget)
("count", w.nCount)
("run", w.nRun)
("index", w.nIndex)
("index2", w.nIndex2)
("channel", w.nChannel)
("damage", w.nDamage)
("turn", w.nTurn)
("x", w.x)
("y", w.y)
.EndObject();
}
return arc;
}
void SerializeState(FSerializer& arc)
{
int loaded = 0;
if (arc.BeginObject("state"))
{
if (arc.isReading() && (currentLevel->gameflags & LEVEL_EX_COUNTDOWN))
{
InitEnergyTile();
}
arc ("besttarget", bestTarget)
("creaturestotal", nCreaturesTotal)
("creatureskilled", nCreaturesKilled)
("freeze", nFreeze)
("snakecam", nSnakeCam)
("clockval", nClockVal) // kTile3603
("redticks", nRedTicks)
("alarmticks", nAlarmTicks)
("buttoncolor", nButtonColor)
("energychan", nEnergyChan)
("countdown", lCountDown)
("energytowers", nEnergyTowers)
("totalmoves", totalmoves)
("curbodynum", nCurBodyNum)
("bodytotal", nBodyTotal)
("bsnakecam", bSnakeCam)
("slipmode", bSlipMode)
("PlayClock", PlayClock)
("spiritsprite", pSpiritSprite)
.EndObject();
}
}
END_PS_NS
| 23.381538
| 209
| 0.579484
|
DosFreak
|
10341a89d0544caa926c916c1f43822dd981210a
| 9,767
|
cc
|
C++
|
src/suif1/TaskMallocLargeArrays.cc
|
paulhjkelly/taskgraph-metaprogramming
|
54c4e2806a97bec555a90784ab4cf0880660bf89
|
[
"BSD-3-Clause"
] | 5
|
2020-04-11T21:30:19.000Z
|
2021-12-04T16:16:09.000Z
|
src/suif1/TaskMallocLargeArrays.cc
|
paulhjkelly/taskgraph-metaprogramming
|
54c4e2806a97bec555a90784ab4cf0880660bf89
|
[
"BSD-3-Clause"
] | null | null | null |
src/suif1/TaskMallocLargeArrays.cc
|
paulhjkelly/taskgraph-metaprogramming
|
54c4e2806a97bec555a90784ab4cf0880660bf89
|
[
"BSD-3-Clause"
] | null | null | null |
#include <cassert>
#include <cstdio>
#include <cstddef>
#include <climits>
#include <limits>
#include <set>
#include <suif1.h>
#include <useful.h>
#include <dependence.h>
#ifdef VERBOSE_MALLOC_LARGE_ARRAYS
#define INFO printf
#else
#define INFO if ( false ) printf
#endif
namespace
{
// This transformation attempts to turn stack allocated arrays into heap
// allocated arrays. It is potentially very broken as SUIF's handling of sizes
// doesn't seem to adapt to the current platform.
class MallocLargeArrays
{
private:
std::size_t maxStackAllocation;
type_node* type_size_t;
proc_sym* malloc_function;
proc_sym* free_function;
proc_sym* createMallocFunction() const
{
func_type *funcType = new func_type(type_void->ptr_to());
funcType->set_num_args(1);
funcType->set_arg_type(0, type_size_t);
funcType->set_varargs(false);
proc_sym *procSym = new proc_sym(funcType, src_c, const_cast<char*>("malloc"));
return procSym;
}
proc_sym* createFreeFunction() const
{
func_type *funcType = new func_type(type_void);
funcType->set_num_args(1);
funcType->set_arg_type(0, type_void->ptr_to());
funcType->set_varargs(false);
proc_sym *procSym = new proc_sym(funcType, src_c, const_cast<char*>("free"));
return procSym;
}
instruction* createMallocCall(const std::size_t bytes) const
{
in_cal *instr = new in_cal();
instruction* base = new in_ldc (malloc_function->type()->ptr_to(), operand(), immed(malloc_function));
instruction* loadBytes = new in_ldc(type_signed_long, operand(), immed(bytes));
instr->set_addr_op(base);
instr->set_num_args(1);
instr->set_argument(0u, loadBytes);
return instr;
}
instruction* createFreeCall(var_sym* const ptr) const
{
in_cal *instr = new in_cal();
instruction* base = new in_ldc (free_function->type()->ptr_to(), operand(), immed(free_function));
instr->set_addr_op(base);
instr->set_num_args(1);
instr->set_argument(0u, ptr);
return instr;
}
static std::size_t getSize(array_type* const arrayType)
{
type_node* type = arrayType;
std::size_t size = 1;
while(type->is_array())
{
array_type* const subArrayType = static_cast<array_type*>(type);
size *= subArrayType->upper_bound().constant() - subArrayType->lower_bound().constant() + 1;
type = subArrayType->elem_type();
}
// FIXME: correct handling of types of different types should be handled by
// SUIF. This is especially important for SUIF to determine the correct type
// of size_t
std::size_t elemSize;
if (type == type_ptr)
elemSize = sizeof(void*);
else if (type == type_char)
elemSize = sizeof(char);
else if (type == type_signed_char)
elemSize = sizeof(signed char);
else if (type == type_unsigned_char)
elemSize = sizeof(unsigned char);
else if (type == type_signed_short)
elemSize = sizeof(signed short);
else if (type == type_unsigned_short)
elemSize = sizeof(unsigned short);
else if (type == type_signed)
elemSize = sizeof (signed int);
else if (type == type_unsigned)
elemSize = sizeof (unsigned int);
else if (type == type_signed_long)
elemSize = sizeof (signed long);
else if (type == type_unsigned_long)
elemSize = sizeof (unsigned long);
//else if (type == type_signed_longlong)
// elemSize = sizeof(signed long long);
//else if (type == type_unsigned_longlong)
// elemSize = sizeof(unsigned long long);
else if (type == type_float)
elemSize = sizeof(float);
else if (type == type_double)
elemSize = sizeof(double);
else if (type == type_longdouble)
elemSize = sizeof(long double);
else
elemSize = type->size() / CHAR_BIT;
size *= elemSize;
return size;
}
std::set<var_sym*> modifyTypesAndCallAllocationRoutines(tree_block * const tb)
{
std::set<var_sym*> heapAllocated;
block_symtab* const symTab = tb->symtab();
sym_node_list* const symbols = symTab->symbols();
sym_node_list_iter iter(symbols);
// First collect all arrays that need to be heap allocated, change their type
// and add appropriate malloc statements.
while (!iter.is_empty())
{
sym_node* const symNode = iter.step();
if (symNode->is_var())
{
var_sym* const var = static_cast<var_sym*>(symNode);
if (!var->is_param() && var->type()->is_array() &&
getSize(static_cast<array_type*>(var->type())) > maxStackAllocation)
{
// Change variable type to a restricted array pointer
array_type* const arrayType = static_cast<array_type*>(var->type());
type_node* const newType = symTab->install_type(new modifier_type(TYPE_RESTRICT, arrayType->ptr_to()));
var->set_type(newType);
heapAllocated.insert(var);
// Create call to malloc
instruction* const mallocCall = createMallocCall(getSize(arrayType));
instruction* const mallocAssignment = new in_rrr(io_cvt, newType, var, mallocCall, operand());
tb->body()->push(new tree_instr(mallocAssignment));
// Create call to free
instruction* const freeCall = createFreeCall(var);
tb->body()->append(new tree_instr(freeCall));
}
}
}
return heapAllocated;
}
void rewriteInstruction(instruction* const ins, const std::set<var_sym*>& heapAllocated)
{
if (ins->opcode() == io_array)
{
in_array* const arrayInstr = static_cast<in_array*>(ins);
var_sym* const array = get_sym_of_array(arrayInstr);
if (heapAllocated.find(array) != heapAllocated.end())
{
arrayInstr->base_op().remove();
arrayInstr->set_base_op(new in_rrr(io_lod, array->type(), operand(), array));
}
}
for (unsigned i = 0; i < ins->num_srcs(); ++i)
{
operand op(ins->src_op(i));
if (op.is_instr())
rewriteInstruction(op.instr(), heapAllocated);
}
}
void mallocLargeArrays(tree_block* const tb, const std::set<var_sym*>& heapAllocated)
{
std::set<var_sym*> localHeapAllocated(modifyTypesAndCallAllocationRoutines(tb));
localHeapAllocated.insert(heapAllocated.begin(), heapAllocated.end());
mallocLargeArrays(tb->body(), localHeapAllocated);
}
void mallocLargeArrays(tree_node_list* const tnl, const std::set<var_sym*>& heapAllocated)
{
tree_node_list_iter iter(tnl);
while (!iter.is_empty())
{
tree_node* const tn = iter.step();
switch (tn->kind())
{
case TREE_FOR:
{
tree_for *const tnf = static_cast <tree_for*>(tn);
mallocLargeArrays(tnf->lb_list(), heapAllocated);
mallocLargeArrays(tnf->ub_list(), heapAllocated);
mallocLargeArrays(tnf->step_list(), heapAllocated);
mallocLargeArrays(tnf->landing_pad(), heapAllocated);
mallocLargeArrays(tnf->body(), heapAllocated);
break;
}
case TREE_IF:
{
tree_if *const tni = static_cast <tree_if*>(tn);
mallocLargeArrays(tni->header(), heapAllocated);
mallocLargeArrays(tni->then_part(), heapAllocated);
mallocLargeArrays(tni->else_part(), heapAllocated);
break;
}
case TREE_LOOP:
{
tree_loop *const tnl = static_cast <tree_loop*>(tn);
mallocLargeArrays(tnl->body(), heapAllocated);
mallocLargeArrays(tnl->test(), heapAllocated);
break;
}
case TREE_BLOCK:
{
tree_block *const tb = static_cast <tree_block*>(tn);
mallocLargeArrays(tb, heapAllocated);
break;
}
case TREE_INSTR:
{
tree_instr* const tnin = static_cast <tree_instr*>(tn);
instruction* const instr = tnin->instr();
rewriteInstruction(instr, heapAllocated);
// Insert free statements before this instruction if it is a return
if (instr->format() == inf_rrr && instr->opcode() == io_ret)
{
for(std::set<var_sym*>::const_iterator symIter(heapAllocated.begin()); symIter!=heapAllocated.end(); ++symIter)
{
instruction* const freeCall = createFreeCall(*symIter);
tnl->insert_before(new tree_instr(freeCall), iter.cur_elem());
}
}
break;
}
default:
{
assert(false);
break;
}
}
}
}
public:
MallocLargeArrays() : maxStackAllocation(4 * 1024)
{
}
void setupGlobals(tree_proc* const tp)
{
// FIXME: This attempts to create a C type corresponding to std::size_t so the generated
// malloc prototype will be correct. It will break when the returned SUIF type does not correspond
// to the appropriate C type on the target platform. It should be removed once headers can be
// specified for TaskGraph generated code.
block_symtab* const symTab = tp->symtab();
type_size_t = symTab->install_type(new base_type(TYPE_INT, sizeof(std::size_t)*CHAR_BIT, std::numeric_limits<std::size_t>::is_signed));
malloc_function = createMallocFunction();
free_function = createFreeFunction();
symTab->add_sym(malloc_function);
symTab->add_sym(free_function);
}
void mallocLargeArrays(tree_block* const tb)
{
const std::set<var_sym*> heapAllocated;
mallocLargeArrays(tb, heapAllocated);
}
};
}
namespace tg
{
void mallocLargeArraysDoProc(tree_proc* const tp, void *)
{
proc_sym* const psym = tp->proc();
INFO("=======%s======= \n", psym->name());
MallocLargeArrays transform;
transform.setupGlobals(tp);
transform.mallocLargeArrays(tp);
}
}
| 31.405145
| 139
| 0.644824
|
paulhjkelly
|
10396c65f424e66812b6eb4872935ab6cc2fe330
| 5,846
|
cpp
|
C++
|
runtime/test/test_pstorage.cpp
|
kinsamanka/OpenPLC_v3
|
fc1afcf702eebaf518971b304acf487809c804d4
|
[
"Apache-2.0"
] | null | null | null |
runtime/test/test_pstorage.cpp
|
kinsamanka/OpenPLC_v3
|
fc1afcf702eebaf518971b304acf487809c804d4
|
[
"Apache-2.0"
] | null | null | null |
runtime/test/test_pstorage.cpp
|
kinsamanka/OpenPLC_v3
|
fc1afcf702eebaf518971b304acf487809c804d4
|
[
"Apache-2.0"
] | null | null | null |
// Copyright 2019 Smarter Grid Solutions
//
// 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 permissionsand
// limitations under the License.
#include <cstring>
#include <mutex>
#include <sstream>
#include "catch.hpp"
#include "fakeit.hpp"
#include "glue.h"
#include "pstorage.h"
using namespace std;
#define IS_BIG_ENDIAN (*(uint16_t *)"\0\xff" < 0x100)
const char VALID_HEADER[] = { static_cast<char>(137), 'O', 'P', 'L', 'C',
'P', 'S', '\n', 'v', 0, '\n' };
const char* CHECKSUM = "16d15b8416040cce48b111ce03ee3dab";
SCENARIO("pstorage_read", "")
{
mutex glue_mutex;
stringstream input_stream;
input_stream.write(VALID_HEADER, 11);
char endian_header[2] = { IS_BIG_ENDIAN, '\n'};
input_stream.write(endian_header, 2);
input_stream.write(CHECKSUM, strlen(CHECKSUM));
input_stream.put('\n');
GIVEN("simple glue variables")
{
IEC_LWORD lword_var = 0;
IEC_SINT usint_var = 0;
IEC_BOOL bool_var = 0;
GlueBoolGroup grp {
.index = 0,
.values = { &bool_var, nullptr, nullptr, nullptr,
nullptr, nullptr, nullptr, nullptr}
};
const GlueVariable glue_vars[] = {
{ IECLDT_MEM, IECLST_DOUBLEWORD, 0, 0, IECVT_LWORD, &lword_var },
{ IECLDT_MEM, IECLST_BYTE, 0, 0, IECVT_USINT, &usint_var },
{ IECLDT_MEM, IECLST_BIT, 0, 0, IECVT_BOOL, &grp },
};
GlueVariablesBinding bindings(&glue_mutex, 3, glue_vars, CHECKSUM);
WHEN("no data")
{
input_stream.seekg(0);
REQUIRE(pstorage_read(input_stream, bindings) != 0);
}
WHEN("data too short")
{
input_stream << '1';
input_stream.seekg(0);
REQUIRE(pstorage_read(input_stream, bindings) != 0);
}
WHEN("data is valid and all zero")
{
char buffer[6] = {0};
input_stream.write(buffer, 6);
input_stream.seekg(0);
REQUIRE(pstorage_read(input_stream, bindings) == 0);
REQUIRE(lword_var == 0);
REQUIRE(usint_var == 0);
REQUIRE(bool_var == 0);
}
WHEN("data is valid and all one")
{
IEC_LWORD lword_initial_value = 1;
IEC_USINT usint_initial_value = 1;
char buffer[6] = {0, 0, 0, 0, 1, 1};
// We don't (in general) know the endianness to know
// the byte order, so we initialize the buffer based on
// the actual memory layout
memcpy(buffer, &lword_initial_value, 4);
input_stream.write(buffer, 6);
input_stream.seekg(0);
REQUIRE(pstorage_read(input_stream, bindings) == 0);
REQUIRE(lword_var == 1);
REQUIRE(usint_var == 1);
REQUIRE(bool_var == 1);
}
}
GIVEN("one bool group")
{
IEC_BOOL bool_var0 = 0;
IEC_BOOL bool_var1 = 0;
IEC_BOOL bool_var7 = 0;
GlueBoolGroup grp {
.index = 0,
.values = { &bool_var0, &bool_var1, nullptr, nullptr,
nullptr, nullptr, nullptr, &bool_var7}
};
const GlueVariable glue_vars[] = {
{ IECLDT_MEM, IECLST_BIT, 0, 0, IECVT_BOOL, &grp },
};
GlueVariablesBinding bindings(&glue_mutex, 1, glue_vars, CHECKSUM);
WHEN("data is valid and mixture of bits set")
{
// We don't (in general) know the endianness to know
// the byte order, so we initialize the buffer based on
// the actual memory layout
char one_char = 0x81;
input_stream.write(&one_char, 1);
input_stream.seekg(0);
REQUIRE(pstorage_read(input_stream, bindings) == 0);
REQUIRE(bool_var0 == 1);
REQUIRE(bool_var1 == 0);
REQUIRE(bool_var7 == 1);
}
}
}
SCENARIO("pstorage_run")
{
mutex glue_mutex;
stringstream input_stream;
input_stream.write(VALID_HEADER, 11);
char endian_header[2] = { IS_BIG_ENDIAN, '\n'};
input_stream.write(endian_header, 2);
input_stream.write(CHECKSUM, strlen(CHECKSUM));
input_stream.put('\n');
GIVEN("glue variables and stream")
{
IEC_LWORD lword_var = 1;
IEC_SINT usint_var = 2;
IEC_BOOL bool_var = 1;
GlueBoolGroup grp {
.index = 0,
.values = { &bool_var, nullptr, nullptr, nullptr,
nullptr, nullptr, nullptr, nullptr}
};
const GlueVariable glue_vars[] = {
{ IECLDT_MEM, IECLST_DOUBLEWORD, 0, 0, IECVT_LWORD, &lword_var },
{ IECLDT_MEM, IECLST_BYTE, 0, 0, IECVT_USINT, &usint_var },
{ IECLDT_MEM, IECLST_BIT, 0, 0, IECVT_BOOL, &grp },
};
GlueVariablesBinding bindings(&glue_mutex, 3, glue_vars, CHECKSUM);
oplc::config_stream cfg_stream(new stringstream(""),
[](istream* s) { delete s; });
WHEN("write once")
{
volatile bool run = false;
auto create_stream = []() { return new stringstream(); };
auto result = pstorage_run(cfg_stream, "0", bindings,
run, create_stream);
REQUIRE(result == 0);
}
}
}
| 32.842697
| 77
| 0.567739
|
kinsamanka
|
103ad622d2b839bd007a56f0a623898d7183a003
| 3,643
|
cpp
|
C++
|
src/mongo/transport/transport_layer_legacy_test.cpp
|
SCC-RHUL-Projects/jrtapsell_loggingMongo
|
4c5b27194f784fe1893bf97923874f736ab6c2ea
|
[
"Apache-2.0"
] | null | null | null |
src/mongo/transport/transport_layer_legacy_test.cpp
|
SCC-RHUL-Projects/jrtapsell_loggingMongo
|
4c5b27194f784fe1893bf97923874f736ab6c2ea
|
[
"Apache-2.0"
] | null | null | null |
src/mongo/transport/transport_layer_legacy_test.cpp
|
SCC-RHUL-Projects/jrtapsell_loggingMongo
|
4c5b27194f784fe1893bf97923874f736ab6c2ea
|
[
"Apache-2.0"
] | null | null | null |
/**
* Copyright (C) 2017 MongoDB Inc.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License, version 3,
* as published by the Free Software Foundation.
*
* 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
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* As a special exception, the copyright holders give permission to link the
* code of portions of this program with the OpenSSL library under certain
* conditions as described in each individual source file and distribute
* linked combinations including the program with the OpenSSL library. You
* must comply with the GNU Affero General Public License in all respects for
* all of the code used other than as permitted herein. If you modify file(s)
* with this exception, you may extend this exception to your version of the
* file(s), but you are not obligated to do so. If you do not wish to do so,
* delete this exception statement from your version. If you delete this
* exception statement from all source files in the program, then also delete
* it in the license file.
*/
#include "mongo/platform/basic.h"
#include "mongo/transport/service_entry_point.h"
#include "mongo/transport/transport_layer_legacy.h"
#include "mongo/unittest/unittest.h"
#include "mongo/util/assert_util.h"
namespace mongo {
namespace {
class ServiceEntryPointUtil : public ServiceEntryPoint {
public:
void startSession(transport::SessionHandle session) override {
Message m;
Status s = session->sourceMessage(&m).wait();
ASSERT_NOT_OK(s);
tll->end(session);
}
DbResponse handleRequest(OperationContext* opCtx, const Message& request) override {
MONGO_UNREACHABLE;
}
transport::TransportLayerLegacy* tll = nullptr;
};
// This test verifies a fix for SERVER-28239. The actual service entry point in use by mongod and
// mongos calls end() manually, which occasionally was the second call to end() if after a primary
// stepdown. This tests verifies our fix (making end() safe to call multiple times)
TEST(TransportLayerLegacy, endSessionsDoesntDoubleClose) {
// Disabling this test until we can figure out the best way to allocate port numbers for unit
// tests
return;
ServiceEntryPointUtil sepu;
transport::TransportLayerLegacy::Options opts{};
opts.port = 27017;
transport::TransportLayerLegacy tll(opts, &sepu);
sepu.tll = &tll;
tll.setup().transitional_ignore();
tll.start().transitional_ignore();
stdx::mutex mutex;
bool end = false;
stdx::condition_variable cv;
stdx::thread thr{[&] {
Socket s;
SockAddr sa{"localhost", 27017, AF_INET};
s.connect(sa);
stdx::unique_lock<stdx::mutex> lk(mutex);
cv.wait(lk, [&] { return end; });
}};
while (Listener::globalTicketHolder.used() == 0) {
}
tll.endAllSessions(transport::Session::TagMask{});
while (Listener::globalTicketHolder.used() == 1) {
}
{
stdx::lock_guard<stdx::mutex> lk(mutex);
end = true;
cv.notify_one();
}
thr.join();
ASSERT(Listener::globalTicketHolder.used() == 0);
tll.shutdown();
}
} // namespace
} // namespace mongo
| 32.526786
| 98
| 0.690914
|
SCC-RHUL-Projects
|
103d9d79352720768d8e12d017b4961cda5f0a2e
| 19,028
|
cpp
|
C++
|
ace/Naming_Context.cpp
|
xiafuyang2004/ACEFileService
|
51a330cdf2515919abe102bac5fec995fbe89cca
|
[
"MIT"
] | null | null | null |
ace/Naming_Context.cpp
|
xiafuyang2004/ACEFileService
|
51a330cdf2515919abe102bac5fec995fbe89cca
|
[
"MIT"
] | null | null | null |
ace/Naming_Context.cpp
|
xiafuyang2004/ACEFileService
|
51a330cdf2515919abe102bac5fec995fbe89cca
|
[
"MIT"
] | 1
|
2020-02-22T08:42:22.000Z
|
2020-02-22T08:42:22.000Z
|
// $Id: Naming_Context.cpp 84565 2009-02-23 08:20:39Z johnnyw $
#include "ace/Get_Opt.h"
#include "ace/Naming_Context.h"
#include "ace/Remote_Name_Space.h"
#include "ace/Local_Name_Space_T.h"
#include "ace/Registry_Name_Space.h"
#include "ace/MMAP_Memory_Pool.h"
#include "ace/RW_Process_Mutex.h"
#include "ace/OS_NS_string.h"
#include "ace/OS_NS_unistd.h"
#if defined (ACE_HAS_TRACE)
# include "ace/OS_NS_strings.h"
# include "ace/Trace.h"
#endif /* ACE_HAS_TRACE */
ACE_RCSID(ace, Naming_Context, "$Id: Naming_Context.cpp 84565 2009-02-23 08:20:39Z johnnyw $")
#if !defined (__ACE_INLINE__)
#include "ace/Naming_Context.inl"
#endif /* __ACE_INLINE__ */
ACE_BEGIN_VERSIONED_NAMESPACE_DECL
// Make life easier later on...
typedef ACE_Local_Name_Space <ACE_MMAP_MEMORY_POOL, ACE_RW_Process_Mutex> LOCAL_NAME_SPACE;
typedef ACE_Local_Name_Space <ACE_LITE_MMAP_MEMORY_POOL, ACE_RW_Process_Mutex> LITE_LOCAL_NAME_SPACE;
// The ACE_Naming_Context static service object is now defined
// by the ACE_Object_Manager, in Object_Manager.cpp.
int
ACE_Naming_Context::info (ACE_TCHAR **strp,
size_t length) const
{
ACE_TRACE ("ACE_Naming_Context::info");
ACE_TCHAR buf[BUFSIZ];
ACE_OS::sprintf (buf,
ACE_TEXT ("%s\t#%s\n"),
ACE_TEXT ("ACE_Naming_Context"),
ACE_TEXT ("Proxy for making calls to a Name Server"));
if (*strp == 0 && (*strp = ACE_OS::strdup (buf)) == 0)
return -1;
else
ACE_OS::strsncpy (*strp, buf, length);
return static_cast<int> (ACE_OS::strlen (buf));
}
int
ACE_Naming_Context::local (void)
{
ACE_TRACE ("ACE_Naming_Context::local");
return ACE_OS::strcmp (this->netnameserver_host_,
ACE_TEXT ("localhost")) == 0
|| ACE_OS::strcmp (this->netnameserver_host_,
this->hostname_) == 0;
}
int
ACE_Naming_Context::open (Context_Scope_Type scope_in, int lite)
{
ACE_TRACE ("ACE_Naming_Context::open");
ACE_OS::hostname (this->hostname_,
(sizeof this->hostname_ / sizeof (ACE_TCHAR)));
this->netnameserver_host_ =
this->name_options_->nameserver_host ();
this->netnameserver_port_ =
this->name_options_->nameserver_port ();
// Perform factory operation to select appropriate type of
// Name_Space subclass.
#if (defined (ACE_WIN32) && defined (ACE_USES_WCHAR))
// This only works on Win32 platforms when ACE_USES_WCHAR is turned on
if (this->name_options_->use_registry ())
// Use ACE_Registry
ACE_NEW_RETURN (this->name_space_,
ACE_Registry_Name_Space (this->name_options_),
-1);
#endif /* ACE_WIN32 && ACE_USES_WCHAR */
if (!this->name_options_->use_registry ())
{
if (scope_in == ACE_Naming_Context::NET_LOCAL && this->local () == 0)
{
// Use NET_LOCAL name space, set up connection with remote server.
ACE_NEW_RETURN (this->name_space_,
ACE_Remote_Name_Space (this->netnameserver_host_,
(u_short) this->netnameserver_port_),
-1);
}
else // Use NODE_LOCAL or PROC_LOCAL name space.
{
if (lite)
ACE_NEW_RETURN (this->name_space_,
LITE_LOCAL_NAME_SPACE (scope_in,
this->name_options_),
-1);
else
ACE_NEW_RETURN (this->name_space_,
LOCAL_NAME_SPACE (scope_in,
this->name_options_),
-1);
}
}
if (ACE_LOG_MSG->op_status () != 0 || this->name_space_ == 0)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("NAME_SPACE::NAME_SPACE\n")),
-1);
return 0;
}
int
ACE_Naming_Context::close_down (void)
{
ACE_TRACE ("ACE_Naming_Context::close_down");
delete this->name_options_;
this->name_options_ = 0;
return this->close ();
}
int
ACE_Naming_Context::close (void)
{
ACE_TRACE ("ACE_Naming_Context::close");
delete this->name_space_;
this->name_space_ = 0;
return 0;
}
ACE_Naming_Context::ACE_Naming_Context (void)
: name_options_ (0),
name_space_ (0)
{
ACE_TRACE ("ACE_Naming_Context::ACE_Naming_Context");
ACE_NEW (this->name_options_,
ACE_Name_Options);
}
ACE_Naming_Context::ACE_Naming_Context (Context_Scope_Type scope_in,
int lite)
: name_options_ (0),
name_space_ (0),
netnameserver_host_ (0)
{
ACE_TRACE ("ACE_Naming_Context::ACE_Naming_Context");
ACE_NEW (this->name_options_,
ACE_Name_Options);
// Initialize.
if (this->open (scope_in, lite) == -1)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("ACE_Naming_Context::ACE_Naming_Context")));
}
ACE_Name_Options *
ACE_Naming_Context::name_options (void)
{
return this->name_options_;
}
int
ACE_Naming_Context::bind (const ACE_NS_WString &name_in,
const ACE_NS_WString &value_in,
const char *type_in)
{
ACE_TRACE ("ACE_Naming_Context::bind");
return this->name_space_->bind (name_in, value_in, type_in);
}
int
ACE_Naming_Context::bind (const char *name_in,
const char *value_in,
const char *type_in)
{
ACE_TRACE ("ACE_Naming_Context::bind");
return this->bind (ACE_NS_WString (name_in),
ACE_NS_WString (value_in),
type_in);
}
int
ACE_Naming_Context::rebind (const ACE_NS_WString &name_in,
const ACE_NS_WString &value_in,
const char *type_in)
{
ACE_TRACE ("ACE_Naming_Context::rebind");
return this->name_space_->rebind (name_in,
value_in,
type_in);
}
int
ACE_Naming_Context::rebind (const char *name_in,
const char *value_in,
const char *type_in)
{
ACE_TRACE ("ACE_Naming_Context::rebind");
return rebind (ACE_NS_WString (name_in),
ACE_NS_WString (value_in),
type_in);
}
int
ACE_Naming_Context::resolve (const ACE_NS_WString &name_in,
ACE_NS_WString &value_out,
char *&type_out)
{
ACE_TRACE ("ACE_Naming_Context::resolve");
return this->name_space_->resolve (name_in,
value_out,
type_out);
}
int
ACE_Naming_Context::resolve (const char *name_in,
ACE_NS_WString &value_out,
char *&type_out)
{
ACE_TRACE ("ACE_Naming_Context::resolve");
return this->resolve (ACE_NS_WString (name_in),
value_out,
type_out);
}
int
ACE_Naming_Context::resolve (const char *name_in,
char *&value_out,
char *&type_out)
{
ACE_TRACE ("ACE_Naming_Context::resolve");
ACE_NS_WString val_str;
if (this->resolve (ACE_NS_WString (name_in),
val_str,
type_out) == -1)
return -1;
// Note that <char_rep> *allocates* the memory! Thus, caller is
// responsible for deleting it!
value_out = val_str.char_rep ();
return value_out == 0 ? -1 : 0;
}
int
ACE_Naming_Context::unbind (const ACE_NS_WString &name_in)
{
ACE_TRACE ("ACE_Naming_Context::unbind");
return this->name_space_->unbind (name_in);
}
int
ACE_Naming_Context::unbind (const char *name_in)
{
ACE_TRACE ("ACE_Naming_Context::unbind");
return this->unbind (ACE_NS_WString (name_in));
}
int
ACE_Naming_Context::list_names (ACE_PWSTRING_SET &set_out,
const ACE_NS_WString &pattern_in)
{
ACE_TRACE ("ACE_Naming_Context::list_names");
return this->name_space_->list_names (set_out,
pattern_in);
}
int
ACE_Naming_Context::list_names (ACE_PWSTRING_SET &set_out,
const char *pattern_in)
{
ACE_TRACE ("ACE_Naming_Context::list_names");
return this->list_names (set_out,
ACE_NS_WString (pattern_in));
}
int
ACE_Naming_Context::list_values (ACE_PWSTRING_SET &set_out,
const ACE_NS_WString &pattern_in)
{
ACE_TRACE ("ACE_Naming_Context::list_values");
return this->name_space_->list_values (set_out,
pattern_in);
}
int
ACE_Naming_Context::list_values (ACE_PWSTRING_SET &set_out,
const char *pattern_in)
{
ACE_TRACE ("ACE_Naming_Context::list_values");
return this->list_values (set_out,
ACE_NS_WString (pattern_in));
}
int
ACE_Naming_Context::list_types (ACE_PWSTRING_SET &set_out,
const ACE_NS_WString &pattern_in)
{
ACE_TRACE ("ACE_Naming_Context::list_types");
return this->name_space_->list_types (set_out,
pattern_in);
}
int
ACE_Naming_Context::list_types (ACE_PWSTRING_SET &set_out,
const char *pattern_in)
{
ACE_TRACE ("ACE_Naming_Context::list_types");
return this->list_types (set_out,
ACE_NS_WString (pattern_in));
}
int
ACE_Naming_Context::list_name_entries (ACE_BINDING_SET &set_out,
const ACE_NS_WString &pattern_in)
{
ACE_TRACE ("ACE_Naming_Context::list_name_entries");
return this->name_space_->list_name_entries (set_out,
pattern_in);
}
int
ACE_Naming_Context::list_name_entries (ACE_BINDING_SET &set_out,
const char *pattern_in)
{
ACE_TRACE ("ACE_Naming_Context::list_name_entries");
return this->list_name_entries (set_out,
ACE_NS_WString (pattern_in));
}
int
ACE_Naming_Context::list_value_entries (ACE_BINDING_SET &set_out,
const ACE_NS_WString &pattern_in)
{
ACE_TRACE ("ACE_Naming_Context::list_value_entries");
return this->name_space_->list_value_entries (set_out,
pattern_in);
}
int
ACE_Naming_Context::list_value_entries (ACE_BINDING_SET &set_out,
const char *pattern_in)
{
ACE_TRACE ("ACE_Naming_Context::list_value_entries");
return this->list_value_entries (set_out,
ACE_NS_WString (pattern_in));
}
int
ACE_Naming_Context::list_type_entries (ACE_BINDING_SET &set_out,
const ACE_NS_WString &pattern_in)
{
ACE_TRACE ("ACE_Naming_Context::list_type_entries");
return this->name_space_->list_type_entries (set_out,
pattern_in);
}
int
ACE_Naming_Context::list_type_entries (ACE_BINDING_SET &set_out,
const char *pattern_in)
{
ACE_TRACE ("ACE_Naming_Context::list_type_entries");
return this->list_type_entries (set_out,
ACE_NS_WString (pattern_in));
}
ACE_Naming_Context::~ACE_Naming_Context (void)
{
ACE_TRACE ("ACE_Naming_Context::~ACE_Naming_Context");
this->close_down ();
}
void
ACE_Naming_Context::dump ()
{
#if defined (ACE_HAS_DUMP)
ACE_TRACE ("ACE_Naming_Context::dump");
this->name_space_->dump();
#endif /* ACE_HAS_DUMP */
}
int
ACE_Naming_Context::init (int argc, ACE_TCHAR *argv[])
{
if (ACE::debug ())
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("ACE_Naming_Context::init\n")));
this->name_options_->parse_args (argc, argv);
return this->open (this->name_options_->context ());
}
int
ACE_Naming_Context::fini (void)
{
if (ACE::debug ())
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("ACE_Naming_Context::fini\n")));
this->close_down ();
return 0;
}
ACE_Name_Options::ACE_Name_Options (void)
: debugging_ (false),
verbosity_ (false),
use_registry_ (false),
nameserver_port_ (ACE_DEFAULT_SERVER_PORT),
nameserver_host_ (ACE_OS::strdup (ACE_DEFAULT_SERVER_HOST)),
process_name_ (0),
database_ (ACE_OS::strdup (ACE_DEFAULT_LOCALNAME)),
base_address_ (ACE_DEFAULT_BASE_ADDR)
{
ACE_TRACE ("ACE_Name_Options::ACE_Name_Options");
#if defined (ACE_DEFAULT_NAMESPACE_DIR)
this->namespace_dir_ = ACE_OS::strdup (ACE_DEFAULT_NAMESPACE_DIR);
#else /* ACE_DEFAULT_NAMESPACE_DIR */
size_t pathsize = (MAXPATHLEN + 1) * sizeof (ACE_TCHAR);
this->namespace_dir_ = static_cast <ACE_TCHAR *> (ACE_OS::malloc (pathsize));
if (ACE::get_temp_dir (this->namespace_dir_, MAXPATHLEN) == -1)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Temporary path too long, ")
ACE_TEXT ("defaulting to current directory\n")));
ACE_OS::strcpy (this->namespace_dir_, ACE_TEXT ("."));
ACE_OS::strcat (this->namespace_dir_, ACE_DIRECTORY_SEPARATOR_STR);
}
#endif /* ACE_DEFAULT_NAMESPACE_DIR */
}
ACE_Name_Options::~ACE_Name_Options (void)
{
ACE_TRACE ("ACE_Name_Options::~ACE_Name_Options");
ACE_OS::free ((void *) this->nameserver_host_);
ACE_OS::free ((void *) this->namespace_dir_ );
ACE_OS::free ((void *) this->process_name_ );
ACE_OS::free ((void *) this->database_ );
}
void
ACE_Name_Options::nameserver_port (int port)
{
ACE_TRACE ("ACE_Name_Options::nameserver_port");
this->nameserver_port_ = port;
}
int
ACE_Name_Options::nameserver_port (void)
{
ACE_TRACE ("ACE_Name_Options::nameserver_port");
return this->nameserver_port_;
}
void
ACE_Name_Options::namespace_dir (const ACE_TCHAR *dir)
{
ACE_TRACE ("ACE_Name_Options::namespace_dir");
ACE_OS::free ((void *) this->namespace_dir_ );
this->namespace_dir_ = ACE_OS::strdup (dir);
}
void
ACE_Name_Options::process_name (const ACE_TCHAR *pname)
{
ACE_TRACE ("ACE_Name_Options::process_name");
const ACE_TCHAR *t = ACE::basename (pname, ACE_DIRECTORY_SEPARATOR_CHAR);
ACE_OS::free ((void *) this->process_name_ );
this->process_name_ = ACE_OS::strdup (t);
}
void
ACE_Name_Options::nameserver_host (const ACE_TCHAR *host)
{
ACE_TRACE ("ACE_Name_Options::nameserver_host");
ACE_OS::free ((void *) this->nameserver_host_);
this->nameserver_host_ = ACE_OS::strdup (host);
}
const ACE_TCHAR *
ACE_Name_Options::nameserver_host (void)
{
ACE_TRACE ("ACE_Name_Options::nameserver_host");
return this->nameserver_host_;
}
const ACE_TCHAR *
ACE_Name_Options::database (void)
{
ACE_TRACE ("ACE_Name_Options::database");
return this->database_;
}
void
ACE_Name_Options::database (const ACE_TCHAR *db)
{
ACE_TRACE ("ACE_Name_Options::database");
ACE_OS::free ((void *) this->database_);
this->database_ = ACE_OS::strdup (db);
}
char *
ACE_Name_Options::base_address (void)
{
ACE_TRACE ("ACE_Name_Options::base_address");
return this->base_address_;
}
void
ACE_Name_Options::base_address (char *base_address)
{
ACE_TRACE ("ACE_Name_Options::base_address");
this->base_address_ = base_address;
}
ACE_Naming_Context::Context_Scope_Type
ACE_Name_Options::context (void)
{
ACE_TRACE ("ACE_Name_Options::context");
return this->context_;
}
void
ACE_Name_Options::context (ACE_Naming_Context::Context_Scope_Type context)
{
ACE_TRACE ("ACE_Name_Options::context");
this->context_ = context;
}
void
ACE_Name_Options::parse_args (int argc, ACE_TCHAR *argv[])
{
ACE_TRACE ("ACE_Name_Options::parse_args");
const ACE_TCHAR* program_name = 0;
// Argc can be 0 on some platforms like VxWorks.
if (argc > 0)
program_name = argv[0];
ACE_LOG_MSG->open (program_name);
this->process_name (program_name);
// Default is to use the PROC_LOCAL context...
this->context (ACE_Naming_Context::PROC_LOCAL);
// Make the database name the same as the process name by default
// (note that this makes a copy of the process_name_ so that we can
// clean it up in the destructor).
this->database (this->process_name ());
ACE_Get_Opt get_opt (argc, argv, ACE_TEXT ("b:c:dh:l:P:p:s:T:vr"));
for (int c; (c = get_opt ()) != -1; )
switch (c)
{
case 'c':
{
if (ACE_OS::strcmp (get_opt.opt_arg (), ACE_TEXT ("PROC_LOCAL")) == 0)
this->context (ACE_Naming_Context::PROC_LOCAL);
else if (ACE_OS::strcmp (get_opt.opt_arg (), ACE_TEXT ("NODE_LOCAL")) == 0)
this->context (ACE_Naming_Context::NODE_LOCAL);
else if (ACE_OS::strcmp (get_opt.opt_arg (), ACE_TEXT ("NET_LOCAL")) == 0)
this->context (ACE_Naming_Context::NET_LOCAL);
}
break;
case 'd':
this->debugging_ = true;
break;
case 'r':
this->use_registry_ = true;
break;
case 'h':
this->nameserver_host (get_opt.opt_arg ());
break;
case 'l':
this->namespace_dir (get_opt.opt_arg ());
break;
case 'P':
this->process_name (get_opt.opt_arg ());
break;
case 'p':
this->nameserver_port (ACE_OS::atoi (get_opt.opt_arg ()));
break;
case 's':
this->database (get_opt.opt_arg ());
break;
case 'b':
this->base_address
(static_cast<char *> (ACE_OS::atop (get_opt.opt_arg ())));
break;
case 'T':
#if defined (ACE_HAS_TRACE)
if (ACE_OS::strcasecmp (get_opt.opt_arg (), ACE_TEXT ("ON")) == 0)
ACE_Trace::start_tracing ();
else if (ACE_OS::strcasecmp (get_opt.opt_arg (), ACE_TEXT ("OFF")) == 0)
ACE_Trace::stop_tracing ();
#endif /* ACE_HAS_TRACE */
break;
case 'v':
this->verbosity_ = true;
break;
default:
ACE_OS::fprintf (stderr, "%s\n"
"\t[-d] (enable debugging)\n"
"\t[-h nameserver host]\n"
"\t[-l namespace directory]\n"
"\t[-P processname]\n"
"\t[-p nameserver port]\n"
"\t[-s database name]\n"
"\t[-b base address]\n"
"\t[-v] (verbose)\n"
"\t[-r] (use Win32 Registry)\n",
argv[0]);
/* NOTREACHED */
break;
}
}
ACE_END_VERSIONED_NAMESPACE_DECL
// The following Factory is used by the ACE_Service_Config and
// svc.conf file to dynamically initialize the state of the Name
// Server client.
ACE_FACTORY_DEFINE (ACE, ACE_Naming_Context)
ACE_STATIC_SVC_DEFINE (ACE_Naming_Context,
ACE_TEXT ("ACE_Naming_Context"),
ACE_SVC_OBJ_T,
&ACE_SVC_NAME (ACE_Naming_Context),
ACE_Service_Type::DELETE_THIS |
ACE_Service_Type::DELETE_OBJ,
0)
ACE_STATIC_SVC_REQUIRE (ACE_Naming_Context)
| 29.273846
| 101
| 0.616302
|
xiafuyang2004
|
103f662a3cb3c9ef1321388a06af822529a21c15
| 2,106
|
cc
|
C++
|
tcpevent/eventloop.cc
|
sonyangchang/mycodecollection
|
d56149742f71ae7ae03f5a92bd009edbb4d5d3c6
|
[
"Apache-2.0"
] | 1
|
2020-10-18T02:00:01.000Z
|
2020-10-18T02:00:01.000Z
|
tcpevent/eventloop.cc
|
sonyangchang/mycodecollection
|
d56149742f71ae7ae03f5a92bd009edbb4d5d3c6
|
[
"Apache-2.0"
] | null | null | null |
tcpevent/eventloop.cc
|
sonyangchang/mycodecollection
|
d56149742f71ae7ae03f5a92bd009edbb4d5d3c6
|
[
"Apache-2.0"
] | 1
|
2020-10-18T02:00:03.000Z
|
2020-10-18T02:00:03.000Z
|
/*
* eventloop.cc
*
* Created on: 2018年8月4日
* Author: LENOVO
*/
#include "eventloop.h"
#include "flag.h"
#include "tcp.h"
#include <malloc.h>
#include <memory.h>
#include <unistd.h>
namespace zsy
{
EventLoop::EventLoop(int maxpoll)
{
m_events=(struct epoll_event*)malloc(maxpoll*sizeof(struct epoll_event));
m_efd=epoll_create(maxpoll);
}
EventLoop::~EventLoop(){}
void EventLoop::loop(){
int fds=m_fds;
int retval=0;
int i=0;
for(auto it=m_free_sessions.begin();it!=m_free_sessions.end();)
{
delete *it;
m_free_sessions.erase(it++);
}
retval=epoll_wait(m_efd,m_events,fds,-1);
if(retval>0)
{
for(i=0;i<retval;i++)
{
TcpInterface *tcp=static_cast<TcpInterface*>(m_events[i].data.ptr);
if(m_events[i].events&EPOLLIN)
{
tcp->OnIncomingEvent();
}
if(m_events[i].events&EPOLLOUT)
{
tcp->OnWriteEvent();
}
}
}
}
void EventLoop::FreeSession(TcpInterface*object)
{
m_free_sessions.push_back(object);
}
void EventLoop::ExitGrace(){
for(auto it=m_free_sessions.begin();it!=m_free_sessions.end();)
{
delete *it;
m_free_sessions.erase(it++);
}
close(m_efd);
}
int EventLoop::AddEvent(void *object,int fd,int mask){
struct epoll_event ee;
ee.events = 0;
if (mask & AE_READABLE) ee.events |= EPOLLIN;
if (mask & AE_WRITABLE) ee.events |= EPOLLOUT;
ee.data.u64 = 0;
ee.data.ptr=object;
if( epoll_ctl(m_efd, EPOLL_CTL_ADD, fd, &ee ) < 0){
return -1;
}
m_fds++;
return 0;
}
int EventLoop::DelEvent(void *object,int fd){
struct epoll_event ee;
ee.events = 0;
ee.data.u64 = 0;
ee.data.ptr=object;
epoll_ctl( m_efd, EPOLL_CTL_DEL,fd, &ee );
m_fds--;
return 0;
}
int EventLoop::ModifyEvent(void*object,int fd,int mask){
struct epoll_event ee;
ee.events = 0;
if (mask & AE_READABLE) ee.events |= EPOLLIN;
if (mask & AE_WRITABLE) ee.events |= EPOLLOUT;
ee.data.u64 = 0;
ee.data.ptr=object;
if( epoll_ctl(m_efd, EPOLL_CTL_MOD, fd, &ee ) < 0){
return -1;
}
return 0;
}
}
| 21.272727
| 75
| 0.625356
|
sonyangchang
|
1040bf145eb3edbfe8ccd7ca383748498f5d12d8
| 4,315
|
cc
|
C++
|
test/extensions/access_loggers/wasm/config_test.cc
|
driev/envoy
|
d04ea855ae99e744ea5ed3df0e0234e301d9e081
|
[
"Apache-2.0"
] | 2
|
2021-04-22T21:38:58.000Z
|
2021-04-22T21:39:40.000Z
|
test/extensions/access_loggers/wasm/config_test.cc
|
driev/envoy
|
d04ea855ae99e744ea5ed3df0e0234e301d9e081
|
[
"Apache-2.0"
] | 8
|
2022-03-01T20:32:32.000Z
|
2022-03-23T22:08:49.000Z
|
test/extensions/access_loggers/wasm/config_test.cc
|
yanavlasov/envoy
|
2b8a744bf0b77717be889d4f514edd22a76cbe8e
|
[
"Apache-2.0"
] | 2
|
2021-02-18T18:25:58.000Z
|
2021-03-30T18:30:26.000Z
|
#include "envoy/extensions/access_loggers/wasm/v3/wasm.pb.h"
#include "envoy/registry/registry.h"
#include "common/access_log/access_log_impl.h"
#include "common/protobuf/protobuf.h"
#include "extensions/access_loggers/wasm/config.h"
#include "extensions/access_loggers/wasm/wasm_access_log_impl.h"
#include "extensions/access_loggers/well_known_names.h"
#include "extensions/common/wasm/wasm.h"
#include "test/extensions/common/wasm/wasm_runtime.h"
#include "test/mocks/server/mocks.h"
#include "test/test_common/environment.h"
#include "test/test_common/printers.h"
#include "test/test_common/utility.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
namespace Envoy {
namespace Extensions {
namespace AccessLoggers {
namespace Wasm {
class TestFactoryContext : public NiceMock<Server::Configuration::MockFactoryContext> {
public:
TestFactoryContext(Api::Api& api, Stats::Scope& scope) : api_(api), scope_(scope) {}
Api::Api& api() override { return api_; }
Stats::Scope& scope() override { return scope_; }
const envoy::config::core::v3::Metadata& listenerMetadata() const override {
return listener_metadata_;
}
private:
Api::Api& api_;
Stats::Scope& scope_;
envoy::config::core::v3::Metadata listener_metadata_;
};
class WasmAccessLogConfigTest : public testing::TestWithParam<std::string> {};
INSTANTIATE_TEST_SUITE_P(Runtimes, WasmAccessLogConfigTest,
Envoy::Extensions::Common::Wasm::runtime_values);
TEST_P(WasmAccessLogConfigTest, CreateWasmFromEmpty) {
auto factory =
Registry::FactoryRegistry<Server::Configuration::AccessLogInstanceFactory>::getFactory(
AccessLogNames::get().Wasm);
ASSERT_NE(factory, nullptr);
ProtobufTypes::MessagePtr message = factory->createEmptyConfigProto();
ASSERT_NE(nullptr, message);
AccessLog::FilterPtr filter;
NiceMock<Server::Configuration::MockFactoryContext> context;
AccessLog::InstanceSharedPtr instance;
EXPECT_THROW_WITH_MESSAGE(
instance = factory->createAccessLogInstance(*message, std::move(filter), context),
Common::Wasm::WasmException, "Unable to create Wasm access log ");
}
TEST_P(WasmAccessLogConfigTest, CreateWasmFromWASM) {
#if defined(__aarch64__)
// TODO(PiotrSikora): There are no Emscripten releases for arm64.
if (GetParam() != "null") {
return;
}
#endif
auto factory =
Registry::FactoryRegistry<Server::Configuration::AccessLogInstanceFactory>::getFactory(
AccessLogNames::get().Wasm);
ASSERT_NE(factory, nullptr);
envoy::extensions::access_loggers::wasm::v3::WasmAccessLog config;
config.mutable_config()->mutable_vm_config()->set_runtime(
absl::StrCat("envoy.wasm.runtime.", GetParam()));
std::string code;
if (GetParam() != "null") {
code = TestEnvironment::readFileToStringForTest(TestEnvironment::substitute(
"{{ test_rundir }}/test/extensions/access_loggers/wasm/test_data/test_cpp.wasm"));
} else {
code = "AccessLoggerTestCpp";
}
config.mutable_config()->mutable_vm_config()->mutable_code()->mutable_local()->set_inline_bytes(
code);
// Test Any configuration.
ProtobufWkt::Struct some_proto;
config.mutable_config()->mutable_vm_config()->mutable_configuration()->PackFrom(some_proto);
AccessLog::FilterPtr filter;
Stats::IsolatedStoreImpl stats_store;
Api::ApiPtr api = Api::createApiForTest(stats_store);
TestFactoryContext context(*api, stats_store);
AccessLog::InstanceSharedPtr instance =
factory->createAccessLogInstance(config, std::move(filter), context);
EXPECT_NE(nullptr, instance);
EXPECT_NE(nullptr, dynamic_cast<WasmAccessLog*>(instance.get()));
Http::TestRequestHeaderMapImpl request_header;
Http::TestResponseHeaderMapImpl response_header;
Http::TestResponseTrailerMapImpl response_trailer;
StreamInfo::MockStreamInfo log_stream_info;
instance->log(&request_header, &response_header, &response_trailer, log_stream_info);
filter = std::make_unique<NiceMock<AccessLog::MockFilter>>();
AccessLog::InstanceSharedPtr filter_instance =
factory->createAccessLogInstance(config, std::move(filter), context);
filter_instance->log(&request_header, &response_header, &response_trailer, log_stream_info);
}
} // namespace Wasm
} // namespace AccessLoggers
} // namespace Extensions
} // namespace Envoy
| 36.880342
| 98
| 0.755736
|
driev
|
1041e56c9f7bfa116c3fa95d4da4e351676c754e
| 632
|
cpp
|
C++
|
10-stl-containers/4-maps/loops.cpp
|
nofar88/cpp-5782
|
473c68627fc0908fdef8956caf1e1d2267c9417b
|
[
"MIT"
] | 14
|
2021-01-30T16:36:18.000Z
|
2022-03-30T17:24:44.000Z
|
10-stl-containers/4-maps/loops.cpp
|
dimastar2310/cpp-5781
|
615ba07e0841522df74384f380172557f5e305a7
|
[
"MIT"
] | 1
|
2022-03-02T20:55:14.000Z
|
2022-03-02T20:55:14.000Z
|
10-stl-containers/4-maps/loops.cpp
|
dimastar2310/cpp-5781
|
615ba07e0841522df74384f380172557f5e305a7
|
[
"MIT"
] | 16
|
2021-03-02T11:13:41.000Z
|
2021-07-09T14:18:15.000Z
|
/**
* Demonstrates iteration on stl maps
*
* @author Erel Segal-Halevi
* @since 2018-05
*/
#include <map>
#include <iostream>
using namespace std;
map<string, int> m {
{"abc", 2},
{"xyz", 8},
};
int main() {
m["def"] = 4;
m["ghi"] = 6;
// Old version:
for (map<string, int>::iterator iter = m.begin(); iter!=m.end(); ++iter)
cout << iter->first << "," << iter->second << endl;
cout << endl;
// C++11 version:
for (const auto& pair: m)
cout << pair.first << "," << pair.second << endl;
cout << endl;
// C++17 version:
for (auto [key,value]: m)
cout << key << "," << value << endl;
cout << endl;
}
| 17.555556
| 74
| 0.544304
|
nofar88
|
1042bcab45f1b1255b15dbaf9b0e71468721d1b3
| 2,720
|
hpp
|
C++
|
include/ssm-proxy.hpp
|
Kamiya-T/Distributed-Streaming-data-Sharing-Manager
|
d615f0062c507b89d35398833544380bbc4240ae
|
[
"MIT"
] | null | null | null |
include/ssm-proxy.hpp
|
Kamiya-T/Distributed-Streaming-data-Sharing-Manager
|
d615f0062c507b89d35398833544380bbc4240ae
|
[
"MIT"
] | 1
|
2019-12-19T04:14:55.000Z
|
2019-12-19T05:53:12.000Z
|
include/ssm-proxy.hpp
|
Kamiya-T/Distributed-Streaming-data-Sharing-Manager
|
d615f0062c507b89d35398833544380bbc4240ae
|
[
"MIT"
] | 1
|
2021-01-07T05:49:17.000Z
|
2021-01-07T05:49:17.000Z
|
#ifndef _SSM_PROXY_H_
#define _SSM_PROXY_H_
#include "ssm.hpp"
void test();
#define SERVER_PORT 8080 /* サーバ用PORT */
#define SERVER_IP 0x00000000UL /* サーバ用待ち受けIP */
#define BUFFER_SIZE 1024 /* バッファバイト数 */
/* クライアントからの接続を待つサーバの情報を表現する構造体 */
typedef struct {
int wait_socket; /* サーバ待ち受け用ソケット */
struct sockaddr_in server_addr; /* サーバ待ち受け用アドレス */
} TCPSERVER_INFO;
/* クライアントとの接続に関する情報を保存する構造体 */
typedef struct {
int data_socket; /* クライアントとの通信用ソケット */
struct sockaddr_in client_addr; /* クライアントのアドレス */
} TCPCLIENT_INFO;
#include "Thread.hpp"
class ProxyServer;
class DataCommunicator : public Thread {
private:
TCPSERVER_INFO server;
TCPCLIENT_INFO client;
char* mData;
uint64_t mDataSize;
uint64_t ssmTimeSize;
uint64_t mFullDataSize;
PROXY_open_mode mType;
uint32_t thrdMsgLen;
char* buf;
SSMApiBase *pstream;
ProxyServer* proxy;
bool sopen();
bool rwait();
bool sclose();
bool receiveTMsg(thrd_msg *tmsg);
bool deserializeTmsg(thrd_msg *tmsg);
bool serializeTmsg(thrd_msg *tmsg);
bool sendTMsg(thrd_msg *tmsg);
bool sendBulkData(char* buf, uint64_t size);
void handleData();
void handleRead();
bool receiveData();
public:
DataCommunicator() = delete;
DataCommunicator(uint16_t nport, char* mData, uint64_t d_size, uint64_t t_size,
SSMApiBase *pstream, PROXY_open_mode type, ProxyServer* proxy);
~DataCommunicator();
void* run(void *args);
};
class ProxyServer {
private:
TCPSERVER_INFO server;
TCPCLIENT_INFO client;
uint16_t nport; // センサデータ受信用のポート番号.子プロセスが生成されるたびにインクリメントしていく
char* mData; // データ用
uint64_t mDataSize; // データサイズ
uint64_t ssmTimeSize; // ssmTimeTのサイズ
uint64_t mFullDataSize; // mDataSize + ssmTimeSize
char *mProperty;
uint64_t mPropertySize;
PROXY_open_mode mType;
DataCommunicator *com;
SSMApiBase stream; // real stream
uint32_t dssmMsgLen;
bool open();
bool wait();
void setSSMType(PROXY_open_mode mode);
int receiveMsg(ssm_msg *msg, char *buf);
int sendMsg(int cmd_type, ssm_msg *msg);
void setupSigHandler();
static void catchSignal(int signo);
public:
ProxyServer();
~ProxyServer();
bool init();
bool run();
bool server_close();
bool client_close();
void handleCommand();
int readInt(char **p);
uint64_t readLong(char **p);
double readDouble(char **p);
void readRawData(char **p, char *d, int len);
void writeInt(char **p, int v);
void writeLong(char **p, uint64_t v);
void writeDouble(char **p, double v);
void writeRawData(char **p, char *d, int len);
void deserializeMessage(ssm_msg *msg, char *buf);
};
#endif
| 22.113821
| 81
| 0.688971
|
Kamiya-T
|
10436864192585229bc52c1c46891eaf2aafa396
| 7,484
|
hpp
|
C++
|
extlib/include/xyginext/ecs/System.hpp
|
fallahn/speljongen
|
57cb5e09eec7db8c21ee7b3e7943fa0a76738c51
|
[
"Unlicense"
] | 17
|
2018-06-23T14:40:56.000Z
|
2019-07-02T11:58:55.000Z
|
extlib/include/xyginext/ecs/System.hpp
|
fallahn/speljongen
|
57cb5e09eec7db8c21ee7b3e7943fa0a76738c51
|
[
"Unlicense"
] | 3
|
2018-06-23T12:35:12.000Z
|
2018-06-23T12:38:54.000Z
|
extlib/include/xyginext/ecs/System.hpp
|
fallahn/speljongen
|
57cb5e09eec7db8c21ee7b3e7943fa0a76738c51
|
[
"Unlicense"
] | null | null | null |
/*********************************************************************
(c) Matt Marchant 2017 - 2019
http://trederia.blogspot.com
xygineXT - Zlib license.
This software is provided 'as-is', without any express or
implied warranty. In no event will the authors be held
liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute
it freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented;
you must not claim that you wrote the original software.
If you use this software in a product, an acknowledgment
in the product documentation would be appreciated but
is not required.
2. Altered source versions must be plainly marked as such,
and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any
source distribution.
*********************************************************************/
#pragma once
#include "xyginext/Config.hpp"
#include "xyginext/ecs/Entity.hpp"
#include "xyginext/ecs/Component.hpp"
#include "xyginext/core/MessageBus.hpp"
#include <vector>
#include <typeindex>
namespace xy
{
class Scene;
class ComponentManager;
using UniqueType = std::type_index;
/*!
\brief Base class for systems.
Systems should all derive from this base class, and instanciated before any entities
are created. Concrete system types should declare a list component types via requireComponent()
on construction, so that only entities with the relevant components are added to the system.
*/
class XY_EXPORT_API System
{
public:
using Ptr = std::unique_ptr<System>;
/*!
\brief Constructor.
Pass in a reference to the concrete implementation to generate
a unique type ID for this system.
*/
System(MessageBus& mb, UniqueType t)
: m_messageBus(mb), m_type(t), m_scene(nullptr), m_active(false){}
virtual ~System() = default;
/*!
\brief Returns the unique type ID of the system
*/
UniqueType getType() const { return m_type; }
/*!
\brief Returns a list of entities that this system is currently interested in
*/
std::vector<Entity> getEntities() const;
/*!
\brief Adds an entity to the list to process
*/
void addEntity(Entity);
/*!
\brief Removes an entity from the list to process
*/
void removeEntity(Entity);
/*!
\brief Returns the component mask used to mask entities with corresponding
components for this system to process
*/
const ComponentMask& getComponentMask() const;
/*!
\brief Used to process any incoming system messages
*/
virtual void handleMessage(const Message&);
/*!
\brief Implement this for system specific processing to entities.
*/
virtual void process(float);
/*!
\brief Returns true if the system is currently active.
Systems can be activeated and deactivated with Scene::setSystemActive()
*/
bool isActive() const { return m_active; }
protected:
/*!
\brief Adds a component type to the list of components required by the
system for it to be interested in a particular entity. This should only
be used in the constructor of the System else types will not be registered.
*/
template <typename T>
void requireComponent();
std::vector<Entity>& getEntities() { return m_entities; }
/*!
\brief Optional callback performed when an entity is added
*/
virtual void onEntityAdded(Entity) {}
/*!
\brief Optional callback performed when an entity is removed
*/
virtual void onEntityRemoved(Entity) {}
/*!
\brief Posts a message on the system wide message bus
*/
template <typename T>
T* postMessage(Message::ID id);
/*!
\brief Returns a reference to the MessageBus
*/
MessageBus& getMessageBus() { return m_messageBus; }
/*
\brief Used by the SystemManager to supply the active scene
*/
void setScene(Scene&);
/*!
\brief Returns a pointer to the scene to which this system belongs
*/
Scene* getScene();
private:
MessageBus& m_messageBus;
UniqueType m_type;
ComponentMask m_componentMask;
std::vector<Entity> m_entities;
Scene* m_scene;
bool m_active; //used by system manager to check if it has been added to the active list
friend class SystemManager;
//list of types populated by requireComponent then processed by SystemManager
//when the system is created
std::vector<std::type_index> m_pendingTypes;
void processTypes(ComponentManager&);
};
class XY_EXPORT_API SystemManager final
{
public:
SystemManager(Scene&, ComponentManager&);
~SystemManager() = default;
SystemManager(const SystemManager&) = delete;
SystemManager(const SystemManager&&) = delete;
SystemManager& operator = (const SystemManager&) = delete;
SystemManager& operator = (const SystemManager&&) = delete;
/*!
\brief Adds a system of a given type to the manager.
If the system already exists nothing is changed.
\returns Reference to the system, for instance a rendering
system maybe required elsewhere so a reference to it can be kept.
*/
template <typename T, typename... Args>
T& addSystem(Args&&... args);
/*!
\brief Removes the system of this type, if it exists
*/
template <typename T>
void removeSystem();
/*!
\brief Sets a system active or inactive by adding or removing it
from the active systems processing list.
\param active Set true to enable the system or false to disable.
If the systems does not exist this function has no effect.
*/
template <typename T>
void setSystemActive(bool active);
/*!
\brief Returns a reference to this system type, if it exists
*/
template <typename T>
T& getSystem();
/*!
\brief Returns true if a system of this type exists within the manager
*/
template <typename T>
bool hasSystem() const;
/*!
\brief Submits an entity to all available systems
*/
void addToSystems(Entity);
/*!
\brief Removes the given Entity from any systems to which it may belong
*/
void removeFromSystems(Entity);
/*!
\brief Forwards messages to all systems
*/
void forwardMessage(const Message&);
/*!
\brief Runs a simulation step by calling process() on each system
*/
void process(float);
private:
Scene& m_scene;
ComponentManager& m_componentManager;
std::vector<std::unique_ptr<System>> m_systems;
std::vector<System*> m_activeSystems;
template <typename T>
void removeFromActive();
};
#include "System.inl"
#include "SystemManager.inl"
}
| 29.936
| 99
| 0.622528
|
fallahn
|
10450c634fdddcbb5969c48429da022e2a571ac6
| 643
|
cpp
|
C++
|
_includes/leet443/leet443.cpp
|
mingdaz/leetcode
|
64f2e5ad0f0446d307e23e33a480bad5c9e51517
|
[
"MIT"
] | null | null | null |
_includes/leet443/leet443.cpp
|
mingdaz/leetcode
|
64f2e5ad0f0446d307e23e33a480bad5c9e51517
|
[
"MIT"
] | 8
|
2019-12-19T04:46:05.000Z
|
2022-02-26T03:45:22.000Z
|
_includes/leet443/leet443.cpp
|
mingdaz/leetcode
|
64f2e5ad0f0446d307e23e33a480bad5c9e51517
|
[
"MIT"
] | null | null | null |
class Solution {
public:
int compress(vector<char>& chars) {
int cur,i,num,count,n;
cur=0;
for(i=0;i<chars.size();){
chars[cur]=chars[i];
cur++;
count=0;
while(i<chars.size()&&chars[i]==chars[cur-1]){
count++;
i++;
}
if(count==1)
continue;
num=cur;
while(count>0){
chars[cur]=(count%10)+48;
cur++;
count/=10;
}
reverse(chars.begin()+num,chars.begin()+cur);
}
return cur;
}
};
| 24.730769
| 58
| 0.374806
|
mingdaz
|
10481bde6b0a0db9a84c6d6dee87130e2c552db3
| 7,074
|
cc
|
C++
|
onnxruntime/core/optimizer/utils.cc
|
codemzs/onnxruntime
|
c69194ec4c8c9674368113aa6044d0db708cd813
|
[
"MIT"
] | 1
|
2020-07-12T14:56:55.000Z
|
2020-07-12T14:56:55.000Z
|
onnxruntime/core/optimizer/utils.cc
|
codemzs/onnxruntime
|
c69194ec4c8c9674368113aa6044d0db708cd813
|
[
"MIT"
] | null | null | null |
onnxruntime/core/optimizer/utils.cc
|
codemzs/onnxruntime
|
c69194ec4c8c9674368113aa6044d0db708cd813
|
[
"MIT"
] | 2
|
2020-05-21T20:08:25.000Z
|
2021-04-19T10:39:13.000Z
|
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
#include "core/common/make_unique.h"
#include "core/graph/onnx_protobuf.h"
#include "core/graph/graph_utils.h"
#include "core/framework/tensorprotoutils.h"
#include "core/optimizer/initializer.h"
#include "core/framework/utils.h"
#include "core/optimizer/utils.h"
#include "float.h"
//#include <deque>
using namespace onnxruntime;
namespace onnxruntime {
namespace optimizer_utils {
bool IsFloatingPointDataType(const ONNX_NAMESPACE::TensorProto& tensor_proto) {
return tensor_proto.data_type() == ONNX_NAMESPACE::TensorProto_DataType_FLOAT || tensor_proto.data_type() == ONNX_NAMESPACE::TensorProto_DataType_FLOAT16 || tensor_proto.data_type() == ONNX_NAMESPACE::TensorProto_DataType_DOUBLE;
}
inline bool IsScalar(const NodeArg& input_arg) {
auto shape = input_arg.Shape();
if (shape == nullptr) {
// shape inferencing wasn't able to populate shape information for this NodeArg
return false;
}
auto dim_size = shape->dim_size();
return dim_size == 0 || (dim_size == 1 && shape->dim(0).has_dim_value() && shape->dim(0).dim_value() == 1);
}
// Check whether input is a constant scalar with expected float value.
bool IsInitializerWithExpectedValue(const Graph& graph, const NodeArg& input_arg, float expected_value, bool is_constant) {
if (!IsScalar(input_arg)) {
return false;
}
const float atol = 1e-8f;
const float rtol = 1e-5f;
const ONNX_NAMESPACE::TensorProto* tensor_proto = nullptr;
if (is_constant) {
tensor_proto = graph_utils::GetConstantInitializer(graph, input_arg.Name());
} else if (!graph.GetInitializedTensor(input_arg.Name(), tensor_proto)) {
return false;
}
if (tensor_proto == nullptr) {
return false;
}
Initializer init_const{*tensor_proto, graph.ModelPath()};
const auto data_type = tensor_proto->data_type();
if (data_type == ONNX_NAMESPACE::TensorProto_DataType_FLOAT) {
const float* val = init_const.data<float>();
if (std::isnan(val[0]) || std::isinf(val[0])) return false;
float diff = std::abs(val[0] - expected_value);
if (diff > (atol + rtol * std::abs(expected_value))) {
return false;
}
} else if (data_type == ONNX_NAMESPACE::TensorProto_DataType_DOUBLE) {
const double* val = init_const.data<double>();
if (std::isnan(val[0]) || std::isinf(val[0])) return false;
const double expected_val = static_cast<double>(expected_value);
double diff = std::abs(val[0] - expected_val);
if (diff > (atol + rtol * std::abs(expected_value))) {
return false;
}
} else if (data_type == ONNX_NAMESPACE::TensorProto_DataType_FLOAT16) {
const MLFloat16* val = init_const.data<MLFloat16>();
const float flt_val = math::halfToFloat(val[0].val);
if (std::isnan(flt_val) || std::isinf(flt_val)) return false;
const float expected_val = math::halfToFloat(math::floatToHalf(expected_value));
float diff = std::abs(flt_val - expected_val);
if (diff > (atol + rtol * std::abs(expected_value))) {
return false;
}
} else {
// Not expected data types.
return false;
}
return true;
}
// Check whether input is a constant scalar with expected intger value.
bool IsInitializerWithExpectedValue(const Graph& graph, const NodeArg& input_arg, int64_t expected_value, bool is_constant) {
if (!IsScalar(input_arg)) {
return false;
}
const ONNX_NAMESPACE::TensorProto* tensor_proto = nullptr;
if (is_constant) {
tensor_proto = graph_utils::GetConstantInitializer(graph, input_arg.Name());
} else if (!graph.GetInitializedTensor(input_arg.Name(), tensor_proto)) {
return false;
}
Initializer init_const{*tensor_proto, graph.ModelPath()};
const auto data_type = tensor_proto->data_type();
if (data_type == ONNX_NAMESPACE::TensorProto_DataType_INT64) {
const int64_t* val = init_const.data<int64_t>();
if (val[0] != expected_value) {
return false;
}
} else if (data_type == ONNX_NAMESPACE::TensorProto_DataType_INT32) {
const int32_t* val = init_const.data<int32_t>();
if (static_cast<int64_t>(val[0]) != expected_value) {
return false;
}
} else {
// Not expected data types.
return false;
}
return true;
}
bool IsAttributeWithExpectedValue(const Node& node, const std::string& attr_name, int64_t expected_value) {
const auto* attr_proto = graph_utils::GetNodeAttribute(node, attr_name);
if ((nullptr != attr_proto) && attr_proto->has_i()) {
return attr_proto->i() == expected_value;
}
return false;
}
bool AppendTensorFromInitializer(const Graph& graph, const NodeArg& input_arg, std::vector<int64_t>& data) {
const ONNX_NAMESPACE::TensorProto* tensor_proto = nullptr;
if (!graph.GetInitializedTensor(input_arg.Name(), tensor_proto)) {
return false;
}
Initializer init_const{*tensor_proto, graph.ModelPath()};
const auto data_type = tensor_proto->data_type();
if (data_type == ONNX_NAMESPACE::TensorProto_DataType_INT64) {
const int64_t* val = init_const.data<int64_t>();
data.reserve(data.size() + init_const.size());
data.insert(data.end(), val, val + init_const.size());
} else if (data_type == ONNX_NAMESPACE::TensorProto_DataType_INT32) {
const int32_t* val = init_const.data<int32_t>();
data.reserve(data.size() + init_const.size());
for (int64_t i = 0; i < init_const.size(); i++) {
data.push_back(static_cast<int64_t>(val[i]));
}
} else {
return false;
}
return true;
}
bool ValidateShape(const NodeArg& node_arg, const std::initializer_list<int64_t>& expected_dim_values) {
auto shape = node_arg.Shape();
if (shape == nullptr || static_cast<size_t>(shape->dim_size()) != expected_dim_values.size()) {
return false;
}
int index = 0;
for (auto& expected_dim_value : expected_dim_values) {
if (expected_dim_value > 0) {
auto dim = shape->dim(index);
if (!utils::HasDimValue(dim) || expected_dim_value != dim.dim_value()) {
return false;
}
}
++index;
}
return true;
}
bool IsShapeKnownOnAllDims(const NodeArg& node_arg, int expected_dim_size) {
auto shape = node_arg.Shape();
if (shape == nullptr || shape->dim_size() != expected_dim_size) {
return false;
}
for (int i = 0; i < expected_dim_size; i++) {
if (!utils::HasDimValue(shape->dim(i))) {
return false;
}
}
return true;
}
int32_t IndexOfNodeInput(const Node& node, const NodeArg& node_arg) {
int32_t index = 0;
for (auto& input_arg : node.InputDefs()) {
if (input_arg->Name().compare(node_arg.Name()) == 0) {
return index;
}
index++;
}
return -1;
}
bool IsSupportedDataType(const Node& node, const std::vector<std::string>& supported_data_types) {
for (const auto& input_arg : node.InputDefs()) {
if (std::find(supported_data_types.begin(), supported_data_types.end(),
*(input_arg->Type())) == supported_data_types.end()) {
return false;
}
}
return true;
}
} // namespace optimizer_utils
} // namespace onnxruntime
| 33.211268
| 231
| 0.691688
|
codemzs
|
1048b6db6ff46329e17c7dc1e77abbd3c8051136
| 108,173
|
cpp
|
C++
|
Code/Tools/FBuild/FBuildCore/Graph/ObjectNode.cpp
|
qq573011406/FASTBuild_UnrealEngine
|
29c49672f82173a903cb32f0e4656e2fd07ebef2
|
[
"MIT"
] | 30
|
2020-07-15T06:16:55.000Z
|
2022-02-10T21:37:52.000Z
|
Code/Tools/FBuild/FBuildCore/Graph/ObjectNode.cpp
|
qq573011406/FASTBuild_UnrealEngine
|
29c49672f82173a903cb32f0e4656e2fd07ebef2
|
[
"MIT"
] | 1
|
2020-10-19T22:12:03.000Z
|
2020-10-19T22:12:03.000Z
|
Code/Tools/FBuild/FBuildCore/Graph/ObjectNode.cpp
|
qq573011406/FASTBuild_UnrealEngine
|
29c49672f82173a903cb32f0e4656e2fd07ebef2
|
[
"MIT"
] | 12
|
2020-09-16T17:39:34.000Z
|
2021-08-17T11:32:37.000Z
|
// ObjectNode.cpp
//------------------------------------------------------------------------------
// Includes
//------------------------------------------------------------------------------
#include "ObjectNode.h"
#include "Tools/FBuild/FBuildCore/BFF/Functions/FunctionObjectList.h"
#include "Tools/FBuild/FBuildCore/Cache/ICache.h"
#include "Tools/FBuild/FBuildCore/FBuild.h"
#include "Tools/FBuild/FBuildCore/FLog.h"
#include "Tools/FBuild/FBuildCore/Cache/LightCache.h"
#include "Tools/FBuild/FBuildCore/Graph/CompilerNode.h"
#include "Tools/FBuild/FBuildCore/Graph/NodeGraph.h"
#include "Tools/FBuild/FBuildCore/Graph/NodeProxy.h"
#include "Tools/FBuild/FBuildCore/Graph/SettingsNode.h"
#include "Tools/FBuild/FBuildCore/Helpers/Args.h"
#include "Tools/FBuild/FBuildCore/Helpers/CIncludeParser.h"
#include "Tools/FBuild/FBuildCore/Helpers/Compressor.h"
#include "Tools/FBuild/FBuildCore/Helpers/MultiBuffer.h"
#include "Tools/FBuild/FBuildCore/Helpers/ResponseFile.h"
#include "Tools/FBuild/FBuildCore/Helpers/ToolManifest.h"
#include "Tools/FBuild/FBuildCore/WorkerPool/Job.h"
#include "Tools/FBuild/FBuildCore/WorkerPool/JobQueue.h"
#include "Tools/FBuild/FBuildCore/WorkerPool/WorkerThread.h"
// Core
#include "Core/Env/Env.h"
#include "Core/Env/ErrorFormat.h"
#include "Core/FileIO/ConstMemoryStream.h"
#include "Core/FileIO/FileIO.h"
#include "Core/FileIO/FileStream.h"
#include "Core/FileIO/PathUtils.h"
#include "Core/Math/xxHash.h"
#include "Core/Process/Process.h"
#include "Core/Profile/Profile.h"
#include "Core/Process/Thread.h"
#include "Core/Time/Time.h"
#include "Core/Tracing/Tracing.h"
#include "Core/Strings/AStackString.h"
#include <string.h>
#if defined( __OSX__ ) || defined( __LINUX__ )
#include <sys/time.h>
#endif
// Reflection
//------------------------------------------------------------------------------
REFLECT_NODE_BEGIN( ObjectNode, Node, MetaNone() )
REFLECT( m_Compiler, "Compiler", MetaFile() + MetaAllowNonFile())
REFLECT( m_CompilerOptions, "CompilerOptions", MetaNone() )
REFLECT( m_CompilerOptionsDeoptimized, "CompilerOptionsDeoptimized", MetaOptional() )
REFLECT( m_CompilerInputFile, "CompilerInputFile", MetaFile() )
REFLECT( m_CompilerOutputExtension, "CompilerOutputExtension", MetaOptional() )
REFLECT( m_PCHObjectFileName, "PCHObjectFileName", MetaOptional() + MetaFile() )
REFLECT( m_DeoptimizeWritableFiles, "DeoptimizeWritableFiles", MetaOptional() )
REFLECT( m_DeoptimizeWritableFilesWithToken, "DeoptimizeWritableFilesWithToken", MetaOptional() )
REFLECT( m_AllowDistribution, "AllowDistribution", MetaOptional() )
REFLECT( m_AllowCaching, "AllowCaching", MetaOptional() )
REFLECT( m_WorkingDir, "WorkingDir", MetaOptional() + MetaPath())
REFLECT_ARRAY( m_CompilerForceUsing, "CompilerForceUsing", MetaOptional() + MetaFile() )
// Preprocessor
REFLECT( m_Preprocessor, "Preprocessor", MetaOptional() + MetaFile() + MetaAllowNonFile())
REFLECT( m_PreprocessorOptions, "PreprocessorOptions", MetaOptional() )
REFLECT_ARRAY( m_PreBuildDependencyNames, "PreBuildDependencies", MetaOptional() + MetaFile() + MetaAllowNonFile() )
// Internal State
REFLECT( m_PrecompiledHeader, "PrecompiledHeader", MetaHidden() )
REFLECT( m_Flags, "Flags", MetaHidden() )
REFLECT( m_PreprocessorFlags, "PreprocessorFlags", MetaHidden() )
REFLECT( m_PCHCacheKey, "PCHCacheKey", MetaHidden() + MetaIgnoreForComparison() )
REFLECT( m_OwnerObjectList, "OwnerObjectList", MetaHidden() )
REFLECT_END( ObjectNode )
// CONSTRUCTOR
//------------------------------------------------------------------------------
ObjectNode::ObjectNode()
: FileNode( AString::GetEmpty(), Node::FLAG_NONE )
{
m_Type = OBJECT_NODE;
m_LastBuildTimeMs = 5000; // higher default than a file node
}
// Initialize
//------------------------------------------------------------------------------
/*virtual*/ bool ObjectNode::Initialize( NodeGraph & nodeGraph, const BFFToken * iter, const Function * function )
{
ASSERT( m_OwnerObjectList.IsEmpty() == false ); // Must be set before we get here
// .PreBuildDependencies
if ( !InitializePreBuildDependencies( nodeGraph, iter, function, m_PreBuildDependencyNames ) )
{
return false; // InitializePreBuildDependencies will have emitted an error
}
// .Compiler
CompilerNode * compiler( nullptr );
if ( !Function::GetCompilerNode( nodeGraph, iter, function, m_Compiler, compiler ) )
{
return false; // GetCompilerNode will have emitted an error
}
// .CompilerInputFile
Dependencies compilerInputFile;
if ( !Function::GetFileNode( nodeGraph, iter, function, m_CompilerInputFile, ".CompilerInputFile", compilerInputFile ) )
{
return false; // GetFileNode will have emitted an error
}
ASSERT( compilerInputFile.GetSize() == 1 ); // Should not be possible to expand to > 1 thing
// .Preprocessor
CompilerNode * preprocessor( nullptr );
if ( m_Preprocessor.IsEmpty() == false )
{
if ( !Function::GetCompilerNode( nodeGraph, iter, function, m_Preprocessor, preprocessor ) )
{
return false; // GetCompilerNode will have emitted an error
}
}
// .CompilerForceUsing
Dependencies compilerForceUsing;
if ( !Function::GetFileNodes( nodeGraph, iter, function, m_CompilerForceUsing, ".CompilerForceUsing", compilerForceUsing ) )
{
return false; // GetFileNode will have emitted an error
}
// Precompiled Header
Dependencies precompiledHeader;
if ( m_PrecompiledHeader.IsEmpty() == false )
{
// m_PrecompiledHeader is only set if our associated ObjectList or Library created one
VERIFY( Function::GetFileNode( nodeGraph, iter, function, m_PrecompiledHeader, ".PrecompiledHeader", precompiledHeader ) );
ASSERT( precompiledHeader.GetSize() == 1 );
}
// Store Dependencies
m_StaticDependencies.SetCapacity( 1 + 1 + precompiledHeader.GetSize() + ( preprocessor ? 1 : 0 ) + compilerForceUsing.GetSize() );
m_StaticDependencies.EmplaceBack( compiler );
m_StaticDependencies.Append( compilerInputFile );
m_StaticDependencies.Append( precompiledHeader );
if ( preprocessor )
{
m_StaticDependencies.EmplaceBack( preprocessor );
}
m_StaticDependencies.Append( compilerForceUsing );
return true;
}
// CONSTRUCTOR (Remote)
//------------------------------------------------------------------------------
ObjectNode::ObjectNode( const AString & objectName,
NodeProxy * srcFile,
const AString & compilerOptions,
uint32_t flags )
: FileNode( objectName, Node::FLAG_NONE )
, m_CompilerOptions( compilerOptions )
, m_Flags( flags )
, m_Remote( true )
{
m_Type = OBJECT_NODE;
m_LastBuildTimeMs = 5000; // higher default than a file node
m_StaticDependencies.SetCapacity( 2 );
m_StaticDependencies.EmplaceBack( nullptr );
m_StaticDependencies.EmplaceBack( srcFile );
}
// DESTRUCTOR
//------------------------------------------------------------------------------
ObjectNode::~ObjectNode()
{
// remote worker owns the ProxyNode for the source file, so must free it
if ( m_Remote )
{
Node * srcFile = GetSourceFile();
ASSERT( srcFile->GetType() == Node::PROXY_NODE );
FDELETE srcFile;
}
}
// DoBuild
//------------------------------------------------------------------------------
/*virtual*/ Node::BuildResult ObjectNode::DoBuild( Job * job )
{
// Delete previous file(s) if doing a clean build
if ( FBuild::Get().GetOptions().m_ForceCleanBuild )
{
if ( DoPreBuildFileDeletion( GetName() ) == false )
{
return NODE_RESULT_FAILED; // HandleFileDeletion will have emitted an error
}
if ( GetFlag( FLAG_MSVC ) && GetFlag( FLAG_CREATING_PCH ) )
{
if ( DoPreBuildFileDeletion( m_PCHObjectFileName ) == false )
{
return NODE_RESULT_FAILED; // HandleFileDeletion will have emitted an error
}
}
}
// Reset PCH cache key - will be set correctly if we end up using the cache
if ( GetFlag( FLAG_MSVC ) && GetFlag( FLAG_CREATING_PCH ) )
{
m_PCHCacheKey = 0;
}
// using deoptimization?
bool useDeoptimization = ShouldUseDeoptimization();
bool useCache = ShouldUseCache();
bool useDist = GetFlag( FLAG_CAN_BE_DISTRIBUTED ) && m_AllowDistribution && FBuild::Get().GetOptions().m_AllowDistributed;
bool useSimpleDist = GetCompiler()->SimpleDistributionMode();
bool usePreProcessor = !useSimpleDist && ( useCache || useDist || GetFlag( FLAG_GCC ) || GetFlag( FLAG_SNC ) || GetFlag( FLAG_CLANG ) || GetFlag( CODEWARRIOR_WII ) || GetFlag( GREENHILLS_WIIU ) || GetFlag( ObjectNode::FLAG_VBCC ) || GetFlag( FLAG_ORBIS_WAVE_PSSLC ) );
if ( GetDedicatedPreprocessor() )
{
usePreProcessor = true;
useDeoptimization = false; // disable deoptimization
}
// Graphing the current amount of distributable jobs
FLOG_MONITOR( "GRAPH FASTBuild \"Distributable Jobs MemUsage\" MB %f\n", (double)( (float)Job::GetTotalLocalDataMemoryUsage() / (float)MEGABYTE ) );
if ( usePreProcessor || useSimpleDist )
{
return DoBuildWithPreProcessor( job, useDeoptimization, useCache, useSimpleDist );
}
if ( GetFlag( FLAG_MSVC ) )
{
return DoBuildMSCL_NoCache( job, useDeoptimization );
}
if ( GetFlag( FLAG_QT_RCC ))
{
return DoBuild_QtRCC( job );
}
return DoBuildOther( job, useDeoptimization );
}
// DoBuild_Remote
//------------------------------------------------------------------------------
/*virtual*/ Node::BuildResult ObjectNode::DoBuild2( Job * job, bool racingRemoteJob = false )
{
// we may be using deoptimized options, but they are always
// the "normal" args when remote compiling
bool useDeoptimization = job->IsLocal() && ShouldUseDeoptimization();
bool stealingRemoteJob = job->IsLocal(); // are we stealing a remote job?
return DoBuildWithPreProcessor2( job, useDeoptimization, stealingRemoteJob, racingRemoteJob );
}
// Finalize
//------------------------------------------------------------------------------
/*virtual*/ bool ObjectNode::Finalize( NodeGraph & nodeGraph )
{
ASSERT( Thread::IsMainThread() );
// convert includes to nodes
m_DynamicDependencies.Clear();
m_DynamicDependencies.SetCapacity( m_Includes.GetSize() );
for ( Array< AString >::ConstIter it = m_Includes.Begin();
it != m_Includes.End();
it++ )
{
Node * fn = nodeGraph.FindNode( *it );
if ( fn == nullptr )
{
fn = nodeGraph.CreateFileNode( *it );
}
else if ( fn->IsAFile() == false )
{
FLOG_ERROR( "'%s' is not a FileNode (type: %s)", fn->GetName().Get(), fn->GetTypeName() );
return false;
}
// Ensure files that are seen for the first time here have their
// mod time recorded in the database
if ( ( fn->GetType() == Node::FILE_NODE ) &&
( fn->GetStamp() == 0 ) &&
( fn->GetStatFlag( Node::STATS_BUILT ) == false ) )
{
fn->CastTo< FileNode >()->DoBuild( nullptr );
}
m_DynamicDependencies.EmplaceBack( fn );
}
Node::Finalize( nodeGraph );
return true;
}
// Migrate
//------------------------------------------------------------------------------
/*virtual*/ void ObjectNode::Migrate( const Node & oldNode )
{
// Migrate Node level properties
Node::Migrate( oldNode );
// Migrate the PCHCacheKey if there is one. This special case property is
// lazily determined during a build, but needs to persist across migrations
// to prevent unnecessary rebuilds of object that depend on this one, if this
// is a precompiled header object.
m_PCHCacheKey = oldNode.CastTo< ObjectNode >()->m_PCHCacheKey;
}
// DoBuildMSCL_NoCache
//------------------------------------------------------------------------------
/*virtual*/ Node::BuildResult ObjectNode::DoBuildMSCL_NoCache( Job * job, bool useDeoptimization )
{
// Format compiler args string
Args fullArgs;
const bool showIncludes( true );
const bool finalize( true );
if ( !BuildArgs( job, fullArgs, PASS_COMPILE, useDeoptimization, showIncludes, finalize ) )
{
return NODE_RESULT_FAILED; // BuildArgs will have emitted an error
}
EmitCompilationMessage( fullArgs, useDeoptimization );
// spawn the process
CompileHelper ch;
if ( !ch.SpawnCompiler( job, GetName(), GetCompiler(), GetCompiler()->GetExecutable(), fullArgs ,m_WorkingDir.IsEmpty() ? nullptr : m_WorkingDir.Get()) ) // use response file for MSVC
{
return NODE_RESULT_FAILED; // SpawnCompiler has logged error
}
// Handle MSCL warnings if not already a failure
// If "warnings as errors" is enabled (/WX) we don't need to check
// (since compilation will fail anyway, and the output will be shown)
if ( ( ch.GetResult() == 0 ) && !GetFlag( FLAG_WARNINGS_AS_ERRORS_MSVC ) )
{
HandleWarningsMSVC( job, GetName(), ch.GetOut() );
}
const char *output = nullptr;
uint32_t outputSize = 0;
// MSVC will write /ShowIncludes output on stderr sometimes (ex: /Fi)
if ( GetFlag( FLAG_INCLUDES_IN_STDERR ) == true )
{
output = ch.GetErr().Get();
outputSize = ch.GetErr().GetLength();
}
else
{
// but most of the time it will be on stdout
output = ch.GetOut().Get();
outputSize = ch.GetOut().GetLength();
}
// compiled ok, try to extract includes
if ( ProcessIncludesMSCL( output, outputSize ) == false )
{
return NODE_RESULT_FAILED; // ProcessIncludesMSCL will have emitted an error
}
GenerateDependenciesListFile();
// record new file time
RecordStampFromBuiltFile();
return NODE_RESULT_OK;
}
// DoBuildWithPreProcessor
//------------------------------------------------------------------------------
Node::BuildResult ObjectNode::DoBuildWithPreProcessor( Job * job, bool useDeoptimization, bool useCache, bool useSimpleDist )
{
Args fullArgs;
const bool showIncludes( false );
const bool finalize( true );
Pass pass = useSimpleDist ? PASS_PREP_FOR_SIMPLE_DISTRIBUTION : PASS_PREPROCESSOR_ONLY;
if ( !BuildArgs( job, fullArgs, pass, useDeoptimization, showIncludes, finalize ) )
{
return NODE_RESULT_FAILED; // BuildArgs will have emitted an error
}
// Try to use the light cache if enabled
if ( useCache && GetCompiler()->GetUseLightCache() )
{
LightCache lc;
if ( lc.Hash( this, fullArgs.GetFinalArgs(), m_LightCacheKey, m_Includes ) == false )
{
// Light cache could not be used (can't parse includes)
if ( FBuild::Get().GetOptions().m_CacheVerbose )
{
FLOG_OUTPUT( "LightCache cannot be used for '%s'\n"
"%s",
GetName().Get(),
lc.GetErrors().Get() );
}
// Fall through to generate preprocessed output for old style cache and distribution....
}
else
{
// LightCache hashing was successful
SetStatFlag( Node::STATS_LIGHT_CACHE ); // Light compatible
// Try retrieve from cache
GetCacheName( job ); // Prepare the cache key (always done here even if write only mode)
if ( RetrieveFromCache( job ) )
{
return NODE_RESULT_OK_CACHE;
}
// Cache miss
const bool belowMemoryLimit = ( ( Job::GetTotalLocalDataMemoryUsage() / MEGABYTE ) < FBuild::Get().GetSettings()->GetDistributableJobMemoryLimitMiB() );
const bool canDistribute = belowMemoryLimit && GetFlag( FLAG_CAN_BE_DISTRIBUTED ) && m_AllowDistribution && FBuild::Get().GetOptions().m_AllowDistributed;
if ( canDistribute == false )
{
// can't distribute, so generating preprocessed output is useless
// so we directly compile from source as one-pass compilation is faster
const bool stealingRemoteJob = false; // never queued
const bool racingRemoteJob = false; // never queued
return DoBuildWithPreProcessor2( job, useDeoptimization, stealingRemoteJob, racingRemoteJob );
}
// Fall through to generate preprocessed output for distribution....
}
}
if ( pass == PASS_PREPROCESSOR_ONLY )
{
if ( BuildPreprocessedOutput( fullArgs, job, useDeoptimization ) == false )
{
return NODE_RESULT_FAILED; // BuildPreprocessedOutput will have emitted an error
}
// preprocessed ok, try to extract includes
if ( ProcessIncludesWithPreProcessor( job ) == false )
{
return NODE_RESULT_FAILED; // ProcessIncludesWithPreProcessor will have emitted an error
}
GenerateDependenciesListFile();
}
if ( pass == PASS_PREP_FOR_SIMPLE_DISTRIBUTION )
{
if ( LoadStaticSourceFileForDistribution( fullArgs, job, useDeoptimization ) == false )
{
return NODE_RESULT_FAILED; // BuildPreprocessedOutput will have emitted an error
}
}
// Do Clang unity fixup if needed
if ( GetFlag( FLAG_UNITY ) && IsClang() && GetCompiler()->IsClangUnityFixupEnabled() )
{
DoClangUnityFixup( job );
}
// calculate the cache entry lookup
if ( useCache )
{
// try to get from cache
GetCacheName( job ); // Prepare the cache key (always done here even if write only mode)
if ( RetrieveFromCache( job ) )
{
return NODE_RESULT_OK_CACHE;
}
}
// can we do the rest of the work remotely?
const bool canDistribute = useSimpleDist || ( GetFlag( FLAG_CAN_BE_DISTRIBUTED ) && m_AllowDistribution && FBuild::Get().GetOptions().m_AllowDistributed );
const bool belowMemoryLimit = ( ( Job::GetTotalLocalDataMemoryUsage() / MEGABYTE ) < FBuild::Get().GetSettings()->GetDistributableJobMemoryLimitMiB() );
if ( canDistribute && belowMemoryLimit )
{
// compress job data
Compressor c;
c.Compress( job->GetData(), job->GetDataSize() );
size_t compressedSize = c.GetResultSize();
job->OwnData( c.ReleaseResult(), compressedSize, true );
// yes... re-queue for secondary build
return NODE_RESULT_NEED_SECOND_BUILD_PASS;
}
// can't do the work remotely, so do it right now
bool stealingRemoteJob = false; // never queued
bool racingRemoteJob = false;
Node::BuildResult result = DoBuildWithPreProcessor2( job, useDeoptimization, stealingRemoteJob, racingRemoteJob );
if ( result != Node::NODE_RESULT_OK )
{
return result;
}
return Node::NODE_RESULT_OK;
}
// DoBuildWithPreProcessor2
//------------------------------------------------------------------------------
Node::BuildResult ObjectNode::DoBuildWithPreProcessor2( Job * job, bool useDeoptimization, bool stealingRemoteJob, bool racingRemoteJob )
{
// should never use preprocessor if using CLR
ASSERT( GetFlag( FLAG_USING_CLR ) == false );
bool usePreProcessedOutput = true;
if ( job->IsLocal() )
{
if ( GetFlag( FLAG_CLANG | FLAG_GCC | FLAG_SNC ) )
{
// Using the PCH with Clang/SNC/GCC doesn't prevent storing to the cache
// so we can use the PCH accelerated compilation
if ( GetFlag( FLAG_USING_PCH ) )
{
usePreProcessedOutput = false;
}
// Creating a PCH must not use the preprocessed output, or we'll create
// a PCH which cannot be used for acceleration
if ( GetFlag( FLAG_CREATING_PCH ) )
{
usePreProcessedOutput = false;
}
}
if ( GetFlag( FLAG_MSVC ) )
{
// If using the PCH, we can't use the preprocessed output
// as that's incompatible with the PCH
if ( GetFlag( FLAG_USING_PCH ) )
{
usePreProcessedOutput = false;
}
// If creating the PCH, we can't use the preprocessed info
// as this would prevent acceleration by users of the PCH
if ( GetFlag( FLAG_CREATING_PCH ) )
{
usePreProcessedOutput = false;
}
// Compiling with /analyze cannot use the preprocessed output
// as it results in inconsistent behavior with the _PREFAST_ macro
if ( GetFlag( FLAG_STATIC_ANALYSIS_MSVC ) )
{
usePreProcessedOutput = false;
}
}
// The CUDA compiler seems to not be able to compile its own preprocessed output
if ( GetFlag( FLAG_CUDA_NVCC ) )
{
usePreProcessedOutput = false;
}
if ( GetFlag( FLAG_VBCC ) )
{
usePreProcessedOutput = false;
}
// We might not have preprocessed data if using the LightCache
if ( job->GetData() == nullptr )
{
usePreProcessedOutput = false;
}
}
Args fullArgs;
AStackString<> tmpDirectoryName;
AStackString<> tmpFileName;
if ( usePreProcessedOutput )
{
if ( WriteTmpFile( job, tmpDirectoryName, tmpFileName ) == false )
{
return NODE_RESULT_FAILED; // WriteTmpFile will have emitted an error
}
const bool showIncludes( false );
const bool finalize( true );
if ( !BuildArgs( job, fullArgs, PASS_COMPILE_PREPROCESSED, useDeoptimization, showIncludes, finalize, tmpFileName ) )
{
return NODE_RESULT_FAILED; // BuildArgs will have emitted an error
}
}
else
{
const bool showIncludes( false );
const bool finalize( true );
if ( !BuildArgs( job, fullArgs, PASS_COMPILE, useDeoptimization, showIncludes, finalize ) )
{
return NODE_RESULT_FAILED; // BuildArgs will have emitted an error
}
}
const bool verbose = FLog::ShowVerbose();
const bool showCommands = ( FBuild::IsValid() && FBuild::Get().GetOptions().m_ShowCommandLines );
const bool isRemote = ( job->IsLocal() == false );
if ( stealingRemoteJob || racingRemoteJob || verbose || showCommands || isRemote )
{
// show that we are locally consuming a remote job
EmitCompilationMessage( fullArgs, useDeoptimization, stealingRemoteJob, racingRemoteJob, false, isRemote );
}
bool result = BuildFinalOutput( job, fullArgs );
// cleanup temp file
if ( tmpFileName.IsEmpty() == false )
{
FileIO::FileDelete( tmpFileName.Get() );
}
// cleanup temp directory
if ( tmpDirectoryName.IsEmpty() == false )
{
FileIO::DirectoryDelete( tmpDirectoryName );
}
if ( result == false )
{
return NODE_RESULT_FAILED; // BuildFinalOutput will have emitted error
}
// record new file time
if ( job->IsLocal() )
{
// record new file time
RecordStampFromBuiltFile();
const bool useCache = ShouldUseCache();
if ( m_Stamp && useCache )
{
WriteToCache( job );
}
}
return NODE_RESULT_OK;
}
// DoBuild_QtRCC
//------------------------------------------------------------------------------
Node::BuildResult ObjectNode::DoBuild_QtRCC( Job * job )
{
// spawn the process to gather dependencies
{
// Format compiler args string
const bool useDeoptimization( false );
const bool showIncludes( false );
const bool finalize( true );
Args fullArgs;
if ( !BuildArgs( job, fullArgs, PASS_PREPROCESSOR_ONLY, useDeoptimization, showIncludes, finalize ) )
{
return NODE_RESULT_FAILED; // BuildArgs will have emitted an error
}
EmitCompilationMessage( fullArgs, false );
CompileHelper ch;
if ( !ch.SpawnCompiler( job, GetName(), GetCompiler(), GetCompiler()->GetExecutable(), fullArgs ) )
{
return NODE_RESULT_FAILED; // compile has logged error
}
// get output
AString output( ch.GetOut() );
output.Replace( '\r', '\n' ); // Normalize all carriage line endings
// split into lines
Array< AString > lines( 256, true );
output.Tokenize( lines, '\n' );
m_Includes.Clear();
// extract paths and store them as includes
for ( const AString & line : lines )
{
if ( line.GetLength() > 0 )
{
AStackString<> cleanedInclude;
NodeGraph::CleanPath( line, cleanedInclude );
m_Includes.Append( cleanedInclude );
}
}
}
// spawn the process to compile
{
// Format compiler args string
const bool useDeoptimization( false );
const bool showIncludes( false );
const bool finalize( true );
Args fullArgs;
if ( !BuildArgs( job, fullArgs, PASS_COMPILE, useDeoptimization, showIncludes, finalize ) )
{
return NODE_RESULT_FAILED; // BuildArgs will have emitted an error
}
CompileHelper ch;
if ( !ch.SpawnCompiler( job, GetName(), GetCompiler(), GetCompiler()->GetExecutable(), fullArgs ) )
{
return NODE_RESULT_FAILED; // compile has logged error
}
}
// record new file time
RecordStampFromBuiltFile();
return NODE_RESULT_OK;
}
// DoBuildOther
//------------------------------------------------------------------------------
/*virtual*/ Node::BuildResult ObjectNode::DoBuildOther( Job * job, bool useDeoptimization )
{
// Format compiler args string
Args fullArgs;
const bool showIncludes( false );
const bool finalize( true );
if ( !BuildArgs( job, fullArgs, PASS_COMPILE, useDeoptimization, showIncludes, finalize ) )
{
return NODE_RESULT_FAILED; // BuildArgs will have emitted an error
}
EmitCompilationMessage( fullArgs, useDeoptimization );
// spawn the process
CompileHelper ch;
if ( !ch.SpawnCompiler( job, GetName(), GetCompiler(), GetCompiler()->GetExecutable(), fullArgs ) )
{
return NODE_RESULT_FAILED; // compile has logged error
}
// record new file time
RecordStampFromBuiltFile();
return NODE_RESULT_OK;
}
// ProcessIncludesMSCL
//------------------------------------------------------------------------------
bool ObjectNode::ProcessIncludesMSCL( const char * output, uint32_t outputSize )
{
Timer t;
{
CIncludeParser parser;
bool result = ( output && outputSize ) ? parser.ParseMSCL_Output( output, outputSize )
: false;
if ( result == false )
{
FLOG_ERROR( "Failed to process includes for '%s'", GetName().Get() );
return false;
}
// record that we have a list of includes
// (we need a flag because we can't use the array size
// as a determinator, because the file might not include anything)
m_Includes.Clear();
parser.SwapIncludes( m_Includes );
}
FLOG_VERBOSE( "Process Includes:\n - File: %s\n - Time: %u ms\n - Num : %u", m_Name.Get(), uint32_t( t.GetElapsedMS() ), uint32_t( m_Includes.GetSize() ) );
return true;
}
// ProcessIncludesWithPreProcessor
//------------------------------------------------------------------------------
bool ObjectNode::ProcessIncludesWithPreProcessor( Job * job )
{
Timer t;
{
const char * output = (char *)job->GetData();
size_t outputSize = job->GetDataSize();
// Unlike most compilers, VBCC writes preprocessed output to a file
ConstMemoryStream vbccMemoryStream;
if ( GetFlag( FLAG_VBCC ) )
{
if ( !GetVBCCPreprocessedOutput( vbccMemoryStream ) )
{
return false; // GetVBCCPreprocessedOutput handles error output
}
output = (const char *)vbccMemoryStream.GetData();
outputSize = vbccMemoryStream.GetSize();
}
ASSERT( output && outputSize );
CIncludeParser parser;
bool msvcStyle;
if ( GetDedicatedPreprocessor() != nullptr )
{
msvcStyle = GetPreprocessorFlag( FLAG_MSVC ) || GetPreprocessorFlag( FLAG_CUDA_NVCC );
}
else
{
msvcStyle = GetFlag( FLAG_MSVC ) || GetFlag( FLAG_CUDA_NVCC );
}
bool result = msvcStyle ? parser.ParseMSCL_Preprocessed( output, outputSize )
: parser.ParseGCC_Preprocessed( output, outputSize );
if ( result == false )
{
FLOG_ERROR( "Failed to process includes for '%s'", GetName().Get() );
return false;
}
// record that we have a list of includes
// (we need a flag because we can't use the array size
// as a determinator, because the file might not include anything)
m_Includes.Clear();
parser.SwapIncludes( m_Includes );
}
FLOG_VERBOSE( "Process Includes:\n - File: %s\n - Time: %u ms\n - Num : %u", m_Name.Get(), uint32_t( t.GetElapsedMS() ), uint32_t( m_Includes.GetSize() ) );
return true;
}
void ObjectNode::GenerateDependenciesListFile()
{
if (m_DependenciesListOutFile.IsEmpty()) return;
if (FileIO::FileExists(m_DependenciesListOutFile.Get()))
{
if (!FileIO::FileDelete(m_DependenciesListOutFile.Get()))
{
FLOG_ERROR("Failed to delete dependencies list file '%s'", m_DependenciesListOutFile.Get());
return;
}
}
FileStream fs;
if (!fs.Open(m_DependenciesListOutFile.Get(), FileStream::WRITE_ONLY))
{
FLOG_ERROR("Failed to create dependencies list file '%s'", m_DependenciesListOutFile.Get());
return;
}
AStackString<> temp;
for (size_t i = 0; i < m_Includes.GetSize(); i++)
{
temp.Append(m_Includes[i]);
temp.Append(AString("\n"));
}
fs.Write(temp.Get(), temp.GetLength());
fs.Flush();
fs.Close();
}
// LoadRemote
//------------------------------------------------------------------------------
/*static*/ Node * ObjectNode::LoadRemote( IOStream & stream )
{
AStackString<> name;
AStackString<> sourceFile;
uint32_t flags;
AStackString<> compilerArgs;
if ( ( stream.Read( name ) == false ) ||
( stream.Read( sourceFile ) == false ) ||
( stream.Read( flags ) == false ) ||
( stream.Read( compilerArgs ) == false ) )
{
return nullptr;
}
NodeProxy * srcFile = FNEW( NodeProxy( sourceFile ) );
return FNEW( ObjectNode( name, srcFile, compilerArgs, flags ) );
}
// DetermineFlags
//------------------------------------------------------------------------------
/*static*/ uint32_t ObjectNode::DetermineFlags( const CompilerNode * compilerNode,
const AString & args,
bool creatingPCH,
bool usingPCH )
{
uint32_t flags = 0;
// set flags known from the context the args will be used in
flags |= ( creatingPCH ? ObjectNode::FLAG_CREATING_PCH : 0 );
flags |= ( usingPCH ? ObjectNode::FLAG_USING_PCH : 0 );
const bool isDistributableCompiler = compilerNode->CanBeDistributed();
// Compiler Type - TODO:C Eliminate duplication of these flags
const CompilerNode::CompilerFamily compilerFamily = compilerNode->GetCompilerFamily();
switch ( compilerFamily )
{
case CompilerNode::CompilerFamily::CUSTOM: break; // Nothing to do
case CompilerNode::CompilerFamily::MSVC: flags |= FLAG_MSVC; break;
case CompilerNode::CompilerFamily::CLANG: flags |= FLAG_CLANG; break;
case CompilerNode::CompilerFamily::GCC: flags |= FLAG_GCC; break;
case CompilerNode::CompilerFamily::SNC: flags |= FLAG_SNC; break;
case CompilerNode::CompilerFamily::CODEWARRIOR_WII: flags |= CODEWARRIOR_WII; break;
case CompilerNode::CompilerFamily::GREENHILLS_WIIU: flags |= GREENHILLS_WIIU; break;
case CompilerNode::CompilerFamily::CUDA_NVCC: flags |= FLAG_CUDA_NVCC; break;
case CompilerNode::CompilerFamily::QT_RCC: flags |= FLAG_QT_RCC; break;
case CompilerNode::CompilerFamily::VBCC: flags |= FLAG_VBCC; break;
case CompilerNode::CompilerFamily::ORBIS_WAVE_PSSLC:flags |= FLAG_ORBIS_WAVE_PSSLC; break;
case CompilerNode::CompilerFamily::CSHARP: ASSERT( false ); break; // Guarded in ObjectListNode::Initialize
}
// Check MS compiler options
if ( flags & ObjectNode::FLAG_MSVC )
{
bool usingCLR = false;
bool usingWinRT = false;
bool usingPreprocessorOnly = false;
Array< AString > tokens;
args.Tokenize( tokens );
const AString * const end = tokens.End();
for ( const AString * it = tokens.Begin(); it != end; ++it )
{
const AString & token = *it;
if ( IsCompilerArg_MSVC( token, "Zi" ) || IsCompilerArg_MSVC( token, "ZI" ) )
{
flags |= ObjectNode::FLAG_USING_PDB;
}
else if ( IsCompilerArg_MSVC( token, "clr" ) )
{
usingCLR = true;
flags |= ObjectNode::FLAG_USING_CLR;
}
else if ( IsCompilerArg_MSVC( token, "ZW" ) )
{
usingWinRT = true;
}
else if ( IsCompilerArg_MSVC( token, "P" ) )
{
usingPreprocessorOnly = true;
flags |= ObjectNode::FLAG_INCLUDES_IN_STDERR;
}
else if ( IsCompilerArg_MSVC( token, "WX" ) )
{
flags |= ObjectNode::FLAG_WARNINGS_AS_ERRORS_MSVC;
}
else if ( IsStartOfCompilerArg_MSVC( token, "analyze" ) )
{
if ( IsCompilerArg_MSVC( token, "analyze-" ) )
{
flags &= ( ~ObjectNode::FLAG_STATIC_ANALYSIS_MSVC );
}
else
{
flags |= ObjectNode::FLAG_STATIC_ANALYSIS_MSVC;
}
}
}
// 1) clr code cannot be distributed due to a compiler bug where the preprocessed using
// statements are truncated
// 2) code consuming the windows runtime cannot be distributed due to preprocessing weirdness
// 3) pch files can't be built from preprocessed output (disabled acceleration), so can't be distributed
// 4) user only wants preprocessor step executed
// 5) Distribution of /analyze is not currently supported due to preprocessor/_PREFAST_ inconsistencies
if ( !usingCLR && !usingPreprocessorOnly )
{
if ( isDistributableCompiler &&
!usingWinRT &&
!( flags & ObjectNode::FLAG_CREATING_PCH ) &&
!( flags & ObjectNode::FLAG_STATIC_ANALYSIS_MSVC ) )
{
flags |= ObjectNode::FLAG_CAN_BE_DISTRIBUTED;
}
// TODO:A Support caching of 7i format
if ( ( flags & ObjectNode::FLAG_USING_PDB ) == 0 )
{
flags |= ObjectNode::FLAG_CAN_BE_CACHED;
}
}
}
// Check GCC/Clang options
bool objectiveC = false;
if ( flags & ( ObjectNode::FLAG_CLANG | ObjectNode::FLAG_GCC ) )
{
// Clang supported -fdiagnostics-color option (and defaulted to =auto) since its first release
if ( flags & ObjectNode::FLAG_CLANG )
{
flags |= ObjectNode::FLAG_DIAGNOSTICS_COLOR_AUTO;
}
Array< AString > tokens;
args.Tokenize( tokens );
const AString * const end = tokens.End();
for ( const AString * it = tokens.Begin(); it != end; ++it )
{
const AString & token = *it;
if ( token == "-fdiagnostics-color=auto" )
{
flags |= ObjectNode::FLAG_DIAGNOSTICS_COLOR_AUTO;
}
else if ( token.BeginsWith( "-fdiagnostics-color" ) || token == "-fno-diagnostics-color" )
{
flags &= ( ~ObjectNode::FLAG_DIAGNOSTICS_COLOR_AUTO );
}
else if ( token.BeginsWith( "-werror" ) )
{
flags |= ObjectNode::FLAG_WARNINGS_AS_ERRORS_CLANGGCC;
}
else if ( token == "-fobjc-arc" )
{
objectiveC = true;
}
else if ( token == "-x" )
{
if ( it < ( end - 1 ) )
{
const AString & nextToken = *( it + 1);
if ( nextToken == "objective-c" )
{
objectiveC = true;
}
}
}
}
}
// check for cacheability/distributability for non-MSVC
if ( flags & ( ObjectNode::FLAG_CLANG | ObjectNode::FLAG_GCC | ObjectNode::FLAG_SNC | ObjectNode::CODEWARRIOR_WII | ObjectNode::GREENHILLS_WIIU ) )
{
// creation of the PCH must be done locally to generate a usable PCH
// Objective C/C++ cannot be distributed
if ( !creatingPCH && !objectiveC )
{
if ( isDistributableCompiler )
{
flags |= ObjectNode::FLAG_CAN_BE_DISTRIBUTED;
}
}
// all objects can be cached with GCC/SNC/Clang (including PCH files)
flags |= ObjectNode::FLAG_CAN_BE_CACHED;
}
// CUDA Compiler
if ( flags & ObjectNode::FLAG_CUDA_NVCC )
{
// Can cache objects
flags |= ObjectNode::FLAG_CAN_BE_CACHED;
}
if ( flags & ObjectNode::FLAG_ORBIS_WAVE_PSSLC )
{
if ( isDistributableCompiler )
{
flags |= ObjectNode::FLAG_CAN_BE_DISTRIBUTED;
}
// Can cache objects
flags |= ObjectNode::FLAG_CAN_BE_CACHED;
}
return flags;
}
// IsCompilerArg_MSVC
//------------------------------------------------------------------------------
/*static*/ bool ObjectNode::IsCompilerArg_MSVC( const AString & token, const char * arg )
{
ASSERT( token.IsEmpty() == false );
// MSVC Compiler args can start with - or /
if ( ( token[0] != '/' ) && ( token[0] != '-' ) )
{
return false;
}
// Length check to early out
const size_t argLen = AString::StrLen( arg );
if ( ( token.GetLength() - 1 ) != argLen )
{
return false; // token is too short or too long
}
// MSVC Compiler args are case-sensitive
return token.EndsWith( arg );
}
// IsStartOfCompilerArg_MSVC
//------------------------------------------------------------------------------
/*static*/ bool ObjectNode::IsStartOfCompilerArg_MSVC( const AString & token, const char * arg )
{
ASSERT( token.IsEmpty() == false );
// MSVC Compiler args can start with - or /
if ( ( token[0] != '/' ) && ( token[0] != '-' ) )
{
return false;
}
// Length check to early out
const size_t argLen = AString::StrLen( arg );
if ( ( token.GetLength() - 1 ) < argLen )
{
return false; // token is too short
}
// MSVC Compiler args are case-sensitive
return ( AString::StrNCmp( token.Get() + 1, arg, argLen ) == 0 );
}
// SaveRemote
//------------------------------------------------------------------------------
/*virtual*/ void ObjectNode::SaveRemote( IOStream & stream ) const
{
// Force using implies /clr which is not distributable
ASSERT( m_CompilerForceUsing.IsEmpty() );
// Save minimal information for the remote worker
stream.Write( m_Name );
stream.Write( GetSourceFile()->GetName() );
stream.Write( m_Flags );
// TODO:B would be nice to make ShouldUseDeoptimization cache the result for this build
// instead of opening the file again.
const bool useDeoptimization = ShouldUseDeoptimization();
if ( useDeoptimization )
{
stream.Write( m_CompilerOptionsDeoptimized );
}
else
{
stream.Write( m_CompilerOptions );
}
}
// GetCompiler
//-----------------------------------------------------------------------------
CompilerNode * ObjectNode::GetCompiler() const
{
// node can be null if compiling remotely
Node * node = m_StaticDependencies[0].GetNode();
return node ? node->CastTo< CompilerNode >() : nullptr;
}
// GetDedicatedPreprocessor
//------------------------------------------------------------------------------
CompilerNode * ObjectNode::GetDedicatedPreprocessor() const
{
if ( m_Preprocessor.IsEmpty() )
{
return nullptr;
}
size_t preprocessorIndex = 2;
if ( m_PrecompiledHeader.IsEmpty() == false )
{
++preprocessorIndex;
}
return m_StaticDependencies[ preprocessorIndex ].GetNode()->CastTo< CompilerNode >();
}
// GetPrecompiledHeader()
//------------------------------------------------------------------------------
ObjectNode * ObjectNode::GetPrecompiledHeader() const
{
ASSERT( m_PrecompiledHeader.IsEmpty() == false );
return m_StaticDependencies[ 2 ].GetNode()->CastTo< ObjectNode >();
}
// GetPDBName
//------------------------------------------------------------------------------
void ObjectNode::GetPDBName( AString & pdbName ) const
{
ASSERT( IsUsingPDB() );
pdbName = m_Name;
pdbName += ".pdb";
}
// GetNativeAnalysisXMLPath
//------------------------------------------------------------------------------
void ObjectNode::GetNativeAnalysisXMLPath( AString& outXMLFileName ) const
{
ASSERT( IsUsingStaticAnalysisMSVC() );
const AString & sourceName = m_PCHObjectFileName.IsEmpty() ? m_Name : m_PCHObjectFileName;
// TODO:B The xml path can be manually specified with /analyze:log
const char * extPos = sourceName.FindLast( '.' ); // Only last extension removed
outXMLFileName.Assign( sourceName.Get(), extPos ? extPos : sourceName.GetEnd() );
outXMLFileName += ".nativecodeanalysis.xml";
}
// GetObjExtension
//------------------------------------------------------------------------------
const char * ObjectNode::GetObjExtension() const
{
if ( m_CompilerOutputExtension.IsEmpty() )
{
#if defined( __WINDOWS__ )
return ".obj";
#else
return ".o";
#endif
}
return m_CompilerOutputExtension.Get();
}
// GetCacheName
//------------------------------------------------------------------------------
const AString & ObjectNode::GetCacheName( Job * job ) const
{
// use already determined cache name if available?
if ( job->GetCacheName().IsEmpty() == false )
{
return job->GetCacheName();
}
PROFILE_FUNCTION
// hash the pre-processed input data
ASSERT( m_LightCacheKey || job->GetData() );
const uint64_t preprocessedSourceKey = m_LightCacheKey ? m_LightCacheKey : xxHash::Calc64( job->GetData(), job->GetDataSize() );
ASSERT( preprocessedSourceKey );
// hash the build "environment"
// TODO:B Exclude preprocessor control defines (the preprocessed input has considered those already)
uint32_t commandLineKey;
{
Args args;
const bool useDeoptimization = false;
const bool showIncludes = false;
const bool finalize = false; // Don't write args to reponse file
BuildArgs( job, args, PASS_COMPILE_PREPROCESSED, useDeoptimization, showIncludes, finalize );
commandLineKey = xxHash::Calc32( args.GetRawArgs().Get(), args.GetRawArgs().GetLength() );
}
ASSERT( commandLineKey );
// ToolChain hash
const uint64_t toolChainKey = GetCompiler()->CastTo< CompilerNode >()->GetManifest().GetToolId();
ASSERT( toolChainKey );
// PCH dependency
uint64_t pchKey = 0;
if ( GetFlag( FLAG_USING_PCH ) && GetFlag( FLAG_MSVC ) )
{
pchKey = GetPrecompiledHeader()->m_PCHCacheKey;
ASSERT( pchKey != 0 ); // Should not be in here if PCH is not cached
}
AStackString<> cacheName;
ICache::GetCacheId( preprocessedSourceKey, commandLineKey, toolChainKey, pchKey, cacheName );
job->SetCacheName(cacheName);
return job->GetCacheName();
}
// RetrieveFromCache
//------------------------------------------------------------------------------
bool ObjectNode::RetrieveFromCache( Job * job )
{
if ( FBuild::Get().GetOptions().m_UseCacheRead == false )
{
return false;
}
PROFILE_FUNCTION
const AString & cacheFileName = GetCacheName(job);
Timer t;
ICache * cache = FBuild::Get().GetCache();
ASSERT( cache );
void * cacheData( nullptr );
size_t cacheDataSize( 0 );
if ( cache->Retrieve( cacheFileName, cacheData, cacheDataSize ) )
{
const uint32_t retrieveTime = uint32_t( t.GetElapsedMS() );
// Hash the PCH result if we will need it later
uint64_t pchKey = 0;
if ( GetFlag( FLAG_CREATING_PCH ) && GetFlag( FLAG_MSVC ) )
{
pchKey = xxHash::Calc64( cacheData, cacheDataSize );
}
const uint32_t startDecompress = uint32_t( t.GetElapsedMS() );
// do decompression
Compressor c;
if ( c.IsValidData( cacheData, cacheDataSize ) == false )
{
FLOG_WARN( "Cache returned invalid data (header)\n"
" - File: '%s'\n"
" - Key : %s\n",
m_Name.Get(), cacheFileName.Get() );
return false;
}
if ( c.Decompress( cacheData ) == false )
{
FLOG_WARN( "Cache returned invalid data (payload)\n"
" - File: '%s'\n"
" - Key : %s\n",
m_Name.Get(), cacheFileName.Get() );
return false;
}
const void * data = c.GetResult();
const size_t dataSize = c.GetResultSize();
const uint32_t stopDecompress = uint32_t( t.GetElapsedMS() );
MultiBuffer buffer( data, dataSize );
Array< AString > fileNames( 4, false );
fileNames.Append( m_Name );
GetExtraCacheFilePaths( job, fileNames );
// Extract the files
const size_t numFiles = fileNames.GetSize();
for ( size_t i=0; i<numFiles; ++i )
{
if ( !buffer.ExtractFile( i, fileNames[ i ] ) )
{
cache->FreeMemory( cacheData, cacheDataSize );
FLOG_ERROR( "Failed to write local file during cache retrieval '%s'", fileNames[ i ].Get() );
return false;
}
// Update file modification time
const bool timeSetOK = FileIO::SetFileLastWriteTimeToNow( fileNames[ i ] );
// set the time on the local file
if ( timeSetOK == false )
{
cache->FreeMemory( cacheData, cacheDataSize );
FLOG_ERROR( "Failed to set timestamp after cache hit. Error: %s Target: '%s'", LAST_ERROR_STR, fileNames[ i ].Get() );
return false;
}
}
cache->FreeMemory( cacheData, cacheDataSize );
FileIO::WorkAroundForWindowsFilePermissionProblem( m_Name );
// record new file time (note that time may differ from what we set above due to
// file system precision)
RecordStampFromBuiltFile();
// Output
if ( FBuild::Get().GetOptions().m_ShowCommandSummary ||
FBuild::Get().GetOptions().m_CacheVerbose )
{
AStackString<> output;
output.Format( "Obj: %s <CACHE>\n", GetName().Get() );
if ( FBuild::Get().GetOptions().m_CacheVerbose )
{
output.AppendFormat( " - Cache Hit: %u ms (Retrieve: %u ms - Decompress: %u ms) (Compressed: %zu - Uncompressed: %zu) '%s'\n", uint32_t( t.GetElapsedMS() ), retrieveTime, stopDecompress - startDecompress, cacheDataSize, dataSize, cacheFileName.Get() );
}
FLOG_OUTPUT( output );
}
SetStatFlag( Node::STATS_CACHE_HIT );
// Dependent objects need to know the PCH key to be able to pull from the cache
if ( GetFlag( FLAG_CREATING_PCH ) && GetFlag( FLAG_MSVC ) )
{
m_PCHCacheKey = pchKey;
}
return true;
}
// Output
if ( FBuild::Get().GetOptions().m_CacheVerbose )
{
FLOG_OUTPUT( "Obj: %s\n"
" - Cache Miss: %u ms '%s'\n",
GetName().Get(), uint32_t( t.GetElapsedMS() ), cacheFileName.Get() );
}
SetStatFlag( Node::STATS_CACHE_MISS );
return false;
}
// WriteToCache
//------------------------------------------------------------------------------
void ObjectNode::WriteToCache( Job * job )
{
if (FBuild::Get().GetOptions().m_UseCacheWrite == false)
{
return;
}
PROFILE_FUNCTION
const AString & cacheFileName = GetCacheName(job);
ASSERT(!cacheFileName.IsEmpty());
Timer t;
ICache * cache = FBuild::Get().GetCache();
ASSERT( cache );
Array< AString > fileNames( 4, false );
fileNames.Append( m_Name );
GetExtraCacheFilePaths( job, fileNames );
MultiBuffer buffer;
if ( buffer.CreateFromFiles( fileNames ) )
{
// try to compress
const uint32_t startCompress( (uint32_t)t.GetElapsedMS() );
Compressor c;
c.Compress( buffer.GetData(), (size_t)buffer.GetDataSize(), FBuild::Get().GetOptions().m_CacheCompressionLevel );
const void * data = c.GetResult();
const size_t dataSize = c.GetResultSize();
const uint32_t stopCompress( (uint32_t)t.GetElapsedMS() );
const uint32_t startPublish( stopCompress );
if ( cache->Publish( cacheFileName, data, dataSize ) )
{
// cache store complete
const uint32_t stopPublish( (uint32_t)t.GetElapsedMS() );
SetStatFlag( Node::STATS_CACHE_STORE );
// Dependent objects need to know the PCH key to be able to pull from the cache
if ( GetFlag( FLAG_CREATING_PCH ) && GetFlag( FLAG_MSVC ) )
{
m_PCHCacheKey = xxHash::Calc64( data, dataSize );
}
const uint32_t cachingTime = uint32_t( t.GetElapsedMS() );
AddCachingTime( cachingTime );
// Output
if ( FBuild::Get().GetOptions().m_CacheVerbose )
{
AStackString<> output;
output.Format( "Obj: %s\n"
" - Cache Store: %u ms (Store: %u ms - Compress: %u ms) (Compressed: %zu - Uncompressed: %zu) '%s'\n",
GetName().Get(), cachingTime, ( stopPublish - startPublish ), ( stopCompress - startCompress ), dataSize, (size_t)buffer.GetDataSize(), cacheFileName.Get() );
if ( m_PCHCacheKey != 0 )
{
output.AppendFormat( " - PCH Key: %" PRIx64 "\n", m_PCHCacheKey );
}
FLOG_OUTPUT( output );
}
return;
}
}
// Output
if ( FBuild::Get().GetOptions().m_CacheVerbose )
{
FLOG_OUTPUT( "Obj: %s\n"
" - Cache Store Fail: %u ms '%s'\n",
GetName().Get(), uint32_t( t.GetElapsedMS() ), cacheFileName.Get() );
}
}
// GetExtraCacheFilePaths
//------------------------------------------------------------------------------
void ObjectNode::GetExtraCacheFilePaths( const Job * job, Array< AString > & outFileNames ) const
{
const Node * node = job->GetNode();
if ( node->GetType() != Node::OBJECT_NODE )
{
return;
}
// Only the MSVC compiler creates extra objects
const ObjectNode * objectNode = node->CastTo< ObjectNode >();
if ( objectNode->GetFlag( ObjectNode::FLAG_MSVC ) == false )
{
return;
}
// Precompiled Headers have an extra file
if ( objectNode->GetFlag( ObjectNode::FLAG_CREATING_PCH ) )
{
// .pch.obj
outFileNames.Append( m_PCHObjectFileName );
}
// Static analysis adds extra files
if ( objectNode->GetFlag( ObjectNode::FLAG_STATIC_ANALYSIS_MSVC ) )
{
if ( objectNode->GetFlag( ObjectNode::FLAG_CREATING_PCH ) )
{
// .pchast (precompiled headers only)
// Get file name start
ASSERT( PathUtils::IsFullPath( m_PCHObjectFileName ) ); // Something is terribly wrong
AStackString<> pchASTFileName( m_PCHObjectFileName );
if ( pchASTFileName.EndsWithI( ".obj" ) )
{
pchASTFileName.SetLength( pchASTFileName.GetLength() - 4 );
}
pchASTFileName += "ast";
outFileNames.Append( pchASTFileName );
}
// .nativecodeanalysis.xml (all files)
AStackString<> xmlFileName;
GetNativeAnalysisXMLPath( xmlFileName );
outFileNames.Append( xmlFileName );
}
}
// EmitCompilationMessage
//------------------------------------------------------------------------------
void ObjectNode::EmitCompilationMessage( const Args & fullArgs, bool useDeoptimization, bool stealingRemoteJob, bool racingRemoteJob, bool useDedicatedPreprocessor, bool isRemote ) const
{
// print basic or detailed output, depending on options
// we combine everything into one string to ensure it is contiguous in
// the output
AStackString<> output;
if ( FBuild::IsValid() && FBuild::Get().GetOptions().m_ShowCommandSummary )
{
output += "Obj: ";
if ( useDeoptimization )
{
output += "**Deoptimized** ";
}
if ( GetFlag( FLAG_ISOLATED_FROM_UNITY ) )
{
output += "**Isolated** ";
}
output += GetName();
if ( racingRemoteJob )
{
output += " <LOCAL RACE>";
}
else if ( stealingRemoteJob )
{
output += " <LOCAL>";
}
output += '\n';
}
if ( ( FBuild::IsValid() && FBuild::Get().GetOptions().m_ShowCommandLines ) || isRemote )
{
output += useDedicatedPreprocessor ? GetDedicatedPreprocessor()->GetExecutable().Get() : GetCompiler() ? GetCompiler()->GetExecutable().Get() : "";
output += ' ';
output += fullArgs.GetRawArgs();
output += '\n';
}
FLOG_OUTPUT( output );
}
// StripTokenWithArg
//------------------------------------------------------------------------------
/*static*/ bool ObjectNode::StripTokenWithArg( const char * tokenToCheckFor, const AString & token, size_t & index )
{
if ( token.BeginsWith( tokenToCheckFor ) )
{
if ( token == tokenToCheckFor )
{
++index; // skip additional next token
}
return true; // found
}
return false; // not found
}
// StripTokenWithArg_MSVC
//------------------------------------------------------------------------------
/*static*/ bool ObjectNode::StripTokenWithArg_MSVC( const char * tokenToCheckFor, const AString & token, size_t & index )
{
if ( IsStartOfCompilerArg_MSVC( token, tokenToCheckFor ) )
{
if ( IsCompilerArg_MSVC( token, tokenToCheckFor ) )
{
++index; // skip additional next token
}
return true; // found
}
return false; // not found
}
// StripToken
//------------------------------------------------------------------------------
/*static*/ bool ObjectNode::StripToken( const char * tokenToCheckFor, const AString & token, bool allowStartsWith )
{
if ( allowStartsWith )
{
return token.BeginsWith( tokenToCheckFor );
}
else
{
return ( token == tokenToCheckFor );
}
}
// StripToken_MSVC
//------------------------------------------------------------------------------
/*static*/ bool ObjectNode::StripToken_MSVC( const char * tokenToCheckFor, const AString & token, bool allowStartsWith )
{
if ( allowStartsWith )
{
return IsStartOfCompilerArg_MSVC( token, tokenToCheckFor );
}
else
{
return IsCompilerArg_MSVC( token, tokenToCheckFor );
}
}
// BuildArgs
//------------------------------------------------------------------------------
bool ObjectNode::BuildArgs( const Job * job, Args & fullArgs, Pass pass, bool useDeoptimization, bool showIncludes, bool finalize, const AString & overrideSrcFile ) const
{
PROFILE_FUNCTION
Array< AString > tokens( 1024, true );
const bool useDedicatedPreprocessor = ( ( pass == PASS_PREPROCESSOR_ONLY ) && GetDedicatedPreprocessor() );
if ( useDedicatedPreprocessor )
{
m_PreprocessorOptions.Tokenize( tokens );
}
else if ( useDeoptimization )
{
ASSERT( !m_CompilerOptionsDeoptimized.IsEmpty() );
m_CompilerOptionsDeoptimized.Tokenize( tokens );
}
else
{
m_CompilerOptions.Tokenize( tokens );
}
fullArgs.Clear();
// Get base path if needed
AStackString<> basePath;
const bool useRelativePaths = job->IsLocal() && // TODO:C We'd want to support this remotely as well
job->GetNode()->CastTo<ObjectNode>()->GetCompiler()->GetUseRelativePaths();
if ( useRelativePaths )
{
basePath = FBuild::Get().GetOptions().GetWorkingDir(); // NOTE: FBuild only valid locally
PathUtils::EnsureTrailingSlash( basePath );
}
const bool isMSVC = ( useDedicatedPreprocessor ) ? GetPreprocessorFlag( FLAG_MSVC ) : GetFlag( FLAG_MSVC );
const bool isClang = ( useDedicatedPreprocessor ) ? GetPreprocessorFlag( FLAG_CLANG ) : GetFlag( FLAG_CLANG );
const bool isGCC = ( useDedicatedPreprocessor ) ? GetPreprocessorFlag( FLAG_GCC ) : GetFlag( FLAG_GCC );
const bool isSNC = ( useDedicatedPreprocessor ) ? GetPreprocessorFlag( FLAG_SNC ) : GetFlag( FLAG_SNC );
const bool isCWWii = ( useDedicatedPreprocessor ) ? GetPreprocessorFlag( CODEWARRIOR_WII ) : GetFlag( CODEWARRIOR_WII );
const bool isGHWiiU = ( useDedicatedPreprocessor ) ? GetPreprocessorFlag( GREENHILLS_WIIU ) : GetFlag( GREENHILLS_WIIU );
const bool isCUDA = ( useDedicatedPreprocessor ) ? GetPreprocessorFlag( FLAG_CUDA_NVCC ) : GetFlag( FLAG_CUDA_NVCC );
const bool isQtRCC = ( useDedicatedPreprocessor ) ? GetPreprocessorFlag( FLAG_QT_RCC ) : GetFlag( FLAG_QT_RCC );
const bool isVBCC = ( useDedicatedPreprocessor ) ? GetPreprocessorFlag( FLAG_VBCC ) : GetFlag( FLAG_VBCC );
const bool isOrbisWavePsslc = ( useDedicatedPreprocessor ) ? GetPreprocessorFlag( FLAG_ORBIS_WAVE_PSSLC) : GetFlag(FLAG_ORBIS_WAVE_PSSLC);
const bool forceColoredDiagnostics = ( ( useDedicatedPreprocessor ) ? GetPreprocessorFlag( FLAG_DIAGNOSTICS_COLOR_AUTO ) : GetFlag( FLAG_DIAGNOSTICS_COLOR_AUTO ) ) && ( Env::IsStdOutRedirected() == false );
const size_t numTokens = tokens.GetSize();
for ( size_t i = 0; i < numTokens; ++i )
{
// current token
const AString & token = tokens[ i ];
// -o removal for preprocessor
if ( pass == PASS_PREPROCESSOR_ONLY )
{
if ( isGCC || isSNC || isClang || isCWWii || isGHWiiU || isCUDA || isVBCC || isOrbisWavePsslc )
{
if ( StripTokenWithArg( "-o", token, i ) )
{
continue;
}
if ( !isVBCC )
{
if ( StripToken( "-c", token ) )
{
continue; // remove -c (compile) option when using preprocessor only
}
}
}
else if ( isQtRCC )
{
// remove --output (or alias -o) so dependency list goes to stdout
if ( StripTokenWithArg( "--output", token, i ) ||
StripTokenWithArg( "-o", token, i ) )
{
continue;
}
}
}
if ( isClang || isGCC ) // Also check when invoked via gcc sym link
{
// The pch can only be utilized when doing a direct compilation
// - Can't be used to generate the preprocessed output
// - Can't be used to accelerate compilation of the preprocessed output
if ( pass != PASS_COMPILE )
{
if ( StripTokenWithArg( "-include-pch", token, i ) )
{
continue; // skip this token in both cases
}
}
}
if ( isMSVC )
{
if ( pass == PASS_COMPILE_PREPROCESSED )
{
// Can't use the precompiled header when compiling the preprocessed output
// as this would prevent cacheing.
if ( StripTokenWithArg_MSVC( "Yu", token, i ) )
{
continue; // skip this token in both cases
}
if ( StripTokenWithArg_MSVC( "Fp", token, i ) )
{
continue; // skip this token in both cases
}
// Remote compilation writes to a temp pdb
if ( job->IsLocal() == false )
{
if ( StripTokenWithArg_MSVC( "Fd", token, i ) )
{
continue; // skip this token in both cases
}
}
}
}
if ( isMSVC )
{
// FASTBuild handles the multiprocessor scheduling
if ( StripToken_MSVC( "MP", token, true ) ) // true = strip '/MP' and starts with '/MP'
{
continue;
}
// "Minimal Rebuild" is not compatible with FASTBuild
if ( StripToken_MSVC( "Gm", token ) )
{
continue;
}
}
// remove includes for second pass
if ( pass == PASS_COMPILE_PREPROCESSED )
{
if ( isClang )
{
// Clang requires -I options be stripped when compiling preprocessed code
// (it raises an error if we don't remove these)
if ( StripTokenWithArg( "-I", token, i ) )
{
continue; // skip this token in both cases
}
}
if ( isGCC || isClang )
{
// Remove isysroot, which may not exist on a distributed system, and
// should only be used for include paths, which have already been
// processed.
if ( StripTokenWithArg( "-isysroot", token, i ) )
{
continue; // skip this token in both cases
}
}
if ( isGCC || isClang || isVBCC || isOrbisWavePsslc )
{
// Remove forced includes so they aren't forced twice
if ( StripTokenWithArg( "-include", token, i ) )
{
continue; // skip this token in both cases
}
}
if ( isMSVC )
{
// NOTE: Leave /I includes for compatibility with Recode
// (unlike Clang, MSVC is ok with leaving the /I when compiling preprocessed code)
// To prevent D8049 "command line is too long to fit in debug record"
// we expand relative includes as they would be on the host (so the remote machine's
// working dir is not used, which might be longer, causing this overflow an internal
// limit of cl.exe)
if ( ( job->IsLocal() == false ) && IsStartOfCompilerArg_MSVC( token, "I" ) )
{
if (StripTokenWithArg_MSVC("I", token, i))
{
continue; // skip this token in both cases
}
// Get include path part
const char * start = token.Get() + 2; // Skip /I or -I
const char * end = token.GetEnd();
// strip quotes if present
if ( *start == '"' )
{
++start;
}
if ( end[ -1 ] == '"' )
{
--end;
}
AStackString<> includePath( start, end );
const bool isFullPath = PathUtils::IsFullPath( includePath );
// Replace relative paths and leave full paths alone
if ( isFullPath == false )
{
// Remove relative include
StripTokenWithArg_MSVC( "I", token, i );
// Add full path include
fullArgs.Append( token.Get(), (size_t)( start - token.Get() ) );
fullArgs += job->GetRemoteSourceRoot();
fullArgs += '\\';
fullArgs += includePath;
fullArgs.Append( end, (size_t)( token.GetEnd() - end ) );
fullArgs.AddDelimiter();
continue; // Include path has been replaced
}
}
// Strip "Force Includes" statements (as they are merged in now)
if ( StripTokenWithArg_MSVC( "FI", token, i ) )
{
continue; // skip this token in both cases
}
}
}
if ( isMSVC )
{
if ( pass == PASS_PREPROCESSOR_ONLY )
{
//Strip /ZW
if ( StripToken_MSVC( "ZW", token ) )
{
fullArgs += "/D__cplusplus_winrt ";
continue;
}
// Strip /Yc (pch creation)
if ( StripTokenWithArg_MSVC( "Yc", token, i ) )
{
continue;
}
}
}
// Remove static analyzer from clang preprocessor
if ( pass == PASS_PREPROCESSOR_ONLY )
{
if ( isClang )
{
if ( StripToken( "--analyze", token ) )
{
continue;
}
if ( StripTokenWithArg( "-Xanalyzer", token, i ) ||
StripTokenWithArg( "-analyzer-output", token, i ) ||
StripTokenWithArg( "-analyzer-config", token, i ) ||
StripTokenWithArg( "-analyzer-checker", token, i ) )
{
continue;
}
}
}
// Strip -fdiagnostics-color options because we are going to override them
if ( forceColoredDiagnostics && ( isClang || isGCC ) )
{
if ( StripToken( "-fdiagnostics-color", token, true ) ||
StripToken( "-fno-diagnostics-color", token ) )
{
continue;
}
}
// %1 -> InputFile
const char * found = token.Find( "%1" );
if ( found )
{
fullArgs += AStackString<>( token.Get(), found );
if ( overrideSrcFile.IsEmpty() )
{
if ( useRelativePaths )
{
AStackString<> relativeFileName;
PathUtils::GetRelativePath( basePath, GetSourceFile()->GetName(), relativeFileName );
fullArgs += relativeFileName;
}
else
{
fullArgs += GetSourceFile()->GetName();
}
}
else
{
fullArgs += overrideSrcFile;
}
fullArgs += AStackString<>( found + 2, token.GetEnd() );
fullArgs.AddDelimiter();
continue;
}
// %2 -> OutputFile
found = token.Find( "%2" );
if ( found )
{
fullArgs += AStackString<>( token.Get(), found );
if ( useRelativePaths )
{
AStackString<> relativeFileName;
PathUtils::GetRelativePath( basePath, m_Name, relativeFileName );
fullArgs += relativeFileName;
}
else
{
fullArgs += m_Name;
}
fullArgs += AStackString<>( found + 2, token.GetEnd() );
fullArgs.AddDelimiter();
continue;
}
// %3 -> PrecompiledHeader Obj
if ( isMSVC )
{
found = token.Find( "%3" );
if ( found )
{
// handle /Option:%3 -> /Option:A
fullArgs += AStackString<>( token.Get(), found );
ASSERT( m_PCHObjectFileName.IsEmpty() == false ); // Should have been populated
fullArgs += m_PCHObjectFileName;
fullArgs += AStackString<>( found + 2, token.GetEnd() );
fullArgs.AddDelimiter();
continue;
}
}
// %4 -> CompilerForceUsing list
if ( isMSVC )
{
found = token.Find( "%4" );
if ( found )
{
AStackString<> pre( token.Get(), found );
AStackString<> post( found + 2, token.GetEnd() );
ExpandCompilerForceUsing( fullArgs, pre, post );
fullArgs.AddDelimiter();
continue;
}
}
// cl.exe treats \" as an escaped quote
// It's a common user error to terminate things (like include paths) with a quote
// this way, messing up the rest of the args and causing bizarre failures.
// Since " is not a valid character in a path, just strip the escape char
if ( isMSVC )
{
// Is this invalid?
// bad: /I"directory\" - TODO:B Handle other args with this problem
// ok : /I\"directory\"
// ok : /I"directory"
if ( ObjectNode::IsStartOfCompilerArg_MSVC( token, "I\"" ) && token.EndsWith( "\\\"" ) )
{
fullArgs.Append( token.Get(), token.GetLength() - 2 );
fullArgs += '"';
fullArgs.AddDelimiter();
continue;
}
}
// untouched token
fullArgs += token;
fullArgs.AddDelimiter();
}
if ( pass == PASS_PREPROCESSOR_ONLY )
{
if ( isMSVC )
{
// This attempt to define the missing _PREFAST_ macro results in strange
// inconsistencies when compiling with /analyze
//if ( GetFlag( FLAG_STATIC_ANALYSIS_MSVC ) )
//{
// // /E disables the /D_PREFAST_ define when used with /analyze
// // but we want SAL annotations to still be applied
// fullArgs += "/D_PREFAST_=1"; // NOTE: Must be before /E option!
// fullArgs.AddDelimiter();
//}
fullArgs += "/E"; // run pre-processor only
// Ensure unused defines declared in the PCH but not used
// in the PCH are accounted for (See TestPrecompiledHeaders/CacheUniqueness)
if ( GetFlag( FLAG_CREATING_PCH ) )
{
fullArgs += " /d1PP"; // Must be after /E
}
}
else if ( isQtRCC )
{
fullArgs += " --list"; // List used resources
}
else
{
ASSERT( isGCC || isSNC || isClang || isCWWii || isGHWiiU || isCUDA || isVBCC || isOrbisWavePsslc );
fullArgs += "-E"; // run pre-processor only
// Ensure unused defines declared in the PCH but not used
// in the PCH are accounted for (See TestPrecompiledHeaders/CacheUniqueness)
if ( GetFlag( FLAG_CREATING_PCH ) )
{
fullArgs += " -dD";
}
const bool clangRewriteIncludes = GetCompiler()->IsClangRewriteIncludesEnabled();
if ( isClang && clangRewriteIncludes )
{
fullArgs += " -frewrite-includes";
}
}
}
if ( showIncludes )
{
fullArgs += " /showIncludes"; // we'll extract dependency information from this
}
// Remote compilation writes to a temp pdb
if ( ( job->IsLocal() == false ) &&
( job->GetNode()->CastTo< ObjectNode >()->IsUsingPDB() ) )
{
AStackString<> pdbName, tmp;
GetPDBName( pdbName );
tmp.Format( " /Fd\"%s\"", pdbName.Get() );
fullArgs += tmp;
}
if ( forceColoredDiagnostics && ( isClang || isGCC ) )
{
fullArgs += " -fdiagnostics-color=always";
}
// Skip finalization?
if ( finalize == false )
{
return true;
}
// Handle all the special needs of args
AStackString<> remoteCompiler;
if ( job->IsLocal() == false )
{
job->GetToolManifest()->GetRemoteFilePath( 0, remoteCompiler );
}
const AString& compiler = job->IsLocal() ? GetCompiler()->GetExecutable() : remoteCompiler;
if ( fullArgs.Finalize( compiler, GetName(), CanUseResponseFile() ) == false )
{
return false; // Finalize will have emitted an error
}
return true;
}
// ExpandCompilerForceUsing
//------------------------------------------------------------------------------
void ObjectNode::ExpandCompilerForceUsing( Args & fullArgs, const AString & pre, const AString & post ) const
{
const size_t startIndex = 2 + ( !m_PrecompiledHeader.IsEmpty() ? 1u : 0u ) + ( !m_Preprocessor.IsEmpty() ? 1u : 0u ); // Skip Compiler, InputFile, PCH and Preprocessor
const size_t endIndex = m_StaticDependencies.GetSize();
for ( size_t i=startIndex; i<endIndex; ++i )
{
Node * n = m_StaticDependencies[ i ].GetNode();
fullArgs += pre;
fullArgs += n->GetName();
fullArgs += post;
fullArgs.AddDelimiter();
}
}
// BuildPreprocessedOutput
//------------------------------------------------------------------------------
bool ObjectNode::BuildPreprocessedOutput( const Args & fullArgs, Job * job, bool useDeoptimization ) const
{
const bool useDedicatedPreprocessor = ( GetDedicatedPreprocessor() != nullptr );
EmitCompilationMessage( fullArgs, useDeoptimization, false, false, useDedicatedPreprocessor );
// spawn the process
CompileHelper ch( false ); // don't handle output (we'll do that)
// TODO:A Add checks in BuildArgs for length of dedicated preprocessor
if ( !ch.SpawnCompiler( job, GetName(),
useDedicatedPreprocessor ? GetDedicatedPreprocessor() : GetCompiler(),
useDedicatedPreprocessor ? GetDedicatedPreprocessor()->GetExecutable() : GetCompiler()->GetExecutable(),
fullArgs,m_WorkingDir.Get()) )
{
// only output errors in failure case
// (as preprocessed output goes to stdout, normal logging is pushed to
// stderr, and we don't want to see that unless there is a problem)
// NOTE: Output is omitted in case the compiler has been aborted because we don't care about the errors
// caused by the manual process abortion (process killed)
if ( ( ch.GetResult() != 0 ) && !ch.HasAborted() )
{
// Use the error text, but if it's empty, use the output
if ( ch.GetErr().Get() )
{
DumpOutput( job, ch.GetErr(), GetName() );
}
else
{
DumpOutput( job, ch.GetOut(), GetName() );
}
}
return false; // SpawnCompiler will have emitted error
}
// take a copy of the output because ReadAllData uses huge buffers to avoid re-sizing
TransferPreprocessedData( ch.GetOut().Get(), ch.GetOut().GetLength(), job );
return true;
}
// LoadStaticSourceFileForDistribution
//------------------------------------------------------------------------------
bool ObjectNode::LoadStaticSourceFileForDistribution( const Args & fullArgs, Job * job, bool useDeoptimization ) const
{
// PreProcessing for SimpleDistribution is just loading the source file
const bool useDedicatedPreprocessor = ( GetDedicatedPreprocessor() != nullptr );
EmitCompilationMessage(fullArgs, useDeoptimization, false, false, useDedicatedPreprocessor);
const AString & fileName = job->GetNode()->CastTo<ObjectNode>()->GetSourceFile()->CastTo<FileNode>()->GetName();
// read the file into memory
FileStream fs;
if ( fs.Open( fileName.Get(), FileStream::READ_ONLY ) == false )
{
FLOG_ERROR( "Error: opening file '%s' while loading source file for transport\n", fileName.Get() );
return false;
}
uint32_t contentSize = (uint32_t)fs.GetFileSize();
AutoPtr< void > mem( ALLOC( contentSize ) );
if ( fs.Read( mem.Get(), contentSize ) != contentSize )
{
FLOG_ERROR( "Error: reading file '%s' in Compiler ToolManifest\n", fileName.Get() );
return false;
}
job->OwnData( mem.Release(), contentSize );
return true;
}
// TransferPreprocessedData
//------------------------------------------------------------------------------
void ObjectNode::TransferPreprocessedData( const char * data, size_t dataSize, Job * job ) const
{
// We will trim the buffer
const char* outputBuffer = data;
size_t outputBufferSize = dataSize;
size_t newBufferSize = outputBufferSize;
char * bufferCopy = nullptr;
#if defined( __WINDOWS__ )
// VS 2012 sometimes generates corrupted code when preprocessing an already preprocessed file when it encounters
// enum definitions.
// Example:
// enum dateorder
// {
// no_order, dmy, mdy, ymd, ydm
// };
// Becomes:
// enummdateorder
// {
// no_order, dmy, mdy, ymd, ydm
// };
// And then compilation fails.
//
// Adding a space between the enum keyword and the name avoids the bug.
// This bug is fixed in VS2013 or later.
bool doVS2012Fixup = false;
if ( GetCompiler()->GetType() == Node::COMPILER_NODE )
{
CompilerNode* cn = GetCompiler();
doVS2012Fixup = cn->IsVS2012EnumBugFixEnabled();
}
if ( doVS2012Fixup )
{
Array< const char * > enumsFound( 2048, true );
const char BUGGY_CODE[] = "enum ";
const char* workBuffer = outputBuffer;
ASSERT( workBuffer[ outputBufferSize ] == '\0' );
// First scan the buffer to find all occurences of the enums.
// This will then let us resize the buffer to the appropriate size.
// Keeping the found enums let us avoid searching for them twice.
uint32_t nbrEnumsFound = 0;
const char * buggyEnum = nullptr;
for (;;)
{
buggyEnum = strstr( workBuffer, BUGGY_CODE );
if ( buggyEnum == nullptr )
{
break;
}
++nbrEnumsFound;
enumsFound.Append( buggyEnum );
workBuffer = buggyEnum + sizeof( BUGGY_CODE ) - 1;
}
ASSERT( enumsFound.GetSize() == nbrEnumsFound );
// Now allocate the new buffer with enough space to add a space after each enum found
newBufferSize = outputBufferSize + nbrEnumsFound;
bufferCopy = (char *)ALLOC( newBufferSize + 1 ); // null terminator for include parser
uint32_t enumIndex = 0;
workBuffer = outputBuffer;
char * writeDest = bufferCopy;
size_t sizeLeftInSourceBuffer = outputBufferSize;
buggyEnum = nullptr;
for (;;)
{
if ( enumIndex < nbrEnumsFound )
{
buggyEnum = enumsFound[ enumIndex ];
++enumIndex;
}
else
{
buggyEnum = nullptr;
}
if ( buggyEnum == nullptr )
{
// Copy the rest of the data.
memcpy( writeDest, workBuffer, sizeLeftInSourceBuffer );
break;
}
// Copy what's before the enum + the enum.
size_t sizeToCopy = (size_t)( buggyEnum - workBuffer );
sizeToCopy += ( sizeof( BUGGY_CODE ) - 1 );
memcpy( writeDest, workBuffer, sizeToCopy );
writeDest += sizeToCopy;
// Add a space
*writeDest = ' ';
++writeDest;
ASSERT( sizeLeftInSourceBuffer >= sizeToCopy );
sizeLeftInSourceBuffer -= sizeToCopy;
workBuffer += sizeToCopy;
}
bufferCopy[ newBufferSize ] = 0; // null terminator for include parser
}
else
#endif
{
bufferCopy = (char *)ALLOC( newBufferSize + 1 ); // null terminator for include parser
memcpy( bufferCopy, outputBuffer, newBufferSize );
bufferCopy[ newBufferSize ] = 0; // null terminator for include parser
}
job->OwnData( bufferCopy, newBufferSize );
}
// WriteTmpFile
//------------------------------------------------------------------------------
bool ObjectNode::WriteTmpFile( Job * job, AString & tmpDirectory, AString & tmpFileName ) const
{
ASSERT( job->GetData() && job->GetDataSize() );
Node * sourceFile = GetSourceFile();
uint32_t sourceNameHash = xxHash::Calc32( sourceFile->GetName().Get(), sourceFile->GetName().GetLength() );
FileStream tmpFile;
AStackString<> fileName( sourceFile->GetName().FindLast( NATIVE_SLASH ) + 1 );
if ( GetFlag( FLAG_GCC ) )
{
// Add extension to the name of the temporary file that corresponds to
// a preprocessed variant of the original extension.
// That way GCC will be able to deduce the same language from the name
// of temporary file as it would do from the original name.
const char * lastDot = fileName.FindLast( '.' );
if ( ( lastDot != nullptr ) && ( lastDot[1] != '\0' ) )
{
AStackString<> extension( lastDot + 1 );
if ( extension == "c" )
{
fileName += ".i";
}
else if ( ( extension == "cpp" ) || ( extension == "cc" ) || ( extension == "cxx" ) || ( extension == "c++" || extension == "cp" || extension == "CPP" || extension == "C" ) )
{
fileName += ".ii";
}
else if ( extension == "m" )
{
fileName += ".mi";
}
else if ( ( extension == "mm" ) || ( extension == "M" ) )
{
fileName += ".mii";
}
else if ( ( extension == "F" ) || ( extension == "fpp" ) || ( extension == "FPP" ) )
{
fileName += ".f";
}
else if ( extension == "FOR" )
{
fileName += ".for";
}
else if ( extension == "FTN" )
{
fileName += ".ftn";
}
else if ( extension == "F90" )
{
fileName += ".f90";
}
else if ( extension == "F95" )
{
fileName += ".f95";
}
else if ( extension == "F03" )
{
fileName += ".f03";
}
else if ( extension == "F08" )
{
fileName += ".f08";
}
else if ( ( extension == "S" ) || ( extension == "sx" ) )
{
fileName += ".s";
}
}
}
void const * dataToWrite = job->GetData();
size_t dataToWriteSize = job->GetDataSize();
// handle compressed data
Compressor c; // scoped here so we can access decompression buffer
if ( job->IsDataCompressed() )
{
VERIFY( c.Decompress( dataToWrite ) );
dataToWrite = c.GetResult();
dataToWriteSize = c.GetResultSize();
}
WorkerThread::GetTempFileDirectory( tmpDirectory );
tmpDirectory.AppendFormat( "%08X%c", sourceNameHash, NATIVE_SLASH );
if ( FileIO::DirectoryCreate( tmpDirectory ) == false )
{
job->Error( "Failed to create temp directory. Error: %s TmpDir: '%s' Target: '%s'", LAST_ERROR_STR, tmpDirectory.Get(), GetName().Get() );
job->OnSystemError();
return NODE_RESULT_FAILED;
}
tmpFileName = tmpDirectory;
tmpFileName += fileName;
if ( WorkerThread::CreateTempFile( tmpFileName, tmpFile ) == false )
{
FileIO::WorkAroundForWindowsFilePermissionProblem( tmpFileName, FileStream::WRITE_ONLY, 10 ); // 10s max wait
// Try again
if ( WorkerThread::CreateTempFile( tmpFileName, tmpFile ) == false )
{
job->Error( "Failed to create temp file. Error: %s TmpFile: '%s' Target: '%s'", LAST_ERROR_STR, tmpFileName.Get(), GetName().Get() );
job->OnSystemError();
return NODE_RESULT_FAILED;
}
}
if ( tmpFile.Write( dataToWrite, dataToWriteSize ) != dataToWriteSize )
{
job->Error( "Failed to write to temp file. Error: %s TmpFile: '%s' Target: '%s'", LAST_ERROR_STR, tmpFileName.Get(), GetName().Get() );
job->OnSystemError();
return NODE_RESULT_FAILED;
}
tmpFile.Close();
FileIO::WorkAroundForWindowsFilePermissionProblem( tmpFileName );
// On remote workers, free compressed buffer as we don't need it anymore
// This reduces memory consumed on the remote worker.
if ( job->IsLocal() == false )
{
job->OwnData( nullptr, 0, false ); // Free compressed buffer
}
return true;
}
// BuildFinalOutput
//------------------------------------------------------------------------------
bool ObjectNode::BuildFinalOutput( Job * job, const Args & fullArgs ) const
{
// Use the remotely synchronized compiler if building remotely
AStackString<> compiler;
AStackString<> workingDir;
if ( job->IsLocal() )
{
compiler = GetCompiler()->GetExecutable();
}
else
{
ASSERT( job->GetToolManifest() );
job->GetToolManifest()->GetRemoteFilePath( 0, compiler );
job->GetToolManifest()->GetRemotePath( workingDir );
}
// spawn the process
CompileHelper ch( true, job->GetAbortFlagPointer() );
if ( !ch.SpawnCompiler( job, GetName(), GetCompiler(), compiler, fullArgs, workingDir.IsEmpty() ? nullptr : workingDir.Get() ) )
{
// did spawn fail, or did we spawn and fail to compile?
if ( ch.GetResult() != 0 )
{
// failed to compile
// for remote jobs, we must serialize the errors to return with the job
if ( job->IsLocal() == false )
{
AutoPtr< char > mem( (char *)ALLOC( ch.GetOut().GetLength() + ch.GetErr().GetLength() ) );
memcpy( mem.Get(), ch.GetOut().Get(), ch.GetOut().GetLength() );
memcpy( mem.Get() + ch.GetOut().GetLength(), ch.GetErr().Get(), ch.GetErr().GetLength() );
job->OwnData( mem.Release(), ( ch.GetOut().GetLength() + ch.GetErr().GetLength() ) );
}
}
return false; // compile has logged error
}
else
{
// Handle warnings for compilation that passed
if ( ch.GetResult() == 0 )
{
if ( IsMSVC() )
{
if ( !GetFlag( FLAG_WARNINGS_AS_ERRORS_MSVC ) )
{
HandleWarningsMSVC( job, GetName(), ch.GetOut() );
}
}
else if ( IsClang() || IsGCC() )
{
if ( !GetFlag( ObjectNode::FLAG_WARNINGS_AS_ERRORS_CLANGGCC ) )
{
HandleWarningsClangGCC( job, GetName(), ch.GetOut() );
}
}
}
}
return true;
}
// CompileHelper::CONSTRUCTOR
//------------------------------------------------------------------------------
ObjectNode::CompileHelper::CompileHelper( bool handleOutput, const volatile bool * abortPointer )
: m_HandleOutput( handleOutput )
, m_Process( FBuild::GetAbortBuildPointer(), abortPointer )
, m_Result( 0 )
{
}
// CompileHelper::DESTRUCTOR
//------------------------------------------------------------------------------
ObjectNode::CompileHelper::~CompileHelper() = default;
// CompilHelper::SpawnCompiler
//------------------------------------------------------------------------------
bool ObjectNode::CompileHelper::SpawnCompiler( Job * job,
const AString & name,
const CompilerNode * compilerNode,
const AString & compiler,
const Args & fullArgs,
const char * workingDir )
{
const char * environmentString = nullptr;
if ( ( job->IsLocal() == false ) && ( job->GetToolManifest() ) )
{
environmentString = job->GetToolManifest()->GetRemoteEnvironmentString();
}
else
{
environmentString = compilerNode->GetEnvironmentString();
}
// spawn the process
if ( false == m_Process.Spawn( compiler.Get(),
fullArgs.GetFinalArgs().Get(),
workingDir,
environmentString ) )
{
if ( m_Process.HasAborted() )
{
return false;
}
job->Error( "Failed to spawn process. Error: %s Target: '%s'\n", LAST_ERROR_STR, name.Get() );
job->OnSystemError();
return false;
}
// capture all of the stdout and stderr
m_Process.ReadAllData( m_Out, m_Err );
// Get result
m_Result = m_Process.WaitForExit();
if ( m_Process.HasAborted() )
{
return false;
}
// Handle special types of failures
HandleSystemFailures( job, m_Result, m_Out, m_Err );
if ( m_HandleOutput )
{
if ( job->IsLocal() && FBuild::Get().GetOptions().m_ShowCommandOutput )
{
// Suppress /showIncludes - TODO:C leave in if user specified it
StackArray< AString > exclusions;
if ( ( compilerNode->GetCompilerFamily() == CompilerNode::CompilerFamily::MSVC ) &&
( fullArgs.GetFinalArgs().Find( " /showIncludes" ) ) )
{
exclusions.EmplaceBack( "Note: including file:" );
}
Node::DumpOutput( job, m_Out, &exclusions );
Node::DumpOutput( job, m_Err, &exclusions );
}
else
{
// output any errors (even if succeeded, there might be warnings)
if ( m_Err.Get() )
{
const bool treatAsWarnings = true; // change msg formatting
DumpOutput( job, m_Err, name, treatAsWarnings );
}
}
}
// failed?
if ( m_Result != 0 )
{
// output 'stdout' which may contain errors for some compilers
if ( m_HandleOutput )
{
DumpOutput( job, m_Out, name );
}
job->Error( "Failed to build Object. Error: %s Target: '%s'\n", ERROR_STR( m_Result ), name.Get() );
return false;
}
return true;
}
// HandleSystemFailures
//------------------------------------------------------------------------------
/*static*/ void ObjectNode::HandleSystemFailures( Job * job, int result, const AString & stdOut, const AString & stdErr )
{
// Only remote compilation has special cases. We don't touch local failures.
if ( job->IsLocal() )
{
return;
}
// Nothing to check if everything is ok
if ( result == 0 )
{
return;
}
const ObjectNode * objectNode = job->GetNode()->CastTo< ObjectNode >();
// General process failures
#if defined( __WINDOWS__ )
// If remote PC is shutdown by user, compiler can be terminated
if ( ( (uint32_t)result == 0x40010004 ) || // DBG_TERMINATE_PROCESS
( (uint32_t)result == 0xC0000142 ) ) // STATUS_DLL_INIT_FAILED - Occurs if remote PC is stuck on force reboot dialog during shutdown
{
job->OnSystemError(); // task will be retried on another worker
return;
}
// When a process is terminated by a user on Windows, the return code can
// be 1. There seems to be no definitive way to differentiate this from
// a process exiting with return code 1, so we default to considering it a
// system failure, unless we can detect some specific situations.
if ( result == 0x1 )
{
bool treatAsSystemError = true;
// Some compilers (like Clang) return 1 when there are compile errors
// and write those errors to stderr
// don't consider this a system failure if there are compile errors
if ( stdErr.IsEmpty() == false )
{
treatAsSystemError = false;
}
if ( treatAsSystemError )
{
job->OnSystemError(); // task will be retried on another worker
return;
}
}
// If DLLs are not correctly sync'd, add an extra message to help the user
if ( (uint32_t)result == 0xC000007B ) // STATUS_INVALID_IMAGE_FORMAT
{
job->Error( "Remote failure: STATUS_INVALID_IMAGE_FORMAT (0xC000007B) - Check Compiler() settings!\n" );
return;
}
if ( (uint32_t)result == 0xC0000135 ) // STATUS_DLL_NOT_FOUND
{
job->Error( "Remote failure: STATUS_DLL_NOT_FOUND (0xC0000135) - Check Compiler() settings!\n" );
return;
}
#endif
// Compiler specific failures
#if defined( __WINDOWS__ )
// MSVC errors
if ( objectNode->IsMSVC() )
{
// But we need to determine if it's actually an out of space
// (rather than some compile error with missing file(s))
// These error codes have been observed in the wild
if ( stdOut.Find( "C1082" ) ||
stdOut.Find( "C1085" ) ||
stdOut.Find( "C1088" ) )
{
job->OnSystemError();
return;
}
// Windows temp directories can have problems failing to open temp files
// resulting in 'C1083: Cannot open compiler intermediate file:'
// It uses the same C1083 error as a mising include C1083, but since we flatten
// includes on the host this should never occur remotely other than in this context.
if ( stdOut.Find( "C1083" ) )
{
job->OnSystemError();
return;
}
// The MSVC compiler can fail with "compiler is out of heap space" even if
// using the 64bit toolchain. This failure can be intermittent and not
// repeatable with the same code on a different machine, so we don't want it
// to fail the build.
if ( stdOut.Find( "C1060" ) )
{
// If either of these are present
// - C1076 : compiler limit : internal heap limit reached; use /Zm to specify a higher limit
// - C3859 : virtual memory range for PCH exceeded; please recompile with a command line option of '-Zmvalue' or greater
// then the issue is related to compiler settings.
// If they are not present, it's a system error, possibly caused by system resource
// exhaustion on the remote machine
if ( ( stdOut.Find( "C1076" ) == nullptr ) &&
( stdOut.Find( "C3859" ) == nullptr ) )
{
job->OnSystemError();
return;
}
}
// If the compiler crashed (Internal Compiler Error), treat this
// as a system error so it will be retried, since it can alse be
// the result of faulty hardware.
if ( stdOut.Find( "C1001" ) )
{
job->OnSystemError();
return;
}
// Error messages above also contains this text
// (We check for this message additionally to handle other error codes
// that may not have been observed yet)
// TODO:C Should we check for localized msg?
if ( stdOut.Find( "No space left on device" ) )
{
job->OnSystemError();
return;
}
}
#endif
// Clang
if ( objectNode->GetFlag( ObjectNode::FLAG_CLANG ) )
{
// When clang fails due to low disk space
// TODO:C Should we check for localized msg?
if ( stdErr.Find( "IO failure on output stream" ) )
{
job->OnSystemError();
return;
}
}
// GCC
if ( objectNode->GetFlag( ObjectNode::FLAG_GCC ) )
{
// When gcc fails due to low disk space
// TODO:C Should we check for localized msg?
if ( stdErr.Find( "No space left on device" ) )
{
job->OnSystemError();
return;
}
}
#if !defined( __WINDOWS__)
(void)stdOut; // No checks use stdOut outside of Windows right now
#endif
}
// ShouldUseDeoptimization
//------------------------------------------------------------------------------
bool ObjectNode::ShouldUseDeoptimization() const
{
if ( GetFlag( FLAG_UNITY ) )
{
return false; // disabled for Unity files (which are always writable)
}
if ( ( m_DeoptimizeWritableFilesWithToken == false ) &&
( m_DeoptimizeWritableFiles == false ) )
{
return false; // feature not enabled
}
// Neither flag should be set for the creation of Precompiled Headers
ASSERT( GetFlag( FLAG_CREATING_PCH ) == false );
if ( FileIO::GetReadOnly( GetSourceFile()->GetName() ) )
{
return false; // file is read only (not modified)
}
if ( m_DeoptimizeWritableFiles )
{
return true; // file modified - deoptimize with or without token
}
// does file contain token?
FileStream fs;
if ( fs.Open( GetSourceFile()->GetName().Get(), FileStream::READ_ONLY ) )
{
const size_t bytesToRead = Math::Min< size_t >( 1024, (size_t)fs.GetFileSize() );
char buffer[ 1025 ];
if ( fs.Read( buffer, bytesToRead ) == bytesToRead )
{
buffer[ bytesToRead ] = 0;
if ( strstr( buffer, "FASTBUILD_DEOPTIMIZE_OBJECT" ) )
{
return true;
}
return false; // token not present
}
}
// problem reading file - TODO:B emit an error?
return false;
}
// ShouldUseCache
//------------------------------------------------------------------------------
bool ObjectNode::ShouldUseCache() const
{
bool useCache = GetFlag( FLAG_CAN_BE_CACHED ) &&
m_AllowCaching &&
( FBuild::Get().GetOptions().m_UseCacheRead ||
FBuild::Get().GetOptions().m_UseCacheWrite );
if ( GetFlag( FLAG_ISOLATED_FROM_UNITY ) )
{
// disable caching for locally modified files (since they will rarely if ever get a hit)
useCache = false;
}
if ( GetFlag( FLAG_MSVC ) && GetFlag( FLAG_USING_PCH ) )
{
// If the PCH is not in the cache, then no point looking there
// for objects and also no point storing them
if ( GetPrecompiledHeader()->m_PCHCacheKey == 0 )
{
return false;
}
}
return useCache;
}
// CanUseResponseFile
//------------------------------------------------------------------------------
bool ObjectNode::CanUseResponseFile() const
{
#if defined( __WINDOWS__ )
// Generally only windows applications support response files (to overcome Windows command line limits)
return ( GetFlag( FLAG_MSVC ) || GetFlag( FLAG_GCC ) || GetFlag( FLAG_SNC ) || GetFlag( FLAG_CLANG ) || GetFlag( CODEWARRIOR_WII ) || GetFlag( GREENHILLS_WIIU ) );
#else
return false;
#endif
}
// GetVBCCPreprocessedOutput
//------------------------------------------------------------------------------
bool ObjectNode::GetVBCCPreprocessedOutput( ConstMemoryStream & outStream ) const
{
// Filename matches the source file, but with extension replaced
const AString & sourceFileName = GetSourceFile()->GetName();
const char * lastDot = sourceFileName.FindLast( '.' );
lastDot = lastDot ? lastDot : sourceFileName.GetEnd();
AStackString<> preprocessedFile( sourceFileName.Get(), lastDot );
preprocessedFile += ".i";
// Try to open the file
FileStream f;
if ( !f.Open( preprocessedFile.Get(), FileStream::READ_ONLY ) )
{
FLOG_ERROR( "Failed to open preprocessed file '%s'", preprocessedFile.Get() );
return false;
}
// Allocate memory
const size_t memSize = (size_t)f.GetFileSize();
char * mem = (char *)ALLOC( memSize + 1 ); // +1 so we can null terminate
outStream.Replace( mem, memSize, true ); // true = outStream now owns memory
// Read contents
if ( (size_t)f.ReadBuffer( mem, memSize ) != memSize )
{
FLOG_ERROR( "Failed to read preprocessed file '%s'", preprocessedFile.Get() );
return false;
}
mem[ memSize ] = 0; // null terminate text buffer for parsing convenience
return true;
}
// DoClangUnityFixup
//------------------------------------------------------------------------------
void ObjectNode::DoClangUnityFixup( Job * job ) const
{
// Fixup preprocessed output so static analysis works well with Unity
//
// Static analysis only analyzes the "topmost" file, which in Unity is the
// Unity.cpp which contains no code. The compiler know which file is the topmost
// file by checking the directives left by the preprocessor, as described here:
// - https://gcc.gnu.org/onlinedocs/cpp/Preprocessor-Output.html
//
// Be removing the "push" flags the preprocesser adds (1) when leaving the main cpp
// file and entering an inluded file only for the Unity, the compiler thinks
// the included files are the top-level files and applies analysis the same way
// as when they are built outside of Unity.
//
// We remove the "pop" flags (2) when returning to the unity as these must match the
// "pop"s
//
// We do this fixup even if not using -Xanalyze, so that:
// a) the behaviour is consistent, avoiding any problems that might show up only
// with static analysis
// b) this behaviour may be useful for other types of warnings for similar reasons
// (i.e. if Clang suppresses then because it thinks a file is not the "main" file)
//
// Sanity checks
ASSERT( IsClang() ); // Only necessary for Clang
ASSERT( GetFlag( FLAG_UNITY ) ); // Only makes sense to for Unity
ASSERT( job->IsDataCompressed() == false ); // Can't fixup compressed data
ASSERT( job->IsLocal() ); // Assuming we're doing this on the local machine (using FBuild singleton lower)
// We'll walk the output and fix it up in-place
AStackString<> srcFileName( GetSourceFile()->GetName() );
#if defined( __WINDOWS__ )
// Clang escapes backslashes, so we must do the same
srcFileName.Replace( "\\", "\\\\" );
#endif
// Build the string used to find "pop" directives when returning to this file
AStackString<> popDirectiveString;
popDirectiveString = " \"";
popDirectiveString += srcFileName;
popDirectiveString += "\" 2"; // 2 is "pop" flag
// Find the first instance of the primary filename (this ensured we ignore any
// injected "-include" stuff before that)
char * pos = strstr( (char *)job->GetData(), srcFileName.Get() );
if ( pos == nullptr )
{
// If not found, try relative path
AStackString<> basePath( FBuild::Get().GetOptions().GetWorkingDir() ); // NOTE: FBuild only valid locally
PathUtils::EnsureTrailingSlash( basePath );
AStackString<> relativeFileName;
PathUtils::GetRelativePath( basePath, GetSourceFile()->GetName(), relativeFileName );
#if defined( __WINDOWS__ )
// Clang escapes backslashes, so we must do the same
relativeFileName.Replace( "\\", "\\\\" );
#endif
pos = strstr( (char *)job->GetData(), relativeFileName.Get() );
// Update pop directive string
popDirectiveString = " \"";
popDirectiveString += relativeFileName;
popDirectiveString += "\" 2"; // 2 is "pop" flag
}
ASSERT( pos ); // TODO:A This fails because the path is now relative
// Find top-level push/pop pairs. We don't want mess with nested directives
// as these can be meaningful in other ways.
while ( pos )
{
// Searching for a "push" directive (i.e. leaving the unity file and pushing
// a file included by the Unity cpp)
pos = strstr( pos, "\n# 1 \"" );
if ( pos == nullptr )
{
return; // no more
}
pos += 6; // skip to string inside quotes
// Ignore special directives like <built-in>
if ( *pos == '<' )
{
continue; // Keep searching
}
// Find closing quote
pos = strchr( pos, '"' );
if ( pos == nullptr )
{
ASSERT( false ); // Unexpected/malformed
return;
}
// Found it?
if ( AString::StrNCmp( pos, "\" 1", 3 ) != 0 ) // Note: '1' flag for "push"
{
continue; // Keep searching
}
// Patch out "push" flag in-place
pos[ 2 ] = ' ';
pos += 3; // Skip closing quote, space and flag
// Find "pop" directive that returns us to the Unity file
char * popDirective = strstr( pos, popDirectiveString.Get() );
if ( popDirective == nullptr )
{
ASSERT( false ); // Unexpected/malformed
return;
}
// Pathc out "pop" flag to match the "push"
pos = ( popDirective + popDirectiveString.GetLength() - 1 );
ASSERT( *pos == '2' );
*pos = ' ';
}
}
//------------------------------------------------------------------------------
| 36.275319
| 272
| 0.548714
|
qq573011406
|
104a5da4cccf8a4385b5420640bc11a60d732437
| 582
|
cpp
|
C++
|
test/src/datastructure/compressed_wavelet_matrix/static_rmq.test.cpp
|
suisen-cp/cp-library-cpp
|
8fbbdcdbceb60f5adc56ff4740549ce3c1a1ea43
|
[
"CC0-1.0"
] | 2
|
2021-10-04T15:46:56.000Z
|
2022-01-14T19:28:43.000Z
|
test/src/datastructure/compressed_wavelet_matrix/static_rmq.test.cpp
|
suisen-cp/cp-library-cpp
|
8fbbdcdbceb60f5adc56ff4740549ce3c1a1ea43
|
[
"CC0-1.0"
] | null | null | null |
test/src/datastructure/compressed_wavelet_matrix/static_rmq.test.cpp
|
suisen-cp/cp-library-cpp
|
8fbbdcdbceb60f5adc56ff4740549ce3c1a1ea43
|
[
"CC0-1.0"
] | null | null | null |
#define PROBLEM "https://judge.yosupo.jp/problem/staticrmq"
#include <iostream>
#include "library/datastructure/compressed_wavelet_matrix.hpp"
using suisen::CompressedWaveletMatrix;
constexpr int MAX_LOG = 19;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int n, q;
std::cin >> n >> q;
std::vector<int> a(n);
for (auto &e : a) std::cin >> e;
CompressedWaveletMatrix<int, MAX_LOG> wm(a);
while (q --> 0) {
int l, r;
std::cin >> l >> r;
std::cout << wm.range_min(l, r) << '\n';
}
return 0;
}
| 23.28
| 62
| 0.597938
|
suisen-cp
|
104e354c7eb4c4a79be63cd2d75190bd4f27e224
| 2,570
|
hpp
|
C++
|
include/armadillo_bits/op_chol_meat.hpp
|
getfiit/armadillo-code
|
3a896deca12a0f596b52d84185ebfad65df650b7
|
[
"Apache-2.0"
] | 3
|
2020-03-23T04:31:14.000Z
|
2021-01-17T09:03:09.000Z
|
include/armadillo_bits/op_chol_meat.hpp
|
getfiit/armadillo-code
|
3a896deca12a0f596b52d84185ebfad65df650b7
|
[
"Apache-2.0"
] | null | null | null |
include/armadillo_bits/op_chol_meat.hpp
|
getfiit/armadillo-code
|
3a896deca12a0f596b52d84185ebfad65df650b7
|
[
"Apache-2.0"
] | 3
|
2018-03-28T20:53:27.000Z
|
2020-04-27T07:03:02.000Z
|
// SPDX-License-Identifier: Apache-2.0
//
// Copyright 2008-2016 Conrad Sanderson (http://conradsanderson.id.au)
// Copyright 2008-2016 National ICT Australia (NICTA)
//
// 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.
// ------------------------------------------------------------------------
//! \addtogroup op_chol
//! @{
template<typename T1>
inline
void
op_chol::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_chol>& X)
{
arma_extra_debug_sigprint();
const bool status = op_chol::apply_direct(out, X.m, X.aux_uword_a);
if(status == false)
{
out.soft_reset();
arma_stop_runtime_error("chol(): decomposition failed");
}
}
template<typename T1>
inline
bool
op_chol::apply_direct(Mat<typename T1::elem_type>& out, const Base<typename T1::elem_type,T1>& A_expr, const uword layout)
{
arma_extra_debug_sigprint();
typedef typename T1::elem_type eT;
out = A_expr.get_ref();
arma_debug_check( (out.is_square() == false), "chol(): given matrix must be square sized" );
if(out.is_empty()) { return true; }
// if(auxlib::rudimentary_sym_check(out) == false)
// {
// if(is_cx<eT>::no ) { arma_debug_warn_level(1, "chol(): given matrix is not symmetric"); }
// if(is_cx<eT>::yes) { arma_debug_warn_level(1, "chol(): given matrix is not hermitian"); }
// return false;
// }
if((arma_config::debug) && (auxlib::rudimentary_sym_check(out) == false))
{
if(is_cx<eT>::no ) { arma_debug_warn_level(1, "chol(): given matrix is not symmetric"); }
if(is_cx<eT>::yes) { arma_debug_warn_level(1, "chol(): given matrix is not hermitian"); }
}
uword KD = 0;
#if defined(ARMA_OPTIMISE_BAND)
const bool is_band = (auxlib::crippled_lapack(out)) ? false : ((layout == 0) ? band_helper::is_band_upper(KD, out, uword(32)) : band_helper::is_band_lower(KD, out, uword(32)));
#else
const bool is_band = false;
#endif
const bool status = (is_band) ? auxlib::chol_band(out, KD, layout) : auxlib::chol(out, layout);
return status;
}
//! @}
| 29.883721
| 180
| 0.657198
|
getfiit
|
10509b0a337b44f7897575e4c4f3ca5dd7eadad3
| 409
|
cpp
|
C++
|
SystemDLL/Source/Object/CameraObject.cpp
|
jsham0414/MyD3D12Engine
|
0dfac18f4b1ede76cb481fb2d7253bc2ef7e9b0e
|
[
"MIT"
] | null | null | null |
SystemDLL/Source/Object/CameraObject.cpp
|
jsham0414/MyD3D12Engine
|
0dfac18f4b1ede76cb481fb2d7253bc2ef7e9b0e
|
[
"MIT"
] | null | null | null |
SystemDLL/Source/Object/CameraObject.cpp
|
jsham0414/MyD3D12Engine
|
0dfac18f4b1ede76cb481fb2d7253bc2ef7e9b0e
|
[
"MIT"
] | null | null | null |
#include "SystemDLL.h"
#include "CameraObject.h"
CameraObject::CameraObject() {
Initialize();
}
CameraObject::~CameraObject() {
Release();
}
VOID CameraObject::Initialize() {
m_Camera = new Camera();
}
VOID CameraObject::Update() {
m_Camera->Update();
}
VOID CameraObject::Render() {
}
VOID CameraObject::Release() {
if (m_Camera != nullptr) {
m_Camera->Release();
SAFE_DELETE(m_Camera);
}
}
| 13.633333
| 33
| 0.677262
|
jsham0414
|
10518a900d3082da1fa12b6d947e352053d8755f
| 13,734
|
cpp
|
C++
|
src/libs/AESCommon.cpp
|
Papabyte/byteduino
|
b0446e040b48acfdcc838074d63d3f2848b1f722
|
[
"MIT"
] | 12
|
2018-09-20T14:44:24.000Z
|
2022-01-31T03:32:01.000Z
|
src/libs/AESCommon.cpp
|
Electronics-world/Byteduino
|
51b6a3eab283948a172db238deeaddac63b69879
|
[
"MIT"
] | null | null | null |
src/libs/AESCommon.cpp
|
Electronics-world/Byteduino
|
51b6a3eab283948a172db238deeaddac63b69879
|
[
"MIT"
] | 4
|
2018-11-02T14:06:06.000Z
|
2019-08-23T17:01:03.000Z
|
/*
* Copyright (C) 2015 Southern Storm Software, Pty Ltd.
*
* 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 "AES.h"
#include "Crypto.h"
#include "utility/ProgMemUtil.h"
#if defined(CRYPTO_AES_DEFAULT) || defined(CRYPTO_DOC)
/**
* \class AESCommon AES.h <AES.h>
* \brief Abstract base class for AES block ciphers.
*
* This class is abstract. The caller should instantiate AES128BDBD,
* AES192, or AES256 to create an AES block cipher with a specific
* key size.
*
* \note This AES implementation does not have constant cache behaviour due
* to the use of table lookups. It may not be safe to use this implementation
* in an environment where the attacker can observe the timing of encryption
* and decryption operations. Unless AES compatibility is required,
* it is recommended that the ChaCha stream cipher be used instead.
*
* Reference: http://en.wikipedia.org/wiki/Advanced_Encryption_Standard
*
* \sa ChaCha, AES128BD, AES192, AES256
*/
/** @cond sbox */
// AES S-box (http://en.wikipedia.org/wiki/Rijndael_S-box)
static uint8_t const sbox[256] PROGMEM = {
0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, // 0x00
0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, // 0x10
0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, // 0x20
0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, // 0x30
0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, // 0x40
0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, // 0x50
0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, // 0x60
0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, // 0x70
0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, // 0x80
0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, // 0x90
0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, // 0xA0
0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, // 0xB0
0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, // 0xC0
0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, // 0xD0
0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, // 0xE0
0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, // 0xF0
0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16
};
// AES inverse S-box (http://en.wikipedia.org/wiki/Rijndael_S-box)
static uint8_t const sbox_inverse[256] PROGMEM = {
0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, // 0x00
0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, // 0x10
0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, // 0x20
0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, // 0x30
0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, // 0x40
0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, // 0x50
0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, // 0x60
0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, // 0x70
0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, // 0x80
0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, // 0x90
0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, // 0xA0
0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, // 0xB0
0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, // 0xC0
0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, // 0xD0
0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, // 0xE0
0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, // 0xF0
0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D
};
/** @endcond */
/**
* \brief Constructs an AES block cipher object.
*/
AESCommon::AESCommon()
: rounds(0), schedule(0)
{
}
/**
* \brief Destroys this AES block cipher object after clearing
* sensitive information.
*/
AESCommon::~AESCommon()
{
}
/**
* \brief Size of an AES block in bytes.
* \return Always returns 16.
*/
size_t AESCommon::blockSize() const
{
return 16;
}
// Constants to correct Galois multiplication for the high bits
// that are shifted out when multiplying by powers of two.
static uint8_t const K[8] = {
0x00,
0x1B,
(0x1B << 1),
(0x1B << 1) ^ 0x1B,
(0x1B << 2),
(0x1B << 2) ^ 0x1B,
(0x1B << 2) ^ (0x1B << 1),
(0x1B << 2) ^ (0x1B << 1) ^ 0x1B
};
// Multiply x by 2 in the Galois field, to achieve the effect of the following:
//
// if (x & 0x80)
// return (x << 1) ^ 0x1B;
// else
// return (x << 1);
//
// However, we don't want to use runtime conditionals if we can help it
// to avoid leaking timing information from the implementation.
// In this case, multiplication is slightly faster than table lookup on AVR.
#define gmul2(x) (t = ((uint16_t)(x)) << 1, \
((uint8_t)t) ^ (uint8_t)(0x1B * ((uint8_t)(t >> 8))))
// Multiply x by 4 in the Galois field.
#define gmul4(x) (t = ((uint16_t)(x)) << 2, ((uint8_t)t) ^ K[t >> 8])
// Multiply x by 8 in the Galois field.
#define gmul8(x) (t = ((uint16_t)(x)) << 3, ((uint8_t)t) ^ K[t >> 8])
#define OUT(col, row) output[(col) * 4 + (row)]
#define IN(col, row) input[(col) * 4 + (row)]
/** @cond aes_funcs */
void AESCommon::subBytesAndShiftRows(uint8_t *output, const uint8_t *input)
{
OUT(0, 0) = pgm_read_byte(sbox + IN(0, 0));
OUT(0, 1) = pgm_read_byte(sbox + IN(1, 1));
OUT(0, 2) = pgm_read_byte(sbox + IN(2, 2));
OUT(0, 3) = pgm_read_byte(sbox + IN(3, 3));
OUT(1, 0) = pgm_read_byte(sbox + IN(1, 0));
OUT(1, 1) = pgm_read_byte(sbox + IN(2, 1));
OUT(1, 2) = pgm_read_byte(sbox + IN(3, 2));
OUT(1, 3) = pgm_read_byte(sbox + IN(0, 3));
OUT(2, 0) = pgm_read_byte(sbox + IN(2, 0));
OUT(2, 1) = pgm_read_byte(sbox + IN(3, 1));
OUT(2, 2) = pgm_read_byte(sbox + IN(0, 2));
OUT(2, 3) = pgm_read_byte(sbox + IN(1, 3));
OUT(3, 0) = pgm_read_byte(sbox + IN(3, 0));
OUT(3, 1) = pgm_read_byte(sbox + IN(0, 1));
OUT(3, 2) = pgm_read_byte(sbox + IN(1, 2));
OUT(3, 3) = pgm_read_byte(sbox + IN(2, 3));
}
void AESCommon::inverseShiftRowsAndSubBytes(uint8_t *output, const uint8_t *input)
{
OUT(0, 0) = pgm_read_byte(sbox_inverse + IN(0, 0));
OUT(0, 1) = pgm_read_byte(sbox_inverse + IN(3, 1));
OUT(0, 2) = pgm_read_byte(sbox_inverse + IN(2, 2));
OUT(0, 3) = pgm_read_byte(sbox_inverse + IN(1, 3));
OUT(1, 0) = pgm_read_byte(sbox_inverse + IN(1, 0));
OUT(1, 1) = pgm_read_byte(sbox_inverse + IN(0, 1));
OUT(1, 2) = pgm_read_byte(sbox_inverse + IN(3, 2));
OUT(1, 3) = pgm_read_byte(sbox_inverse + IN(2, 3));
OUT(2, 0) = pgm_read_byte(sbox_inverse + IN(2, 0));
OUT(2, 1) = pgm_read_byte(sbox_inverse + IN(1, 1));
OUT(2, 2) = pgm_read_byte(sbox_inverse + IN(0, 2));
OUT(2, 3) = pgm_read_byte(sbox_inverse + IN(3, 3));
OUT(3, 0) = pgm_read_byte(sbox_inverse + IN(3, 0));
OUT(3, 1) = pgm_read_byte(sbox_inverse + IN(2, 1));
OUT(3, 2) = pgm_read_byte(sbox_inverse + IN(1, 2));
OUT(3, 3) = pgm_read_byte(sbox_inverse + IN(0, 3));
}
void AESCommon::mixColumn(uint8_t *output, uint8_t *input)
{
uint16_t t; // Needed by the gmul2 macro.
uint8_t a = input[0];
uint8_t b = input[1];
uint8_t c = input[2];
uint8_t d = input[3];
uint8_t a2 = gmul2(a);
uint8_t b2 = gmul2(b);
uint8_t c2 = gmul2(c);
uint8_t d2 = gmul2(d);
output[0] = a2 ^ b2 ^ b ^ c ^ d;
output[1] = a ^ b2 ^ c2 ^ c ^ d;
output[2] = a ^ b ^ c2 ^ d2 ^ d;
output[3] = a2 ^ a ^ b ^ c ^ d2;
}
void AESCommon::inverseMixColumn(uint8_t *output, const uint8_t *input)
{
uint16_t t; // Needed by the gmul2, gmul4, and gmul8 macros.
uint8_t a = input[0];
uint8_t b = input[1];
uint8_t c = input[2];
uint8_t d = input[3];
uint8_t a2 = gmul2(a);
uint8_t b2 = gmul2(b);
uint8_t c2 = gmul2(c);
uint8_t d2 = gmul2(d);
uint8_t a4 = gmul4(a);
uint8_t b4 = gmul4(b);
uint8_t c4 = gmul4(c);
uint8_t d4 = gmul4(d);
uint8_t a8 = gmul8(a);
uint8_t b8 = gmul8(b);
uint8_t c8 = gmul8(c);
uint8_t d8 = gmul8(d);
output[0] = a8 ^ a4 ^ a2 ^ b8 ^ b2 ^ b ^ c8 ^ c4 ^ c ^ d8 ^ d;
output[1] = a8 ^ a ^ b8 ^ b4 ^ b2 ^ c8 ^ c2 ^ c ^ d8 ^ d4 ^ d;
output[2] = a8 ^ a4 ^ a ^ b8 ^ b ^ c8 ^ c4 ^ c2 ^ d8 ^ d2 ^ d;
output[3] = a8 ^ a2 ^ a ^ b8 ^ b4 ^ b ^ c8 ^ c ^ d8 ^ d4 ^ d2;
}
/** @endcond */
void AESCommon::encryptBlock(uint8_t *output, const uint8_t *input)
{
const uint8_t *roundKey = schedule;
uint8_t posn;
uint8_t round;
uint8_t state1[16];
uint8_t state2[16];
// Copy the input into the state and XOR with the first round key.
for (posn = 0; posn < 16; ++posn)
state1[posn] = input[posn] ^ roundKey[posn];
roundKey += 16;
// Perform all rounds except the last.
for (round = rounds; round > 1; --round) {
subBytesAndShiftRows(state2, state1);
mixColumn(state1, state2);
mixColumn(state1 + 4, state2 + 4);
mixColumn(state1 + 8, state2 + 8);
mixColumn(state1 + 12, state2 + 12);
for (posn = 0; posn < 16; ++posn)
state1[posn] ^= roundKey[posn];
roundKey += 16;
}
// Perform the final round.
subBytesAndShiftRows(state2, state1);
for (posn = 0; posn < 16; ++posn)
output[posn] = state2[posn] ^ roundKey[posn];
}
void AESCommon::decryptBlock(uint8_t *output, const uint8_t *input)
{
const uint8_t *roundKey = schedule + rounds * 16;
uint8_t round;
uint8_t posn;
uint8_t state1[16];
uint8_t state2[16];
// Copy the input into the state and reverse the final round.
for (posn = 0; posn < 16; ++posn)
state1[posn] = input[posn] ^ roundKey[posn];
inverseShiftRowsAndSubBytes(state2, state1);
// Perform all other rounds in reverse.
for (round = rounds; round > 1; --round) {
roundKey -= 16;
for (posn = 0; posn < 16; ++posn)
state2[posn] ^= roundKey[posn];
inverseMixColumn(state1, state2);
inverseMixColumn(state1 + 4, state2 + 4);
inverseMixColumn(state1 + 8, state2 + 8);
inverseMixColumn(state1 + 12, state2 + 12);
inverseShiftRowsAndSubBytes(state2, state1);
}
// Reverse the initial round and create the output words.
roundKey -= 16;
for (posn = 0; posn < 16; ++posn)
output[posn] = state2[posn] ^ roundKey[posn];
}
void AESCommon::clear()
{
clean(schedule, (rounds + 1) * 16);
}
/** @cond aes_keycore */
void AESCommon::keyScheduleCore(uint8_t *output, const uint8_t *input, uint8_t iteration)
{
// Rcon(i), 2^i in the Rijndael finite field, for i = 0..10.
// http://en.wikipedia.org/wiki/Rijndael_key_schedule
static uint8_t const rcon[11] PROGMEM = {
0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, // 0x00
0x80, 0x1B, 0x36
};
output[0] = pgm_read_byte(sbox + input[1]) ^ pgm_read_byte(rcon + iteration);
output[1] = pgm_read_byte(sbox + input[2]);
output[2] = pgm_read_byte(sbox + input[3]);
output[3] = pgm_read_byte(sbox + input[0]);
}
void AESCommon::applySbox(uint8_t *output, const uint8_t *input)
{
output[0] = pgm_read_byte(sbox + input[0]);
output[1] = pgm_read_byte(sbox + input[1]);
output[2] = pgm_read_byte(sbox + input[2]);
output[3] = pgm_read_byte(sbox + input[3]);
}
/** @endcond */
#endif // CRYPTO_AES_DEFAULT
| 37.730769
| 89
| 0.614606
|
Papabyte
|
1051d3eb8c0967f70077ca8cc5200b5e0733b0a6
| 229,676
|
cpp
|
C++
|
common/beerocks/tlvf/AutoGenerated/src/beerocks/tlvf/beerocks_message_bml.cpp
|
ydx-coder/prplMesh
|
6401b15c31c563f9e00ce6ff1b5513df3d39f157
|
[
"BSD-2-Clause-Patent"
] | null | null | null |
common/beerocks/tlvf/AutoGenerated/src/beerocks/tlvf/beerocks_message_bml.cpp
|
ydx-coder/prplMesh
|
6401b15c31c563f9e00ce6ff1b5513df3d39f157
|
[
"BSD-2-Clause-Patent"
] | null | null | null |
common/beerocks/tlvf/AutoGenerated/src/beerocks/tlvf/beerocks_message_bml.cpp
|
ydx-coder/prplMesh
|
6401b15c31c563f9e00ce6ff1b5513df3d39f157
|
[
"BSD-2-Clause-Patent"
] | null | null | null |
///////////////////////////////////////
// AUTO GENERATED FILE - DO NOT EDIT //
///////////////////////////////////////
/* SPDX-License-Identifier: BSD-2-Clause-Patent
*
* Copyright (c) 2016-2019 Intel Corporation
*
* This code is subject to the terms of the BSD+Patent license.
* See LICENSE file for more details.
*/
#include <beerocks/tlvf/beerocks_message_bml.h>
#include <tlvf/tlvflogging.h>
using namespace beerocks_message;
cACTION_BML_PING_REQUEST::cACTION_BML_PING_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_PING_REQUEST::cACTION_BML_PING_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_PING_REQUEST::~cACTION_BML_PING_REQUEST() {
}
void cACTION_BML_PING_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_PING_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_PING_REQUEST::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_PING_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_PING_RESPONSE::cACTION_BML_PING_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_PING_RESPONSE::cACTION_BML_PING_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_PING_RESPONSE::~cACTION_BML_PING_RESPONSE() {
}
void cACTION_BML_PING_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_PING_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_PING_RESPONSE::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_PING_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_NW_MAP_REQUEST::cACTION_BML_NW_MAP_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_NW_MAP_REQUEST::cACTION_BML_NW_MAP_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_NW_MAP_REQUEST::~cACTION_BML_NW_MAP_REQUEST() {
}
void cACTION_BML_NW_MAP_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_NW_MAP_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_NW_MAP_REQUEST::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_NW_MAP_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_NW_MAP_RESPONSE::cACTION_BML_NW_MAP_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_NW_MAP_RESPONSE::cACTION_BML_NW_MAP_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_NW_MAP_RESPONSE::~cACTION_BML_NW_MAP_RESPONSE() {
}
uint32_t& cACTION_BML_NW_MAP_RESPONSE::node_num() {
return (uint32_t&)(*m_node_num);
}
uint32_t& cACTION_BML_NW_MAP_RESPONSE::buffer_size() {
return (uint32_t&)(*m_buffer_size);
}
std::string cACTION_BML_NW_MAP_RESPONSE::buffer_str() {
char *buffer_ = buffer();
if (!buffer_) { return std::string(); }
return std::string(buffer_, m_buffer_idx__);
}
char* cACTION_BML_NW_MAP_RESPONSE::buffer(size_t length) {
if( (m_buffer_idx__ == 0) || (m_buffer_idx__ < length) ) {
TLVF_LOG(ERROR) << "buffer length is smaller than requested length";
return nullptr;
}
return ((char*)m_buffer);
}
bool cACTION_BML_NW_MAP_RESPONSE::set_buffer(const std::string& str) { return set_buffer(str.c_str(), str.size()); }
bool cACTION_BML_NW_MAP_RESPONSE::set_buffer(const char str[], size_t size) {
if (str == nullptr) {
TLVF_LOG(WARNING) << "set_buffer received a null pointer.";
return false;
}
if (!alloc_buffer(size)) { return false; }
std::copy(str, str + size, m_buffer);
return true;
}
bool cACTION_BML_NW_MAP_RESPONSE::alloc_buffer(size_t count) {
if (m_lock_order_counter__ > 0) {;
TLVF_LOG(ERROR) << "Out of order allocation for variable length list buffer, abort!";
return false;
}
size_t len = sizeof(char) * count;
if(getBuffRemainingBytes() < len ) {
TLVF_LOG(ERROR) << "Not enough available space on buffer - can't allocate";
return false;
}
m_lock_order_counter__ = 0;
uint8_t *src = (uint8_t *)&m_buffer[*m_buffer_size];
uint8_t *dst = src + len;
if (!m_parse__) {
size_t move_length = getBuffRemainingBytes(src) - len;
std::copy_n(src, move_length, dst);
}
m_buffer_idx__ += count;
*m_buffer_size += count;
if (!buffPtrIncrementSafe(len)) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << len << ") Failed!";
return false;
}
return true;
}
void cACTION_BML_NW_MAP_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
tlvf_swap(32, reinterpret_cast<uint8_t*>(m_node_num));
tlvf_swap(32, reinterpret_cast<uint8_t*>(m_buffer_size));
}
bool cACTION_BML_NW_MAP_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_NW_MAP_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint32_t); // node_num
class_size += sizeof(uint32_t); // buffer_size
return class_size;
}
bool cACTION_BML_NW_MAP_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_node_num = (uint32_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint32_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint32_t) << ") Failed!";
return false;
}
m_buffer_size = (uint32_t*)m_buff_ptr__;
if (!m_parse__) *m_buffer_size = 0;
if (!buffPtrIncrementSafe(sizeof(uint32_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint32_t) << ") Failed!";
return false;
}
m_buffer = (char*)m_buff_ptr__;
uint32_t buffer_size = *m_buffer_size;
if (m_parse__) { tlvf_swap(32, reinterpret_cast<uint8_t*>(&buffer_size)); }
m_buffer_idx__ = buffer_size;
if (!buffPtrIncrementSafe(sizeof(char) * (buffer_size))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(char) * (buffer_size) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_NW_MAP_UPDATE::cACTION_BML_NW_MAP_UPDATE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_NW_MAP_UPDATE::cACTION_BML_NW_MAP_UPDATE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_NW_MAP_UPDATE::~cACTION_BML_NW_MAP_UPDATE() {
}
uint32_t& cACTION_BML_NW_MAP_UPDATE::node_num() {
return (uint32_t&)(*m_node_num);
}
uint32_t& cACTION_BML_NW_MAP_UPDATE::buffer_size() {
return (uint32_t&)(*m_buffer_size);
}
std::string cACTION_BML_NW_MAP_UPDATE::buffer_str() {
char *buffer_ = buffer();
if (!buffer_) { return std::string(); }
return std::string(buffer_, m_buffer_idx__);
}
char* cACTION_BML_NW_MAP_UPDATE::buffer(size_t length) {
if( (m_buffer_idx__ == 0) || (m_buffer_idx__ < length) ) {
TLVF_LOG(ERROR) << "buffer length is smaller than requested length";
return nullptr;
}
return ((char*)m_buffer);
}
bool cACTION_BML_NW_MAP_UPDATE::set_buffer(const std::string& str) { return set_buffer(str.c_str(), str.size()); }
bool cACTION_BML_NW_MAP_UPDATE::set_buffer(const char str[], size_t size) {
if (str == nullptr) {
TLVF_LOG(WARNING) << "set_buffer received a null pointer.";
return false;
}
if (!alloc_buffer(size)) { return false; }
std::copy(str, str + size, m_buffer);
return true;
}
bool cACTION_BML_NW_MAP_UPDATE::alloc_buffer(size_t count) {
if (m_lock_order_counter__ > 0) {;
TLVF_LOG(ERROR) << "Out of order allocation for variable length list buffer, abort!";
return false;
}
size_t len = sizeof(char) * count;
if(getBuffRemainingBytes() < len ) {
TLVF_LOG(ERROR) << "Not enough available space on buffer - can't allocate";
return false;
}
m_lock_order_counter__ = 0;
uint8_t *src = (uint8_t *)&m_buffer[*m_buffer_size];
uint8_t *dst = src + len;
if (!m_parse__) {
size_t move_length = getBuffRemainingBytes(src) - len;
std::copy_n(src, move_length, dst);
}
m_buffer_idx__ += count;
*m_buffer_size += count;
if (!buffPtrIncrementSafe(len)) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << len << ") Failed!";
return false;
}
return true;
}
void cACTION_BML_NW_MAP_UPDATE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
tlvf_swap(32, reinterpret_cast<uint8_t*>(m_node_num));
tlvf_swap(32, reinterpret_cast<uint8_t*>(m_buffer_size));
}
bool cACTION_BML_NW_MAP_UPDATE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_NW_MAP_UPDATE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint32_t); // node_num
class_size += sizeof(uint32_t); // buffer_size
return class_size;
}
bool cACTION_BML_NW_MAP_UPDATE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_node_num = (uint32_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint32_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint32_t) << ") Failed!";
return false;
}
m_buffer_size = (uint32_t*)m_buff_ptr__;
if (!m_parse__) *m_buffer_size = 0;
if (!buffPtrIncrementSafe(sizeof(uint32_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint32_t) << ") Failed!";
return false;
}
m_buffer = (char*)m_buff_ptr__;
uint32_t buffer_size = *m_buffer_size;
if (m_parse__) { tlvf_swap(32, reinterpret_cast<uint8_t*>(&buffer_size)); }
m_buffer_idx__ = buffer_size;
if (!buffPtrIncrementSafe(sizeof(char) * (buffer_size))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(char) * (buffer_size) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_STATS_UPDATE::cACTION_BML_STATS_UPDATE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_STATS_UPDATE::cACTION_BML_STATS_UPDATE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_STATS_UPDATE::~cACTION_BML_STATS_UPDATE() {
}
uint32_t& cACTION_BML_STATS_UPDATE::num_of_stats_bulks() {
return (uint32_t&)(*m_num_of_stats_bulks);
}
uint32_t& cACTION_BML_STATS_UPDATE::buffer_size() {
return (uint32_t&)(*m_buffer_size);
}
std::string cACTION_BML_STATS_UPDATE::buffer_str() {
char *buffer_ = buffer();
if (!buffer_) { return std::string(); }
return std::string(buffer_, m_buffer_idx__);
}
char* cACTION_BML_STATS_UPDATE::buffer(size_t length) {
if( (m_buffer_idx__ == 0) || (m_buffer_idx__ < length) ) {
TLVF_LOG(ERROR) << "buffer length is smaller than requested length";
return nullptr;
}
return ((char*)m_buffer);
}
bool cACTION_BML_STATS_UPDATE::set_buffer(const std::string& str) { return set_buffer(str.c_str(), str.size()); }
bool cACTION_BML_STATS_UPDATE::set_buffer(const char str[], size_t size) {
if (str == nullptr) {
TLVF_LOG(WARNING) << "set_buffer received a null pointer.";
return false;
}
if (!alloc_buffer(size)) { return false; }
std::copy(str, str + size, m_buffer);
return true;
}
bool cACTION_BML_STATS_UPDATE::alloc_buffer(size_t count) {
if (m_lock_order_counter__ > 0) {;
TLVF_LOG(ERROR) << "Out of order allocation for variable length list buffer, abort!";
return false;
}
size_t len = sizeof(char) * count;
if(getBuffRemainingBytes() < len ) {
TLVF_LOG(ERROR) << "Not enough available space on buffer - can't allocate";
return false;
}
m_lock_order_counter__ = 0;
uint8_t *src = (uint8_t *)&m_buffer[*m_buffer_size];
uint8_t *dst = src + len;
if (!m_parse__) {
size_t move_length = getBuffRemainingBytes(src) - len;
std::copy_n(src, move_length, dst);
}
m_buffer_idx__ += count;
*m_buffer_size += count;
if (!buffPtrIncrementSafe(len)) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << len << ") Failed!";
return false;
}
return true;
}
void cACTION_BML_STATS_UPDATE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
tlvf_swap(32, reinterpret_cast<uint8_t*>(m_num_of_stats_bulks));
tlvf_swap(32, reinterpret_cast<uint8_t*>(m_buffer_size));
}
bool cACTION_BML_STATS_UPDATE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_STATS_UPDATE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint32_t); // num_of_stats_bulks
class_size += sizeof(uint32_t); // buffer_size
return class_size;
}
bool cACTION_BML_STATS_UPDATE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_num_of_stats_bulks = (uint32_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint32_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint32_t) << ") Failed!";
return false;
}
m_buffer_size = (uint32_t*)m_buff_ptr__;
if (!m_parse__) *m_buffer_size = 0;
if (!buffPtrIncrementSafe(sizeof(uint32_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint32_t) << ") Failed!";
return false;
}
m_buffer = (char*)m_buff_ptr__;
uint32_t buffer_size = *m_buffer_size;
if (m_parse__) { tlvf_swap(32, reinterpret_cast<uint8_t*>(&buffer_size)); }
m_buffer_idx__ = buffer_size;
if (!buffPtrIncrementSafe(sizeof(char) * (buffer_size))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(char) * (buffer_size) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_EVENTS_UPDATE::cACTION_BML_EVENTS_UPDATE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_EVENTS_UPDATE::cACTION_BML_EVENTS_UPDATE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_EVENTS_UPDATE::~cACTION_BML_EVENTS_UPDATE() {
}
uint32_t& cACTION_BML_EVENTS_UPDATE::buffer_size() {
return (uint32_t&)(*m_buffer_size);
}
std::string cACTION_BML_EVENTS_UPDATE::buffer_str() {
char *buffer_ = buffer();
if (!buffer_) { return std::string(); }
return std::string(buffer_, m_buffer_idx__);
}
char* cACTION_BML_EVENTS_UPDATE::buffer(size_t length) {
if( (m_buffer_idx__ == 0) || (m_buffer_idx__ < length) ) {
TLVF_LOG(ERROR) << "buffer length is smaller than requested length";
return nullptr;
}
return ((char*)m_buffer);
}
bool cACTION_BML_EVENTS_UPDATE::set_buffer(const std::string& str) { return set_buffer(str.c_str(), str.size()); }
bool cACTION_BML_EVENTS_UPDATE::set_buffer(const char str[], size_t size) {
if (str == nullptr) {
TLVF_LOG(WARNING) << "set_buffer received a null pointer.";
return false;
}
if (!alloc_buffer(size)) { return false; }
std::copy(str, str + size, m_buffer);
return true;
}
bool cACTION_BML_EVENTS_UPDATE::alloc_buffer(size_t count) {
if (m_lock_order_counter__ > 0) {;
TLVF_LOG(ERROR) << "Out of order allocation for variable length list buffer, abort!";
return false;
}
size_t len = sizeof(char) * count;
if(getBuffRemainingBytes() < len ) {
TLVF_LOG(ERROR) << "Not enough available space on buffer - can't allocate";
return false;
}
m_lock_order_counter__ = 0;
uint8_t *src = (uint8_t *)&m_buffer[*m_buffer_size];
uint8_t *dst = src + len;
if (!m_parse__) {
size_t move_length = getBuffRemainingBytes(src) - len;
std::copy_n(src, move_length, dst);
}
m_buffer_idx__ += count;
*m_buffer_size += count;
if (!buffPtrIncrementSafe(len)) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << len << ") Failed!";
return false;
}
return true;
}
void cACTION_BML_EVENTS_UPDATE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
tlvf_swap(32, reinterpret_cast<uint8_t*>(m_buffer_size));
}
bool cACTION_BML_EVENTS_UPDATE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_EVENTS_UPDATE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint32_t); // buffer_size
return class_size;
}
bool cACTION_BML_EVENTS_UPDATE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_buffer_size = (uint32_t*)m_buff_ptr__;
if (!m_parse__) *m_buffer_size = 0;
if (!buffPtrIncrementSafe(sizeof(uint32_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint32_t) << ") Failed!";
return false;
}
m_buffer = (char*)m_buff_ptr__;
uint32_t buffer_size = *m_buffer_size;
if (m_parse__) { tlvf_swap(32, reinterpret_cast<uint8_t*>(&buffer_size)); }
m_buffer_idx__ = buffer_size;
if (!buffPtrIncrementSafe(sizeof(char) * (buffer_size))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(char) * (buffer_size) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_REGISTER_TO_NW_MAP_UPDATES_REQUEST::cACTION_BML_REGISTER_TO_NW_MAP_UPDATES_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_REGISTER_TO_NW_MAP_UPDATES_REQUEST::cACTION_BML_REGISTER_TO_NW_MAP_UPDATES_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_REGISTER_TO_NW_MAP_UPDATES_REQUEST::~cACTION_BML_REGISTER_TO_NW_MAP_UPDATES_REQUEST() {
}
void cACTION_BML_REGISTER_TO_NW_MAP_UPDATES_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_REGISTER_TO_NW_MAP_UPDATES_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_REGISTER_TO_NW_MAP_UPDATES_REQUEST::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_REGISTER_TO_NW_MAP_UPDATES_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_REGISTER_TO_NW_MAP_UPDATES_RESPONSE::cACTION_BML_REGISTER_TO_NW_MAP_UPDATES_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_REGISTER_TO_NW_MAP_UPDATES_RESPONSE::cACTION_BML_REGISTER_TO_NW_MAP_UPDATES_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_REGISTER_TO_NW_MAP_UPDATES_RESPONSE::~cACTION_BML_REGISTER_TO_NW_MAP_UPDATES_RESPONSE() {
}
void cACTION_BML_REGISTER_TO_NW_MAP_UPDATES_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_REGISTER_TO_NW_MAP_UPDATES_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_REGISTER_TO_NW_MAP_UPDATES_RESPONSE::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_REGISTER_TO_NW_MAP_UPDATES_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_UNREGISTER_FROM_NW_MAP_UPDATES_REQUEST::cACTION_BML_UNREGISTER_FROM_NW_MAP_UPDATES_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_UNREGISTER_FROM_NW_MAP_UPDATES_REQUEST::cACTION_BML_UNREGISTER_FROM_NW_MAP_UPDATES_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_UNREGISTER_FROM_NW_MAP_UPDATES_REQUEST::~cACTION_BML_UNREGISTER_FROM_NW_MAP_UPDATES_REQUEST() {
}
void cACTION_BML_UNREGISTER_FROM_NW_MAP_UPDATES_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_UNREGISTER_FROM_NW_MAP_UPDATES_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_UNREGISTER_FROM_NW_MAP_UPDATES_REQUEST::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_UNREGISTER_FROM_NW_MAP_UPDATES_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_UNREGISTER_FROM_NW_MAP_UPDATES_RESPONSE::cACTION_BML_UNREGISTER_FROM_NW_MAP_UPDATES_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_UNREGISTER_FROM_NW_MAP_UPDATES_RESPONSE::cACTION_BML_UNREGISTER_FROM_NW_MAP_UPDATES_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_UNREGISTER_FROM_NW_MAP_UPDATES_RESPONSE::~cACTION_BML_UNREGISTER_FROM_NW_MAP_UPDATES_RESPONSE() {
}
void cACTION_BML_UNREGISTER_FROM_NW_MAP_UPDATES_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_UNREGISTER_FROM_NW_MAP_UPDATES_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_UNREGISTER_FROM_NW_MAP_UPDATES_RESPONSE::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_UNREGISTER_FROM_NW_MAP_UPDATES_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_SET_LEGACY_CLIENT_ROAMING_RESPONSE::cACTION_BML_SET_LEGACY_CLIENT_ROAMING_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_SET_LEGACY_CLIENT_ROAMING_RESPONSE::cACTION_BML_SET_LEGACY_CLIENT_ROAMING_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_SET_LEGACY_CLIENT_ROAMING_RESPONSE::~cACTION_BML_SET_LEGACY_CLIENT_ROAMING_RESPONSE() {
}
void cACTION_BML_SET_LEGACY_CLIENT_ROAMING_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_SET_LEGACY_CLIENT_ROAMING_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_SET_LEGACY_CLIENT_ROAMING_RESPONSE::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_SET_LEGACY_CLIENT_ROAMING_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_GET_LEGACY_CLIENT_ROAMING_REQUEST::cACTION_BML_GET_LEGACY_CLIENT_ROAMING_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_GET_LEGACY_CLIENT_ROAMING_REQUEST::cACTION_BML_GET_LEGACY_CLIENT_ROAMING_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_GET_LEGACY_CLIENT_ROAMING_REQUEST::~cACTION_BML_GET_LEGACY_CLIENT_ROAMING_REQUEST() {
}
void cACTION_BML_GET_LEGACY_CLIENT_ROAMING_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_GET_LEGACY_CLIENT_ROAMING_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_GET_LEGACY_CLIENT_ROAMING_REQUEST::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_GET_LEGACY_CLIENT_ROAMING_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_REGISTER_TO_EVENTS_UPDATES_REQUEST::cACTION_BML_REGISTER_TO_EVENTS_UPDATES_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_REGISTER_TO_EVENTS_UPDATES_REQUEST::cACTION_BML_REGISTER_TO_EVENTS_UPDATES_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_REGISTER_TO_EVENTS_UPDATES_REQUEST::~cACTION_BML_REGISTER_TO_EVENTS_UPDATES_REQUEST() {
}
void cACTION_BML_REGISTER_TO_EVENTS_UPDATES_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_REGISTER_TO_EVENTS_UPDATES_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_REGISTER_TO_EVENTS_UPDATES_REQUEST::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_REGISTER_TO_EVENTS_UPDATES_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_REGISTER_TO_EVENTS_UPDATES_RESPONSE::cACTION_BML_REGISTER_TO_EVENTS_UPDATES_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_REGISTER_TO_EVENTS_UPDATES_RESPONSE::cACTION_BML_REGISTER_TO_EVENTS_UPDATES_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_REGISTER_TO_EVENTS_UPDATES_RESPONSE::~cACTION_BML_REGISTER_TO_EVENTS_UPDATES_RESPONSE() {
}
void cACTION_BML_REGISTER_TO_EVENTS_UPDATES_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_REGISTER_TO_EVENTS_UPDATES_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_REGISTER_TO_EVENTS_UPDATES_RESPONSE::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_REGISTER_TO_EVENTS_UPDATES_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_UNREGISTER_FROM_EVENTS_UPDATES_REQUEST::cACTION_BML_UNREGISTER_FROM_EVENTS_UPDATES_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_UNREGISTER_FROM_EVENTS_UPDATES_REQUEST::cACTION_BML_UNREGISTER_FROM_EVENTS_UPDATES_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_UNREGISTER_FROM_EVENTS_UPDATES_REQUEST::~cACTION_BML_UNREGISTER_FROM_EVENTS_UPDATES_REQUEST() {
}
void cACTION_BML_UNREGISTER_FROM_EVENTS_UPDATES_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_UNREGISTER_FROM_EVENTS_UPDATES_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_UNREGISTER_FROM_EVENTS_UPDATES_REQUEST::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_UNREGISTER_FROM_EVENTS_UPDATES_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_UNREGISTER_FROM_EVENTS_UPDATES_RESPONSE::cACTION_BML_UNREGISTER_FROM_EVENTS_UPDATES_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_UNREGISTER_FROM_EVENTS_UPDATES_RESPONSE::cACTION_BML_UNREGISTER_FROM_EVENTS_UPDATES_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_UNREGISTER_FROM_EVENTS_UPDATES_RESPONSE::~cACTION_BML_UNREGISTER_FROM_EVENTS_UPDATES_RESPONSE() {
}
void cACTION_BML_UNREGISTER_FROM_EVENTS_UPDATES_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_UNREGISTER_FROM_EVENTS_UPDATES_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_UNREGISTER_FROM_EVENTS_UPDATES_RESPONSE::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_UNREGISTER_FROM_EVENTS_UPDATES_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_REGISTER_TO_STATS_UPDATES_REQUEST::cACTION_BML_REGISTER_TO_STATS_UPDATES_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_REGISTER_TO_STATS_UPDATES_REQUEST::cACTION_BML_REGISTER_TO_STATS_UPDATES_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_REGISTER_TO_STATS_UPDATES_REQUEST::~cACTION_BML_REGISTER_TO_STATS_UPDATES_REQUEST() {
}
void cACTION_BML_REGISTER_TO_STATS_UPDATES_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_REGISTER_TO_STATS_UPDATES_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_REGISTER_TO_STATS_UPDATES_REQUEST::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_REGISTER_TO_STATS_UPDATES_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_REGISTER_TO_STATS_UPDATES_RESPONSE::cACTION_BML_REGISTER_TO_STATS_UPDATES_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_REGISTER_TO_STATS_UPDATES_RESPONSE::cACTION_BML_REGISTER_TO_STATS_UPDATES_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_REGISTER_TO_STATS_UPDATES_RESPONSE::~cACTION_BML_REGISTER_TO_STATS_UPDATES_RESPONSE() {
}
void cACTION_BML_REGISTER_TO_STATS_UPDATES_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_REGISTER_TO_STATS_UPDATES_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_REGISTER_TO_STATS_UPDATES_RESPONSE::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_REGISTER_TO_STATS_UPDATES_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_UNREGISTER_FROM_STATS_UPDATES_REQUEST::cACTION_BML_UNREGISTER_FROM_STATS_UPDATES_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_UNREGISTER_FROM_STATS_UPDATES_REQUEST::cACTION_BML_UNREGISTER_FROM_STATS_UPDATES_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_UNREGISTER_FROM_STATS_UPDATES_REQUEST::~cACTION_BML_UNREGISTER_FROM_STATS_UPDATES_REQUEST() {
}
void cACTION_BML_UNREGISTER_FROM_STATS_UPDATES_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_UNREGISTER_FROM_STATS_UPDATES_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_UNREGISTER_FROM_STATS_UPDATES_REQUEST::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_UNREGISTER_FROM_STATS_UPDATES_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_UNREGISTER_FROM_STATS_UPDATES_RESPONSE::cACTION_BML_UNREGISTER_FROM_STATS_UPDATES_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_UNREGISTER_FROM_STATS_UPDATES_RESPONSE::cACTION_BML_UNREGISTER_FROM_STATS_UPDATES_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_UNREGISTER_FROM_STATS_UPDATES_RESPONSE::~cACTION_BML_UNREGISTER_FROM_STATS_UPDATES_RESPONSE() {
}
void cACTION_BML_UNREGISTER_FROM_STATS_UPDATES_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_UNREGISTER_FROM_STATS_UPDATES_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_UNREGISTER_FROM_STATS_UPDATES_RESPONSE::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_UNREGISTER_FROM_STATS_UPDATES_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_SET_LEGACY_CLIENT_ROAMING_REQUEST::cACTION_BML_SET_LEGACY_CLIENT_ROAMING_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_SET_LEGACY_CLIENT_ROAMING_REQUEST::cACTION_BML_SET_LEGACY_CLIENT_ROAMING_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_SET_LEGACY_CLIENT_ROAMING_REQUEST::~cACTION_BML_SET_LEGACY_CLIENT_ROAMING_REQUEST() {
}
uint8_t& cACTION_BML_SET_LEGACY_CLIENT_ROAMING_REQUEST::isEnable() {
return (uint8_t&)(*m_isEnable);
}
void cACTION_BML_SET_LEGACY_CLIENT_ROAMING_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_SET_LEGACY_CLIENT_ROAMING_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_SET_LEGACY_CLIENT_ROAMING_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint8_t); // isEnable
return class_size;
}
bool cACTION_BML_SET_LEGACY_CLIENT_ROAMING_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_isEnable = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_GET_LEGACY_CLIENT_ROAMING_RESPONSE::cACTION_BML_GET_LEGACY_CLIENT_ROAMING_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_GET_LEGACY_CLIENT_ROAMING_RESPONSE::cACTION_BML_GET_LEGACY_CLIENT_ROAMING_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_GET_LEGACY_CLIENT_ROAMING_RESPONSE::~cACTION_BML_GET_LEGACY_CLIENT_ROAMING_RESPONSE() {
}
uint8_t& cACTION_BML_GET_LEGACY_CLIENT_ROAMING_RESPONSE::isEnable() {
return (uint8_t&)(*m_isEnable);
}
void cACTION_BML_GET_LEGACY_CLIENT_ROAMING_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_GET_LEGACY_CLIENT_ROAMING_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_GET_LEGACY_CLIENT_ROAMING_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint8_t); // isEnable
return class_size;
}
bool cACTION_BML_GET_LEGACY_CLIENT_ROAMING_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_isEnable = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_SET_CLIENT_ROAMING_REQUEST::cACTION_BML_SET_CLIENT_ROAMING_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_SET_CLIENT_ROAMING_REQUEST::cACTION_BML_SET_CLIENT_ROAMING_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_SET_CLIENT_ROAMING_REQUEST::~cACTION_BML_SET_CLIENT_ROAMING_REQUEST() {
}
uint8_t& cACTION_BML_SET_CLIENT_ROAMING_REQUEST::isEnable() {
return (uint8_t&)(*m_isEnable);
}
void cACTION_BML_SET_CLIENT_ROAMING_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_SET_CLIENT_ROAMING_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_SET_CLIENT_ROAMING_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint8_t); // isEnable
return class_size;
}
bool cACTION_BML_SET_CLIENT_ROAMING_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_isEnable = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_SET_CLIENT_ROAMING_RESPONSE::cACTION_BML_SET_CLIENT_ROAMING_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_SET_CLIENT_ROAMING_RESPONSE::cACTION_BML_SET_CLIENT_ROAMING_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_SET_CLIENT_ROAMING_RESPONSE::~cACTION_BML_SET_CLIENT_ROAMING_RESPONSE() {
}
void cACTION_BML_SET_CLIENT_ROAMING_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_SET_CLIENT_ROAMING_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_SET_CLIENT_ROAMING_RESPONSE::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_SET_CLIENT_ROAMING_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_GET_CLIENT_ROAMING_REQUEST::cACTION_BML_GET_CLIENT_ROAMING_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_GET_CLIENT_ROAMING_REQUEST::cACTION_BML_GET_CLIENT_ROAMING_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_GET_CLIENT_ROAMING_REQUEST::~cACTION_BML_GET_CLIENT_ROAMING_REQUEST() {
}
void cACTION_BML_GET_CLIENT_ROAMING_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_GET_CLIENT_ROAMING_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_GET_CLIENT_ROAMING_REQUEST::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_GET_CLIENT_ROAMING_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_GET_CLIENT_ROAMING_RESPONSE::cACTION_BML_GET_CLIENT_ROAMING_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_GET_CLIENT_ROAMING_RESPONSE::cACTION_BML_GET_CLIENT_ROAMING_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_GET_CLIENT_ROAMING_RESPONSE::~cACTION_BML_GET_CLIENT_ROAMING_RESPONSE() {
}
uint8_t& cACTION_BML_GET_CLIENT_ROAMING_RESPONSE::isEnable() {
return (uint8_t&)(*m_isEnable);
}
void cACTION_BML_GET_CLIENT_ROAMING_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_GET_CLIENT_ROAMING_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_GET_CLIENT_ROAMING_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint8_t); // isEnable
return class_size;
}
bool cACTION_BML_GET_CLIENT_ROAMING_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_isEnable = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_SET_DFS_REENTRY_REQUEST::cACTION_BML_SET_DFS_REENTRY_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_SET_DFS_REENTRY_REQUEST::cACTION_BML_SET_DFS_REENTRY_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_SET_DFS_REENTRY_REQUEST::~cACTION_BML_SET_DFS_REENTRY_REQUEST() {
}
uint8_t& cACTION_BML_SET_DFS_REENTRY_REQUEST::isEnable() {
return (uint8_t&)(*m_isEnable);
}
void cACTION_BML_SET_DFS_REENTRY_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_SET_DFS_REENTRY_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_SET_DFS_REENTRY_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint8_t); // isEnable
return class_size;
}
bool cACTION_BML_SET_DFS_REENTRY_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_isEnable = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_SET_DFS_REENTRY_RESPONSE::cACTION_BML_SET_DFS_REENTRY_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_SET_DFS_REENTRY_RESPONSE::cACTION_BML_SET_DFS_REENTRY_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_SET_DFS_REENTRY_RESPONSE::~cACTION_BML_SET_DFS_REENTRY_RESPONSE() {
}
void cACTION_BML_SET_DFS_REENTRY_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_SET_DFS_REENTRY_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_SET_DFS_REENTRY_RESPONSE::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_SET_DFS_REENTRY_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_GET_DFS_REENTRY_REQUEST::cACTION_BML_GET_DFS_REENTRY_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_GET_DFS_REENTRY_REQUEST::cACTION_BML_GET_DFS_REENTRY_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_GET_DFS_REENTRY_REQUEST::~cACTION_BML_GET_DFS_REENTRY_REQUEST() {
}
void cACTION_BML_GET_DFS_REENTRY_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_GET_DFS_REENTRY_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_GET_DFS_REENTRY_REQUEST::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_GET_DFS_REENTRY_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_GET_DFS_REENTRY_RESPONSE::cACTION_BML_GET_DFS_REENTRY_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_GET_DFS_REENTRY_RESPONSE::cACTION_BML_GET_DFS_REENTRY_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_GET_DFS_REENTRY_RESPONSE::~cACTION_BML_GET_DFS_REENTRY_RESPONSE() {
}
uint8_t& cACTION_BML_GET_DFS_REENTRY_RESPONSE::isEnable() {
return (uint8_t&)(*m_isEnable);
}
void cACTION_BML_GET_DFS_REENTRY_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_GET_DFS_REENTRY_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_GET_DFS_REENTRY_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint8_t); // isEnable
return class_size;
}
bool cACTION_BML_GET_DFS_REENTRY_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_isEnable = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_SET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_REQUEST::cACTION_BML_SET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_SET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_REQUEST::cACTION_BML_SET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_SET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_REQUEST::~cACTION_BML_SET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_REQUEST() {
}
uint8_t& cACTION_BML_SET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_REQUEST::isEnable() {
return (uint8_t&)(*m_isEnable);
}
void cACTION_BML_SET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_SET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_SET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint8_t); // isEnable
return class_size;
}
bool cACTION_BML_SET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_isEnable = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_SET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_RESPONSE::cACTION_BML_SET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_SET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_RESPONSE::cACTION_BML_SET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_SET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_RESPONSE::~cACTION_BML_SET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_RESPONSE() {
}
void cACTION_BML_SET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_SET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_SET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_RESPONSE::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_SET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_GET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_REQUEST::cACTION_BML_GET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_GET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_REQUEST::cACTION_BML_GET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_GET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_REQUEST::~cACTION_BML_GET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_REQUEST() {
}
void cACTION_BML_GET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_GET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_GET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_REQUEST::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_GET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_GET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_RESPONSE::cACTION_BML_GET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_GET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_RESPONSE::cACTION_BML_GET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_GET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_RESPONSE::~cACTION_BML_GET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_RESPONSE() {
}
uint8_t& cACTION_BML_GET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_RESPONSE::isEnable() {
return (uint8_t&)(*m_isEnable);
}
void cACTION_BML_GET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_GET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_GET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint8_t); // isEnable
return class_size;
}
bool cACTION_BML_GET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_isEnable = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_SET_CLIENT_BAND_STEERING_REQUEST::cACTION_BML_SET_CLIENT_BAND_STEERING_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_SET_CLIENT_BAND_STEERING_REQUEST::cACTION_BML_SET_CLIENT_BAND_STEERING_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_SET_CLIENT_BAND_STEERING_REQUEST::~cACTION_BML_SET_CLIENT_BAND_STEERING_REQUEST() {
}
uint8_t& cACTION_BML_SET_CLIENT_BAND_STEERING_REQUEST::isEnable() {
return (uint8_t&)(*m_isEnable);
}
void cACTION_BML_SET_CLIENT_BAND_STEERING_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_SET_CLIENT_BAND_STEERING_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_SET_CLIENT_BAND_STEERING_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint8_t); // isEnable
return class_size;
}
bool cACTION_BML_SET_CLIENT_BAND_STEERING_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_isEnable = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_SET_CLIENT_BAND_STEERING_RESPONSE::cACTION_BML_SET_CLIENT_BAND_STEERING_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_SET_CLIENT_BAND_STEERING_RESPONSE::cACTION_BML_SET_CLIENT_BAND_STEERING_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_SET_CLIENT_BAND_STEERING_RESPONSE::~cACTION_BML_SET_CLIENT_BAND_STEERING_RESPONSE() {
}
void cACTION_BML_SET_CLIENT_BAND_STEERING_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_SET_CLIENT_BAND_STEERING_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_SET_CLIENT_BAND_STEERING_RESPONSE::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_SET_CLIENT_BAND_STEERING_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_GET_CLIENT_BAND_STEERING_REQUEST::cACTION_BML_GET_CLIENT_BAND_STEERING_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_GET_CLIENT_BAND_STEERING_REQUEST::cACTION_BML_GET_CLIENT_BAND_STEERING_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_GET_CLIENT_BAND_STEERING_REQUEST::~cACTION_BML_GET_CLIENT_BAND_STEERING_REQUEST() {
}
void cACTION_BML_GET_CLIENT_BAND_STEERING_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_GET_CLIENT_BAND_STEERING_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_GET_CLIENT_BAND_STEERING_REQUEST::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_GET_CLIENT_BAND_STEERING_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_GET_CLIENT_BAND_STEERING_RESPONSE::cACTION_BML_GET_CLIENT_BAND_STEERING_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_GET_CLIENT_BAND_STEERING_RESPONSE::cACTION_BML_GET_CLIENT_BAND_STEERING_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_GET_CLIENT_BAND_STEERING_RESPONSE::~cACTION_BML_GET_CLIENT_BAND_STEERING_RESPONSE() {
}
uint8_t& cACTION_BML_GET_CLIENT_BAND_STEERING_RESPONSE::isEnable() {
return (uint8_t&)(*m_isEnable);
}
void cACTION_BML_GET_CLIENT_BAND_STEERING_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_GET_CLIENT_BAND_STEERING_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_GET_CLIENT_BAND_STEERING_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint8_t); // isEnable
return class_size;
}
bool cACTION_BML_GET_CLIENT_BAND_STEERING_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_isEnable = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_SET_IRE_ROAMING_REQUEST::cACTION_BML_SET_IRE_ROAMING_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_SET_IRE_ROAMING_REQUEST::cACTION_BML_SET_IRE_ROAMING_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_SET_IRE_ROAMING_REQUEST::~cACTION_BML_SET_IRE_ROAMING_REQUEST() {
}
uint8_t& cACTION_BML_SET_IRE_ROAMING_REQUEST::isEnable() {
return (uint8_t&)(*m_isEnable);
}
void cACTION_BML_SET_IRE_ROAMING_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_SET_IRE_ROAMING_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_SET_IRE_ROAMING_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint8_t); // isEnable
return class_size;
}
bool cACTION_BML_SET_IRE_ROAMING_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_isEnable = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_SET_IRE_ROAMING_RESPONSE::cACTION_BML_SET_IRE_ROAMING_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_SET_IRE_ROAMING_RESPONSE::cACTION_BML_SET_IRE_ROAMING_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_SET_IRE_ROAMING_RESPONSE::~cACTION_BML_SET_IRE_ROAMING_RESPONSE() {
}
void cACTION_BML_SET_IRE_ROAMING_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_SET_IRE_ROAMING_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_SET_IRE_ROAMING_RESPONSE::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_SET_IRE_ROAMING_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_GET_IRE_ROAMING_REQUEST::cACTION_BML_GET_IRE_ROAMING_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_GET_IRE_ROAMING_REQUEST::cACTION_BML_GET_IRE_ROAMING_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_GET_IRE_ROAMING_REQUEST::~cACTION_BML_GET_IRE_ROAMING_REQUEST() {
}
void cACTION_BML_GET_IRE_ROAMING_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_GET_IRE_ROAMING_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_GET_IRE_ROAMING_REQUEST::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_GET_IRE_ROAMING_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_GET_IRE_ROAMING_RESPONSE::cACTION_BML_GET_IRE_ROAMING_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_GET_IRE_ROAMING_RESPONSE::cACTION_BML_GET_IRE_ROAMING_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_GET_IRE_ROAMING_RESPONSE::~cACTION_BML_GET_IRE_ROAMING_RESPONSE() {
}
uint8_t& cACTION_BML_GET_IRE_ROAMING_RESPONSE::isEnable() {
return (uint8_t&)(*m_isEnable);
}
void cACTION_BML_GET_IRE_ROAMING_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_GET_IRE_ROAMING_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_GET_IRE_ROAMING_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint8_t); // isEnable
return class_size;
}
bool cACTION_BML_GET_IRE_ROAMING_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_isEnable = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_SET_LOAD_BALANCER_REQUEST::cACTION_BML_SET_LOAD_BALANCER_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_SET_LOAD_BALANCER_REQUEST::cACTION_BML_SET_LOAD_BALANCER_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_SET_LOAD_BALANCER_REQUEST::~cACTION_BML_SET_LOAD_BALANCER_REQUEST() {
}
uint8_t& cACTION_BML_SET_LOAD_BALANCER_REQUEST::isEnable() {
return (uint8_t&)(*m_isEnable);
}
void cACTION_BML_SET_LOAD_BALANCER_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_SET_LOAD_BALANCER_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_SET_LOAD_BALANCER_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint8_t); // isEnable
return class_size;
}
bool cACTION_BML_SET_LOAD_BALANCER_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_isEnable = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_SET_LOAD_BALANCER_RESPONSE::cACTION_BML_SET_LOAD_BALANCER_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_SET_LOAD_BALANCER_RESPONSE::cACTION_BML_SET_LOAD_BALANCER_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_SET_LOAD_BALANCER_RESPONSE::~cACTION_BML_SET_LOAD_BALANCER_RESPONSE() {
}
void cACTION_BML_SET_LOAD_BALANCER_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_SET_LOAD_BALANCER_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_SET_LOAD_BALANCER_RESPONSE::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_SET_LOAD_BALANCER_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_GET_LOAD_BALANCER_REQUEST::cACTION_BML_GET_LOAD_BALANCER_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_GET_LOAD_BALANCER_REQUEST::cACTION_BML_GET_LOAD_BALANCER_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_GET_LOAD_BALANCER_REQUEST::~cACTION_BML_GET_LOAD_BALANCER_REQUEST() {
}
void cACTION_BML_GET_LOAD_BALANCER_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_GET_LOAD_BALANCER_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_GET_LOAD_BALANCER_REQUEST::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_GET_LOAD_BALANCER_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_GET_LOAD_BALANCER_RESPONSE::cACTION_BML_GET_LOAD_BALANCER_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_GET_LOAD_BALANCER_RESPONSE::cACTION_BML_GET_LOAD_BALANCER_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_GET_LOAD_BALANCER_RESPONSE::~cACTION_BML_GET_LOAD_BALANCER_RESPONSE() {
}
uint8_t& cACTION_BML_GET_LOAD_BALANCER_RESPONSE::isEnable() {
return (uint8_t&)(*m_isEnable);
}
void cACTION_BML_GET_LOAD_BALANCER_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_GET_LOAD_BALANCER_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_GET_LOAD_BALANCER_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint8_t); // isEnable
return class_size;
}
bool cACTION_BML_GET_LOAD_BALANCER_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_isEnable = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_SET_SERVICE_FAIRNESS_REQUEST::cACTION_BML_SET_SERVICE_FAIRNESS_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_SET_SERVICE_FAIRNESS_REQUEST::cACTION_BML_SET_SERVICE_FAIRNESS_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_SET_SERVICE_FAIRNESS_REQUEST::~cACTION_BML_SET_SERVICE_FAIRNESS_REQUEST() {
}
uint8_t& cACTION_BML_SET_SERVICE_FAIRNESS_REQUEST::isEnable() {
return (uint8_t&)(*m_isEnable);
}
void cACTION_BML_SET_SERVICE_FAIRNESS_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_SET_SERVICE_FAIRNESS_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_SET_SERVICE_FAIRNESS_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint8_t); // isEnable
return class_size;
}
bool cACTION_BML_SET_SERVICE_FAIRNESS_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_isEnable = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_SET_SERVICE_FAIRNESS_RESPONSE::cACTION_BML_SET_SERVICE_FAIRNESS_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_SET_SERVICE_FAIRNESS_RESPONSE::cACTION_BML_SET_SERVICE_FAIRNESS_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_SET_SERVICE_FAIRNESS_RESPONSE::~cACTION_BML_SET_SERVICE_FAIRNESS_RESPONSE() {
}
void cACTION_BML_SET_SERVICE_FAIRNESS_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_SET_SERVICE_FAIRNESS_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_SET_SERVICE_FAIRNESS_RESPONSE::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_SET_SERVICE_FAIRNESS_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_GET_SERVICE_FAIRNESS_REQUEST::cACTION_BML_GET_SERVICE_FAIRNESS_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_GET_SERVICE_FAIRNESS_REQUEST::cACTION_BML_GET_SERVICE_FAIRNESS_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_GET_SERVICE_FAIRNESS_REQUEST::~cACTION_BML_GET_SERVICE_FAIRNESS_REQUEST() {
}
void cACTION_BML_GET_SERVICE_FAIRNESS_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_GET_SERVICE_FAIRNESS_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_GET_SERVICE_FAIRNESS_REQUEST::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_GET_SERVICE_FAIRNESS_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_GET_SERVICE_FAIRNESS_RESPONSE::cACTION_BML_GET_SERVICE_FAIRNESS_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_GET_SERVICE_FAIRNESS_RESPONSE::cACTION_BML_GET_SERVICE_FAIRNESS_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_GET_SERVICE_FAIRNESS_RESPONSE::~cACTION_BML_GET_SERVICE_FAIRNESS_RESPONSE() {
}
uint8_t& cACTION_BML_GET_SERVICE_FAIRNESS_RESPONSE::isEnable() {
return (uint8_t&)(*m_isEnable);
}
void cACTION_BML_GET_SERVICE_FAIRNESS_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_GET_SERVICE_FAIRNESS_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_GET_SERVICE_FAIRNESS_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint8_t); // isEnable
return class_size;
}
bool cACTION_BML_GET_SERVICE_FAIRNESS_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_isEnable = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_CHANGE_MODULE_LOGGING_LEVEL_REQUEST::cACTION_BML_CHANGE_MODULE_LOGGING_LEVEL_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_CHANGE_MODULE_LOGGING_LEVEL_REQUEST::cACTION_BML_CHANGE_MODULE_LOGGING_LEVEL_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_CHANGE_MODULE_LOGGING_LEVEL_REQUEST::~cACTION_BML_CHANGE_MODULE_LOGGING_LEVEL_REQUEST() {
}
sLoggingLevelChange& cACTION_BML_CHANGE_MODULE_LOGGING_LEVEL_REQUEST::params() {
return (sLoggingLevelChange&)(*m_params);
}
void cACTION_BML_CHANGE_MODULE_LOGGING_LEVEL_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
m_params->struct_swap();
}
bool cACTION_BML_CHANGE_MODULE_LOGGING_LEVEL_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_CHANGE_MODULE_LOGGING_LEVEL_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(sLoggingLevelChange); // params
return class_size;
}
bool cACTION_BML_CHANGE_MODULE_LOGGING_LEVEL_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_params = (sLoggingLevelChange*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(sLoggingLevelChange))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sLoggingLevelChange) << ") Failed!";
return false;
}
if (!m_parse__) { m_params->struct_init(); }
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_CHANGE_MODULE_LOGGING_LEVEL_RESPONSE::cACTION_BML_CHANGE_MODULE_LOGGING_LEVEL_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_CHANGE_MODULE_LOGGING_LEVEL_RESPONSE::cACTION_BML_CHANGE_MODULE_LOGGING_LEVEL_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_CHANGE_MODULE_LOGGING_LEVEL_RESPONSE::~cACTION_BML_CHANGE_MODULE_LOGGING_LEVEL_RESPONSE() {
}
void cACTION_BML_CHANGE_MODULE_LOGGING_LEVEL_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_CHANGE_MODULE_LOGGING_LEVEL_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_CHANGE_MODULE_LOGGING_LEVEL_RESPONSE::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_CHANGE_MODULE_LOGGING_LEVEL_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_WIFI_CREDENTIALS_UPDATE_REQUEST::cACTION_BML_WIFI_CREDENTIALS_UPDATE_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_WIFI_CREDENTIALS_UPDATE_REQUEST::cACTION_BML_WIFI_CREDENTIALS_UPDATE_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_WIFI_CREDENTIALS_UPDATE_REQUEST::~cACTION_BML_WIFI_CREDENTIALS_UPDATE_REQUEST() {
}
sWifiCredentials& cACTION_BML_WIFI_CREDENTIALS_UPDATE_REQUEST::params() {
return (sWifiCredentials&)(*m_params);
}
void cACTION_BML_WIFI_CREDENTIALS_UPDATE_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
m_params->struct_swap();
}
bool cACTION_BML_WIFI_CREDENTIALS_UPDATE_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_WIFI_CREDENTIALS_UPDATE_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(sWifiCredentials); // params
return class_size;
}
bool cACTION_BML_WIFI_CREDENTIALS_UPDATE_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_params = (sWifiCredentials*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(sWifiCredentials))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sWifiCredentials) << ") Failed!";
return false;
}
if (!m_parse__) { m_params->struct_init(); }
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_WIFI_CREDENTIALS_UPDATE_RESPONSE::cACTION_BML_WIFI_CREDENTIALS_UPDATE_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_WIFI_CREDENTIALS_UPDATE_RESPONSE::cACTION_BML_WIFI_CREDENTIALS_UPDATE_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_WIFI_CREDENTIALS_UPDATE_RESPONSE::~cACTION_BML_WIFI_CREDENTIALS_UPDATE_RESPONSE() {
}
uint32_t& cACTION_BML_WIFI_CREDENTIALS_UPDATE_RESPONSE::error_code() {
return (uint32_t&)(*m_error_code);
}
void cACTION_BML_WIFI_CREDENTIALS_UPDATE_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
tlvf_swap(32, reinterpret_cast<uint8_t*>(m_error_code));
}
bool cACTION_BML_WIFI_CREDENTIALS_UPDATE_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_WIFI_CREDENTIALS_UPDATE_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint32_t); // error_code
return class_size;
}
bool cACTION_BML_WIFI_CREDENTIALS_UPDATE_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_error_code = (uint32_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint32_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint32_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_SET_RESTRICTED_CHANNELS_REQUEST::cACTION_BML_SET_RESTRICTED_CHANNELS_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_SET_RESTRICTED_CHANNELS_REQUEST::cACTION_BML_SET_RESTRICTED_CHANNELS_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_SET_RESTRICTED_CHANNELS_REQUEST::~cACTION_BML_SET_RESTRICTED_CHANNELS_REQUEST() {
}
sRestrictedChannels& cACTION_BML_SET_RESTRICTED_CHANNELS_REQUEST::params() {
return (sRestrictedChannels&)(*m_params);
}
void cACTION_BML_SET_RESTRICTED_CHANNELS_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
m_params->struct_swap();
}
bool cACTION_BML_SET_RESTRICTED_CHANNELS_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_SET_RESTRICTED_CHANNELS_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(sRestrictedChannels); // params
return class_size;
}
bool cACTION_BML_SET_RESTRICTED_CHANNELS_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_params = (sRestrictedChannels*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(sRestrictedChannels))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sRestrictedChannels) << ") Failed!";
return false;
}
if (!m_parse__) { m_params->struct_init(); }
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_SET_RESTRICTED_CHANNELS_RESPONSE::cACTION_BML_SET_RESTRICTED_CHANNELS_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_SET_RESTRICTED_CHANNELS_RESPONSE::cACTION_BML_SET_RESTRICTED_CHANNELS_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_SET_RESTRICTED_CHANNELS_RESPONSE::~cACTION_BML_SET_RESTRICTED_CHANNELS_RESPONSE() {
}
uint32_t& cACTION_BML_SET_RESTRICTED_CHANNELS_RESPONSE::error_code() {
return (uint32_t&)(*m_error_code);
}
void cACTION_BML_SET_RESTRICTED_CHANNELS_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
tlvf_swap(32, reinterpret_cast<uint8_t*>(m_error_code));
}
bool cACTION_BML_SET_RESTRICTED_CHANNELS_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_SET_RESTRICTED_CHANNELS_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint32_t); // error_code
return class_size;
}
bool cACTION_BML_SET_RESTRICTED_CHANNELS_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_error_code = (uint32_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint32_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint32_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_GET_RESTRICTED_CHANNELS_REQUEST::cACTION_BML_GET_RESTRICTED_CHANNELS_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_GET_RESTRICTED_CHANNELS_REQUEST::cACTION_BML_GET_RESTRICTED_CHANNELS_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_GET_RESTRICTED_CHANNELS_REQUEST::~cACTION_BML_GET_RESTRICTED_CHANNELS_REQUEST() {
}
sRestrictedChannels& cACTION_BML_GET_RESTRICTED_CHANNELS_REQUEST::params() {
return (sRestrictedChannels&)(*m_params);
}
void cACTION_BML_GET_RESTRICTED_CHANNELS_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
m_params->struct_swap();
}
bool cACTION_BML_GET_RESTRICTED_CHANNELS_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_GET_RESTRICTED_CHANNELS_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(sRestrictedChannels); // params
return class_size;
}
bool cACTION_BML_GET_RESTRICTED_CHANNELS_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_params = (sRestrictedChannels*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(sRestrictedChannels))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sRestrictedChannels) << ") Failed!";
return false;
}
if (!m_parse__) { m_params->struct_init(); }
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_GET_RESTRICTED_CHANNELS_RESPONSE::cACTION_BML_GET_RESTRICTED_CHANNELS_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_GET_RESTRICTED_CHANNELS_RESPONSE::cACTION_BML_GET_RESTRICTED_CHANNELS_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_GET_RESTRICTED_CHANNELS_RESPONSE::~cACTION_BML_GET_RESTRICTED_CHANNELS_RESPONSE() {
}
sRestrictedChannels& cACTION_BML_GET_RESTRICTED_CHANNELS_RESPONSE::params() {
return (sRestrictedChannels&)(*m_params);
}
void cACTION_BML_GET_RESTRICTED_CHANNELS_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
m_params->struct_swap();
}
bool cACTION_BML_GET_RESTRICTED_CHANNELS_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_GET_RESTRICTED_CHANNELS_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(sRestrictedChannels); // params
return class_size;
}
bool cACTION_BML_GET_RESTRICTED_CHANNELS_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_params = (sRestrictedChannels*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(sRestrictedChannels))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sRestrictedChannels) << ") Failed!";
return false;
}
if (!m_parse__) { m_params->struct_init(); }
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_SET_CERTIFICATION_MODE_REQUEST::cACTION_BML_SET_CERTIFICATION_MODE_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_SET_CERTIFICATION_MODE_REQUEST::cACTION_BML_SET_CERTIFICATION_MODE_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_SET_CERTIFICATION_MODE_REQUEST::~cACTION_BML_SET_CERTIFICATION_MODE_REQUEST() {
}
uint8_t& cACTION_BML_SET_CERTIFICATION_MODE_REQUEST::isEnable() {
return (uint8_t&)(*m_isEnable);
}
void cACTION_BML_SET_CERTIFICATION_MODE_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_SET_CERTIFICATION_MODE_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_SET_CERTIFICATION_MODE_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint8_t); // isEnable
return class_size;
}
bool cACTION_BML_SET_CERTIFICATION_MODE_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_isEnable = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_SET_CERTIFICATION_MODE_RESPONSE::cACTION_BML_SET_CERTIFICATION_MODE_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_SET_CERTIFICATION_MODE_RESPONSE::cACTION_BML_SET_CERTIFICATION_MODE_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_SET_CERTIFICATION_MODE_RESPONSE::~cACTION_BML_SET_CERTIFICATION_MODE_RESPONSE() {
}
void cACTION_BML_SET_CERTIFICATION_MODE_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_SET_CERTIFICATION_MODE_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_SET_CERTIFICATION_MODE_RESPONSE::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_SET_CERTIFICATION_MODE_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_GET_CERTIFICATION_MODE_REQUEST::cACTION_BML_GET_CERTIFICATION_MODE_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_GET_CERTIFICATION_MODE_REQUEST::cACTION_BML_GET_CERTIFICATION_MODE_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_GET_CERTIFICATION_MODE_REQUEST::~cACTION_BML_GET_CERTIFICATION_MODE_REQUEST() {
}
void cACTION_BML_GET_CERTIFICATION_MODE_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_GET_CERTIFICATION_MODE_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_GET_CERTIFICATION_MODE_REQUEST::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_GET_CERTIFICATION_MODE_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_GET_CERTIFICATION_MODE_RESPONSE::cACTION_BML_GET_CERTIFICATION_MODE_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_GET_CERTIFICATION_MODE_RESPONSE::cACTION_BML_GET_CERTIFICATION_MODE_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_GET_CERTIFICATION_MODE_RESPONSE::~cACTION_BML_GET_CERTIFICATION_MODE_RESPONSE() {
}
uint8_t& cACTION_BML_GET_CERTIFICATION_MODE_RESPONSE::isEnable() {
return (uint8_t&)(*m_isEnable);
}
void cACTION_BML_GET_CERTIFICATION_MODE_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_GET_CERTIFICATION_MODE_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_GET_CERTIFICATION_MODE_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint8_t); // isEnable
return class_size;
}
bool cACTION_BML_GET_CERTIFICATION_MODE_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_isEnable = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_SET_VAP_LIST_CREDENTIALS_REQUEST::cACTION_BML_SET_VAP_LIST_CREDENTIALS_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_SET_VAP_LIST_CREDENTIALS_REQUEST::cACTION_BML_SET_VAP_LIST_CREDENTIALS_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_SET_VAP_LIST_CREDENTIALS_REQUEST::~cACTION_BML_SET_VAP_LIST_CREDENTIALS_REQUEST() {
}
uint32_t& cACTION_BML_SET_VAP_LIST_CREDENTIALS_REQUEST::result() {
return (uint32_t&)(*m_result);
}
uint8_t& cACTION_BML_SET_VAP_LIST_CREDENTIALS_REQUEST::vap_list_size() {
return (uint8_t&)(*m_vap_list_size);
}
std::tuple<bool, sConfigVapInfo&> cACTION_BML_SET_VAP_LIST_CREDENTIALS_REQUEST::vap_list(size_t idx) {
bool ret_success = ( (m_vap_list_idx__ > 0) && (m_vap_list_idx__ > idx) );
size_t ret_idx = ret_success ? idx : 0;
if (!ret_success) {
TLVF_LOG(ERROR) << "Requested index is greater than the number of available entries";
}
return std::forward_as_tuple(ret_success, m_vap_list[ret_idx]);
}
bool cACTION_BML_SET_VAP_LIST_CREDENTIALS_REQUEST::alloc_vap_list(size_t count) {
if (m_lock_order_counter__ > 0) {;
TLVF_LOG(ERROR) << "Out of order allocation for variable length list vap_list, abort!";
return false;
}
size_t len = sizeof(sConfigVapInfo) * count;
if(getBuffRemainingBytes() < len ) {
TLVF_LOG(ERROR) << "Not enough available space on buffer - can't allocate";
return false;
}
m_lock_order_counter__ = 0;
uint8_t *src = (uint8_t *)&m_vap_list[*m_vap_list_size];
uint8_t *dst = src + len;
if (!m_parse__) {
size_t move_length = getBuffRemainingBytes(src) - len;
std::copy_n(src, move_length, dst);
}
m_vap_list_idx__ += count;
*m_vap_list_size += count;
if (!buffPtrIncrementSafe(len)) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << len << ") Failed!";
return false;
}
if (!m_parse__) {
for (size_t i = m_vap_list_idx__ - count; i < m_vap_list_idx__; i++) { m_vap_list[i].struct_init(); }
}
return true;
}
void cACTION_BML_SET_VAP_LIST_CREDENTIALS_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
tlvf_swap(32, reinterpret_cast<uint8_t*>(m_result));
for (size_t i = 0; i < (size_t)*m_vap_list_size; i++){
m_vap_list[i].struct_swap();
}
}
bool cACTION_BML_SET_VAP_LIST_CREDENTIALS_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_SET_VAP_LIST_CREDENTIALS_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint32_t); // result
class_size += sizeof(uint8_t); // vap_list_size
return class_size;
}
bool cACTION_BML_SET_VAP_LIST_CREDENTIALS_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_result = (uint32_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint32_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint32_t) << ") Failed!";
return false;
}
m_vap_list_size = (uint8_t*)m_buff_ptr__;
if (!m_parse__) *m_vap_list_size = 0;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
m_vap_list = (sConfigVapInfo*)m_buff_ptr__;
uint8_t vap_list_size = *m_vap_list_size;
m_vap_list_idx__ = vap_list_size;
if (!buffPtrIncrementSafe(sizeof(sConfigVapInfo) * (vap_list_size))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sConfigVapInfo) * (vap_list_size) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_SET_VAP_LIST_CREDENTIALS_RESPONSE::cACTION_BML_SET_VAP_LIST_CREDENTIALS_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_SET_VAP_LIST_CREDENTIALS_RESPONSE::cACTION_BML_SET_VAP_LIST_CREDENTIALS_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_SET_VAP_LIST_CREDENTIALS_RESPONSE::~cACTION_BML_SET_VAP_LIST_CREDENTIALS_RESPONSE() {
}
uint32_t& cACTION_BML_SET_VAP_LIST_CREDENTIALS_RESPONSE::result() {
return (uint32_t&)(*m_result);
}
void cACTION_BML_SET_VAP_LIST_CREDENTIALS_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
tlvf_swap(32, reinterpret_cast<uint8_t*>(m_result));
}
bool cACTION_BML_SET_VAP_LIST_CREDENTIALS_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_SET_VAP_LIST_CREDENTIALS_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint32_t); // result
return class_size;
}
bool cACTION_BML_SET_VAP_LIST_CREDENTIALS_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_result = (uint32_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint32_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint32_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_GET_VAP_LIST_CREDENTIALS_RESPONSE::cACTION_BML_GET_VAP_LIST_CREDENTIALS_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_GET_VAP_LIST_CREDENTIALS_RESPONSE::cACTION_BML_GET_VAP_LIST_CREDENTIALS_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_GET_VAP_LIST_CREDENTIALS_RESPONSE::~cACTION_BML_GET_VAP_LIST_CREDENTIALS_RESPONSE() {
}
uint32_t& cACTION_BML_GET_VAP_LIST_CREDENTIALS_RESPONSE::result() {
return (uint32_t&)(*m_result);
}
uint8_t& cACTION_BML_GET_VAP_LIST_CREDENTIALS_RESPONSE::vap_list_size() {
return (uint8_t&)(*m_vap_list_size);
}
std::tuple<bool, sConfigVapInfo&> cACTION_BML_GET_VAP_LIST_CREDENTIALS_RESPONSE::vap_list(size_t idx) {
bool ret_success = ( (m_vap_list_idx__ > 0) && (m_vap_list_idx__ > idx) );
size_t ret_idx = ret_success ? idx : 0;
if (!ret_success) {
TLVF_LOG(ERROR) << "Requested index is greater than the number of available entries";
}
return std::forward_as_tuple(ret_success, m_vap_list[ret_idx]);
}
bool cACTION_BML_GET_VAP_LIST_CREDENTIALS_RESPONSE::alloc_vap_list(size_t count) {
if (m_lock_order_counter__ > 0) {;
TLVF_LOG(ERROR) << "Out of order allocation for variable length list vap_list, abort!";
return false;
}
size_t len = sizeof(sConfigVapInfo) * count;
if(getBuffRemainingBytes() < len ) {
TLVF_LOG(ERROR) << "Not enough available space on buffer - can't allocate";
return false;
}
m_lock_order_counter__ = 0;
uint8_t *src = (uint8_t *)&m_vap_list[*m_vap_list_size];
uint8_t *dst = src + len;
if (!m_parse__) {
size_t move_length = getBuffRemainingBytes(src) - len;
std::copy_n(src, move_length, dst);
}
m_vap_list_idx__ += count;
*m_vap_list_size += count;
if (!buffPtrIncrementSafe(len)) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << len << ") Failed!";
return false;
}
if (!m_parse__) {
for (size_t i = m_vap_list_idx__ - count; i < m_vap_list_idx__; i++) { m_vap_list[i].struct_init(); }
}
return true;
}
void cACTION_BML_GET_VAP_LIST_CREDENTIALS_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
tlvf_swap(32, reinterpret_cast<uint8_t*>(m_result));
for (size_t i = 0; i < (size_t)*m_vap_list_size; i++){
m_vap_list[i].struct_swap();
}
}
bool cACTION_BML_GET_VAP_LIST_CREDENTIALS_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_GET_VAP_LIST_CREDENTIALS_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint32_t); // result
class_size += sizeof(uint8_t); // vap_list_size
return class_size;
}
bool cACTION_BML_GET_VAP_LIST_CREDENTIALS_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_result = (uint32_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint32_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint32_t) << ") Failed!";
return false;
}
m_vap_list_size = (uint8_t*)m_buff_ptr__;
if (!m_parse__) *m_vap_list_size = 0;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
m_vap_list = (sConfigVapInfo*)m_buff_ptr__;
uint8_t vap_list_size = *m_vap_list_size;
m_vap_list_idx__ = vap_list_size;
if (!buffPtrIncrementSafe(sizeof(sConfigVapInfo) * (vap_list_size))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sConfigVapInfo) * (vap_list_size) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_GET_VAP_LIST_CREDENTIALS_REQUEST::cACTION_BML_GET_VAP_LIST_CREDENTIALS_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_GET_VAP_LIST_CREDENTIALS_REQUEST::cACTION_BML_GET_VAP_LIST_CREDENTIALS_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_GET_VAP_LIST_CREDENTIALS_REQUEST::~cACTION_BML_GET_VAP_LIST_CREDENTIALS_REQUEST() {
}
uint32_t& cACTION_BML_GET_VAP_LIST_CREDENTIALS_REQUEST::result() {
return (uint32_t&)(*m_result);
}
void cACTION_BML_GET_VAP_LIST_CREDENTIALS_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
tlvf_swap(32, reinterpret_cast<uint8_t*>(m_result));
}
bool cACTION_BML_GET_VAP_LIST_CREDENTIALS_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_GET_VAP_LIST_CREDENTIALS_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint32_t); // result
return class_size;
}
bool cACTION_BML_GET_VAP_LIST_CREDENTIALS_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_result = (uint32_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint32_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint32_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_STEERING_SET_GROUP_REQUEST::cACTION_BML_STEERING_SET_GROUP_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_STEERING_SET_GROUP_REQUEST::cACTION_BML_STEERING_SET_GROUP_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_STEERING_SET_GROUP_REQUEST::~cACTION_BML_STEERING_SET_GROUP_REQUEST() {
}
uint32_t& cACTION_BML_STEERING_SET_GROUP_REQUEST::steeringGroupIndex() {
return (uint32_t&)(*m_steeringGroupIndex);
}
sSteeringApConfig& cACTION_BML_STEERING_SET_GROUP_REQUEST::cfg_2() {
return (sSteeringApConfig&)(*m_cfg_2);
}
sSteeringApConfig& cACTION_BML_STEERING_SET_GROUP_REQUEST::cfg_5() {
return (sSteeringApConfig&)(*m_cfg_5);
}
uint8_t& cACTION_BML_STEERING_SET_GROUP_REQUEST::remove() {
return (uint8_t&)(*m_remove);
}
void cACTION_BML_STEERING_SET_GROUP_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
tlvf_swap(32, reinterpret_cast<uint8_t*>(m_steeringGroupIndex));
m_cfg_2->struct_swap();
m_cfg_5->struct_swap();
}
bool cACTION_BML_STEERING_SET_GROUP_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_STEERING_SET_GROUP_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint32_t); // steeringGroupIndex
class_size += sizeof(sSteeringApConfig); // cfg_2
class_size += sizeof(sSteeringApConfig); // cfg_5
class_size += sizeof(uint8_t); // remove
return class_size;
}
bool cACTION_BML_STEERING_SET_GROUP_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_steeringGroupIndex = (uint32_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint32_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint32_t) << ") Failed!";
return false;
}
m_cfg_2 = (sSteeringApConfig*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(sSteeringApConfig))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sSteeringApConfig) << ") Failed!";
return false;
}
if (!m_parse__) { m_cfg_2->struct_init(); }
m_cfg_5 = (sSteeringApConfig*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(sSteeringApConfig))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sSteeringApConfig) << ") Failed!";
return false;
}
if (!m_parse__) { m_cfg_5->struct_init(); }
m_remove = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_STEERING_SET_GROUP_RESPONSE::cACTION_BML_STEERING_SET_GROUP_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_STEERING_SET_GROUP_RESPONSE::cACTION_BML_STEERING_SET_GROUP_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_STEERING_SET_GROUP_RESPONSE::~cACTION_BML_STEERING_SET_GROUP_RESPONSE() {
}
int32_t& cACTION_BML_STEERING_SET_GROUP_RESPONSE::error_code() {
return (int32_t&)(*m_error_code);
}
void cACTION_BML_STEERING_SET_GROUP_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
tlvf_swap(32, reinterpret_cast<uint8_t*>(m_error_code));
}
bool cACTION_BML_STEERING_SET_GROUP_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_STEERING_SET_GROUP_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(int32_t); // error_code
return class_size;
}
bool cACTION_BML_STEERING_SET_GROUP_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_error_code = (int32_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(int32_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(int32_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_STEERING_CLIENT_SET_REQUEST::cACTION_BML_STEERING_CLIENT_SET_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_STEERING_CLIENT_SET_REQUEST::cACTION_BML_STEERING_CLIENT_SET_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_STEERING_CLIENT_SET_REQUEST::~cACTION_BML_STEERING_CLIENT_SET_REQUEST() {
}
uint32_t& cACTION_BML_STEERING_CLIENT_SET_REQUEST::steeringGroupIndex() {
return (uint32_t&)(*m_steeringGroupIndex);
}
sMacAddr& cACTION_BML_STEERING_CLIENT_SET_REQUEST::bssid() {
return (sMacAddr&)(*m_bssid);
}
sMacAddr& cACTION_BML_STEERING_CLIENT_SET_REQUEST::client_mac() {
return (sMacAddr&)(*m_client_mac);
}
sSteeringClientConfig& cACTION_BML_STEERING_CLIENT_SET_REQUEST::config() {
return (sSteeringClientConfig&)(*m_config);
}
uint8_t& cACTION_BML_STEERING_CLIENT_SET_REQUEST::remove() {
return (uint8_t&)(*m_remove);
}
void cACTION_BML_STEERING_CLIENT_SET_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
tlvf_swap(32, reinterpret_cast<uint8_t*>(m_steeringGroupIndex));
m_bssid->struct_swap();
m_client_mac->struct_swap();
m_config->struct_swap();
}
bool cACTION_BML_STEERING_CLIENT_SET_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_STEERING_CLIENT_SET_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint32_t); // steeringGroupIndex
class_size += sizeof(sMacAddr); // bssid
class_size += sizeof(sMacAddr); // client_mac
class_size += sizeof(sSteeringClientConfig); // config
class_size += sizeof(uint8_t); // remove
return class_size;
}
bool cACTION_BML_STEERING_CLIENT_SET_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_steeringGroupIndex = (uint32_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint32_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint32_t) << ") Failed!";
return false;
}
m_bssid = (sMacAddr*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(sMacAddr))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sMacAddr) << ") Failed!";
return false;
}
if (!m_parse__) { m_bssid->struct_init(); }
m_client_mac = (sMacAddr*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(sMacAddr))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sMacAddr) << ") Failed!";
return false;
}
if (!m_parse__) { m_client_mac->struct_init(); }
m_config = (sSteeringClientConfig*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(sSteeringClientConfig))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sSteeringClientConfig) << ") Failed!";
return false;
}
if (!m_parse__) { m_config->struct_init(); }
m_remove = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_STEERING_CLIENT_SET_RESPONSE::cACTION_BML_STEERING_CLIENT_SET_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_STEERING_CLIENT_SET_RESPONSE::cACTION_BML_STEERING_CLIENT_SET_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_STEERING_CLIENT_SET_RESPONSE::~cACTION_BML_STEERING_CLIENT_SET_RESPONSE() {
}
int32_t& cACTION_BML_STEERING_CLIENT_SET_RESPONSE::error_code() {
return (int32_t&)(*m_error_code);
}
void cACTION_BML_STEERING_CLIENT_SET_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
tlvf_swap(32, reinterpret_cast<uint8_t*>(m_error_code));
}
bool cACTION_BML_STEERING_CLIENT_SET_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_STEERING_CLIENT_SET_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(int32_t); // error_code
return class_size;
}
bool cACTION_BML_STEERING_CLIENT_SET_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_error_code = (int32_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(int32_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(int32_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_STEERING_EVENT_REGISTER_UNREGISTER_REQUEST::cACTION_BML_STEERING_EVENT_REGISTER_UNREGISTER_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_STEERING_EVENT_REGISTER_UNREGISTER_REQUEST::cACTION_BML_STEERING_EVENT_REGISTER_UNREGISTER_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_STEERING_EVENT_REGISTER_UNREGISTER_REQUEST::~cACTION_BML_STEERING_EVENT_REGISTER_UNREGISTER_REQUEST() {
}
uint8_t& cACTION_BML_STEERING_EVENT_REGISTER_UNREGISTER_REQUEST::unregister() {
return (uint8_t&)(*m_unregister);
}
void cACTION_BML_STEERING_EVENT_REGISTER_UNREGISTER_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_STEERING_EVENT_REGISTER_UNREGISTER_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_STEERING_EVENT_REGISTER_UNREGISTER_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint8_t); // unregister
return class_size;
}
bool cACTION_BML_STEERING_EVENT_REGISTER_UNREGISTER_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_unregister = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_STEERING_EVENT_REGISTER_UNREGISTER_RESPONSE::cACTION_BML_STEERING_EVENT_REGISTER_UNREGISTER_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_STEERING_EVENT_REGISTER_UNREGISTER_RESPONSE::cACTION_BML_STEERING_EVENT_REGISTER_UNREGISTER_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_STEERING_EVENT_REGISTER_UNREGISTER_RESPONSE::~cACTION_BML_STEERING_EVENT_REGISTER_UNREGISTER_RESPONSE() {
}
int32_t& cACTION_BML_STEERING_EVENT_REGISTER_UNREGISTER_RESPONSE::error_code() {
return (int32_t&)(*m_error_code);
}
void cACTION_BML_STEERING_EVENT_REGISTER_UNREGISTER_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
tlvf_swap(32, reinterpret_cast<uint8_t*>(m_error_code));
}
bool cACTION_BML_STEERING_EVENT_REGISTER_UNREGISTER_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_STEERING_EVENT_REGISTER_UNREGISTER_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(int32_t); // error_code
return class_size;
}
bool cACTION_BML_STEERING_EVENT_REGISTER_UNREGISTER_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_error_code = (int32_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(int32_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(int32_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_STEERING_CLIENT_DISCONNECT_REQUEST::cACTION_BML_STEERING_CLIENT_DISCONNECT_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_STEERING_CLIENT_DISCONNECT_REQUEST::cACTION_BML_STEERING_CLIENT_DISCONNECT_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_STEERING_CLIENT_DISCONNECT_REQUEST::~cACTION_BML_STEERING_CLIENT_DISCONNECT_REQUEST() {
}
uint32_t& cACTION_BML_STEERING_CLIENT_DISCONNECT_REQUEST::steeringGroupIndex() {
return (uint32_t&)(*m_steeringGroupIndex);
}
sMacAddr& cACTION_BML_STEERING_CLIENT_DISCONNECT_REQUEST::bssid() {
return (sMacAddr&)(*m_bssid);
}
sMacAddr& cACTION_BML_STEERING_CLIENT_DISCONNECT_REQUEST::client_mac() {
return (sMacAddr&)(*m_client_mac);
}
eDisconnectType& cACTION_BML_STEERING_CLIENT_DISCONNECT_REQUEST::type() {
return (eDisconnectType&)(*m_type);
}
uint32_t& cACTION_BML_STEERING_CLIENT_DISCONNECT_REQUEST::reason() {
return (uint32_t&)(*m_reason);
}
void cACTION_BML_STEERING_CLIENT_DISCONNECT_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
tlvf_swap(32, reinterpret_cast<uint8_t*>(m_steeringGroupIndex));
m_bssid->struct_swap();
m_client_mac->struct_swap();
tlvf_swap(8*sizeof(eDisconnectType), reinterpret_cast<uint8_t*>(m_type));
tlvf_swap(32, reinterpret_cast<uint8_t*>(m_reason));
}
bool cACTION_BML_STEERING_CLIENT_DISCONNECT_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_STEERING_CLIENT_DISCONNECT_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint32_t); // steeringGroupIndex
class_size += sizeof(sMacAddr); // bssid
class_size += sizeof(sMacAddr); // client_mac
class_size += sizeof(eDisconnectType); // type
class_size += sizeof(uint32_t); // reason
return class_size;
}
bool cACTION_BML_STEERING_CLIENT_DISCONNECT_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_steeringGroupIndex = (uint32_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint32_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint32_t) << ") Failed!";
return false;
}
m_bssid = (sMacAddr*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(sMacAddr))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sMacAddr) << ") Failed!";
return false;
}
if (!m_parse__) { m_bssid->struct_init(); }
m_client_mac = (sMacAddr*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(sMacAddr))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sMacAddr) << ") Failed!";
return false;
}
if (!m_parse__) { m_client_mac->struct_init(); }
m_type = (eDisconnectType*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(eDisconnectType))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(eDisconnectType) << ") Failed!";
return false;
}
m_reason = (uint32_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint32_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint32_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_STEERING_CLIENT_DISCONNECT_RESPONSE::cACTION_BML_STEERING_CLIENT_DISCONNECT_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_STEERING_CLIENT_DISCONNECT_RESPONSE::cACTION_BML_STEERING_CLIENT_DISCONNECT_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_STEERING_CLIENT_DISCONNECT_RESPONSE::~cACTION_BML_STEERING_CLIENT_DISCONNECT_RESPONSE() {
}
int32_t& cACTION_BML_STEERING_CLIENT_DISCONNECT_RESPONSE::error_code() {
return (int32_t&)(*m_error_code);
}
void cACTION_BML_STEERING_CLIENT_DISCONNECT_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
tlvf_swap(32, reinterpret_cast<uint8_t*>(m_error_code));
}
bool cACTION_BML_STEERING_CLIENT_DISCONNECT_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_STEERING_CLIENT_DISCONNECT_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(int32_t); // error_code
return class_size;
}
bool cACTION_BML_STEERING_CLIENT_DISCONNECT_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_error_code = (int32_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(int32_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(int32_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_STEERING_CLIENT_MEASURE_REQUEST::cACTION_BML_STEERING_CLIENT_MEASURE_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_STEERING_CLIENT_MEASURE_REQUEST::cACTION_BML_STEERING_CLIENT_MEASURE_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_STEERING_CLIENT_MEASURE_REQUEST::~cACTION_BML_STEERING_CLIENT_MEASURE_REQUEST() {
}
uint32_t& cACTION_BML_STEERING_CLIENT_MEASURE_REQUEST::steeringGroupIndex() {
return (uint32_t&)(*m_steeringGroupIndex);
}
sMacAddr& cACTION_BML_STEERING_CLIENT_MEASURE_REQUEST::bssid() {
return (sMacAddr&)(*m_bssid);
}
sMacAddr& cACTION_BML_STEERING_CLIENT_MEASURE_REQUEST::client_mac() {
return (sMacAddr&)(*m_client_mac);
}
void cACTION_BML_STEERING_CLIENT_MEASURE_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
tlvf_swap(32, reinterpret_cast<uint8_t*>(m_steeringGroupIndex));
m_bssid->struct_swap();
m_client_mac->struct_swap();
}
bool cACTION_BML_STEERING_CLIENT_MEASURE_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_STEERING_CLIENT_MEASURE_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint32_t); // steeringGroupIndex
class_size += sizeof(sMacAddr); // bssid
class_size += sizeof(sMacAddr); // client_mac
return class_size;
}
bool cACTION_BML_STEERING_CLIENT_MEASURE_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_steeringGroupIndex = (uint32_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint32_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint32_t) << ") Failed!";
return false;
}
m_bssid = (sMacAddr*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(sMacAddr))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sMacAddr) << ") Failed!";
return false;
}
if (!m_parse__) { m_bssid->struct_init(); }
m_client_mac = (sMacAddr*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(sMacAddr))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sMacAddr) << ") Failed!";
return false;
}
if (!m_parse__) { m_client_mac->struct_init(); }
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_STEERING_CLIENT_MEASURE_RESPONSE::cACTION_BML_STEERING_CLIENT_MEASURE_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_STEERING_CLIENT_MEASURE_RESPONSE::cACTION_BML_STEERING_CLIENT_MEASURE_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_STEERING_CLIENT_MEASURE_RESPONSE::~cACTION_BML_STEERING_CLIENT_MEASURE_RESPONSE() {
}
int32_t& cACTION_BML_STEERING_CLIENT_MEASURE_RESPONSE::error_code() {
return (int32_t&)(*m_error_code);
}
void cACTION_BML_STEERING_CLIENT_MEASURE_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
tlvf_swap(32, reinterpret_cast<uint8_t*>(m_error_code));
}
bool cACTION_BML_STEERING_CLIENT_MEASURE_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_STEERING_CLIENT_MEASURE_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(int32_t); // error_code
return class_size;
}
bool cACTION_BML_STEERING_CLIENT_MEASURE_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_error_code = (int32_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(int32_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(int32_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_STEERING_EVENTS_UPDATE::cACTION_BML_STEERING_EVENTS_UPDATE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_STEERING_EVENTS_UPDATE::cACTION_BML_STEERING_EVENTS_UPDATE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_STEERING_EVENTS_UPDATE::~cACTION_BML_STEERING_EVENTS_UPDATE() {
}
uint32_t& cACTION_BML_STEERING_EVENTS_UPDATE::buffer_size() {
return (uint32_t&)(*m_buffer_size);
}
std::string cACTION_BML_STEERING_EVENTS_UPDATE::buffer_str() {
char *buffer_ = buffer();
if (!buffer_) { return std::string(); }
return std::string(buffer_, m_buffer_idx__);
}
char* cACTION_BML_STEERING_EVENTS_UPDATE::buffer(size_t length) {
if( (m_buffer_idx__ == 0) || (m_buffer_idx__ < length) ) {
TLVF_LOG(ERROR) << "buffer length is smaller than requested length";
return nullptr;
}
return ((char*)m_buffer);
}
bool cACTION_BML_STEERING_EVENTS_UPDATE::set_buffer(const std::string& str) { return set_buffer(str.c_str(), str.size()); }
bool cACTION_BML_STEERING_EVENTS_UPDATE::set_buffer(const char str[], size_t size) {
if (str == nullptr) {
TLVF_LOG(WARNING) << "set_buffer received a null pointer.";
return false;
}
if (!alloc_buffer(size)) { return false; }
std::copy(str, str + size, m_buffer);
return true;
}
bool cACTION_BML_STEERING_EVENTS_UPDATE::alloc_buffer(size_t count) {
if (m_lock_order_counter__ > 0) {;
TLVF_LOG(ERROR) << "Out of order allocation for variable length list buffer, abort!";
return false;
}
size_t len = sizeof(char) * count;
if(getBuffRemainingBytes() < len ) {
TLVF_LOG(ERROR) << "Not enough available space on buffer - can't allocate";
return false;
}
m_lock_order_counter__ = 0;
uint8_t *src = (uint8_t *)&m_buffer[*m_buffer_size];
uint8_t *dst = src + len;
if (!m_parse__) {
size_t move_length = getBuffRemainingBytes(src) - len;
std::copy_n(src, move_length, dst);
}
m_buffer_idx__ += count;
*m_buffer_size += count;
if (!buffPtrIncrementSafe(len)) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << len << ") Failed!";
return false;
}
return true;
}
void cACTION_BML_STEERING_EVENTS_UPDATE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
tlvf_swap(32, reinterpret_cast<uint8_t*>(m_buffer_size));
}
bool cACTION_BML_STEERING_EVENTS_UPDATE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_STEERING_EVENTS_UPDATE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint32_t); // buffer_size
return class_size;
}
bool cACTION_BML_STEERING_EVENTS_UPDATE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_buffer_size = (uint32_t*)m_buff_ptr__;
if (!m_parse__) *m_buffer_size = 0;
if (!buffPtrIncrementSafe(sizeof(uint32_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint32_t) << ") Failed!";
return false;
}
m_buffer = (char*)m_buff_ptr__;
uint32_t buffer_size = *m_buffer_size;
if (m_parse__) { tlvf_swap(32, reinterpret_cast<uint8_t*>(&buffer_size)); }
m_buffer_idx__ = buffer_size;
if (!buffPtrIncrementSafe(sizeof(char) * (buffer_size))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(char) * (buffer_size) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_TRIGGER_TOPOLOGY_QUERY::cACTION_BML_TRIGGER_TOPOLOGY_QUERY(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_TRIGGER_TOPOLOGY_QUERY::cACTION_BML_TRIGGER_TOPOLOGY_QUERY(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_TRIGGER_TOPOLOGY_QUERY::~cACTION_BML_TRIGGER_TOPOLOGY_QUERY() {
}
sMacAddr& cACTION_BML_TRIGGER_TOPOLOGY_QUERY::al_mac() {
return (sMacAddr&)(*m_al_mac);
}
void cACTION_BML_TRIGGER_TOPOLOGY_QUERY::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
m_al_mac->struct_swap();
}
bool cACTION_BML_TRIGGER_TOPOLOGY_QUERY::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_TRIGGER_TOPOLOGY_QUERY::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(sMacAddr); // al_mac
return class_size;
}
bool cACTION_BML_TRIGGER_TOPOLOGY_QUERY::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_al_mac = (sMacAddr*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(sMacAddr))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sMacAddr) << ") Failed!";
return false;
}
if (!m_parse__) { m_al_mac->struct_init(); }
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_TRIGGER_CHANNEL_SELECTION_REQUEST::cACTION_BML_TRIGGER_CHANNEL_SELECTION_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_TRIGGER_CHANNEL_SELECTION_REQUEST::cACTION_BML_TRIGGER_CHANNEL_SELECTION_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_TRIGGER_CHANNEL_SELECTION_REQUEST::~cACTION_BML_TRIGGER_CHANNEL_SELECTION_REQUEST() {
}
sMacAddr& cACTION_BML_TRIGGER_CHANNEL_SELECTION_REQUEST::al_mac() {
return (sMacAddr&)(*m_al_mac);
}
sMacAddr& cACTION_BML_TRIGGER_CHANNEL_SELECTION_REQUEST::ruid() {
return (sMacAddr&)(*m_ruid);
}
void cACTION_BML_TRIGGER_CHANNEL_SELECTION_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
m_al_mac->struct_swap();
m_ruid->struct_swap();
}
bool cACTION_BML_TRIGGER_CHANNEL_SELECTION_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_TRIGGER_CHANNEL_SELECTION_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(sMacAddr); // al_mac
class_size += sizeof(sMacAddr); // ruid
return class_size;
}
bool cACTION_BML_TRIGGER_CHANNEL_SELECTION_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_al_mac = (sMacAddr*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(sMacAddr))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sMacAddr) << ") Failed!";
return false;
}
if (!m_parse__) { m_al_mac->struct_init(); }
m_ruid = (sMacAddr*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(sMacAddr))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sMacAddr) << ") Failed!";
return false;
}
if (!m_parse__) { m_ruid->struct_init(); }
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_REQUEST::cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_REQUEST::cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_REQUEST::~cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_REQUEST() {
}
sMacAddr& cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_REQUEST::radio_mac() {
return (sMacAddr&)(*m_radio_mac);
}
sChannelScanRequestParams& cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_REQUEST::params() {
return (sChannelScanRequestParams&)(*m_params);
}
void cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
m_radio_mac->struct_swap();
m_params->struct_swap();
}
bool cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(sMacAddr); // radio_mac
class_size += sizeof(sChannelScanRequestParams); // params
return class_size;
}
bool cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_radio_mac = (sMacAddr*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(sMacAddr))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sMacAddr) << ") Failed!";
return false;
}
if (!m_parse__) { m_radio_mac->struct_init(); }
m_params = (sChannelScanRequestParams*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(sChannelScanRequestParams))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sChannelScanRequestParams) << ") Failed!";
return false;
}
if (!m_parse__) { m_params->struct_init(); }
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_RESPONSE::cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_RESPONSE::cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_RESPONSE::~cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_RESPONSE() {
}
uint8_t& cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_RESPONSE::op_error_code() {
return (uint8_t&)(*m_op_error_code);
}
void cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint8_t); // op_error_code
return class_size;
}
bool cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_op_error_code = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_REQUEST::cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_REQUEST::cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_REQUEST::~cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_REQUEST() {
}
sMacAddr& cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_REQUEST::radio_mac() {
return (sMacAddr&)(*m_radio_mac);
}
void cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
m_radio_mac->struct_swap();
}
bool cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(sMacAddr); // radio_mac
return class_size;
}
bool cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_radio_mac = (sMacAddr*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(sMacAddr))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sMacAddr) << ") Failed!";
return false;
}
if (!m_parse__) { m_radio_mac->struct_init(); }
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_RESPONSE::cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_RESPONSE::cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_RESPONSE::~cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_RESPONSE() {
}
sChannelScanRequestParams& cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_RESPONSE::params() {
return (sChannelScanRequestParams&)(*m_params);
}
void cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
m_params->struct_swap();
}
bool cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(sChannelScanRequestParams); // params
return class_size;
}
bool cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_params = (sChannelScanRequestParams*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(sChannelScanRequestParams))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sChannelScanRequestParams) << ") Failed!";
return false;
}
if (!m_parse__) { m_params->struct_init(); }
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_REQUEST::cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_REQUEST::cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_REQUEST::~cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_REQUEST() {
}
sMacAddr& cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_REQUEST::radio_mac() {
return (sMacAddr&)(*m_radio_mac);
}
uint8_t& cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_REQUEST::isEnable() {
return (uint8_t&)(*m_isEnable);
}
void cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
m_radio_mac->struct_swap();
}
bool cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(sMacAddr); // radio_mac
class_size += sizeof(uint8_t); // isEnable
return class_size;
}
bool cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_radio_mac = (sMacAddr*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(sMacAddr))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sMacAddr) << ") Failed!";
return false;
}
if (!m_parse__) { m_radio_mac->struct_init(); }
m_isEnable = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_RESPONSE::cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_RESPONSE::cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_RESPONSE::~cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_RESPONSE() {
}
uint8_t& cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_RESPONSE::op_error_code() {
return (uint8_t&)(*m_op_error_code);
}
void cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint8_t); // op_error_code
return class_size;
}
bool cACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_op_error_code = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_REQUEST::cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_REQUEST::cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_REQUEST::~cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_REQUEST() {
}
sMacAddr& cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_REQUEST::radio_mac() {
return (sMacAddr&)(*m_radio_mac);
}
void cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
m_radio_mac->struct_swap();
}
bool cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(sMacAddr); // radio_mac
return class_size;
}
bool cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_radio_mac = (sMacAddr*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(sMacAddr))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sMacAddr) << ") Failed!";
return false;
}
if (!m_parse__) { m_radio_mac->struct_init(); }
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_RESPONSE::cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_RESPONSE::cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_RESPONSE::~cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_RESPONSE() {
}
uint8_t& cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_RESPONSE::isEnable() {
return (uint8_t&)(*m_isEnable);
}
void cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint8_t); // isEnable
return class_size;
}
bool cACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_isEnable = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_CHANNEL_SCAN_START_SCAN_REQUEST::cACTION_BML_CHANNEL_SCAN_START_SCAN_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_START_SCAN_REQUEST::cACTION_BML_CHANNEL_SCAN_START_SCAN_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_START_SCAN_REQUEST::~cACTION_BML_CHANNEL_SCAN_START_SCAN_REQUEST() {
}
sTriggerChannelScanParams& cACTION_BML_CHANNEL_SCAN_START_SCAN_REQUEST::scan_params() {
return (sTriggerChannelScanParams&)(*m_scan_params);
}
void cACTION_BML_CHANNEL_SCAN_START_SCAN_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
m_scan_params->struct_swap();
}
bool cACTION_BML_CHANNEL_SCAN_START_SCAN_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_CHANNEL_SCAN_START_SCAN_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(sTriggerChannelScanParams); // scan_params
return class_size;
}
bool cACTION_BML_CHANNEL_SCAN_START_SCAN_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_scan_params = (sTriggerChannelScanParams*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(sTriggerChannelScanParams))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sTriggerChannelScanParams) << ") Failed!";
return false;
}
if (!m_parse__) { m_scan_params->struct_init(); }
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_CHANNEL_SCAN_START_SCAN_RESPONSE::cACTION_BML_CHANNEL_SCAN_START_SCAN_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_START_SCAN_RESPONSE::cACTION_BML_CHANNEL_SCAN_START_SCAN_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_START_SCAN_RESPONSE::~cACTION_BML_CHANNEL_SCAN_START_SCAN_RESPONSE() {
}
uint8_t& cACTION_BML_CHANNEL_SCAN_START_SCAN_RESPONSE::op_error_code() {
return (uint8_t&)(*m_op_error_code);
}
void cACTION_BML_CHANNEL_SCAN_START_SCAN_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_CHANNEL_SCAN_START_SCAN_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_CHANNEL_SCAN_START_SCAN_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint8_t); // op_error_code
return class_size;
}
bool cACTION_BML_CHANNEL_SCAN_START_SCAN_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_op_error_code = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_CHANNEL_SCAN_GET_RESULTS_REQUEST::cACTION_BML_CHANNEL_SCAN_GET_RESULTS_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_GET_RESULTS_REQUEST::cACTION_BML_CHANNEL_SCAN_GET_RESULTS_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_GET_RESULTS_REQUEST::~cACTION_BML_CHANNEL_SCAN_GET_RESULTS_REQUEST() {
}
sMacAddr& cACTION_BML_CHANNEL_SCAN_GET_RESULTS_REQUEST::radio_mac() {
return (sMacAddr&)(*m_radio_mac);
}
uint8_t& cACTION_BML_CHANNEL_SCAN_GET_RESULTS_REQUEST::scan_mode() {
return (uint8_t&)(*m_scan_mode);
}
void cACTION_BML_CHANNEL_SCAN_GET_RESULTS_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
m_radio_mac->struct_swap();
}
bool cACTION_BML_CHANNEL_SCAN_GET_RESULTS_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_CHANNEL_SCAN_GET_RESULTS_REQUEST::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(sMacAddr); // radio_mac
class_size += sizeof(uint8_t); // scan_mode
return class_size;
}
bool cACTION_BML_CHANNEL_SCAN_GET_RESULTS_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_radio_mac = (sMacAddr*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(sMacAddr))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sMacAddr) << ") Failed!";
return false;
}
if (!m_parse__) { m_radio_mac->struct_init(); }
m_scan_mode = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_CHANNEL_SCAN_GET_RESULTS_RESPONSE::cACTION_BML_CHANNEL_SCAN_GET_RESULTS_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_GET_RESULTS_RESPONSE::cACTION_BML_CHANNEL_SCAN_GET_RESULTS_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_GET_RESULTS_RESPONSE::~cACTION_BML_CHANNEL_SCAN_GET_RESULTS_RESPONSE() {
}
uint8_t& cACTION_BML_CHANNEL_SCAN_GET_RESULTS_RESPONSE::result_status() {
return (uint8_t&)(*m_result_status);
}
uint8_t& cACTION_BML_CHANNEL_SCAN_GET_RESULTS_RESPONSE::op_error_code() {
return (uint8_t&)(*m_op_error_code);
}
uint8_t& cACTION_BML_CHANNEL_SCAN_GET_RESULTS_RESPONSE::last() {
return (uint8_t&)(*m_last);
}
uint32_t& cACTION_BML_CHANNEL_SCAN_GET_RESULTS_RESPONSE::results_size() {
return (uint32_t&)(*m_results_size);
}
std::tuple<bool, sChannelScanResults&> cACTION_BML_CHANNEL_SCAN_GET_RESULTS_RESPONSE::results(size_t idx) {
bool ret_success = ( (m_results_idx__ > 0) && (m_results_idx__ > idx) );
size_t ret_idx = ret_success ? idx : 0;
if (!ret_success) {
TLVF_LOG(ERROR) << "Requested index is greater than the number of available entries";
}
return std::forward_as_tuple(ret_success, m_results[ret_idx]);
}
bool cACTION_BML_CHANNEL_SCAN_GET_RESULTS_RESPONSE::alloc_results(size_t count) {
if (m_lock_order_counter__ > 0) {;
TLVF_LOG(ERROR) << "Out of order allocation for variable length list results, abort!";
return false;
}
size_t len = sizeof(sChannelScanResults) * count;
if(getBuffRemainingBytes() < len ) {
TLVF_LOG(ERROR) << "Not enough available space on buffer - can't allocate";
return false;
}
m_lock_order_counter__ = 0;
uint8_t *src = (uint8_t *)&m_results[*m_results_size];
uint8_t *dst = src + len;
if (!m_parse__) {
size_t move_length = getBuffRemainingBytes(src) - len;
std::copy_n(src, move_length, dst);
}
m_results_idx__ += count;
*m_results_size += count;
if (!buffPtrIncrementSafe(len)) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << len << ") Failed!";
return false;
}
if (!m_parse__) {
for (size_t i = m_results_idx__ - count; i < m_results_idx__; i++) { m_results[i].struct_init(); }
}
return true;
}
void cACTION_BML_CHANNEL_SCAN_GET_RESULTS_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
tlvf_swap(32, reinterpret_cast<uint8_t*>(m_results_size));
for (size_t i = 0; i < (size_t)*m_results_size; i++){
m_results[i].struct_swap();
}
}
bool cACTION_BML_CHANNEL_SCAN_GET_RESULTS_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_CHANNEL_SCAN_GET_RESULTS_RESPONSE::get_initial_size()
{
size_t class_size = 0;
class_size += sizeof(uint8_t); // result_status
class_size += sizeof(uint8_t); // op_error_code
class_size += sizeof(uint8_t); // last
class_size += sizeof(uint32_t); // results_size
return class_size;
}
bool cACTION_BML_CHANNEL_SCAN_GET_RESULTS_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
m_result_status = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
m_op_error_code = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
m_last = (uint8_t*)m_buff_ptr__;
if (!buffPtrIncrementSafe(sizeof(uint8_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!";
return false;
}
m_results_size = (uint32_t*)m_buff_ptr__;
if (!m_parse__) *m_results_size = 0;
if (!buffPtrIncrementSafe(sizeof(uint32_t))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint32_t) << ") Failed!";
return false;
}
m_results = (sChannelScanResults*)m_buff_ptr__;
uint32_t results_size = *m_results_size;
if (m_parse__) { tlvf_swap(32, reinterpret_cast<uint8_t*>(&results_size)); }
m_results_idx__ = results_size;
if (!buffPtrIncrementSafe(sizeof(sChannelScanResults) * (results_size))) {
LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sChannelScanResults) * (results_size) << ") Failed!";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_CHANNEL_SCAN_DUMP_RESULTS_REQUEST::cACTION_BML_CHANNEL_SCAN_DUMP_RESULTS_REQUEST(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_DUMP_RESULTS_REQUEST::cACTION_BML_CHANNEL_SCAN_DUMP_RESULTS_REQUEST(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_DUMP_RESULTS_REQUEST::~cACTION_BML_CHANNEL_SCAN_DUMP_RESULTS_REQUEST() {
}
void cACTION_BML_CHANNEL_SCAN_DUMP_RESULTS_REQUEST::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_CHANNEL_SCAN_DUMP_RESULTS_REQUEST::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_CHANNEL_SCAN_DUMP_RESULTS_REQUEST::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_CHANNEL_SCAN_DUMP_RESULTS_REQUEST::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
cACTION_BML_CHANNEL_SCAN_DUMP_RESULTS_RESPONSE::cACTION_BML_CHANNEL_SCAN_DUMP_RESULTS_RESPONSE(uint8_t* buff, size_t buff_len, bool parse) :
BaseClass(buff, buff_len, parse) {
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_DUMP_RESULTS_RESPONSE::cACTION_BML_CHANNEL_SCAN_DUMP_RESULTS_RESPONSE(std::shared_ptr<BaseClass> base, bool parse) :
BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){
m_init_succeeded = init();
}
cACTION_BML_CHANNEL_SCAN_DUMP_RESULTS_RESPONSE::~cACTION_BML_CHANNEL_SCAN_DUMP_RESULTS_RESPONSE() {
}
void cACTION_BML_CHANNEL_SCAN_DUMP_RESULTS_RESPONSE::class_swap()
{
tlvf_swap(8*sizeof(eActionOp_BML), reinterpret_cast<uint8_t*>(m_action_op));
}
bool cACTION_BML_CHANNEL_SCAN_DUMP_RESULTS_RESPONSE::finalize()
{
if (m_parse__) {
TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set";
return true;
}
if (m_finalized__) {
TLVF_LOG(DEBUG) << "finalize() called for already finalized class";
return true;
}
if (!isPostInitSucceeded()) {
TLVF_LOG(ERROR) << "post init check failed";
return false;
}
if (m_inner__) {
if (!m_inner__->finalize()) {
TLVF_LOG(ERROR) << "m_inner__->finalize() failed";
return false;
}
auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength();
m_buff_ptr__ -= tailroom;
}
class_swap();
m_finalized__ = true;
return true;
}
size_t cACTION_BML_CHANNEL_SCAN_DUMP_RESULTS_RESPONSE::get_initial_size()
{
size_t class_size = 0;
return class_size;
}
bool cACTION_BML_CHANNEL_SCAN_DUMP_RESULTS_RESPONSE::init()
{
if (getBuffRemainingBytes() < get_initial_size()) {
TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed";
return false;
}
if (m_parse__) { class_swap(); }
return true;
}
| 33.676833
| 173
| 0.692489
|
ydx-coder
|
1054cbbb09802aa8a6cfaf8670407e54aa96d367
| 3,438
|
hpp
|
C++
|
PathNetwork.hpp
|
jeffreycassidy/osm2bin
|
7a6751d1a5045d8fb260aaa723ae85da193b4c93
|
[
"Apache-2.0"
] | 4
|
2015-10-31T01:33:25.000Z
|
2021-04-29T08:04:51.000Z
|
PathNetwork.hpp
|
jeffreycassidy/osm2bin
|
7a6751d1a5045d8fb260aaa723ae85da193b4c93
|
[
"Apache-2.0"
] | null | null | null |
PathNetwork.hpp
|
jeffreycassidy/osm2bin
|
7a6751d1a5045d8fb260aaa723ae85da193b4c93
|
[
"Apache-2.0"
] | 2
|
2016-06-14T05:05:04.000Z
|
2020-04-11T05:56:39.000Z
|
/*
* PathNetwork.hpp
*
* Created on: Jun 15, 2015
* Author: jcassidy
*/
#ifndef PATHNETWORK_HPP_
#define PATHNETWORK_HPP_
#include <vector>
#include <string>
#include <unordered_map>
#include <boost/range/algorithm.hpp>
#include <iomanip>
#include <iostream>
#include <boost/container/flat_set.hpp>
#include <unordered_map>
#include <boost/range/algorithm.hpp>
#include <boost/range/adaptor/indexed.hpp>
#include <boost/range/adaptor/map.hpp>
#include <boost/range/adaptor/filtered.hpp>
#include <boost/graph/adjacency_list.hpp>
#include "OSMEntity.hpp"
#include "OSMNode.hpp"
#include "OSMWay.hpp"
#include "KeyValueTable.hpp"
#include "OSMEntityFilter.hpp"
#include "OSMDatabase.hpp"
/** Specialization to pick out roads */
class OSMWayFilterRoads : public OSMEntityFilter<OSMWay> {
public:
OSMWayFilterRoads(const OSMDatabase& db, const std::vector<OSMNode>& nodes) :
OSMEntityFilter<OSMWay>(db),
kvt_(db.wayTags()),
kiName_(db.wayTags().getIndexForKeyString("name")),
kiHighway_(db.wayTags().getIndexForKeyString("highway")) {
for (const char * const *s = includeHighwayTagValueStrings_; *s != nullptr; ++s)
includeHighwayTagValues_.insert(kvt_.getIndexForValueString(*s));
}
virtual bool operator()(const OSMWay& e) const override
{
unsigned vi = e.getValueForKey(kiHighway_);
return vi != -1U && includeHighwayTagValues_.count(vi);
}
private:
const KeyValueTable& kvt_;
unsigned kiName_ = -1U;
unsigned kiHighway_ = -1U;
boost::container::flat_set<unsigned> includeHighwayTagValues_;
static const char * includeHighwayTagValueStrings_[];
};
struct NodeInfo {
OSMID osmid = -1ULL;
LatLon latlon;
private:
friend boost::serialization::access;
template<class Archive>void serialize(Archive& ar, const unsigned ver) {
ar & osmid & latlon;
}
};
struct EdgeProperties {
std::vector<LatLon> curvePoints;
unsigned long long wayOSMID = -1U;
unsigned streetVectorIndex = -1U;
unsigned streetSegmentVectorIndex = -1U; // <=== NOT SERIALIZED! MUST BE REBUILT BY PATHNETWORK
float maxspeed = 50.0;
enum Oneway : uint8_t {
Bidir = 0, ToGreaterVertexNumber = 1, ToLesserVertexNumber = 2
};
Oneway oneWay = Bidir;
private:
friend boost::serialization::access;
template<class Archive>void serialize(Archive& ar, const unsigned ver) {
ar & curvePoints & wayOSMID & streetVectorIndex & maxspeed & oneWay;
}
};
typedef boost::adjacency_list<
boost::vecS, // outedgelist
boost::vecS, // vertex list
boost::undirectedS, // dir/undir/bidir
NodeInfo,
EdgeProperties,
boost::no_property,
boost::vecS> PathNetwork;
#ifdef CLANG
#define STDPAIR std::__1::pair
#else
#define STDPAIR std::pair
#endif
template<class Iterator>Iterator begin(STDPAIR<Iterator, Iterator> p,
typename std::iterator_traits<Iterator>::difference_type __sfinae = 0) {
return p.first;
}
template<class Iterator>Iterator end(STDPAIR<Iterator, Iterator> p,
typename std::iterator_traits<Iterator>::difference_type __sfinae = 0) {
return p.second;
}
PathNetwork buildNetwork(const OSMDatabase& db, const OSMEntityFilter<OSMWay>& wayFilter);
// build street names for network
class OSMDatabase;
std::vector<std::string> assignStreets(OSMDatabase* db, PathNetwork& G);
void nameIntersections(PathNetwork& G);
#endif /* PATHNETWORK_HPP_ */
| 24.557143
| 99
| 0.71466
|
jeffreycassidy
|
1056671f2a48b5c142753ad4c39802c78b639595
| 1,177
|
cpp
|
C++
|
homomorphic_evaluation/ntl-11.3.2/src/ZZVec.cpp
|
dklee0501/PLDI_20_242_artifact_publication
|
f2b73df9165c76e8b521d8ebd639d68321e3862b
|
[
"MIT"
] | 160
|
2016-05-11T09:45:56.000Z
|
2022-03-06T09:32:19.000Z
|
homomorphic_evaluation/ntl-11.3.2/src/ZZVec.cpp
|
dklee0501/Lobster
|
f2b73df9165c76e8b521d8ebd639d68321e3862b
|
[
"MIT"
] | 57
|
2016-12-26T07:02:12.000Z
|
2022-03-06T16:34:31.000Z
|
LibSource/ExtendedNTL/src/ZZVec.cpp
|
ekzyis/CrypTool-2
|
1af234b4f74486fbfeb3b3c49228cc36533a8c89
|
[
"Apache-2.0"
] | 67
|
2016-10-10T17:56:22.000Z
|
2022-03-15T22:56:39.000Z
|
#include <NTL/ZZVec.h>
NTL_START_IMPL
void ZZVec::SetSize(long n, long d)
{
if (n < 0 || d <= 0) LogicError("bad args to ZZVec::SetSize()");
if (v)
LogicError("illegal ZZVec initialization");
if (n == 0) {
len = n;
bsize = d;
return;
}
ZZVec tmp;
tmp.len = 0;
tmp.bsize = d;
tmp.v = (ZZ*) NTL_SNS_MALLOC(n, sizeof(ZZ), 0);
if (!tmp.v) MemoryError();
long i = 0;
long m;
long j;
while (i < n) {
m = ZZ_BlockConstructAlloc(tmp.v[i], d, n-i);
for (j = 1; j < m; j++)
ZZ_BlockConstructSet(tmp.v[i], tmp.v[i+j], j);
i += m;
tmp.len = i;
}
tmp.swap(*this);
}
void ZZVec::kill()
{
long n = len;
long i = 0;
while (i < n) {
long m = ZZ_BlockDestroy(v[i]);
i += m;
}
len = 0;
bsize = 0;
if (v) {
free(v);
v = 0;
}
}
ZZVec& ZZVec::operator=(const ZZVec& a)
{
if (this == &a) return *this;
ZZVec tmp(a);
tmp.swap(*this);
return *this;
}
ZZVec::ZZVec(const ZZVec& a) : v(0), len(0), bsize(0)
{
SetSize(a.len, a.bsize);
long i;
for (i = 0; i < a.len; i++)
v[i] = (a.v)[i];
}
NTL_END_IMPL
| 14.898734
| 67
| 0.487681
|
dklee0501
|
10573532943b08ac912f1d82906e6bddd40aa40d
| 10,649
|
cpp
|
C++
|
program/p2m3/p2m3.cpp
|
Gabriellgpc/Sistemas_Roboticos
|
299fe01b85c3644acb7fa2141d9b095649c5dcef
|
[
"MIT"
] | 4
|
2021-02-06T09:13:54.000Z
|
2021-12-14T20:09:23.000Z
|
program/p2m3/p2m3.cpp
|
Gabriellgpc/Sistemas_Roboticos
|
299fe01b85c3644acb7fa2141d9b095649c5dcef
|
[
"MIT"
] | null | null | null |
program/p2m3/p2m3.cpp
|
Gabriellgpc/Sistemas_Roboticos
|
299fe01b85c3644acb7fa2141d9b095649c5dcef
|
[
"MIT"
] | 1
|
2021-12-30T15:49:42.000Z
|
2021-12-30T15:49:42.000Z
|
#include <gnuplot-iostream.h> //Gnuplot
#include <configSpaceTools.hpp> //Polygon2D, Robot, World, Vector2D, Config
#include <b0RemoteApi.h> //para comunicação com o coppeliaSim via Blue-zero
#include <potentialField.hpp> //PotentialField
#include <utils.hpp> //pioneer_model
#include <kinematicsControllers.hpp> //PathFollowController
#include <iostream> //cout
#include <stdio.h> //printf
#include <cstdio> //FILENAME_MAX, printf
#include <unistd.h> //getcwd
#include <string> //string
#include <thread> //thread
#include <omp.h> //omp_get_wtime()
#include <list> //list
using namespace std;
unsigned int SAMPLES = 200;
double pioneer_radius = 0.52 / 2.0;
unsigned int n_vertices = 8;
#define GetCurrentDir getcwd
#define STOP_TIME 9999 //segundos
void living_plot();
void _init(int argc, char **argv);
b0RemoteApi client("b0RemoteApi_CoppeliaSim-addOn", "b0RemoteApiAddOn");
Robot robot(Config(-3.0, -2.0, M_PI / 4.0), Polygon2D::circle_to_polygon2D(pioneer_radius, n_vertices));
World W(robot);
Config target_conf;
PotentialField pfield;
char cCurrentPath[FILENAME_MAX];
bool is_finished = false;
double v = 0.1;
double K_lin = 0.5;
double K_ang = 1.6;
PathFollowController controller(K_ang, K_lin);
std::list<Config> path;
int main(int argc, char **argv)
{
Config curr_config, ref;
std::thread thr_plot;
std::vector<float> pioneer_pos, pioneer_ori;
std::vector<float> target_pos, target_ori;
int pioneer, leftMotor, rightMotor, target;
float w_r, w_l;
double w, lin_error, ang_error;
target = b0RemoteApi::readInt(client.simxGetObjectHandle("Target", client.simxServiceCall()), 1);
pioneer = b0RemoteApi::readInt(client.simxGetObjectHandle("Pioneer_p3dx", client.simxServiceCall()), 1);
leftMotor = b0RemoteApi::readInt(client.simxGetObjectHandle("Pioneer_p3dx_leftMotor", client.simxServiceCall()), 1);
rightMotor = b0RemoteApi::readInt(client.simxGetObjectHandle("Pioneer_p3dx_rightMotor", client.simxServiceCall()), 1);
//obtendo configuração do target
bool t_pos = b0RemoteApi::readFloatArray(client.simxGetObjectPosition(target, -1, client.simxServiceCall()), target_pos, 1);
bool t_ori = b0RemoteApi::readFloatArray(client.simxGetObjectOrientation(target, -1, client.simxServiceCall()), target_ori, 1);
target_conf = Config(target_pos[0], target_pos[1], target_ori[2]);
bool r_pos = b0RemoteApi::readFloatArray(client.simxGetObjectPosition(pioneer, -1, client.simxServiceCall()), pioneer_pos, 1);
bool r_ori = b0RemoteApi::readFloatArray(client.simxGetObjectOrientation(pioneer, -1, client.simxServiceCall()), pioneer_ori, 1);
curr_config.set_pos(pioneer_pos[0], pioneer_pos[1]);
curr_config.set_theta(pioneer_ori[2]);
W.update_config(curr_config);
_init(argc, argv);
thr_plot = std::thread(living_plot);
double time = 0, start_time = omp_get_wtime();
do
{
time = omp_get_wtime() - start_time;
r_pos = b0RemoteApi::readFloatArray(client.simxGetObjectPosition(pioneer, -1, client.simxServiceCall()), pioneer_pos, 1);
r_ori = b0RemoteApi::readFloatArray(client.simxGetObjectOrientation(pioneer, -1, client.simxServiceCall()), pioneer_ori, 1);
if (!r_pos || !r_ori)
{
std::cout << "Falha ao receber dados do simulador!\n";
continue;
}
curr_config.set_pos(pioneer_pos[0], pioneer_pos[1]);
curr_config.set_theta(pioneer_ori[2]);
W.update_config(curr_config);
if (time > 0.3 && W.check_collision())
{
std::cout << "Colisão detectada!\n";
break;
}
is_finished = controller.step(curr_config, v, w, ref, lin_error, ang_error);
pioneer_model(0.2, w, w_r, w_l);
client.simxSetJointTargetVelocity(rightMotor, w_r, client.simxServiceCall());
client.simxSetJointTargetVelocity(leftMotor, w_l, client.simxServiceCall());
std::cout << "REF = " << ref << " | ";
printf("Angular Error = %lf | Linear Error = %lf \n", ang_error, lin_error);
// client.simxSetJointTargetVelocity(rightMotor, 0.0, client.simxServiceCall());
// client.simxSetJointTargetVelocity(leftMotor, 0.0, client.simxServiceCall());
} while ((time <= STOP_TIME) && (is_finished == false));
client.simxSetJointTargetVelocity(rightMotor, 0.0, client.simxServiceCall());
client.simxSetJointTargetVelocity(leftMotor, 0.0, client.simxServiceCall());
is_finished = true;
std::cout << "Programa encerrando...\n";
thr_plot.join();
std::cout << "Programa encerrado!\n";
client.simxStopSimulation(client.simxServiceCall());
return 0;
}
void _init(int argc, char **argv)
{
if (argc == 3)
{
K_ang = std::atof(argv[1]);
K_lin = std::atof(argv[2]);
printf("Ganho angular = %lf | Ganho linear = %lf\n", K_ang, K_lin);
}
else
{
std::cerr << "Voce pode passar os ganhos do controlador por linha de comando: K_ang K_lin\n";
// printf("Argumentos exigidos: quantidade de pontos em theta e numero de vertices para representar o robo\n");
// printf("exemplo\n./p2m1 200 8\n");
}
Polygon2D obstacle;
/*
bool r = GetCurrentDir(cCurrentPath, sizeof(cCurrentPath));
if (!r)
std::cerr << "Falha ao carregar o cenário!\n";
std::string scene = string(cCurrentPath) + string("/scenes/p2m1_scene.ttt");
client.simxLoadScene(scene.c_str(), client.simxServiceCall());
*/
//Criando obstaculos
{
/* //Exemplo 1
// Octogono
obstacle = Polygon2D::circle_to_polygon2D(1.0, 8);
obstacle = obstacle.translate(-5.7500e-01, -1.7500e-01);
W.add_obstacle(obstacle);
*/
//Exemplo 2
/*
obstacle = Polygon2D::circle_to_polygon2D(1.0, 8);
obstacle = obstacle.translate(-1.1500e+00, +1.4000e+00);
W.add_obstacle(obstacle);
obstacle = Polygon2D::circle_to_polygon2D(1.0, 8);
obstacle = obstacle.translate(+9.2500e-01,+4.9999e-02);
W.add_obstacle(obstacle);
*/
//Exemplo 3
obstacle = Polygon2D::circle_to_polygon2D(1.0, 8);
obstacle = obstacle.translate(+4.9998e-02, +3.2500e-01);
W.add_obstacle(obstacle);
// obstacle = Polygon2D::circle_to_polygon2D(1.0, 8);
// obstacle = obstacle.translate(+3.1000e+00,+9.7500e-01);
// W.add_obstacle(obstacle);
// obstacle = Polygon2D::circle_to_polygon2D(1.0, 8);
// obstacle = obstacle.translate(-3.0750e+00, -2.2500e-01);
// W.add_obstacle(obstacle);
}
double tik, tok;
tik = omp_get_wtime();
W.compute_c_obstacles(SAMPLES);
tok = omp_get_wtime();
client.simxStartSimulation(client.simxServiceCall());
std::cout << "Conectado!\n";
printf("Tempo gasto calcular o espaço de configuração com %d amostras de theta e %ld obstaculos | dt = %lf s\n", SAMPLES, W.get_obstacles().size(), tok - tik);
//Planejamento de rota
pfield.set_space(W);
std::cout << "Computando rota...\n";
tik = omp_get_wtime();
path = pfield.get_planned_path(W.get_robot().get_config(), target_conf, pioneer_radius, 0.001);
tok = omp_get_wtime();
std::cout << "Tempo gasto para computar a rota:" << tok - tik << "s\n";
std::cout << "Numero de pontos:" << path.size() << '\n';
controller.update(K_ang, K_lin, path);
}
void living_plot()
{
std::list<Polygon2D> obstacles = W.get_obstacles();
std::list<Polygon2D> cb_obstacles;
std::vector<double> x_vec, y_vec, z_vec, x_robot, y_robot, z_robot;
std::vector<Config> config_hist;
std::vector<std::tuple<
std::vector<double>,
std::vector<double>>>
pts_obs, pts, pts_path;
Gnuplot gp_work;
Gnuplot gp_curr_config;
auto plots_work = gp_work.plotGroup();
auto plots_curr_config = gp_curr_config.plotGroup();
gp_work << "set title 'Espaço de trabalho'\n";
gp_work << "load 'config_plot2D'\n";
gp_curr_config << "set title 'Espaço de Configuração para o Theta Atual'\n";
gp_curr_config << "load 'config_plot2D'\n";
//ploting obstacles at work space
{
for (auto polygon_it = obstacles.begin(); polygon_it != obstacles.end(); polygon_it++)
{
x_vec.clear();
y_vec.clear();
Polygon2D::polygon_to_vectorsXY(*polygon_it, x_vec, y_vec);
pts_obs.emplace_back(std::make_tuple(x_vec, y_vec));
}
//ploting the planned plath
x_vec.clear();
y_vec.clear();
for (auto p = path.begin(); p != path.end(); p++)
{
x_vec.push_back(p->x());
y_vec.push_back(p->y());
}
pts_path.emplace_back(std::make_tuple(x_vec, y_vec));
}
while (is_finished == false)
{
auto plots_work = gp_work.plotGroup();
auto plots_curr_config = gp_curr_config.plotGroup();
//objs
plots_work.add_plot2d(pts_obs, "with filledcurve fc 'black'");
plots_work.add_plot2d(pts_path, "with line lc 'blue' lt 23");
// plot robot trajectory
config_hist.push_back(W.get_robot().get_config());
x_robot.push_back(W.get_robot().get_config().get_pos().x());
y_robot.push_back(W.get_robot().get_config().get_pos().y());
pts.clear();
pts.emplace_back(std::make_tuple(x_robot, y_robot));
plots_work.add_plot2d(pts, "with line lc 'red' lw 1");
//plot current position only
x_vec.clear();
y_vec.clear();
Polygon2D::polygon_to_vectorsXY(W.get_robot().to_polygon2D(), x_vec, y_vec);
pts.clear();
pts.emplace_back(std::make_tuple(x_vec, y_vec));
plots_work.add_plot2d(pts, "with line lc'red'");
//plot config space
pts.clear();
cb_obstacles = W.get_cobstacles(SAMPLES);
for (auto cb_it = cb_obstacles.begin(); cb_it != cb_obstacles.end(); cb_it++)
{
x_vec.clear();
y_vec.clear();
Polygon2D::polygon_to_vectorsXY(*cb_it, x_vec, y_vec);
pts.emplace_back(std::make_tuple(x_vec, y_vec));
}
plots_curr_config.add_plot2d(pts, "with filledcurve fc 'black'");
// robot at config space
pts.clear();
pts.emplace_back(std::make_tuple(x_robot, y_robot));
plots_curr_config.add_plot2d(pts, "with linespoints lc 'red' lt 7 lw 1");
//show plot
gp_work << plots_work;
gp_curr_config << plots_curr_config;
}
std::cout << "Press enter to exit." << std::endl;
std::cin.get();
}
| 37.628975
| 164
| 0.645976
|
Gabriellgpc
|
10583f18bd53129820d3cb50863f519907c790cf
| 8,019
|
cpp
|
C++
|
Chess/Move.cpp
|
jambolo/Chess
|
5c1206fe976336bd240c546457590013685ee2bb
|
[
"MIT"
] | null | null | null |
Chess/Move.cpp
|
jambolo/Chess
|
5c1206fe976336bd240c546457590013685ee2bb
|
[
"MIT"
] | 27
|
2018-12-04T19:52:37.000Z
|
2019-02-03T10:21:02.000Z
|
Chess/Move.cpp
|
jambolo/Chess
|
5c1206fe976336bd240c546457590013685ee2bb
|
[
"MIT"
] | null | null | null |
#include "Move.h"
#include "Move.h"
#include "Piece.h"
#include "Types.h"
#include <cassert>
#include <cstdlib>
Move::Move(Piece const * piece, Position const & from, Position const & to, bool capture /*= false*/)
: piece_(piece)
, from_(from)
, to_(to)
, capture_(capture)
, special_(NORMAL)
{
}
Move::Move(Special special,
Color color /*= Color::INVALID*/,
Position const & from /*= Position()*/,
Position const & to /*= Position()*/,
bool capture /*= false*/)
: from_(from)
, to_(to)
, capture_(capture)
, special_(special)
{
switch (special)
{
case NORMAL: piece_ = nullptr; break;
case RESIGN: piece_ = Piece::get(PieceTypeId::KING, color); break;
case UNDO: piece_ = nullptr; break;
case RESET: piece_ = nullptr; break;
case KINGSIDE_CASTLE: piece_ = Piece::get(PieceTypeId::KING, color); break;
case QUEENSIDE_CASTLE: piece_ = Piece::get(PieceTypeId::KING, color); break;
case PROMOTION: piece_ = Piece::get(PieceTypeId::PAWN, color); break;
case ENPASSANT: piece_ = Piece::get(PieceTypeId::PAWN, color); break;
}
}
bool Move::isMoved(int dr, int dc)
{
return dr != 0 || dc != 0;
}
bool Move::isDiagonal(int dr, int dc)
{
return dr == dc || dr == -dc;
}
bool Move::inRange(int dr, int dc, int range)
{
return dr > range || dr < -range || dc > range || dc < -range;
}
bool Move::isSquare(int dr, int dc)
{
return dr == 0 || dc == 0;
}
std::string Move::notation(Notation notation /*= Notation::STANDARD*/) const
{
std::string result;
switch (notation)
{
case Notation::STANDARD:
result = standardNotation();
break;
case Notation::LONG:
result = longNotation();
break;
case Notation::PGN:
result = pgnNotation();
break;
case Notation::FIGURINE:
result = figurineNotation();
break;
case Notation::ICCF:
result = iccfNotation();
case Notation::UCI:
result = uciNotation();
default:
break;
}
return result;
}
Move Move::kingSideCastleKing(Color c)
{
Piece const * king = Piece::get(PieceTypeId::KING, c);
if (c == Color::WHITE)
return Move(king, { 7, 4 }, { 7, 6 });
else
return Move(king, { 0, 4 }, { 0, 6 });
}
Move Move::kingSideCastleRook(Color c)
{
Piece const * rook = Piece::get(PieceTypeId::ROOK, c);
if (c == Color::WHITE)
return Move(rook, { 7, 7 }, { 7, 5 });
else
return Move(rook, { 0, 7 }, { 0, 5 });
}
Move Move::queenSideCastleKing(Color c)
{
Piece const * king = Piece::get(PieceTypeId::KING, c);
if (c == Color::WHITE)
return Move(king, { 7, 4 }, { 7, 2 });
else
return Move(king, { 0, 4 }, { 0, 2 });
}
Move Move::queenSideCastleRook(Color c)
{
Piece const * rook = Piece::get(PieceTypeId::ROOK, c);
if (c == Color::WHITE)
return Move(rook, { 7, 0 }, { 7, 3 });
else
return Move(rook, { 0, 0 }, { 0, 3 });
}
std::string Move::standardNotation() const
{
std::string result;
if (isKingSideCastle())
{
result = "0-0";
}
else if (isQueenSideCastle())
{
result = "0-0-0";
}
else if (isEnPassant())
{
result += char(from().column + 'a');
result += 'x';
result += to().notation();
}
else if (isResignation())
{
result = (piece_->color() == Color::WHITE) ? "1-0" : "0-1";
}
else
{
PieceTypeId id = piece_->type();
if (id != PieceTypeId::PAWN)
result = Piece::symbol(piece_->type());
if (capture_)
{
if (id == PieceTypeId::PAWN)
result += from().notation()[0];
result += 'x';
}
result += to().notation();
if (isPromotion())
result += "Q";
}
return result;
}
std::string Move::longNotation() const
{
std::string result;
if (isKingSideCastle())
{
result = "0-0";
}
else if (isQueenSideCastle())
{
result = "0-0-0";
}
else if (isEnPassant())
{
result = from().notation();
result += 'x';
result += to().notation();
}
else if (isResignation())
{
result = (piece_->color() == Color::WHITE) ? "1-0" : "0-1";
}
else
{
if (piece_->type() != PieceTypeId::PAWN)
result = Piece::symbol(piece_->type());
result += from().notation();
result += capture_ ? 'x' : '-';
result += to().notation();
if (isPromotion())
result += "Q";
}
return result;
}
std::string Move::pgnNotation() const
{
std::string result;
if (isKingSideCastle())
{
result = "O-O";
}
else if (isQueenSideCastle())
{
result = "O-O-O";
}
else if (isEnPassant())
{
result = from().notation();
result += 'x';
result += to().notation();
}
else if (isResignation())
{
result = (piece_->color() == Color::WHITE) ? "1-0" : "0-1";
}
else
{
PieceTypeId id = piece_->type();
if (id != PieceTypeId::PAWN)
result = Piece::symbol(id);
result += from().notation();
result += capture_ ? 'x' : '-';
result += to().notation();
if (isPromotion())
result += "=Q";
}
return result;
}
std::string Move::figurineNotation() const
{
std::string result;
if (isKingSideCastle())
{
result = "0-0";
}
else if (isQueenSideCastle())
{
result = "0-0-0";
}
else if (isEnPassant())
{
result += char(from().column + 'a');
result += 'x';
result += to().notation();
}
else if (isResignation())
{
result = (piece_->color() == Color::WHITE) ? "1-0" : "0-1";
}
else
{
PieceTypeId id = piece_->type();
if (id != PieceTypeId::PAWN)
result = piece_->figurine();
if (capture_)
{
if (id == PieceTypeId::PAWN)
result += from().notation()[0];
result += 'x';
}
result += to().notation();
if (isPromotion())
result += Piece::figurine(PieceTypeId::QUEEN, piece_->color());
}
return result;
}
std::string Move::iccfNotation() const
{
std::string result;
if (isKingSideCastle())
{
result = (piece_->color() == Color::WHITE) ? "5171" : "5878";
}
else if (isQueenSideCastle())
{
result = (piece_->color() == Color::WHITE) ? "5131" : "5838";
}
else if (isResignation())
{
// nothing
}
else
{
result += from().column + '1';
result += '8' - from().row;
result += to().column + '1';
result += '8' - to().row;
if (isPromotion())
result += '1';
}
return result;
}
std::string Move::uciNotation() const
{
std::string result;
if (isKingSideCastle())
{
result = "0-0";
}
else if (isQueenSideCastle())
{
result = "0-0-0";
}
else if (isEnPassant())
{
result = from().notation();
result += 'x';
result += to().notation();
}
else if (isResignation())
{
result = (piece_->color() == Color::WHITE) ? "1-0" : "0-1";
}
else
{
if (piece_->type() != PieceTypeId::PAWN)
result = Piece::symbol(piece_->type());
result += from().notation();
if (capture_)
result += 'x';
result += to().notation();
if (isPromotion())
result += "Q";
}
return result;
}
| 23.937313
| 101
| 0.485971
|
jambolo
|
105c2c981e2002370fb86bdd661ac64c2238a60e
| 3,954
|
cpp
|
C++
|
modules/mono/utils/path_utils.cpp
|
MattDBell/godot
|
5938466c848becb269f002191901487135e39ce3
|
[
"CC-BY-3.0",
"Apache-2.0",
"MIT"
] | 1
|
2020-04-30T23:05:16.000Z
|
2020-04-30T23:05:16.000Z
|
modules/mono/utils/path_utils.cpp
|
MattDBell/godot
|
5938466c848becb269f002191901487135e39ce3
|
[
"CC-BY-3.0",
"Apache-2.0",
"MIT"
] | null | null | null |
modules/mono/utils/path_utils.cpp
|
MattDBell/godot
|
5938466c848becb269f002191901487135e39ce3
|
[
"CC-BY-3.0",
"Apache-2.0",
"MIT"
] | null | null | null |
/*************************************************************************/
/* path_utils.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */
/* */
/* 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 "path_utils.h"
#include "os/dir_access.h"
#include "os/file_access.h"
#include "os/os.h"
#include "project_settings.h"
#ifdef WINDOWS_ENABLED
#define ENV_PATH_SEP ";"
#else
#define ENV_PATH_SEP ":"
#include <limits.h>
#endif
#include <stdlib.h>
String path_which(const String &p_name) {
#ifdef WINDOWS_ENABLED
Vector<String> exts = OS::get_singleton()->get_environment("PATHEXT").split(ENV_PATH_SEP, false);
#endif
Vector<String> env_path = OS::get_singleton()->get_environment("PATH").split(ENV_PATH_SEP, false);
if (env_path.empty())
return String();
for (int i = 0; i < env_path.size(); i++) {
String p = path_join(env_path[i], p_name);
#ifdef WINDOWS_ENABLED
for (int j = 0; j < exts.size(); j++) {
String p2 = p + exts[j];
if (FileAccess::exists(p2))
return p2;
}
#else
if (FileAccess::exists(p))
return p;
#endif
}
return String();
}
void fix_path(const String &p_path, String &r_out) {
r_out = p_path.replace("\\", "/");
while (true) { // in case of using 2 or more slash
String compare = r_out.replace("//", "/");
if (r_out == compare)
break;
else
r_out = compare;
}
}
bool rel_path_to_abs(const String &p_existing_path, String &r_abs_path) {
#ifdef WINDOWS_ENABLED
CharType ret[_MAX_PATH];
if (_wfullpath(ret, p_existing_path.c_str(), _MAX_PATH)) {
String abspath = String(ret).replace("\\", "/");
int pos = abspath.find(":/");
if (pos != -1) {
r_abs_path = abspath.substr(pos - 1, abspath.length());
} else {
r_abs_path = abspath;
}
return true;
}
#else
char ret[PATH_MAX];
if (realpath(p_existing_path.utf8().get_data(), ret)) {
String retstr;
if (!retstr.parse_utf8(ret)) {
r_abs_path = retstr;
return true;
}
}
#endif
return false;
}
| 35.303571
| 99
| 0.540465
|
MattDBell
|
106200e0bd0f0e4fa61552ec2ca92ff9bd726009
| 2,365
|
cpp
|
C++
|
test/run_emoa.cpp
|
wonderren/public_emoa
|
d40d6543ffa2a7d0efb1141541d685427eee87dc
|
[
"Unlicense"
] | null | null | null |
test/run_emoa.cpp
|
wonderren/public_emoa
|
d40d6543ffa2a7d0efb1141541d685427eee87dc
|
[
"Unlicense"
] | null | null | null |
test/run_emoa.cpp
|
wonderren/public_emoa
|
d40d6543ffa2a7d0efb1141541d685427eee87dc
|
[
"Unlicense"
] | null | null | null |
/*******************************************
* Author: Zhongqiang Richard Ren.
* All Rights Reserved.
*******************************************/
#include "api.hpp"
#include "graph_io.hpp"
#include "debug.hpp"
#include <iostream>
#include <string>
int TestNY3();
void print_help_message();
int main( int argc, char *argv[] ) {
// help
if (argc >= 2) {
std::string arg1 = argv[1];
if (arg1 == "-h" || arg1 == "--help") {
print_help_message();
return 0;
}
}
// get args
for (int i = 0; i < argc; i++){
std::cout << "[INFO] input arg[" << i << "]=" << argv[i] << std::endl;
}
long vo = std::stol(argv[1]);
long vd = std::stol(argv[2]);
double time_limit = std::stod(argv[3]);
int M = std::stoi(argv[4]);
int expected_args = M + 6;
if (argc != expected_args) {
std::cout << "M=" << M << ", expected M+6 (" << expected_args << ") arguments, received " << argc << std::endl;
return -1;
}
// get filenames
std::string result_fname = argv[argc - 1];
std::vector<std::string> input_fnames;
for (int i = 0; i < M; i++) {
input_fnames.push_back(argv[i + 5]);
}
// timer for loading graph files
rzq::basic::SimpleTimer timer;
timer.Start();
rzq::basic::Roadmap g;
{
int status = rzq::basic::ReadRoadmapFromFile(input_fnames, false, &g);
if (status < 0) {
// if return value is less than 0, then error
std::cout << "Error: ReadRoadmapFromFile()" << std::endl;
return -1;
}
}
double load_graph_time = timer.GetDurationSecond();
// do some print and verification to make sure the generated graph is correct.
std::cout << "num_nodes: " << g.GetNumberOfNodes() << std::endl;
std::cout << "num_edges: " << g.GetNumberOfEdges() << std::endl;
std::cout << "cdims: " << g.GetCostDim() << std::endl;
// ######################################### //
// ####### Test 2 - run planner ######### //
// ######################################### //
rzq::search::EMOAResult res;
rzq::search::RunEMOA(&g, vo, vd, time_limit, &res);
rzq::basic::SaveResultToFile(result_fname, load_graph_time, &res);
return 1;
};
void print_help_message () {
std::cout << "./run_emoa (arg1 v_start) (arg2 v_dest) (arg3 time_limit) (arg4 M) (arg5 graph1_path) (arg6 graph2_path) ... ((arg(M+4) graphM_path)) (arg(M+5) result_path)" << std::endl;
}
| 26.875
| 187
| 0.547992
|
wonderren
|
1062814c8f9a47382833651b4f6ee97b85c79616
| 3,896
|
hh
|
C++
|
LiteCore/Storage/RecordEnumerator.hh
|
udkyo/couchbase-lite-core
|
18f3368186875461c49a559705f9a791e31c6fb9
|
[
"Apache-2.0"
] | null | null | null |
LiteCore/Storage/RecordEnumerator.hh
|
udkyo/couchbase-lite-core
|
18f3368186875461c49a559705f9a791e31c6fb9
|
[
"Apache-2.0"
] | null | null | null |
LiteCore/Storage/RecordEnumerator.hh
|
udkyo/couchbase-lite-core
|
18f3368186875461c49a559705f9a791e31c6fb9
|
[
"Apache-2.0"
] | null | null | null |
//
// RecordEnumerator.hh
//
// Copyright (c) 2014 Couchbase, Inc All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#pragma once
#include "Record.hh"
#include <algorithm>
#include <limits.h>
namespace litecore {
class KeyStore;
enum SortOption {
kDescending = -1,
kUnsorted = 0,
kAscending = 1
};
/** KeyStore enumerator/iterator that returns a range of Records.
Usage:
for (auto e=db.enumerate(); e.next(); ) {...}
or
auto e=db.enumerate();
while (e.next()) { ... }
Inside the loop you can treat the enumerator as though it were a Record*, for example
"e->key()".
*/
class RecordEnumerator {
public:
struct Options {
bool includeDeleted = false; ///< Include deleted records?
bool onlyBlobs = false; ///< Only include records which contain linked binary data
bool onlyConflicts = false; ///< Only include records with conflicts
SortOption sortOption = kAscending; ///< Sort order, or unsorted
ContentOption contentOption = kEntireBody; ///< Load record bodies?
Options() { }
};
RecordEnumerator(KeyStore&,
Options options = Options());
RecordEnumerator(KeyStore&,
sequence_t since,
Options options = Options());
RecordEnumerator(RecordEnumerator&& e) noexcept {*this = move(e);}
RecordEnumerator& operator=(RecordEnumerator&& e) noexcept {
_store = e._store;
_impl = move(e._impl);
return *this;
}
/** Advances to the next key/record, returning false when it hits the end.
next() must be called *before* accessing the first record! */
bool next();
/** Stops the enumerator and frees its resources. (You only need to call this if the
destructor might not be called soon enough.) */
void close() noexcept;
/** True if the enumerator is at a record, false if it's at the end. */
bool hasRecord() const FLPURE {return _record.key().buf != nullptr;}
/** The current record. */
const Record& record() const FLPURE {return _record;}
// Can treat an enumerator as a record pointer:
operator const Record*() const FLPURE {return hasRecord() ? &_record : nullptr;}
const Record* operator->() const FLPURE {return hasRecord() ? &_record : nullptr;}
/** Internal implementation of enumerator; each storage type must subclass it. */
class Impl {
public:
virtual ~Impl() =default;
virtual bool next() =0;
virtual bool read(Record&) =0;
};
private:
friend class KeyStore;
RecordEnumerator(const RecordEnumerator&) = delete; // no copying allowed
RecordEnumerator& operator=(const RecordEnumerator&) = delete; // no assignment allowed
KeyStore * _store; // The KeyStore I'm enumerating
Record _record; // Current record
unique_ptr<Impl> _impl; // The storage-specific implementation
};
}
| 36.074074
| 111
| 0.585472
|
udkyo
|
1067689b39767c46042ce443c17c14eaf4946b8b
| 1,247
|
cpp
|
C++
|
lib/winss/event_wrapper.cpp
|
taylorb-microsoft/winss
|
ede93f84a5d9585502db5190f2ec6365858f695a
|
[
"Apache-2.0"
] | 52
|
2017-01-05T23:39:38.000Z
|
2020-06-04T03:00:11.000Z
|
lib/winss/event_wrapper.cpp
|
morganstanley/winss
|
ede93f84a5d9585502db5190f2ec6365858f695a
|
[
"Apache-2.0"
] | 24
|
2017-01-05T05:07:34.000Z
|
2018-03-09T00:50:58.000Z
|
lib/winss/event_wrapper.cpp
|
morganstanley/winss
|
ede93f84a5d9585502db5190f2ec6365858f695a
|
[
"Apache-2.0"
] | 7
|
2016-12-27T20:55:20.000Z
|
2018-03-09T00:32:19.000Z
|
/*
* Copyright 2016-2017 Morgan Stanley
*
* 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 "event_wrapper.hpp"
#include "windows_interface.hpp"
#include "handle_wrapper.hpp"
winss::EventWrapper::EventWrapper() : handle(winss::TrustedHandleWrapper(
WINDOWS.CreateEvent(nullptr, true, false, nullptr), SYNCHRONIZE)) {}
bool winss::EventWrapper::IsSet() const {
return WINDOWS.WaitForSingleObject(handle.GetHandle(), 0) != WAIT_TIMEOUT;
}
bool winss::EventWrapper::Set() {
return WINDOWS.SetEvent(handle.GetHandle());
}
bool winss::EventWrapper::Reset() {
return WINDOWS.ResetEvent(handle.GetHandle());
}
winss::HandleWrapper winss::EventWrapper::GetHandle() const {
return handle.GetHandleWrapper();
}
| 31.974359
| 78
| 0.740978
|
taylorb-microsoft
|
1067b59f92955f4abb3143cf090bbf9beccce792
| 5,146
|
hpp
|
C++
|
libs/ml/include/ml/utilities/min_max_scaler.hpp
|
devjsc/ledger
|
5681480faf6e2aeee577f149c17745d6ab4d4ab3
|
[
"Apache-2.0"
] | 1
|
2019-09-11T09:46:04.000Z
|
2019-09-11T09:46:04.000Z
|
libs/ml/include/ml/utilities/min_max_scaler.hpp
|
devjsc/ledger
|
5681480faf6e2aeee577f149c17745d6ab4d4ab3
|
[
"Apache-2.0"
] | null | null | null |
libs/ml/include/ml/utilities/min_max_scaler.hpp
|
devjsc/ledger
|
5681480faf6e2aeee577f149c17745d6ab4d4ab3
|
[
"Apache-2.0"
] | 1
|
2019-09-19T12:38:46.000Z
|
2019-09-19T12:38:46.000Z
|
#pragma once
//------------------------------------------------------------------------------
//
// Copyright 2018-2019 Fetch.AI Limited
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
//------------------------------------------------------------------------------
#include "core/serializers/base_types.hpp"
#include "math/base_types.hpp"
#include "ml/utilities/scaler.hpp"
namespace fetch {
namespace ml {
namespace utilities {
template <typename TensorType>
class MinMaxScaler : public Scaler<TensorType>
{
public:
using DataType = typename TensorType::Type;
using SizeType = fetch::math::SizeType;
using SizeVector = fetch::math::SizeVector;
MinMaxScaler() = default;
void SetScale(TensorType const &reference_tensor) override;
void SetScale(DataType const &min_val, DataType const &max_val) override;
void Normalise(TensorType const &input_tensor, TensorType &output_tensor) override;
void DeNormalise(TensorType const &input_tensor, TensorType &output_tensor) override;
DataType x_min_ = fetch::math::numeric_max<DataType>();
DataType x_max_ = fetch::math::numeric_lowest<DataType>();
DataType x_range_ = fetch::math::numeric_max<DataType>();
};
/**
* Calculate the min, max, and range for reference data
* @tparam TensorType
* @param reference_tensor
*/
template <typename TensorType>
void MinMaxScaler<TensorType>::SetScale(TensorType const &reference_tensor)
{
SizeType batch_dim = reference_tensor.shape().size() - 1;
// first loop computes min and max
for (std::size_t i = 0; i < reference_tensor.shape(batch_dim); ++i)
{
auto ref_it = reference_tensor.View(i).cbegin();
while (ref_it.is_valid())
{
if (x_min_ > *ref_it)
{
x_min_ = *ref_it;
}
if (x_max_ < *ref_it)
{
x_max_ = *ref_it;
}
++ref_it;
}
}
x_range_ = x_max_ - x_min_;
}
/**
* Normalise data according to previously set reference scale
* @tparam TensorType
* @param input_tensor
* @param output_tensor
*/
template <typename TensorType>
void MinMaxScaler<TensorType>::Normalise(TensorType const &input_tensor, TensorType &output_tensor)
{
output_tensor.Reshape(input_tensor.shape());
SizeType batch_dim = input_tensor.shape().size() - 1;
// apply normalisation to all data according to scale -1, 1
for (std::size_t i = 0; i < input_tensor.shape(batch_dim); ++i)
{
auto in_it = input_tensor.View(i).cbegin();
auto ret_it = output_tensor.View(i).begin();
while (ret_it.is_valid())
{
*ret_it = (*in_it - x_min_) / (x_range_);
++in_it;
++ret_it;
}
}
}
/**
* De normalise according to previously computed scale
* @tparam TensorType
* @param input_tensor
* @param output_tensor
*/
template <typename TensorType>
void MinMaxScaler<TensorType>::DeNormalise(TensorType const &input_tensor,
TensorType & output_tensor)
{
output_tensor.Reshape(input_tensor.shape());
SizeType batch_dim = input_tensor.shape().size() - 1;
// apply normalisation to each feature according to scale -1, 1
for (std::size_t i = 0; i < input_tensor.shape(batch_dim); ++i)
{
auto in_it = input_tensor.View(i).cbegin();
auto ret_it = output_tensor.View(i).begin();
while (ret_it.is_valid())
{
*ret_it = ((*in_it) * x_range_) + x_min_;
++in_it;
++ret_it;
}
}
}
template <typename TensorType>
void MinMaxScaler<TensorType>::SetScale(DataType const &min_val, DataType const &max_val)
{
assert(min_val <= max_val);
x_min_ = min_val;
x_max_ = max_val;
x_range_ = x_max_ - x_min_;
}
} // namespace utilities
} // namespace ml
namespace serializers {
/**
* serializer for MinMaxScaler
* @tparam TensorType
*/
template <typename TensorType, typename D>
struct MapSerializer<ml::utilities::MinMaxScaler<TensorType>, D>
{
using Type = ml::utilities::MinMaxScaler<TensorType>;
using DriverType = D;
static uint8_t const MIN_VAL = 1;
static uint8_t const MAX_VAL = 2;
static uint8_t const RANGE = 3;
template <typename Constructor>
static void Serialize(Constructor &map_constructor, Type const &sp)
{
auto map = map_constructor(3);
map.Append(MIN_VAL, sp.x_min_);
map.Append(MAX_VAL, sp.x_max_);
map.Append(RANGE, sp.x_range_);
}
template <typename MapDeserializer>
static void Deserialize(MapDeserializer &map, Type &sp)
{
map.ExpectKeyGetValue(MIN_VAL, sp.x_min_);
map.ExpectKeyGetValue(MAX_VAL, sp.x_max_);
map.ExpectKeyGetValue(RANGE, sp.x_range_);
}
};
} // namespace serializers
} // namespace fetch
| 28.274725
| 99
| 0.669063
|
devjsc
|
106acee9c927d15a504bc6ce72be475d8b5ca07d
| 34,870
|
cc
|
C++
|
src/libmodelbox/engine/graph.cc
|
fujl/modelbox
|
390541a87318bb6f8a37163668b439e5387f5d9a
|
[
"Apache-2.0"
] | 1
|
2021-12-16T06:53:00.000Z
|
2021-12-16T06:53:00.000Z
|
src/libmodelbox/engine/graph.cc
|
fujl/modelbox
|
390541a87318bb6f8a37163668b439e5387f5d9a
|
[
"Apache-2.0"
] | null | null | null |
src/libmodelbox/engine/graph.cc
|
fujl/modelbox
|
390541a87318bb6f8a37163668b439e5387f5d9a
|
[
"Apache-2.0"
] | 1
|
2021-12-03T06:19:09.000Z
|
2021-12-03T06:19:09.000Z
|
/*
* Copyright 2021 The Modelbox Project 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 "modelbox/graph.h"
#include "modelbox/base/log.h"
#include "modelbox/base/uuid.h"
#include "modelbox/external_data_map.h"
#include "modelbox/graph_checker.h"
#include "modelbox/profiler.h"
#include "scheduler/flow_scheduler.h"
namespace modelbox {
constexpr const char *GRAPH_NODE_TYPE = "type";
constexpr const char *GRAPH_NODE_FLOWUNIT = "flowunit";
constexpr const char *GRAPH_NODE_INPUT = "input";
constexpr const char *GRAPH_NODE_OUTPUT = "output";
constexpr const char *GRAPH_KEY_DEVICE = "device";
constexpr const char *GRAPH_KEY_DEVICE_ID = "deviceid";
constexpr const char *GRAPH_KEY_QUEUE_SIZE = "queue_size";
constexpr const char *GRAPH_KEY_BATCH_SIZE = "batch_size";
constexpr const char *GRAPH_KEY_CHECK_NODE_OUTPUT = "need_check_output";
constexpr const char *GRAPH_NODE_REGISTER_FLOWUNIT = "register_flowunit";
Graph::Graph()
: nodes_(),
src_to_dst_(),
dst_to_src_(),
topo_order_(),
scheduler_(nullptr),
is_stop_(false) {}
Graph::~Graph() {
if (!is_stop_) {
Shutdown();
}
src_to_dst_.clear();
dst_to_src_.clear();
topo_order_.clear();
nodes_.clear();
if (flow_stats_ != nullptr) {
flow_stats_->DelItem(id_);
}
}
Status Graph::Initialize(std::shared_ptr<FlowUnitManager> flowunit_mgr,
std::shared_ptr<DeviceManager> device_mgr,
std::shared_ptr<Profiler> profiler,
std::shared_ptr<Configuration> config) {
if (flowunit_mgr == nullptr || device_mgr == nullptr || config == nullptr) {
auto msg = "argument is invalid";
auto ret = Status(STATUS_INVALID, msg);
MBLOG_ERROR << ret.WrapErrormsgs();
return ret;
}
flowunit_mgr_ = flowunit_mgr;
device_mgr_ = device_mgr;
profiler_ = profiler;
flow_stats_ = Statistics::GetGlobalItem()->GetItem(STATISTICS_ITEM_FLOW);
config_ = config;
auto ret = GetUUID(&id_);
if (ret != STATUS_OK) {
MBLOG_ERROR << "Get uuid for graph failed";
return ret;
}
if (flow_stats_ != nullptr) {
graph_stats_ = flow_stats_->AddItem(id_);
if (graph_stats_ == nullptr) {
MBLOG_ERROR << "Get stats for graph " << id_
<< " failed, err: " << StatusError.Errormsg();
}
}
return STATUS_OK;
}
std::string Graph::GetId() const { return id_; }
std::string Graph::GetName() const { return name_; }
Status Graph::CheckLoopStructureNode() {
Status status{STATUS_OK};
for (auto &loop : loop_structures_) {
auto pos = std::find(loop.begin(), loop.end(), *(loop.end() - 1));
for (auto iter = pos; iter != loop.end(); iter++) {
auto real_node = std::dynamic_pointer_cast<Node>(GetNode(*iter));
if (real_node == nullptr) {
auto err_msg = "invalid node " + *iter;
status = {STATUS_FAULT, err_msg};
break;
}
if (real_node->GetFlowType() == STREAM) {
auto err_msg = "loop node " + *iter + " can not be stream node.";
status = {STATUS_FAULT, err_msg};
break;
}
}
}
return status;
}
void Graph::ShowGraphInfo(std::shared_ptr<GCGraph> g) {
name_ = g->GetGraphName();
MBLOG_INFO << "Build graph name:" << name_ << ", id:" << id_;
g->ShowAllSubGraph();
g->ShowAllNode();
g->ShowAllEdge();
}
Status Graph::CheckGraph() {
auto start_nodes = GetStartNodes();
auto graph_checker = std::make_shared<GraphChecker>(
topo_order_, start_nodes, loop_links_, loop_structures_, src_to_dst_);
Status res = graph_checker->Check();
if (!res) {
return res;
}
graph_checker->SetMatchNodes();
graph_checker->ShowMatchNodes();
return res;
}
Status Graph::Build(std::shared_ptr<GCGraph> g) {
if (g == nullptr) {
return STATUS_INVALID;
}
if (flowunit_mgr_ == nullptr || device_mgr_ == nullptr ||
config_ == nullptr) {
auto msg = "graph is not initialized";
auto ret = Status(STATUS_INVALID, msg);
return ret;
}
ShowGraphInfo(g);
// build node and add link
Status status = BuildGraph(g);
if (!status) {
auto msg = "build graph from config fail.";
auto ret = Status(status, msg);
return ret;
}
status = IsValidGraph();
if (!status) {
auto msg = "invalid graph.";
auto ret = Status(status, msg);
return ret;
}
status = FindLoopStructure();
if (!status) {
auto msg = "loop node is illegal.";
auto ret = Status(status, msg);
return ret;
}
status = GenerateTopology();
if (!status) {
auto msg = "generate topology fail.";
auto ret = Status(status, msg);
return ret;
}
status = UpdatePriority();
if (!status) {
auto msg = "update proiority fail.";
auto ret = Status(status, msg);
return ret;
}
status = InitPort();
if (!status) {
auto msg = "init port fail.";
auto ret = Status(status, msg);
return ret;
}
status = CheckLoopStructureNode();
if (!status) {
auto msg = "check loop node fail.";
auto ret = Status(status, msg);
return ret;
}
status = CheckGraph();
if (!status) {
auto msg = "check graph failed.";
auto ret = Status(status, msg);
return ret;
}
status = InitScheduler();
if (!status) {
auto msg = "init scheduler fail.";
auto ret = Status(status, msg);
return ret;
}
return STATUS_OK;
}
Status Graph::AddNode(std::shared_ptr<NodeBase> node) {
if (node == nullptr) {
auto msg = "node is null pointer.";
return {STATUS_INVALID, msg};
}
auto ite = nodes_.find(node->GetName());
if (ite != nodes_.end()) {
auto msg = "node is already exist. name: " + node->GetName();
return {STATUS_INVALID, msg};
}
nodes_[node->GetName()] = node;
return STATUS_OK;
}
std::shared_ptr<NodeBase> Graph::GetNode(const std::string &nodeName) const {
auto ite = nodes_.find(nodeName);
if (ite == nodes_.end()) {
return nullptr;
}
return ite->second;
}
std::shared_ptr<InPort> Graph::GetInPort(const std::string &nodeName,
const std::string &portName) const {
auto ite = nodes_.find(nodeName);
if (ite == nodes_.end()) {
return nullptr;
}
auto node = ite->second;
if (node == nullptr) {
auto msg = "node is null pointer, never here. name: " + node->GetName();
MBLOG_ERROR << msg;
return nullptr;
}
return node->GetInputPort(portName);
}
std::shared_ptr<OutPort> Graph::GetOutPort(const std::string &nodeName,
const std::string &portName) const {
auto ite = nodes_.find(nodeName);
if (ite == nodes_.end()) {
auto msg = "node is not found, name: " + nodeName;
StatusError = {STATUS_BADCONF, msg};
return nullptr;
}
auto node = ite->second;
if (node == nullptr) {
auto msg = "node is null pointer, never here. name: " + node->GetName();
MBLOG_ERROR << msg;
return nullptr;
}
return node->GetOutputPort(portName);
}
const std::unordered_map<std::shared_ptr<NodeBase>,
std::vector<std::shared_ptr<IPort>>>
Graph::GetNotifyPort() const {
std::unordered_map<std::shared_ptr<NodeBase>,
std::vector<std::shared_ptr<IPort>>>
node_ports;
for (auto &node : nodes_) {
std::vector<std::shared_ptr<IPort>> ports;
// add in ports
const auto &in_ports = node.second->GetInputPorts();
std::copy(in_ports.begin(), in_ports.end(), std::back_inserter(ports));
// add event port
const auto &event_port = node.second->GetEventPort();
ports.push_back(std::dynamic_pointer_cast<IPort>(event_port));
// add external port
const auto &external_ports = node.second->GetExternalPorts();
std::copy(external_ports.begin(), external_ports.end(),
std::back_inserter(ports));
node_ports.emplace(node.second, std::move(ports));
}
return node_ports;
}
Status Graph::AddLink(const std::string &srcNodeName,
const std::string &srcPortName,
const std::string &dstNodeName,
const std::string &dstPortName) {
auto srcPort = GetOutPort(srcNodeName, srcPortName);
if (srcPort == nullptr) {
auto msg =
"src port is not exist. node: " + srcNodeName + " port: " + srcPortName;
return {STATUS_BADCONF, msg};
}
auto dstPort = GetInPort(dstNodeName, dstPortName);
if (dstPort == nullptr) {
auto msg =
"dst port is not exist. node: " + dstNodeName + " port: " + dstPortName;
return {STATUS_BADCONF, msg};
}
return AddLink(srcPort, dstPort);
}
Status Graph::AddLink(std::shared_ptr<OutPort> src,
std::shared_ptr<InPort> dst) {
if (src == nullptr) {
auto msg = "src port is null pointer.";
return {STATUS_INVALID, msg};
}
if (dst == nullptr) {
auto msg = "dst port is null pointer.";
return {STATUS_INVALID, msg};
}
auto srcNode = src->GetNode();
if (srcNode == nullptr) {
auto msg = "src node is null point.";
return {STATUS_INVALID, msg};
}
auto dstNode = dst->GetNode();
if (dstNode == nullptr) {
auto msg = "dst node is null point.";
return {STATUS_INVALID, msg};
}
auto dstLinks = src_to_dst_.find(src);
if (dstLinks != src_to_dst_.end()) {
auto ite = dstLinks->second.find(dst);
if (ite != dstLinks->second.end()) {
auto msg = "link is already exist. srcNode: " + srcNode->GetName() +
" srcPort: " + src->GetName() + "->" +
" dstNode: " + dstNode->GetName() +
" dstPort: " + dst->GetName();
return {STATUS_INVALID, msg};
}
}
src_to_dst_[src].insert(dst);
dst_to_src_[dst].insert(src);
auto msg = "add link, " + srcNode->GetName() + ":" + src->GetName() + " -> " +
dstNode->GetName() + ":" + dst->GetName();
MBLOG_INFO << msg;
return STATUS_OK;
}
std::set<std::shared_ptr<InPort>> Graph::GetDstPortsByPort(
std::shared_ptr<OutPort> port) const {
std::set<std::shared_ptr<InPort>> ports;
if (port == nullptr) {
return ports;
}
auto ite = src_to_dst_.find(port);
if (ite == src_to_dst_.end()) {
return ports;
}
ports = ite->second;
return ports;
}
std::set<std::shared_ptr<OutPort>> Graph::GetSrcPortsByPort(
std::shared_ptr<InPort> port) const {
std::set<std::shared_ptr<OutPort>> ports;
if (port == nullptr) {
return ports;
}
auto ite = dst_to_src_.find(port);
if (ite == dst_to_src_.end()) {
return ports;
}
ports = ite->second;
return ports;
}
std::set<std::shared_ptr<NodeBase>> Graph::GetStartNodes() const {
std::set<std::shared_ptr<NodeBase>> startNode;
for (auto &node : nodes_) {
auto inputNum = node.second->GetInputNum();
if (inputNum == 0) {
startNode.insert(node.second);
}
}
return startNode;
}
std::set<std::shared_ptr<NodeBase>> Graph::GetEndNodes() const {
std::set<std::shared_ptr<NodeBase>> endNode;
for (auto &node : nodes_) {
auto inputNum = node.second->GetInputNum();
if (inputNum == 0) {
endNode.insert(node.second);
}
}
return endNode;
}
std::set<std::shared_ptr<NodeBase>> Graph::GetEndPointNodes() const {
std::set<std::shared_ptr<NodeBase>> endNode;
for (auto &node : nodes_) {
auto outports = node.second->GetOutputPorts();
for (auto iter : outports) {
if (iter->GetConnectInPort().size() <= 0) {
endNode.insert(node.second);
}
}
}
return endNode;
}
std::set<std::shared_ptr<NodeBase>> Graph::GetAllNodes() const {
std::set<std::shared_ptr<NodeBase>> allNode;
for (auto &node : nodes_) {
allNode.insert(node.second);
}
return allNode;
}
std::set<std::shared_ptr<NodeBase>> Graph::GetDstNodesByNode(
const std::string &nodeName) const {
std::set<std::shared_ptr<NodeBase>> nodes;
auto node = GetNode(nodeName);
if (node == nullptr) {
return nodes;
}
auto outports = node->GetOutputPorts();
for (auto port : outports) {
auto linkPorts = GetDstPortsByPort(port);
for (auto linkport : linkPorts) {
nodes.insert(linkport->GetNode());
}
}
return nodes;
}
std::set<std::shared_ptr<NodeBase>> Graph::GetSrcNodesByNode(
const std::string &nodeName) const {
std::set<std::shared_ptr<NodeBase>> nodes;
auto node = GetNode(nodeName);
if (node == nullptr) {
return nodes;
}
auto inports = node->GetInputPorts();
for (auto port : inports) {
auto linkPorts = GetSrcPortsByPort(port);
for (auto linkport : linkPorts) {
nodes.insert(linkport->GetNode());
}
}
return nodes;
}
std::shared_ptr<ExternalDataMap> Graph::CreateExternalDataMap() {
if (input_node_ == nullptr) {
MBLOG_ERROR << "virtual input_node is nullptr";
return nullptr;
}
auto session = session_manager_.CreateSession(graph_stats_);
auto init_stream = std::make_shared<Stream>(session);
auto extern_data =
std::make_shared<ExternalDataMapImpl>(input_node_, init_stream);
session->SetSessionIO(extern_data);
return extern_data;
}
Status Graph::UpdateGraphConfigToNode(std::shared_ptr<GCGraph> g,
const std::shared_ptr<GCNode> node) {
auto graph_config = g->GetConfiguration();
auto node_config = node->GetConfiguration();
auto update_node_config = [=](const std::string &key) {
if (node_config->Contain(key) == true) {
return;
}
if (graph_config->Contain(key) == false) {
return;
}
node_config->Copy(*graph_config.get(), key);
};
update_node_config(GRAPH_KEY_BATCH_SIZE);
update_node_config(GRAPH_KEY_QUEUE_SIZE);
update_node_config(GRAPH_KEY_DEVICE_ID);
update_node_config(GRAPH_KEY_CHECK_NODE_OUTPUT);
return STATUS_OK;
}
Status Graph::BuildFlowunitNode(std::shared_ptr<GCGraph> g,
std::shared_ptr<GCNode> gcnode, bool strict) {
auto name = gcnode->GetNodeName();
auto node_config = gcnode->GetConfiguration();
auto device = node_config->GetString(GRAPH_KEY_DEVICE, "");
auto deviceid = node_config->GetString(GRAPH_KEY_DEVICE_ID, "");
auto flowunit = node_config->GetString(GRAPH_NODE_FLOWUNIT, "");
auto inports = gcnode->GetInputPorts();
auto outports = gcnode->GetOutputPorts();
if (flowunit.empty()) {
auto msg = "node " + name + ": flowunit name is empty.";
return {STATUS_INVALID, msg};
}
if (inports->size() == 0 && outports->size() == 0) {
if (strict == false) {
MBLOG_INFO << "skip orphan node: " << name;
return STATUS_SUCCESS;
}
auto msg = "orphan node: '" + name +
"', use graph.strict=false to disable orphan check";
return {STATUS_BADCONF, msg};
}
if (UpdateGraphConfigToNode(g, gcnode) == false) {
auto msg =
"update node config failed, please check node config in graph scope";
return {STATUS_BADCONF, msg};
}
auto node = std::make_shared<Node>();
node->SetFlowUnitInfo(flowunit, device, deviceid, flowunit_mgr_);
node->SetProfiler(profiler_);
node->SetStats(graph_stats_);
node->SetSessionManager(&session_manager_);
node->SetName(name);
auto status = InitNode(node, *inports, *outports, node_config);
if (!status) {
return status;
}
status = AddNode(node);
if (!status) {
auto msg = "add node failed. name: '" + name + "'";
return {status, msg};
}
return STATUS_SUCCESS;
}
Status Graph::BuildCommonRegisterNode(std::shared_ptr<GCGraph> g,
std::shared_ptr<GCNode> gcnode) {
auto name = gcnode->GetNodeName();
auto node_config = gcnode->GetConfiguration();
auto device = node_config->GetString(GRAPH_KEY_DEVICE, "cpu");
auto deviceid = node_config->GetString(GRAPH_KEY_DEVICE_ID, "0");
auto flowunit = node_config->GetString(GRAPH_NODE_FLOWUNIT, "");
auto inports = gcnode->GetInputPorts();
auto outports = gcnode->GetOutputPorts();
if (inports->size() == 0 && outports->size() == 0) {
auto msg =
"callback flowunit has no input or output port, please must specify "
"one port";
return {STATUS_BADCONF, msg};
}
if (UpdateGraphConfigToNode(g, gcnode) == false) {
auto msg =
"update node config failed, please check node config in graph scope";
return {STATUS_BADCONF, msg};
}
auto node = std::make_shared<Node>();
node->SetFlowUnitInfo(flowunit, device, deviceid, flowunit_mgr_);
node->SetProfiler(profiler_);
node->SetStats(graph_stats_);
node->SetSessionManager(&session_manager_);
node->SetName(name);
auto status = InitNode(node, *inports, *outports, node_config);
if (!status) {
return status;
}
status = AddNode(node);
if (!status) {
auto msg = "add node failed. name: '" + name + "'";
return {status, msg};
}
return STATUS_SUCCESS;
}
Status Graph::BuildInputNode(std::shared_ptr<GCNode> gcnode) {
auto name = gcnode->GetNodeName();
auto node_config = gcnode->GetConfiguration();
if (input_node_ports_.find(name) != input_node_ports_.end()) {
auto msg = "virtual input port is already exist. name: '" + name + "'";
return {STATUS_INVALID, msg};
}
input_node_ports_.insert(name);
input_node_config_map_.emplace(name, node_config);
return STATUS_SUCCESS;
}
Status Graph::BuildOutputNode(std::shared_ptr<GCNode> gcnode) {
auto name = gcnode->GetNodeName();
auto node_config = gcnode->GetConfiguration();
if (output_node_ports_.find(name) != output_node_ports_.end()) {
auto msg = "virtual out port is already exist. name: '" + name + "'";
return {STATUS_INVALID, msg};
}
output_node_ports_.insert(name);
output_node_config_map_.emplace(name, node_config);
return STATUS_SUCCESS;
}
Status Graph::BuildNode(std::shared_ptr<GCGraph> g,
std::shared_ptr<GCNode> gcnode, bool strict) {
auto name = gcnode->GetNodeName();
auto node_config = gcnode->GetConfiguration();
auto type = node_config->GetString(GRAPH_NODE_TYPE, "");
auto flowunit = node_config->GetString(GRAPH_NODE_FLOWUNIT, "");
if (flowunit.length() > 0 && type.length() == 0) {
type = GRAPH_NODE_FLOWUNIT;
}
Status status = STATUS_SUCCESS;
if (type == GRAPH_NODE_FLOWUNIT) {
status = BuildFlowunitNode(g, gcnode, strict);
} else if (type == GRAPH_NODE_INPUT) {
status = BuildInputNode(gcnode);
} else if (type == GRAPH_NODE_OUTPUT) {
status = BuildOutputNode(gcnode);
} else if (type == GRAPH_NODE_REGISTER_FLOWUNIT) {
status = BuildCommonRegisterNode(g, gcnode);
} else {
if (strict) {
auto msg =
"unsupport node type. name: '" + name + "' type: '" + type + "'";
status = {STATUS_NOTSUPPORT, msg};
}
}
return status;
}
Status Graph::BuildNodes(std::shared_ptr<GCGraph> g) {
auto strict = config_->GetBool("graph.strict", true);
auto nodes = g->GetAllNodes();
for (auto &ite : nodes) {
auto gcnode = ite.second;
auto name = gcnode->GetNodeName();
MBLOG_INFO << "begin build node " << name;
auto status = BuildNode(g, gcnode, strict);
if (!status) {
MBLOG_ERROR << status;
auto msg = "build node failed. name: '" + name + "'";
return {status, msg};
}
MBLOG_INFO << "build node " << name << " success";
}
return STATUS_OK;
}
Status Graph::BuildVirtualNodes(std::shared_ptr<GCGraph> g) {
if (!input_node_ports_.empty()) {
input_node_name_ = *input_node_ports_.begin();
input_node_ = std::make_shared<InputVirtualNode>("cpu", "0", device_mgr_);
auto input_config = input_node_config_map_.begin()->second;
auto status = input_node_->Init({}, input_node_ports_, input_config);
if (!status) {
auto msg = "init virtual input node failed.";
return {status, msg};
}
input_node_->SetName(input_node_name_);
status = AddNode(input_node_);
if (!status) {
auto msg = "add virtual input node failed.";
return {status, msg};
}
}
if (!output_node_ports_.empty()) {
output_node_name_ = *output_node_ports_.begin();
auto output_config = output_node_config_map_.begin()->second;
auto output_type = output_config->GetString("output_type", "match");
if (output_type == "match") {
output_node_ =
std::make_shared<OutputVirtualNode>("cpu", "0", device_mgr_);
} else if (output_type == "unmatch") {
output_node_ =
std::make_shared<OutputUnmatchVirtualNode>("cpu", "0", device_mgr_);
} else {
return {STATUS_INVALID, "Invalid Output Type"};
}
auto status = output_node_->Init(output_node_ports_, {}, output_config);
if (!status) {
auto msg = "init virtual output node failed.";
return {status, msg};
}
output_node_->SetName(output_node_name_);
status = AddNode(output_node_);
if (!status) {
auto msg = "add virtual output node failed.";
return {status, msg};
}
}
return STATUS_OK;
}
Status Graph::BuildEdges(std::shared_ptr<GCGraph> g) {
auto edges = g->GetAllEdges();
for (auto &ite : edges) {
auto gcedge = ite.second;
auto srcNode = gcedge->GetHeadNode();
auto srcNodeName = srcNode->GetNodeName();
auto srcPortName = gcedge->GetHeadOutPort();
auto dstNode = gcedge->GetTailNode();
auto dstNodeName = dstNode->GetNodeName();
auto dstPortName = gcedge->GetTailInPort();
if (input_node_ports_.find(srcNodeName) != input_node_ports_.end()) {
srcPortName = srcNodeName;
srcNodeName = input_node_name_;
}
if (output_node_ports_.find(dstNodeName) != output_node_ports_.end()) {
dstPortName = dstNodeName;
dstNodeName = output_node_name_;
}
auto status = AddLink(srcNodeName, srcPortName, dstNodeName, dstPortName);
if (!status) {
auto msg = "add link failed.";
return {status, msg};
}
}
return STATUS_OK;
}
Status Graph::OpenNodes() {
ThreadPool pool(std::thread::hardware_concurrency());
pool.SetName("Node-Open");
std::vector<std::future<Status>> result;
for (auto &itr : nodes_) {
auto node = itr.second;
auto ret = pool.Submit(node->GetName(), &NodeBase::Open, node.get());
result.push_back(std::move(ret));
}
for (auto &fut : result) {
auto msg = "open node failed, please check log.";
if (!fut.valid()) {
return {STATUS_FAULT, msg};
}
auto ret = fut.get();
if (!ret) {
return ret;
}
}
return STATUS_OK;
}
void Graph::CloseNodes() const {
ThreadPool pool(std::thread::hardware_concurrency());
pool.SetName("Node-Close");
std::vector<std::future<void>> result;
for (auto &itr : nodes_) {
auto node = itr.second;
auto ret =
pool.Submit(node->GetName() + "_close", &NodeBase::Close, node.get());
result.push_back(std::move(ret));
}
for (auto &fut : result) {
if (!fut.valid()) {
continue;
}
fut.get();
}
}
Status Graph::BuildGraph(std::shared_ptr<GCGraph> g) {
auto status = BuildNodes(g);
if (!status) {
return status;
}
status = BuildVirtualNodes(g);
if (!status) {
return status;
}
status = BuildEdges(g);
if (!status) {
return status;
}
status = OpenNodes();
return status;
}
Status Graph::IsValidGraph() const {
if (nodes_.empty()) {
auto msg = "graph is empty, no node.";
return {STATUS_BADCONF, msg};
}
auto status = IsAllPortConnect();
if (!status) {
auto msg = "not all port connect.";
return {status, msg};
}
status = IsAllNodeConnect();
if (!status) {
auto msg = "not all node connect.";
return {status, msg};
}
return STATUS_OK;
}
Status Graph::IsAllPortConnect() const {
for (auto node : nodes_) {
// 某些输入port、输出port是可选的, TODO
auto inports = node.second->GetInputPorts();
for (auto port : inports) {
auto ite = dst_to_src_.find(port);
if (ite == dst_to_src_.end()) {
auto msg = "in port is not connect. node: " + node.second->GetName() +
" port: " + port->GetName();
return {STATUS_BADCONF, msg};
}
}
auto outports = node.second->GetOutputPorts();
for (auto port : outports) {
auto ite = src_to_dst_.find(port);
if (ite == src_to_dst_.end()) {
auto msg = "out port is not connect. node: " + node.second->GetName() +
" port: " + port->GetName();
return {STATUS_BADCONF, msg};
}
}
}
return STATUS_OK;
}
Status Graph::IsAllNodeConnect() const {
std::map<std::string, int> nodeType;
int idx = 0;
for (auto &node : nodes_) {
nodeType[node.first] = idx++;
}
for (auto link : src_to_dst_) {
for (auto linkport : link.second) {
auto srcNode = link.first->GetNode();
auto dstNode = linkport->GetNode();
auto srcType = nodeType[srcNode->GetName()];
auto dstType = nodeType[dstNode->GetName()];
if (srcType == dstType) {
continue;
}
auto msg = "node. srcNode: " + srcNode->GetName() + " #" +
std::to_string(srcType) + " dstNode: " + dstNode->GetName() +
" #" + std::to_string(dstType);
MBLOG_DEBUG << msg;
auto mergeType = srcType < dstType ? srcType : dstType;
for (auto node : nodeType) {
if (node.second == srcType || node.second == dstType) {
nodeType[node.first] = mergeType;
auto msg = "merge. src: " + node.first + ", " +
std::to_string(node.second) + " -> " +
std::to_string(mergeType);
MBLOG_DEBUG << msg;
}
}
}
}
for (auto node : nodeType) {
auto msg = "node: " + node.first + " #" + std::to_string(node.second);
MBLOG_INFO << msg;
}
auto firstType = nodeType.begin();
for (auto node : nodeType) {
if (node.second != firstType->second) {
auto msg = "not all node union.";
return Status(STATUS_BADCONF, msg);
}
}
return STATUS_OK;
}
Status Graph::UpdatePriority() {
auto callback = [](std::shared_ptr<NodeBase> node, int order) {
auto inports = node->GetInputPorts();
for (auto port : inports) {
port->SetPriority(order);
auto msg = "set priority. node: " + node->GetName() +
" port: " + port->GetName() +
" priority: " + std::to_string(order);
MBLOG_INFO << msg;
}
return true;
};
return Topology(callback);
}
Status Graph::Topology(
std::function<bool(std::shared_ptr<NodeBase> node, int order)> callback)
const {
int idx = 0;
for (auto node : topo_order_) {
auto ret = callback(node, idx);
if (!ret) {
auto msg = "callback fail. topo idx: " + std::to_string(idx) + ", " +
node->GetName();
MBLOG_WARN << msg;
} else {
auto msg = "callback success. topo idx: " + std::to_string(idx) + ", " +
node->GetName();
MBLOG_DEBUG << msg;
}
idx++;
}
return STATUS_OK;
}
void Graph::FindLoopSeq(std::shared_ptr<NodeBase> &root_node,
std::vector<std::string> &vis) {
auto dstNodes = GetDstNodesByNode(root_node->GetName());
if (dstNodes.empty()) {
return;
}
for (auto dstNode : dstNodes) {
if (std::find(vis.begin(), vis.end(), dstNode->GetName()) != vis.end()) {
vis.push_back(dstNode->GetName());
loop_structures_.push_back(vis);
vis.pop_back();
return;
}
vis.push_back(dstNode->GetName());
FindLoopSeq(dstNode, vis);
vis.pop_back();
}
}
void Graph::FindLoopWithNode(std::shared_ptr<NodeBase> &root_node,
std::vector<std::string> &vis) {
vis.push_back(root_node->GetName());
FindLoopSeq(root_node, vis);
}
void Graph::FillLoopLink() {
for (auto &loop : loop_structures_) {
auto loop_link_from = *(loop.end() - 2);
auto loop_link_to = *(loop.end() - 1);
loop_links_.insert(std::make_pair(loop_link_to, loop_link_from));
}
}
Status Graph::CheckLoopNode() {
Status status{STATUS_EOF};
for (auto &node : nodes_) {
auto tmp_node = std::dynamic_pointer_cast<Node>(node.second);
// virtual node
if (tmp_node == nullptr) {
continue;
}
if (tmp_node->GetLoopType() != LOOP) {
continue;
}
if (tmp_node->GetInputNum() != 1) {
return {STATUS_FAULT, "loop node input should be one."};
}
if (tmp_node->GetOutputNum() != 2) {
return {STATUS_FAULT, "loop node output shoulde be two."};
}
status = STATUS_OK;
}
return status;
}
Status Graph::FindLoopStructure() {
auto status = CheckLoopNode();
if (status == STATUS_FAULT) {
return status;
}
if (status == STATUS_EOF) {
MBLOG_DEBUG << "there is no loop node.";
return STATUS_OK;
}
auto connectNode = GetStartNodes();
if (connectNode.empty()) {
auto msg = "start node is not exist.";
return {STATUS_BADCONF, msg};
}
std::vector<std::string> vis;
while (!connectNode.empty()) {
auto nodeIte = connectNode.begin();
auto node = *nodeIte;
connectNode.erase(nodeIte);
FindLoopWithNode(node, vis);
vis.clear();
}
for (auto &loop : loop_structures_) {
for (auto &item : loop) {
MBLOG_INFO << "item: " << item;
}
}
FillLoopLink();
for (auto &loop : loop_links_) {
MBLOG_INFO << loop.first << ", " << loop.second;
}
return STATUS_OK;
}
Status Graph::GenerateTopology() {
std::vector<std::shared_ptr<NodeBase>> topoNode;
auto connectNode = GetStartNodes();
if (connectNode.empty()) {
auto msg = "start node is not exist.";
return {STATUS_BADCONF, msg};
}
while (!connectNode.empty()) {
auto nodeIte = connectNode.begin();
auto node = *nodeIte;
connectNode.erase(nodeIte);
auto ite = std::find(topoNode.begin(), topoNode.end(), node);
if (ite != topoNode.end()) {
continue;
}
// all inport is in topoNode set
bool topo = true;
auto srcNodes = GetSrcNodesByNode(node->GetName());
for (const auto &srcNode : srcNodes) {
if (loop_links_.find(node->GetName()) != loop_links_.end() &&
loop_links_[node->GetName()] == srcNode->GetName()) {
continue;
}
auto ite = std::find(topoNode.begin(), topoNode.end(), srcNode);
if (ite == topoNode.end()) {
auto msg = "srcNode not topnode. srcNode: " + node->GetName() +
" node: " + node->GetName();
MBLOG_DEBUG << msg;
topo = false;
}
}
if (topo) {
auto msg = "add new topnode. node: " + node->GetName();
MBLOG_DEBUG << msg;
topoNode.push_back(node);
auto dstNodes = GetDstNodesByNode(node->GetName());
for (auto dstNode : dstNodes) {
connectNode.insert(dstNode);
auto msg = "add connect node. " + node->GetName() + " -> " +
dstNode->GetName();
MBLOG_DEBUG << msg;
}
}
}
auto i = 0;
for (auto node : topoNode) {
auto msg = "topo index: " + std::to_string(i) + ", " + node->GetName();
MBLOG_INFO << msg;
++i;
}
if (topoNode.size() != nodes_.size()) {
auto msg = "not all node connect.";
return {STATUS_BADCONF, msg};
}
topo_order_ = topoNode;
return STATUS_OK;
}
Status Graph::InitPort() {
for (auto &portIte : dst_to_src_) {
auto inport = portIte.first;
for (const auto &outport : portIte.second) {
auto msg = "port connect, " + outport->GetNode()->GetName() + ":" +
outport->GetName() + " -> " + inport->GetNode()->GetName() +
":" + inport->GetName();
MBLOG_INFO << msg;
outport->ConnectPort(inport);
}
}
return STATUS_OK;
}
Status Graph::InitNode(std::shared_ptr<Node> &node,
const std::set<std::string> &input_port_names,
const std::set<std::string> &output_port_names,
std::shared_ptr<Configuration> &config) {
auto status = node->Init(input_port_names, output_port_names, config);
return status;
}
Status Graph::InitScheduler() {
scheduler_ = std::make_shared<FlowScheduler>();
size_t thread_num = nodes_.size() * 2;
if (thread_num < std::thread::hardware_concurrency()) {
thread_num = std::thread::hardware_concurrency();
}
if (!config_->Contain("graph.thread-num")) {
config_->SetProperty("graph.thread-num", thread_num);
}
if (!config_->Contain("graph.thread-num")) {
config_->SetProperty("graph.max-thread-num", thread_num * 4);
}
auto status = scheduler_->Init(config_);
if (!status) {
auto msg = "init scheduler failed.";
MBLOG_FATAL << msg;
return {status, msg};
}
status = scheduler_->Build(*this);
if (!status) {
auto msg = "build scheduler failed.";
MBLOG_FATAL << msg;
return {status, msg};
}
return STATUS_OK;
}
Status Graph::Run() {
if (scheduler_ == nullptr) {
auto message = "scheduler is not initialized.";
return {STATUS_SHUTDOWN, message};
}
if (profiler_ != nullptr) {
profiler_->Start();
}
return scheduler_->Run();
}
void Graph::RunAsync() {
if (scheduler_ == nullptr) {
auto message = "scheduler is not initialized.";
StatusError = {STATUS_SHUTDOWN, message};
return;
}
if (profiler_ != nullptr) {
profiler_->Start();
}
scheduler_->RunAsync();
}
Status Graph::Wait(int64_t milliseconds, Status *ret_val) {
if (scheduler_ == nullptr) {
auto message = "scheduler is not initialized.";
return {STATUS_SHUTDOWN, message};
}
auto status = scheduler_->Wait(milliseconds, ret_val);
return status;
}
Status Graph::Shutdown() {
if (scheduler_ != nullptr) {
scheduler_->Shutdown();
scheduler_ = nullptr;
}
if (profiler_ != nullptr) {
profiler_->Stop();
}
CloseNodes();
is_stop_ = true;
return STATUS_OK;
}
DynamicGraph::DynamicGraph() : Graph() {}
DynamicGraph::~DynamicGraph() { Shutdown(); }
Status DynamicGraph::Shutdown() { return STATUS_OK; }
Status DynamicGraph::IsValidGraph() const { return STATUS_OK; }
Status DynamicGraph::InitScheduler() { return STATUS_OK; }
Status DynamicGraph::InitNode(std::shared_ptr<Node> &node,
const std::set<std::string> &input_port_names,
const std::set<std::string> &output_port_names,
std::shared_ptr<Configuration> &config) {
auto status = node->Init(input_port_names, output_port_names, config);
return status;
}
} // namespace modelbox
| 27.413522
| 80
| 0.624405
|
fujl
|
106c3bdda9708e1f33261c2b446dff5d2dd4ef6a
| 986
|
hpp
|
C++
|
third_party/glm/ext/quaternion_double.hpp
|
floppyhammer/nanovg-demo
|
47e0772e73d7d0cbb4f017b09871da4fd19af7a6
|
[
"MIT"
] | null | null | null |
third_party/glm/ext/quaternion_double.hpp
|
floppyhammer/nanovg-demo
|
47e0772e73d7d0cbb4f017b09871da4fd19af7a6
|
[
"MIT"
] | null | null | null |
third_party/glm/ext/quaternion_double.hpp
|
floppyhammer/nanovg-demo
|
47e0772e73d7d0cbb4f017b09871da4fd19af7a6
|
[
"MIT"
] | 1
|
2019-12-05T11:50:24.000Z
|
2019-12-05T11:50:24.000Z
|
/// @ref ext_quaternion_double
/// @file glm/ext/quaternion_double.hpp
///
/// @defgroup ext_quaternion_double GLM_EXT_quaternion_double
/// @ingroup ext
///
/// Exposes double-precision floating point quaternion type.
///
/// Include <glm/ext/quaternion_double.hpp> to use the features of this extension.
///
/// @see ext_quaternion_float
/// @see ext_quaternion_double_precision
/// @see ext_quaternion_common
/// @see ext_quaternion_exponential
/// @see ext_quaternion_geometric
/// @see ext_quaternion_relational
/// @see ext_quaternion_transform
/// @see ext_quaternion_trigonometric
#pragma once
// Dependency:
#include "glm/detail/type_quat.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_quaternion_double extension included")
#endif
namespace glm
{
/// @addtogroup ext_quaternion_double
/// @{
/// Quaternion of double-precision floating-point numbers.
typedef qua<double, defaultp> dquat;
/// @}
} //namespace glm
| 24.65
| 82
| 0.75355
|
floppyhammer
|
1072e13a3af2fdd62274b7dc4a450df660128e4b
| 7,990
|
cxx
|
C++
|
Source/Decoda/libs/wxScintilla/src/scintilla/src/LexLisp.cxx
|
KoSukeWork/BabeLua
|
0904f8ba15174fcfe88d75e37349c4f4f15403ef
|
[
"MIT"
] | 68
|
2015-02-01T10:42:09.000Z
|
2021-08-05T06:30:35.000Z
|
Src/Plugins/org.owm.scite/scintilla1.7.7/src/LexLisp.cxx
|
H1N2/Script.NET
|
6214e00371b3c983ec68e0660b0c708a6d8b81e8
|
[
"MIT"
] | 2
|
2016-08-24T10:29:05.000Z
|
2021-11-08T13:56:40.000Z
|
Src/Plugins/org.owm.scite/scintilla1.7.7/src/LexLisp.cxx
|
H1N2/Script.NET
|
6214e00371b3c983ec68e0660b0c708a6d8b81e8
|
[
"MIT"
] | 39
|
2015-03-03T15:11:24.000Z
|
2022-03-20T05:31:57.000Z
|
// Scintilla source code edit control
/** @file LexLisp.cxx
** Lexer for Lisp.
** Written by Alexey Yutkin.
**/
// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdio.h>
#include <stdarg.h>
#include "Platform.h"
#include "PropSet.h"
#include "Accessor.h"
#include "KeyWords.h"
#include "Scintilla.h"
#include "SciLexer.h"
#include "StyleContext.h"
#ifdef SCI_NAMESPACE
using namespace Scintilla;
#endif
#define SCE_LISP_CHARACTER 29
#define SCE_LISP_MACRO 30
#define SCE_LISP_MACRO_DISPATCH 31
static inline bool isLispoperator(char ch) {
if (isascii(ch) && isalnum(ch))
return false;
if (ch == '\'' || ch == '`' || ch == '(' || ch == ')' )
return true;
return false;
}
static inline bool isLispwordstart(char ch) {
return isascii(ch) && ch != ';' && !isspacechar(ch) && !isLispoperator(ch) &&
ch != '\n' && ch != '\r' && ch != '\"';
}
static void classifyWordLisp(unsigned int start, unsigned int end, WordList &keywords, WordList &keywords_kw, Accessor &styler) {
PLATFORM_ASSERT(end >= start);
char s[100];
unsigned int i;
bool digit_flag = true;
for (i = 0; (i < end - start + 1) && (i < 99); i++) {
s[i] = styler[start + i];
s[i + 1] = '\0';
if (!isdigit(s[i]) && (s[i] != '.')) digit_flag = false;
}
char chAttr = SCE_LISP_IDENTIFIER;
if(digit_flag) chAttr = SCE_LISP_NUMBER;
else {
if (keywords.InList(s)) {
chAttr = SCE_LISP_KEYWORD;
} else if (keywords_kw.InList(s)) {
chAttr = SCE_LISP_KEYWORD_KW;
} else if ((s[0] == '*' && s[i-1] == '*') ||
(s[0] == '+' && s[i-1] == '+')) {
chAttr = SCE_LISP_SPECIAL;
}
}
styler.ColourTo(end, chAttr);
return;
}
static void ColouriseLispDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
Accessor &styler) {
WordList &keywords = *keywordlists[0];
WordList &keywords_kw = *keywordlists[1];
styler.StartAt(startPos);
int state = initStyle, radix = -1;
char chNext = styler[startPos];
unsigned int lengthDoc = startPos + length;
styler.StartSegment(startPos);
for (unsigned int i = startPos; i < lengthDoc; i++) {
char ch = chNext;
chNext = styler.SafeGetCharAt(i + 1);
bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
if (styler.IsLeadByte(ch)) {
chNext = styler.SafeGetCharAt(i + 2);
i += 1;
continue;
}
if (state == SCE_LISP_DEFAULT) {
if (ch == '#') {
styler.ColourTo(i - 1, state);
radix = -1;
state = SCE_LISP_MACRO_DISPATCH;
} else if (isLispwordstart(ch)) {
styler.ColourTo(i - 1, state);
state = SCE_LISP_IDENTIFIER;
}
else if (ch == ';') {
styler.ColourTo(i - 1, state);
state = SCE_LISP_COMMENT;
}
else if (isLispoperator(ch) || ch=='\'') {
styler.ColourTo(i - 1, state);
styler.ColourTo(i, SCE_LISP_OPERATOR);
if (ch=='\'' && isLispwordstart(chNext)) {
state = SCE_LISP_SYMBOL;
}
}
else if (ch == '\"') {
styler.ColourTo(i - 1, state);
state = SCE_LISP_STRING;
}
} else if (state == SCE_LISP_IDENTIFIER || state == SCE_LISP_SYMBOL) {
if (!isLispwordstart(ch)) {
if (state == SCE_LISP_IDENTIFIER) {
classifyWordLisp(styler.GetStartSegment(), i - 1, keywords, keywords_kw, styler);
} else {
styler.ColourTo(i - 1, state);
}
state = SCE_LISP_DEFAULT;
} /*else*/
if (isLispoperator(ch) || ch=='\'') {
styler.ColourTo(i - 1, state);
styler.ColourTo(i, SCE_LISP_OPERATOR);
if (ch=='\'' && isLispwordstart(chNext)) {
state = SCE_LISP_SYMBOL;
}
}
} else if (state == SCE_LISP_MACRO_DISPATCH) {
if (!isdigit(ch)) {
if (ch != 'r' && ch != 'R' && (i - styler.GetStartSegment()) > 1) {
state = SCE_LISP_DEFAULT;
} else {
switch (ch) {
case '|': state = SCE_LISP_MULTI_COMMENT; break;
case 'o':
case 'O': radix = 8; state = SCE_LISP_MACRO; break;
case 'x':
case 'X': radix = 16; state = SCE_LISP_MACRO; break;
case 'b':
case 'B': radix = 2; state = SCE_LISP_MACRO; break;
case '\\': state = SCE_LISP_CHARACTER; break;
case ':':
case '-':
case '+': state = SCE_LISP_MACRO; break;
case '\'': if (isLispwordstart(chNext)) {
state = SCE_LISP_SPECIAL;
} else {
styler.ColourTo(i - 1, SCE_LISP_DEFAULT);
styler.ColourTo(i, SCE_LISP_OPERATOR);
state = SCE_LISP_DEFAULT;
}
break;
default: if (isLispoperator(ch)) {
styler.ColourTo(i - 1, SCE_LISP_DEFAULT);
styler.ColourTo(i, SCE_LISP_OPERATOR);
}
state = SCE_LISP_DEFAULT;
break;
}
}
}
} else if (state == SCE_LISP_MACRO) {
if (isLispwordstart(ch) && (radix == -1 || IsADigit(ch, radix))) {
state = SCE_LISP_SPECIAL;
} else {
state = SCE_LISP_DEFAULT;
}
} else if (state == SCE_LISP_CHARACTER) {
if (isLispoperator(ch)) {
styler.ColourTo(i, SCE_LISP_SPECIAL);
state = SCE_LISP_DEFAULT;
} else if (isLispwordstart(ch)) {
styler.ColourTo(i, SCE_LISP_SPECIAL);
state = SCE_LISP_SPECIAL;
} else {
state = SCE_LISP_DEFAULT;
}
} else if (state == SCE_LISP_SPECIAL) {
if (!isLispwordstart(ch) || (radix != -1 && !IsADigit(ch, radix))) {
styler.ColourTo(i - 1, state);
state = SCE_LISP_DEFAULT;
}
if (isLispoperator(ch) || ch=='\'') {
styler.ColourTo(i - 1, state);
styler.ColourTo(i, SCE_LISP_OPERATOR);
if (ch=='\'' && isLispwordstart(chNext)) {
state = SCE_LISP_SYMBOL;
}
}
} else {
if (state == SCE_LISP_COMMENT) {
if (atEOL) {
styler.ColourTo(i - 1, state);
state = SCE_LISP_DEFAULT;
}
} else if (state == SCE_LISP_MULTI_COMMENT) {
if (ch == '|' && chNext == '#') {
i++;
chNext = styler.SafeGetCharAt(i + 1);
styler.ColourTo(i, state);
state = SCE_LISP_DEFAULT;
}
} else if (state == SCE_LISP_STRING) {
if (ch == '\\') {
if (chNext == '\"' || chNext == '\'' || chNext == '\\') {
i++;
chNext = styler.SafeGetCharAt(i + 1);
}
} else if (ch == '\"') {
styler.ColourTo(i, state);
state = SCE_LISP_DEFAULT;
}
}
}
}
styler.ColourTo(lengthDoc - 1, state);
}
static void FoldLispDoc(unsigned int startPos, int length, int /* initStyle */, WordList *[],
Accessor &styler) {
unsigned int lengthDoc = startPos + length;
int visibleChars = 0;
int lineCurrent = styler.GetLine(startPos);
int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
int levelCurrent = levelPrev;
char chNext = styler[startPos];
int styleNext = styler.StyleAt(startPos);
for (unsigned int i = startPos; i < lengthDoc; i++) {
char ch = chNext;
chNext = styler.SafeGetCharAt(i + 1);
int style = styleNext;
styleNext = styler.StyleAt(i + 1);
bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
if (style == SCE_LISP_OPERATOR) {
if (ch == '(') {
levelCurrent++;
} else if (ch == ')') {
levelCurrent--;
}
}
if (atEOL) {
int lev = levelPrev;
if (visibleChars == 0)
lev |= SC_FOLDLEVELWHITEFLAG;
if ((levelCurrent > levelPrev) && (visibleChars > 0))
lev |= SC_FOLDLEVELHEADERFLAG;
if (lev != styler.LevelAt(lineCurrent)) {
styler.SetLevel(lineCurrent, lev);
}
lineCurrent++;
levelPrev = levelCurrent;
visibleChars = 0;
}
if (!isspacechar(ch))
visibleChars++;
}
// Fill in the real level of the next line, keeping the current flags as they will be filled in later
int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
styler.SetLevel(lineCurrent, levelPrev | flagsNext);
}
static const char * const lispWordListDesc[] = {
"Functions and special operators",
"Keywords",
0
};
LexerModule lmLISP(SCLEX_LISP, ColouriseLispDoc, "lisp", FoldLispDoc, lispWordListDesc);
| 28.535714
| 129
| 0.606008
|
KoSukeWork
|
1075628b91b4ec1138d59e99f1d45304599be8aa
| 2,890
|
cpp
|
C++
|
Source/DeathMatch/Weapon.cpp
|
OmarAlesharie/UE4_OnlineDeathMatch
|
aa41143d01743c6b41c8bf1a15160747018f88ff
|
[
"MIT"
] | null | null | null |
Source/DeathMatch/Weapon.cpp
|
OmarAlesharie/UE4_OnlineDeathMatch
|
aa41143d01743c6b41c8bf1a15160747018f88ff
|
[
"MIT"
] | null | null | null |
Source/DeathMatch/Weapon.cpp
|
OmarAlesharie/UE4_OnlineDeathMatch
|
aa41143d01743c6b41c8bf1a15160747018f88ff
|
[
"MIT"
] | 1
|
2021-11-29T11:40:16.000Z
|
2021-11-29T11:40:16.000Z
|
// Fill out your copyright notice in the Description page of Project Settings.
#include "Weapon.h"
#include "DrawDebugHelpers.h"
#include "Projectile.h"
#include "Kismet/GameplayStatics.h"
#include "Sound/SoundCue.h"
#include "UObject/ConstructorHelpers.h"
// Sets default values
AWeapon::AWeapon()
{
MeshComp = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("MeshComp"));
RootComponent = MeshComp;
static ConstructorHelpers::FObjectFinder<USkeletalMesh> WeaponMesh(TEXT("/Game/SciFiWeapDark/Weapons/Darkness_AssaultRifle.Darkness_AssaultRifle"));
if (WeaponMesh.Succeeded())
{
MeshComp->SetSkeletalMesh(WeaponMesh.Object);
}
FireSound = CreateDefaultSubobject<USoundCue>(TEXT("FireSound"));
static ConstructorHelpers::FObjectFinder<USoundCue> LaserSound(TEXT("/Game/Sounds/Laser_Cue.Laser_Cue"));
if (LaserSound.Succeeded())
{
FireSound = LaserSound.Object;
}
MuzzleSocketName = "MuzzleSocket";
SetReplicates(true);
//NetUpdateFrequency = 66.0f;
//MinNetUpdateFrequency = 33.0f;
//Initialize projectile class
ProjectileClass = AProjectile::StaticClass();
//Initialize fire rate
FireRate = 0.25f;
bIsFiringWeapon = false;
}
// Called when the game starts or when spawned
void AWeapon::BeginPlay()
{
Super::BeginPlay();
}
void AWeapon::PlayFireSound_Server_Implementation()
{
UGameplayStatics::SpawnSoundAtLocation(GetWorld(),FireSound,GetActorLocation());
}
void AWeapon::StartFire()
{
if (!bIsFiringWeapon)
{
bIsFiringWeapon = true;
UWorld* World = GetWorld();
World->GetTimerManager().SetTimer(FiringTimer, this, &AWeapon::StopFire, FireRate, false);
HandleFire();
}
}
void AWeapon::StopFire()
{
bIsFiringWeapon = false;
}
void AWeapon::HandleFire_Implementation()
{
FVector MuzzleLocation = MeshComp->GetSocketLocation(MuzzleSocketName);
AActor* MyOwner = GetOwner();
if (MyOwner)
{
FVector EyeLocation;
FRotator EyeRotation;
MyOwner->GetActorEyesViewPoint(EyeLocation, EyeRotation);
FVector TraceEnd = EyeLocation + (EyeRotation.Vector() * 30000);
FVector TracerEndPoint = TraceEnd;
FCollisionQueryParams QueryParams;
QueryParams.AddIgnoredActor(MyOwner);
QueryParams.AddIgnoredActor(this);
QueryParams.bTraceComplex = true;
FHitResult Hit;
if (GetWorld()->LineTraceSingleByChannel(Hit, EyeLocation, TraceEnd, ECollisionChannel::ECC_GameTraceChannel1, QueryParams))
{
AActor* HitActor = Hit.GetActor();
TracerEndPoint = Hit.ImpactPoint;
}
FVector ShotDirection = (TracerEndPoint - MuzzleLocation).GetSafeNormal();
FActorSpawnParameters spawnParameters;
spawnParameters.Instigator = this->GetInstigator();
spawnParameters.Owner = this->GetOwner();
AProjectile* spawnedProjectile = GetWorld()->SpawnActor<AProjectile>(MuzzleLocation, ShotDirection.Rotation(), spawnParameters);
PlayFireSound_Server();
}
}
bool AWeapon::HandleFire_Validate()
{
return true;
}
| 23.688525
| 149
| 0.762284
|
OmarAlesharie
|
1075b4bc42b06c9a3d679ec74a22bcf045baf046
| 386
|
cpp
|
C++
|
lib/zdrot.cpp
|
langou/latl
|
df838fb44a1ef5c77b57bf60bd46eaeff8db3492
|
[
"BSD-3-Clause-Open-MPI"
] | 6
|
2015-12-13T09:10:11.000Z
|
2022-02-09T23:18:22.000Z
|
lib/zdrot.cpp
|
langou/latl
|
df838fb44a1ef5c77b57bf60bd46eaeff8db3492
|
[
"BSD-3-Clause-Open-MPI"
] | null | null | null |
lib/zdrot.cpp
|
langou/latl
|
df838fb44a1ef5c77b57bf60bd46eaeff8db3492
|
[
"BSD-3-Clause-Open-MPI"
] | 2
|
2019-02-01T06:46:36.000Z
|
2022-02-09T23:18:24.000Z
|
//
// zdrot.cpp
// Linear Algebra Template Library
//
// Created by Rodney James on 1/1/13.
// Copyright (c) 2013 University of Colorado Denver. All rights reserved.
//
#include "blas.h"
#include "rot.h"
using LATL::ROT;
int zdrot_(int &n, complex<double> *x, int& incx, complex<double> *y, int& incy, double &C, double &S)
{
ROT<double>(n,x,incx,y,incy,C,S);
return 0;
}
| 19.3
| 102
| 0.65285
|
langou
|
10782735499772ad9308acae174f3a08a9d8ef79
| 5,612
|
cpp
|
C++
|
src/server/lcdapi/sensors/LCDSensor.cpp
|
adriaandegroot/NymphCast
|
730ad80eed58a0e610f110167b39f8a525e306c2
|
[
"BSD-3-Clause"
] | null | null | null |
src/server/lcdapi/sensors/LCDSensor.cpp
|
adriaandegroot/NymphCast
|
730ad80eed58a0e610f110167b39f8a525e306c2
|
[
"BSD-3-Clause"
] | null | null | null |
src/server/lcdapi/sensors/LCDSensor.cpp
|
adriaandegroot/NymphCast
|
730ad80eed58a0e610f110167b39f8a525e306c2
|
[
"BSD-3-Clause"
] | null | null | null |
/* Copyright 2012-2017 Simon Dawson <spdawson@gmail.com>
This file is part of lcdapi.
lcdapi is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation, either version 3 of
the License, or (at your option) any later version.
lcdapi 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 lcdapi. If not,
see <http://www.gnu.org/licenses/>. */
#include <lcdapi/sensors/LCDSensor.h>
#include <lcdapi/api/LCDWidget.h>
#include <lcdapi/api/LCDUtils.h>
#include <cstdio>
#include <cstring>
#include <chrono>
#include <thread>
namespace lcdapi {
using namespace std;
void *updateWhenChanged(void *);
void *updateEach(void *);
const int LCDSensor::MAX_CMD_RESULT_LINE_SIZE = 255;
LCDSensor::LCDSensor()
: _exist(true),
_onChangeThreadStarted(false),
//_onChangeThread(static_cast<pthread_t>(-1)),
_onChangeList(),
_onTimeOutList()
{
}
LCDSensor::~LCDSensor() {
_exist = false;
if (_onChangeThreadStarted) {
if (::pthread_cancel(_onChangeThread) == 0) {
::pthread_join(_onChangeThread, 0);
}
_onChangeThreadStarted = false;
}
for (WidgetTimeOutList::const_iterator it = _onTimeOutList.begin();
it != _onTimeOutList.end(); ++it) {
if (::pthread_cancel(it->second._thread) == 0) {
::pthread_join(it->second._thread, 0);
}
}
}
bool LCDSensor::exists() {
return _exist;
}
void LCDSensor::fireChanged() {
string value = getCurrentValue();
for (WidgetList::const_iterator it = _onChangeList.begin();
it != _onChangeList.end(); ++it) {
if (LCDElement::exists(it->first)) {
it->second->valueCallback(value);
} else {
removeOnChangeWidget(it->first);
}
}
}
const LCDWidgetTimeOut &LCDSensor::getThreadWidgetInfo(const ::pthread_t &thread) {
for (WidgetTimeOutList::const_iterator it = _onTimeOutList.begin();
it != _onTimeOutList.end(); ++it) {
if (::pthread_equal(thread, it->second._thread)) {
return it->second;
}
}
static LCDWidgetTimeOut dummy;
dummy._timeOut = 0;
dummy._widget = 0;
return dummy;
}
string LCDSensor::intToString(int value) {
return LCDUtils::toString(value);
}
string LCDSensor::executeCommand(const string &cmd) {
const string silentCmd = cmd + " 2>/dev/null";
char buf[MAX_CMD_RESULT_LINE_SIZE + 1];
buf[0] = '\0';
FILE *ptr = NULL;
#ifndef _MSC_VER
if ((ptr = popen(silentCmd.c_str(), "r")) != NULL) {
if (NULL == fgets(buf, MAX_CMD_RESULT_LINE_SIZE, ptr)) {
/// \todo Handle error or EOF
}
pclose(ptr);
}
#else
if ((ptr = _popen(silentCmd.c_str(), "r")) != NULL) {
if (NULL == fgets(buf, MAX_CMD_RESULT_LINE_SIZE, ptr)) {
/// \todo Handle error or EOF
}
_pclose(ptr);
}
#endif
// N.B. The length of the string is determined by the first occurrence
// of a null character in the character array.
string result(buf);
// Erase line termination character.
if (!result.empty()) {
result.erase(result.size() - 1, 1);
}
return result;
}
void LCDSensor::addOnChangeWidget(LCDWidget *widget) {
if (!_onChangeThreadStarted) {
::pthread_create(&_onChangeThread, 0, &updateWhenChanged, this);
_onChangeThreadStarted = true;
}
_onChangeList[widget->getId()] = widget;
}
void LCDSensor::removeOnChangeWidget(LCDWidget *widget) {
removeOnChangeWidget(widget->getId());
}
void LCDSensor::removeOnChangeWidget(const string& id) {
_onChangeList.erase(id);
if (_onChangeList.empty() && _onChangeThreadStarted) {
if (::pthread_cancel(_onChangeThread) == 0) {
::pthread_join(_onChangeThread, 0);
}
_onChangeThreadStarted = false;
}
}
void LCDSensor::addOnTimeOutWidget(LCDWidget *widget, int timeout) {
LCDWidgetTimeOut tmpWidget;
tmpWidget._timeOut = timeout;
tmpWidget._widget = widget;
tmpWidget._widgetId = widget->getId();
_onTimeOutList[widget->getId()] = tmpWidget;
::pthread_create(&(_onTimeOutList[widget->getId()]._thread), 0, &updateEach, this);
_onTimeOutList[widget->getId()]._active = true;
}
void LCDSensor::removeOnTimeOutWidget(LCDWidget *widget) {
removeOnTimeOutWidget(widget->getId());
}
void LCDSensor::removeOnTimeOutWidget(const string& id) {
if (::pthread_cancel(_onTimeOutList[id]._thread) == 0) {
::pthread_join(_onTimeOutList[id]._thread, 0);
}
_onTimeOutList.erase(id);
}
void *updateWhenChanged(void *param) {
::pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, 0);
LCDSensor *daddy = static_cast<LCDSensor*>(param);
while (daddy->exists()) {
daddy->waitForChange();
daddy->fireChanged();
}
return NULL;
}
void *updateEach(void *param) {
::pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, 0);
LCDSensor *daddy = static_cast<LCDSensor*>(param);
LCDWidgetTimeOut widgetInfo;
while (!widgetInfo.isValid()) {
widgetInfo = daddy->getThreadWidgetInfo(::pthread_self());
//usleep(10);
using namespace std::chrono_literals;
std::this_thread::sleep_for(10us);
}
while (daddy->exists()) {
if (LCDElement::exists(widgetInfo._widgetId)) {
widgetInfo._widget->valueCallback(daddy->getCurrentValue());
//usleep(widgetInfo._timeOut * 100000);
using namespace std::chrono_literals;
std::this_thread::sleep_for(std::chrono::microseconds(widgetInfo._timeOut * 100000));
::pthread_testcancel();
} else {
daddy->removeOnTimeOutWidget(widgetInfo._widgetId);
}
}
return NULL;
}
} // end of lcdapi namespace
| 25.393665
| 88
| 0.715075
|
adriaandegroot
|
1079948bc3a4f3159500be04eb6f1f02607337e0
| 21,769
|
cc
|
C++
|
src/core/ext/filters/client_channel/subchannel_stream_client.cc
|
temawi/grpc
|
4bcfbcd8025ff5b28206895b4ac9139eb8474cb6
|
[
"Apache-2.0"
] | null | null | null |
src/core/ext/filters/client_channel/subchannel_stream_client.cc
|
temawi/grpc
|
4bcfbcd8025ff5b28206895b4ac9139eb8474cb6
|
[
"Apache-2.0"
] | null | null | null |
src/core/ext/filters/client_channel/subchannel_stream_client.cc
|
temawi/grpc
|
4bcfbcd8025ff5b28206895b4ac9139eb8474cb6
|
[
"Apache-2.0"
] | null | null | null |
//
// Copyright 2018 gRPC 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 <grpc/support/port_platform.h>
#include "src/core/ext/filters/client_channel/subchannel_stream_client.h"
#include <stdint.h>
#include <stdio.h>
#include <grpc/status.h>
#include "src/core/lib/gprpp/sync.h"
#include "src/core/lib/resource_quota/api.h"
#include "src/core/lib/slice/slice_internal.h"
#include "src/core/lib/transport/error_utils.h"
#define SUBCHANNEL_STREAM_INITIAL_CONNECT_BACKOFF_SECONDS 1
#define SUBCHANNEL_STREAM_RECONNECT_BACKOFF_MULTIPLIER 1.6
#define SUBCHANNEL_STREAM_RECONNECT_MAX_BACKOFF_SECONDS 120
#define SUBCHANNEL_STREAM_RECONNECT_JITTER 0.2
namespace grpc_core {
//
// SubchannelStreamClient
//
SubchannelStreamClient::SubchannelStreamClient(
RefCountedPtr<ConnectedSubchannel> connected_subchannel,
grpc_pollset_set* interested_parties,
std::unique_ptr<CallEventHandler> event_handler, const char* tracer)
: InternallyRefCounted<SubchannelStreamClient>(tracer),
connected_subchannel_(std::move(connected_subchannel)),
interested_parties_(interested_parties),
tracer_(tracer),
call_allocator_(
ResourceQuotaFromChannelArgs(connected_subchannel_->args())
->memory_quota()
->CreateMemoryAllocator(
(tracer != nullptr) ? tracer : "SubchannelStreamClient")),
event_handler_(std::move(event_handler)),
retry_backoff_(
BackOff::Options()
.set_initial_backoff(Duration::Seconds(
SUBCHANNEL_STREAM_INITIAL_CONNECT_BACKOFF_SECONDS))
.set_multiplier(SUBCHANNEL_STREAM_RECONNECT_BACKOFF_MULTIPLIER)
.set_jitter(SUBCHANNEL_STREAM_RECONNECT_JITTER)
.set_max_backoff(Duration::Seconds(
SUBCHANNEL_STREAM_RECONNECT_MAX_BACKOFF_SECONDS))) {
if (GPR_UNLIKELY(tracer_ != nullptr)) {
gpr_log(GPR_INFO, "%s %p: created SubchannelStreamClient", tracer_, this);
}
GRPC_CLOSURE_INIT(&retry_timer_callback_, OnRetryTimer, this,
grpc_schedule_on_exec_ctx);
StartCall();
}
SubchannelStreamClient::~SubchannelStreamClient() {
if (GPR_UNLIKELY(tracer_ != nullptr)) {
gpr_log(GPR_INFO, "%s %p: destroying SubchannelStreamClient", tracer_,
this);
}
}
void SubchannelStreamClient::Orphan() {
if (GPR_UNLIKELY(tracer_ != nullptr)) {
gpr_log(GPR_INFO, "%s %p: SubchannelStreamClient shutting down", tracer_,
this);
}
{
MutexLock lock(&mu_);
event_handler_.reset();
call_state_.reset();
if (retry_timer_callback_pending_) {
grpc_timer_cancel(&retry_timer_);
}
}
Unref(DEBUG_LOCATION, "orphan");
}
void SubchannelStreamClient::StartCall() {
MutexLock lock(&mu_);
StartCallLocked();
}
void SubchannelStreamClient::StartCallLocked() {
if (event_handler_ == nullptr) return;
GPR_ASSERT(call_state_ == nullptr);
if (event_handler_ != nullptr) {
event_handler_->OnCallStartLocked(this);
}
call_state_ = MakeOrphanable<CallState>(Ref(), interested_parties_);
if (GPR_UNLIKELY(tracer_ != nullptr)) {
gpr_log(GPR_INFO, "%s %p: SubchannelStreamClient created CallState %p",
tracer_, this, call_state_.get());
}
call_state_->StartCallLocked();
}
void SubchannelStreamClient::StartRetryTimerLocked() {
if (event_handler_ != nullptr) {
event_handler_->OnRetryTimerStartLocked(this);
}
Timestamp next_try = retry_backoff_.NextAttemptTime();
if (GPR_UNLIKELY(tracer_ != nullptr)) {
gpr_log(GPR_INFO, "%s %p: SubchannelStreamClient health check call lost...",
tracer_, this);
Duration timeout = next_try - ExecCtx::Get()->Now();
if (timeout > Duration::Zero()) {
gpr_log(GPR_INFO, "%s %p: ... will retry in %" PRId64 "ms.", tracer_,
this, timeout.millis());
} else {
gpr_log(GPR_INFO, "%s %p: ... retrying immediately.", tracer_, this);
}
}
// Ref for callback, tracked manually.
Ref(DEBUG_LOCATION, "health_retry_timer").release();
retry_timer_callback_pending_ = true;
grpc_timer_init(&retry_timer_, next_try, &retry_timer_callback_);
}
void SubchannelStreamClient::OnRetryTimer(void* arg, grpc_error_handle error) {
auto* self = static_cast<SubchannelStreamClient*>(arg);
{
MutexLock lock(&self->mu_);
self->retry_timer_callback_pending_ = false;
if (self->event_handler_ != nullptr && error == GRPC_ERROR_NONE &&
self->call_state_ == nullptr) {
if (GPR_UNLIKELY(self->tracer_ != nullptr)) {
gpr_log(GPR_INFO,
"%s %p: SubchannelStreamClient restarting health check call",
self->tracer_, self);
}
self->StartCallLocked();
}
}
self->Unref(DEBUG_LOCATION, "health_retry_timer");
}
//
// SubchannelStreamClient::CallState
//
SubchannelStreamClient::CallState::CallState(
RefCountedPtr<SubchannelStreamClient> health_check_client,
grpc_pollset_set* interested_parties)
: subchannel_stream_client_(std::move(health_check_client)),
pollent_(grpc_polling_entity_create_from_pollset_set(interested_parties)),
arena_(Arena::Create(subchannel_stream_client_->connected_subchannel_
->GetInitialCallSizeEstimate(),
&subchannel_stream_client_->call_allocator_)),
payload_(context_),
send_initial_metadata_(arena_.get()),
send_trailing_metadata_(arena_.get()),
recv_initial_metadata_(arena_.get()),
recv_trailing_metadata_(arena_.get()) {}
SubchannelStreamClient::CallState::~CallState() {
if (GPR_UNLIKELY(subchannel_stream_client_->tracer_ != nullptr)) {
gpr_log(GPR_INFO, "%s %p: SubchannelStreamClient destroying CallState %p",
subchannel_stream_client_->tracer_, subchannel_stream_client_.get(),
this);
}
for (size_t i = 0; i < GRPC_CONTEXT_COUNT; ++i) {
if (context_[i].destroy != nullptr) {
context_[i].destroy(context_[i].value);
}
}
// Unset the call combiner cancellation closure. This has the
// effect of scheduling the previously set cancellation closure, if
// any, so that it can release any internal references it may be
// holding to the call stack.
call_combiner_.SetNotifyOnCancel(nullptr);
}
void SubchannelStreamClient::CallState::Orphan() {
call_combiner_.Cancel(GRPC_ERROR_CANCELLED);
Cancel();
}
void SubchannelStreamClient::CallState::StartCallLocked() {
SubchannelCall::Args args = {
subchannel_stream_client_->connected_subchannel_,
&pollent_,
Slice::FromStaticString("/grpc.health.v1.Health/Watch"),
gpr_get_cycle_counter(), // start_time
Timestamp::InfFuture(), // deadline
arena_.get(),
context_,
&call_combiner_,
};
grpc_error_handle error = GRPC_ERROR_NONE;
call_ = SubchannelCall::Create(std::move(args), &error).release();
// Register after-destruction callback.
GRPC_CLOSURE_INIT(&after_call_stack_destruction_, AfterCallStackDestruction,
this, grpc_schedule_on_exec_ctx);
call_->SetAfterCallStackDestroy(&after_call_stack_destruction_);
// Check if creation failed.
if (error != GRPC_ERROR_NONE ||
subchannel_stream_client_->event_handler_ == nullptr) {
gpr_log(GPR_ERROR,
"SubchannelStreamClient %p CallState %p: error creating "
"stream on subchannel (%s); will retry",
subchannel_stream_client_.get(), this,
grpc_error_std_string(error).c_str());
GRPC_ERROR_UNREF(error);
CallEndedLocked(/*retry=*/true);
return;
}
// Initialize payload and batch.
payload_.context = context_;
batch_.payload = &payload_;
// on_complete callback takes ref, handled manually.
call_->Ref(DEBUG_LOCATION, "on_complete").release();
batch_.on_complete = GRPC_CLOSURE_INIT(&on_complete_, OnComplete, this,
grpc_schedule_on_exec_ctx);
// Add send_initial_metadata op.
send_initial_metadata_.Set(
HttpPathMetadata(),
subchannel_stream_client_->event_handler_->GetPathLocked());
GPR_ASSERT(error == GRPC_ERROR_NONE);
payload_.send_initial_metadata.send_initial_metadata =
&send_initial_metadata_;
payload_.send_initial_metadata.send_initial_metadata_flags = 0;
payload_.send_initial_metadata.peer_string = nullptr;
batch_.send_initial_metadata = true;
// Add send_message op.
grpc_slice request_slice =
subchannel_stream_client_->event_handler_->EncodeSendMessageLocked();
grpc_slice_buffer slice_buffer;
grpc_slice_buffer_init(&slice_buffer);
grpc_slice_buffer_add(&slice_buffer, request_slice);
send_message_.emplace(&slice_buffer, 0);
grpc_slice_buffer_destroy_internal(&slice_buffer);
payload_.send_message.send_message.reset(&*send_message_);
batch_.send_message = true;
// Add send_trailing_metadata op.
payload_.send_trailing_metadata.send_trailing_metadata =
&send_trailing_metadata_;
batch_.send_trailing_metadata = true;
// Add recv_initial_metadata op.
payload_.recv_initial_metadata.recv_initial_metadata =
&recv_initial_metadata_;
payload_.recv_initial_metadata.recv_flags = nullptr;
payload_.recv_initial_metadata.trailing_metadata_available = nullptr;
payload_.recv_initial_metadata.peer_string = nullptr;
// recv_initial_metadata_ready callback takes ref, handled manually.
call_->Ref(DEBUG_LOCATION, "recv_initial_metadata_ready").release();
payload_.recv_initial_metadata.recv_initial_metadata_ready =
GRPC_CLOSURE_INIT(&recv_initial_metadata_ready_, RecvInitialMetadataReady,
this, grpc_schedule_on_exec_ctx);
batch_.recv_initial_metadata = true;
// Add recv_message op.
payload_.recv_message.recv_message = &recv_message_;
payload_.recv_message.call_failed_before_recv_message = nullptr;
// recv_message callback takes ref, handled manually.
call_->Ref(DEBUG_LOCATION, "recv_message_ready").release();
payload_.recv_message.recv_message_ready = GRPC_CLOSURE_INIT(
&recv_message_ready_, RecvMessageReady, this, grpc_schedule_on_exec_ctx);
batch_.recv_message = true;
// Start batch.
StartBatch(&batch_);
// Initialize recv_trailing_metadata batch.
recv_trailing_metadata_batch_.payload = &payload_;
// Add recv_trailing_metadata op.
payload_.recv_trailing_metadata.recv_trailing_metadata =
&recv_trailing_metadata_;
payload_.recv_trailing_metadata.collect_stats = &collect_stats_;
// This callback signals the end of the call, so it relies on the
// initial ref instead of taking a new ref. When it's invoked, the
// initial ref is released.
payload_.recv_trailing_metadata.recv_trailing_metadata_ready =
GRPC_CLOSURE_INIT(&recv_trailing_metadata_ready_,
RecvTrailingMetadataReady, this,
grpc_schedule_on_exec_ctx);
recv_trailing_metadata_batch_.recv_trailing_metadata = true;
// Start recv_trailing_metadata batch.
StartBatch(&recv_trailing_metadata_batch_);
}
void SubchannelStreamClient::CallState::StartBatchInCallCombiner(
void* arg, grpc_error_handle /*error*/) {
auto* batch = static_cast<grpc_transport_stream_op_batch*>(arg);
auto* call = static_cast<SubchannelCall*>(batch->handler_private.extra_arg);
call->StartTransportStreamOpBatch(batch);
}
void SubchannelStreamClient::CallState::StartBatch(
grpc_transport_stream_op_batch* batch) {
batch->handler_private.extra_arg = call_;
GRPC_CLOSURE_INIT(&batch->handler_private.closure, StartBatchInCallCombiner,
batch, grpc_schedule_on_exec_ctx);
GRPC_CALL_COMBINER_START(&call_combiner_, &batch->handler_private.closure,
GRPC_ERROR_NONE, "start_subchannel_batch");
}
void SubchannelStreamClient::CallState::AfterCallStackDestruction(
void* arg, grpc_error_handle /*error*/) {
auto* self = static_cast<SubchannelStreamClient::CallState*>(arg);
delete self;
}
void SubchannelStreamClient::CallState::OnCancelComplete(
void* arg, grpc_error_handle /*error*/) {
auto* self = static_cast<SubchannelStreamClient::CallState*>(arg);
GRPC_CALL_COMBINER_STOP(&self->call_combiner_, "health_cancel");
self->call_->Unref(DEBUG_LOCATION, "cancel");
}
void SubchannelStreamClient::CallState::StartCancel(
void* arg, grpc_error_handle /*error*/) {
auto* self = static_cast<SubchannelStreamClient::CallState*>(arg);
auto* batch = grpc_make_transport_stream_op(
GRPC_CLOSURE_CREATE(OnCancelComplete, self, grpc_schedule_on_exec_ctx));
batch->cancel_stream = true;
batch->payload->cancel_stream.cancel_error = GRPC_ERROR_CANCELLED;
self->call_->StartTransportStreamOpBatch(batch);
}
void SubchannelStreamClient::CallState::Cancel() {
bool expected = false;
if (cancelled_.compare_exchange_strong(expected, true,
std::memory_order_acq_rel,
std::memory_order_acquire)) {
call_->Ref(DEBUG_LOCATION, "cancel").release();
GRPC_CALL_COMBINER_START(
&call_combiner_,
GRPC_CLOSURE_CREATE(StartCancel, this, grpc_schedule_on_exec_ctx),
GRPC_ERROR_NONE, "health_cancel");
}
}
void SubchannelStreamClient::CallState::OnComplete(
void* arg, grpc_error_handle /*error*/) {
auto* self = static_cast<SubchannelStreamClient::CallState*>(arg);
GRPC_CALL_COMBINER_STOP(&self->call_combiner_, "on_complete");
self->send_initial_metadata_.Clear();
self->send_trailing_metadata_.Clear();
self->call_->Unref(DEBUG_LOCATION, "on_complete");
}
void SubchannelStreamClient::CallState::RecvInitialMetadataReady(
void* arg, grpc_error_handle /*error*/) {
auto* self = static_cast<SubchannelStreamClient::CallState*>(arg);
GRPC_CALL_COMBINER_STOP(&self->call_combiner_, "recv_initial_metadata_ready");
self->recv_initial_metadata_.Clear();
self->call_->Unref(DEBUG_LOCATION, "recv_initial_metadata_ready");
}
void SubchannelStreamClient::CallState::DoneReadingRecvMessage(
grpc_error_handle error) {
recv_message_.reset();
if (error != GRPC_ERROR_NONE) {
GRPC_ERROR_UNREF(error);
Cancel();
grpc_slice_buffer_destroy_internal(&recv_message_buffer_);
call_->Unref(DEBUG_LOCATION, "recv_message_ready");
return;
}
// Concatenate the slices to form a single string.
std::unique_ptr<uint8_t> recv_message_deleter;
uint8_t* recv_message;
if (recv_message_buffer_.count == 1) {
recv_message = GRPC_SLICE_START_PTR(recv_message_buffer_.slices[0]);
} else {
recv_message =
static_cast<uint8_t*>(gpr_malloc(recv_message_buffer_.length));
recv_message_deleter.reset(recv_message);
size_t offset = 0;
for (size_t i = 0; i < recv_message_buffer_.count; ++i) {
memcpy(recv_message + offset,
GRPC_SLICE_START_PTR(recv_message_buffer_.slices[i]),
GRPC_SLICE_LENGTH(recv_message_buffer_.slices[i]));
offset += GRPC_SLICE_LENGTH(recv_message_buffer_.slices[i]);
}
}
// Report payload.
{
MutexLock lock(&subchannel_stream_client_->mu_);
if (subchannel_stream_client_->event_handler_ != nullptr) {
absl::string_view serialized_message(
reinterpret_cast<char*>(recv_message), recv_message_buffer_.length);
absl::Status status =
subchannel_stream_client_->event_handler_->RecvMessageReadyLocked(
subchannel_stream_client_.get(), serialized_message);
if (!status.ok()) {
if (GPR_UNLIKELY(subchannel_stream_client_->tracer_ != nullptr)) {
gpr_log(GPR_INFO,
"%s %p: SubchannelStreamClient CallState %p: failed to "
"parse response message: %s",
subchannel_stream_client_->tracer_,
subchannel_stream_client_.get(), this,
status.ToString().c_str());
}
Cancel();
}
}
}
seen_response_.store(true, std::memory_order_release);
grpc_slice_buffer_destroy_internal(&recv_message_buffer_);
// Start another recv_message batch.
// This re-uses the ref we're holding.
// Note: Can't just reuse batch_ here, since we don't know that all
// callbacks from the original batch have completed yet.
recv_message_batch_.payload = &payload_;
payload_.recv_message.recv_message = &recv_message_;
payload_.recv_message.call_failed_before_recv_message = nullptr;
payload_.recv_message.recv_message_ready = GRPC_CLOSURE_INIT(
&recv_message_ready_, RecvMessageReady, this, grpc_schedule_on_exec_ctx);
recv_message_batch_.recv_message = true;
StartBatch(&recv_message_batch_);
}
grpc_error_handle
SubchannelStreamClient::CallState::PullSliceFromRecvMessage() {
grpc_slice slice;
grpc_error_handle error = recv_message_->Pull(&slice);
if (error == GRPC_ERROR_NONE) {
grpc_slice_buffer_add(&recv_message_buffer_, slice);
}
return error;
}
void SubchannelStreamClient::CallState::ContinueReadingRecvMessage() {
while (recv_message_->Next(SIZE_MAX, &recv_message_ready_)) {
grpc_error_handle error = PullSliceFromRecvMessage();
if (error != GRPC_ERROR_NONE) {
DoneReadingRecvMessage(error);
return;
}
if (recv_message_buffer_.length == recv_message_->length()) {
DoneReadingRecvMessage(GRPC_ERROR_NONE);
break;
}
}
}
void SubchannelStreamClient::CallState::OnByteStreamNext(
void* arg, grpc_error_handle error) {
auto* self = static_cast<SubchannelStreamClient::CallState*>(arg);
if (error != GRPC_ERROR_NONE) {
self->DoneReadingRecvMessage(GRPC_ERROR_REF(error));
return;
}
error = self->PullSliceFromRecvMessage();
if (error != GRPC_ERROR_NONE) {
self->DoneReadingRecvMessage(error);
return;
}
if (self->recv_message_buffer_.length == self->recv_message_->length()) {
self->DoneReadingRecvMessage(GRPC_ERROR_NONE);
} else {
self->ContinueReadingRecvMessage();
}
}
void SubchannelStreamClient::CallState::RecvMessageReady(
void* arg, grpc_error_handle /*error*/) {
auto* self = static_cast<SubchannelStreamClient::CallState*>(arg);
GRPC_CALL_COMBINER_STOP(&self->call_combiner_, "recv_message_ready");
if (self->recv_message_ == nullptr) {
self->call_->Unref(DEBUG_LOCATION, "recv_message_ready");
return;
}
grpc_slice_buffer_init(&self->recv_message_buffer_);
GRPC_CLOSURE_INIT(&self->recv_message_ready_, OnByteStreamNext, self,
grpc_schedule_on_exec_ctx);
self->ContinueReadingRecvMessage();
// Ref will continue to be held until we finish draining the byte stream.
}
void SubchannelStreamClient::CallState::RecvTrailingMetadataReady(
void* arg, grpc_error_handle error) {
auto* self = static_cast<SubchannelStreamClient::CallState*>(arg);
GRPC_CALL_COMBINER_STOP(&self->call_combiner_,
"recv_trailing_metadata_ready");
// Get call status.
grpc_status_code status =
self->recv_trailing_metadata_.get(GrpcStatusMetadata())
.value_or(GRPC_STATUS_UNKNOWN);
if (error != GRPC_ERROR_NONE) {
grpc_error_get_status(error, Timestamp::InfFuture(), &status,
nullptr /* slice */, nullptr /* http_error */,
nullptr /* error_string */);
}
if (GPR_UNLIKELY(self->subchannel_stream_client_->tracer_ != nullptr)) {
gpr_log(GPR_INFO,
"%s %p: SubchannelStreamClient CallState %p: health watch failed "
"with status %d",
self->subchannel_stream_client_->tracer_,
self->subchannel_stream_client_.get(), self, status);
}
// Clean up.
self->recv_trailing_metadata_.Clear();
// Report call end.
MutexLock lock(&self->subchannel_stream_client_->mu_);
if (self->subchannel_stream_client_->event_handler_ != nullptr) {
self->subchannel_stream_client_->event_handler_
->RecvTrailingMetadataReadyLocked(self->subchannel_stream_client_.get(),
status);
}
// For status UNIMPLEMENTED, give up and assume always healthy.
self->CallEndedLocked(/*retry=*/status != GRPC_STATUS_UNIMPLEMENTED);
}
void SubchannelStreamClient::CallState::CallEndedLocked(bool retry) {
// If this CallState is still in use, this call ended because of a failure,
// so we need to stop using it and optionally create a new one.
// Otherwise, we have deliberately ended this call, and no further action
// is required.
if (this == subchannel_stream_client_->call_state_.get()) {
subchannel_stream_client_->call_state_.reset();
if (retry) {
GPR_ASSERT(subchannel_stream_client_->event_handler_ != nullptr);
if (seen_response_.load(std::memory_order_acquire)) {
// If the call fails after we've gotten a successful response, reset
// the backoff and restart the call immediately.
subchannel_stream_client_->retry_backoff_.Reset();
subchannel_stream_client_->StartCallLocked();
} else {
// If the call failed without receiving any messages, retry later.
subchannel_stream_client_->StartRetryTimerLocked();
}
}
}
// When the last ref to the call stack goes away, the CallState object
// will be automatically destroyed.
call_->Unref(DEBUG_LOCATION, "call_ended");
}
} // namespace grpc_core
| 39.869963
| 80
| 0.720474
|
temawi
|
1079f5dd440bc601983f505b0662deb9392e0302
| 9,188
|
cpp
|
C++
|
oneflow/user/kernels/eager_s_to_b_kernel.cpp
|
dssgsra/oneflow
|
47e85b05c15d68ef9ed3b8dfd03c469aec6b8e15
|
[
"Apache-2.0"
] | null | null | null |
oneflow/user/kernels/eager_s_to_b_kernel.cpp
|
dssgsra/oneflow
|
47e85b05c15d68ef9ed3b8dfd03c469aec6b8e15
|
[
"Apache-2.0"
] | null | null | null |
oneflow/user/kernels/eager_s_to_b_kernel.cpp
|
dssgsra/oneflow
|
47e85b05c15d68ef9ed3b8dfd03c469aec6b8e15
|
[
"Apache-2.0"
] | null | null | null |
/*
Copyright 2020 The OneFlow 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 "oneflow/user/kernels/communicate_util.h"
#include "oneflow/core/device/nccl_util.h"
#include "oneflow/core/common/container_util.h"
#include "oneflow/core/framework/framework.h"
#include "oneflow/core/kernel/new_kernel_util.h"
#include "oneflow/core/job/parallel_desc.h"
#include "oneflow/core/control/global_process_ctx.h"
#include "oneflow/core/framework/placement_sbp_util.h"
#include "oneflow/core/job/nd_sbp_util.h"
#include "oneflow/core/register/tensor_slice_copier.h"
namespace oneflow {
namespace {
Maybe<Symbol<cfg::NdSbp>> GetAllSplitNdSbp(int64_t axis, int64_t ndim) {
cfg::NdSbp split_nd_sbp;
for (int64_t i = 0; i < ndim; ++i) {
split_nd_sbp.mutable_sbp_parallel()->Add()->mutable_split_parallel()->set_axis(axis);
}
return SymbolOf(split_nd_sbp);
}
auto* CachedGetAllSplitNdSbp = DECORATE(&GetAllSplitNdSbp, ThreadLocal);
Maybe<Symbol<cfg::NdSbp>> GetAllBroadcastNdSbp(int64_t ndim) {
cfg::NdSbp split_nd_sbp;
for (int64_t i = 0; i < ndim; ++i) {
split_nd_sbp.mutable_sbp_parallel()->Add()->mutable_broadcast_parallel();
}
return SymbolOf(split_nd_sbp);
}
auto* CachedGetAllBroadcastNdSbp = DECORATE(&GetAllBroadcastNdSbp, ThreadLocal);
class EagerSToBOpKernelState final : public user_op::OpKernelState {
public:
explicit EagerSToBOpKernelState(user_op::KernelInitContext* ctx) { Init(ctx); }
~EagerSToBOpKernelState() override = default;
const std::vector<std::pair<int64_t, std::shared_ptr<TensorSliceCopier>>>&
sorted_elem_cnt2in_tensor_slice_copier_pair() const {
return sorted_elem_cnt2in_tensor_slice_copier_pair_;
}
const std::vector<std::pair<int64_t, std::shared_ptr<TensorSliceCopier>>>&
sorted_elem_cnt2out_tensor_slice_copier_pair() const {
return sorted_elem_cnt2out_tensor_slice_copier_pair_;
}
const std::vector<std::pair<int64_t, int64_t>>& sorted_p2p_pair() const {
return sorted_p2p_pair_;
}
private:
void Init(user_op::KernelInitContext* ctx) {
const std::string& in_parallel_conf_txt = ctx->Attr<std::string>("in_parallel_conf");
const std::string& out_parallel_conf_txt = ctx->Attr<std::string>("out_parallel_conf");
const int64_t in_split_axis = ctx->Attr<int64_t>("in_split_axis");
const Shape& shape = ctx->Attr<Shape>("shape");
DeviceType device_type = ctx->device_type();
DataType data_type = ctx->TensorDesc4ArgNameAndIndex("in", 0)->data_type();
Symbol<ParallelDesc> in_parallel_desc = CHECK_JUST(TxtStringToPlacement(in_parallel_conf_txt));
Symbol<ParallelDesc> out_parallel_desc =
CHECK_JUST(TxtStringToPlacement(out_parallel_conf_txt));
int64_t out_parallel_num = out_parallel_desc->parallel_num();
int64_t in_parallel_num = in_parallel_desc->parallel_num();
for (int64_t out_parallel_id = 0; out_parallel_id < out_parallel_num; ++out_parallel_id) {
int64_t dst = CHECK_JUST(out_parallel_desc->MachineId4ParallelId(out_parallel_id));
const TensorSliceView& out_slice = GetTensorSliceView4ParallelId(
*out_parallel_desc->hierarchy(),
*CHECK_JUST(CachedGetAllBroadcastNdSbp(out_parallel_desc->hierarchy()->NumAxes())), shape,
out_parallel_id);
CHECK(!out_slice.IsEmpty());
for (int64_t in_parallel_id = 0; in_parallel_id < in_parallel_num; ++in_parallel_id) {
int64_t src = CHECK_JUST(in_parallel_desc->MachineId4ParallelId(in_parallel_id));
const TensorSliceView& in_slice = GetTensorSliceView4ParallelId(
*in_parallel_desc->hierarchy(),
*CHECK_JUST(
CachedGetAllSplitNdSbp(in_split_axis, in_parallel_desc->hierarchy()->NumAxes())),
shape, in_parallel_id);
CHECK(!in_slice.IsEmpty());
const TensorSliceView& intersection = out_slice.Intersect(in_slice);
CHECK(!intersection.IsEmpty());
sorted_p2p_pair_.emplace_back(std::make_pair(src, dst));
sorted_elem_cnt2in_tensor_slice_copier_pair_.emplace_back(std::make_pair(
intersection.shape().elem_cnt(),
std::make_shared<TensorSliceCopier>(intersection, in_slice, data_type, device_type)));
sorted_elem_cnt2out_tensor_slice_copier_pair_.emplace_back(std::make_pair(
intersection.shape().elem_cnt(),
std::make_shared<TensorSliceCopier>(out_slice, intersection, data_type, device_type)));
}
}
}
std::vector<std::pair<int64_t, std::shared_ptr<TensorSliceCopier>>>
sorted_elem_cnt2in_tensor_slice_copier_pair_;
std::vector<std::pair<int64_t, std::shared_ptr<TensorSliceCopier>>>
sorted_elem_cnt2out_tensor_slice_copier_pair_;
std::vector<std::pair<int64_t, int64_t>> sorted_p2p_pair_;
};
size_t InferEagerSToBKernelTmpBufferSize(user_op::InferContext* ctx) {
const user_op::TensorDesc& in_tensor = ctx->InputTensorDesc("in", 0);
const Shape& shape = ctx->Attr<Shape>("shape");
const std::string& in_parallel_conf_txt = ctx->Attr<std::string>("in_parallel_conf");
Symbol<ParallelDesc> in_parallel_desc = CHECK_JUST(TxtStringToPlacement(in_parallel_conf_txt));
int64_t in_parallel_num = in_parallel_desc->parallel_num();
size_t tensor_byte_size =
shape.elem_cnt() / in_parallel_num * GetSizeOfDataType(in_tensor.data_type());
return tensor_byte_size;
}
} // namespace
template<DeviceType device_type>
class EagerSToBKernel final : public user_op::OpKernel {
public:
EagerSToBKernel() = default;
~EagerSToBKernel() override = default;
std::shared_ptr<user_op::OpKernelState> CreateOpKernelState(
user_op::KernelInitContext* ctx) const override {
return std::make_shared<EagerSToBOpKernelState>(ctx);
}
private:
void Compute(user_op::KernelComputeContext* ctx, user_op::OpKernelState* state) const override {
auto* kernel_state = dynamic_cast<EagerSToBOpKernelState*>(state);
CHECK(kernel_state != nullptr);
const user_op::Tensor* in = ctx->Tensor4ArgNameAndIndex("in", 0);
user_op::Tensor* out = ctx->Tensor4ArgNameAndIndex("out", 0);
user_op::Tensor* tmp_buffer = ctx->Tensor4ArgNameAndIndex("tmp_buffer", 0);
const void* in_ptr = in->dptr();
void* out_ptr = out->mut_dptr();
void* tmp_buffer_ptr = tmp_buffer->mut_dptr();
const auto& sorted_elem_cnt2in_tensor_slice_copier_pair =
kernel_state->sorted_elem_cnt2in_tensor_slice_copier_pair();
const auto& sorted_elem_cnt2out_tensor_slice_copier_pair =
kernel_state->sorted_elem_cnt2out_tensor_slice_copier_pair();
const auto& sorted_p2p_pair = kernel_state->sorted_p2p_pair();
CHECK_EQ(sorted_elem_cnt2in_tensor_slice_copier_pair.size(), sorted_p2p_pair.size());
CHECK_EQ(sorted_elem_cnt2out_tensor_slice_copier_pair.size(), sorted_p2p_pair.size());
for (int64_t i = 0; i < sorted_p2p_pair.size(); ++i) {
const auto& p2p_pair = sorted_p2p_pair.at(i);
int64_t src = p2p_pair.first;
int64_t dst = p2p_pair.second;
if (GlobalProcessCtx::Rank() == src) {
const auto& elem_cnt2tensor_slice_copier_pair =
sorted_elem_cnt2in_tensor_slice_copier_pair.at(i);
const auto& elem_cnt = elem_cnt2tensor_slice_copier_pair.first;
const auto& tensor_slice_copier = elem_cnt2tensor_slice_copier_pair.second;
tensor_slice_copier->Copy(ctx->stream(), tmp_buffer_ptr, in_ptr);
CHECK_JUST(Send<device_type>(reinterpret_cast<const void*>(tmp_buffer_ptr), elem_cnt,
in->data_type(), dst, ctx->device_ctx()));
}
if (GlobalProcessCtx::Rank() == dst) {
const auto& elem_cnt2tensor_slice_copier_pair =
sorted_elem_cnt2out_tensor_slice_copier_pair.at(i);
const auto& elem_cnt = elem_cnt2tensor_slice_copier_pair.first;
const auto& tensor_slice_copier = elem_cnt2tensor_slice_copier_pair.second;
CHECK_JUST(
Recv<device_type>(tmp_buffer_ptr, elem_cnt, out->data_type(), src, ctx->device_ctx()));
tensor_slice_copier->Copy(ctx->stream(), out_ptr,
reinterpret_cast<const void*>(tmp_buffer_ptr));
}
}
}
bool AlwaysComputeWhenAllOutputsEmpty() const override { return false; }
};
#define REGISTER_EAGER_S_TO_B_KERNEL(device) \
REGISTER_USER_KERNEL("eager_s_to_b") \
.SetCreateFn<EagerSToBKernel<device>>() \
.SetIsMatchedHob(user_op::HobDeviceType() == device) \
.SetInferTmpSizeFn(InferEagerSToBKernelTmpBufferSize);
REGISTER_EAGER_S_TO_B_KERNEL(DeviceType::kCPU)
#if defined(WITH_CUDA) && HAS_GPU_SEND_RECV
REGISTER_EAGER_S_TO_B_KERNEL(DeviceType::kGPU)
#endif
} // namespace oneflow
| 45.485149
| 100
| 0.735851
|
dssgsra
|
107b40d28b4287d78b6fdaaaa39e13b2166eab9b
| 1,971
|
cpp
|
C++
|
sdk_core/src/command_handler/hub_command_handler.cpp
|
elapidae/Livox-SDK
|
c51d62ab2a6ce7dd8efb059da6600b755ea75a39
|
[
"BSL-1.0",
"Apache-2.0",
"BSD-3-Clause"
] | null | null | null |
sdk_core/src/command_handler/hub_command_handler.cpp
|
elapidae/Livox-SDK
|
c51d62ab2a6ce7dd8efb059da6600b755ea75a39
|
[
"BSL-1.0",
"Apache-2.0",
"BSD-3-Clause"
] | null | null | null |
sdk_core/src/command_handler/hub_command_handler.cpp
|
elapidae/Livox-SDK
|
c51d62ab2a6ce7dd8efb059da6600b755ea75a39
|
[
"BSL-1.0",
"Apache-2.0",
"BSD-3-Clause"
] | null | null | null |
//
// The MIT License (MIT)
//
// Copyright (c) 2019 Livox. All rights reserved.
//
// 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 "hub_command_handler.h"
#include "base/network_util.h"
namespace livox {
void HubCommandHandlerImpl::Uninit() {
if (channel_) {
channel_.reset(NULL);
}
is_valid_ = false;
}
bool HubCommandHandlerImpl::AddDevice(const DeviceInfo &info) {
if (is_valid_) {
return false;
}
is_valid_ = true;
hub_info_ = info;
channel_.reset(new CommandChannel(info.cmd_port, info.handle, info.ip, this, mem_pool_));
channel_->Bind(loop_);
return true;
}
bool HubCommandHandlerImpl::SendCommand(uint8_t, const Command &command) {
if (channel_ == NULL) {
return false;
}
channel_->SendAsync(command);
return true;
}
bool HubCommandHandlerImpl::RemoveDevice(uint8_t) {
is_valid_ = false;
if (channel_) {
channel_.reset(NULL);
}
return false;
}
} // namespace livox
| 29.863636
| 91
| 0.73313
|
elapidae
|
107ee4e37164cc7ae0cfb0a51f402c2cf65c4bfc
| 55
|
cc
|
C++
|
wobblepy/core.cc
|
spanezz/wobblepy
|
29850f5e1257d58f5e35af93bf362ddda9edf0e5
|
[
"BSD-3-Clause"
] | null | null | null |
wobblepy/core.cc
|
spanezz/wobblepy
|
29850f5e1257d58f5e35af93bf362ddda9edf0e5
|
[
"BSD-3-Clause"
] | null | null | null |
wobblepy/core.cc
|
spanezz/wobblepy
|
29850f5e1257d58f5e35af93bf362ddda9edf0e5
|
[
"BSD-3-Clause"
] | null | null | null |
#include "core.h"
namespace wobblepy {
} // wobblepy
| 9.166667
| 20
| 0.672727
|
spanezz
|
108275c2ad36506c49e72fec288ffa7f923e8ba1
| 849
|
cpp
|
C++
|
recursive/Recursion/src/fiboniciseriesrecursive.cpp
|
ShaliniThiyagarajan/Datastructure_and_Algorithm
|
d57551883cdd6bc65eab2b67d1edbdbf9dc97f0d
|
[
"MIT"
] | null | null | null |
recursive/Recursion/src/fiboniciseriesrecursive.cpp
|
ShaliniThiyagarajan/Datastructure_and_Algorithm
|
d57551883cdd6bc65eab2b67d1edbdbf9dc97f0d
|
[
"MIT"
] | null | null | null |
recursive/Recursion/src/fiboniciseriesrecursive.cpp
|
ShaliniThiyagarajan/Datastructure_and_Algorithm
|
d57551883cdd6bc65eab2b67d1edbdbf9dc97f0d
|
[
"MIT"
] | null | null | null |
/*
* fiboniciseriesrecursive.cpp
*
* Created on: 17-Dec-2021
* Author: acer
*/
#include<iostream>
#include<stdio.h>
using namespace std;
int fibanic(int n)
{
if(n<=1)
return n;
return fibanic( n-1)+fibanic( n-2);
}
int fibanic1(int n)
{
int t1=0,t2=1,f;
if(n<=1)
{
return n;
}
for(int i=2;i<=n;i++)
{
f=t1+t2;
t1=t2;
t2=f;
}
return f;
}
int f[10];
int fibanici(int n)
{
if(n<=1)
{
f[n]=n;
return n;
}
else
{
if(f[n-1]==-1)
{
f[n-1]=fibanici(n-1);
}
if(f[n-2]==-1)
{
f[n-2]=fibanici(n-2);
}
f[n]=f[n-2]+f[n-1];
return f[n-1]+f[n-2];
}
}
int main()
{
int n;
cin>>n;
for (int i=0;i<10;i++)
f[i]=-1;
cout<<"fibonacci series of "<<n<<" is "<<fibanic1(n)<<endl;
cout<<"fibonacci series of "<<n<<" is "<<fibanici(n)<<endl;
cout<<"fibonacci series of "<<n<<" is "<<fibanic(n);
}
| 11.025974
| 60
| 0.526502
|
ShaliniThiyagarajan
|
1085410cb5dd5cd47dc04cf29f221613e31ab58e
| 5,364
|
cpp
|
C++
|
Scenes/HostClient.cpp
|
javics2002/Paella
|
53449d828b09ba63805ea9ee5a2f6b2d178490dc
|
[
"MIT"
] | 4
|
2022-01-29T16:50:42.000Z
|
2022-03-04T09:44:59.000Z
|
Scenes/HostClient.cpp
|
javics2002/Paella
|
53449d828b09ba63805ea9ee5a2f6b2d178490dc
|
[
"MIT"
] | 194
|
2022-01-27T09:47:37.000Z
|
2022-03-31T21:42:06.000Z
|
Scenes/HostClient.cpp
|
javics2002/Paella
|
53449d828b09ba63805ea9ee5a2f6b2d178490dc
|
[
"MIT"
] | 2
|
2022-02-05T10:18:35.000Z
|
2022-03-27T11:52:13.000Z
|
#include "HostClient.h"
#include "../Scenes/Lobby.h"
#include "../Control/NetworkManager.h"
#include "../Scenes/Jornada.h"
#include "../GameObjects/UI/ShowText.h"
#include "../Scenes/Menu.h"
HostClient::HostClient(Game* mGame) : Scene(mGame)
{
mBackground->setTexture("hostClientBg");
mBackground->setPosition(sdlutils().width() / 2, sdlutils().height() / 2);
mBackground->setDimension(sdlutils().width(), sdlutils().height() + 100);
int mOffsetX = 300, mOffsetY = 150;
mParticles = new ParticleExample();
mParticles->setRenderer(sdlutils().renderer());
mParticles->setStyle(ParticleExample::NONE);
UiButton* mBackButton = new UiButton(mGame, "back", 70, 50, 125, 60);
mBackButton->setInitialDimension(mBackButton->getWidth(), mBackButton->getHeight());
mBackButton->setAction([](Game* mGame, bool& exit) {
mGame->sendMessageScene(new Menu(mGame));
});
mUiManager->addButton(mBackButton);
mHostButton = new UiButton(mGame, "cocinera",
sdlutils().width() / 2 - mOffsetX, sdlutils().height() - 350, 500, 700);
mHostButton->setInitialDimension(500, 700);
mHostButton->setAction([](Game* mGame, bool& exit) {
//Host
mGame->getNetworkManager()->init('h', nullptr, mGame->getNombre());
mGame->sendMessageScene(new Lobby(mGame));
});
mUiManager->addButton(mHostButton);
mClientButton = new UiButton(mGame, "camarero",
sdlutils().width() / 2 + mOffsetX, sdlutils().height() - 350, 500, 700);
mClientButton->setInitialDimension(500, 700);
mPosYNotOver = 165;
mPosYOver = 145;
mTextIp = new ShowText(mGame, " ", "ip", mClientButton->getX() + 20, mPosYNotOver);
mTextIp->setActive(true);
mIpNoValida = new ShowText(mGame, "IP NO VALIDA", "ipCursor", mClientButton->getX() + 20, 225);
mIpNoValida->setActive(false);
mRestauranteNoEncontrado = new ShowText(mGame, "Restaurante no encontrado", "ipCursor", mClientButton->getX() + 20, 225);
mRestauranteNoEncontrado->setActive(false);
mCursor = new ShowText(mGame, "|", "ipCursor", mClientButton->getX() + 20, mPosYNotOver);
mCursor->setActive(false);
mClientButton->setAction([this](Game* mGame, bool& exit) {
//Client
if (!mEscribiendo) {
mEscribiendo = true;
ih().clearInputBuffer();
mCursor->setActive(true);
mTime = sdlutils().currRealTime();
}
else {
mIp.erase(remove(mIp.begin(), mIp.end(), ' '), mIp.end());
if (esValida(mIp)) {
if (mGame->getNetworkManager()->init('c', mIp.c_str(), mGame->getNombre())) {
// crear el lobby
mGame->sendMessageScene(new Lobby(mGame, mGame->getNetworkManager()->getOtherName()));
}
else {
mTiempoIpNV = sdlutils().currRealTime();
mRestauranteNoEncontrado->setActive(true);
}
}
else {
mIpNoValida->setActive(true);
mTiempoIpNV = sdlutils().currRealTime();
}
}
});
mUiManager->addButton(mClientButton);
}
bool HostClient::esValida(string ipText)
{
if (ipText == " ") return false;
vector<string> aux = split(ipText);
if (aux.size() < 4) return false;
for (int i = 0; i < aux.size(); i++) {
string digito = aux[i];
if (digito.size() == 0) return false;
for (int j = 0; j < digito.size(); j++) {
if (!std::isdigit(digito[j])) {
return false;
}
}
if (stoi(digito) >= 256) {
return false;
}
}
return true;
}
void HostClient::update()
{
Scene::update();
mParticles->update();
if (mEscribiendo) {
char c = ih().getTypedKey();
if (c != ' ' && c != '\r')
{
if (!mEscrito) mEscrito = true;
if (c == '\b')
{
if (!mIp.empty())
mIp.pop_back();
else
mIp = ' ';
}
else if (mIp.size() < mMaxCaracteres) {
mIp += c;
}
if (mIp.empty())
mIp = ' ';
mTextIp->setTexture(mIp, string("ip"), {255,255,255,0}, { 0, 0, 0, 0 });
mTextIp->setDimension();
}
mTextIp->render(nullptr);
}
//Preguntar isHover y
if (mClientButton->hover()) {
mTextIp->setPosition(mTextIp->getX(), mPosYOver);
mCursor->setPosition(mCursor->getX(), mPosYOver);
mParticles->setStyle(ParticleExample::LIGHT);
mParticles->setPosition(mClientButton->getX(), sdlutils().height());
}
else {
mTextIp->setPosition(mTextIp->getX(), mPosYNotOver);
mCursor->setPosition(mCursor->getX(), mPosYNotOver);
}
if (mHostButton->hover()) {
mParticles->setStyle(ParticleExample::LIGHT);
mParticles->setPosition(mHostButton->getX(), sdlutils().height());
}
if (sdlutils().currRealTime() - mTiempoIpNV > mFrameRateIpNV) {
mIpNoValida->setActive(false);
}
}
vector<string> HostClient::split(string ipText)
{
vector<string> mIpText;
char mDelimitador = '.';
string mDigitos = "";
for (int i = 0; i < ipText.size(); i++) {
if (ipText[i] != mDelimitador) {
mDigitos += ipText[i];
if(i + 1 == ipText.size()) mIpText.push_back(mDigitos);
}
else {
mIpText.push_back(mDigitos);
mDigitos = "";
}
}
return mIpText;
}
void HostClient::render() {
mBackground->render(mCamera->renderRect());
mObjectManager->render(mCamera->renderRect());
mParticles->draw(mCamera->renderRect());
mUiManager->render(nullptr); // ponemos nullptr para que se mantenga en la pantalla siempre
mTextIp->render(nullptr);
mIpNoValida->render(nullptr);
mRestauranteNoEncontrado->render(nullptr);
if (!mEscrito && sdlutils().currRealTime() - mTime > mFrameRate) {
mCursor->render(nullptr);
mTime = sdlutils().currRealTime();
}
mTextMngr->render();
}
| 24.605505
| 122
| 0.656972
|
javics2002
|
108763a3a64d7c4e0c815d18763c7bcc8f19dbb3
| 548
|
cpp
|
C++
|
src/tfwifi.cpp
|
thingforward/slyft-demo-board
|
6031aa5824817a6c20a8cd8435841c42ee289234
|
[
"MIT"
] | null | null | null |
src/tfwifi.cpp
|
thingforward/slyft-demo-board
|
6031aa5824817a6c20a8cd8435841c42ee289234
|
[
"MIT"
] | null | null | null |
src/tfwifi.cpp
|
thingforward/slyft-demo-board
|
6031aa5824817a6c20a8cd8435841c42ee289234
|
[
"MIT"
] | null | null | null |
#include <Arduino.h>
#include "tfwifi.h"
const char* ssid = "ThingForwardWiFi";
const char* password = "iotthingforward";
void setup_wifi() {
Serial.println();
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
}
| 20.296296
| 43
| 0.616788
|
thingforward
|
1087fae7a181ffe404a9f72a8be436c2705fd8ff
| 437
|
cpp
|
C++
|
test/test.cpp
|
scpaes/aed
|
1937bd3e8093179a05f0c78aca76264354c0ae20
|
[
"MIT"
] | null | null | null |
test/test.cpp
|
scpaes/aed
|
1937bd3e8093179a05f0c78aca76264354c0ae20
|
[
"MIT"
] | null | null | null |
test/test.cpp
|
scpaes/aed
|
1937bd3e8093179a05f0c78aca76264354c0ae20
|
[
"MIT"
] | null | null | null |
#include <iostream>
using namespace std;
#define PRINT(M) cout << M << " ";
class A
{
public:
A() { PRINT("A+"); }
~A() { PRINT("A-"); }
};
class B
{
private:
A *a;
public:
B()
{
PRINT("B+");
a = new A;
}
~B()
{
PRINT("B-");
delete a;
}
};
class C : B
{
public:
C() : B() { PRINT("C+"); }
~C() { PRINT("C-"); }
};
int main()
{
B *b = new B;
C c;
}
| 10.404762
| 34
| 0.377574
|
scpaes
|
c8061fec0d750aba9f1393ca9c9b070631ca9ba6
| 604
|
cpp
|
C++
|
src/PlotsDrawer/ui/LogsImpl.cpp
|
jenya4361/Composite-LightCurve-Asteroids-PlotsDrawer
|
1155e67fe000573ddb606a8039a4068bd73bf1bb
|
[
"MIT"
] | null | null | null |
src/PlotsDrawer/ui/LogsImpl.cpp
|
jenya4361/Composite-LightCurve-Asteroids-PlotsDrawer
|
1155e67fe000573ddb606a8039a4068bd73bf1bb
|
[
"MIT"
] | null | null | null |
src/PlotsDrawer/ui/LogsImpl.cpp
|
jenya4361/Composite-LightCurve-Asteroids-PlotsDrawer
|
1155e67fe000573ddb606a8039a4068bd73bf1bb
|
[
"MIT"
] | null | null | null |
#include "LogsImpl.h"
#include <QLabel>
#include <QLayout>
#include "MainIncludes.h"
LogsImpl::LogsImpl()
{
m_fout.open( "log.txt" );
}
LogsImpl::~LogsImpl()
{
m_fout.close();
}
void LogsImpl::assignUI( const QMainWindow* ui )
{
m_logLabel = FindUIElementInWindow<QLabel*>( ui, "logLabel" );
}
void LogsImpl::addLog( const QString& str )
{
if( !m_logLabel )
return;
m_logLabel->setStyleSheet( "QLabel { color : blue }" );
m_logLabel->setText( str );
m_fout << "| PlotsDrawer Log | " << std::string( str.toLocal8Bit() ) << "\n";
printf( str.toLocal8Bit() );
}
| 19.483871
| 81
| 0.629139
|
jenya4361
|
c8089ea330b4699cbc595340f32e81f28a8cfa5b
| 10,632
|
hpp
|
C++
|
source/xyo/xyo-managedmemory-tmemorypoolactiveprocess.hpp
|
g-stefan/xyo
|
e203cb699d6bba46eae6c8157f27ea29ab7506f1
|
[
"MIT",
"Unlicense"
] | null | null | null |
source/xyo/xyo-managedmemory-tmemorypoolactiveprocess.hpp
|
g-stefan/xyo
|
e203cb699d6bba46eae6c8157f27ea29ab7506f1
|
[
"MIT",
"Unlicense"
] | null | null | null |
source/xyo/xyo-managedmemory-tmemorypoolactiveprocess.hpp
|
g-stefan/xyo
|
e203cb699d6bba46eae6c8157f27ea29ab7506f1
|
[
"MIT",
"Unlicense"
] | null | null | null |
//
// XYO
//
// Copyright (c) 2020-2021 Grigore Stefan <g_stefan@yahoo.com>
// Created by Grigore Stefan <g_stefan@yahoo.com>
//
// MIT License (MIT) <http://opensource.org/licenses/MIT>
//
#ifndef XYO_MANAGEDMEMORY_TMEMORYPOOLACTIVEPROCESS_HPP
#define XYO_MANAGEDMEMORY_TMEMORYPOOLACTIVEPROCESS_HPP
#ifdef XYO_TMEMORYPOOL_SYSTEM
#ifndef XYO_MANAGEDMEMORY_TMEMORYSYSTEM_HPP
#include "xyo-managedmemory-tmemorysystem.hpp"
#endif
namespace XYO {
namespace ManagedMemory {
template<typename T>
struct TMemoryPoolActiveProcess : TMemorySystem<T> {};
};
};
#elif defined(XYO_TMEMORYPOOL_ACTIVE_AS_UNIFIED)
#ifndef XYO_MANAGEDMEMORY_TMEMORYPOOLUNIFIEDPROCESS_HPP
#include "xyo-managedmemory-tmemorypoolunifiedprocess.hpp"
#endif
namespace XYO {
namespace ManagedMemory {
template<typename T>
struct TMemoryPoolActiveProcess: TMemoryPoolUnifiedProcess<T> {};
};
};
#else
#ifndef XYO_MANAGEDMEMORY_TMEMORYPOOLUNIFIEDPROCESS_HPP
#include "xyo-managedmemory-tmemorypoolunifiedprocess.hpp"
#endif
#ifndef XYO_DATASTRUCTURES_TXLIST1_HPP
#include "xyo-datastructures-txlist1.hpp"
#endif
#ifdef XYO_MULTI_THREAD
# ifndef XYO_MULTITHREADING_CRITICALSECTION_HPP
# include "xyo-multithreading-criticalsection.hpp"
# endif
#endif
#ifndef XYO_MULTITHREADING_TATOMIC_HPP
#include "xyo-multithreading-tatomic.hpp"
#endif
namespace XYO {
namespace ManagedMemory {
using namespace XYO::DataStructures;
using namespace XYO::Multithreading;
template<typename T>
class TMemoryPoolActiveProcessImplement {
protected:
#ifdef XYO_MULTI_THREAD
CriticalSection criticalSection;
#endif
public:
enum {
NewElementCount = 8,
FreeElementCountThreshold = 24,
FreeElementCount = 16
};
struct Link {
Link *next;
uint8_t value[sizeof(T)];
#ifdef XYO_TMEMORYPOOL_CHECK
bool isDeleted;
#endif
};
#ifdef XYO_TMEMORYPOOL_ACTIVE_LEVEL_IS_SYSTEM
typedef TXList1<Link, TMemorySystem> ListLink;
#else
typedef TXList1<Link, TMemoryPoolUnifiedProcess> ListLink;
#endif
Link *poolFreeLink;
size_t poolFreeLinkCount;
#ifdef XYO_TMEMORYPOOL_CHECK_COUNT_INFO
size_t checkCount;
#endif
inline TMemoryPoolActiveProcessImplement() {
ListLink::constructor(poolFreeLink);
poolFreeLinkCount = 0;
#ifdef XYO_TMEMORYPOOL_CHECK_COUNT_INFO
checkCount = 0;
#endif
#ifdef XYO_TMEMORYPOOL_CONSTRUCTOR_INFO
printf("# Constructor %s - " XYO_FORMAT_SIZET "\n", registryKey(), sizeof(T));
#endif
};
inline ~TMemoryPoolActiveProcessImplement() {
#ifdef XYO_TMEMORYPOOL_DESTRUCTOR_INFO
printf("# Destructor %s - " XYO_FORMAT_SIZET "\n", registryKey(), sizeof(T));
#endif
#ifdef XYO_TMEMORYPOOL_CHECK_COUNT_INFO
if(checkCount != 0) {
printf("# Check Count Info: " XYO_FORMAT_SIZET " - %s\n", checkCount, registryKey());
fflush(stdout);
};
#endif
Link *this_;
while (poolFreeLink) {
this_ = poolFreeLink;
poolFreeLink = poolFreeLink->next;
TIfHasActiveFinalizer<T>::activeFinalizer(reinterpret_cast<T *>(&this_->value[0]));
TIfHasSetDeleteMemory<T>::setDeleteMemory(reinterpret_cast<T *>(&this_->value[0]), nullptr, nullptr);
(reinterpret_cast<T *>(&this_->value[0]))->~T();
ListLink::deleteNode(this_);
};
};
inline void grow() {
size_t k;
Link *this_;
for (k = 0; k < NewElementCount; ++k) {
this_ = ListLink::newNode();
new(&this_->value[0]) T();
#ifdef XYO_TMEMORYPOOL_CHECK
this_->isDeleted = true;
#endif
++poolFreeLinkCount;
ListLink::push(poolFreeLink, this_);
TIfHasSetDeleteMemory<T>::setDeleteMemory(reinterpret_cast<T *>(&this_->value[0]), (DeleteMemory)deleteMemory_, reinterpret_cast<T *>(&this_->value[0]));
};
};
inline T *newMemory() {
T *this_;
#ifdef XYO_MULTI_THREAD
criticalSection.enter();
#endif
if(!poolFreeLink) {
grow();
};
this_ = reinterpret_cast<T *>(&poolFreeLink->value[0]);
#ifdef XYO_TMEMORYPOOL_CHECK
poolFreeLink->isDeleted = false;
#endif
--poolFreeLinkCount;
ListLink::popUnsafeX(poolFreeLink);
#ifdef XYO_TMEMORYPOOL_CHECK_COUNT_INFO
checkCount++;
#endif
#ifdef XYO_MULTI_THREAD
criticalSection.leave();
#endif
TIfHasActiveConstructor<T>::activeConstructor(this_);
return this_;
};
static inline const std::string deleteMemoryOnAlreadyDeletedObject_() {
std::string retV("deleteMemory on already deleted object ");
retV += registryKey();
return retV;
};
inline void deleteMemory(T *this_) {
#ifdef XYO_TMEMORYPOOL_CHECK
if((reinterpret_cast<Link *>( (reinterpret_cast<uint8_t *>(this_)) - offsetof(Link, value) ))->isDeleted) {
#ifdef XYO_TMEMORYPOOL_CHECK_INFO
printf("# Double deleteMemory: %p - %s", this_, registryKey());
fflush(stdout);
#endif
throw std::runtime_error(deleteMemoryOnAlreadyDeletedObject_());
};
(reinterpret_cast<Link *>( (reinterpret_cast<uint8_t *>(this_)) - offsetof(Link, value) ))->isDeleted = true;
#endif
#ifdef XYO_TMEMORYPOOL_CHECK_COUNT_INFO
checkCount--;
#endif
TIfHasActiveDestructor<T>::activeDestructor(this_);
Link *itemListToFree = nullptr;
#ifdef XYO_MULTI_THREAD
criticalSection.enter();
#endif
this_ = reinterpret_cast<T *>( (reinterpret_cast<uint8_t *>(this_)) - offsetof(Link, value) );
ListLink::push(poolFreeLink, (reinterpret_cast<Link *>(this_)));
++poolFreeLinkCount;
if(poolFreeLinkCount == FreeElementCountThreshold) {
Link *item;
size_t k;
for(k = 0; k < FreeElementCount; ++k) {
if(poolFreeLink) {
--poolFreeLinkCount;
item = poolFreeLink;
ListLink::popUnsafeX(poolFreeLink);
ListLink::push(itemListToFree, item);
continue;
};
poolFreeLinkCount = 0;
break;
};
};
#ifdef XYO_MULTI_THREAD
criticalSection.leave();
#endif
if(itemListToFree != nullptr) {
Link *this_;
while (itemListToFree) {
this_ = itemListToFree;
itemListToFree = itemListToFree->next;
TIfHasActiveFinalizer<T>::activeFinalizer(reinterpret_cast<T *>(&this_->value[0]));
TIfHasSetDeleteMemory<T>::setDeleteMemory(reinterpret_cast<T *>(&this_->value[0]), nullptr, nullptr);
(reinterpret_cast<T *>(&this_->value[0]))->~T();
ListLink::deleteNode(this_);
};
};
};
static inline void initMemory() {
ListLink::initMemory();
};
static inline const std::string deleteMemoryWithoutInitialization_() {
std::string retV("deleteMemory without initialization ");
retV += TMemoryPoolActiveProcessImplement<T>::registryKey();
return retV;
};
static inline void deleteMemory_(T *this_) {
//
// dynamic link guard, can be multiple instances in different libraries
// this will recover the original instance
//
if(!memoryPool.get()) {
memoryPool.set(reinterpret_cast<TMemoryPoolActiveProcessImplement<T> *>(
RegistryProcess::getKey(TMemoryPoolActiveProcessImplement<T>::registryKey())
));
if(!memoryPool.get()) {
throw std::runtime_error(deleteMemoryWithoutInitialization_());
};
};
//
//
//
(memoryPool.get())->deleteMemory(this_);
};
static TAtomic<TMemoryPoolActiveProcessImplement *> memoryPool;
static const char *registryKey();
static void resourceDelete(void *);
static void resourceFinalizer(void *);
};
template<typename T>
const char *TMemoryPoolActiveProcessImplement<T>::registryKey() {
return typeid(TMemoryPoolActiveProcessImplement<T>).name();
};
template<typename T>
TAtomic<TMemoryPoolActiveProcessImplement<T> *> TMemoryPoolActiveProcessImplement<T>::memoryPool(nullptr);
template<typename T>
void TMemoryPoolActiveProcessImplement<T>::resourceDelete(void *this_) {
delete (TMemoryPoolActiveProcessImplement<T> *)this_;
};
template<typename T>
void TMemoryPoolActiveProcessImplement<T>::resourceFinalizer(void *this_) {
TMemoryPoolActiveProcessImplement<T>::Link *scan = ((TMemoryPoolActiveProcessImplement<T> *)this_)->poolFreeLink;
while (scan) {
TIfHasActiveFinalizer<T>::activeFinalizer(reinterpret_cast<T *>(&scan->value[0]));
scan = scan->next;
};
};
template<typename T>
class TMemoryPoolActiveProcess {
protected:
template<typename U, bool hasDecReferenceCount>
struct TDeleteMemory {
static inline void deleteMemory(U *this_) {
TMemoryPoolActiveProcessImplement<T>::deleteMemory_(this_);
};
};
template<typename U>
struct TDeleteMemory<U, true> {
static inline void deleteMemory(U *this_) {
this_->decReferenceCount();
};
};
public:
static inline T *newMemory() {
if(!TMemoryPoolActiveProcessImplement<T>::memoryPool.get()) {
initMemory();
};
return (TMemoryPoolActiveProcessImplement<T>::memoryPool.get())->newMemory();
};
static inline void deleteMemory(T *this_) {
TDeleteMemory<T, THasDecReferenceCount<T>::value>::deleteMemory(this_);
};
static inline void initMemory() {
Registry::registryInit();
TMemoryPoolActiveProcessImplement<T>::initMemory();
void *registryLink;
//
if(RegistryProcess::checkAndRegisterKey(TMemoryPoolActiveProcessImplement<T>::registryKey(), registryLink, [] {
return (TMemoryPoolActiveProcessImplement<T>::memoryPool.get() == nullptr);
}
, [](void *this__) {
TMemoryPoolActiveProcessImplement<T>
*this_ = reinterpret_cast<TMemoryPoolActiveProcessImplement<T> *>(this__);
TMemoryPoolActiveProcessImplement<T>::memoryPool.set(this_);
})) {
TIfHasInitMemory<T>::initMemory();
TMemoryPoolActiveProcessImplement<T>::memoryPool.set(new TMemoryPoolActiveProcessImplement<T>());
RegistryProcess::setValue(
registryLink,
RegistryLevel::Active,
TMemoryPoolActiveProcessImplement<T>::memoryPool.get(),
TMemoryPoolActiveProcessImplement<T>::resourceDelete,
(THasActiveFinalizer<T>::value) ? TMemoryPoolActiveProcessImplement<T>::resourceFinalizer : nullptr
);
};
};
};
};
};
#endif
#endif
| 28.276596
| 160
| 0.670617
|
g-stefan
|
c80bff069b102c7c6fe9b777ef9e4f5192955bfd
| 884
|
cpp
|
C++
|
src/parser/__ast/SwitchStmt.cpp
|
shockazoid/HydroLanguage
|
25071995477406245911989584cb3e6f036229c0
|
[
"Apache-2.0"
] | null | null | null |
src/parser/__ast/SwitchStmt.cpp
|
shockazoid/HydroLanguage
|
25071995477406245911989584cb3e6f036229c0
|
[
"Apache-2.0"
] | null | null | null |
src/parser/__ast/SwitchStmt.cpp
|
shockazoid/HydroLanguage
|
25071995477406245911989584cb3e6f036229c0
|
[
"Apache-2.0"
] | null | null | null |
//
// __ __ __
// / / / /__ __ ____/ /_____ ____
// / /_/ // / / // __ // ___// __ \
// / __ // /_/ // /_/ // / / /_/ /
// /_/ /_/ \__, / \__,_//_/ \____/
// /____/
//
// The Hydro Programming Language
//
// © 2020 Shockazoid, Inc. All Rights Reserved.
//
#include "SwitchStmt.hpp"
namespace hydro
{
CaseClause::CaseClause(lex_token token, ast_expr expr) : Stmt{token}, _expr{expr}
{
addChild(expr);
}
CaseClause::~CaseClause() {}
DefaultClause::DefaultClause(lex_token token) : Stmt{token} {}
DefaultClause::~DefaultClause() {}
SwitchStmt::SwitchStmt(lex_token token, ast_expr expr, ast_stmt body) : Stmt{token}, _expr{expr}, _body{body}
{
addChild(expr);
}
SwitchStmt::~SwitchStmt() {}
} // namespace hydro
| 23.263158
| 109
| 0.507919
|
shockazoid
|
c80e4bcf5ef90132e51973018658b27335f7841d
| 9,901
|
cpp
|
C++
|
Source/Urho3D/Math/Polyhedron.cpp
|
jayrulez/rbfx
|
8641813787d558b6e8318c1b8e9da86c0e52f9dc
|
[
"MIT"
] | 48
|
2016-11-14T00:39:35.000Z
|
2018-12-18T16:37:43.000Z
|
Source/Urho3D/Math/Polyhedron.cpp
|
jayrulez/rbfx
|
8641813787d558b6e8318c1b8e9da86c0e52f9dc
|
[
"MIT"
] | 54
|
2017-10-18T07:18:12.000Z
|
2018-12-23T14:09:30.000Z
|
Source/Urho3D/Math/Polyhedron.cpp
|
jayrulez/rbfx
|
8641813787d558b6e8318c1b8e9da86c0e52f9dc
|
[
"MIT"
] | 10
|
2017-11-10T11:46:15.000Z
|
2018-12-18T11:58:44.000Z
|
//
// Copyright (c) 2008-2022 the Urho3D project.
//
// 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 "../Precompiled.h"
#include "../Math/Frustum.h"
#include "../Math/Polyhedron.h"
#include "../DebugNew.h"
#ifdef _MSC_VER
#pragma warning(disable:6293)
#endif
namespace Urho3D
{
void Polyhedron::Define(const BoundingBox& box)
{
Vector3 vertices[8];
vertices[0] = box.min_;
vertices[1] = Vector3(box.max_.x_, box.min_.y_, box.min_.z_);
vertices[2] = Vector3(box.min_.x_, box.max_.y_, box.min_.z_);
vertices[3] = Vector3(box.max_.x_, box.max_.y_, box.min_.z_);
vertices[4] = Vector3(box.min_.x_, box.min_.y_, box.max_.z_);
vertices[5] = Vector3(box.max_.x_, box.min_.y_, box.max_.z_);
vertices[6] = Vector3(box.min_.x_, box.max_.y_, box.max_.z_);
vertices[7] = box.max_;
faces_.resize(6);
SetFace(0, vertices[3], vertices[7], vertices[5], vertices[1]);
SetFace(1, vertices[6], vertices[2], vertices[0], vertices[4]);
SetFace(2, vertices[6], vertices[7], vertices[3], vertices[2]);
SetFace(3, vertices[1], vertices[5], vertices[4], vertices[0]);
SetFace(4, vertices[7], vertices[6], vertices[4], vertices[5]);
SetFace(5, vertices[2], vertices[3], vertices[1], vertices[0]);
}
void Polyhedron::Define(const Frustum& frustum)
{
const Vector3* vertices = frustum.vertices_;
faces_.resize(6);
SetFace(0, vertices[0], vertices[4], vertices[5], vertices[1]);
SetFace(1, vertices[7], vertices[3], vertices[2], vertices[6]);
SetFace(2, vertices[7], vertices[4], vertices[0], vertices[3]);
SetFace(3, vertices[1], vertices[5], vertices[6], vertices[2]);
SetFace(4, vertices[4], vertices[7], vertices[6], vertices[5]);
SetFace(5, vertices[3], vertices[0], vertices[1], vertices[2]);
}
void Polyhedron::AddFace(const Vector3& v0, const Vector3& v1, const Vector3& v2)
{
faces_.resize(faces_.size() + 1);
ea::vector<Vector3>& face = faces_[faces_.size() - 1];
face.resize(3);
face[0] = v0;
face[1] = v1;
face[2] = v2;
}
void Polyhedron::AddFace(const Vector3& v0, const Vector3& v1, const Vector3& v2, const Vector3& v3)
{
faces_.resize(faces_.size() + 1);
ea::vector<Vector3>& face = faces_[faces_.size() - 1];
face.resize(4);
face[0] = v0;
face[1] = v1;
face[2] = v2;
face[3] = v3;
}
void Polyhedron::AddFace(const ea::vector<Vector3>& face)
{
faces_.push_back(face);
}
void Polyhedron::Clip(const Plane& plane)
{
clippedVertices_.clear();
for (unsigned i = 0; i < faces_.size(); ++i)
{
ea::vector<Vector3>& face = faces_[i];
Vector3 lastVertex;
float lastDistance = 0.0f;
outFace_.clear();
for (unsigned j = 0; j < face.size(); ++j)
{
float distance = plane.Distance(face[j]);
if (distance >= 0.0f)
{
if (lastDistance < 0.0f)
{
float t = lastDistance / (lastDistance - distance);
Vector3 clippedVertex = lastVertex + t * (face[j] - lastVertex);
outFace_.push_back(clippedVertex);
clippedVertices_.push_back(clippedVertex);
}
outFace_.push_back(face[j]);
}
else
{
if (lastDistance >= 0.0f && j != 0)
{
float t = lastDistance / (lastDistance - distance);
Vector3 clippedVertex = lastVertex + t * (face[j] - lastVertex);
outFace_.push_back(clippedVertex);
clippedVertices_.push_back(clippedVertex);
}
}
lastVertex = face[j];
lastDistance = distance;
}
// Recheck the distances of the last and first vertices and add the final clipped vertex if applicable
float distance = plane.Distance(face[0]);
if ((lastDistance < 0.0f && distance >= 0.0f) || (lastDistance >= 0.0f && distance < 0.0f))
{
float t = lastDistance / (lastDistance - distance);
Vector3 clippedVertex = lastVertex + t * (face[0] - lastVertex);
outFace_.push_back(clippedVertex);
clippedVertices_.push_back(clippedVertex);
}
// Do not keep faces which are less than triangles
if (outFace_.size() < 3)
outFace_.clear();
face = outFace_;
}
// Remove empty faces
for (unsigned i = faces_.size() - 1; i < faces_.size(); --i)
{
if (faces_[i].empty())
faces_.erase_at(i);
}
// Create a new face from the clipped vertices. First remove duplicates
for (unsigned i = 0; i < clippedVertices_.size(); ++i)
{
for (unsigned j = clippedVertices_.size() - 1; j > i; --j)
{
if (clippedVertices_[j].Equals(clippedVertices_[i]))
clippedVertices_.erase_at(j);
}
}
if (clippedVertices_.size() > 3)
{
outFace_.clear();
// Start with the first vertex
outFace_.push_back(clippedVertices_.front());
clippedVertices_.pop_front();
while (!clippedVertices_.empty())
{
// Then add the vertex which is closest to the last added
const Vector3& lastAdded = outFace_.back();
float bestDistance = M_INFINITY;
unsigned bestIndex = 0;
for (unsigned i = 0; i < clippedVertices_.size(); ++i)
{
float distance = (clippedVertices_[i] - lastAdded).LengthSquared();
if (distance < bestDistance)
{
bestDistance = distance;
bestIndex = i;
}
}
outFace_.push_back(clippedVertices_[bestIndex]);
clippedVertices_.erase_at(bestIndex);
}
faces_.push_back(outFace_);
}
}
void Polyhedron::Clip(const Frustum& frustum)
{
for (const auto& plane : frustum.planes_)
Clip(plane);
}
void Polyhedron::Clip(const BoundingBox& box)
{
Vector3 vertices[8];
vertices[0] = box.min_;
vertices[1] = Vector3(box.max_.x_, box.min_.y_, box.min_.z_);
vertices[2] = Vector3(box.min_.x_, box.max_.y_, box.min_.z_);
vertices[3] = Vector3(box.max_.x_, box.max_.y_, box.min_.z_);
vertices[4] = Vector3(box.min_.x_, box.min_.y_, box.max_.z_);
vertices[5] = Vector3(box.max_.x_, box.min_.y_, box.max_.z_);
vertices[6] = Vector3(box.min_.x_, box.max_.y_, box.max_.z_);
vertices[7] = box.max_;
Clip(Plane(vertices[5], vertices[7], vertices[3]));
Clip(Plane(vertices[0], vertices[2], vertices[6]));
Clip(Plane(vertices[3], vertices[7], vertices[6]));
Clip(Plane(vertices[4], vertices[5], vertices[1]));
Clip(Plane(vertices[4], vertices[6], vertices[7]));
Clip(Plane(vertices[1], vertices[3], vertices[2]));
}
void Polyhedron::Clear()
{
faces_.clear();
}
void Polyhedron::Transform(const Matrix3& transform)
{
for (unsigned i = 0; i < faces_.size(); ++i)
{
ea::vector<Vector3>& face = faces_[i];
for (unsigned j = 0; j < face.size(); ++j)
face[j] = transform * face[j];
}
}
void Polyhedron::Transform(const Matrix3x4& transform)
{
for (unsigned i = 0; i < faces_.size(); ++i)
{
ea::vector<Vector3>& face = faces_[i];
for (unsigned j = 0; j < face.size(); ++j)
face[j] = transform * face[j];
}
}
Polyhedron Polyhedron::Transformed(const Matrix3& transform) const
{
Polyhedron ret;
ret.faces_.resize(faces_.size());
for (unsigned i = 0; i < faces_.size(); ++i)
{
const ea::vector<Vector3>& face = faces_[i];
ea::vector<Vector3>& newFace = ret.faces_[i];
newFace.resize(face.size());
for (unsigned j = 0; j < face.size(); ++j)
newFace[j] = transform * face[j];
}
return ret;
}
Polyhedron Polyhedron::Transformed(const Matrix3x4& transform) const
{
Polyhedron ret;
ret.faces_.resize(faces_.size());
for (unsigned i = 0; i < faces_.size(); ++i)
{
const ea::vector<Vector3>& face = faces_[i];
ea::vector<Vector3>& newFace = ret.faces_[i];
newFace.resize(face.size());
for (unsigned j = 0; j < face.size(); ++j)
newFace[j] = transform * face[j];
}
return ret;
}
void Polyhedron::SetFace(unsigned index, const Vector3& v0, const Vector3& v1, const Vector3& v2)
{
ea::vector<Vector3>& face = faces_[index];
face.resize(3);
face[0] = v0;
face[1] = v1;
face[2] = v2;
}
void Polyhedron::SetFace(unsigned index, const Vector3& v0, const Vector3& v1, const Vector3& v2, const Vector3& v3)
{
ea::vector<Vector3>& face = faces_[index];
face.resize(4);
face[0] = v0;
face[1] = v1;
face[2] = v2;
face[3] = v3;
}
}
| 31.632588
| 116
| 0.59802
|
jayrulez
|
c8123127495c5f1f14e9f35669385718c0a14365
| 6,458
|
hxx
|
C++
|
src/utils/constants.hxx
|
TrainzLuvr/openmrn
|
b3bb9d4995e49aa39856740d292d38cf4a99845b
|
[
"BSD-2-Clause"
] | 1
|
2016-03-14T21:43:26.000Z
|
2016-03-14T21:43:26.000Z
|
src/utils/constants.hxx
|
TrainzLuvr/openmrn
|
b3bb9d4995e49aa39856740d292d38cf4a99845b
|
[
"BSD-2-Clause"
] | null | null | null |
src/utils/constants.hxx
|
TrainzLuvr/openmrn
|
b3bb9d4995e49aa39856740d292d38cf4a99845b
|
[
"BSD-2-Clause"
] | null | null | null |
/** \copyright
* Copyright (c) 2014, Balazs Racz
* 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 COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* \file constants.hxx
* Utility to specify linking-time constants and overrides for them.
*
* @author Balazs Racz
* @date 30 Apr 2014
*/
#ifndef _UTILS_CONSTANTS_HXX_
#define _UTILS_CONSTANTS_HXX_
#include <stddef.h>
#ifdef __cplusplus
#define EXTERNC extern "C" {
#define EXTERNCEND }
#else
/// Allows both C and C++ compilation
#define EXTERNC
/// Allows both C and C++ compilation
#define EXTERNCEND
#endif
#if defined (__EMSCRIPTEN__) || defined (__MACH__) || defined(__linux__)
#define NEED_SIMPLE_CONST
#endif
#ifdef NEED_SIMPLE_CONST
/// Declares a constant value. Put this into a header and include that header
/// to the code which has to access that constant.
///
/// @param name name of the constant. For a name NNN Creates a function called
/// config_NNN() that returns the configured value.
#define DECLARE_CONST(name) \
EXTERNC extern const int _sym_##name; \
EXTERNCEND \
static inline int config_##name(void) \
{ \
return _sym_##name; \
} \
/** internal guard */ \
typedef unsigned char \
_do_not_add_declare_and_default_const_to_the_same_file_for_##name;
/// Defines the default value of a constant. Use this is a single .cxx file and
/// make sure NOT to include the header that has the respective DECLARE_CONST
/// macros. Best not to incude anything at all.
///
/// @param name name of the constant.
/// @param value is what the default value should be.
#define DEFAULT_CONST(name, value) \
EXTERNC extern const int __attribute__((__weak__)) _sym_##name = value; \
EXTERNCEND \
/** internal guard */ \
typedef signed char \
_do_not_add_declare_and_default_const_to_the_same_file_for_##name;
/// Overrides the value of a constant. Use this is a single .cxx file (usually
/// main.cxx).
///
/// @param name name of the constant.
/// @param value is what the actual value should be.
#define OVERRIDE_CONST(name, value) \
EXTERNC extern const int _sym_##name; \
const int _sym_##name = value; \
EXTERNCEND
#else // native C
#define DECLARE_CONST(name) \
EXTERNC extern void _sym_##name(void); \
EXTERNCEND typedef unsigned char \
_do_not_add_declare_and_default_const_to_the_same_file_for_##name; \
static inline ptrdiff_t config_##name(void) \
{ \
return (ptrdiff_t)(&_sym_##name); \
}
#define DEFAULT_CONST(name, value) \
typedef signed char \
_do_not_add_declare_and_default_const_to_the_same_file_for_##name; \
asm(".global _sym_" #name " \n"); \
asm(".weak _sym_" #name " \n"); \
asm(".set _sym_" #name ", " #value " \n");
#define OVERRIDE_CONST(name, value) \
asm(".global _sym_" #name " \n"); \
asm(".set _sym_" #name ", " #value " \n");
#endif // native C
/// We cannot compare constants to zero, so we use 1 and 2 as constant values
/// for booleans.
#define CONSTANT_TRUE 1
/// We cannot compare constants to zero, so we use 1 and 2 as constant values
/// for booleans.
#define CONSTANT_FALSE 2
/// Sets the default value of a boolean constant to true.
/// @param name is the name of the constant to set.
#define DEFAULT_CONST_TRUE(name) DEFAULT_CONST(name, 1)
/// Sets the default value of a boolean constant to false.
/// @param name is the name of the constant to set.
#define DEFAULT_CONST_FALSE(name) DEFAULT_CONST(name, 2)
/// Overrides the value of a boolean constant to true.
/// @param name is the name of the constant to set.
#define OVERRIDE_CONST_TRUE(name) OVERRIDE_CONST(name, 1)
/// Overrides the value of a boolean constant to false.
/// @param name is the name of the constant to set.
#define OVERRIDE_CONST_FALSE(name) OVERRIDE_CONST(name, 2)
#endif // _UTILS_CONSTANTS_HXX_
| 46.128571
| 80
| 0.568287
|
TrainzLuvr
|
c81357a16345be3eebe2a4a2bbe6bfda6abea46c
| 1,168
|
cpp
|
C++
|
LeetCode/ValidateBinarySearchTree.cpp
|
SelvorWhim/competitive
|
b9daaf21920d6f7669dc0c525e903949f4e33b62
|
[
"Unlicense"
] | null | null | null |
LeetCode/ValidateBinarySearchTree.cpp
|
SelvorWhim/competitive
|
b9daaf21920d6f7669dc0c525e903949f4e33b62
|
[
"Unlicense"
] | null | null | null |
LeetCode/ValidateBinarySearchTree.cpp
|
SelvorWhim/competitive
|
b9daaf21920d6f7669dc0c525e903949f4e33b62
|
[
"Unlicense"
] | null | null | null |
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
bool isValidBST(TreeNode* root) {
if (root == nullptr) {
return true;
}
return isValidBstRecursive(root->left, 0, false, root->val, true) && isValidBstRecursive(root->right, root->val, true, 0, false);
}
bool isValidBstRecursive(TreeNode* node, int min, bool has_min, int max, bool has_max) {
if (node == nullptr) {
return true;
}
if ((has_min && node->val <= min) || (has_max && node->val >= max)) {
// note: based on examples, equal values are not allowed, otherwise it would be strict inequality
return false;
}
return isValidBstRecursive(node->left, min, has_min, node->val, true) && isValidBstRecursive(node->right, node->val, true, max, has_max);
}
};
| 37.677419
| 145
| 0.589041
|
SelvorWhim
|
c81c462769954a0406bd1361b4a374a39d5b587b
| 9,944
|
cpp
|
C++
|
src/generation/impl/CompilerImpl.cpp
|
fuchstraumer/ShaderTools
|
02acb297c5cbb645d0004dd681f8a7135b568a5f
|
[
"MIT"
] | 1
|
2018-03-29T14:49:03.000Z
|
2018-03-29T14:49:03.000Z
|
src/generation/impl/CompilerImpl.cpp
|
fuchstraumer/ShaderTools
|
02acb297c5cbb645d0004dd681f8a7135b568a5f
|
[
"MIT"
] | 5
|
2018-04-22T16:03:49.000Z
|
2019-04-25T21:55:02.000Z
|
src/generation/impl/CompilerImpl.cpp
|
fuchstraumer/ShaderTools
|
02acb297c5cbb645d0004dd681f8a7135b568a5f
|
[
"MIT"
] | null | null | null |
#include "CompilerImpl.hpp"
#include <filesystem>
#include <fstream>
#include "spirv_glsl.hpp"
#include "easyloggingpp/src/easylogging++.h"
#include "../../util/ShaderFileTracker.hpp"
namespace st {
namespace fs = std::filesystem;
shaderc::CompileOptions ShaderCompilerImpl::getCompilerOptions() const {
shaderc::CompileOptions options;
options.SetGenerateDebugInfo();
options.SetOptimizationLevel(shaderc_optimization_level_performance);
options.SetTargetEnvironment(shaderc_target_env_vulkan, shaderc_env_version_vulkan_1_1);
options.SetSourceLanguage(shaderc_source_language_glsl);
return options;
}
shaderc_shader_kind ShaderCompilerImpl::getShaderKind(const VkShaderStageFlagBits& flags) const {
switch (flags) {
case VK_SHADER_STAGE_VERTEX_BIT:
return shaderc_glsl_vertex_shader;
case VK_SHADER_STAGE_FRAGMENT_BIT:
return shaderc_glsl_fragment_shader;
// MoltenVK cannot yet use the geometry or tesselation shaders.
#ifndef __APPLE__
case VK_SHADER_STAGE_GEOMETRY_BIT:
return shaderc_glsl_geometry_shader;
case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
return shaderc_glsl_tess_control_shader;
case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
return shaderc_glsl_tess_evaluation_shader;
#endif
case VK_SHADER_STAGE_COMPUTE_BIT:
return shaderc_glsl_compute_shader;
default:
LOG(ERROR) << "Invalid shader stage bitfield, or shader stage selected not supported on current platform!";
throw std::domain_error("Invalid shader stage bitfield, or shader stage not supported on current platform!");
}
}
enum class dump_reason {
failed_compile = 0,
failed_recompile = 1,
};
void dump_bad_source_to_file(const std::string& name, const std::string& src, const std::string& err_text, dump_reason reason) {
std::string suffix = (reason == dump_reason::failed_compile) ? std::string{ "_failed_compile.glsl" } : std::string{ "_failed_recompile.glsl" };
const std::string output_name = name + suffix;
std::ofstream output_stream(output_name);
output_stream << src;
output_stream.flush(); output_stream.close();
if (reason == dump_reason::failed_compile) {
const std::string err_msg_output = name + std::string{ "_compiliation_errors.txt" };
output_stream.open(err_msg_output);
output_stream << err_text;
output_stream.flush(); output_stream.close();
}
}
void ShaderCompilerImpl::prepareToCompile(const ShaderStage& handle, const std::string& name, const std::string& src) {
const auto shader_stage = getShaderKind(handle.GetStage());
compile(handle, shader_stage, name, src);
}
void ShaderCompilerImpl::prepareToCompile(const ShaderStage& handle, const char* path_to_source_str) {
fs::path path_to_source(path_to_source_str);
// First check to verify the path given exists.
if (!fs::exists(path_to_source)) {
LOG(ERROR) << "Given shader source path/file does not exist!\n";
throw std::runtime_error("Failed to open/find given shader file.");
}
const auto shader_stage = getShaderKind(handle.GetStage());
std::ifstream input_file(path_to_source);
if (!input_file.is_open()) {
LOG(ERROR) << "Failed to open " << path_to_source_str << " for compiliation.";
throw std::runtime_error("Failed to open supplied file in GLSLCompiler!");
}
const std::string source_code((std::istreambuf_iterator<char>(input_file)), (std::istreambuf_iterator<char>()));
const std::string file_name = path_to_source.filename().replace_extension().string();
compile(handle, shader_stage, file_name, source_code);
}
void ShaderCompilerImpl::compile(const ShaderStage & handle, const shaderc_shader_kind & kind, const std::string & name, const std::string & src_str) {
auto& FileTracker = ShaderFileTracker::GetFileTracker();
shaderc::Compiler compiler;
auto options = getCompilerOptions();
// We allow for optimization to be disabled for shaders in case they break or need debugging
// Should probably make this part of a try-catch with compiling shaders, where we try a second pass and notify the user if their shader fails optimized compile
auto disableOptsIter = FileTracker.StageOptimizationDisabled.find(handle);
bool configDisableOptimization = disableOptsIter != std::end(FileTracker.StageOptimizationDisabled) ? disableOptsIter->second : false;
shaderc_optimization_level optimizationLevel = configDisableOptimization ? shaderc_optimization_level_zero : shaderc_optimization_level_performance;
options.SetOptimizationLevel(optimizationLevel);
// Wholly unneeded and is going to artifically inflate our compile times. ifdef'd out in non-debug builds because of that
#ifndef NDEBUG
shaderc::AssemblyCompilationResult assembly_result = compiler.CompileGlslToSpvAssembly(src_str, kind, name.c_str(), options);
if (assembly_result.GetCompilationStatus() == shaderc_compilation_status_success)
{
auto assemblyIter = FileTracker.AssemblyStrings.emplace(handle, std::string{ assembly_result.begin(), assembly_result.end() });
if (!assemblyIter.second)
{
LOG(WARNING) << "Failed to emplace non-critical assembly string into state storage.";
}
}
#endif
shaderc::SpvCompilationResult compiliation_result = compiler.CompileGlslToSpv(src_str, kind, name.c_str(), options);
if (compiliation_result.GetCompilationStatus() != shaderc_compilation_status_success) {
const std::string err_msg = compiliation_result.GetErrorMessage();
LOG(ERROR) << "Shader compiliation to assembly failed: " << err_msg.c_str() << "\n";
#ifndef NDEBUG
LOG(ERROR) << "Dumping shader source to file...";
dump_bad_source_to_file(name, src_str, err_msg, dump_reason::failed_compile);
#endif
const std::string except_msg = std::string("Failed to compile shader to assembly: ") + err_msg + std::string("\n");
throw std::runtime_error(except_msg.c_str());
}
if (FileTracker.Binaries.count(handle) != 0) {
// erase as we're gonna replace with an updated binary
FileTracker.Binaries.erase(handle);
}
auto binary_iter = FileTracker.Binaries.emplace(handle, std::vector<uint32_t>{compiliation_result.begin(), compiliation_result.end()});
if (!binary_iter.second) {
LOG(ERROR) << "Failed to emplace compiled SPIR-V binary into program's storage!";
throw std::runtime_error("Emplacement of shader SPIR-V binary failed.");
}
}
void ShaderCompilerImpl::recompileBinaryToGLSL(const ShaderStage & handle, size_t * str_size, char * dest_str) {
auto& FileTracker = ShaderFileTracker::GetFileTracker();
std::string recompiled_src_str;
if (!FileTracker.FindRecompiledShaderSource(handle, recompiled_src_str)) {
std::vector<uint32_t> found_binary;
if (FileTracker.FindShaderBinary(handle, found_binary)) {
using namespace spirv_cross;
CompilerGLSL recompiler(found_binary);
spirv_cross::CompilerGLSL::Options options;
options.vulkan_semantics = true;
recompiler.set_common_options(options);
std::string recompiled_source;
try {
recompiled_source = recompiler.compile();
}
catch (const spirv_cross::CompilerError& e) {
LOG(WARNING) << "Failed to fully parse/recompile SPIR-V binary back to GLSL text. Outputting partial source thus far.";
LOG(WARNING) << "spirv_cross::CompilerError.what(): " << e.what() << "\n";
recompiled_source = recompiler.get_partial_source();
dump_bad_source_to_file(FileTracker.GetShaderName(handle), recompiled_source, "", dump_reason::failed_recompile);
}
auto iter = FileTracker.RecompiledSourcesFromBinaries.emplace(handle, recompiled_source);
if (!iter.second) {
LOG(WARNING) << "Failed to emplace recompiled shader source into program's filetracker system!";
}
*str_size = recompiled_source.size();
if (dest_str != nullptr) {
std::copy(recompiled_source.cbegin(), recompiled_source.cend(), dest_str);
}
}
else {
LOG(WARNING) << "Failed to find or recompile shader's binary to GLSL code.";
*str_size = 0;
return;
}
}
else {
*str_size = recompiled_src_str.size();
if (dest_str != nullptr) {
std::copy(recompiled_src_str.cbegin(), recompiled_src_str.cend(), dest_str);
}
}
}
void ShaderCompilerImpl::getBinaryAssemblyString(const ShaderStage& handle, size_t* str_size, char* dest_str) {
auto& FileTracker = ShaderFileTracker::GetFileTracker();
std::string recompiled_src_str;
if (!FileTracker.FindAssemblyString(handle, recompiled_src_str)) {
LOG(WARNING) << "Could not find requested shader's assembly source!";
*str_size = 0;
return;
}
else {
*str_size = recompiled_src_str.size();
if (dest_str != nullptr) {
std::copy(recompiled_src_str.cbegin(), recompiled_src_str.cend(), dest_str);
}
}
}
}
| 47.127962
| 167
| 0.656778
|
fuchstraumer
|
c81dc5b1911d513cd873cc733bd8bdf58cacfe32
| 17,807
|
cpp
|
C++
|
SDK/ARKSurvivalEvolved_Telemetry_functions.cpp
|
2bite/ARK-SDK
|
c38ca9925309516b2093ad8c3a70ed9489e1d573
|
[
"MIT"
] | 10
|
2020-02-17T19:08:46.000Z
|
2021-07-31T11:07:19.000Z
|
SDK/ARKSurvivalEvolved_Telemetry_functions.cpp
|
2bite/ARK-SDK
|
c38ca9925309516b2093ad8c3a70ed9489e1d573
|
[
"MIT"
] | 9
|
2020-02-17T18:15:41.000Z
|
2021-06-06T19:17:34.000Z
|
SDK/ARKSurvivalEvolved_Telemetry_functions.cpp
|
2bite/ARK-SDK
|
c38ca9925309516b2093ad8c3a70ed9489e1d573
|
[
"MIT"
] | 3
|
2020-07-22T17:42:07.000Z
|
2021-06-19T17:16:13.000Z
|
// ARKSurvivalEvolved (329.9) SDK
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
#include "ARKSurvivalEvolved_Telemetry_parameters.hpp"
namespace sdk
{
//---------------------------------------------------------------------------
//Functions
//---------------------------------------------------------------------------
// Function Telemetry.TelemetryFunctionLibrary.ZoneColor
// ()
// Parameters:
// float red (Parm, ZeroConstructor, IsPlainOldData)
// float green (Parm, ZeroConstructor, IsPlainOldData)
// float blue (Parm, ZeroConstructor, IsPlainOldData)
void UTelemetryFunctionLibrary::ZoneColor(float red, float green, float blue)
{
static auto fn = UObject::FindObject<UFunction>("Function Telemetry.TelemetryFunctionLibrary.ZoneColor");
UTelemetryFunctionLibrary_ZoneColor_Params params;
params.red = red;
params.green = green;
params.blue = blue;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Telemetry.TelemetryFunctionLibrary.Stop
// ()
void UTelemetryFunctionLibrary::Stop()
{
static auto fn = UObject::FindObject<UFunction>("Function Telemetry.TelemetryFunctionLibrary.Stop");
UTelemetryFunctionLibrary_Stop_Params params;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Telemetry.TelemetryFunctionLibrary.Start
// ()
// Parameters:
// class FString server_ip (Parm, ZeroConstructor)
void UTelemetryFunctionLibrary::Start(const class FString& server_ip)
{
static auto fn = UObject::FindObject<UFunction>("Function Telemetry.TelemetryFunctionLibrary.Start");
UTelemetryFunctionLibrary_Start_Params params;
params.server_ip = server_ip;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Telemetry.TelemetryFunctionLibrary.SetZoneFlag
// ()
// Parameters:
// TEnumAsByte<ETmZoneFlags> Flags (Parm, ZeroConstructor, IsPlainOldData)
void UTelemetryFunctionLibrary::SetZoneFlag(TEnumAsByte<ETmZoneFlags> Flags)
{
static auto fn = UObject::FindObject<UFunction>("Function Telemetry.TelemetryFunctionLibrary.SetZoneFlag");
UTelemetryFunctionLibrary_SetZoneFlag_Params params;
params.Flags = Flags;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Telemetry.TelemetryFunctionLibrary.SetZoneFilterThreshold
// ()
// Parameters:
// int filter_clocks (Parm, ZeroConstructor, IsPlainOldData)
void UTelemetryFunctionLibrary::SetZoneFilterThreshold(int filter_clocks)
{
static auto fn = UObject::FindObject<UFunction>("Function Telemetry.TelemetryFunctionLibrary.SetZoneFilterThreshold");
UTelemetryFunctionLibrary_SetZoneFilterThreshold_Params params;
params.filter_clocks = filter_clocks;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Telemetry.TelemetryFunctionLibrary.SetSendBufferSize
// ()
// Parameters:
// int buffer_size (Parm, ZeroConstructor, IsPlainOldData)
void UTelemetryFunctionLibrary::SetSendBufferSize(int buffer_size)
{
static auto fn = UObject::FindObject<UFunction>("Function Telemetry.TelemetryFunctionLibrary.SetSendBufferSize");
UTelemetryFunctionLibrary_SetSendBufferSize_Params params;
params.buffer_size = buffer_size;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Telemetry.TelemetryFunctionLibrary.SetSendBufferCount
// ()
// Parameters:
// int buffer_count (Parm, ZeroConstructor, IsPlainOldData)
void UTelemetryFunctionLibrary::SetSendBufferCount(int buffer_count)
{
static auto fn = UObject::FindObject<UFunction>("Function Telemetry.TelemetryFunctionLibrary.SetSendBufferCount");
UTelemetryFunctionLibrary_SetSendBufferCount_Params params;
params.buffer_count = buffer_count;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Telemetry.TelemetryFunctionLibrary.SetMaxTimeSpanTrackCount
// ()
// Parameters:
// int max_track_count (Parm, ZeroConstructor, IsPlainOldData)
void UTelemetryFunctionLibrary::SetMaxTimeSpanTrackCount(int max_track_count)
{
static auto fn = UObject::FindObject<UFunction>("Function Telemetry.TelemetryFunctionLibrary.SetMaxTimeSpanTrackCount");
UTelemetryFunctionLibrary_SetMaxTimeSpanTrackCount_Params params;
params.max_track_count = max_track_count;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Telemetry.TelemetryFunctionLibrary.SetCaptureMask
// ()
// Parameters:
// int capture_mask (Parm, ZeroConstructor, IsPlainOldData)
void UTelemetryFunctionLibrary::SetCaptureMask(int capture_mask)
{
static auto fn = UObject::FindObject<UFunction>("Function Telemetry.TelemetryFunctionLibrary.SetCaptureMask");
UTelemetryFunctionLibrary_SetCaptureMask_Params params;
params.capture_mask = capture_mask;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Telemetry.TelemetryFunctionLibrary.Running
// ()
// Parameters:
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
int UTelemetryFunctionLibrary::Running()
{
static auto fn = UObject::FindObject<UFunction>("Function Telemetry.TelemetryFunctionLibrary.Running");
UTelemetryFunctionLibrary_Running_Params params;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function Telemetry.TelemetryFunctionLibrary.RenameZone
// ()
// Parameters:
// int capture_mask (Parm, ZeroConstructor, IsPlainOldData)
// class FString Name (Parm, ZeroConstructor)
void UTelemetryFunctionLibrary::RenameZone(int capture_mask, const class FString& Name)
{
static auto fn = UObject::FindObject<UFunction>("Function Telemetry.TelemetryFunctionLibrary.RenameZone");
UTelemetryFunctionLibrary_RenameZone_Params params;
params.capture_mask = capture_mask;
params.Name = Name;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Telemetry.TelemetryFunctionLibrary.Ploti
// ()
// Parameters:
// int capture_mask (Parm, ZeroConstructor, IsPlainOldData)
// class FString Name (Parm, ZeroConstructor)
// int Value (Parm, ZeroConstructor, IsPlainOldData)
void UTelemetryFunctionLibrary::Ploti(int capture_mask, const class FString& Name, int Value)
{
static auto fn = UObject::FindObject<UFunction>("Function Telemetry.TelemetryFunctionLibrary.Ploti");
UTelemetryFunctionLibrary_Ploti_Params params;
params.capture_mask = capture_mask;
params.Name = Name;
params.Value = Value;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Telemetry.TelemetryFunctionLibrary.Plotf
// ()
// Parameters:
// int capture_mask (Parm, ZeroConstructor, IsPlainOldData)
// class FString Name (Parm, ZeroConstructor)
// float Value (Parm, ZeroConstructor, IsPlainOldData)
void UTelemetryFunctionLibrary::Plotf(int capture_mask, const class FString& Name, float Value)
{
static auto fn = UObject::FindObject<UFunction>("Function Telemetry.TelemetryFunctionLibrary.Plotf");
UTelemetryFunctionLibrary_Plotf_Params params;
params.capture_mask = capture_mask;
params.Name = Name;
params.Value = Value;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Telemetry.TelemetryFunctionLibrary.Message
// ()
// Parameters:
// int capture_mask (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ETmMessageFlags> Flags (Parm, ZeroConstructor, IsPlainOldData)
// class FString Message (Parm, ZeroConstructor)
void UTelemetryFunctionLibrary::Message(int capture_mask, TEnumAsByte<ETmMessageFlags> Flags, const class FString& Message)
{
static auto fn = UObject::FindObject<UFunction>("Function Telemetry.TelemetryFunctionLibrary.Message");
UTelemetryFunctionLibrary_Message_Params params;
params.capture_mask = capture_mask;
params.Flags = Flags;
params.Message = Message;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Telemetry.TelemetryFunctionLibrary.LeaveAccumulationZone
// ()
// Parameters:
// int capture_mask (Parm, ZeroConstructor, IsPlainOldData)
// struct FTmAccumulator accumulator (Parm, ZeroConstructor, IsPlainOldData)
// struct FTmAccumulator ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
struct FTmAccumulator UTelemetryFunctionLibrary::LeaveAccumulationZone(int capture_mask, const struct FTmAccumulator& accumulator)
{
static auto fn = UObject::FindObject<UFunction>("Function Telemetry.TelemetryFunctionLibrary.LeaveAccumulationZone");
UTelemetryFunctionLibrary_LeaveAccumulationZone_Params params;
params.capture_mask = capture_mask;
params.accumulator = accumulator;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function Telemetry.TelemetryFunctionLibrary.Leave
// ()
// Parameters:
// int capture_mask (Parm, ZeroConstructor, IsPlainOldData)
void UTelemetryFunctionLibrary::Leave(int capture_mask)
{
static auto fn = UObject::FindObject<UFunction>("Function Telemetry.TelemetryFunctionLibrary.Leave");
UTelemetryFunctionLibrary_Leave_Params params;
params.capture_mask = capture_mask;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Telemetry.TelemetryFunctionLibrary.GetSendBufferSize
// ()
// Parameters:
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
int UTelemetryFunctionLibrary::GetSendBufferSize()
{
static auto fn = UObject::FindObject<UFunction>("Function Telemetry.TelemetryFunctionLibrary.GetSendBufferSize");
UTelemetryFunctionLibrary_GetSendBufferSize_Params params;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function Telemetry.TelemetryFunctionLibrary.GetSendBufferCount
// ()
// Parameters:
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
int UTelemetryFunctionLibrary::GetSendBufferCount()
{
static auto fn = UObject::FindObject<UFunction>("Function Telemetry.TelemetryFunctionLibrary.GetSendBufferCount");
UTelemetryFunctionLibrary_GetSendBufferCount_Params params;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function Telemetry.TelemetryFunctionLibrary.GetMaxTimeSpanTrackCount
// ()
// Parameters:
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
int UTelemetryFunctionLibrary::GetMaxTimeSpanTrackCount()
{
static auto fn = UObject::FindObject<UFunction>("Function Telemetry.TelemetryFunctionLibrary.GetMaxTimeSpanTrackCount");
UTelemetryFunctionLibrary_GetMaxTimeSpanTrackCount_Params params;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function Telemetry.TelemetryFunctionLibrary.GetCaptureMask
// ()
// Parameters:
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
int UTelemetryFunctionLibrary::GetCaptureMask()
{
static auto fn = UObject::FindObject<UFunction>("Function Telemetry.TelemetryFunctionLibrary.GetCaptureMask");
UTelemetryFunctionLibrary_GetCaptureMask_Params params;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function Telemetry.TelemetryFunctionLibrary.EnterAccumulationZone
// ()
// Parameters:
// int capture_mask (Parm, ZeroConstructor, IsPlainOldData)
// struct FTmAccumulator accumulator (Parm, ZeroConstructor, IsPlainOldData)
// struct FTmAccumulator ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
struct FTmAccumulator UTelemetryFunctionLibrary::EnterAccumulationZone(int capture_mask, const struct FTmAccumulator& accumulator)
{
static auto fn = UObject::FindObject<UFunction>("Function Telemetry.TelemetryFunctionLibrary.EnterAccumulationZone");
UTelemetryFunctionLibrary_EnterAccumulationZone_Params params;
params.capture_mask = capture_mask;
params.accumulator = accumulator;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function Telemetry.TelemetryFunctionLibrary.Enter
// ()
// Parameters:
// int capture_mask (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ETmZoneFlags> Flags (Parm, ZeroConstructor, IsPlainOldData)
// class FString Name (Parm, ZeroConstructor)
void UTelemetryFunctionLibrary::Enter(int capture_mask, TEnumAsByte<ETmZoneFlags> Flags, const class FString& Name)
{
static auto fn = UObject::FindObject<UFunction>("Function Telemetry.TelemetryFunctionLibrary.Enter");
UTelemetryFunctionLibrary_Enter_Params params;
params.capture_mask = capture_mask;
params.Flags = Flags;
params.Name = Name;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Telemetry.TelemetryFunctionLibrary.EndTimeSpan
// ()
// Parameters:
// int capture_mask (Parm, ZeroConstructor, IsPlainOldData)
// int time_span_id (Parm, ZeroConstructor, IsPlainOldData)
void UTelemetryFunctionLibrary::EndTimeSpan(int capture_mask, int time_span_id)
{
static auto fn = UObject::FindObject<UFunction>("Function Telemetry.TelemetryFunctionLibrary.EndTimeSpan");
UTelemetryFunctionLibrary_EndTimeSpan_Params params;
params.capture_mask = capture_mask;
params.time_span_id = time_span_id;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Telemetry.TelemetryFunctionLibrary.EmitAccumulationZone
// ()
// Parameters:
// int capture_mask (Parm, ZeroConstructor, IsPlainOldData)
// int Flags (Parm, ZeroConstructor, IsPlainOldData)
// int Count (Parm, ZeroConstructor, IsPlainOldData)
// struct FTmAccumulator accumulated_clocks (Parm, ZeroConstructor, IsPlainOldData)
// class FString zone_name (Parm, ZeroConstructor)
void UTelemetryFunctionLibrary::EmitAccumulationZone(int capture_mask, int Flags, int Count, const struct FTmAccumulator& accumulated_clocks, const class FString& zone_name)
{
static auto fn = UObject::FindObject<UFunction>("Function Telemetry.TelemetryFunctionLibrary.EmitAccumulationZone");
UTelemetryFunctionLibrary_EmitAccumulationZone_Params params;
params.capture_mask = capture_mask;
params.Flags = Flags;
params.Count = Count;
params.accumulated_clocks = accumulated_clocks;
params.zone_name = zone_name;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Telemetry.TelemetryFunctionLibrary.BeginTimeSpan
// ()
// Parameters:
// int capture_mask (Parm, ZeroConstructor, IsPlainOldData)
// int time_span_id (Parm, ZeroConstructor, IsPlainOldData)
// int Flags (Parm, ZeroConstructor, IsPlainOldData)
// class FString time_span_name (Parm, ZeroConstructor)
void UTelemetryFunctionLibrary::BeginTimeSpan(int capture_mask, int time_span_id, int Flags, const class FString& time_span_name)
{
static auto fn = UObject::FindObject<UFunction>("Function Telemetry.TelemetryFunctionLibrary.BeginTimeSpan");
UTelemetryFunctionLibrary_BeginTimeSpan_Params params;
params.capture_mask = capture_mask;
params.time_span_id = time_span_id;
params.Flags = Flags;
params.time_span_name = time_span_name;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| 31.240351
| 173
| 0.699107
|
2bite
|
c81f2349939a070d59ee0905ed32153184db9789
| 1,362
|
cpp
|
C++
|
dev/ScrollPresenter/ScrollControllerScrollToRequestedEventArgs.cpp
|
riverar/microsoft-ui-xaml
|
ef3a0fcd85d200c98514e765eea94323b943cf1e
|
[
"MIT"
] | 3,788
|
2019-05-07T02:41:36.000Z
|
2022-03-30T12:34:15.000Z
|
dev/ScrollPresenter/ScrollControllerScrollToRequestedEventArgs.cpp
|
riverar/microsoft-ui-xaml
|
ef3a0fcd85d200c98514e765eea94323b943cf1e
|
[
"MIT"
] | 6,170
|
2019-05-06T21:32:43.000Z
|
2022-03-31T23:46:55.000Z
|
dev/ScrollPresenter/ScrollControllerScrollToRequestedEventArgs.cpp
|
riverar/microsoft-ui-xaml
|
ef3a0fcd85d200c98514e765eea94323b943cf1e
|
[
"MIT"
] | 532
|
2019-05-07T12:15:58.000Z
|
2022-03-31T11:36:26.000Z
|
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.
#include "pch.h"
#include "common.h"
#include "TypeLogging.h"
#include "ScrollPresenterTypeLogging.h"
#include "ScrollPresenter.h"
#include "ScrollControllerScrollToRequestedEventArgs.h"
#include "ScrollControllerScrollToRequestedEventArgs.properties.cpp"
ScrollControllerScrollToRequestedEventArgs::ScrollControllerScrollToRequestedEventArgs(
double offset,
winrt::ScrollingScrollOptions const& options)
{
SCROLLPRESENTER_TRACE_VERBOSE(nullptr, TRACE_MSG_METH_STR_DBL, METH_NAME, this,
TypeLogging::ScrollOptionsToString(options).c_str(), offset);
m_offset = offset;
m_options = options;
}
double ScrollControllerScrollToRequestedEventArgs::Offset() const
{
return m_offset;
}
winrt::ScrollingScrollOptions ScrollControllerScrollToRequestedEventArgs::Options() const
{
return m_options;
}
int32_t ScrollControllerScrollToRequestedEventArgs::CorrelationId() const
{
return m_correlationId;
}
void ScrollControllerScrollToRequestedEventArgs::CorrelationId(int32_t correlationId)
{
SCROLLPRESENTER_TRACE_VERBOSE(nullptr, TRACE_MSG_METH_INT, METH_NAME, this, correlationId);
m_correlationId = correlationId;
}
| 30.266667
| 96
| 0.78047
|
riverar
|
c821b4f3e1686afdec2ca85677951da0c1229aac
| 19,144
|
cpp
|
C++
|
src/add-ons/kernel/bus_managers/ps2/ps2_synaptics.cpp
|
Yn0ga/haiku
|
74e271b2a286c239e60f0ec261f4f197f4727eee
|
[
"MIT"
] | 1,338
|
2015-01-03T20:06:56.000Z
|
2022-03-26T13:49:54.000Z
|
src/add-ons/kernel/bus_managers/ps2/ps2_synaptics.cpp
|
Yn0ga/haiku
|
74e271b2a286c239e60f0ec261f4f197f4727eee
|
[
"MIT"
] | 15
|
2015-01-17T22:19:32.000Z
|
2021-12-20T12:35:00.000Z
|
src/add-ons/kernel/bus_managers/ps2/ps2_synaptics.cpp
|
Yn0ga/haiku
|
74e271b2a286c239e60f0ec261f4f197f4727eee
|
[
"MIT"
] | 350
|
2015-01-08T14:15:27.000Z
|
2022-03-21T18:14:35.000Z
|
/*
* Copyright 2008-2010, Haiku, Inc.
* Distributed under the terms of the MIT License.
*
* Authors (in chronological order):
* Clemens Zeidler (haiku@Clemens-Zeidler.de)
* Axel Dörfler, axeld@pinc-software.de
*/
//! PS/2 synaptics touchpad
#include "ps2_synaptics.h"
#include <string.h>
#include <stdlib.h>
#include <keyboard_mouse_driver.h>
#include "ps2_service.h"
//#define TRACE_PS2_SYNAPTICS
#ifdef TRACE_PS2_SYNAPTICS
# define TRACE(x...) dprintf(x)
#else
# define TRACE(x...)
#endif
// synaptics touchpad proportions
#define SYN_EDGE_MOTION_WIDTH 50
#define SYN_AREA_OFFSET 40
#define MIN_PRESSURE 30
#define REAL_MAX_PRESSURE 100
#define MAX_PRESSURE 200
enum {
kIdentify = 0x00,
kReadModes = 0x01,
kReadCapabilities = 0x02,
kReadModelId = 0x03,
kReadSerialNumberPrefix = 0x06,
kReadSerialModelSuffix = 0x07,
kReadResolutions = 0x08,
kExtendedModelId = 0x09,
kContinuedCapabilities = 0x0C,
kMaximumCoordinates = 0x0D,
kDeluxeLedInfo = 0x0E,
kMinimumCoordinates = 0x0F,
kTrackpointQuirk = 0x10
};
static hardware_specs gHardwareSpecs;
const char* kSynapticsPath[4] = {
"input/touchpad/ps2/synaptics_0",
"input/touchpad/ps2/synaptics_1",
"input/touchpad/ps2/synaptics_2",
"input/touchpad/ps2/synaptics_3"
};
static touchpad_info sTouchpadInfo;
static ps2_dev *sPassthroughDevice = &ps2_device[PS2_DEVICE_SYN_PASSTHROUGH];
static void
default_settings(touchpad_settings *set)
{
memcpy(set, &kDefaultTouchpadSettings, sizeof(touchpad_settings));
}
static status_t
send_touchpad_arg_timeout(ps2_dev *dev, uint8 arg, bigtime_t timeout)
{
int8 i;
uint8 val[8];
for (i = 0; i < 4; i++) {
val[2 * i] = (arg >> (6 - 2 * i)) & 3;
val[2 * i + 1] = 0xE8;
}
return ps2_dev_command_timeout(dev, 0xE8, val, 7, NULL, 0, timeout);
}
static status_t
send_touchpad_arg(ps2_dev *dev, uint8 arg)
{
return send_touchpad_arg_timeout(dev, arg, 4000000);
}
static status_t
set_touchpad_mode(ps2_dev *dev, uint8 mode)
{
uint8 sample_rate = SYN_CHANGE_MODE;
send_touchpad_arg(dev, mode);
return ps2_dev_command(dev, PS2_CMD_SET_SAMPLE_RATE, &sample_rate, 1,
NULL, 0);
}
static status_t
get_information_query(ps2_dev *dev, uint8 extendedQueries, uint8 query,
uint8 val[3])
{
if (query == kTrackpointQuirk) {
// Special case: this information query is not reported in the
// "extended queries", but is still supported when the touchpad has
// a pass-through port.
if (!sTouchpadInfo.capPassThrough)
return B_NOT_SUPPORTED;
} else if (query > extendedQueries + 8)
return B_NOT_SUPPORTED;
status_t error = send_touchpad_arg(dev, query);
if (error != B_OK)
return error;
return ps2_dev_command(dev, 0xE9, NULL, 0, val, 3);
}
static status_t
get_synaptics_movment(synaptics_cookie *cookie, mouse_movement *movement)
{
status_t status;
touch_event event;
uint8 event_buffer[PS2_MAX_PACKET_SIZE];
uint8 wValue0, wValue1, wValue2, wValue3, wValue;
uint32 val32;
uint32 xTwelfBit, yTwelfBit;
status = acquire_sem_etc(cookie->synaptics_sem, 1, B_CAN_INTERRUPT, 0);
if (status < B_OK)
return status;
if (!cookie->dev->active) {
TRACE("SYNAPTICS: read_event: Error device no longer active\n");
return B_ERROR;
}
if (packet_buffer_read(cookie->synaptics_ring_buffer, event_buffer,
cookie->dev->packet_size) != cookie->dev->packet_size) {
TRACE("SYNAPTICS: error copying buffer\n");
return B_ERROR;
}
event.buttons = event_buffer[0] & 3;
event.zPressure = event_buffer[2];
if (sTouchpadInfo.capExtended) {
wValue0 = event_buffer[3] >> 2 & 1;
wValue1 = event_buffer[0] >> 2 & 1;
wValue2 = event_buffer[0] >> 4 & 1;
wValue3 = event_buffer[0] >> 5 & 1;
wValue = wValue0;
wValue = wValue | (wValue1 << 1);
wValue = wValue | (wValue2 << 2);
wValue = wValue | (wValue3 << 3);
event.wValue = wValue;
event.gesture = false;
// Clickpad pretends that all clicks on the touchpad are middle clicks.
// Pass them to userspace as left clicks instead.
if (sTouchpadInfo.capClickPad)
event.buttons |= ((event_buffer[0] ^ event_buffer[3]) & 0x01);
if (sTouchpadInfo.capMiddleButton || sTouchpadInfo.capFourButtons)
event.buttons |= ((event_buffer[0] ^ event_buffer[3]) & 0x01) << 2;
if (sTouchpadInfo.nExtendedButtons > 0) {
if (((event_buffer[0] ^ event_buffer[3]) & 0x02) != 0) {
// This packet includes extended buttons state. The state is
// only reported once when one of the buttons is pressed or
// released, so we must keep track of the buttons state.
// The values replace the lowest bits of the X and Y coordinates
// in the packet, we need to extract them from there.
bool pressed;
for (int button = 0; button < sTouchpadInfo.nExtendedButtons;
button++) {
// Even buttons are in the X byte
pressed = event_buffer[4 + button % 2] >> button / 2 & 0x1;
if (pressed) {
sTouchpadInfo.extendedButtonsState |= 1 << button;
} else {
sTouchpadInfo.extendedButtonsState &= ~(1 << button);
}
}
}
event.buttons |= sTouchpadInfo.extendedButtonsState
<< sTouchpadInfo.firstExtendedButton;
}
} else {
bool finger = event_buffer[0] >> 5 & 1;
if (finger) {
// finger with normal width
event.wValue = 4;
}
event.gesture = event_buffer[0] >> 2 & 1;
}
event.xPosition = event_buffer[4];
event.yPosition = event_buffer[5];
val32 = event_buffer[1] & 0x0F;
event.xPosition += val32 << 8;
val32 = event_buffer[1] >> 4 & 0x0F;
event.yPosition += val32 << 8;
xTwelfBit = event_buffer[3] >> 4 & 1;
event.xPosition += xTwelfBit << 12;
yTwelfBit = event_buffer[3] >> 5 & 1;
event.yPosition += yTwelfBit << 12;
status = cookie->movementMaker.EventToMovement(&event, movement);
return status;
}
static void
query_capability(ps2_dev *dev)
{
uint8 val[3];
uint8 nExtendedQueries = 0;
get_information_query(dev, nExtendedQueries, kReadCapabilities, val);
TRACE("SYNAPTICS: extended mode %2x\n", val[0] >> 7 & 1);
sTouchpadInfo.capExtended = val[0] >> 7 & 1;
TRACE("SYNAPTICS: extended queries %2x\n", val[0] >> 4 & 7);
nExtendedQueries = val[0] >> 4 & 7;
TRACE("SYNAPTICS: middle button %2x\n", val[0] >> 2 & 1);
sTouchpadInfo.capMiddleButton = val[0] >> 2 & 1;
TRACE("SYNAPTICS: sleep mode %2x\n", val[2] >> 4 & 1);
sTouchpadInfo.capSleep = val[2] >> 4 & 1;
TRACE("SYNAPTICS: four buttons %2x\n", val[2] >> 3 & 1);
sTouchpadInfo.capFourButtons = val[2] >> 3 & 1;
TRACE("SYNAPTICS: multi finger %2x\n", val[2] >> 1 & 1);
sTouchpadInfo.capMultiFinger = val[2] >> 1 & 1;
TRACE("SYNAPTICS: palm detection %2x\n", val[2] & 1);
sTouchpadInfo.capPalmDetection = val[2] & 1;
TRACE("SYNAPTICS: pass through %2x\n", val[2] >> 7 & 1);
sTouchpadInfo.capPassThrough = val[2] >> 7 & 1;
if (get_information_query(dev, nExtendedQueries, kExtendedModelId, val)
!= B_OK) {
// "Extended Model ID" is not supported, so there cannot be extra
// buttons.
sTouchpadInfo.nExtendedButtons = 0;
sTouchpadInfo.firstExtendedButton = 0;
sTouchpadInfo.capClickPad = false;
return;
}
sTouchpadInfo.capClickPad = (val[0] >> 5 & 1) | (val[1] >> 0 & 1);
TRACE("SYNAPTICS: clickpad %x\n", sTouchpadInfo.capClickPad);
TRACE("SYNAPTICS: extended buttons %2x\n", val[1] >> 4 & 15);
sTouchpadInfo.nExtendedButtons = val[1] >> 4 & 15;
sTouchpadInfo.extendedButtonsState = 0;
if (sTouchpadInfo.capMiddleButton)
sTouchpadInfo.firstExtendedButton = 3;
else
sTouchpadInfo.firstExtendedButton = 2;
// Capability 0x10 is not documented in the Synaptics Touchpad interfacing
// guide (at least the versions I could find), but we got the information
// from Linux patches: https://lkml.org/lkml/2015/2/6/621
if (get_information_query(dev, nExtendedQueries, kTrackpointQuirk, val)
!= B_OK)
return;
// Workaround for Thinkpad use of the extended buttons: they are
// used as buttons for the trackpoint, so they should be reported
// as buttons 0, 1, 2 rather than 3, 4, 5.
TRACE("SYNAPTICS: alternate buttons %2x\n", val[0] >> 0 & 1);
if (val[0] >> 0 & 1)
sTouchpadInfo.firstExtendedButton = 0;
}
// #pragma mark - exported functions
status_t
synaptics_pass_through_set_packet_size(ps2_dev *dev, uint8 size)
{
synaptics_cookie *synapticsCookie
= (synaptics_cookie*)dev->parent_dev->cookie;
status_t status = ps2_dev_command(dev->parent_dev, PS2_CMD_DISABLE, NULL,
0, NULL, 0);
if (status < B_OK) {
INFO("SYNAPTICS: cannot disable touchpad %s\n", dev->parent_dev->name);
return B_ERROR;
}
synapticsCookie->packet_index = 0;
if (size == 4)
synapticsCookie->mode |= SYN_FOUR_BYTE_CHILD;
else
synapticsCookie->mode &= ~SYN_FOUR_BYTE_CHILD;
set_touchpad_mode(dev->parent_dev, synapticsCookie->mode);
status = ps2_dev_command(dev->parent_dev, PS2_CMD_ENABLE, NULL, 0, NULL, 0);
if (status < B_OK) {
INFO("SYNAPTICS: cannot enable touchpad %s\n", dev->parent_dev->name);
return B_ERROR;
}
return status;
}
status_t
passthrough_command(ps2_dev *dev, uint8 cmd, const uint8 *out, int outCount,
uint8 *in, int inCount, bigtime_t timeout)
{
status_t status;
uint8 passThroughCmd = SYN_PASSTHROUGH_CMD;
uint8 val;
uint32 passThroughInCount = (inCount + 1) * 6;
uint8 passThroughIn[passThroughInCount];
int8 i;
TRACE("SYNAPTICS: passthrough command 0x%x\n", cmd);
status = ps2_dev_command(dev->parent_dev, PS2_CMD_DISABLE, NULL, 0,
NULL, 0);
if (status != B_OK)
return status;
for (i = -1; i < outCount; i++) {
if (i == -1)
val = cmd;
else
val = out[i];
status = send_touchpad_arg_timeout(dev->parent_dev, val, timeout);
if (status != B_OK)
goto finalize;
if (i != outCount -1) {
status = ps2_dev_command_timeout(dev->parent_dev,
PS2_CMD_SET_SAMPLE_RATE, &passThroughCmd, 1, NULL, 0, timeout);
if (status != B_OK)
goto finalize;
}
}
status = ps2_dev_command_timeout(dev->parent_dev, PS2_CMD_SET_SAMPLE_RATE,
&passThroughCmd, 1, passThroughIn, passThroughInCount, timeout);
if (status != B_OK)
goto finalize;
for (i = 0; i < inCount + 1; i++) {
uint8 *inPointer = &passThroughIn[i * 6];
if (!IS_SYN_PT_PACKAGE(inPointer)) {
TRACE("SYNAPTICS: not a pass throught package\n");
goto finalize;
}
if (i == 0)
continue;
in[i - 1] = passThroughIn[i * 6 + 1];
}
finalize:
status_t statusOfEnable = ps2_dev_command(dev->parent_dev, PS2_CMD_ENABLE,
NULL, 0, NULL, 0);
if (statusOfEnable != B_OK) {
TRACE("SYNAPTICS: enabling of parent failed: 0x%" B_PRIx32 ".\n",
statusOfEnable);
}
return status != B_OK ? status : statusOfEnable;
}
status_t
probe_synaptics(ps2_dev *dev)
{
uint8 val[3];
uint8 deviceId;
status_t status;
TRACE("SYNAPTICS: probe\n");
// We reset the device here because it may have been left in a confused
// state by a previous probing attempt. Some synaptics touchpads are known
// to lockup when we attempt to detect them as IBM trackpoints.
ps2_reset_mouse(dev);
// Request "Identify touchpad"
// The touchpad will delay this, until it's ready and calibrated.
status = get_information_query(dev, 0, kIdentify, val);
if (status != B_OK)
return status;
sTouchpadInfo.minorVersion = val[0];
deviceId = val[1];
if (deviceId != SYN_TOUCHPAD) {
TRACE("SYNAPTICS: not found\n");
return B_ERROR;
}
TRACE("SYNAPTICS: Touchpad found id:l %2x\n", deviceId);
sTouchpadInfo.majorVersion = val[2] & 0x0F;
TRACE("SYNAPTICS: version %d.%d\n", sTouchpadInfo.majorVersion,
sTouchpadInfo.minorVersion);
// version >= 4.0?
if (sTouchpadInfo.minorVersion <= 2
&& sTouchpadInfo.majorVersion <= 3) {
TRACE("SYNAPTICS: too old touchpad not supported\n");
return B_ERROR;
}
dev->name = kSynapticsPath[dev->idx];
return B_OK;
}
// #pragma mark - Device functions
status_t
synaptics_open(const char *name, uint32 flags, void **_cookie)
{
status_t status;
synaptics_cookie *cookie;
ps2_dev *dev;
int i;
for (dev = NULL, i = 0; i < PS2_DEVICE_COUNT; i++) {
if (0 == strcmp(ps2_device[i].name, name)) {
dev = &ps2_device[i];
break;
}
}
if (dev == NULL) {
TRACE("ps2: dev = NULL\n");
return B_ERROR;
}
if (atomic_or(&dev->flags, PS2_FLAG_OPEN) & PS2_FLAG_OPEN)
return B_BUSY;
cookie = (synaptics_cookie*)malloc(sizeof(synaptics_cookie));
if (cookie == NULL)
goto err1;
memset(cookie, 0, sizeof(*cookie));
cookie->movementMaker.Init();
*_cookie = cookie;
cookie->dev = dev;
dev->cookie = cookie;
dev->disconnect = &synaptics_disconnect;
dev->handle_int = &synaptics_handle_int;
default_settings(&cookie->settings);
gHardwareSpecs.edgeMotionWidth = SYN_EDGE_MOTION_WIDTH;
gHardwareSpecs.areaStartX = SYN_AREA_START_X;
gHardwareSpecs.areaEndX = SYN_AREA_END_X;
gHardwareSpecs.areaStartY = SYN_AREA_START_Y;
gHardwareSpecs.areaEndY = SYN_AREA_END_Y;
gHardwareSpecs.minPressure = MIN_PRESSURE;
gHardwareSpecs.realMaxPressure = REAL_MAX_PRESSURE;
gHardwareSpecs.maxPressure = MAX_PRESSURE;
cookie->movementMaker.SetSettings(&cookie->settings);
cookie->movementMaker.SetSpecs(&gHardwareSpecs);
dev->packet_size = PS2_PACKET_SYNAPTICS;
cookie->synaptics_ring_buffer
= create_packet_buffer(SYNAPTICS_HISTORY_SIZE * dev->packet_size);
if (cookie->synaptics_ring_buffer == NULL) {
TRACE("ps2: can't allocate mouse actions buffer\n");
goto err2;
}
// create the mouse semaphore, used for synchronization between
// the interrupt handler and the read operation
cookie->synaptics_sem = create_sem(0, "ps2_synaptics_sem");
if (cookie->synaptics_sem < 0) {
TRACE("SYNAPTICS: failed creating semaphore!\n");
goto err3;
}
query_capability(dev);
// create pass through dev
if (sTouchpadInfo.capPassThrough) {
TRACE("SYNAPTICS: pass through detected\n");
sPassthroughDevice->parent_dev = dev;
sPassthroughDevice->idx = dev->idx;
ps2_service_notify_device_added(sPassthroughDevice);
}
// Set Mode
if (sTouchpadInfo.capExtended)
cookie->mode = SYN_ABSOLUTE_W_MODE;
else
cookie->mode = SYN_ABSOLUTE_MODE;
status = set_touchpad_mode(dev, cookie->mode);
if (status < B_OK) {
INFO("SYNAPTICS: cannot set mode %s\n", name);
goto err4;
}
status = ps2_dev_command(dev, PS2_CMD_ENABLE, NULL, 0, NULL, 0);
if (status < B_OK) {
INFO("SYNAPTICS: cannot enable touchpad %s\n", name);
goto err4;
}
atomic_or(&dev->flags, PS2_FLAG_ENABLED);
TRACE("SYNAPTICS: open %s success\n", name);
return B_OK;
err4:
delete_sem(cookie->synaptics_sem);
err3:
delete_packet_buffer(cookie->synaptics_ring_buffer);
err2:
free(cookie);
err1:
atomic_and(&dev->flags, ~PS2_FLAG_OPEN);
TRACE("SYNAPTICS: synaptics_open %s failed\n", name);
return B_ERROR;
}
status_t
synaptics_close(void *_cookie)
{
status_t status;
synaptics_cookie *cookie = (synaptics_cookie*)_cookie;
ps2_dev_command_timeout(cookie->dev, PS2_CMD_DISABLE, NULL, 0, NULL, 0,
150000);
delete_packet_buffer(cookie->synaptics_ring_buffer);
delete_sem(cookie->synaptics_sem);
atomic_and(&cookie->dev->flags, ~PS2_FLAG_OPEN);
atomic_and(&cookie->dev->flags, ~PS2_FLAG_ENABLED);
// Reset the touchpad so it generate standard ps2 packets instead of
// extended ones. If not, BeOS is confused with such packets when rebooting
// without a complete shutdown.
status = ps2_reset_mouse(cookie->dev);
if (status != B_OK) {
INFO("ps2: reset failed\n");
return B_ERROR;
}
if (sTouchpadInfo.capPassThrough)
ps2_service_notify_device_removed(sPassthroughDevice);
TRACE("SYNAPTICS: close %s done\n", cookie->dev->name);
return B_OK;
}
status_t
synaptics_freecookie(void *_cookie)
{
free(_cookie);
return B_OK;
}
static status_t
synaptics_read(void *cookie, off_t pos, void *buffer, size_t *_length)
{
*_length = 0;
return B_NOT_ALLOWED;
}
static status_t
synaptics_write(void *cookie, off_t pos, const void *buffer, size_t *_length)
{
*_length = 0;
return B_NOT_ALLOWED;
}
status_t
synaptics_ioctl(void *_cookie, uint32 op, void *buffer, size_t length)
{
synaptics_cookie *cookie = (synaptics_cookie*)_cookie;
mouse_movement movement;
status_t status;
switch (op) {
case MS_READ:
if ((status = get_synaptics_movment(cookie, &movement)) != B_OK)
return status;
TRACE("SYNAPTICS: MS_READ get event\n");
return user_memcpy(buffer, &movement, sizeof(movement));
case MS_IS_TOUCHPAD:
TRACE("SYNAPTICS: MS_IS_TOUCHPAD\n");
return B_OK;
case MS_SET_TOUCHPAD_SETTINGS:
TRACE("SYNAPTICS: MS_SET_TOUCHPAD_SETTINGS");
user_memcpy(&cookie->settings, buffer, sizeof(touchpad_settings));
return B_OK;
case MS_SET_CLICKSPEED:
TRACE("SYNAPTICS: ioctl MS_SETCLICK (set click speed)\n");
return user_memcpy(&cookie->movementMaker.click_speed, buffer,
sizeof(bigtime_t));
default:
TRACE("SYNAPTICS: unknown opcode: %" B_PRIu32 "\n", op);
return B_DEV_INVALID_IOCTL;
}
}
int32
synaptics_handle_int(ps2_dev *dev)
{
synaptics_cookie *cookie = (synaptics_cookie*)dev->cookie;
uint8 val;
val = cookie->dev->history[0].data;
if ((cookie->packet_index == 0 || cookie->packet_index == 3)
&& (val & 8) != 0) {
INFO("SYNAPTICS: bad mouse data, trying resync\n");
cookie->packet_index = 0;
return B_UNHANDLED_INTERRUPT;
}
if (cookie->packet_index == 0 && val >> 6 != 0x02) {
TRACE("SYNAPTICS: first package begins not with bit 1, 0\n");
return B_UNHANDLED_INTERRUPT;
}
if (cookie->packet_index == 3 && val >> 6 != 0x03) {
TRACE("SYNAPTICS: third package begins not with bit 1, 1\n");
cookie->packet_index = 0;
return B_UNHANDLED_INTERRUPT;
}
cookie->buffer[cookie->packet_index] = val;
cookie->packet_index++;
if (cookie->packet_index >= 6) {
cookie->packet_index = 0;
// check if package is a pass through package if true pass it
// too the pass through interrupt handle
if (sPassthroughDevice->active
&& sPassthroughDevice->handle_int != NULL
&& IS_SYN_PT_PACKAGE(cookie->buffer)) {
status_t status;
sPassthroughDevice->history[0].data = cookie->buffer[1];
sPassthroughDevice->handle_int(sPassthroughDevice);
sPassthroughDevice->history[0].data = cookie->buffer[4];
sPassthroughDevice->handle_int(sPassthroughDevice);
sPassthroughDevice->history[0].data = cookie->buffer[5];
status = sPassthroughDevice->handle_int(sPassthroughDevice);
if (cookie->dev->packet_size == 4) {
sPassthroughDevice->history[0].data = cookie->buffer[2];
status = sPassthroughDevice->handle_int(sPassthroughDevice);
}
return status;
}
if (packet_buffer_write(cookie->synaptics_ring_buffer,
cookie->buffer, cookie->dev->packet_size)
!= cookie->dev->packet_size) {
// buffer is full, drop new data
return B_HANDLED_INTERRUPT;
}
release_sem_etc(cookie->synaptics_sem, 1, B_DO_NOT_RESCHEDULE);
return B_INVOKE_SCHEDULER;
}
return B_HANDLED_INTERRUPT;
}
void
synaptics_disconnect(ps2_dev *dev)
{
synaptics_cookie *cookie = (synaptics_cookie*)dev->cookie;
// the mouse device might not be opened at this point
INFO("SYNAPTICS: synaptics_disconnect %s\n", dev->name);
if ((dev->flags & PS2_FLAG_OPEN) != 0)
release_sem(cookie->synaptics_sem);
}
device_hooks gSynapticsDeviceHooks = {
synaptics_open,
synaptics_close,
synaptics_freecookie,
synaptics_ioctl,
synaptics_read,
synaptics_write,
};
| 26.405517
| 77
| 0.711241
|
Yn0ga
|
c828fc96a96db8f61d3dd100a4fdb4d606cb7028
| 442
|
hpp
|
C++
|
sprout/uuid/name_generator.hpp
|
osyo-manga/Sprout
|
8885b115f739ef255530f772067475d3bc0dcef7
|
[
"BSL-1.0"
] | 1
|
2020-02-04T05:16:01.000Z
|
2020-02-04T05:16:01.000Z
|
sprout/uuid/name_generator.hpp
|
osyo-manga/Sprout
|
8885b115f739ef255530f772067475d3bc0dcef7
|
[
"BSL-1.0"
] | null | null | null |
sprout/uuid/name_generator.hpp
|
osyo-manga/Sprout
|
8885b115f739ef255530f772067475d3bc0dcef7
|
[
"BSL-1.0"
] | null | null | null |
#ifndef SPROUT_UUID_NAME_GENERATOR_HPP
#define SPROUT_UUID_NAME_GENERATOR_HPP
#include <sprout/config.hpp>
#include <sprout/uuid/md5_name_generator.hpp>
#include <sprout/uuid/sha1_name_generator.hpp>
namespace sprout {
namespace uuids {
//
// name_generator
//
typedef sprout::uuids::sha1_name_generator name_generator;
} // namespace uuids
} // namespace sprout
#endif // #ifndef SPROUT_UUID_NAME_GENERATOR_HPP
| 24.555556
| 61
| 0.757919
|
osyo-manga
|
c8299cd8793afc40f2d1115b7686df57c2209339
| 6,978
|
hpp
|
C++
|
src/Evolution/Systems/NewtonianEuler/FiniteDifference/AoWeno.hpp
|
geoffrey4444/spectre
|
9350d61830b360e2d5b273fdd176dcc841dbefb0
|
[
"MIT"
] | 1
|
2021-04-02T16:49:35.000Z
|
2021-04-02T16:49:35.000Z
|
src/Evolution/Systems/NewtonianEuler/FiniteDifference/AoWeno.hpp
|
GitHimanshuc/spectre
|
4de4033ba36547113293fe4dbdd77591485a4aee
|
[
"MIT"
] | 19
|
2019-02-27T22:13:47.000Z
|
2020-09-03T16:21:08.000Z
|
src/Evolution/Systems/NewtonianEuler/FiniteDifference/AoWeno.hpp
|
geoffrey4444/spectre
|
9350d61830b360e2d5b273fdd176dcc841dbefb0
|
[
"MIT"
] | null | null | null |
// Distributed under the MIT License.
// See LICENSE.txt for details.
#pragma once
#include <array>
#include <boost/functional/hash.hpp>
#include <cstddef>
#include <limits>
#include <memory>
#include "DataStructures/DataBox/PrefixHelpers.hpp"
#include "DataStructures/DataBox/Prefixes.hpp"
#include "DataStructures/FixedHashMap.hpp"
#include "DataStructures/Tensor/TypeAliases.hpp"
#include "Domain/Structure/MaxNumberOfNeighbors.hpp"
#include "Domain/Tags.hpp"
#include "Evolution/DgSubcell/Tags/Mesh.hpp"
#include "Evolution/DgSubcell/Tags/NeighborData.hpp"
#include "Evolution/Systems/NewtonianEuler/FiniteDifference/Reconstructor.hpp"
#include "Evolution/Systems/NewtonianEuler/Tags.hpp"
#include "PointwiseFunctions/Hydro/EquationsOfState/EquationOfState.hpp"
#include "PointwiseFunctions/Hydro/Tags.hpp"
namespace NewtonianEuler::fd {
/*!
* \brief Adaptive-order WENO reconstruction hybridizing orders 5 and 3. See
* ::fd::reconstruction::aoweno_53() for details.
*/
template <size_t Dim>
class AoWeno53Prim : public Reconstructor<Dim> {
private:
// Conservative vars tags
using MassDensityCons = Tags::MassDensityCons;
using EnergyDensity = Tags::EnergyDensity;
using MomentumDensity = Tags::MomentumDensity<Dim>;
// Primitive vars tags
using MassDensity = Tags::MassDensity<DataVector>;
using Velocity = Tags::Velocity<DataVector, Dim>;
using SpecificInternalEnergy = Tags::SpecificInternalEnergy<DataVector>;
using Pressure = Tags::Pressure<DataVector>;
using prims_tags =
tmpl::list<MassDensity, Velocity, SpecificInternalEnergy, Pressure>;
using cons_tags = tmpl::list<MassDensityCons, MomentumDensity, EnergyDensity>;
using flux_tags = db::wrap_tags_in<::Tags::Flux, cons_tags, tmpl::size_t<Dim>,
Frame::Inertial>;
using prim_tags_for_reconstruction =
tmpl::list<MassDensity, Velocity, Pressure>;
public:
struct GammaHi {
using type = double;
static constexpr Options::String help = {
"The linear weight for the 5th-order stencil."};
};
struct GammaLo {
using type = double;
static constexpr Options::String help = {
"The linear weight for the central 3rd-order stencil."};
};
struct Epsilon {
using type = double;
static constexpr Options::String help = {
"The parameter added to the oscillation indicators to avoid division "
"by zero"};
};
struct NonlinearWeightExponent {
using type = size_t;
static constexpr Options::String help = {
"The exponent q to which the oscillation indicators are raised"};
};
using options =
tmpl::list<GammaHi, GammaLo, Epsilon, NonlinearWeightExponent>;
static constexpr Options::String help{
"Monotised central reconstruction scheme using primitive variables."};
AoWeno53Prim() = default;
AoWeno53Prim(AoWeno53Prim&&) = default;
AoWeno53Prim& operator=(AoWeno53Prim&&) = default;
AoWeno53Prim(const AoWeno53Prim&) = default;
AoWeno53Prim& operator=(const AoWeno53Prim&) = default;
~AoWeno53Prim() override = default;
AoWeno53Prim(double gamma_hi, double gamma_lo, double epsilon,
size_t nonlinear_weight_exponent);
explicit AoWeno53Prim(CkMigrateMessage* msg);
WRAPPED_PUPable_decl_base_template(Reconstructor<Dim>, AoWeno53Prim);
auto get_clone() const -> std::unique_ptr<Reconstructor<Dim>> override;
void pup(PUP::er& p) override;
size_t ghost_zone_size() const override { return 3; }
using reconstruction_argument_tags =
tmpl::list<::Tags::Variables<prims_tags>,
hydro::Tags::EquationOfStateBase, domain::Tags::Element<Dim>,
evolution::dg::subcell::Tags::
NeighborDataForReconstructionAndRdmpTci<Dim>,
evolution::dg::subcell::Tags::Mesh<Dim>>;
template <size_t ThermodynamicDim, typename TagsList>
void reconstruct(
gsl::not_null<std::array<Variables<TagsList>, Dim>*> vars_on_lower_face,
gsl::not_null<std::array<Variables<TagsList>, Dim>*> vars_on_upper_face,
const Variables<prims_tags>& volume_prims,
const EquationsOfState::EquationOfState<false, ThermodynamicDim>& eos,
const Element<Dim>& element,
const FixedHashMap<
maximum_number_of_neighbors(Dim) + 1,
std::pair<Direction<Dim>, ElementId<Dim>>,
evolution::dg::subcell::NeighborData,
boost::hash<std::pair<Direction<Dim>, ElementId<Dim>>>>&
neighbor_data,
const Mesh<Dim>& subcell_mesh) const;
/// Called by an element doing DG when the neighbor is doing subcell.
template <size_t ThermodynamicDim, typename TagsList>
void reconstruct_fd_neighbor(
gsl::not_null<Variables<TagsList>*> vars_on_face,
const Variables<prims_tags>& subcell_volume_prims,
const EquationsOfState::EquationOfState<false, ThermodynamicDim>& eos,
const Element<Dim>& element,
const FixedHashMap<
maximum_number_of_neighbors(Dim) + 1,
std::pair<Direction<Dim>, ElementId<Dim>>,
evolution::dg::subcell::NeighborData,
boost::hash<std::pair<Direction<Dim>, ElementId<Dim>>>>&
neighbor_data,
const Mesh<Dim>& subcell_mesh,
const Direction<Dim> direction_to_reconstruct) const;
private:
template <size_t LocalDim>
// NOLINTNEXTLINE(readability-redundant-declaration)
friend bool operator==(const AoWeno53Prim<LocalDim>& lhs,
const AoWeno53Prim<LocalDim>& rhs);
double gamma_hi_ = std::numeric_limits<double>::signaling_NaN();
double gamma_lo_ = std::numeric_limits<double>::signaling_NaN();
double epsilon_ = std::numeric_limits<double>::signaling_NaN();
size_t nonlinear_weight_exponent_ = 0;
void (*reconstruct_)(gsl::not_null<std::array<gsl::span<double>, Dim>*>,
gsl::not_null<std::array<gsl::span<double>, Dim>*>,
const gsl::span<const double>&,
const DirectionMap<Dim, gsl::span<const double>>&,
const Index<Dim>&, size_t, double, double, double);
void (*reconstruct_lower_neighbor_)(gsl::not_null<DataVector*>,
const DataVector&, const DataVector&,
const Index<Dim>&, const Index<Dim>&,
const Direction<Dim>&, const double&,
const double&, const double&);
void (*reconstruct_upper_neighbor_)(gsl::not_null<DataVector*>,
const DataVector&, const DataVector&,
const Index<Dim>&, const Index<Dim>&,
const Direction<Dim>&, const double&,
const double&, const double&);
};
template <size_t Dim>
bool operator!=(const AoWeno53Prim<Dim>& lhs, const AoWeno53Prim<Dim>& rhs) {
return not(lhs == rhs);
}
} // namespace NewtonianEuler::fd
| 40.807018
| 80
| 0.676842
|
geoffrey4444
|
c82b1b9f3a60642dcd21eecf8c9c04ed8a4628dd
| 5,516
|
cpp
|
C++
|
models/cache/simple-cache/hash_table.cpp
|
Basseuph/manifold
|
99779998911ed7e8b8ff6adacc7f93080409a5fe
|
[
"BSD-3-Clause"
] | 8
|
2016-01-22T18:28:48.000Z
|
2021-05-07T02:27:21.000Z
|
models/cache/simple-cache/hash_table.cpp
|
Basseuph/manifold
|
99779998911ed7e8b8ff6adacc7f93080409a5fe
|
[
"BSD-3-Clause"
] | 3
|
2016-04-15T02:58:58.000Z
|
2017-01-19T17:07:34.000Z
|
models/cache/simple-cache/hash_table.cpp
|
Basseuph/manifold
|
99779998911ed7e8b8ff6adacc7f93080409a5fe
|
[
"BSD-3-Clause"
] | 10
|
2015-12-11T04:16:55.000Z
|
2019-05-25T20:58:13.000Z
|
#include <assert.h>
//#include <iostream>
#include <math.h>
#include <string.h>
#include "hash_table.h"
#include "cache_req.h"
using namespace std;
namespace manifold {
namespace simple_cache {
// mshr_entry: Constructor
mshr_entry::mshr_entry (Cache_req *request)
{
creq = request;
}
//! hash_entry: Constructor
//!
//! This is a single cache line
//! associated with one set within the cache. Contains pointers back
//! to the parent table and parent set, the address tag associated with
//! this line, and valid/dirty bits to indicate status.
hash_entry::hash_entry (hash_table *table, hash_set *set, paddr_t tag, bool valid)
{
this->my_table = table;
this->my_set = set;
this->tag = tag;
this->valid = valid;
this->dirty = false;
}
//! hash_set: Constructor
//!
//! This is a set of cache lines, the number
//! of which is determined by the cache's associativity. Contains a pointer
//! back to the parent table, the associativity factor, and a list of pointers
//! to the hash_entries it owns.
hash_set::hash_set (hash_table *table)
{
my_table = table;
assoc = table->get_assoc();
// initialize the hash_entry list - all entries initialized to tag
// 0x0 and marked invalid
set_entries.clear();
for (int i = 0; i < assoc; i++)
set_entries.push_front(new hash_entry (table, this, 0x0, false));
}
hash_set::~hash_set (void)
{
while (!set_entries.empty ())
{
delete set_entries.back();
set_entries.pop_back();
}
}
//! Calls get_entry to determine whether the request is a hit or miss. If get_entry
//! returns NULL, we have a miss. Otherwise, we have a hit and we update the LRU
//! status of the member entries.
bool hash_set::process_request (paddr_t addr)
{
hash_entry *entry = get_entry (my_table->get_tag (addr));
if (entry)
{
update_lru (entry);
return true;
}
return false;
}
//! hash_set: get_entry
//!
//! Loops through each entry in the set to see if there's a tag match. Return NULL
//! if there's no match. Otherwise, return a pointer to the matching entry.
hash_entry* hash_set::get_entry (paddr_t tag)
{
list<hash_entry *>::iterator it;
for (it = set_entries.begin(); it != set_entries.end(); it++)
{
if ((tag == (*it)->tag) && (*it)->valid)
{
return *it;
}
}
return 0;
}
//! hash_set: replace_entry
//!
//! Replaces a line in the set with a tag; Place the entry
//! at the front of the list so that it's ranked as MRU.
void hash_set::replace_entry (paddr_t new_tag)
{
hash_entry* victim = set_entries.back();
set_entries.pop_back();
victim->tag = new_tag;
victim->valid = true;
victim->dirty = false;
set_entries.push_front(victim);
}
//! hash_set: update_lru
//!
//! On a hit, move this entry to the front of the list to indicate
//! MRU status.
void hash_set::update_lru (hash_entry *entry)
{
set_entries.remove (entry);
set_entries.push_front (entry);
}
hash_table::hash_table (int sz, int as, int block, int hit, int lookup)
{
assert( sz % (as*block) == 0); // size/(assoc*block) = num of sets; must be integer
size = sz;
assoc = as;
block_size = block;
sets = size / (assoc * block_size);
hit_time = hit;
lookup_time = lookup;
num_index_bits = (int) log2 (sets);
assert(sets == 0x1 << num_index_bits); //sets must be power of 2
num_offset_bits = (int) log2 (block_size);
assert(block_size == 0x1 << num_offset_bits); //block must be power of 2
tag_mask = ~0x0;
tag_mask = tag_mask << (num_index_bits + num_offset_bits);
index_mask = ~0x0;
index_mask = index_mask << num_offset_bits;
index_mask = index_mask & ~tag_mask;
offset_mask = ~0x0;
offset_mask = offset_mask << num_offset_bits;
for (int i = 0; i < sets; i++)
my_sets[i] = new hash_set (this);
}
hash_table::~hash_table (void)
{
for (int i = 0; i < sets; i++)
delete my_sets[i];
my_sets.clear();
}
//! hash_table: get_tag
//!
//! Mask out the tag bits from the address and return the tag.
paddr_t hash_table::get_tag (paddr_t addr)
{
return (addr & tag_mask);
}
//! hash_table: get_index
//!
//! Mask out the index bits from the address and return the index.
paddr_t hash_table::get_index (paddr_t addr)
{
return ((addr & index_mask) >> num_offset_bits);
}
//! hash_table: get_line_addr
//!
//! Mask out the offset bits from the address and return the tag plus index.
paddr_t hash_table::get_line_addr (paddr_t addr)
{
return (addr & offset_mask);
}
//! hash_table: get_set
//!
//! Return a pointer to the set addressed.
hash_set* hash_table::get_set (paddr_t addr)
{
return my_sets[get_index (addr)];
}
//! hash_table: get_entry
//!
//! Return a pointer to the cache line addressed.
hash_entry* hash_table::get_entry (paddr_t addr)
{
return my_sets[get_index (addr)]->get_entry (get_tag (addr));
}
//! Called when the cache receives a request from the processor or lower-level
//! cache. Returns true if hit, false if miss. In case of hit, the LRU is updated.
bool hash_table::process_request (paddr_t addr)
{
hash_set* set = get_set (addr);
return set->process_request (addr);
}
//! hash_table: process_response
//!
//! Called when a LOAD response comes back from memory. Evict a block if
//! necessary.
void hash_table::process_response (paddr_t addr)
{
hash_set* set = get_set (addr);
set->replace_entry (get_tag(addr));
}
} //namespace simple_cache
} //namespace manifold
| 21.976096
| 87
| 0.669688
|
Basseuph
|
c82fe4367fd685d76d4b70ba4c2280c715dd9f70
| 4,635
|
hpp
|
C++
|
boost/archive/xml_iarchive.hpp
|
ballisticwhisper/boost
|
f72119ab640b564c4b983bd457457046b52af9ee
|
[
"BSL-1.0"
] | 2
|
2015-01-02T14:24:56.000Z
|
2015-01-02T14:25:17.000Z
|
boost/archive/xml_iarchive.hpp
|
ballisticwhisper/boost
|
f72119ab640b564c4b983bd457457046b52af9ee
|
[
"BSL-1.0"
] | 2
|
2019-01-13T23:45:51.000Z
|
2019-02-03T08:13:26.000Z
|
boost/archive/xml_iarchive.hpp
|
ballisticwhisper/boost
|
f72119ab640b564c4b983bd457457046b52af9ee
|
[
"BSL-1.0"
] | 1
|
2016-05-29T13:41:15.000Z
|
2016-05-29T13:41:15.000Z
|
#ifndef BOOST_ARCHIVE_XML_IARCHIVE_HPP
#define BOOST_ARCHIVE_XML_IARCHIVE_HPP
// MS compatible compilers support #pragma once
#if defined(_MSC_VER)
# pragma once
#endif
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// xml_iarchive.hpp
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// Use, modification and distribution is subject to 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 for updates, documentation, and revision history.
#include <istream>
//#include <boost/scoped_ptr.hpp>
#include <boost/archive/detail/auto_link_archive.hpp>
#include <boost/archive/basic_text_iprimitive.hpp>
#include <boost/archive/basic_xml_iarchive.hpp>
#include <boost/archive/detail/register_archive.hpp>
#include <boost/serialization/item_version_type.hpp>
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
#ifdef BOOST_MSVC
# pragma warning(push)
# pragma warning(disable : 4511 4512)
#endif
namespace boost {
namespace archive {
namespace detail {
template<class Archive> class interface_iarchive;
} // namespace detail
template<class CharType>
class basic_xml_grammar;
typedef basic_xml_grammar<char> xml_grammar;
template<class Archive>
class xml_iarchive_impl :
public basic_text_iprimitive<std::istream>,
public basic_xml_iarchive<Archive>
{
#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
public:
#else
friend class detail::interface_iarchive<Archive>;
friend class basic_xml_iarchive<Archive>;
friend class load_access;
protected:
#endif
// instances of micro xml parser to parse start preambles
// scoped_ptr doesn't play nice with borland - so use a naked pointer
// scoped_ptr<xml_grammar> gimpl;
xml_grammar *gimpl;
std::istream & get_is(){
return is;
}
template<class T>
void load(T & t){
basic_text_iprimitive<std::istream>::load(t);
}
void
load(version_type & t){
unsigned int v;
load(v);
t = version_type(v);
}
void
load(boost::serialization::item_version_type & t){
unsigned int v;
load(v);
t = boost::serialization::item_version_type(v);
}
BOOST_ARCHIVE_DECL(void)
load(char * t);
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
BOOST_ARCHIVE_DECL(void)
load(wchar_t * t);
#endif
BOOST_ARCHIVE_DECL(void)
load(std::string &s);
#ifndef BOOST_NO_STD_WSTRING
BOOST_ARCHIVE_DECL(void)
load(std::wstring &ws);
#endif
template<class T>
void load_override(T & t, BOOST_PFTO int){
basic_xml_iarchive<Archive>::load_override(t, 0);
}
BOOST_ARCHIVE_DECL(void)
load_override(class_name_type & t, int);
BOOST_ARCHIVE_DECL(void)
init();
BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
xml_iarchive_impl(std::istream & is, unsigned int flags);
BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
~xml_iarchive_impl();
};
// do not derive from the classes below. If you want to extend this functionality
// via inhertance, derived from text_iarchive_impl instead. This will
// preserve correct static polymorphism.
// same as xml_iarchive below - without the shared_ptr_helper
class naked_xml_iarchive :
public xml_iarchive_impl<naked_xml_iarchive>
{
public:
naked_xml_iarchive(std::istream & is, unsigned int flags = 0) :
xml_iarchive_impl<naked_xml_iarchive>(is, flags)
{}
~naked_xml_iarchive(){}
};
} // namespace archive
} // namespace boost
#ifdef BOOST_MSVC
#pragma warning(pop)
#endif
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
// note special treatment of shared_ptr. This type needs a special
// structure associated with every archive. We created a "mix-in"
// class to provide this functionality. Since shared_ptr holds a
// special esteem in the boost library - we included it here by default.
#include <boost/archive/shared_ptr_helper.hpp>
#ifdef BOOST_MSVC
# pragma warning(push)
# pragma warning(disable : 4511 4512)
#endif
namespace boost {
namespace archive {
class xml_iarchive :
public xml_iarchive_impl<xml_iarchive>,
public detail::shared_ptr_helper
{
public:
xml_iarchive(std::istream & is, unsigned int flags = 0) :
xml_iarchive_impl<xml_iarchive>(is, flags)
{}
~xml_iarchive(){};
};
} // namespace archive
} // namespace boost
// required by export
BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_iarchive)
#ifdef BOOST_MSVC
#pragma warning(pop)
#endif
#endif // BOOST_ARCHIVE_XML_IARCHIVE_HPP
| 27.426036
| 82
| 0.716289
|
ballisticwhisper
|
c834120498fd3e69faa2fd5aab03b7f20e5db3c7
| 7,333
|
cc
|
C++
|
etc/ctemplate-master-configured/src/template_namelist.cc
|
kundanjadhav/OpenProtocolMail
|
682780de4602524b969d1ed2536fa035c750706a
|
[
"BSD-3-Clause"
] | 337
|
2015-03-12T19:10:04.000Z
|
2022-03-29T12:31:00.000Z
|
etc/ctemplate-master-configured/src/template_namelist.cc
|
kundanjadhav/OpenProtocolMail
|
682780de4602524b969d1ed2536fa035c750706a
|
[
"BSD-3-Clause"
] | 38
|
2015-04-03T09:00:39.000Z
|
2020-11-02T02:58:22.000Z
|
etc/ctemplate-master-configured/src/template_namelist.cc
|
kundanjadhav/OpenProtocolMail
|
682780de4602524b969d1ed2536fa035c750706a
|
[
"BSD-3-Clause"
] | 105
|
2015-03-14T12:18:14.000Z
|
2022-03-06T07:36:59.000Z
|
// Copyright (c) 2006, Google 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:
//
// * 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 Google Inc. 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.
// ---
#include <config.h>
#include <stdlib.h>
#include <sys/stat.h> // for stat()
#include <time.h> // for time_t
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#include <algorithm> // for binary_search
#include HASH_SET_H // that's NameListType
#include <string>
#include <vector> // that's MissingListType, SyntaxListType
#include <ctemplate/template_namelist.h>
#include <ctemplate/template_pathops.h>
#include <ctemplate/template.h> // for Strip, GetTemplate(), etc.
#include <assert.h>
#include <iostream> // for cerr
#include "base/fileutil.h"
using std::max;
using std::pair;
using std::string;
using std::vector;
#define LOG(level) std::cerr << #level << ": "
namespace ctemplate {
TemplateNamelist::NameListType *TemplateNamelist::namelist_ = NULL;
TemplateNamelist::MissingListType *TemplateNamelist::missing_list_ = NULL;
TemplateNamelist::SyntaxListType *TemplateNamelist::bad_syntax_list_ = NULL;
// Make sure there is a namelist_ and then insert the name onto it
const char* TemplateNamelist::RegisterTemplate(const char* name) {
if (!namelist_) {
namelist_ = new NameListType;
}
pair<NameListType::iterator, bool> insert_result = namelist_->insert(name);
// return a pointer to the entry corresponding to name;
return insert_result.first->c_str();
}
// GetList
// Make sure there is a namelist_ and return a reference to it.
const TemplateNamelist::NameListType& TemplateNamelist::GetList() {
if ( !namelist_ ) {
namelist_ = new NameListType;
}
return *namelist_;
}
// GetMissingList
// On the first invocation, it creates a new missing list and sets
// refresh to true.
// If refresh is true, whether from being passed to the function
// or being set when the list is created the first time, it iterates
// through the complete list of registered template files
// and adds to the list any that are missing
// On subsequent calls, if refresh is false it merely returns the
// list created in the prior call that refreshed the list.
// Returns a sorted list of missing templates.
const TemplateNamelist::MissingListType& TemplateNamelist::GetMissingList(
bool refresh) {
if (!missing_list_) {
missing_list_ = new MissingListType;
refresh = true; // always refresh the first time
}
if (refresh) {
const NameListType& the_list = TemplateNamelist::GetList();
missing_list_->clear();
for (NameListType::const_iterator iter = the_list.begin();
iter != the_list.end();
++iter) {
const string path = Template::FindTemplateFilename(*iter);
if (path.empty() || !File::Readable(path.c_str())) {
missing_list_->push_back(*iter);
LOG(ERROR) << "Template file missing: " << *iter
<< " at path: " << (path.empty() ? "(empty path)" : path)
<< "\n";
}
}
}
sort(missing_list_->begin(), missing_list_->end());
return *missing_list_;
}
// GetBadSyntaxList
// On the first invocation, it creates a new "bad syntax" list and
// sets refresh to true.
// If refresh is true, whether from being passed to the function
// or being set when the list is created the first time, it
// iterates through the complete list of registered template files
// and adds to the list any that cannot be loaded. In the process, it
// calls GetMissingList, refreshing it. It does not include any
// files in the bad syntax list which are in the missing list.
// On subsequent calls, if refresh is false it merely returns the
// list created in the prior call that refreshed the list.
const TemplateNamelist::SyntaxListType& TemplateNamelist::GetBadSyntaxList(
bool refresh, Strip strip) {
if (!bad_syntax_list_) {
bad_syntax_list_ = new SyntaxListType;
refresh = true; // always refresh the first time
}
if (refresh) {
const NameListType& the_list = TemplateNamelist::GetList();
bad_syntax_list_->clear();
const MissingListType& missing_list = GetMissingList(true);
for (NameListType::const_iterator iter = the_list.begin();
iter != the_list.end();
++iter) {
Template *tpl = Template::GetTemplate((*iter), strip);
if (!tpl) {
if (!binary_search(missing_list.begin(), missing_list.end(), *iter)) {
// If it's not in the missing list, then we're here because
// it caused an error during parsing
bad_syntax_list_->push_back(*iter);
LOG(ERROR) << "Error loading template: " << (*iter) << "\n";
}
}
}
}
return *bad_syntax_list_;
}
// Look at all the existing template files, and get their lastmod time via stat()
time_t TemplateNamelist::GetLastmodTime() {
time_t retval = -1;
const NameListType& the_list = TemplateNamelist::GetList();
for (NameListType::const_iterator iter = the_list.begin();
iter != the_list.end();
++iter) {
// Only prepend root_dir if *iter isn't an absolute path:
const string path = Template::FindTemplateFilename(*iter);
struct stat statbuf;
if (path.empty() || stat(path.c_str(), &statbuf) != 0)
continue; // ignore files we can't find
retval = max(retval, statbuf.st_mtime);
}
return retval;
}
// AllDoExist
bool TemplateNamelist::AllDoExist() {
// AllDoExist always refreshes the list, hence the "true"
const MissingListType& missing_list = TemplateNamelist::GetMissingList(true);
return missing_list.empty();
}
// IsAllSyntaxOkay
bool TemplateNamelist::IsAllSyntaxOkay(Strip strip) {
// IsAllSyntaxOkay always refreshes the list, hence the "true"
const SyntaxListType& bad_syntax_list =
TemplateNamelist::GetBadSyntaxList(true, strip);
return bad_syntax_list.empty();
}
}
| 37.605128
| 81
| 0.700805
|
kundanjadhav
|
c836eab1f99e724f3855ac2fda7af49f7e9924ae
| 129
|
cpp
|
C++
|
dependencies/physx-4.1/source/physxextensions/src/ExtRigidActorExt.cpp
|
realtehcman/-UnderwaterSceneProject
|
72cbd375ef5e175bed8f4e8a4d117f5340f239a4
|
[
"MIT"
] | null | null | null |
dependencies/physx-4.1/source/physxextensions/src/ExtRigidActorExt.cpp
|
realtehcman/-UnderwaterSceneProject
|
72cbd375ef5e175bed8f4e8a4d117f5340f239a4
|
[
"MIT"
] | null | null | null |
dependencies/physx-4.1/source/physxextensions/src/ExtRigidActorExt.cpp
|
realtehcman/-UnderwaterSceneProject
|
72cbd375ef5e175bed8f4e8a4d117f5340f239a4
|
[
"MIT"
] | null | null | null |
version https://git-lfs.github.com/spec/v1
oid sha256:1b2bcfd87c3bda2a807e67b8e14f0401226018f6de551423e3b55f37df208c1b
size 2789
| 32.25
| 75
| 0.883721
|
realtehcman
|
c83c59875d965fbfda3d3cc5540620cfcebedd15
| 17,386
|
cpp
|
C++
|
Server/GameServer/CharacterMovementHandler.cpp
|
APistole/KnightOnline
|
80268e2fa971389a3e94c430966a7943c2631dbf
|
[
"MIT"
] | 191
|
2016-03-05T16:44:15.000Z
|
2022-03-09T00:52:31.000Z
|
Server/GameServer/CharacterMovementHandler.cpp
|
APistole/KnightOnline
|
80268e2fa971389a3e94c430966a7943c2631dbf
|
[
"MIT"
] | 128
|
2016-08-31T04:09:06.000Z
|
2022-01-14T13:42:56.000Z
|
Server/GameServer/CharacterMovementHandler.cpp
|
APistole/KnightOnline
|
80268e2fa971389a3e94c430966a7943c2631dbf
|
[
"MIT"
] | 165
|
2016-03-05T16:43:59.000Z
|
2022-01-22T00:52:25.000Z
|
#include "stdafx.h"
#include "Map.h"
void CUser::MoveProcess(Packet & pkt)
{
ASSERT(GetMap() != nullptr);
if (m_bWarp || isDead())
return;
uint16_t will_x, will_z, will_y;
int16_t speed=0;
float real_x, real_z, real_y;
uint8_t echo;
pkt >> will_x >> will_z >> will_y >> speed >> echo;
real_x = will_x/10.0f; real_z = will_z/10.0f; real_y = will_y/10.0f;
m_sSpeed = speed;
SpeedHackUser();
if (!GetMap()->IsValidPosition(real_x, real_z, real_y))
return;
if (m_oldx != GetX()
|| m_oldz != GetZ())
{
m_oldx = GetX();
m_oldy = GetY();
m_oldz = GetZ();
}
// TODO: Ensure this is checked properly to prevent speedhacking
SetPosition(real_x, real_y, real_z);
if (RegisterRegion())
{
g_pMain->RegionNpcInfoForMe(this);
g_pMain->RegionUserInOutForMe(this);
g_pMain->MerchantUserInOutForMe(this);
}
if (m_bInvisibilityType == INVIS_DISPEL_ON_MOVE)
CMagicProcess::RemoveStealth(this, INVIS_DISPEL_ON_MOVE);
Packet result(WIZ_MOVE);
result << GetSocketID() << will_x << will_z << will_y << speed << echo;
SendToRegion(&result);
GetMap()->CheckEvent(real_x, real_z, this);
result.Initialize(AG_USER_MOVE);
result << GetSocketID() << m_curx << m_curz << m_cury << speed;
Send_AIServer(&result);
}
void CUser::AddToRegion(int16_t new_region_x, int16_t new_region_z)
{
GetRegion()->Remove(this);
SetRegion(new_region_x, new_region_z);
GetRegion()->Add(this);
}
void CUser::GetInOut(Packet & result, uint8_t bType)
{
result.Initialize(WIZ_USER_INOUT);
result << uint8_t(bType) << GetID(); // uint8_t for 1298 not uint16_t
if (bType != INOUT_OUT)
GetUserInfo(result);
}
void CUser::UserInOut(uint8_t bType)
{
if (GetRegion() == nullptr)
return;
Packet result;
if (bType != INOUT_OUT)
ResetGMVisibility();
GetInOut(result, bType);
if (bType == INOUT_OUT)
GetRegion()->Remove(this);
else
GetRegion()->Add(this);
SendToRegion(&result, this, GetEventRoom());
if (bType == INOUT_OUT || !isBlinking())
{
result.Initialize(AG_USER_INOUT);
result.SByte();
result << bType << GetSocketID() << GetName() << m_curx << m_curz;
Send_AIServer(&result);
}
}
void CUser::GetUserInfo(Packet & pkt)
{
pkt.SByte();
pkt
<< GetName()
<< GetNation()
<< GetClanID()
<< GetFame();
CKnights * pKnights = g_pMain->GetClanPtr(GetClanID());
if (pKnights == nullptr)
{
//pkt /*<< uint8_t(0)*/ << uint16_t(0) << uint8_t(0) << uint8_t(0);
pkt << uint32_t(0) << uint16_t(0) << uint8_t(0) << uint16_t(-1);
}
else
{
pkt << pKnights->GetAllianceID()
<< pKnights->m_strName
<< pKnights->m_byGrade << pKnights->m_byRanking
<< uint16_t(pKnights->m_sMarkVersion) // symbol/mark version
<< pKnights->GetCapeID(pKnights); // cape ID
}
// There are two event-driven invisibility states; dispel on attack, and dispel on move.
// These are handled primarily server-side; from memory the client only cares about value 1 (which we class as 'dispel on move').
// As this is the only place where this flag is actually sent to the client, we'll just convert 'dispel on attack'
// back to 'dispel on move' as the client expects.
uint8_t bInvisibilityType = m_bInvisibilityType;
if (bInvisibilityType != INVIS_NONE)
bInvisibilityType = INVIS_DISPEL_ON_MOVE;
pkt << GetLevel() << m_bRace << m_sClass
<< GetSPosX() << GetSPosZ() << GetSPosY()
<< m_bFace << m_nHair
<< m_bResHpType << uint32_t(m_bAbnormalType)//uint8_t(m_bAbnormalType)
<< m_bNeedParty
<< m_bAuthority
<< m_bPartyLeader // is party leader (bool)
<< bInvisibilityType // visibility state
//<< uint8_t(m_teamColour) // team colour (i.e. in soccer, 0=none, 1=blue, 2=red)
//<< m_bIsHidingHelmet // either this is correct and items are super buggy, or it causes baldness. You choose.
<< m_sDirection // direction
<< m_bIsChicken // chicken/beginner flag
<< m_bRank // king flag
<< m_bKnightsRank << m_bPersonalRank; // NP ranks (total, monthly)
uint8_t equippedItems[] =
{
BREAST, LEG, HEAD, GLOVE, FOOT, SHOULDER, RIGHTHAND, LEFTHAND, CTOP, CHELMET
};
foreach_array(i, equippedItems)
{
_ITEM_DATA * pItem = GetItem(equippedItems[i]);
if (pItem == nullptr)
continue;
pkt << pItem->nNum << pItem->sDuration << pItem->bFlag;
}
// NOTE: not sure about the rest of this
pkt << GetZoneID(); //<< uint8_t(-1) << uint8_t(-1) << uint16_t(0) << uint16_t(0) << uint16_t(0);
}
void CUser::Rotate(Packet & pkt)
{
if (isDead())
return;
Packet result(WIZ_ROTATE);
pkt >> m_sDirection;
result << GetSocketID() << m_sDirection;
SendToRegion(&result, this, GetEventRoom());
}
bool CUser::CanChangeZone(C3DMap * pTargetMap, WarpListResponse & errorReason)
{
// While unofficial, game masters should be allowed to teleport anywhere.
if (isGM())
return true;
// Generic error reason; this should only be checked when the method returns false.
errorReason = WarpListGenericError;
if (GetLevel() < pTargetMap->GetMinLevelReq())
{
errorReason = WarpListMinLevel;
return false;
}
if (GetLevel() > pTargetMap->GetMaxLevelReq()
/*|| !CanLevelQualify(pTargetMap->GetMaxLevelReq())*/)
{
errorReason = WarpListDoNotQualify;
return false;
}
switch (pTargetMap->GetID())
{
case ZONE_KARUS:
// Users may enter Luferson (1)/El Morad (2) if they are that nation,
if (GetNation() == pTargetMap->GetID())
return true;
// Users may also enter if there's a war invasion happening in that zone.
if (GetNation() == ELMORAD)
return g_pMain->m_byKarusOpenFlag;
else
return g_pMain->m_byElmoradOpenFlag;
case ZONE_ELMORAD:
// Users may enter Luferson (1)/El Morad (2) if they are that nation,
if (GetNation() == pTargetMap->GetID())
return true;
// Users may also enter if there's a war invasion happening in that zone.
if (GetNation() == KARUS)
return g_pMain->m_byElmoradOpenFlag;
else
return g_pMain->m_byKarusOpenFlag;
case ZONE_KARUS_ESLANT:
return GetNation() == pTargetMap->GetID() - 10;
case ZONE_ELMORAD_ESLANT:
return GetNation() == pTargetMap->GetID() - 10;
case ZONE_DELOS: // TODO: implement CSW logic.
if (g_pMain->m_byBattleOpen == CLAN_BATTLE && !g_pMain->m_byBattleSiegeWarTeleport)
{
errorReason = WarpListNotDuringCSW;
return false;
}
else
return true;
case ZONE_BIFROST:
return true;
case ZONE_ARDREAM:
if (g_pMain->isWarOpen())
{
errorReason = WarpListNotDuringWar;
return false;
}
if (GetLoyalty() <= 0)
{
errorReason = WarpListNeedNP;
return false;
}
return true;
case ZONE_RONARK_LAND_BASE:
if (g_pMain->isWarOpen() && g_pMain->m_byBattleZoneType != ZONE_ARDREAM)
{
errorReason = WarpListNotDuringWar;
return false;
}
if (GetLoyalty() <= 0)
{
errorReason = WarpListNeedNP;
return false;
}
return false;
case ZONE_RONARK_LAND:
if (g_pMain->isWarOpen() && g_pMain->m_byBattleZoneType != ZONE_ARDREAM)
{
errorReason = WarpListNotDuringWar;
return false;
}
if (GetLoyalty() <= 0)
{
errorReason = WarpListNeedNP;
return false;
}
return true;
default:
// War zones may only be entered if that war zone is active.
if (pTargetMap->isWarZone())
{
if(pTargetMap->GetID() == ZONE_SNOW_BATTLE)
{
if ((pTargetMap->GetID() - ZONE_SNOW_BATTLE) != g_pMain->m_byBattleZone)
return false;
}
else if ((pTargetMap->GetID() - ZONE_BATTLE_BASE) != g_pMain->m_byBattleZone)
return false;
else if ((GetNation() == ELMORAD && g_pMain->m_byElmoradOpenFlag)
|| (GetNation() == KARUS && g_pMain->m_byKarusOpenFlag))
return false;
}
}
return true;
}
bool CUser::CanLevelQualify(uint8_t sLevel)
{
int16_t nStatTotal = 300 + (sLevel - 1) * 3;
uint8_t nSkillTotal = (sLevel - 9) * 2;
if (sLevel > 60)
nStatTotal += 2 * (sLevel - 60);
if ((m_sPoints + GetStatTotal()) > nStatTotal || GetTotalSkillPoints() > nSkillTotal)
return false;
return true;
}
void CUser::ZoneChange(uint16_t sNewZone, float x, float z)
{
C3DMap * pMap = g_pMain->GetZoneByID(sNewZone);
_KNIGHTS_SIEGE_WARFARE *pKnightSiege = g_pMain->GetSiegeMasterKnightsPtr(1);
CKnights* pKnightsMaster = NULL;
if(pKnightSiege) pKnightsMaster = g_pMain->GetClanPtr(pKnightSiege->sMasterKnights);
if (pMap == nullptr)
return;
WarpListResponse errorReason;
if (!CanChangeZone(pMap, errorReason))
{
Packet result(WIZ_WARP_LIST);
result << uint8_t(2) << uint8_t(errorReason);
if (errorReason == WarpListMinLevel)
result << pMap->GetMinLevelReq();
Send(&result);
return;
}
if (x == 0.0f && z == 0.0f)
{
_START_POSITION * pStartPosition = g_pMain->GetStartPosition(sNewZone);
if (pStartPosition != nullptr)
{
x = (float)(GetNation() == KARUS ? pStartPosition->sKarusX : pStartPosition->sElmoradX + myrand(0, pStartPosition->bRangeX));
z = (float)(GetNation() == KARUS ? pStartPosition->sKarusZ : pStartPosition->sElmoradZ + myrand(0, pStartPosition->bRangeZ));
}
}
m_bWarp = true;
m_bZoneChangeFlag = true;
// Random respawn position...
if (sNewZone == ZONE_CHAOS_DUNGEON)
{
int16_t sx, sz;
GetStartPositionRandom(sx,sz,(uint8_t)sNewZone);
x = (float)sx;
z = (float)sz;
}
if (sNewZone == ZONE_DELOS)
{
if (pKnightSiege && (pKnightSiege->sMasterKnights==GetClanID()) && (GetClanID()!=0))
{
if (GetNation() == KARUS)
{
x = (float)(455 + myrand(0, 5));
z = (float)(790 + myrand(0, 5));
}
else
{
x = (float)(555 + myrand(0, 5));
z = (float)(790 + myrand(0, 5));
}
}
}
m_LastX = x;
m_LastZ = z;
if (isInTempleEventZone((uint8_t)sNewZone) && !isGM())
{
if (!isEventUser())
g_pMain->AddEventUser(this);
g_pMain->SetEventUser(this);
}
if (GetZoneID() != sNewZone)
{
UserInOut(INOUT_OUT);
SetZoneAbilityChange(sNewZone);
// Reset the user's anger gauge when leaving the zone
// Unknown if this is official behaviour, but it's logical.
if (GetAngerGauge() > 0)
UpdateAngerGauge(0);
m_bZoneChangeSameZone = false;
/*
Here we also send a clan packet with subopcode 0x16 (with a byte flag of 2) if war zone/Moradon
or subopcode 0x17 (with nWarEnemyID) for all else
*/
#if 0
if (isInClan())
{
CKnights * pKnights = g_pMain->GetClanPtr(GetClanID());
if (pKnights != nullptr
&& pKnights->bKnightsWarStarted)
{
Packet clanPacket(WIZ_KNIGHTS_PROCESS);
if (pMap->isWarZone() || sNewZone == ZONE_MORADON)
clanPacket << uint8_t(0x17) << uint8_t(2);
else
clanPacket << uint16_t(0x16) << uint16_t(0 /*nWarEnemyID*/);
Send(&clanPacket);
}
}
#endif
if (isInParty() && !m_bZoneChangeSameZone)
if (isPartyLeader())
{
_PARTY_GROUP * pParty = g_pMain->GetPartyPtr(GetPartyID());
PartyPromote(pParty->uid[1]);
}
PartyRemove(GetSocketID());
if (hasRival())
RemoveRival();
ResetWindows();
}
else
{
m_bWarp = false;
Warp(uint16_t(x * 10), uint16_t(z * 10));
return;
}
if (sNewZone != ZONE_SNOW_BATTLE && GetZoneID() == ZONE_SNOW_BATTLE)
SetMaxHp(1);
if (sNewZone != ZONE_CHAOS_DUNGEON && GetZoneID() == ZONE_CHAOS_DUNGEON)
{
SetMaxHp(1);
RobChaosSkillItems();
g_pMain->UpdateEventUser(this, 0);
}
else if (sNewZone == ZONE_FORGOTTEN_TEMPLE)
g_pMain->m_nForgettenTempleUsers.push_back(GetSocketID());
else if (sNewZone != ZONE_FORGOTTEN_TEMPLE && GetZoneID() == ZONE_FORGOTTEN_TEMPLE)
g_pMain->m_nForgettenTempleUsers.erase(std::remove(g_pMain->m_nForgettenTempleUsers.begin(), g_pMain->m_nForgettenTempleUsers.end(), GetSocketID()), g_pMain->m_nForgettenTempleUsers.end());
m_bZone = (uint8_t) sNewZone; // this is 2 bytes to support the warp data loaded from SMDs. It should not go above a byte, however.
SetPosition(x, 0.0f, z);
m_pMap = pMap;
if (g_pMain->m_nServerNo != pMap->m_nServerNo)
{
_ZONE_SERVERINFO *pInfo = g_pMain->m_ServerArray.GetData(pMap->m_nServerNo);
if (pInfo == nullptr)
return;
UserDataSaveToAgent();
m_bLogout = 2; // server change flag
SendServerChange(pInfo->strServerIP, 2);
return;
}
SetRegion(GetNewRegionX(), GetNewRegionZ());
Packet result(WIZ_ZONE_CHANGE);
result << uint8_t(ZoneChangeTeleport) << uint16_t(GetZoneID()) << GetSPosX() << GetSPosZ() << GetSPosY() << g_pMain->m_byOldVictory;
Send(&result);
if (!m_bZoneChangeSameZone)
{
m_sWhoKilledMe = -1;
m_iLostExp = 0;
m_bRegeneType = 0;
m_tLastRegeneTime = 0;
m_sBind = -1;
InitType3();
InitType4();
CMagicProcess::CheckExpiredType9Skills(this, true);
SetUserAbility();
}
result.Initialize(AG_ZONE_CHANGE);
result << GetSocketID() << GetZoneID();
Send_AIServer(&result);
g_pMain->TempleEventSendActiveEventTime(this);
m_bZoneChangeFlag = false;
if (pKnightsMaster != nullptr && GetZoneID() == ZONE_DELOS)
{
Packet result(WIZ_SIEGE);
result << uint8_t(2) << pKnightsMaster->GetID() << pKnightsMaster->m_sMarkVersion;
Send(&result);
}
}
void CUser::PlayerRankingProcess(uint16_t ZoneID, bool RemoveInZone)
{
if(m_bZoneChangeSameZone)
return;
if (ZoneID == ZONE_ARDREAM
|| ZoneID == ZONE_RONARK_LAND_BASE
|| ZoneID == ZONE_RONARK_LAND
|| ZoneID == ZONE_BORDER_DEFENSE_WAR
|| ZoneID == ZONE_CHAOS_DUNGEON)
{
if (RemoveInZone)
RemovePlayerRank();
else
{
RemovePlayerRank();
AddPlayerRank(ZoneID);
}
}
else
RemovePlayerRank();
}
void CUser::AddPlayerRank(uint16_t ZoneID)
{
m_iLoyaltyDaily = 0;
m_iLoyaltyPremiumBonus = 0;
m_KillCount = 0;
m_DeathCount = 0;
_USER_RANKING * pData = new _USER_RANKING;
pData->m_socketID = GetSocketID();
pData->m_bEventRoom = GetEventRoom();
pData->m_bZone = ZoneID;
pData->m_bNation = GetNation();
pData->m_iLoyaltyDaily = m_iLoyaltyDaily;
pData->m_iLoyaltyPremiumBonus = m_iLoyaltyPremiumBonus;
pData->m_KillCount = 0;
pData->m_DeathCount = 0;
if (!g_pMain->m_UserRankingArray[GetNation() - 1].PutData(pData->m_socketID, pData))
delete pData;
}
void CUser::RemovePlayerRank()
{
g_pMain->m_UserRankingArray[GetNation() - 1].DeleteData(GetSocketID());
}
void CUser::UpdatePlayerRank()
{
if (isGM())
return;
_USER_RANKING * pRankInfo = g_pMain->m_UserRankingArray[GetNation() -1].GetData(GetSocketID());
if (pRankInfo == nullptr)
return;
pRankInfo->m_iLoyaltyDaily = m_iLoyaltyDaily;
pRankInfo->m_iLoyaltyPremiumBonus = m_iLoyaltyPremiumBonus;
pRankInfo->m_KillCount = m_KillCount;
pRankInfo->m_DeathCount = m_DeathCount;
}
void CUser::CheckWaiting(uint8_t sNewZone, uint16_t Time)
{
Packet result(WIZ_BIFROST);
result << uint8_t(MONSTER_SQUARD) << Time;
g_pMain->Send_All(&result, nullptr, 0, sNewZone);
}
/**
* @brief Changes the zone of all party members within the user's zone.
* If the user is not in a party, they should still be teleported.
*
* @param sNewZone ID of the new zone.
* @param x The x coordinate.
* @param z The z coordinate.
*/
void CUser::ZoneChangeParty(uint16_t sNewZone, float x, float z)
{
_PARTY_GROUP * pParty = g_pMain->GetPartyPtr(GetPartyID());
if (pParty == nullptr)
return ZoneChange(sNewZone, x, z);
int16_t partyUsers[MAX_PARTY_USERS];
for (int i = 0; i < MAX_PARTY_USERS; i++)
partyUsers[i] = pParty->uid[i];
for (int i = 0; i < MAX_PARTY_USERS; i++)
{
CUser * pUser = g_pMain->GetUserPtr(partyUsers[i]);
if (pUser != nullptr)
pUser->ZoneChange(sNewZone, x, z);
}
}
/**
* @brief Changes the zone of all clan members in home/neutral zones (including Eslant).
* If the user is not in a clan, they should not be teleported.
*
* @param sNewZone ID of the new zone.
* @param x The x coordinate.
* @param z The z coordinate.
*/
void CUser::ZoneChangeClan(uint16_t sNewZone, float x, float z)
{
CKnights * pKnights = g_pMain->GetClanPtr(GetClanID());
if (pKnights == nullptr)
return;
for (int i = 0; i < MAX_CLAN_USERS; i++)
{
_KNIGHTS_USER * p = &pKnights->m_arKnightsUser[i];
CUser * pUser = p->pSession;
if (p->byUsed && pUser != nullptr
&& pUser->GetZoneID() < ZONE_DELOS)
pUser->ZoneChange(sNewZone, x, z);
}
}
void CUser::Warp(uint16_t sPosX, uint16_t sPosZ)
{
ASSERT(GetMap() != nullptr);
if (m_bWarp)
return;
float real_x = sPosX / 10.0f, real_z = sPosZ / 10.0f;
if (!GetMap()->IsValidPosition(real_x, real_z, 0.0f))
{
TRACE("Invalid position %f,%f\n", real_x, real_z);
return;
}
m_LastX = real_x;
m_LastZ = real_z;
Packet result(WIZ_WARP);
result << sPosX << sPosZ;
Send(&result);
UserInOut(INOUT_OUT);
m_curx = real_x;
m_curz = real_z;
SetRegion(GetNewRegionX(), GetNewRegionZ());
UserInOut(INOUT_WARP);
g_pMain->UserInOutForMe(this);
g_pMain->NpcInOutForMe(this);
g_pMain->MerchantUserInOutForMe(this);
ResetWindows();
}
void CUser::RecvWarp(Packet & pkt)
{
uint16_t warp_x, warp_z;
pkt >> warp_x >> warp_z;
Warp(warp_x, warp_z);
}
void CUser::RecvZoneChange(Packet & pkt)
{
if (isDead()) // we also need to make sure we're actually waiting on this request...
return;
uint8_t opcode = pkt.read<uint8_t>();
if (opcode == ZoneChangeLoading)
{
g_pMain->RegionUserInOutForMe(this);
g_pMain->NpcInOutForMe(this);
g_pMain->MerchantUserInOutForMe(this);
Packet result(WIZ_ZONE_CHANGE);
result << uint8_t(ZoneChangeLoaded); // finalise the zone change
Send(&result);
}
else if (opcode == ZoneChangeLoaded)
{
UserInOut(INOUT_RESPAWN);
// TODO: Fix all this up (it's too messy/confusing)
if (!m_bZoneChangeSameZone)
BlinkStart();
if (GetZoneID() != ZONE_CHAOS_DUNGEON)
{
InitType4();
RecastSavedMagic();
}
m_bZoneChangeFlag = false;
m_bWarp = false;
}
}
| 24.660993
| 191
| 0.68791
|
APistole
|
c845f9425a08bd2cad727a4cd9cdede33a57645d
| 8,528
|
cpp
|
C++
|
SignInRegister/MyPrintManager.cpp
|
sbweeden/signinregister
|
bf6741f71eefb4ad860c83473f84417a9cabbd73
|
[
"MIT"
] | null | null | null |
SignInRegister/MyPrintManager.cpp
|
sbweeden/signinregister
|
bf6741f71eefb4ad860c83473f84417a9cabbd73
|
[
"MIT"
] | null | null | null |
SignInRegister/MyPrintManager.cpp
|
sbweeden/signinregister
|
bf6741f71eefb4ad860c83473f84417a9cabbd73
|
[
"MIT"
] | null | null | null |
#include "StdAfx.h"
#include "MyPrintManager.h"
#include "SignInRegister.h"
#include "Msg.h"
#include "Resource.h"
#include "SignInRecord.h"
#define RECORDS_PER_PAGE 14
#define PRINTER_SIGNATURE_SCALE 1.016
MyPrintManager::MyPrintManager(CPtrArray& records, LPCTSTR filename)
: m_records(records),
m_filename(filename)
{
}
MyPrintManager::~MyPrintManager(void)
{
}
void MyPrintManager::PrintRecords()
{
CDC dc;
CPrintDialog printDlg(FALSE);
theApp.SetPrinterOptions();
if (theApp.DoPrintDialog(&printDlg) == IDCANCEL) // Get printer settings from user
return;
dc.Attach(printDlg.GetPrinterDC()); // Get and attach a printer DC
// determine if we can print on this page
if ( !GetAndCheckDeviceCapabilities(&dc))
{
dc.DeleteDC();
return;
}
dc.m_bPrinting = TRUE;
CString strTitle; // Get the application title
strTitle.LoadString(IDS_APP_TITLE);
DOCINFO di; // Initialise print document details
::ZeroMemory (&di, sizeof (DOCINFO));
di.cbSize = sizeof (DOCINFO);
di.lpszDocName = strTitle;
BOOL bPrintingOK = dc.StartDoc(&di); // Begin a new print job
// Get the printing extents and store in the m_rectDraw field of a
// CPrintInfo object
CPrintInfo Info;
Info.m_rectDraw.SetRect(0,0,
dc.GetDeviceCaps(HORZRES),
dc.GetDeviceCaps(VERTRES));
OnBeginPrinting(&dc, &Info); // Call your "Init printing" function
for (UINT page = Info.GetMinPage();
page <= Info.GetMaxPage() && bPrintingOK;
page++)
{
dc.StartPage(); // begin new page
Info.m_nCurPage = page;
OnPrint(&dc, &Info); // Call your "Print page" function
bPrintingOK = (dc.EndPage() > 0); // end page
}
OnEndPrinting(&dc, &Info); // Call your "Clean up" function
if (bPrintingOK)
dc.EndDoc(); // end a print job
else
dc.AbortDoc(); // abort job.
dc.DeleteDC(); // delete the printer DC
}
void MyPrintManager::OnBeginPrinting(CDC *pDC, CPrintInfo* pInfo)
{
// maybe pre cache some pens or brushes, or modify the
// properties of the DC
m_pPrintPen = new CPen(PS_SOLID, 8, RGB(0,0,0));
m_pOldPrintPen = pDC->SelectObject(m_pPrintPen);
// maximum number of pages
pInfo->SetMaxPage((int)((m_records.GetCount()+RECORDS_PER_PAGE-1)/RECORDS_PER_PAGE));
}
void MyPrintManager::OnPrint(CDC *pDC, CPrintInfo* pInfo)
{
// Do your drawing/printing exactly as you would in a
// CView::OnDraw function. The CPrintInfo structure
// will give you the bounds and the current page number
/*
CString msg;
msg.Format(_T("Left: %d Top: %d Right: %d Bottom: %d Width(mm): %d Height(mm): %d Width(res): %d Height(res): %d"),
pInfo->m_rectDraw.left,
pInfo->m_rectDraw.top,
pInfo->m_rectDraw.right,
pInfo->m_rectDraw.bottom,
pDC->GetDeviceCaps(HORZSIZE),
pDC->GetDeviceCaps(VERTSIZE),
pDC->GetDeviceCaps(HORZRES),
pDC->GetDeviceCaps(VERTRES)
);
MessageBox(NULL, msg, _T("Debug"), MB_OK);
*/
// all these numbers are in mm - we convert them into device units at draw time
const int BORDER_LEFT = (m_width_mm - m_a4_width) / 2;
const int BORDER_TOP = (m_height_mm - m_a4_height) / 2 + 20;
const int BORDER_RIGHT = BORDER_LEFT + m_a4_width;
const int BORDER_BOTTOM = BORDER_TOP + m_a4_height - 21;
// overall border
pDC->Rectangle(
BORDER_LEFT*m_hdps,
BORDER_TOP*m_vdps,
BORDER_RIGHT*m_hdps,
BORDER_BOTTOM*m_vdps);
// column lines
const int TIMESTAMP_LINE_X = BORDER_LEFT+26;
const int NAME_LINE_X = TIMESTAMP_LINE_X+63;
const int LICENSE_LINE_X = NAME_LINE_X + 37;
const int CLUB_LINE_X = LICENSE_LINE_X + 51;
const int CAT_LINE_X = CLUB_LINE_X + 10;
const int SIG_LINE_X = CAT_LINE_X + 30;
pDC->MoveTo(TIMESTAMP_LINE_X*m_hdps, BORDER_TOP*m_vdps);
pDC->LineTo(TIMESTAMP_LINE_X*m_hdps, BORDER_BOTTOM*m_vdps);
pDC->MoveTo(NAME_LINE_X*m_hdps, BORDER_TOP*m_vdps);
pDC->LineTo(NAME_LINE_X*m_hdps, BORDER_BOTTOM*m_vdps);
pDC->MoveTo(LICENSE_LINE_X*m_hdps, BORDER_TOP*m_vdps);
pDC->LineTo(LICENSE_LINE_X*m_hdps, BORDER_BOTTOM*m_vdps);
pDC->MoveTo(CLUB_LINE_X*m_hdps, BORDER_TOP*m_vdps);
pDC->LineTo(CLUB_LINE_X*m_hdps, BORDER_BOTTOM*m_vdps);
pDC->MoveTo(CAT_LINE_X*m_hdps, BORDER_TOP*m_vdps);
pDC->LineTo(CAT_LINE_X*m_hdps, BORDER_BOTTOM*m_vdps);
pDC->MoveTo(SIG_LINE_X*m_hdps, BORDER_TOP*m_vdps);
pDC->LineTo(SIG_LINE_X*m_hdps, BORDER_BOTTOM*m_vdps);
// first row underline
const int TITLE_LINE_Y = BORDER_TOP + 10;
pDC->MoveTo(BORDER_LEFT*m_hdps, TITLE_LINE_Y*m_vdps);
pDC->LineTo(BORDER_RIGHT*m_hdps, TITLE_LINE_Y*m_vdps);
pDC->MoveTo(BORDER_LEFT*m_hdps, (TITLE_LINE_Y-1)*m_vdps);
pDC->LineTo(BORDER_RIGHT*m_hdps, (TITLE_LINE_Y-1)*m_vdps);
// filename and page number
const int META_Y = BORDER_TOP - 5;
CString metastr;
metastr.Format(_T("Filename: %s Page %d of %d"), m_filename, pInfo->m_nCurPage, pInfo->GetMaxPage());
pDC->TextOut((BORDER_LEFT+2)*m_hdps, META_Y*m_vdps, metastr);
// text for column headings
const int TITLES_Y = BORDER_TOP + 2;
pDC->TextOut((BORDER_LEFT+2)*m_hdps, TITLES_Y*m_vdps, CString(_T("Timestamp")));
pDC->TextOut((TIMESTAMP_LINE_X+2)*m_hdps, TITLES_Y*m_vdps, CString(_T("Name")));
pDC->TextOut((NAME_LINE_X+2)*m_hdps, TITLES_Y*m_vdps, CString(_T("License")));
pDC->TextOut((LICENSE_LINE_X+2)*m_hdps, TITLES_Y*m_vdps, CString(_T("Club")));
pDC->TextOut((CLUB_LINE_X+2)*m_hdps, TITLES_Y*m_vdps, CString(_T("Cat")));
pDC->TextOut((CAT_LINE_X+2)*m_hdps, TITLES_Y*m_vdps, CString(_T("Signature")));
pDC->TextOut((SIG_LINE_X+1)*m_hdps, TITLES_Y*m_vdps, CString(_T("Range Officer (* R.O. login)")));
// print this page's records
int start_record = (int) (RECORDS_PER_PAGE * (pInfo->m_nCurPage-1));
int end_record = (int) min((start_record+RECORDS_PER_PAGE), m_records.GetCount());
for ( int i = start_record; i < end_record; i++ )
{
const int RECORD_HEIGHT = 12;
const int RECORD_Y = (TITLE_LINE_Y+1) + ((i-start_record)*RECORD_HEIGHT);
SignInRecord * pRecord = (SignInRecord *) m_records.GetAt(i);
// print the timestamp
CString tstr1 = pRecord->getTimestamp().Format("%Y-%m-%d");
CString tstr2 = pRecord->getTimestamp().Format("%H:%M:%S");
pDC->TextOut((BORDER_LEFT+1)*m_hdps, RECORD_Y*m_vdps, tstr1);
pDC->TextOut((BORDER_LEFT+1)*m_hdps, (RECORD_Y+6)*m_vdps, tstr2);
// print the name
pDC->TextOut((TIMESTAMP_LINE_X+1)*m_hdps, RECORD_Y*m_vdps, pRecord->getShooterName());
// print the license
pDC->TextOut((NAME_LINE_X+1)*m_hdps, RECORD_Y*m_vdps, pRecord->getLicense());
// print the club
pDC->TextOut((LICENSE_LINE_X+1)*m_hdps, RECORD_Y*m_vdps, pRecord->getClub());
// print the category
pDC->TextOut((CLUB_LINE_X+1)*m_hdps, RECORD_Y*m_vdps, pRecord->getCategory());
// print the signature
//pRecord->getSignature().Draw(pDC, CPoint((CAT_LINE_X+1)*m_hdps, RECORD_Y*m_vdps), 4, false, PRINTER_SIGNATURE_SCALE);
pRecord->getSignature().Draw(pDC, CPoint((CAT_LINE_X)*m_hdps, (RECORD_Y-1)*m_vdps), 4, false, PRINTER_SIGNATURE_SCALE);
// print the range office
pDC->TextOut((SIG_LINE_X+1)*m_hdps, RECORD_Y*m_vdps, pRecord->getRangeOfficer());
// underline if it's not the last for this page
pDC->MoveTo(BORDER_LEFT*m_hdps, (RECORD_Y+RECORD_HEIGHT-1)*m_vdps);
pDC->LineTo(BORDER_RIGHT*m_hdps, (RECORD_Y+RECORD_HEIGHT-1)*m_vdps);
}
}
void MyPrintManager::OnEndPrinting(CDC *pDC, CPrintInfo* pInfo)
{
// Clean up pens or brushes, or restore the DC
pDC->SelectObject(m_pOldPrintPen);
delete m_pPrintPen;
}
bool MyPrintManager::GetAndCheckDeviceCapabilities(CDC * pDC)
{
m_width_bits = pDC->GetDeviceCaps(HORZRES);
m_height_bits = pDC->GetDeviceCaps(VERTRES);
m_width_mm = pDC->GetDeviceCaps(HORZSIZE);
m_height_mm = pDC->GetDeviceCaps(VERTSIZE);
m_hdps = m_width_bits/m_width_mm;
m_vdps = m_height_bits/m_height_mm;
// an A4 page in landscape mode is 297mm x 210 mm, however many printers can't use that whole area.
// we require 280mm x 200mm
m_a4_width = 280; // 297;
m_a4_height = 200; //210;
if ( m_width_mm < m_a4_width || m_height_mm < m_a4_height )
{
CString widthstr;
CString heightstr;
widthstr.Format(_T("%d"), m_width_mm);
heightstr.Format(_T("%d"), m_height_mm);
MessageBox(NULL, CFMsg(IDS_ERR_PAGE_RESOLUTION, widthstr, heightstr), CMsg(IDS_MB_ERROR), MB_OK | MB_SYSTEMMODAL);
return false;
}
return true;
}
| 35.09465
| 121
| 0.695356
|
sbweeden
|
c847e6fae78ccb5587cd2b02676a32c49cb407f8
| 15,055
|
cpp
|
C++
|
engine/tmessage.cpp
|
DannyParker0001/Kisak-Strike
|
99ed85927336fe3aff2efd9b9382b2b32eb1d05d
|
[
"Unlicense"
] | 252
|
2020-12-16T15:34:43.000Z
|
2022-03-31T23:21:37.000Z
|
cstrike15_src/engine/tmessage.cpp
|
bahadiraraz/Counter-Strike-Global-Offensive
|
9a0534100cb98ffa1cf0c32e138f0e7971e910d3
|
[
"MIT"
] | 23
|
2020-12-20T18:02:54.000Z
|
2022-03-28T16:58:32.000Z
|
cstrike15_src/engine/tmessage.cpp
|
bahadiraraz/Counter-Strike-Global-Offensive
|
9a0534100cb98ffa1cf0c32e138f0e7971e910d3
|
[
"MIT"
] | 42
|
2020-12-19T04:32:33.000Z
|
2022-03-30T06:00:28.000Z
|
//========= Copyright (c) 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//=============================================================================//
#include "quakedef.h"
#include "cdll_int.h"
#include "draw.h"
#include "tmessage.h"
#include "common.h"
#include "characterset.h"
#include "mem_fgets.h"
#include "tier0/icommandline.h"
#include "tier0/platform.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#define MSGFILE_NAME 0
#define MSGFILE_TEXT 1
#define MAX_MESSAGES 600 // I don't know if this table will balloon like every other feature in Half-Life
// But, for now, I've set this to a reasonable value
// Defined in other files.
static characterset_t g_WhiteSpace;
client_textmessage_t gMessageParms;
client_textmessage_t *gMessageTable = NULL;
int gMessageTableCount = 0;
char gNetworkTextMessageBuffer[MAX_NETMESSAGE][512];
const char *gNetworkMessageNames[MAX_NETMESSAGE] = { NETWORK_MESSAGE1, NETWORK_MESSAGE2, NETWORK_MESSAGE3, NETWORK_MESSAGE4, NETWORK_MESSAGE5, NETWORK_MESSAGE6 };
client_textmessage_t gNetworkTextMessage[MAX_NETMESSAGE] =
{
0, // effect
255,255,255,255,
255,255,255,255,
-1.0f, // x
-1.0f, // y
0.0f, // fadein
0.0f, // fadeout
0.0f, // holdtime
0.0f, // fxTime,
NULL,//pVGuiSchemeFontName (NULL == default)
NETWORK_MESSAGE1, // pName message name.
gNetworkTextMessageBuffer[0] // pMessage
};
char gDemoMessageBuffer[512];
client_textmessage_t tm_demomessage =
{
0, // effect
255,255,255,255,
255,255,255,255,
-1.0f, // x
-1.0f, // y
0.0f, // fadein
0.0f, // fadeout
0.0f, // holdtime
0.0f, // fxTime,
NULL,// pVGuiSchemeFontName (NULL == default)
DEMO_MESSAGE, // pName message name.
gDemoMessageBuffer // pMessage
};
static client_textmessage_t orig_demo_message = tm_demomessage;
static void TextMessageParse( byte *pMemFile, int fileSize );
// The string "pText" is assumed to have all whitespace from both ends cut out
int IsComment( char *pText )
{
if ( pText )
{
int length = strlen( pText );
if ( length >= 2 && pText[0] == '/' && pText[1] == '/' )
return 1;
// No text?
if ( length > 0 )
return 0;
}
// No text is a comment too
return 1;
}
// The string "pText" is assumed to have all whitespace from both ends cut out
int IsStartOfText( char *pText )
{
if ( pText )
{
if ( pText[0] == '{' )
return 1;
}
return 0;
}
// The string "pText" is assumed to have all whitespace from both ends cut out
int IsEndOfText( char *pText )
{
if ( pText )
{
if ( pText[0] == '}' )
return 1;
}
return 0;
}
#if 0
int IsWhiteSpace( char space )
{
if ( space == ' ' || space == '\t' || space == '\r' || space == '\n' )
return 1;
return 0;
}
#else
#define IsWhiteSpace(space) IN_CHARACTERSET( g_WhiteSpace, space )
#endif
const char *SkipSpace( const char *pText )
{
if ( pText )
{
int pos = 0;
while ( pText[pos] && IsWhiteSpace( pText[pos] ) )
pos++;
return pText + pos;
}
return NULL;
}
const char *SkipText( const char *pText )
{
if ( pText )
{
int pos = 0;
while ( pText[pos] && !IsWhiteSpace( pText[pos] ) )
pos++;
return pText + pos;
}
return NULL;
}
int ParseFloats( const char *pText, float *pFloat, int count )
{
const char *pTemp = pText;
int index = 0;
while ( pTemp && count > 0 )
{
// Skip current token / float
pTemp = SkipText( pTemp );
// Skip any whitespace in between
pTemp = SkipSpace( pTemp );
if ( pTemp )
{
// Parse a float
pFloat[index] = (float)atof( pTemp );
count--;
index++;
}
}
if ( count == 0 )
return 1;
return 0;
}
int ParseString( char const *pText, char *buf, size_t bufsize )
{
const char *pTemp = pText;
// Skip current token / float
pTemp = SkipText( pTemp );
// Skip any whitespace in between
pTemp = SkipSpace( pTemp );
if ( pTemp )
{
char const *pStart = pTemp;
pTemp = SkipText( pTemp );
int len = MIN( pTemp - pStart + 1, (int)bufsize - 1 );
Q_strncpy( buf, pStart, len );
buf[ len ] = 0;
return 1;
}
return 0;
}
// Trims all whitespace from the front and end of a string
void TrimSpace( const char *source, char *dest )
{
int start, end, length;
start = 0;
end = strlen( source );
while ( source[start] && IsWhiteSpace( source[start] ) )
start++;
end--;
while ( end > 0 && IsWhiteSpace( source[end] ) )
end--;
end++;
length = end - start;
if ( length > 0 )
memcpy( dest, source + start, length );
else
length = 0;
// Terminate the dest string
dest[ length ] = 0;
}
int IsToken( const char *pText, const char *pTokenName )
{
if ( !pText || !pTokenName )
return 0;
if ( StringHasPrefix( pText+1, pTokenName ) )
return 1;
return 0;
}
static char g_pchSkipName[ 64 ];
int ParseDirective( const char *pText )
{
if ( pText && pText[0] == '$' )
{
float tempFloat[8];
if ( IsToken( pText, "position" ) )
{
if ( ParseFloats( pText, tempFloat, 2 ) )
{
gMessageParms.x = tempFloat[0];
gMessageParms.y = tempFloat[1];
}
}
else if ( IsToken( pText, "effect" ) )
{
if ( ParseFloats( pText, tempFloat, 1 ) )
{
gMessageParms.effect = (int)tempFloat[0];
}
}
else if ( IsToken( pText, "fxtime" ) )
{
if ( ParseFloats( pText, tempFloat, 1 ) )
{
gMessageParms.fxtime = tempFloat[0];
}
}
else if ( IsToken( pText, "color2" ) )
{
if ( ParseFloats( pText, tempFloat, 3 ) )
{
gMessageParms.r2 = (int)tempFloat[0];
gMessageParms.g2 = (int)tempFloat[1];
gMessageParms.b2 = (int)tempFloat[2];
}
}
else if ( IsToken( pText, "color" ) )
{
if ( ParseFloats( pText, tempFloat, 3 ) )
{
gMessageParms.r1 = (int)tempFloat[0];
gMessageParms.g1 = (int)tempFloat[1];
gMessageParms.b1 = (int)tempFloat[2];
}
}
else if ( IsToken( pText, "fadein" ) )
{
if ( ParseFloats( pText, tempFloat, 1 ) )
{
gMessageParms.fadein = tempFloat[0];
}
}
else if ( IsToken( pText, "fadeout" ) )
{
if ( ParseFloats( pText, tempFloat, 3 ) )
{
gMessageParms.fadeout = tempFloat[0];
}
}
else if ( IsToken( pText, "holdtime" ) )
{
if ( ParseFloats( pText, tempFloat, 3 ) )
{
gMessageParms.holdtime = tempFloat[0];
}
}
else if ( IsToken( pText, "boxsize" ) )
{
if ( ParseFloats( pText, tempFloat, 1 ) )
{
gMessageParms.bRoundedRectBackdropBox = tempFloat[0] != 0.0f;
gMessageParms.flBoxSize = tempFloat[0];
}
}
else if ( IsToken( pText, "boxcolor" ) )
{
if ( ParseFloats( pText, tempFloat, 4 ) )
{
for ( int i = 0; i < 4; ++i )
{
gMessageParms.boxcolor[ i ] = (byte)(int)tempFloat[ i ];
}
}
}
else if ( IsToken( pText, "clearmessage" ) )
{
if ( ParseString( pText, g_pchSkipName, sizeof( g_pchSkipName ) ) )
{
if ( !g_pchSkipName[ 0 ] || !Q_stricmp( g_pchSkipName, "0" ) )
{
gMessageParms.pClearMessage = NULL;
}
else
{
gMessageParms.pClearMessage = g_pchSkipName;
}
}
}
else
{
ConDMsg("Unknown token: %s\n", pText );
}
return 1;
}
return 0;
}
#define NAME_HEAP_SIZE 16384
void TextMessageParse( byte *pMemFile, int fileSize )
{
char buf[512], trim[512];
char *pCurrentText=0, *pNameHeap;
char currentName[512], nameHeap[ NAME_HEAP_SIZE ];
int lastNamePos;
int mode = MSGFILE_NAME; // Searching for a message name
int lineNumber, filePos, lastLinePos;
int messageCount;
client_textmessage_t textMessages[ MAX_MESSAGES ];
int i, nameHeapSize, textHeapSize, messageSize;
intp nameOffset;
lastNamePos = 0;
lineNumber = 0;
filePos = 0;
lastLinePos = 0;
messageCount = 0;
bool bSpew = CommandLine()->FindParm( "-textmessagedebug" ) ? true : false;
CharacterSetBuild( &g_WhiteSpace, " \r\n\t" );
while( memfgets( pMemFile, fileSize, &filePos, buf, 512 ) != NULL )
{
if(messageCount>=MAX_MESSAGES)
{
Sys_Error("tmessage::TextMessageParse : messageCount>=MAX_MESSAGES");
}
TrimSpace( buf, trim );
switch( mode )
{
case MSGFILE_NAME:
if ( IsComment( trim ) ) // Skip comment lines
break;
if ( ParseDirective( trim ) ) // Is this a directive "$command"?, if so parse it and break
break;
if ( IsStartOfText( trim ) )
{
mode = MSGFILE_TEXT;
pCurrentText = (char*)(pMemFile + filePos);
break;
}
if ( IsEndOfText( trim ) )
{
ConDMsg("Unexpected '}' found, line %d\n", lineNumber );
return;
}
Q_strncpy( currentName, trim, sizeof( currentName ) );
break;
case MSGFILE_TEXT:
if ( IsEndOfText( trim ) )
{
int length = strlen(currentName);
// Save name on name heap
if ( lastNamePos + length > 8192 )
{
ConDMsg("Error parsing file!\n" );
return;
}
Q_strcpy( nameHeap + lastNamePos, currentName );
// Terminate text in-place in the memory file (it's temporary memory that will be deleted)
// If the string starts with #, it's a localization string and we don't
// want the \n (or \r) on the end or the Find() lookup will fail (so subtract 2)
if ( pCurrentText && pCurrentText[0] && pCurrentText[0] == '#' && lastLinePos > 1 &&
( ( pMemFile[lastLinePos - 2] == '\n' ) || ( pMemFile[lastLinePos - 2] == '\r' ) ) )
{
pMemFile[ lastLinePos - 2 ] = 0;
}
else
{
pMemFile[ lastLinePos - 1 ] = 0;
}
// Save name/text on heap
textMessages[ messageCount ] = gMessageParms;
textMessages[ messageCount ].pName = nameHeap + lastNamePos;
lastNamePos += strlen(currentName) + 1;
if ( gMessageParms.pClearMessage )
{
Q_strncpy( nameHeap + lastNamePos, textMessages[ messageCount ].pClearMessage, Q_strlen( textMessages[ messageCount ].pClearMessage ) + 1 );
textMessages[ messageCount ].pClearMessage = nameHeap + lastNamePos;
lastNamePos += Q_strlen( textMessages[ messageCount ].pClearMessage ) + 1;
}
textMessages[ messageCount ].pMessage = pCurrentText;
if ( bSpew )
{
client_textmessage_t *m = &textMessages[ messageCount ];
Msg( "%d %s\n",
messageCount, m->pName ? m->pName : "(null)" );
Msg( " effect %d, color1(%d,%d,%d,%d), color2(%d,%d,%d,%d)\n",
m->effect, m->r1, m->g1, m->b1, m->a1, m->r2, m->g2, m->b2, m->a2 );
Msg( " pos %f,%f, fadein %f fadeout %f hold %f fxtime %f\n",
m->x, m->y, m->fadein, m->fadeout, m->holdtime, m->fxtime );
Msg( " '%s'\n", m->pMessage ? m->pMessage : "(null)" );
Msg( " box %s, size %f, color(%d,%d,%d,%d)\n",
m->bRoundedRectBackdropBox ? "yes" : "no", m->flBoxSize, m->boxcolor[ 0 ], m->boxcolor[ 1 ], m->boxcolor[ 2 ], m->boxcolor[ 3 ] );
if ( m->pClearMessage )
{
Msg( " will clear '%s'\n", m->pClearMessage );
}
}
messageCount++;
// Reset parser to search for names
mode = MSGFILE_NAME;
break;
}
if ( IsStartOfText( trim ) )
{
ConDMsg("Unexpected '{' found, line %d\n", lineNumber );
return;
}
break;
}
lineNumber++;
lastLinePos = filePos;
if ( messageCount >= MAX_MESSAGES )
{
ConMsg("WARNING: TOO MANY MESSAGES IN TITLES.TXT, MAX IS %d\n", MAX_MESSAGES );
break;
}
}
ConDMsg("Parsed %d text messages\n", messageCount );
nameHeapSize = lastNamePos;
textHeapSize = 0;
for ( i = 0; i < messageCount; i++ )
textHeapSize += strlen( textMessages[i].pMessage ) + 1;
messageSize = (messageCount * sizeof(client_textmessage_t));
// Must malloc because we need to be able to clear it after initialization
gMessageTable = (client_textmessage_t *)malloc( textHeapSize + nameHeapSize + messageSize );
// Copy table over
memcpy( gMessageTable, textMessages, messageSize );
// Copy Name heap
pNameHeap = ((char *)gMessageTable) + messageSize;
memcpy( pNameHeap, nameHeap, nameHeapSize );
nameOffset = pNameHeap - gMessageTable[0].pName;
// Copy text & fixup pointers
pCurrentText = pNameHeap + nameHeapSize;
for ( i = 0; i < messageCount; i++ )
{
gMessageTable[i].pName += nameOffset; // Adjust name pointer (parallel buffer)
if ( gMessageTable[ i ].pClearMessage )
{
gMessageTable[ i ].pClearMessage += nameOffset;
}
Q_strcpy( pCurrentText, gMessageTable[i].pMessage ); // Copy text over
gMessageTable[i].pMessage = pCurrentText;
pCurrentText += strlen( pCurrentText ) + 1;
}
#if _DEBUG
if ( (pCurrentText - (char *)gMessageTable) != (textHeapSize + nameHeapSize + messageSize) )
ConMsg("Overflow text message buffer!!!!!\n");
#endif
gMessageTableCount = messageCount;
}
void TextMessageShutdown( void )
{
// Clear out any old data that's sitting around.
if ( gMessageTable )
{
free( gMessageTable );
gMessageTable = NULL;
}
}
void TextMessageInit( void )
{
int fileSize;
byte *pMemFile;
// Clear out any old data that's sitting around.
if ( gMessageTable )
{
free( gMessageTable );
gMessageTable = NULL;
}
pMemFile = COM_LoadFile( "scripts/titles.txt", 5, &fileSize );
if ( pMemFile )
{
TextMessageParse( pMemFile, fileSize );
free( pMemFile );
}
int i;
for ( i = 0; i < MAX_NETMESSAGE; i++ )
{
gNetworkTextMessage[ i ].pMessage =
gNetworkTextMessageBuffer[ i ];
}
}
void TextMessage_DemoMessage( const char *pszMessage, float fFadeInTime, float fFadeOutTime, float fHoldTime )
{
if ( !pszMessage || !pszMessage[0] )
return;
// Restore
tm_demomessage = orig_demo_message;
Q_strncpy( gDemoMessageBuffer, (char *)pszMessage, sizeof( gDemoMessageBuffer ) );
tm_demomessage.fadein = fFadeInTime;
tm_demomessage.fadeout = fFadeOutTime;
tm_demomessage.holdtime = fHoldTime;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pszMessage -
// *message -
//-----------------------------------------------------------------------------
void TextMessage_DemoMessageFull( const char *pszMessage, client_textmessage_t const *message )
{
Assert( message );
if ( !message )
return;
if ( !pszMessage || !pszMessage[0] )
return;
memcpy( &tm_demomessage, message, sizeof( tm_demomessage ) );
tm_demomessage.pMessage = orig_demo_message.pMessage;
tm_demomessage.pName = orig_demo_message.pName;
Q_strncpy( gDemoMessageBuffer, pszMessage, sizeof( gDemoMessageBuffer ) );
}
client_textmessage_t *TextMessageGet( const char *pName )
{
if (!Q_stricmp( pName, DEMO_MESSAGE ))
return &tm_demomessage;
// HACKHACK -- add 4 "channels" of network text
if (!Q_stricmp( pName, NETWORK_MESSAGE1 ))
return gNetworkTextMessage;
else if (!Q_stricmp( pName, NETWORK_MESSAGE2 ))
return gNetworkTextMessage + 1;
else if (!Q_stricmp( pName, NETWORK_MESSAGE3 ))
return gNetworkTextMessage + 2;
else if (!Q_stricmp( pName, NETWORK_MESSAGE4 ))
return gNetworkTextMessage + 3;
else if (!Q_stricmp( pName, NETWORK_MESSAGE5 ))
return gNetworkTextMessage + 4;
else if (!Q_stricmp( pName, NETWORK_MESSAGE6 ))
return gNetworkTextMessage + 5;
for ( int i = 0; i < gMessageTableCount; i++ )
{
if ( !Q_stricmp( pName, gMessageTable[i].pName ) )
return &gMessageTable[i];
}
return NULL;
}
| 23.56025
| 162
| 0.630687
|
DannyParker0001
|
c8497a1e3394b401688b970a845be2c8ab1b9633
| 1,121
|
cc
|
C++
|
Codeforces/213 Division 1/Problem A/A.cc
|
VastoLorde95/Competitive-Programming
|
6c990656178fb0cd33354cbe5508164207012f24
|
[
"MIT"
] | 170
|
2017-07-25T14:47:29.000Z
|
2022-01-26T19:16:31.000Z
|
Codeforces/213 Division 1/Problem A/A.cc
|
navodit15/Competitive-Programming
|
6c990656178fb0cd33354cbe5508164207012f24
|
[
"MIT"
] | null | null | null |
Codeforces/213 Division 1/Problem A/A.cc
|
navodit15/Competitive-Programming
|
6c990656178fb0cd33354cbe5508164207012f24
|
[
"MIT"
] | 55
|
2017-07-28T06:17:33.000Z
|
2021-10-31T03:06:22.000Z
|
#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<map>
#include<set>
#include<vector>
#include<utility>
#include<queue>
#include<stack>
#define sd(x) scanf("%d",&x)
#define sd2(x,y) scanf("%d%d",&x,&y)
#define sd3(x,y,z) scanf("%d%d%d",&x,&y,&z)
#define fi first
#define se second
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
#define _ ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
using namespace std;
long long a, n;
long long sum[4001];
map<long long, long long> cnt;
long long res;
string s;
int main(){ _
cin >> a;
cin >> s;
n = s.length();
for(int i = 1; i <= n; i++){
sum[i] = sum[i-1] + (s[i-1]-'0');
}
for(int i = 1; i <= n; i++){
for(int j = i; j <= n; j++){
cnt[sum[j]-sum[i-1]]++;
}
}
for(map<long long, long long>::iterator it = cnt.begin(); it != cnt.end(); it++){
long long t1 = it->fi, t2 = it->se;
if(t1 == 0){
if(a == 0) res = res + t2*((n*(n+1))/2);
}
else if(a%t1 == 0 and cnt.find(a/t1) != cnt.end()){
res = res + (t2 * cnt[a/t1]);
}
}
cout << res << endl;
return 0;
}
| 19
| 82
| 0.570027
|
VastoLorde95
|
c84996aeb4718c79230683382d6425bb03f93f2b
| 3,001
|
cpp
|
C++
|
Reactions/AMReX_SUNMemory.cpp
|
wjge/PelePhysics
|
631bc129262f9a0e0a3fa4626f855c02e4847a81
|
[
"BSD-3-Clause-LBNL"
] | null | null | null |
Reactions/AMReX_SUNMemory.cpp
|
wjge/PelePhysics
|
631bc129262f9a0e0a3fa4626f855c02e4847a81
|
[
"BSD-3-Clause-LBNL"
] | null | null | null |
Reactions/AMReX_SUNMemory.cpp
|
wjge/PelePhysics
|
631bc129262f9a0e0a3fa4626f855c02e4847a81
|
[
"BSD-3-Clause-LBNL"
] | null | null | null |
#include <AMReX.H>
#include <AMReX_Gpu.H>
#include <AMReX_SUNMemory.H>
#if defined(AMREX_USE_HIP)
#include <sunmemory/sunmemory_hip.h>
#elif defined(AMREX_USE_CUDA)
#include <sunmemory/sunmemory_cuda.h>
#endif
namespace amrex {
namespace sundials {
namespace {
int
Alloc(
SUNMemoryHelper, SUNMemory* memptr, size_t memsize, SUNMemoryType mem_type)
{
SUNMemory mem = SUNMemoryNewEmpty();
mem->ptr = NULL;
mem->own = SUNTRUE;
mem->type = mem_type;
if (mem_type == SUNMEMTYPE_HOST) {
mem->ptr = The_Cpu_Arena()->alloc(memsize);
} else if (mem_type == SUNMEMTYPE_UVM) {
mem->ptr = The_Managed_Arena()->alloc(memsize);
} else if (mem_type == SUNMEMTYPE_DEVICE) {
mem->ptr = The_Device_Arena()->alloc(memsize);
} else if (mem_type == SUNMEMTYPE_PINNED) {
mem->ptr = The_Pinned_Arena()->alloc(memsize);
} else {
free(mem);
return (-1);
}
*memptr = mem;
return (0);
}
int
Dealloc(SUNMemoryHelper, SUNMemory mem)
{
if (mem == NULL)
return (0);
if (mem->type == SUNMEMTYPE_HOST) {
if (mem->own)
The_Cpu_Arena()->free(mem->ptr);
} else if (mem->type == SUNMEMTYPE_UVM) {
if (mem->own)
The_Managed_Arena()->free(mem->ptr);
} else if (mem->type == SUNMEMTYPE_DEVICE) {
if (mem->own)
The_Device_Arena()->free(mem->ptr);
} else if (mem->type == SUNMEMTYPE_PINNED) {
if (mem->own)
The_Pinned_Arena()->free(mem->ptr);
} else {
return (-1);
}
free(mem);
return (0);
}
SUNMemoryHelper CloneMemoryHelper(SUNMemoryHelper)
{
return *The_SUNMemory_Helper();
}
int DestroyMemoryHelper(SUNMemoryHelper) { return (0); }
SUNMemoryHelper
CreateMemoryHelper()
{
SUNMemoryHelper helper;
helper = SUNMemoryHelper_NewEmpty();
helper->content = NULL;
helper->ops->clone = CloneMemoryHelper;
helper->ops->destroy = DestroyMemoryHelper;
helper->ops->alloc = Alloc;
helper->ops->dealloc = Dealloc;
#if defined(AMREX_USE_HIP)
helper->ops->copy = SUNMemoryHelper_Copy_Hip;
helper->ops->copyasync = SUNMemoryHelper_CopyAsync_Hip;
#elif defined(AMREX_USE_CUDA)
helper->ops->copy = SUNMemoryHelper_Copy_Cuda;
helper->ops->copyasync = SUNMemoryHelper_CopyAsync_Cuda;
#endif
return helper;
}
bool initialized = false;
MemoryHelper* the_sunmemory_helper = nullptr;
} // namespace
MemoryHelper::MemoryHelper() : helper(CreateMemoryHelper()) {}
MemoryHelper::~MemoryHelper()
{
// if (helper->content) {} <--- need to free content only if the field is used
if (helper->ops)
free(helper->ops);
free(helper);
}
void
MemoryHelper::Initialize()
{
if (initialized)
return;
initialized = true;
BL_ASSERT(the_sunmemory_helper == nullptr);
the_sunmemory_helper = new MemoryHelper();
}
void
MemoryHelper::Finalize()
{
initialized = false;
delete the_sunmemory_helper;
the_sunmemory_helper = nullptr;
}
MemoryHelper*
The_SUNMemory_Helper()
{
BL_ASSERT(the_sunmemory_helper != nullptr);
return the_sunmemory_helper;
}
} // namespace sundials
} // namespace amrex
| 21.589928
| 80
| 0.695102
|
wjge
|
c84e7eeea51b7b82d21e2344707891582bf1083e
| 697
|
cpp
|
C++
|
gym/index20_29/ioi2021_25/JI.cpp
|
daklqw/IOI2021-training
|
4f21cef8eec47330e3db77a3d90cbe2309fa8294
|
[
"Apache-2.0"
] | 6
|
2020-10-12T05:07:03.000Z
|
2021-09-11T14:54:58.000Z
|
gym/index20_29/ioi2021_25/JI.cpp
|
daklqw/IOI2021-training
|
4f21cef8eec47330e3db77a3d90cbe2309fa8294
|
[
"Apache-2.0"
] | null | null | null |
gym/index20_29/ioi2021_25/JI.cpp
|
daklqw/IOI2021-training
|
4f21cef8eec47330e3db77a3d90cbe2309fa8294
|
[
"Apache-2.0"
] | 2
|
2021-02-09T02:06:31.000Z
|
2021-10-06T01:25:08.000Z
|
#include <bits/stdc++.h>
const int MAXN = 2e5 + 10;
int A[MAXN], n;
int f[MAXN], g[MAXN];
void solve(int * f) {
static int st[MAXN];
memset(st, 0x3f, n << 2);
int top = 0;
for (int i = 1; i <= n; ++i) {
int * at = std::upper_bound(st, st + top, A[i]);
f[i] = (at - st) + 1;
*at = std::min(*at, A[i]);
top = std::max<int>(top, at - st + 1);
}
}
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
std::cin >> n;
for (int i = 1, t; i <= n; ++i)
std::cin >> t, A[t] = i;
solve(f);
std::reverse(A + 1, A + 1 + n);
solve(g);
int ans = 0;
for (int i = 1; i <= n; ++i)
ans = std::max(f[i] + g[n - i + 1] - 1, ans);
std::cout << ans << std::endl;
return 0;
}
| 21.78125
| 56
| 0.497848
|
daklqw
|
c84f2616ebd8e69e8bbae5de0ab78e92ebab007f
| 17,869
|
cpp
|
C++
|
ukmarsbot-basic-follower/commands.cpp
|
micromouseonline/ukmarsbot-line-follower-basic
|
b4030c358f4a316d4089f8e27afda02d78e7544f
|
[
"MIT"
] | null | null | null |
ukmarsbot-basic-follower/commands.cpp
|
micromouseonline/ukmarsbot-line-follower-basic
|
b4030c358f4a316d4089f8e27afda02d78e7544f
|
[
"MIT"
] | null | null | null |
ukmarsbot-basic-follower/commands.cpp
|
micromouseonline/ukmarsbot-line-follower-basic
|
b4030c358f4a316d4089f8e27afda02d78e7544f
|
[
"MIT"
] | 1
|
2021-12-21T15:48:01.000Z
|
2021-12-21T15:48:01.000Z
|
#include "commands.h"
#include "cli.h"
#include "digitalWriteFast.h"
#include "encoders.h"
#include "motors.h"
#include "profile.h"
#include "sensors.h"
#include "settings.h"
#include "streaming.h"
#include "systick.h"
#include "twiddle.h"
#include <arduino.h>
#include <util/atomic.h>
void cmdFilter(float f) {
float iirOut[2];
float angle = 2 * 3.14159 * f / 500;
float alpha = 0.995;
float pole[2];
pole[0] = cos(angle) * alpha;
pole[1] = sin(angle) * alpha;
uint32_t t = millis();
while (!functionButtonPressed()) {
while (t == millis()) {
// do nothing
}
t = millis();
float out[2];
out[0] = iirOut[0] * pole[0] - iirOut[1] * pole[1] + getSensor(0);
out[1] = iirOut[0] * pole[1] - iirOut[1] * pole[0];
iirOut[0] = out[0];
iirOut[1] = out[1];
float mag = out[0] * out[0] + out[1] * out[1];
Serial.println(mag, 4);
}
}
void cmdLineCalibrate(Args &args) {
sensorsEnable();
fwd.reset();
rot.reset();
motor_controllers_enabled = true;
rot.start_move(360.0, 300.0, 0.0, 1000.0);
int angle = -1;
int a;
while (rot.mState != Profile::FINISHED) {
a = int(rot.mPosition);
if (a != angle) {
angle = a;
Serial << _JUSTIFY(angle, 5);
sensorsShow();
}
}
motor_controllers_enabled = false;
stop_motors();
sensorsDisable();
}
//////////////////////////////////////////////////////////////////////
void sendWallCalHeader() {
Serial.println();
Serial.println(F("time position Left Right Front Ctrl Error "));
}
void sendWallCalTelemetry(uint32_t t, float error) {
int posNow = int(fwd.mPosition);
// send it at leisure
Serial.print(t);
Serial.print(' ');
Serial.print(posNow);
Serial.print(' ');
Serial.print(gSensorLeftWall);
Serial.print(' ');
Serial.print(gSensorRightWall);
Serial.print(' ');
Serial.print(gSensorFrontWall);
Serial.print(' ');
Serial.print(gSteeringControl);
Serial.print(' ');
Serial.print(gSensorCTE);
Serial.print(' ');
Serial.print(rot.mCurrentSpeed);
Serial.println();
}
void cmdWallCalibrate(Args &args) {
uint32_t t = millis();
float topSpeed = 500;
float accel = 2000;
if (args.argc > 1) {
topSpeed = atof(args.argv[1]);
}
if (args.argc > 2) {
accel = atof(args.argv[2]);
}
sendWallCalHeader();
sensorsEnable();
fwd.reset();
rot.reset();
motor_controllers_enabled = true;
steeringReset();
gSteeringEnabled = true;
fwd.start_move(7 * 180.0, topSpeed, 0.0, accel);
while (not(fwd.is_finished())) {
sendWallCalTelemetry(millis() - t, 1);
}
gSteeringEnabled = false;
uint32_t t2 = millis() - t;
spin(180);
gSteeringEnabled = true;
t = millis();
fwd.start_move(7 * 180.0, topSpeed, 0, accel);
while (not(fwd.is_finished())) {
sendWallCalTelemetry(millis() - t + t2, 1);
}
gSteeringEnabled = false;
spin(-180);
// fwd.make_move(150,500,0,2000);
motor_controllers_enabled = false;
stop_motors();
sensorsDisable();
}
///////////////////////////////////////////////////////////////////////
void cmdShowFront(Args &args) {
}
void cmdShowLeft(Args &args) {
}
void cmdShowRight(Args &args) {
}
void cmdShowBattery(Args &args) {
}
void cmdShowFunction(Args &args) {
}
void cmdShowEncoders(Args &args) {
Serial.println(F("Encoders:"));
while (true) {
Serial.print(F("Left = "));
Serial.print(encoderLeftCount);
Serial.print(F(" Right = "));
Serial.print(encoderRightCount);
Serial.print(F(" FWD = "));
Serial.print(encoderTotal);
Serial.print(F(" ROT = "));
Serial.print(encoderRotation);
Serial.println();
if (functionButtonPressed()) {
break;
}
}
}
/**
* Open loop forward motion test
* Move the robot forwards or backwards by setting the motor
* voltage directly for a given time.
* During motion, data is transmitted using the serial port and
* can be collected over a Bluetooth link
* Requires that the motor controllers be disabled.
*
* Command line:
* FWD volts time
*
* where time is in milliseconds
* e.g. FWD 4.5 1000 => implies left = +4.5V, right = -4.5V, 1200ms run
*/
void cmdTestFwd(Args &args) {
uint32_t endTime = 1000;
int volts = 3;
if (args.argc > 1) {
volts = atoi(args.argv[1]);
}
if (args.argc > 2) {
endTime = atol(args.argv[2]);
}
encoderReset();
Serial.println(F("time(ms), encSpeed, encPos"));
set_left_motor_volts(volts);
set_right_motor_volts(volts);
uint32_t t = millis();
endTime += t;
while (millis() < endTime) {
// gather the data quickly
float spd = encoderSpeed;
float pos = encoderPosition;
// send it at leisure
Serial.print(millis() - t);
Serial.print(' ');
Serial.print(spd, 4);
Serial.print(' ');
Serial.print(pos, 4);
Serial.println();
}
stop_motors();
}
enum { IDLE,
STARTING,
RUNNING,
STOPPING,
CROSSING };
void sendLineHeader() {
Serial.println();
Serial.println(F("time position Start Left Right Turn Error FastError rawError"));
}
void sendLineTelemetry(uint32_t t, float error) {
int posNow = int(fwd.mPosition);
// send it at leisure
Serial.print(t);
Serial.print(' ');
Serial.print(posNow);
Serial.print(' ');
Serial.print(getSensor(0));
Serial.print(' ');
Serial.print(getSensor(1));
Serial.print(' ');
Serial.print(getSensor(2));
Serial.print(' ');
Serial.print(getSensor(3));
Serial.print(' ');
Serial.print(gSteeringControl);
Serial.print(' ');
Serial.print(error);
Serial.println();
}
float lineTrial() {
encoderReset();
sensorsEnable();
steeringReset();
fwd.reset();
rot.reset();
motor_controllers_enabled = true;
gSteeringEnabled = true;
gSteeringControl = 0;
uint32_t trigger = millis();
float errorSum = 0;
uint32_t startTime = millis();
fwd.start_move(500, 500, 500, 4000);
enum {
IDLE,
STARTING,
RUNNING,
STOPPING,
};
int runState = STARTING;
digitalWrite(LED_LEFT, 0);
digitalWrite(LED_RIGHT, 0);
float error = 0;
float slowFilter = 0;
while (runState != STOPPING) {
uint8_t markers = startMarker() + 2 * turnMarker();
digitalWrite(LED_RIGHT, markers & 2);
digitalWrite(LED_LEFT, markers & 1);
switch (runState) {
case STARTING:
if (markers == 3) {
runState = CROSSING;
}
break;
case CROSSING:
if (markers == 0) {
runState = RUNNING;
}
break;
case RUNNING:
if (markers == 3) {
runState = STOPPING;
}
break;
}
if (fwd.mPosition > 2520) {
runState = STOPPING;
}
if (millis() > trigger) {
trigger += 5;
if (functionButtonPressed()) {
runState = STOPPING;
}
slowFilter += 0.3 * (gSteeringControl - slowFilter);
error = fabsf(slowFilter - gSteeringControl);
errorSum += error;
// sendLineTelemetry(millis() - startTime, error);
}
}
while (functionButtonPressed()) {
}
Serial.print(F("\nError Sum: "));
Serial.print(errorSum);
Serial.println('\n');
sensorsDisable();
stop_motors();
delay(250);
motor_controllers_enabled = false;
gSteeringEnabled = false;
return errorSum;
}
void cmdTestTwiddle(Args &args) {
setup_motor_controllers();
float *params[2] = {&settings.lineKP, &settings.lineKD};
Serial.print(*params[0], 6);
Serial.print(" ");
Serial.print(*params[1], 6);
Serial.print(" ");
Twiddle tw(2, params, lineTrial);
Serial.println("TWIDDLING");
tw.go();
}
float cmdFollowLine(Args &args) {
float speed = 500;
if (args.argc > 1) {
speed = atof(args.argv[1]);
}
if (args.argc > 2) {
settings.lineKP = atof(args.argv[2]);
}
if (args.argc > 3) {
settings.lineKD = atof(args.argv[3]);
}
Serial.print(F("\"Line follower kD: "));
Serial.print(settings.lineKP);
Serial.print(F(" kD: "));
Serial.print(settings.lineKD);
Serial.print(F(" speed: "));
Serial.print(speed);
Serial.print(F("\""));
sendLineHeader();
encoderReset();
steeringReset();
sensorsEnable();
fwd.reset();
rot.reset();
gSteeringControl = 0;
gSteeringEnabled = true;
motor_controllers_enabled = true;
uint32_t trigger = millis();
float errorSum = 0;
uint32_t startTime = millis();
fwd.start_move(500, speed, speed, 4000);
int runState = STARTING;
digitalWrite(LED_LEFT, 0);
digitalWrite(LED_RIGHT, 0);
float error = 0;
float slowFilter = 0;
while (runState != STOPPING) {
uint8_t markers = startMarker() + 2 * turnMarker();
digitalWrite(LED_RIGHT, markers & 2);
digitalWrite(LED_LEFT, markers & 1);
switch (runState) {
case STARTING:
if (markers == 3) {
runState = CROSSING;
}
break;
case CROSSING:
if (markers == 0) {
runState = RUNNING;
}
break;
case RUNNING:
if (markers == 3) {
runState = STOPPING;
}
break;
}
if (fwd.mPosition > 2520) {
runState = STOPPING;
}
if (millis() > trigger) {
trigger += 5;
if (functionButtonPressed()) {
runState = STOPPING;
}
slowFilter += 0.3 * (gSteeringControl - slowFilter);
error = fabsf(slowFilter - gSteeringControl);
errorSum += error;
sendLineTelemetry(millis() - startTime, error);
}
}
while (functionButtonPressed()) {
}
Serial.print(F("\n==========================\n\nError Sum: \""));
Serial.print(errorSum);
Serial.println(F("\"\n"));
sensorsDisable();
stop_motors();
motor_controllers_enabled = false;
delay(250);
gSteeringEnabled = false;
return errorSum;
}
/**
* Open loop rotational motion test
* Rotates the robot left (+ve) or right (-ve) by setting the motor
* voltage directly for a given time.
* During motion, data is transmitted using the serial port and
* can be collected over a Bluetoth link
* Requires that the motor controllers be disabled.
*
* Command line:
* ROT volts time
*
* where time is in milliseconds
* e.g. FWD 1200 4.5
*/
void cmdTestRot(Args &args) {
uint32_t endTime = 1500;
int volts = 3;
if (args.argc > 1) {
volts = atoi(args.argv[2]);
}
if (args.argc > 2) {
endTime = atol(args.argv[1]);
}
encoderReset();
set_left_motor_volts(-volts);
set_right_motor_volts(+volts);
uint32_t t = millis();
endTime += t;
while (millis() < endTime) {
// gather the data quickly
float spd = encoderOmega;
float pos = encoderAngle;
// send it at leisure
Serial.print(millis() - t);
Serial.print(' ');
Serial.print(spd, 4);
Serial.print(' ');
Serial.print(pos, 4);
Serial.println();
}
stop_motors();
}
void sendProfileHeader() {
Serial.println(F("time setPos setSpeed actPos actSpeed encAngle encOmega LeftVolts RightVolts"));
}
void sendProfileData(int timeStamp, Profile &prof) {
// gather the data quickly for consistency
float setPos;
float setSpeed;
float actPos;
float actSpeed;
float actAngle;
float actOmega;
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
setSpeed = prof.mCurrentSpeed;
setPos = prof.mPosition;
actPos = encoderPosition;
actSpeed = encoderSpeed;
actAngle = encoderAngle;
actOmega = encoderOmega;
}
// send it at leisure
Serial.print(timeStamp);
Serial.print(' ');
Serial.print(setPos);
Serial.print(' ');
Serial.print(setSpeed);
Serial.print(' ');
Serial.print(actPos);
Serial.print(' ');
Serial.print(actSpeed);
Serial.print(' ');
Serial.print(actAngle);
Serial.print(' ');
Serial.print(actOmega);
Serial.print(' ');
Serial.print(fwd_controller.output());
Serial.print(' ');
Serial.print(rot_controller.output());
Serial.println();
}
void cmdTestMove(Args &args) {
uint32_t t = millis();
float dist = atof(args.argv[1]);
float topSpeed = atof(args.argv[2]);
float endSpeed = atof(args.argv[3]);
float accel = atof(args.argv[4]);
if (dist == 0) {
dist = 400;
}
if (topSpeed == 0) {
topSpeed = 400;
}
if (accel == 0) {
accel = 2000;
}
delay(500);
sendProfileHeader();
encoderReset();
sensorsEnable();
fwd.reset();
rot.reset();
fwd_controller.Initialize();
rot_controller.Initialize();
motor_controllers_enabled = true;
t = millis();
fwd.start_move(dist, topSpeed, endSpeed, accel);
while (fwd.mState != Profile::FINISHED) {
sendProfileData(millis() - t, fwd);
}
motor_controllers_enabled = false;
stop_motors();
sensorsDisable();
Serial.println();
}
void cmdTestMotors(Args &args) {
float leftVolts = atof(args.argv[1]);
float rightVolts = atof(args.argv[2]);
encoderReset();
fwd.reset();
rot.reset();
set_left_motor_volts(leftVolts);
set_right_motor_volts(rightVolts);
while (true) {
Serial.print(F("Left = "));
Serial.print(encoderLeftCount);
Serial.print(F(" Right = "));
Serial.print(encoderRightCount);
Serial.print(F(" FWD = "));
Serial.print(encoderTotal);
Serial.print(F(" ROT = "));
Serial.print(encoderRotation);
Serial.println();
if (functionButtonPressed()) {
break;
}
}
stop_motors();
Serial.println();
}
void cmdTestSpin(Args &args) {
uint32_t t = millis();
float dist = atof(args.argv[1]);
float topSpeed = atof(args.argv[2]);
float endSpeed = atof(args.argv[3]);
float accel = atof(args.argv[4]);
if (dist == 0) {
dist = 360;
}
if (topSpeed == 0) {
topSpeed = 400;
}
if (accel == 0) {
accel = 1500;
}
sendProfileHeader();
encoderReset();
sensorsEnable();
fwd.reset();
rot.reset();
motor_controllers_enabled = true;
rot.start_move(dist, topSpeed, endSpeed, accel);
while (rot.mState != Profile::FINISHED) {
sendProfileData(millis() - t, rot);
}
motor_controllers_enabled = false;
stop_motors();
sensorsDisable();
Serial.println();
}
void cmdTestTurn(Args &args) {
uint32_t t = millis();
float dist = atof(args.argv[1]);
float speed = atof(args.argv[2]);
float omega = atof(args.argv[3]);
float alpha = atof(args.argv[4]);
if (dist == 0) {
dist = 360;
}
if (speed == 0) {
speed = 500;
}
if (omega == 0) {
omega = 500;
}
if (alpha == 0) {
alpha = 5000;
}
sendProfileHeader();
gSteeringEnabled = false;
encoderReset();
fwd.reset();
rot.reset();
motor_controllers_enabled = true;
fwd.start_move(300, speed, speed, 2500);
while (!fwd.is_finished()) {
}
rot.start_move(dist, omega, 0, alpha);
while (rot.mState != Profile::FINISHED) {
sendProfileData(millis() - t, rot);
}
fwd.start_move(300, speed, 0, 2500);
while (!fwd.is_finished()) {
}
motor_controllers_enabled = false;
stop_motors();
Serial.println();
}
void cmdSearch() {
encoderReset();
fwd.reset();
rot.reset();
motor_controllers_enabled = true;
sensorsEnable();
gSteeringControl = 0;
gSteeringEnabled = true;
bool finished = false;
Serial.println(F("START"));
while (not(finished)) {
goHalfCell(false);
// sensors can be checked here.
if (not(gLeftWall)) {
Serial.println(F("LEFT"));
goHalfCell(true);
spin(90);
} else if (not(gFrontWall)) {
Serial.println(F("FWD"));
goHalfCell(false);
} else if (not(gRightWall)) {
Serial.println(F("RIGHT"));
goHalfCell(true);
spin(-90);
} else {
Serial.println(F("???"));
goHalfCell(true);
spin(180);
}
}
sensorsDisable();
motor_controllers_enabled = false;
stop_motors();
}
void turnLeft() {
bool savedSteering = gSteeringEnabled;
gSteeringEnabled = false;
fwd.make_move(90, SEARCH_SPEED, 0, SEARCH_ACCEL);
spin(90);
steeringReset();
gSteeringEnabled = savedSteering;
fwd.make_move(90, SEARCH_SPEED, SEARCH_SPEED, SEARCH_ACCEL);
}
void turnRight() {
bool savedSteering = gSteeringEnabled;
gSteeringEnabled = false;
fwd.make_move(90, SEARCH_SPEED, 0, SEARCH_ACCEL);
spin(-90);
steeringReset();
gSteeringEnabled = savedSteering;
fwd.make_move(90, SEARCH_SPEED, SEARCH_SPEED, SEARCH_ACCEL);
}
void turnAround() {
bool savedSteering = gSteeringEnabled;
gSteeringEnabled = false;
fwd.start_move(90, SEARCH_SPEED, 0, SEARCH_ACCEL);
stop_motors();
delay(25);
spin(-(330.0 / 2));
steeringReset();
gSteeringEnabled = savedSteering;
fwd.make_move(90, SEARCH_SPEED, SEARCH_SPEED, SEARCH_ACCEL);
}
void cmdFollowWall() {
encoderReset();
fwd.reset();
rot.reset();
motor_controllers_enabled = true;
sensorsEnable();
gSteeringControl = 0;
gSteeringEnabled = true;
bool finished = false;
Serial.println(F("START"));
fwd.make_move(90.0, SEARCH_SPEED, SEARCH_SPEED, SEARCH_ACCEL);
while (not(finished)) {
if (not(gLeftWall)) {
Serial.print(F("turn"));
turnLeft();
Serial.println(F(" left"));
} else if (not(gRightWall)) {
Serial.print(F("turn "));
turnRight();
Serial.println(F(" right"));
} else if (gSensorFrontWall > 25) {
Serial.print(F("turn "));
turnAround();
Serial.println(F(" around"));
} else {
fwd.make_move(180.0, SEARCH_SPEED, SEARCH_SPEED, SEARCH_ACCEL);
}
}
sensorsDisable();
motor_controllers_enabled = false;
stop_motors();
}
/***
* smooth turn the robot left or right by 90 degrees
*/
void turn(const int direction){
};
/***
* spin turn the robot left or right by 90 degrees on the spot
*/
void spin(const float angle) {
bool savedSteering = gSteeringEnabled;
gSteeringEnabled = false;
rot.start_move(angle, 360.0, 0.0, 1200.0);
while (rot.mState != Profile::FINISHED) {
}
steeringReset();
gSteeringEnabled = savedSteering;
};
void goHalfCell(const bool stopAtEnd) {
if (stopAtEnd) {
fwd.start_move(90.0, SEARCH_SPEED, 0.0, 1500.0);
} else {
fwd.start_move(90.0, SEARCH_SPEED, SEARCH_SPEED, 1500.0);
}
while (fwd.mState != Profile::FINISHED) {
delay(1);
}
};
| 23.793609
| 99
| 0.624825
|
micromouseonline
|
c8504be6512b56ac5925669bccb70d0702e43bae
| 460
|
cpp
|
C++
|
codeforces/802G.cpp
|
sgrade/cpptest
|
84ade6ec03ea394d4a4489c7559d12b4799c0b62
|
[
"MIT"
] | null | null | null |
codeforces/802G.cpp
|
sgrade/cpptest
|
84ade6ec03ea394d4a4489c7559d12b4799c0b62
|
[
"MIT"
] | null | null | null |
codeforces/802G.cpp
|
sgrade/cpptest
|
84ade6ec03ea394d4a4489c7559d12b4799c0b62
|
[
"MIT"
] | null | null | null |
// G. Fake News (easy)
#include <iostream>
#include <string>
using namespace std;
int main() {
string s;
cin >> s;
bool ans = false;
int n = size(s);
string fake = "heidi";
int j = 0;
for (int i = 0; i < n; ++i) {
if (s[i] == fake[j]) {
++j;
}
if (j == 5) {
ans = true;
break;
}
}
cout << (ans ? "YES" : "NO") << endl;
return 0;
}
| 12.432432
| 41
| 0.384783
|
sgrade
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.