blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 3 264 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2 values | repo_name stringlengths 5 140 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 905 values | visit_date timestamp[us]date 2015-08-09 11:21:18 2023-09-06 10:45:07 | revision_date timestamp[us]date 1997-09-14 05:04:47 2023-09-17 19:19:19 | committer_date timestamp[us]date 1997-09-14 05:04:47 2023-09-06 06:22:19 | github_id int64 3.89k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 22 values | gha_event_created_at timestamp[us]date 2012-06-07 00:51:45 2023-09-14 21:58:39 ⌀ | gha_created_at timestamp[us]date 2008-03-27 23:40:48 2023-08-21 23:17:38 ⌀ | gha_language stringclasses 141 values | src_encoding stringclasses 34 values | language stringclasses 1 value | is_vendor bool 1 class | is_generated bool 2 classes | length_bytes int64 3 10.4M | extension stringclasses 115 values | content stringlengths 3 10.4M | authors listlengths 1 1 | author_id stringlengths 0 158 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
d81cb1f3c53425c1faf310caf842ba3aeb8de74b | 5b9fb483017ea3f8bced15680936b932298413cc | /Source/UnrealEnginePython/Private/Slate/UEPyFGeometry.cpp | 3ff99de542dec75533ab3818a75ab9603b1e092f | [
"MIT"
] | permissive | cuigrey/UnrealEnginePython | e7be876557158c48084d1eaa3584b554b55243de | 4d38ba61c32682b0e9596824b906561f846178a5 | refs/heads/master | 2021-01-19T16:40:52.815381 | 2017-08-21T15:19:40 | 2017-08-21T15:19:40 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,554 | cpp | #include "UnrealEnginePythonPrivatePCH.h"
#include "UEPyFGeometry.h"
static PyObject *py_ue_fgeometry_get_local_size(ue_PyFGeometry *self, PyObject * args) {
FVector2D size = self->geometry.GetLocalSize();
return Py_BuildValue("(ff)", size.X, size.Y);
}
static PyMethodDef ue_PyFGeometry_methods[] = {
{ "get_local_size", (PyCFunction)py_ue_fgeometry_get_local_size, METH_VARARGS, "" },
{ NULL } /* Sentinel */
};
static PyObject *ue_PyFGeometry_str(ue_PyFGeometry *self)
{
return PyUnicode_FromFormat("<unreal_engine.FGeometry '%s'>",
TCHAR_TO_UTF8(*self->geometry.ToString()));
}
static PyTypeObject ue_PyFGeometryType = {
PyVarObject_HEAD_INIT(NULL, 0)
"unreal_engine.FGeometry", /* tp_name */
sizeof(ue_PyFGeometry), /* tp_basicsize */
0, /* tp_itemsize */
0, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_reserved */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
(reprfunc)ue_PyFGeometry_str, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
"Unreal Engine FGeometry", /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
ue_PyFGeometry_methods, /* tp_methods */
};
void ue_python_init_fgeometry(PyObject *ue_module) {
ue_PyFGeometryType.tp_new = PyType_GenericNew;
if (PyType_Ready(&ue_PyFGeometryType) < 0)
return;
Py_INCREF(&ue_PyFGeometryType);
PyModule_AddObject(ue_module, "FGeometry", (PyObject *)&ue_PyFGeometryType);
}
ue_PyFGeometry *py_ue_is_fgeometry(PyObject *obj) {
if (!PyObject_IsInstance(obj, (PyObject *)&ue_PyFGeometryType))
return nullptr;
return (ue_PyFGeometry *)obj;
}
PyObject *py_ue_new_fgeometry(FGeometry geometry) {
ue_PyFGeometry *ret = (ue_PyFGeometry *)PyObject_New(ue_PyFGeometry, &ue_PyFGeometryType);
ret->geometry = geometry;
return (PyObject *)ret;
}
| [
"roberto@20tab.com"
] | roberto@20tab.com |
113f4dd487e88e61be4201c8aaa6771b226228e5 | 4d381bf60f506902627065d7f6de5cc0189ca222 | /tetris/T.cpp | a3c3c26342ba84e266861c784f0fdf9889b212a8 | [] | no_license | batzionko/tetrisProject | 1ef5ec96b063ca26d702b2d25d8c59d3bb6a360d | 4b357236a8dca2df09d154468d587da3065d6f66 | refs/heads/master | 2020-03-19T00:18:26.789539 | 2018-05-30T16:49:21 | 2018-05-30T16:49:21 | 135,471,204 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 783 | cpp | #include "T.h"
T::T(sf::Texture& t, int colorNum, sf::Vector2f pos):
Shapes(pos)
{
std::for_each(begin(m_square), end(m_square), [&t, &colorNum](square& s) { s.setTexture(t, colorNum); });
setPosition(m_pos);
m_square[0].setTheOrigin(sf::Vector2f(S_SIZE * 0.5, S_SIZE* 0.5));
m_square[1].setTheOrigin(sf::Vector2f(S_SIZE * 0.5, S_SIZE* 1.5));
m_square[2].setTheOrigin(sf::Vector2f(S_SIZE * 1.5, S_SIZE * 0.5));
m_square[3].setTheOrigin(sf::Vector2f(-S_SIZE * 0.5, S_SIZE * 0.5));
}
T::~T()
{
}
//---------------------------
void T::setPosition(sf::Vector2f pos) {
m_square[0].setLocation(pos);
std::for_each(begin(m_square), end(m_square), [&pos](square& s) { s.setPosition(pos); });
}
//-------------------------
//-----------------------------------------
| [
"sarazo@LAB6_4"
] | sarazo@LAB6_4 |
d21a251d92636fb91d17e88ac7a80b003341b478 | 5d7d74570f37e0c4aa4a61edbd29f453a56a8d4c | /3rdparty/arpack++/include/arlgcomp.h | 1d26965af84e84077e66edc0705b974241cfa7f9 | [] | no_license | fanxiaochen/Point-Set-Registration | 9ff84f57046df788829854a0dd3f678884bd354b | fa3f3070a245f8e6eb95596edc4b8595f93515e6 | refs/heads/master | 2016-09-05T20:23:17.736878 | 2015-08-11T16:47:14 | 2015-08-11T16:47:14 | 39,198,189 | 8 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 5,714 | h | /*
ARPACK++ v1.2 2/20/2000
c++ interface to ARPACK code.
MODULE ARLGComp.h.
Arpack++ class ARluCompGenEig definition
(superlu version).
ARPACK Authors
Richard Lehoucq
Danny Sorensen
Chao Yang
Dept. of Computational & Applied Mathematics
Rice University
Houston, Texas
*/
#ifndef ARLGCOMP_H
#define ARLGCOMP_H
#include <stddef.h>
#include "arch.h"
#include "arlnsmat.h"
#include "arlnspen.h"
#include "arrseig.h"
#include "argcomp.h"
template<class ARFLOAT>
class ARluCompGenEig:
public virtual
ARCompGenEig<ARFLOAT, ARluNonSymPencil<arcomplex<ARFLOAT>, ARFLOAT >,
ARluNonSymPencil<arcomplex<ARFLOAT>, ARFLOAT > > {
private:
// a) Data structure used to store matrices.
ARluNonSymPencil<arcomplex<ARFLOAT>, ARFLOAT > Pencil;
// b) Protected functions:
virtual void Copy(const ARluCompGenEig& other);
// Makes a deep copy of "other" over "this" object.
// Old values are not deleted (this function is to be used
// by the copy constructor and the assignment operator only).
public:
// c) Public functions:
// c.1) Functions that allow changes in problem parameters.
virtual void ChangeShift(arcomplex<ARFLOAT> sigmap);
virtual void SetRegularMode();
virtual void SetShiftInvertMode(arcomplex<ARFLOAT> sigmap);
// c.2) Constructors and destructor.
ARluCompGenEig() { }
// Short constructor.
ARluCompGenEig(int nevp, ARluNonSymMatrix<arcomplex<ARFLOAT>, ARFLOAT>& A,
ARluNonSymMatrix<arcomplex<ARFLOAT>, ARFLOAT>& B,
char* whichp = "LM", int ncvp = 0,
ARFLOAT tolp = 0.0, int maxitp = 0,
arcomplex<ARFLOAT>* residp = NULL, bool ishiftp = true);
// Long constructor (regular mode).
ARluCompGenEig(int nevp, ARluNonSymMatrix<arcomplex<ARFLOAT>, ARFLOAT>& A,
ARluNonSymMatrix<arcomplex<ARFLOAT>, ARFLOAT>& B,
arcomplex<ARFLOAT> sigma, char* whichp = "LM",
int ncvp = 0, ARFLOAT tolp = 0.0, int maxitp = 0,
arcomplex<ARFLOAT>* residp = NULL, bool ishiftp = true);
// Long constructor (shift and invert mode).
ARluCompGenEig(const ARluCompGenEig& other) { Copy(other); }
// Copy constructor.
virtual ~ARluCompGenEig() { }
// d) Operators.
ARluCompGenEig& operator=(const ARluCompGenEig& other);
// Assignment operator.
}; // class ARluCompGenEig.
// ------------------------------------------------------------------------ //
// ARluCompGenEig member functions definition. //
// ------------------------------------------------------------------------ //
template<class ARFLOAT>
inline void ARluCompGenEig<ARFLOAT>::
Copy(const ARluCompGenEig<ARFLOAT>& other)
{
ARCompGenEig<ARFLOAT, ARluNonSymPencil<arcomplex<ARFLOAT>, ARFLOAT >,
ARluNonSymPencil<arcomplex<ARFLOAT>, ARFLOAT> >:: Copy(other);
Pencil = other.Pencil;
objOP = &Pencil;
objB = &Pencil;
if (mode > 2) objOP->FactorAsB(sigmaR);
} // Copy.
template<class ARFLOAT>
inline void ARluCompGenEig<ARFLOAT>::ChangeShift(arcomplex<ARFLOAT> sigmap)
{
objOP->FactorAsB(sigmap);
ARrcStdEig<ARFLOAT, arcomplex<ARFLOAT> >::ChangeShift(sigmap);
} // ChangeShift.
template<class ARFLOAT>
inline void ARluCompGenEig<ARFLOAT>::SetRegularMode()
{
ARStdEig<ARFLOAT, arcomplex<ARFLOAT>,
ARluNonSymPencil<arcomplex<ARFLOAT>, ARFLOAT> >::
SetRegularMode(&Pencil,
&ARluNonSymPencil<arcomplex<ARFLOAT>, ARFLOAT>::MultInvBAv);
} // SetRegularMode.
template<class ARFLOAT>
inline void ARluCompGenEig<ARFLOAT>::
SetShiftInvertMode(arcomplex<ARFLOAT> sigmap)
{
ARCompGenEig<ARFLOAT, ARluNonSymPencil<arcomplex<ARFLOAT>, ARFLOAT>,
ARluNonSymPencil<arcomplex<ARFLOAT>, ARFLOAT> >::
SetShiftInvertMode(sigmap, &Pencil,
&ARluNonSymPencil<arcomplex<ARFLOAT>,ARFLOAT>::MultInvAsBv);
} // SetShiftInvertMode.
template<class ARFLOAT>
inline ARluCompGenEig<ARFLOAT>::
ARluCompGenEig(int nevp, ARluNonSymMatrix<arcomplex<ARFLOAT>, ARFLOAT>& A,
ARluNonSymMatrix<arcomplex<ARFLOAT>, ARFLOAT>& B, char* whichp,
int ncvp, ARFLOAT tolp, int maxitp,
arcomplex<ARFLOAT>* residp, bool ishiftp)
{
Pencil.DefineMatrices(A, B);
NoShift();
DefineParameters(A.ncols(), nevp, &Pencil,
&ARluNonSymPencil<arcomplex<ARFLOAT>, ARFLOAT>::MultInvBAv,
&Pencil,
&ARluNonSymPencil<arcomplex<ARFLOAT>, ARFLOAT>::MultBv,
whichp, ncvp, tolp, maxitp, residp, ishiftp);
} // Long constructor (regular mode).
template<class ARFLOAT>
inline ARluCompGenEig<ARFLOAT>::
ARluCompGenEig(int nevp, ARluNonSymMatrix<arcomplex<ARFLOAT>, ARFLOAT>& A,
ARluNonSymMatrix<arcomplex<ARFLOAT>, ARFLOAT>& B,
arcomplex<ARFLOAT> sigmap, char* whichp, int ncvp,
ARFLOAT tolp, int maxitp, arcomplex<ARFLOAT>* residp,
bool ishiftp)
{
Pencil.DefineMatrices(A, B);
DefineParameters(A.ncols(), nevp, &Pencil,
&ARluNonSymPencil<arcomplex<ARFLOAT>, ARFLOAT>::MultInvAsBv,
&Pencil,
&ARluNonSymPencil<arcomplex<ARFLOAT>, ARFLOAT>::MultBv,
whichp, ncvp, tolp, maxitp, residp, ishiftp);
SetShiftInvertMode(sigmap);
} // Long constructor (shift and invert mode).
template<class ARFLOAT>
ARluCompGenEig<ARFLOAT>& ARluCompGenEig<ARFLOAT>::
operator=(const ARluCompGenEig<ARFLOAT>& other)
{
if (this != &other) { // Stroustrup suggestion.
ClearMem();
Copy(other);
}
return *this;
} // operator=.
#endif // ARLGCOMP_H
| [
"fan.daybreak@gmail.com"
] | fan.daybreak@gmail.com |
fc2c84f3287aa7219f35b6c124a6d7ee98e97ce3 | 00966c983022f7853d25cf873d65751f3fc646e1 | /AbilitySystem/Ability/Source/Ability/AbilityProjectile.h | 8082e85a0abd20bb6e1ee132d4fa9ac9951146ef | [] | no_license | ultratroll/coop | a64b787845b95618c9e5adeed65f147c2909114a | cd931fcb71dd46d42ebbaebc16a414cbc705a064 | refs/heads/master | 2021-07-08T12:37:48.928397 | 2019-01-30T22:39:59 | 2019-01-30T22:39:59 | 137,826,179 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,111 | h | // Copyright 1998-2018 Epic Games, Inc. All Rights Reserved.
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "AbilityProjectile.generated.h"
UCLASS(config=Game)
class AAbilityProjectile : public AActor
{
GENERATED_BODY()
/** Sphere collision component */
UPROPERTY(VisibleDefaultsOnly, Category=Projectile)
class USphereComponent* CollisionComp;
/** Projectile movement component */
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Movement, meta = (AllowPrivateAccess = "true"))
class UProjectileMovementComponent* ProjectileMovement;
public:
AAbilityProjectile();
/** called when projectile hits something */
UFUNCTION()
void OnHit(UPrimitiveComponent* HitComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, FVector NormalImpulse, const FHitResult& Hit);
/** Returns CollisionComp subobject **/
FORCEINLINE class USphereComponent* GetCollisionComp() const { return CollisionComp; }
/** Returns ProjectileMovement subobject **/
FORCEINLINE class UProjectileMovementComponent* GetProjectileMovement() const { return ProjectileMovement; }
};
| [
"jdejesus@teravisiongames.com"
] | jdejesus@teravisiongames.com |
c015634469b4c951689f84bb1f507446c66c037d | b00c54389a95d81a22e361fa9f8bdf5a2edc93e3 | /vendor/intel/hardware/libmultidisplay/native/include/IMultiDisplayConnectionObserver.h | 2e4c363b310c4e01a9fbf022a53c449cfb18d2a2 | [] | no_license | mirek190/x86-android-5.0 | 9d1756fa7ff2f423887aa22694bd737eb634ef23 | eb1029956682072bb7404192a80214189f0dc73b | refs/heads/master | 2020-05-27T01:09:51.830208 | 2015-10-07T22:47:36 | 2015-10-07T22:47:36 | 41,942,802 | 15 | 20 | null | 2020-03-09T00:21:03 | 2015-09-05T00:11:19 | null | UTF-8 | C++ | false | false | 2,005 | h | /*
* Copyright (c) 2012-2013, Intel Corporation. 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.
*
* Author: tianyang.zhu@intel.com
*/
#ifndef __ANDROID_INTEL_IMULTIDISPLAY_CONNECTIONOBSERVER_H__
#define __ANDROID_INTEL_IMULTIDISPLAY_CONNECTIONOBSERVER_H__
#include <utils/Errors.h>
#include <utils/RefBase.h>
#include <binder/IInterface.h>
#include <display/MultiDisplayType.h>
namespace android {
namespace intel {
class IMultiDisplayConnectionObserver : public IInterface {
public:
DECLARE_META_INTERFACE(MultiDisplayConnectionObserver);
/**
* @brief update HDMI hotplug event to MDS
*
* @param connected: "true" indicate receiving a HDMI connected event @
* @return @see status_t in <utils/Errors.h>
*/
virtual status_t updateHdmiConnectionStatus(bool connected) = 0;
/**
* @brief update widi video extended mode to MDS
*
* @param connected: "true" indicate WIDI video playback is working under extended mode @
* @return @see status_t in <utils/Errors.h>
*/
virtual status_t updateWidiConnectionStatus(bool connected) = 0;
};
class BnMultiDisplayConnectionObserver : public BnInterface<IMultiDisplayConnectionObserver> {
public:
virtual status_t onTransact(uint32_t code,
const Parcel& data,
Parcel* replay,
uint32_t flags = 0);
};
}; // namespace intel
}; // namespace android
#endif
| [
"mirek190@gmail.com"
] | mirek190@gmail.com |
9954107c008551d827ace12237db6371da5b25b5 | 5ed2a97e269dced8e720cdecca912537d2308b3f | /tyvj/第07页(1600-1699)/1615fox/1615.cpp | 8c8dfca8bf8f8e9240d013ef28f6f268fa840c29 | [] | no_license | courage17340/OI | 7a81c62bf3b09c29b093979d77d68bdb8eea0e1a | 29e3914442d1334e0b1da849db4c3e942492cb7d | refs/heads/master | 2021-01-13T01:25:19.188664 | 2015-06-08T08:12:34 | 2015-06-08T08:12:34 | 32,979,121 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 475 | cpp | #include <cstdio>
const int md = 123456;
int n,f[210] = {0},p,ans;
bool pr(int x){
for (int i = 2;i * i <= x;i++) if (x % i == 0) return 0;
return 1;
}
void make(int x,int flag){
int y;
for (int i = 2;i <= x;i++) if (pr(i)){
y = x;
while (y){
y /= i;
f[i] += y * flag;
}
}
}
int main(){
scanf("%d",&n);
make(n * 2,1);
make(n + 1,-1);
make(n,-1);
ans = 1;
for (int i = 2;i <= n * 2;i++) if (f[i]) while (f[i]--) ans = ans * i % md;
printf("%d",ans);
}
| [
"courage17340@163.com"
] | courage17340@163.com |
b601c9cd833eea1def586986639ad1640782d62e | 60c820303a55f21a1521859740c854efceb0b489 | /asobi/Cpp/math/prime_number.hpp | 5d4f93d65459eac2c764692a345d17332ab40abf | [] | no_license | asobininn/asobi | 7bea40cc91c032034fc1353f482dc8ec75368b6c | 1f9b7cf3c04ef420a47175b4020e9a34b5811d4e | refs/heads/master | 2020-11-24T20:33:29.104284 | 2020-04-24T16:41:29 | 2020-04-24T16:41:29 | 221,192,522 | 1 | 0 | null | null | null | null | SHIFT_JIS | C++ | false | false | 1,399 | hpp | #pragma once
#define ASOBI_MATH_PRIME_NUMBER
#include <future>
#include <thread>
#include "isqrt.hpp"
namespace asobi {
namespace detail {
// その値について、範囲内を調べて割り切れる値があるか
template <class Int>
struct seek_prime_until_length {
bool operator ()(const Int& v, const Int&& first, const Int& last, int increment)
{
for (Int i = first; i <= last; i += increment) {
if (v % i == 0)
return false;
}
return true;
}
};
}
constexpr int SINGLE_LIMIT = 0; // シングルタスクで処理する値の最大値
// その値が素数か判定する
template <class Int>
bool is_prime_num(Int v)
{
auto task_num = std::thread::hardware_concurrency() * 2;
if (v <= 1) return false;
if (v == 2) return true;
if (v % 2 == 0) return false;
Int limit = isqrt(v) + 1;
//if (v <= SINGLE_LIMIT) {
if (false) {
return detail::seek_prime_until_length<Int>()(v, 3, limit, 2);
}
else {
std::vector<std::future<bool>> d(task_num);
for (unsigned int i = 0; i < task_num; i++) {
d[i] = std::async(std::launch::async, detail::seek_prime_until_length<Int>(), v, 3 + (i * 2), limit, task_num);
}
unsigned int result = 0;
for (unsigned int i = 0; i < task_num; i++)
result += d[i].get();
if (result < task_num)
return false;
return true;
}
}
}// namespace asobi | [
"asobininn2000@gmail.com"
] | asobininn2000@gmail.com |
90df5ea361032ebf9b3c39e1a570259968400051 | 5315da63eaf2aad52074f0cadf42654ba998dbdf | /classes_and_inheritance/Task 2/Include/Array.h | 0cc0893a0c54f0f84f3f1a4c3e52cdfd936b4b7e | [] | no_license | n1kstep/cpp-course-fs11 | f47dc2e938f86d66e9858fcb6aa753bcc1b13b3e | 2cc49a2cba86b22335ee2b93b250d71c1b3aa153 | refs/heads/main | 2023-06-17T06:05:37.004645 | 2021-07-10T13:21:15 | 2021-07-10T13:21:15 | 384,697,832 | 4 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 743 | h | #ifndef CLASSES_AND_INHERITANCE_ARRAY_H
#define CLASSES_AND_INHERITANCE_ARRAY_H
#include <iostream>
class Array {
protected:
unsigned char *m_arr;
int m_size;
const static int max_size = 100;
public:
explicit Array(int size = 0);
Array(int size, const unsigned char* arr);
Array(const Array &a);
virtual ~Array();
Array& operator=(const Array& ob);
unsigned char &operator[](int i);
const unsigned char &operator[](int i) const;
virtual void sum(const Array* a, Array* res);
friend std::ostream& operator<<(std::ostream& out, const Array& a);
friend std::istream& operator>>(std::istream& in, Array& a);
unsigned int get_size() const;
};
#endif //CLASSES_AND_INHERITANCE_ARRAY_H
| [
"nikitast.diff@gmail.com"
] | nikitast.diff@gmail.com |
ba82904be3bef5cc5bc57e62a6f9f0454d8e1f77 | 54457e1e0ae7b5bd0dbbf3e94232af4e91e61e67 | /Algorithms/SortingAlgos/insertion sort.cpp | 846d30fd50e24d6de53108febf3889ef38c22159 | [] | no_license | ankitjain-1/Data-Structures-and-Algorithms | f5d3fa5589094de6492035ffe3e06041df132963 | 3c4f2c09cfc1751b1b0612cf9348b8dc451b79ab | refs/heads/master | 2023-01-06T16:39:06.439933 | 2020-10-31T16:13:04 | 2020-10-31T16:13:04 | 271,839,780 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,450 | cpp | /**
* Time Complexity: O(n*2)
* Auxiliary Space: O(1)
* Boundary Cases: Insertion sort takes maximum time to sort if elements are sorted in reverse order. And it takes minimum time (Order of n) when elements are already sorted.
* Algorithmic Paradigm: Incremental Approach
* Sorting In Place: Yes
* Stable: Yes
* Online: Yes
* Uses: Insertion sort is used when number of elements is small. It can also be useful when input array is almost sorted, only few elements are misplaced in complete big array.
**/
#include <bits/stdc++.h>
#define fo(i, n) for(int i = 0; i < n; i++)
// #define fo(n, i, r) for(int i = n; i > 0; i--)
#define Fo(i, k ,n) for(int i = k; i < n; i++)
using namespace std;
void insertion_sort(vector<int>& seq);
void print_seq(vector<int>);
void insertion_sort(vector<int>& seq){
int key, j;
fo(i, seq.size()) {
key = seq[i];
j = i - 1;
while (j >= 0 && key < seq[j]) {
seq[j + 1] = seq[j];
j--;
}
seq[j + 1] = key;
}
}
void print_seq(vector<int> seq) {
for (auto num: seq) {
cout << num << " ";
}
cout << "/n";
}
int main () {
cout << "Enter elements of the arrat to be sorted separated by space, enter any char to stop: " << "\n";
vector<int> seq;
int inp;
while (cin >> inp){
seq.push_back(inp);
}
insertion_sort(seq);
print_seq(seq);
return 0;
}
| [
"akjain6067.aj@gmail.com"
] | akjain6067.aj@gmail.com |
d29c8a3f53bd032e36f6061b3971a3c82f19ec4d | 7d758f41ad94da640e63a7cf0023cb036e804560 | /data structures/c++/MaxHeapArray.h | 809a98be53b01d2c079dcd5b07cd6d014f845570 | [] | no_license | synzen/Data-Structures-Algorithms | 8497a9237d2ecd60d51ddd41fe69257e63e8edaa | 91c7dd635e2d04c2ac0d8b6def763fe471e15671 | refs/heads/master | 2020-06-13T07:06:05.233936 | 2019-07-13T23:04:41 | 2019-07-13T23:04:41 | 194,580,665 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,892 | h | #pragma once
#include <iostream>
#include <vector>
template <class T>
class MaxHeap {
public:
std::vector<T> data;
MaxHeap<T>(T arr[], int len) {
for (int i = 0; i < len; ++i) {
data.push_back(arr[i]);
}
}
void insert(T d) {
data.push_back(d);
int size = data.size();
if (size == 1) return;
heapifyUp(size - 1);
}
void heapifyUp(int i) {
int value = data[i];
int parentIndex = parentIndexOf(i);
while (parentIndex >= 0 && value > data[parentIndex]) {
// swap the parent and the current nodes until the max heap is satisfied
data[i] = data[parentIndex];
data[parentIndex] = value;
i = parentIndex;
parentIndex = parentIndexOf(i);
}
}
// Used when removing the root (max) node for example, the node swaps downwards if applicable
void heapifyDown(int i) {
int size = data.size();
int largestIndex = i;
T value = data[i];
do {
if (largestIndex != i) {
data[i] = data[largestIndex];
data[largestIndex] = value;
i = largestIndex;
}
int leftChildIndex = leftChildIndexOf(i);
if (leftChildIndex < size && data[leftChildIndex] > data[largestIndex]) largestIndex = leftChildIndex;
int rightChildIndex = rightChildIndexOf(i);
if (rightChildIndex < size && data[rightChildIndex] > data[largestIndex]) largestIndex = rightChildIndex;
} while (largestIndex != i);
}
void removeMax() {
if (data.size() == 0) return;
data.erase(data.begin());
if (data.size() > 0) {
data.insert(data.begin(), data[data.size() - 1]);
data.erase(data.end() - 1);
heapifyDown(0);
}
}
void print() {
for (auto i = data.begin(); i != data.end(); ++i) {
std::cout << *i << " ";
}
std::cout << std::endl;
}
int parentIndexOf(int index) {
return (index - 1) / 2;
}
int leftChildIndexOf(int index) {
return (index * 2) + 1;
}
int rightChildIndexOf(int index) {
return (index * 2) + 2;
}
}; | [
"michael994664@gmail.com"
] | michael994664@gmail.com |
3fc6a1a47d3351cd61d0adf526b123d5c8c97665 | 9a9fffa65f8dd09767b06183ec9ac8651b42bede | /src/rend/Shader.h | b399d744fbab0b237effa000911bcf82d248cdd7 | [] | no_license | MariaPrograms/GEPEngine | eb64888b6eb7fa19917d21c01b1499eaefd63f33 | 7c8558fc46909df348fb0db90befed2a801a8556 | refs/heads/master | 2020-08-06T00:53:42.170878 | 2020-01-17T07:21:36 | 2020-01-17T07:21:36 | 212,774,028 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,563 | h | #include "mathutil.h"
#include <GL/glew.h>
#include <sr1/zero_initialized>
#include <sr1/noncopyable>
#include <sr1/memory>
#include <sr1/vector>
#include <string>
namespace rend
{
struct Context;
struct VariableInfo;
struct Buffer;
struct RenderTexture;
struct TextureAdapter;
struct Mesh;
struct Shader : public std::sr1::noncopyable
{
~Shader();
void render();
void render(const std::sr1::shared_ptr<RenderTexture>& target);
GLuint getId();
void setSource(const std::string& source);
void parse(const std::string& source);
void setUniform(const std::string& variable, float value);
void setUniform(const std::string& variable, mat4 value);
void setUniform(const std::string& variable, vec2 value);
void setUniform(const std::string& variable, vec3 value);
void setUniform(const std::string& variable, vec4 value);
void setAttribute(const std::string& variable, const std::sr1::shared_ptr<Buffer>& value);
void setSampler(const std::string& variable, const std::sr1::shared_ptr<TextureAdapter>& value);
void setMesh(const std::sr1::shared_ptr<Mesh>& value);
void setDepthTesting(bool value);//Maria
void setCullFaces(bool value);//Maria
private:
friend struct Context;
std::sr1::shared_ptr<Context> context;
std::sr1::zero_initialized<GLuint> id;
std::sr1::vector<std::sr1::shared_ptr<VariableInfo> > cache;
std::sr1::shared_ptr<VariableInfo> getVariableInfo(const std::string& name, GLenum type, bool attrib);
std::string LoadFile(std::string _path);
bool cullFace;
bool depthTest;
};
}
| [
"s4915051@bournemouth.ac.uk"
] | s4915051@bournemouth.ac.uk |
c28998cdabc2f1f07b95b2309ec865488f8514d1 | 8c1dbeb23cb2bcf0fe44b62f703486dcc99f79a4 | /v3/Arborist/src/treenet/scanning/explorenet/ExploreNETRunnable.cpp | 37f349f19dbeba10e40d733a4d97cf056a43ffc0 | [] | no_license | JefGrailet/treenet | 0e2bf104ea347ec0efd221e3b91f738d69ca90e8 | 10cfdcd7e94d73ab29c129ccffb07c4ba6dbcadd | refs/heads/master | 2020-12-24T06:42:31.569006 | 2019-10-14T10:06:17 | 2019-10-14T10:06:17 | 34,863,160 | 10 | 5 | null | null | null | null | UTF-8 | C++ | false | false | 12,155 | cpp | /*
* ExploreNETRunnable.cpp
*
* Created on: Oct 04, 2014
* Author: grailet
*
* This class fuses the classes ExploreNETRunnableBox and ExploreNETRunnableSingleInput from
* the original ExploreNET (v2.1) into a single thread class. The goal is to redesign this
* part of ExploreNET in order to embed it in a larger topology discovery tool (as the
* class ExploreNETRunnableMultipleInput is expected to be useless in this context).
*/
#include "ExploreNETRecord.h"
#include "ExploreNETRunnable.h"
// 7 next lines are for print out purpose only
#include <string>
using std::string;
#include <vector>
using std::vector;
#include <iomanip>
using std::left;
using std::right;
Mutex ExploreNETRunnable::sssMutex(Mutex::ERROR_CHECKING_MUTEX);
ExploreNETRunnable::ExploreNETRunnable(TreeNETEnvironment *e,
InetAddress &t,
unsigned short lowerBoundSrcPortORICMPid,
unsigned short upperBoundSrcPortORICMPid,
unsigned short lowerBoundDstPortORICMPseq,
unsigned short upperBoundDstPortICMPseq) throw (SocketException):
env(e),
target(t),
sinf(e,
lowerBoundSrcPortORICMPid,
upperBoundSrcPortORICMPid,
lowerBoundDstPortORICMPseq,
upperBoundDstPortICMPseq)
{
}
ExploreNETRunnable::~ExploreNETRunnable() {}
/**
* Usual run method.
*/
void ExploreNETRunnable::run()
{
InetAddress t;
SubnetSite *site = NULL;
unsigned short res;
// Parameters obtained through env
IPLookUpTable *table = env->getIPTable();
SubnetSiteSet *subnetSet = env->getSubnetSet();
NetworkAddress LAN = env->getLAN();
unsigned char startTTL = env->getStartTTL();
bool exploreLANExplicitly = env->exploringLANExplicitly();
bool useLowerBorderAsWell = env->usingLowerBorderAsWell();
t = this->target;
if(t.isUnset())
{
return;
}
// Checks that target is not already covered in the set
sssMutex.lock();
SubnetSite *coverage = subnetSet->getSubnetContaining(t);
if(coverage != NULL)
{
TreeNETEnvironment::consoleMessagesMutex.lock();
ostream *out = env->getOutputStream();
(*out) << t << " is already in previously inferred subnet ";
(*out) << coverage->getInferredNetworkAddressString() << "." << endl;
// Finds and gives TTL to that target in IP table
list<SubnetSiteNode*> *nodes = coverage->getSubnetIPList();
unsigned char minTTL = 255;
unsigned char tTTL = 0;
for(std::list<SubnetSiteNode*>::iterator it = nodes->begin(); it != nodes->end(); ++it)
{
if((*it)->ip == t)
{
tTTL = (*it)->TTL;
break;
}
if((*it)->TTL < minTTL)
minTTL = (*it)->TTL;
}
IPTableEntry *entry = table->lookUp(t);
if(entry != NULL) // Just in case
{
if(tTTL != 0)
entry->setTTL(tTTL);
else // Pivot TTL
{
// Status of coverage subnet is checked, just in case.
unsigned short status = coverage->getStatus();
if(status == SubnetSite::ACCURATE_SUBNET || status == SubnetSite::ODD_SUBNET)
entry->setTTL(minTTL + 1);
else
entry->setTTL(minTTL);
}
}
/*
* N.B. (April 2017): since the encompassing subnet was either obtained straight from
* ExploreNET module or through expansion, the encompassed IP either:
* -is already in the inferred subnet through probing,
* -was probed at some point during the refinement of the encompassing subnet and is
* necessarily located farther than the contra-pivot TTL, therefore at pivot IP. If it
* is actually farther in the real network, then it means either the contra-pivot IP(s)
* of the encompassing subnet should have been found earlier (something which is very
* hard to infer without a groundtruth; potential improvement for future TreeNET
* versions), either the encompassed IP is an (undetected) outlier.
*/
TreeNETEnvironment::consoleMessagesMutex.unlock();
sssMutex.unlock();
return;
}
sssMutex.unlock();
try
{
// Infers local subnet if the target is within the range of the LAN
if(LAN.subsumes(t))
{
// Infers local subnet with all IPs or use local information
if(exploreLANExplicitly == true)
{
site = sinf.inferLocalAreaSubnet(t, LAN);
res = ExploreNETRunnable::SUCCESSFULLY_INFERRED_LOCAL_SUBNET_SITE;
}
else
{
site = sinf.inferDummyLocalAreaSubnet(t, LAN);
res = ExploreNETRunnable::DUMMY_LOCAL_SUBNET_SITE;
}
}
// Infers remote subnet
else
{
site = sinf.inferRemoteSubnet(t, false, startTTL, useLowerBorderAsWell);
if(site != 0 && site->getInferredSubnetPrefixLength() <= 32)
{
if(site->getStatus() == SubnetSite::NOT_PREPARED_YET)
{
res = ExploreNETRunnable::SUCCESSFULLY_INFERRED_REMOTE_SUBNET_SITE;
}
else
{
res = ExploreNETRunnable::UNNECESSARY_PROBING;
}
}
else
{
res = ExploreNETRunnable::NULL_SUBNET_SITE;
}
}
}
catch(SocketException &se)
{
TreeNETEnvironment::consoleMessagesMutex.lock();
ostream *out = env->getOutputStream();
(*out) << "Probed " << t << ": critical failure at probing time." << endl;
TreeNETEnvironment::consoleMessagesMutex.unlock();
return;
}
catch(NoTTLEstimationException &e)
{
string msg = e.what();
std::size_t posTrueMsg = msg.find(":");
if(posTrueMsg != std::string::npos)
{
string trueMsg = msg.substr(posTrueMsg + 2);
if(trueMsg.compare("too many consecutive anonymous replies.") == 0)
res = ExploreNETRunnable::NO_TTL_ESTIMATION_1;
else if(trueMsg.compare("too many redundant responsive IPs.") == 0)
res = ExploreNETRunnable::NO_TTL_ESTIMATION_2;
else if(trueMsg.compare("estimated TTL is too large.") == 0)
res = ExploreNETRunnable::NO_TTL_ESTIMATION_3;
else
res = ExploreNETRunnable::NO_TTL_ESTIMATION_4; // To make the compiler happy
/*
* Not the most elegant way to deal with this exception, but still easier and lighter
* than creating separate classes of exception.
*/
}
else
res = ExploreNETRunnable::NO_TTL_ESTIMATION_4;
}
catch (UnresponsiveIPException &e)
{
res = ExploreNETRunnable::UNRESPONSIVE_IP_EXCEPTION;
}
catch (UndesignatedPivotInterface &e)
{
res = ExploreNETRunnable::UNDESIGNATED_PIVOT_INTERFACE_EXCEPTION;
}
catch (ShortTTLException &e)
{
res = ExploreNETRunnable::SHORT_TTL_EXCEPTION;
}
string stringResult = ""; // For output purpose
// Registering the site in the set
if(res == ExploreNETRunnable::SUCCESSFULLY_INFERRED_REMOTE_SUBNET_SITE ||
res == ExploreNETRunnable::SUCCESSFULLY_INFERRED_LOCAL_SUBNET_SITE ||
res == ExploreNETRunnable::DUMMY_LOCAL_SUBNET_SITE)
{
sssMutex.lock();
unsigned short insertionResult = subnetSet->addSite(site);
string networkAddressStr = site->getInferredNetworkAddressString();
if(insertionResult == SubnetSiteSet::SMALLER_SUBNET ||
insertionResult == SubnetSiteSet::KNOWN_SUBNET)
{
delete site;
stringResult += "inferred " + networkAddressStr + ", merged with a larger or equivalent known subnet";
}
else
{
stringResult += "inferred " + networkAddressStr + ", a new subnet";
// Saves an ExploreNET record, but only if asked by the user.
if(env->savingExploreNETResults())
{
ExploreNETRecord *rec = new ExploreNETRecord(t,
networkAddressStr,
site->getSubnetPositioningCost(),
site->getSubnetInferenceCost(),
site->getAlternativeNetworkAddressString());
env->pushExploreNETRecord(rec);
}
}
site = NULL;
sssMutex.unlock();
}
// Failure: display cause of the problem in console if showInferenceFailures is true
else
{
/*
* TreeNET v2.1: no inference for IP encompassed by a /20 block with the same TTL for
* Pivot IPs, because previous inference/expansion led to subnet(s) with no Contra-Pivot
* to ensure their soundness.
*/
if(res == ExploreNETRunnable::UNNECESSARY_PROBING)
{
stringResult += "no inference, as pivot TTL is the same as for IPs in ";
stringResult += site->getInferredNetworkAddressString();
stringResult += " (IP range to avoid)";
// Avoids deleting the /20 block afterwards
site = 0;
}
// Other errors already present in TreeNET v2.0 (+ in v3.0: lack of a good TTL estimation)
else if(res == ExploreNETRunnable::NULL_SUBNET_SITE)
stringResult += "failure, subnet seems to not exist";
else if(res == ExploreNETRunnable::SHORT_TTL_EXCEPTION)
stringResult += "no inference, subnet TTL (pivot TTL) must be at least two";
else if(res == ExploreNETRunnable::UNDESIGNATED_PIVOT_INTERFACE_EXCEPTION)
stringResult += "no inference, undesignated pivot IP address";
else if(res == ExploreNETRunnable::NO_TTL_ESTIMATION_1)
stringResult += "aborted distance (in TTL) estimation because of too many consecutive anonymous hops";
else if(res == ExploreNETRunnable::NO_TTL_ESTIMATION_2)
stringResult += "aborted distance (in TTL) estimation because of too many redundant responsive IPs";
else if(res == ExploreNETRunnable::NO_TTL_ESTIMATION_3)
stringResult += "aborted distance (in TTL) estimation because the current distance is too big";
else if(res == ExploreNETRunnable::UNRESPONSIVE_IP_EXCEPTION)
stringResult += "no inference, unresponsive target IP address";
else
stringResult += "error in the code; uninitialized/unknown error type";
}
// Delete the site object if initialized
if(site != 0)
{
delete site;
site = 0;
}
TreeNETEnvironment::consoleMessagesMutex.lock();
ostream *out = env->getOutputStream();
// Debug/verbose stuff
if(env->getDisplayMode() == TreeNETEnvironment::DISPLAY_MODE_VERBOSE)
{
if(res == ExploreNETRunnable::SUCCESSFULLY_INFERRED_REMOTE_SUBNET_SITE ||
res == ExploreNETRunnable::SUCCESSFULLY_INFERRED_LOCAL_SUBNET_SITE ||
res == ExploreNETRunnable::DUMMY_LOCAL_SUBNET_SITE)
{
(*out) << sinf.getExploreNETLog() << endl;
}
}
else if(env->getDisplayMode() == TreeNETEnvironment::DISPLAY_MODE_DEBUG)
{
(*out) << sinf.getExploreNETLog() << endl;
}
// Default message (printed in any situation)
(*out) << "Probed " << t << ": " << stringResult << "." << endl;
TreeNETEnvironment::consoleMessagesMutex.unlock();
return;
}
| [
"Jean-Francois.Grailet@student.ulg.ac.be"
] | Jean-Francois.Grailet@student.ulg.ac.be |
cd156db3ac1676536167729bf7697be577c51b54 | 8b91e4da1ede27974550627a10f30375e612d50f | /statdataset/statdataset.h | 28098090a5676ea653453dc04afd9f8bb8e8d374 | [] | no_license | boubad/CPPStats | 1859876fb9de86339ab6c49fb392312c8c58b08a | 25a5a2e50ad6d39a5b942365e66e0c0e085b0892 | refs/heads/master | 2016-09-02T01:25:39.795611 | 2013-09-21T09:20:45 | 2013-09-21T09:20:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 28,853 | h | /*
* Statdataset.h
*
* Created on: 17 sept. 2013
* Author: Boubacar
*/
#ifndef STATDATASET_H_
#define STATDATASET_H_
///////////////////////////////////////
#include <cassert>
#include <memory>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
//////////////////////
#ifndef __MY_BOOST_INC__
#define __MYBOOST_INC__
#include <boost/algorithm/string.hpp>
#include <boost/any.hpp>
#endif // __MY_BOOST_UNC__
/////////////////////////////////////
namespace intra {
////////////////////////////////////////////
class StatValue;
template<class TSTRING>
class StatIndiv;
template<class TSTRING, class ALLOCANYPAIR>
class StatVariable;
template<class TSTRING, class ALLOCANYPAIR, class ALLOCVARPAIR,
class ALLOCINDIVPAIR>
class StatDataset;
///////////////////////////////////////
class StatValue {
private:
int m_id;
int m_optlock;
int m_variableid;
int m_individ;
boost::any m_val;
public:
StatValue() :
m_id(0), m_optlock(1), m_variableid(0), m_individ(0) {
}
StatValue(const boost::any &v) :
m_id(0), m_optlock(1), m_variableid(0), m_individ(0), m_val(v) {
}
StatValue(const StatValue &other) :
m_id(other.m_id), m_optlock(other.m_optlock), m_variableid(
other.m_variableid), m_individ(other.m_individ), m_val(
other.m_val) {
} // StatIndiv
StatValue & operator=(const StatValue &other) {
if (this != &other) {
this->m_id = other.m_id;
this->m_optlock = other.m_optlock;
this->m_variableid = other.m_variableid;
this->m_individ = other.m_individ;
}
return (*this);
} // operator=
virtual ~StatValue() {
}
bool operator==(const StatValue &other) const {
if ((this->m_id != 0) && (other.m_id != 0)) {
return (this->m_id == other.m_id);
}
return ((this->m_variableid == other.m_variableid)
&& (this->m_individ == other.m_individ));
} // operator==
bool operator<(const StatValue &other) const {
if (this->m_variableid < other.m_variableid) {
return (true);
} else if (m_variableid > other.m_variableid) {
return (false);
}
return (this->m_individ < other.m_individ);
} // operator==
////////////////////////////
public:
inline int id(void) const {
return (this->m_id);
}
inline void id(int n) {
this->m_id = n;
}
inline int variable_id(void) const {
return (this->m_variableid);
}
inline void variable_id(int n) {
this->m_variableid = n;
}
inline int indiv_id(void) const {
return (this->m_individ);
}
inline void indiv_id(int n) {
this->m_individ = n;
}
inline int version(void) const {
return (this->m_optlock);
}
inline void version(int n) {
this->m_optlock = n;
}
inline const boost::any & value(void) const {
return (this->m_val);
}
inline void value(const boost::any &s) {
this->m_val = s;
}
inline void value(bool bVal) {
this->m_val = boost::any(bVal);
}
inline void value(int v) {
this->m_val = boost::any(v);
}
inline void value(float v) {
this->m_val = boost::any(v);
}
inline void value(double v) {
this->m_val = boost::any(v);
}
inline void value(const std::string &v) {
this->m_val = boost::any(v);
}
inline void value(const std::wstring &v) {
this->m_val = boost::any(v);
}
inline bool is_valid(void) const {
return ((this->m_variableid > 0) && (this->m_individ > 0));
}
inline bool is_empty(void) const {
return (this->m_val.empty());
}
inline bool is_updateable(void) const {
return (this->m_id > 0);
}
inline bool is_removeable(void) const {
return (this->m_id > 0);
}
public:
bool bool_value(void) const {
bool oRet = false;
const boost::any &v = this->m_val;
if (!v.empty()) {
const std::type_info & t = v.type();
if (t == typeid(bool)) {
oRet = boost::any_cast<bool>(v);
} else if (t == typeid(short)) {
short x = boost::any_cast<short>(v);
oRet = (x != 0) ? true : false;
} else if (t == typeid(int)) {
int x = boost::any_cast<int>(v);
oRet = (x != 0) ? true : false;
} else if (t == typeid(float)) {
float x = boost::any_cast<float>(v);
oRet = (x != 0.0f) ? true : false;
} else if (t == typeid(double)) {
double x = boost::any_cast<double>(v);
oRet = (x != 0.0) ? true : false;
} else if (t == typeid(std::string)) {
std::string x = boost::any_cast<std::string>(v);
std::string xx = boost::to_lower_copy(boost::trim_copy(x));
if (!xx.empty()) {
auto c = *(xx.begin());
oRet = (c == 't') || (c == '1') || (c == 'v') || (c == 'o');
} // not empty
} else if (t == typeid(std::wstring)) {
std::wstring x = boost::any_cast<std::wstring>(v);
std::wstring xx = boost::to_lower_copy(boost::trim_copy(x));
if (!xx.empty()) {
auto c = *(xx.begin());
oRet = (c == L't') || (c == L'1') || (c == L'v')
|| (c == L'o');
} // not empty
}
} // not empty
return (oRet);
} // bool_value
short short_value(void) const {
short oRet = -1;
const boost::any &v = this->m_val;
if (!v.empty()) {
const std::type_info & t = v.type();
if (t == typeid(bool)) {
bool b = boost::any_cast<bool>(v);
oRet = (b) ? 1 : 0;
} else if (t == typeid(short)) {
short x = boost::any_cast<short>(v);
oRet = x;
} else if (t == typeid(int)) {
int x = boost::any_cast<int>(v);
oRet = (short) x;
} else if (t == typeid(float)) {
float x = boost::any_cast<float>(v);
oRet = (short) x;
} else if (t == typeid(double)) {
double x = boost::any_cast<double>(v);
oRet = (short) x;
} else if (t == typeid(std::string)) {
std::string x = boost::any_cast<std::string>(v);
std::string xx = boost::to_lower_copy(boost::trim_copy(x));
if (!xx.empty()) {
std::stringstream in(xx);
in >> oRet;
} // not empty
} else if (t == typeid(std::wstring)) {
std::wstring x = boost::any_cast<std::wstring>(v);
std::wstring xx = boost::to_lower_copy(boost::trim_copy(x));
if (!xx.empty()) {
std::wstringstream in(xx);
in >> oRet;
} // not empty
}
} // not empty
return (oRet);
} // short_value
int int_value(void) const {
int oRet = -1;
const boost::any &v = this->m_val;
if (!v.empty()) {
const std::type_info & t = v.type();
if (t == typeid(bool)) {
bool b = boost::any_cast<bool>(v);
oRet = (b) ? 1 : 0;
} else if (t == typeid(short)) {
short x = boost::any_cast<short>(v);
oRet = (int) x;
} else if (t == typeid(int)) {
int x = boost::any_cast<int>(v);
oRet = x;
} else if (t == typeid(float)) {
float x = boost::any_cast<float>(v);
oRet = (int) x;
} else if (t == typeid(double)) {
double x = boost::any_cast<double>(v);
oRet = (int) x;
} else if (t == typeid(std::string)) {
std::string x = boost::any_cast<std::string>(v);
std::string xx = boost::to_lower_copy(boost::trim_copy(x));
if (!xx.empty()) {
std::stringstream in(xx);
in >> oRet;
} // not empty
} else if (t == typeid(std::wstring)) {
std::wstring x = boost::any_cast<std::wstring>(v);
std::wstring xx = boost::to_lower_copy(boost::trim_copy(x));
if (!xx.empty()) {
std::wstringstream in(xx);
in >> oRet;
} // not empty
}
} // not empty
return (oRet);
} // int_value
float float_value(void) const {
float oRet = -1.0f;
const boost::any &v = this->m_val;
if (!v.empty()) {
const std::type_info & t = v.type();
if (t == typeid(bool)) {
bool b = boost::any_cast<bool>(v);
oRet = (b) ? 1.0f : 0.0f;
} else if (t == typeid(short)) {
short x = boost::any_cast<short>(v);
oRet = (float) x;
} else if (t == typeid(int)) {
int x = boost::any_cast<int>(v);
oRet = (float) x;
} else if (t == typeid(float)) {
float x = boost::any_cast<float>(v);
oRet = x;
} else if (t == typeid(double)) {
double x = boost::any_cast<double>(v);
oRet = (float) x;
} else if (t == typeid(std::string)) {
std::string x = boost::any_cast<std::string>(v);
std::string xx = boost::to_lower_copy(boost::trim_copy(x));
if (!xx.empty()) {
std::stringstream in(xx);
in >> oRet;
} // not empty
} else if (t == typeid(std::wstring)) {
std::wstring x = boost::any_cast<std::wstring>(v);
std::wstring xx = boost::to_lower_copy(boost::trim_copy(x));
if (!xx.empty()) {
std::wstringstream in(xx);
in >> oRet;
} // not empty
}
} // not empty
return (oRet);
} // float_value
double double_value(void) const {
double oRet = -1.0;
const boost::any &v = this->m_val;
if (!v.empty()) {
const std::type_info & t = v.type();
if (t == typeid(bool)) {
bool b = boost::any_cast<bool>(v);
oRet = (b) ? 1.0 : 0.0;
} else if (t == typeid(short)) {
short x = boost::any_cast<short>(v);
oRet = (double) x;
} else if (t == typeid(int)) {
int x = boost::any_cast<int>(v);
oRet = (double) x;
} else if (t == typeid(float)) {
float x = boost::any_cast<float>(v);
oRet = (double) x;
} else if (t == typeid(double)) {
double x = boost::any_cast<double>(v);
oRet = x;
} else if (t == typeid(std::string)) {
std::string x = boost::any_cast<std::string>(v);
std::string xx = boost::to_lower_copy(boost::trim_copy(x));
if (!xx.empty()) {
std::stringstream in(xx);
in >> oRet;
} // not empty
} else if (t == typeid(std::wstring)) {
std::wstring x = boost::any_cast<std::wstring>(v);
std::wstring xx = boost::to_lower_copy(boost::trim_copy(x));
if (!xx.empty()) {
std::wstringstream in(xx);
in >> oRet;
} // not empty
}
} // not empty
return (oRet);
} // double_value
bool string_value(std::string &s) const {
bool bRet = false;
s.clear();
const boost::any &v = this->m_val;
if (!v.empty()) {
const std::type_info & t = v.type();
if (t == typeid(bool)) {
bool b = boost::any_cast<bool>(v);
s = (b) ? "True" : "False";
bRet = true;
} else if (t == typeid(short)) {
short x = boost::any_cast<short>(v);
std::stringstream os;
os << x;
s = os.str();
bRet = true;
} else if (t == typeid(int)) {
int x = boost::any_cast<int>(v);
std::stringstream os;
os << x;
s = os.str();
bRet = true;
} else if (t == typeid(float)) {
float x = boost::any_cast<float>(v);
std::stringstream os;
os << x;
s = os.str();
bRet = true;
} else if (t == typeid(double)) {
double x = boost::any_cast<double>(v);
std::stringstream os;
os << x;
s = os.str();
bRet = true;
} else if (t == typeid(std::string)) {
std::string x = boost::any_cast<std::string>(v);
s = x;
bRet = true;
} else if (t == typeid(std::wstring)) {
std::wstring x = boost::any_cast<std::wstring>(v);
std::string sx(x.length(), ' ');
std::copy(x.begin(), x.end(), sx.begin());
s = sx;
bRet = true;
}
} // not empty
return (bRet);
} // string_value
bool string_value(std::wstring &s) const {
bool bRet = false;
s.clear();
const boost::any &v = this->m_val;
if (!v.empty()) {
const std::type_info & t = v.type();
if (t == typeid(bool)) {
bool b = boost::any_cast<bool>(v);
s = (b) ? L"True" : L"False";
bRet = true;
} else if (t == typeid(short)) {
short x = boost::any_cast<short>(v);
std::wstringstream os;
os << x;
s = os.str();
bRet = true;
} else if (t == typeid(int)) {
int x = boost::any_cast<int>(v);
std::wstringstream os;
os << x;
s = os.str();
bRet = true;
} else if (t == typeid(float)) {
float x = boost::any_cast<float>(v);
std::wstringstream os;
os << x;
s = os.str();
bRet = true;
} else if (t == typeid(double)) {
double x = boost::any_cast<double>(v);
std::wstringstream os;
os << x;
s = os.str();
bRet = true;
} else if (t == typeid(std::wstring)) {
std::wstring x = boost::any_cast<std::wstring>(v);
s = x;
bRet = true;
} else if (t == typeid(std::string)) {
std::string x = boost::any_cast<std::string>(v);
std::wstring sx(x.length(), L' ');
std::copy(x.begin(), x.end(), sx.begin());
s = sx;
bRet = true;
}
} // not empty
return (bRet);
} // string_value
};
/////////////////////////////////////
template<class TSTRING = std::string>
class StatIndiv {
public:
typedef TSTRING StringType;
typedef StatIndiv<TSTRING> IndivType;
private:
int m_id;
int m_datasetid;
int m_optlock;
StringType m_sigle;
StringType m_name;
StringType m_desc;
public:
StatIndiv() :
m_id(0), m_datasetid(0), m_optlock(1) {
}
StatIndiv(const IndivType &other) :
m_id(other.m_id), m_datasetid(other.m_datasetid), m_optlock(
other.m_optlock), m_sigle(other.m_sigle), m_name(
other.m_name), m_desc(other.m_desc) {
} // StatIndiv
IndivType & operator=(const IndivType &other) {
if (this != &other) {
this->m_id = other.m_id;
this->m_datasetid = other.m_datasetid;
this->m_optlock = other.m_optlock;
this->m_sigle = other.m_sigle;
this->m_name = other.m_name;
this->m_desc = other.m_desc;
}
return (*this);
} // operator=
virtual ~StatIndiv() {
}
bool operator==(const IndivType &other) const {
if ((this->m_id != 0) && (other.m_id != 0)) {
return (this->m_id == other.m_id);
}
return ((this->m_datasetid == other.m_datasetid)
&& (this->m_sigle == other.m_sigle));
} // operator==
bool operator<(const IndivType &other) const {
if (this->m_datasetid < other.m_datasetid) {
return (true);
} else if (m_datasetid > other.m_datasetid) {
return (false);
}
return (this->m_sigle < other.m_sigle);
} // operator==
////////////////////////////
public:
inline int id(void) const {
return (this->m_id);
}
inline void id(int n) {
this->m_id = n;
}
inline int dataset_id(void) const {
return (this->m_datasetid);
}
inline void dataset_id(int n) {
this->m_datasetid = n;
}
inline int version(void) const {
return (this->m_optlock);
}
inline void version(int n) {
this->m_optlock = n;
}
inline const StringType & sigle(void) const {
return (this->m_sigle);
}
inline void sigle(const StringType &s) {
this->m_sigle = boost::trim_copy(s);
}
inline const StringType &name(void) const {
return (this->m_name);
}
inline void name(const StringType &s) {
this->m_name = boost::trim_copy(s);
}
inline const StringType & description(void) const {
return (this->m_desc);
}
inline void description(const StringType &s) {
this->m_desc = boost::trim_copy(s);
}
inline bool is_valid(void) const {
return ((this->m_datasetid > 0) && (!this->m_sigle.empty()));
}
inline bool is_updateable(void) const {
return ((this->m_id > 0) && (!this->m_sigle.empty()));
}
inline bool is_removeable(void) const {
return (this->m_id > 0);
}
};
/////////////////////////////////////
template<class TSTRING = std::string, class ALLOCANYPAIR = std::allocator<
std::pair<int, std::shared_ptr<StatValue> > > >
class StatVariable {
public:
typedef TSTRING StringType;
typedef std::map<int, std::shared_ptr<StatValue>, std::less<int>,
ALLOCANYPAIR> ValuesMapType;
typedef StatVariable<TSTRING, ALLOCANYPAIR> VariableType;
typedef std::shared_ptr<StatValue> ValuePtr;
private:
int m_id;
int m_datasetid;
int m_optlock;
int m_categvar;
StringType m_type;
StringType m_sigle;
StringType m_name;
StringType m_desc;
ValuesMapType m_valuesmap;
public:
StatVariable() :
m_id(0), m_datasetid(0), m_optlock(1), m_categvar(0) {
}
StatVariable(const VariableType &other) :
m_id(other.m_id), m_datasetid(other.m_datasetid), m_optlock(
other.m_optlock), m_categvar(other.m_categvar), m_type(
other.m_type), m_sigle(other.m_sigle), m_name(other.m_name), m_desc(
other.m_desc), m_valuesmap(other.m_valuesmap) {
} // StatDataset
VariableType & operator=(const VariableType &other) {
if (this != &other) {
this->m_id = other.m_id;
this->m_datasetid = other.m_datasetid;
this->m_optlock = other.m_optlock;
this->m_categvar = other.m_categvar;
this->m_type = other.m_type;
this->m_sigle = other.m_sigle;
this->m_name = other.m_name;
this->m_desc = other.m_desc;
this->m_valuesmap = other.m_valuesmap;
}
return (*this);
} // operator=
virtual ~StatVariable() {
}
bool operator==(const VariableType &other) const {
if ((this->m_id != 0) && (other.m_id != 0)) {
return (this->m_id == other.m_id);
}
return ((this->m_datasetid == other.m_datasetid)
&& (this->m_sigle == other.m_sigle));
} // operator==
bool operator<(const VariableType &other) const {
if (this->m_datasetid < other.m_datasetid) {
return (true);
} else if (m_datasetid > other.m_datasetid) {
return (false);
}
if (this->m_categvar > other.m_categvar) {
return (true);
} else if (this->m_categvar < other.m_categvar) {
return (false);
}
return (this->m_sigle < other.m_sigle);
} // operator==
////////////////////////////
public:
inline bool add_value(ValuePtr v) {
const StatValue *px = v.get();
if (px != nullptr) {
int key = px->indiv_id();
(this->m_valuesmap)[key] = v;
return (true);
} // px
return (false);
} // add_value
inline void add_value(const StatValue &oVal) {
int key = oVal.indiv_id();
ValuePtr val = std::make_shared < StatValue > (oVal);
(this->m_valuesmap)[key] = val;
} // add_value
inline bool has_indiv_value(int indivId) const {
auto oMap = this->m_valuesmap;
return (oMap.find(indivId) != oMap.end());
} // has_indiv_value
inline bool get_indiv_value(int indivId, ValuePtr &val) const {
const ValuesMapType & oMap = this->m_valuesmap;
auto it = oMap.find(indivId);
if (it != oMap.end()) {
val = (*it).second;
return (true);
}
return (false);
} // get_indiv_value
inline const StatValue *get_indiv_value(int indivId) const {
const ValuesMapType & oMap = this->m_valuesmap;
auto it = oMap.find(indivId);
if (it != oMap.end()) {
const ValuePtr &vx = (*it).second;
return (vx.get());
}
return (nullptr);
} // get_indiv_value
inline void set_indiv_value(int indivId, const StatValue &v) {
ValuePtr val = std::make_shared < StatValue > (v);
(this->m_valuesmap)[indivId] = val;
} // get_indiv_value
inline bool set_indiv_value(ValuePtr v) {
const StatValue *px = v.get();
if (px != nullptr) {
int key = px->indiv_id();
(this->m_valuesmap)[key] = v;
return (true);
} // px
return (false);
} // get_indiv_value
inline const ValuesMapType & values_map(void) const {
return (this->m_valuesmap);
}
inline ValuesMapType & values_map(void) {
return (this->m_valuesmap);
}
template<class ALLOCINT>
void get_valid_indivs_ids(
std::set<int, std::less<int>, ALLOCINT> &oSet) const {
oSet.clear();
const ValuesMapType & oMap = this->m_valuesmap;
auto iend = oMap.end();
for (auto it = oMap.begin(); it != iend; ++it) {
const ValuePtr &v = (*it).second;
const StatValue *px = v.get();
if (px == nullptr) {
continue;
}
if (!px->is_empty()) {
oSet.insert((*it).first);
}
} // it
} // get_indivs_ids
template<class CONTAINER>
void get_indiv_ids_values(const CONTAINER &oIds,
ValuesMapType &oVals) const {
oVals.clear();
const ValuesMapType &oMap = this->m_valuesmap;
auto iend = oIds.end();
auto jend = oMap.end();
for (auto it = oIds.begin(); it != iend; ++it) {
int ii = *it;
if (oMap.find(ii) != jend) {
ValuePtr v = oMap[ii];
oVals[ii] = v;
}
} // it
} // get_values
//
inline int id(void) const {
return (this->m_id);
}
inline void id(int n) {
this->m_id = n;
}
inline int dataset_id(void) const {
return (this->m_datasetid);
}
inline void dataset_id(int n) {
this->m_datasetid = n;
}
inline int version(void) const {
return (this->m_optlock);
}
inline void version(int n) {
this->m_optlock = n;
}
inline bool is_categvar(void) const {
return (this->m_categvar != 0);
}
inline void is_categvar(bool b) {
this->m_categvar = (b) ? 1 : 0;
}
inline const StringType & var_type(void) const {
return (this->m_type);
}
inline void var_type(const StringType &s) {
this->m_type = boost::trim_copy(s);
}
inline const StringType & sigle(void) const {
return (this->m_sigle);
}
inline void sigle(const StringType &s) {
this->m_sigle = boost::trim_copy(s);
}
inline const StringType &name(void) const {
return (this->m_name);
}
inline void name(const StringType &s) {
this->m_name = boost::trim_copy(s);
}
inline const StringType & description(void) const {
return (this->m_desc);
}
inline void description(const StringType &s) {
this->m_desc = boost::trim_copy(s);
}
inline bool is_valid(void) const {
return ((this->m_datasetid > 0) && (!this->m_sigle.empty())
&& (!this->m_type.empty()));
}
inline bool is_updateable(void) const {
return ((this->m_id > 0) && (!this->m_sigle.empty())
&& (!this->m_type.empty()));
}
inline bool is_removeable(void) const {
return (this->m_id > 0);
}
};
/////////////////////////////////////
template<class TSTRING = std::string, class ALLOCANYPAIR = std::allocator<
std::pair<int, boost::any> >,
class ALLOCVARPAIR = std::allocator<
std::pair<int,
std::shared_ptr<StatVariable<TSTRING, ALLOCANYPAIR> > > >,
class ALLOCINDIVPAIR = std::allocator<
std::pair<int, std::shared_ptr<StatIndiv<TSTRING> > > > >
class StatDataset {
public:
typedef TSTRING StringType;
typedef StatVariable<TSTRING, ALLOCANYPAIR> VariableType;
typedef StatIndiv<TSTRING> IndivType;
typedef std::map<int, std::shared_ptr<VariableType>, std::less<int>,
ALLOCVARPAIR> VariablesMapType;
typedef std::map<int, std::shared_ptr<IndivType>, std::less<int>,
ALLOCINDIVPAIR> IndivsMapType;
typedef StatDataset<TSTRING, ALLOCANYPAIR, ALLOCVARPAIR, ALLOCINDIVPAIR> DatasetType;
typedef std::shared_ptr<StatValue> StatValuePtr;
typedef std::shared_ptr<IndivType> IndivTypePtr;
typedef std::shared_ptr<VariableType> VariableTypePtr;
typedef std::shared_ptr<DatasetType> DatasetTypePtr;
private:
int m_id;
int m_optlock;
StringType m_sigle;
StringType m_name;
StringType m_desc;
IndivsMapType m_indivs;
VariablesMapType m_variables;
public:
StatDataset() :
m_id(0), m_optlock(1) {
}
StatDataset(const DatasetType &other) :
m_id(other.m_id), m_optlock(other.m_optlock), m_sigle(
other.m_sigle), m_name(other.m_name), m_desc(other.m_desc), m_indivs(
other.m_indivs), m_variables(other.m_variables) {
} // StatDataset
DatasetType & operator=(const DatasetType &other) {
if (this != &other) {
this->m_id = other.m_id;
this->m_optlock = other.m_optlock;
this->m_sigle = other.m_sigle;
this->m_name = other.m_name;
this->m_desc = other.m_desc;
this->m_indivs = other.m_indivs;
this->m_variables = other.m_variables;
}
return (*this);
} // operator=
virtual ~StatDataset() {
}
bool operator==(const DatasetType &other) const {
if ((this->m_id != 0) && (other.m_id != 0)) {
return (this->m_id == other.m_id);
}
return (this->m_sigle == other.m_sigle);
} // operator==
bool operator<(const DatasetType &other) const {
return (this->m_sigle < other.m_sigle);
} // operator==
/////////////////////////////////
public:
inline const VariablesMapType & variables(void) const {
return (this->m_variables);
}
inline VariablesMapType & variables(void) {
return (this->m_variables);
}
inline const IndivsMapType & indivs(void) const {
return (this->m_indivs);
}
inline IndivsMapType & indivs(void) {
return (this->m_indivs);
}
void clear_data(void) {
this->m_variables.clear();
this->m_indivs.clear();
} // claer_data
bool add_indiv(IndivTypePtr v) {
const IndivType *px = v.get();
if (px != nullptr) {
int key = px->id();
(this->m_indivs)[key] = v;
return (true);
} // px
return (false);
} // add_indiv
void add_indiv(const IndivType &ind) {
int key = ind.id();
IndivTypePtr val = std::make_shared < IndivType > (ind);
(this->m_indivs)[key] = val;
} // add_indiv
bool add_variable(VariableTypePtr v) {
const VariableType *px = v.get();
if (px != nullptr) {
int key = px->id();
(this->m_variables)[key] = v;
return (true);
} // px
return (false);
} // add_variable
void add_variable(const VariableType &oVar) {
int key = oVar.id();
VariableTypePtr val = std::make_shared < VariableType > (oVar);
(this->m_variables)[key] = val;
} // add_variables
const VariableType *find_variable_by_sigle(const TSTRING &s) const {
const VariablesMapType & oMap = this->m_variables;
auto iend = oMap.end();
for (auto it = oMap.begin(); it != iend; ++it) {
const VariableTypePtr &v = (*it).second;
const VariableType *vx = v.get();
if (vx != nullptr) {
TSTRING ss = vx->sigle();
if (ss == s) {
return (&v);
}
}
} // it
return (nullptr);
} // find_variable_by_sigle
const VariableType *find_variable_by_id(int nVarId) const {
const VariablesMapType & oMap = this->m_variables;
auto it = oMap.find(nVarId);
if (it != oMap.end()) {
const VariableTypePtr &v = (*it).second;
return v.get();
}
return (nullptr);
} // find_variable_by_id
const IndivType *find_indiv_by_id(int nIndivId) const {
const IndivsMapType & oMap = this->m_indivs;
auto it = oMap.find(nIndivId);
if (it != oMap.end()) {
const IndivTypePtr &v = (*it).second;
return v.get();
}
return (nullptr);
} // find_indiv_by_id
const IndivType *find_indiv_by_sigle(const TSTRING &s) const {
const IndivsMapType & oMap = this->m_indivs;
auto iend = oMap.end();
for (auto it = oMap.begin(); it != iend; ++it) {
const IndivTypePtr &v = (*it).second;
const IndivType *vx = v.get();
if (vx != nullptr) {
TSTRING ss = vx->sigle();
if (ss == s) {
return (&v);
}
}
} // it
return (nullptr);
} // find_indiv_by_sigle
/////////////////////////////////////////
template<class ALLOCVEC>
void get_variables(std::vector<VariableTypePtr, ALLOCVEC> &oVec) const {
oVec.clear();
const VariablesMapType &oMap = this->m_variables;
auto iend = oMap.end();
for (auto it = oMap.begin(); it != iend; ++it) {
oVec.push_back((*it).second);
} // it
} // get_variables
template<class ALLOCVEC>
void get_indivs(std::vector<IndivTypePtr, ALLOCVEC> &oVec) const {
oVec.clear();
const IndivsMapType &oMap = this->m_indivs;
auto iend = oMap.end();
for (auto it = oMap.begin(); it != iend; ++it) {
oVec.push_back((*it).second);
} // it
} // get_variables
/////////////////////////////////////////
template<class CONTAINER, class ALLOCINT>
void get_common_indivs_ids(const CONTAINER &variablesIds,
std::set<int, std::less<int>, ALLOCINT> &oRes) const {
bool bFirst = true;
auto iend = variablesIds.end();
const VariablesMapType &oVars = this->m_variables;
auto jend = oVars.end();
for (auto it = variablesIds.begin(); it != iend; ++it) {
int icol = *it;
auto jt = oVars.find(icol);
if (jt != jend) {
const VariableTypePtr &vcol = (*jt).second;
const VariableType *pcol = vcol.get();
if (pcol == nullptr) {
continue;
}
std::set<int, std::less<int>, ALLOCINT> oCurSet;
pcol->get_valid_indivs_ids(oCurSet);
if (bFirst) {
bFirst = false;
oRes = oCurSet;
} else {
std::set<int, std::less<int>, ALLOCINT> oDelSet;
auto kend = oRes.end();
auto lt = oCurSet.end();
for (auto kt = oRes.begin(); kt != kend; ++kt) {
int ii = *kt;
if (oCurSet.find(ii) == lt) {
oDelSet.insert(ii);
}
} // kt
for (auto mt = oDelSet.begin(); mt != oDelSet.end(); ++mt) {
int jj = *mt;
auto dt = oRes.find(jj);
if (dt != oRes.find()) {
oRes.erase(dt);
}
} // mt
if (oRes.empty()) {
return;
}
}
} // ok vars
} // it
} // get_common_indexes
////////////////////////////
public:
inline int id(void) const {
return (this->m_id);
}
inline void id(int n) {
this->m_id = n;
}
inline int version(void) const {
return (this->m_optlock);
}
inline void version(int n) {
this->m_optlock = n;
}
inline const StringType & sigle(void) const {
return (this->m_sigle);
}
inline void sigle(const StringType &s) {
this->m_sigle = s;
}
inline const StringType &name(void) const {
return (this->m_name);
}
inline void name(const StringType &s) {
this->m_name = s;
}
inline const StringType & description(void) const {
return (this->m_desc);
}
inline void description(const StringType &s) {
this->m_desc = s;
}
inline bool is_valid(void) const {
return (!this->m_sigle.empty());
}
inline bool is_updateable(void) const {
return ((this->m_id > 0) && (!this->m_sigle.empty()));
}
inline bool is_removeable(void) const {
return (this->m_id > 0);
}
};
////////////////////////////////////////
/////////////////////////////////////
} /* namespace intra */
#endif /* STATDATASET_H_ */
| [
"boubadiarra@gmail.com"
] | boubadiarra@gmail.com |
5b3f074e362f3673060ec75d34bdae535f12ac92 | 472b67ee52788adc5b3d85a56e2c621d8d462925 | /ConcurencyInCPlusPplus/Main_Thread_RAII.cpp | 8c25d212b949fafc804900f367e4a9e3098f60ea | [] | no_license | ZingFreelancer/ConcurencyInCPlusPplus | afa7514e7b175b6fec816a272033c115909c4280 | c67dacff79a051f5cfeeb248eb275dd173a6e5eb | refs/heads/master | 2021-09-16T18:26:03.496388 | 2018-06-23T07:06:56 | 2018-06-23T07:06:56 | 106,421,200 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 906 | cpp | #include "stdafx.h"
#include <iostream>
#include <string>
#include <thread>
#include <chrono>
#include "ThreadGuard.h"
using namespace std;
//void func_1()
//{
// cout << "Hello from Thread One!" << endl;
//}
//
//void error_func()
//{
// throw std::runtime_error("Runtime error occured");
//}
//
/////Protected with use of thread guard
//int main()
//{
// std::thread t1(func_1);
// ThreadGuard tg(t1);
//
// ///Cause error
// error_func();
//
// cout << "Hello from main" << endl;
// system("pause");
// return 0;
//}
/////Protected with use of try catch
//int main()
//{
// std::thread t1(func_1);
//
// ///Error is thrown and t1 is never executed
// error_func();
//
// ///Wrap it in try catch block and manage join from it.
// try
// {
// error_func();
// t1.join();
// }
// catch (...)
// {
// t1.join();
// }
//
// cout << "Hello from main!" << endl;
//
// system("pause");
// return 0;
//} | [
"aleksander.naumenok@gmail.com"
] | aleksander.naumenok@gmail.com |
999a76829f5f334e67afa35bebe161668ead34ca | 3d3be59222796e8bbedc160c1f1595b245bde002 | /OpenGl9/OpenGL/OpenGL/GLWindow.cpp | 11a6f52c4e62446b8400c90030c426d2666cdad6 | [
"MIT"
] | permissive | coconutjim/hseb4-compgraph | 77fc8a04345f32e840f5bd19bebdeef7cd0f20c0 | 2d4d883873b3589d7dceeef3597eda185c368ef2 | refs/heads/master | 2022-07-22T03:29:37.325022 | 2022-07-14T19:34:28 | 2022-07-14T19:34:28 | 234,436,864 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 15,894 | cpp | /*
Осипов Лев Игоревич
Проект 19. OpenGL8
Visual Studio 2013
24.03.2016
Сделано:
1) реализовано 7 дополнительных фильтров:
отражение, искажение по синусу, эффект закручивания, эффект линзы, эффект волны, контраст, бинаризация
(включение - клавиши F8, F9, F11, NUMPAD0, NUMPAD1, NUMPAD2 соответственно)
2) Реализован Canny - NUMPAD3
3) реализован контроль области применения фильтров - клавиши Q и E
4) реализовано управление параметрами фильтров, как существующих, так и добавленных (но не всех, конечно, некоторые не нуждаются в конфигурации)
Управление реализовано стрелками. у некоторых фильтров регулируется один параметр стрелками влево и вправо, у некоторых два, и тогда
нужно работать еще и стрелками вверх и вниз, а у Canny еще больше нюансов
Список регулируемых фильтров:
1. F5 - размытие - стрелки влево и вправо
2. F6 - рельеф - стрелки влево и вправо
3. F7 - абберация - стрелки влево и вправо
3. F9 - искажение по синусу - стрелки влево и вправо
4. F10 - закручивание - стрелки влево и вправо (радиус) и стрелки вверх и вниз (угол)
5. F11 - линза - стрелки влево и вправо (радиус) и стрелки вверх и вниз (увеличение)
6. NUMPAD0 - волна - стрелки влево и вправо (длина волны) и стрелки вверх и вниз (смещение)
7. NUMPAD1 - контрастность - стрелки влево и вправо
8. NUMPAD2 - бинаризация - стрелки влево и вправо
9. NUMPAD3 - Canny - стрелки влево и вправо (степень размытия по Гауссу), стрелки вверх и вниз (контроль пороговой фильтрации).
Также клавишей С можно контролировать этапы применения фильтра Canny - либо полный фильтр, либо только Гаусс с обесцвечиванием (без Собеля)
5) код закомментирован
*/
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#include "GLWindow.h"
static const uint8_t INPUT_UP = 0, INPUT_DOWN = 1, INPUT_PRESSED = 2;
static const char GLWINDOW_CLASS_NAME[] = "GLWindow_class";
static HINSTANCE g_hInstance = NULL;
static HWND g_hWnd = NULL;
static HDC g_hDC = NULL;
static HGLRC g_hRC = NULL;
// обработчик сообщений окна
static LRESULT CALLBACK GLWindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
// хранение состояния окна и ввода
static GLWindow g_window;
static Input g_input;
static double g_timerFrequency = 0.0;
static LARGE_INTEGER g_qpc;
static double GetTimerTicks()
{
QueryPerformanceCounter(&g_qpc);
return g_timerFrequency * g_qpc.QuadPart;
}
bool GLWindowCreate(const char *title, int width, int height, bool fullScreen)
{
ASSERT(title);
ASSERT(width > 0);
ASSERT(height > 0);
WNDCLASSEX wcx;
PIXELFORMATDESCRIPTOR pfd;
RECT rect;
HGLRC hRCTemp;
DWORD style, exStyle;
int x, y, format;
// обнуляем состояние окна
memset(&g_window, 0, sizeof(g_window));
// обнуляем состояние ввода
memset(&g_input, 0, sizeof(g_input));
// определим указатель на функцию создания расширенного контекста OpenGL
PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribsARB = NULL;
// укажем атрибуты для создания расширенного контекста OpenGL
int attribs[] =
{
WGL_CONTEXT_MAJOR_VERSION_ARB, 3,
WGL_CONTEXT_MINOR_VERSION_ARB, 3,
WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,
WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_CORE_PROFILE_BIT_ARB,
0
};
// установим зерно генератора случайных чисел
srand((unsigned int) time(NULL));
// инциализация таймера
QueryPerformanceFrequency(&g_qpc);
ASSERT(g_qpc.QuadPart > 0);
g_timerFrequency = 1.0 / (double)g_qpc.QuadPart;
g_hInstance = (HINSTANCE)GetModuleHandle(NULL);
// регистрация класса окна
memset(&wcx, 0, sizeof(wcx));
wcx.cbSize = sizeof(wcx);
wcx.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wcx.lpfnWndProc = (WNDPROC)GLWindowProc;
wcx.hInstance = g_hInstance;
wcx.lpszClassName = GLWINDOW_CLASS_NAME;
wcx.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wcx.hCursor = LoadCursor(NULL, IDC_ARROW);
if (!RegisterClassEx(&wcx))
{
LOG_ERROR("RegisterClassEx fail (%d)\n", GetLastError());
return false;
}
// стили окна
style = WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
exStyle = WS_EX_APPWINDOW;
// выровняем окно по центру экрана
x = (GetSystemMetrics(SM_CXSCREEN) - width) / 2;
y = (GetSystemMetrics(SM_CYSCREEN) - height) / 2;
rect.left = x;
rect.right = x + width;
rect.top = y;
rect.bottom = y + height;
// подгоним размер окна под стили
AdjustWindowRectEx (&rect, style, FALSE, exStyle);
// создаем окно
g_hWnd = CreateWindowEx(exStyle, GLWINDOW_CLASS_NAME, title, style, rect.left, rect.top,
rect.right - rect.left, rect.bottom - rect.top, NULL, NULL, g_hInstance, NULL);
if (!g_hWnd)
{
LOG_ERROR("CreateWindowEx fail (%d)\n", GetLastError());
return false;
}
// получим дескриптор контекста окна
g_hDC = GetDC(g_hWnd);
if (!g_hDC)
{
LOG_ERROR("GetDC fail (%d)\n", GetLastError());
return false;
}
// описание формата пикселей
memset(&pfd, 0, sizeof(pfd));
pfd.nSize = sizeof(pfd);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 32;
pfd.cDepthBits = 24;
// запросим формат пикселей, ближайший к описанному выше
format = ChoosePixelFormat(g_hDC, &pfd);
if (!format || !SetPixelFormat(g_hDC, format, &pfd))
{
LOG_ERROR("Setting pixel format fail (%d)\n", GetLastError());
return false;
}
// создадим временный контекст рендеринга
// он нужен для получения функции wglCreateContextAttribsARB
hRCTemp = wglCreateContext(g_hDC);
if (!hRCTemp || !wglMakeCurrent(g_hDC, hRCTemp))
{
LOG_ERROR("Сreating temp render context fail (%d)\n", GetLastError());
return false;
}
// получим адрес функции установки атрибутов контекста рендеринга
OPENGL_GET_PROC(PFNWGLCREATECONTEXTATTRIBSARBPROC, wglCreateContextAttribsARB);
// временный контекст OpenGL нам больше не нужен, удаляем его
wglMakeCurrent(NULL, NULL);
wglDeleteContext(hRCTemp);
// создадим расширенный контекст с поддержкой OpenGL 3
g_hRC = wglCreateContextAttribsARB(g_hDC, 0, attribs);
if (!g_hRC || !wglMakeCurrent(g_hDC, g_hRC))
{
LOG_ERROR("Creating render context fail (%d)\n", GetLastError());
return false;
}
// вывод в лог-файл различной информации по OpenGL
OpenGLPrintDebugInfo();
// попробуем загрузить расширения OpenGL
if (!OpenGLInitExtensions())
return false;
// зададим размеры окна
GLWindowSetSize(width, height, fullScreen);
return true;
}
void GLWindowDestroy()
{
g_window.running = g_window.active = false;
GLWindowClear(g_window);
// восстановим разрешение экрана
if (g_window.fullScreen)
{
ChangeDisplaySettings(NULL, CDS_RESET);
g_window.fullScreen = false;
}
// удаляем контекст рендеринга
if (g_hRC)
{
wglMakeCurrent(NULL, NULL);
wglDeleteContext(g_hRC);
g_hRC = NULL;
}
// освобождаем контекст окна
if (g_hDC)
{
ReleaseDC(g_hWnd, g_hDC);
g_hDC = NULL;
}
// удаляем окно
if (g_hWnd)
{
DestroyWindow(g_hWnd);
g_hWnd = NULL;
}
// удаляем класс окна
if (g_hInstance)
{
UnregisterClass(GLWINDOW_CLASS_NAME, g_hInstance);
g_hInstance = NULL;
}
}
void GLWindowSetSize(int width, int height, bool fullScreen)
{
ASSERT(width > 0);
ASSERT(height > 0);
RECT rect;
DWORD style, exStyle;
DEVMODE devMode;
LONG result;
int x, y;
// если мы возвращаемся из полноэкранного режима
if (g_window.fullScreen && !fullScreen)
ChangeDisplaySettings(NULL, CDS_RESET);
g_window.fullScreen = fullScreen;
// если необходим полноэкранный режим
if (g_window.fullScreen)
{
memset(&devMode, 0, sizeof(devMode));
devMode.dmSize = sizeof(devMode);
devMode.dmPelsWidth = width;
devMode.dmPelsHeight = height;
devMode.dmBitsPerPel = GetDeviceCaps(g_hDC, BITSPIXEL);
devMode.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;
// попытка установить полноэкранный режим
result = ChangeDisplaySettings(&devMode, CDS_FULLSCREEN);
if (result != DISP_CHANGE_SUCCESSFUL)
{
LOG_ERROR("ChangeDisplaySettings fail %dx%d (%d)\n", width, height, result);
g_window.fullScreen = false;
}
}
// если был запрошен полноэкранный режим и его удалось установить
if (g_window.fullScreen)
{
style = WS_POPUP;
exStyle = WS_EX_APPWINDOW | WS_EX_TOPMOST;
x = y = 0;
} else // если полноэкранный режим не нужен, или его не удалось установить
{
style = WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
exStyle = WS_EX_APPWINDOW;
// выровняем окно по центру экрана
x = (GetSystemMetrics(SM_CXSCREEN) - width) / 2;
y = (GetSystemMetrics(SM_CYSCREEN) - height) / 2;
}
rect.left = x;
rect.right = x + width;
rect.top = y;
rect.bottom = y + height;
// подгоним размер окна под стили
AdjustWindowRectEx (&rect, style, FALSE, exStyle);
// установим стили окна
SetWindowLong(g_hWnd, GWL_STYLE, style);
SetWindowLong(g_hWnd, GWL_EXSTYLE, exStyle);
// обновим позицию окна
SetWindowPos(g_hWnd, HWND_TOP, rect.left, rect.top,
rect.right - rect.left, rect.bottom - rect.top,
SWP_FRAMECHANGED);
// покажем окно на экране
ShowWindow(g_hWnd, SW_SHOW);
SetForegroundWindow(g_hWnd);
SetFocus(g_hWnd);
UpdateWindow(g_hWnd);
// получим размеры окна
GetClientRect(g_hWnd, &rect);
g_window.width = rect.right - rect.left;
g_window.height = rect.bottom - rect.top;
// центрируем курсор относительно окна
InputSetCursorPos(g_window.width / 2, g_window.height / 2);
OPENGL_CHECK_FOR_ERRORS();
}
// основной цикл окна
int GLWindowMainLoop()
{
MSG msg;
double deltaTime, beginFrameTime, fixedTimeStep;
// пользовательская инициализация
g_window.running = g_window.active = GLWindowInit(g_window);
deltaTime = 0.0;
fixedTimeStep = 1.0 / 100.0;
while (g_window.running)
{
// обработаем сообщения из очереди сообщений
while (PeekMessage(&msg, g_hWnd, 0, 0, PM_NOREMOVE))
{
if(!GetMessage(&msg, g_hWnd, 0, 0) || msg.message == WM_QUIT)
{
g_window.running = false;
break;
}
TranslateMessage(&msg);
DispatchMessage(&msg);
}
// начало обработки текущего кадра
beginFrameTime = GetTimerTicks();
// обработка ввода
GLWindowInput(g_window);
// если окно в рабочем режиме и активно
if (g_window.running && g_window.active)
{
// рендер сцены
GLWindowRender(g_window);
glFinish();
SwapBuffers(g_hDC);
// обновление сцены
deltaTime += GetTimerTicks() - beginFrameTime;
while (deltaTime >= fixedTimeStep)
{
GLWindowUpdate(g_window, deltaTime);
deltaTime -= fixedTimeStep;
}
}
}
g_window.running = g_window.active = false;
return 0;
}
LRESULT CALLBACK GLWindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
case WM_LBUTTONDOWN:
case WM_LBUTTONUP:
case WM_RBUTTONDOWN:
case WM_RBUTTONUP:
case WM_MBUTTONDOWN:
case WM_MBUTTONUP:
{
g_input.cursorPos[0] = (int)LOWORD(lParam);
g_input.cursorPos[1] = (int)HIWORD(lParam);
if (msg == WM_LBUTTONDOWN || msg == WM_LBUTTONUP)
g_input.buttonState[0] = (msg == WM_LBUTTONDOWN ? INPUT_PRESSED : INPUT_UP);
if (msg == WM_RBUTTONDOWN || msg == WM_RBUTTONUP)
g_input.buttonState[1] = (msg == WM_RBUTTONDOWN ? INPUT_PRESSED : INPUT_UP);
if (msg == WM_MBUTTONDOWN || msg == WM_MBUTTONUP)
g_input.buttonState[2] = (msg == WM_MBUTTONDOWN ? INPUT_PRESSED : INPUT_UP);
return FALSE;
}
case WM_MOUSEMOVE:
{
g_input.cursorPos[0] = (int)LOWORD(lParam);
g_input.cursorPos[1] = (int)HIWORD(lParam);
return FALSE;
}
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
{
if (wParam < 256 && (lParam & 0x40000000) == 0)
g_input.keyState[wParam] = INPUT_PRESSED;
return FALSE;
}
case WM_KEYUP:
case WM_SYSKEYUP:
{
if (wParam < 256)
g_input.keyState[wParam] = INPUT_UP;
return FALSE;
}
case WM_SETFOCUS:
case WM_KILLFOCUS:
{
g_window.active = (msg == WM_SETFOCUS);
return FALSE;
}
case WM_ACTIVATE:
{
g_window.active = (LOWORD(wParam) != WA_INACTIVE);
return FALSE;
}
case WM_CLOSE:
{
g_window.running = g_window.active = false;
PostQuitMessage(0);
return FALSE;
}
case WM_SYSCOMMAND:
{
switch (wParam & 0xFFF0)
{
case SC_SCREENSAVE:
case SC_MONITORPOWER:
{
if (g_window.fullScreen)
return FALSE;
break;
}
case SC_KEYMENU:
case SC_TASKLIST:
{
return FALSE;
}
}
break;
}
case WM_ERASEBKGND:
{
return FALSE;
}
}
return DefWindowProc(hWnd, msg, wParam, lParam);
}
bool InputIsKeyDown(uint8_t key)
{
return (g_input.keyState[key] != 0);
}
bool InputIsKeyPressed(uint8_t key)
{
bool pressed = (g_input.keyState[key] == INPUT_PRESSED);
g_input.keyState[key] = INPUT_DOWN;
return pressed;
}
bool InputIsButtonDown(uint8_t button)
{
ASSERT(button < 3);
return (g_input.buttonState[button] != 0);
}
bool InputIsButtonClick(uint8_t button)
{
ASSERT(button < 3);
bool pressed = (g_input.buttonState[button] == INPUT_PRESSED);
g_input.buttonState[button] = INPUT_DOWN;
return pressed;
}
void InputGetCursorPos(int *x, int *y)
{
ASSERT(x);
ASSERT(y);
*x = g_input.cursorPos[0];
*y = g_input.cursorPos[1];
}
void InputSetCursorPos(int x, int y)
{
POINT pos = {x, y};
ClientToScreen(g_hWnd, &pos);
SetCursorPos(pos.x, pos.y);
g_input.cursorPos[0] = x;
g_input.cursorPos[1] = y;
}
void InputShowCursor(bool visible)
{
ShowCursor(visible ? TRUE : FALSE);
}
| [
"osipov.enterprise@gmail.com"
] | osipov.enterprise@gmail.com |
0fab2f362c1bc1e6518f4f790ebf9306dbd1ab39 | bc472f5c228a1d9e0f67f3b9d71a30c09048c024 | /Acquisition_Board_Dll/Acquisition_Board_Dll/Histogram_Module.h | 688cccc6b32eb4cafd52d3f5f4d11c37615c377b | [] | no_license | blanchardsimon/Programme-C-carte-Acquistion | 040dfb1d232558434ab0396cf8ac282b115106d1 | 508931873d3a678de21e2fbd8dd3818f31bc4096 | refs/heads/master | 2016-09-05T18:53:20.814299 | 2011-11-10T19:57:49 | 2011-11-10T19:57:49 | 2,638,265 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,325 | h | // Histogram_Module.h
//
// This file contain the histogram_module class definition and all the thread needed by his methode
//
#ifndef _HISTOGRAM_MODULE_H_
#define _HISTOGRAM_MODULE_H_
//**********************************************************************************************************************
// Include
//**********************************************************************************************************************
#include "stdafx.h"
#include "AppDll.h"
#include "Acq_Define_Constant.h"
#include "Communication_Structure.h"
#include "Acq_Function.h"
#include "Acq_data_container_class.h"
//**********************************************************************************************************************
// Class definition
//**********************************************************************************************************************
////////////////////////////////////////////////////////////////////
// histogram_module class
////////////////////////////////////////////////////////////////////
// contain all the mothode and variable needed by the module
class Histogram_Module
{
// decalration of private member
private:
// constant
static const unsigned int NB_MAX_THREADS = 8;
static const unsigned int NB_OF_BUFFER = 2;
static const unsigned int THREADS_BUFFER_MEM_LENGTH = 512;
static const unsigned int NB_STEP_8BITS = 256;
static const unsigned int NB_STEP_14BITS = 16384;
static const unsigned int HIST_8BITS_BUFFER_SIZE = 33554432;
// Handle
HANDLE h_gestion_work;
// Pointer
// variable
// decalration of public member
public:
// Handle
HANDLE h_workthread[NB_MAX_THREADS];
// Pointer
Acq_Data_Container * acq_data;
unsigned char * buffer[NB_OF_BUFFER];
// structure
Histogram_Result_struct histogram_result;
// Variable
unsigned int samples_by_buffer; // sample per buffer for 14bits correlation and 14 histogram
unsigned __int64 nb_sample;
double time_to_acq_sec; // time in seconde to acquire
double sampling_rate;
unsigned int f_workthread_start[NB_MAX_THREADS]; // start bit for the workthread
unsigned int f_workthread_stop; // stop bit for the working thread
unsigned __int64 * work_histogram_ptr[NB_MAX_THREADS]; // pointer to array containning the histogram for each working thread
unsigned int buffer_2_use;
TIME_VAR_TYPE acquire_time_start; // variable to mesure acquisition time
double acquire_time; // variable to mesure acquisition time
TIME_VAR_TYPE threads_time_start; // variable to mesure working thread execution time
unsigned char thread_finish_count;
double executtime_sec;
unsigned __int64 histogram0[16384];
unsigned __int64 histogram1[16384];
unsigned __int64 histogram2[16384];
unsigned __int64 histogram3[16384];
unsigned __int64 histogram4[16384];
unsigned __int64 histogram5[16384];
unsigned __int64 histogram6[16384];
unsigned __int64 histogram7[16384];
unsigned __int64 histogram_14bits[16384];
unsigned __int64 histogram_8bits[256];
unsigned __int64 total_sample;
double average;
double variance;
double skewness;
// Methode
Histogram_Module(Acq_Data_Container * ptr); // constructor
~Histogram_Module(); // destructor
void Compute_Histogram_Result();
int Allocate_Memory();
int Init_Working_Threads_Hist14();
int Init_Working_Threads_Hist8();
void Display_Setting();
void Display_Result();
void Store_Result();
Histogram_Result_struct * Get_Result();
unsigned __int64 * Get_Data();
unsigned int Get_NB_MAX_THREADS();
unsigned int Get_NB_OF_BUFFER();
unsigned int Get_THREADS_BUFFER_MEM_LENGTH();
int Run_Module();
};
//**********************************************************************************************************************
// Class thread function definition
//**********************************************************************************************************************
DWORD WINAPI Gestion_Work_Hist_8bits(Histogram_Module * hist_module);
DWORD WINAPI Histogram_8bits_FPGA(Histogram_Module * hist_module); //(not operationnal)
DWORD WINAPI Gestion_Work_Hist_14bits(Histogram_Module * hist_module);
DWORD WINAPI Work_Thread_Hist8_0(Histogram_Module * hist_module);
DWORD WINAPI Work_Thread_Hist8_1(Histogram_Module * hist_module);
DWORD WINAPI Work_Thread_Hist8_2(Histogram_Module * hist_module);
DWORD WINAPI Work_Thread_Hist8_3(Histogram_Module * hist_module);
DWORD WINAPI Work_Thread_Hist8_4(Histogram_Module * hist_module);
DWORD WINAPI Work_Thread_Hist8_5(Histogram_Module * hist_module);
DWORD WINAPI Work_Thread_Hist8_6(Histogram_Module * hist_module);
DWORD WINAPI Work_Thread_Hist8_7(Histogram_Module * hist_module);
DWORD WINAPI Work_Thread_Hist14_0(Histogram_Module * hist_module);
DWORD WINAPI Work_Thread_Hist14_1(Histogram_Module * hist_module);
DWORD WINAPI Work_Thread_Hist14_2(Histogram_Module * hist_module);
DWORD WINAPI Work_Thread_Hist14_3(Histogram_Module * hist_module);
DWORD WINAPI Work_Thread_Hist14_4(Histogram_Module * hist_module);
DWORD WINAPI Work_Thread_Hist14_5(Histogram_Module * hist_module);
DWORD WINAPI Work_Thread_Hist14_6(Histogram_Module * hist_module);
DWORD WINAPI Work_Thread_Hist14_7(Histogram_Module * hist_module);
#endif | [
"blas2310@REULETLAB2.ad.physique.usherb.ca"
] | blas2310@REULETLAB2.ad.physique.usherb.ca |
788376c7b25bf508448ead3f6bde6c5dc3cd1889 | 4146b6ede0ee8af95139ac4d17d52e00948f099e | /AIReference/Solver.h | 69c2f3e52c4b1510200999754593736e16f6697c | [] | no_license | esmelusina/AIReferenceImplementation | 2401f9d1644a3baca105f71c16e6e988130b6f0e | 35cd7ec4f5d93f4837597bc1d20f6cdf24769d95 | refs/heads/master | 2021-01-01T03:55:05.872308 | 2016-04-20T23:03:59 | 2016-04-20T23:03:59 | 56,643,176 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,140 | h | #pragma once
#include "Graph.h"
#include <set>
struct Meta
{
Meta()
: node(UINT_MAX), // The node's ID for this metadata (see Graph.h)
prev(UINT_MAX), // Previous node, for pathing
// Bookkeeping data
g(FLT_MAX), // Actual Cost
h(0), // Guessed Cost
f(g), // Combined Cost
DOS(0), // Degrees of Separation
state(STATE::undiscovered) // State, for frontier management
{}
size_t node, prev;
float g, h, f;
unsigned DOS;
enum class STATE { undiscovered, frontier, explored } state;
};
inline bool Dijkstra (const Meta *a, const Meta *b) { return a->g < b->g; }
inline bool Greedy (const Meta *a, const Meta *b) { return a->h < b->h; }
inline bool AStar (const Meta *a, const Meta *b) { return a->f < b->f; }
inline bool DepthFirst (const Meta *a, const Meta *b) { return a->DOS > b->DOS; }
inline bool BreadthFirst (const Meta *a, const Meta *b) { return a->DOS < b->DOS; }
template<typename T>
std::list<T> FindPath(const Graph<T> &graph, const T &start, const T &goal,
float(*Heuristic )(const T&, const T&),
bool (*Comparison)(const Meta *, const Meta *), float searchRange = 0.0001f, float fudgeEquals = 0.0001f)
{
//setup data
std::list<T> path;
std::list<Meta*> frontier;
std::map<size_t, Meta> metadata;
// find indices for the starting nodes
int startNode = graph.findNode(start, Heuristic, searchRange);
int goalNode = graph.findNode(goal , Heuristic, searchRange);
assert(startNode >= 0 && goalNode >= 0);
Meta *current = nullptr;
bool solved = false;
// Initialize the starting node's metadata and put it into the frontier
Meta ts;
ts.node = startNode;
ts.prev = startNode;
ts.g = 0;
ts.h = Heuristic(graph.getNodeData(startNode), goal);
ts.f = ts.h;
ts.state = Meta::STATE::frontier;
ts.DOS = 0;
metadata[startNode] = ts;
frontier.push_back(&metadata[startNode]);
while (!frontier.empty())
{
// Get node off of frontier
frontier.sort(Comparison);
current = frontier.front();
frontier.pop_front();
// victory!
if (solved = current->node == goalNode) break;
// A node is explored if all its neighbors are
// in the frontier
current->state = Meta::STATE::explored;
// evaluate metadata and populate the frontier
for each(auto eid in graph.getNodeEdges(current->node))
if(metadata[graph.getEdgeData(eid).next].state != Meta::STATE::explored)
{
// accumulate new meta data for the node
auto edge = graph.getEdgeData(eid);
Meta t;
t.prev = edge.prev;
t.node = edge.next;
t.g = edge.cost + current->g;
t.h = Heuristic(graph.getNodeData(t.node), goal);
t.f = t.g + t.h;
t.DOS = current->DOS + 1;
t.state = Meta::STATE::frontier;
// push into frontier if necessary
if (metadata[t.node].state == Meta::STATE::undiscovered)
frontier.push_back(&metadata[t.node]);
// update bookkeeping if better path found
if (t.g < metadata[t.node].g)
metadata[t.node] = t;
}
}
if (!solved) return path; // Path is empty.
// check to see if the goal node is close enough to the goal value
if(Heuristic(goal, graph.getNodeData(current->node)) > fudgeEquals)
path.push_front(goal); // if it isn't, push the goal value into the path
for (; current->node != startNode; current = &metadata[current->prev])
path.push_front(graph.getNodeData(current->node));
path.push_front(graph.getNodeData(current->node));
if (Heuristic(start, graph.getNodeData(current->node)) > fudgeEquals)
path.push_front(start);
return path;
}
| [
"esmelusina@gmail.com"
] | esmelusina@gmail.com |
584662cf36bf8d906bcf3da38866fc4d854304a8 | 04a524c0b4df3ca0fccc6343a694b332aec6e523 | /tju/3274.cpp | c94207251d94b02b7182a327213b5025dacb1e96 | [
"MIT"
] | permissive | Victoralin10/ACMSolutions | 93ce41fb6a250c021ce007913c4b8d809adeee6a | 6d6e50da87b2bc455e953629737215b74b10269c | refs/heads/master | 2021-01-21T04:40:21.643679 | 2018-09-07T01:54:50 | 2018-09-07T01:54:50 | 53,037,723 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,820 | cpp | /**
* Title: 3274. Rescue Me II
* Author: Victor Cueva Llanos
* Email: Ingvcueva@gmail.com
**/
#include <bits/stdc++.h>
#define MOD 1023
#define MAXN 900005
using namespace std;
int A2[MAXN], I[MAXN], F[MAXN];
int pow(int b, int e) {
int ans = 1;
while (e) {
if ((e&1)) ans = (ans*b) & MOD;
b = (b*b) & MOD;
e >>= 1;
}
return ans;
}
int cmb(int n, int m) {
int nrd = A2[n] - A2[m] - A2[n-m];
if (nrd >= 10) return 0;
int ans = (F[n]*I[m]) & MOD;
ans = (ans*I[n-m]) & MOD;
ans = (ans*(1<<nrd)) & MOD;
return ans;
}
int solve(int x, int y, int z) {
int ans = 0;
for (int i = 1; i < x; i++) {
ans += cmb(z + i - 1, i)*cmb(y + x - i, y);
ans += cmb(y + i - 1, i)*cmb(z + x - i, z);
ans &= MOD;
}
for (int i = 1; i < y; i++) {
ans += cmb(z + i - 1, i)*cmb(x + y - i, x);
ans += cmb(x + i - 1, i)*cmb(z + y - i, z);
ans &= MOD;
}
for (int i = 1; i < z; i++) {
ans += cmb(x + i - 1, i)*cmb(y + z - i, y);
ans += cmb(y + i - 1, i)*cmb(x + z - i, x);
ans &= MOD;
}
ans += cmb(y + z, y);
ans += cmb(y + x, y);
ans += cmb(x + z, x);
return ans & MOD;
}
int main(int nargs, char **args) {
// clock_t _inicio = clock();
A2[0] = 0;
I[0] = 1;
F[0] = 1;
for (int i = 1; i < MAXN; i++) {
int nrd = 0, ci = i;
while (!(ci&1)) {
nrd++;
ci >>= 1;
}
A2[i] = A2[i-1] + nrd;
F[i] = (F[i-1]*ci) & MOD;
I[i] = pow(F[i], 511);
}
int x, y, z;
while (scanf("%d%d%d", &x, &y, &z) != EOF) {
printf("%d\n", solve(x, y, z));
}
// printf("Time elapsed: %ld ms\n", (clock() - _inicio)/1000);
return 0;
}
| [
"Ingvcueva@gmail.com"
] | Ingvcueva@gmail.com |
fd655e908f27d49eb9ceecc4a8373c5058e138de | edb4f249883679792e689eea9fcf969f331c28ba | /hackerank/bonappetit.cpp | 0ace95f08492a34c180a6fe2b1df21572a98e9bb | [] | no_license | pavelsimo/ProgrammingContest | 2845bddc2a61444bf2c667aa5f77e34f7a324ebc | a2c52be868bcd480a682b872fed85b344731497b | refs/heads/master | 2021-01-25T03:48:05.415007 | 2017-11-11T14:39:51 | 2017-11-11T14:39:51 | 25,308,102 | 4 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 790 | cpp | /* ========================================================================
$File:
$Date:
$Creator: Pavel Simo
======================================================================== */
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <limits.h>
#include <stdbool.h>
int main() {
int n;
int k;
scanf("%i %i", &n, &k);
int x;
int sum = 0;
int d = 0;
for(int i = 0; i < n; i++) {
scanf("%d", &x);
sum += x;
if (i == k) d = x;
}
int charged;
scanf("%i", &charged);
int res = charged - ((sum - d) / 2);
if (res > 0) {
printf("%d\n", res);
} else {
printf("Bon Appetit\n");
}
return 0;
}
| [
"pavel.simo@gmail.com"
] | pavel.simo@gmail.com |
9a9ef0a7529e3408b28caf42fbbc14a2e99bb485 | d841b8ac90be4000b95d06fe9706377acbb30238 | /util/posix_logger.h | 9c891e98c33d3c74a589e6cc3518d10537a527ed | [] | no_license | lebinhe/components | 3ee27ca035545fdd9d5d2cca4e83ad93d4fabdac | b2f74a7d6e119d83a40c2dbad88ac506edcc8846 | refs/heads/master | 2020-03-08T03:58:58.349205 | 2018-07-09T12:13:49 | 2018-07-09T12:13:49 | 127,907,859 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,710 | h | #ifndef COMPONENTS_UTIL_POSIX_LOGGER_H_
#define COMPONENTS_UTIL_POSIX_LOGGER_H_
#include <algorithm>
#include <stdio.h>
#include <sys/time.h>
#include <time.h>
#include "components/util/env.h"
class PosixLogger : public Logger {
public:
PosixLogger(FILE* f, uint64_t (*gettid)()) : file_(f), gettid_(gettid) { }
virtual ~PosixLogger() {
fclose(file_);
}
virtual void Logv(const char* format, va_list ap) {
const uint64_t thread_id = (*gettid_)();
// We try twice: the first time with a fixed-size stack allocated buffer,
// and the second time with a much larger dynamically allocated buffer.
char buffer[500];
for (int iter = 0; iter < 2; iter++) {
char* base;
int bufsize;
if (iter == 0) {
bufsize = sizeof(buffer);
base = buffer;
} else {
bufsize = 30000;
base = new char[bufsize];
}
char* p = base;
char* limit = base + bufsize;
struct timeval now_tv;
gettimeofday(&now_tv, nullptr);
const time_t seconds = now_tv.tv_sec;
struct tm t;
localtime_r(&seconds, &t);
p += snprintf(p, limit - p,
"%04d/%02d/%02d-%02d:%02d:%02d.%06d %llx ",
t.tm_year + 1900,
t.tm_mon + 1,
t.tm_mday,
t.tm_hour,
t.tm_min,
t.tm_sec,
static_cast<int>(now_tv.tv_usec),
static_cast<long long unsigned int>(thread_id));
// Print the message
if (p < limit) {
va_list backup_ap;
va_copy(backup_ap, ap);
p += vsnprintf(p, limit - p, format, backup_ap);
va_end(backup_ap);
}
// Truncate to available space if necessary
if (p >= limit) {
if (iter == 0) {
continue;
} else {
p = limit - 1;
}
}
// Add newline if necessary
if (p == base || p[-1] != '\n') {
*p++ = '\n';
}
assert(p <= limit);
fwrite(base, 1, p - base, file_);
fflush(file_);
if (base != buffer) {
delete[] base;
}
break;
}
}
private:
FILE* file_;
uint64_t (*gettid_)(); // Return the thread id for the current thread
};
#endif // COMPONENTS_UTIL_POSIX_LOGGER_H_
| [
"iceriver12@gmail.com"
] | iceriver12@gmail.com |
214cc878c1dde50f177bf49af8e26a4f2e6bf5d1 | 963e242f252fdcc8b5b0ae9d174d85bcc2474d2a | /src/target_code/src/intermediate_code/include/intermediate_code.h | 199899cf474bf809e77c77c39448239f4766cb28 | [] | no_license | VakrasVasileios/compilers | ab1210394425040051fb4f2852c9de998a3ae99f | 2840ea810ffa8430058e9a5e5a108661251866d2 | refs/heads/main | 2023-07-18T17:37:04.519858 | 2021-06-20T20:10:17 | 2021-06-20T20:10:17 | 343,479,856 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,497 | h | #ifndef INTERMEDIATE_CODE_H
#define INTERMEDIATE_CODE_H
#include <vector>
#include <stack>
#include "../../../../../util/contract/include/contract.h"
#include "../../syntax_analysis/include/syntax_analysis.h"
#include "quad.h"
#include "stmt.h"
#include "loop_stmt.h"
#include "while_stmt.h"
#include "for_stmt.h"
#include "func_def_stmt.h"
#include "if_stmt.h"
/**
* @brief Namespace for generating intermediate code quads.
*
*/
namespace target_code
{
namespace intermediate_code
{
/**
* @brief A list of all the intermediate code emitted
* quads.
*
*/
extern std::vector<Quad*> quads;
/**
* @brief A stack of all the parsed loop statements.
*
*/
extern std::stack<LoopStmt*> loop_stmts;
/**
* @brief A stack of all the parsed while loop statements.
*
*/
extern std::stack<WhileStmt*> while_stmts;
/**
* @brief A stack of all the parsed for loop statements.
*
*/
extern std::stack<ForStmt*> for_stmts;
/**
* @brief A stack of all the parsed function definition statements.
*
*/
extern std::stack<FuncDefStmt*> func_def_stmts;
/**
* @brief A stack of all the parsed if statements.
*
*/
extern std::stack<IfStmt*> if_stmts;
/**
* @brief A stack of all the parsed statements.
*
*/
extern std::list<StmtType> stmt_stack;
/**
* @brief Logs a runtime warning, parsed at a line, with a message.
*
* @param msg the message of the runtime warning, not null
* @param line the line on which the warning is parsed, greater or
* equal to zero
*/
void LogWarning(std::string msg, unsigned int line);
/**
* @brief Logs all of the previously emitted quads to an
* output.
*
* @param output the output on which to log all of the previously
* emitted quads.
*/
void LogQuads(std::ostream& output);
/**
* @brief Inserts a new hidden symbol at the current scope, in
* case the generated name hasn't been already defined, else returns
* the defined hidden symbol.
*
* @param type the type of the hidden symbol
* @param index the index of the hidden table item symbol,
* the symbol must be a table item
*
* @return a new hidden symbol at the current scope, in
* case the generated name hasn't been already defined, else
* the defined hidden symbol, not null
*/
expression::Symbol* NewTemp(expression::ExprType type,
expression::Expression* index);
/**
* @brief Resets the hidden symbol name counter, that is responsible
* for generating new hidden symbols.
*
*/
void ResetTemp();
/**
* @brief Emits a new quad, with its fields.
*
* @param op the opcode of the emitted quad
* @param result the result of the emitted quad, can be null
* @param arg1 the arg1 of the emitted quad, can be null
* @param arg2 the arg2 of the emitted quad, can be null
* @param line the line of the emitted quad, can be null
*
* @return the emitted quad, not null
*/
Quad* Emit(Iopcode op, expression::Expression* result,
expression::Expression* arg1,
expression::Expression* arg2,
unsigned int line);
/**
* @brief Returns the label of the quad after the most
* recently emitted quad.
*
* @return the label of the quad after the most
* recently emitted quad, greater or equal to zero
*/
unsigned int NextQuadLabel();
/**
* @brief Emits a TABLEGETELEM quad, in case of a table
* item symbol
*
* @param sym the symbol to be checked if it is a table item,
* not null
* @param line the currently parsed line, greater or equal to zero
*
* @return the symbol in case it's not a table item, else
* a new hidden table item symbol, not null
*/
expression::Symbol* EmitIfTableItem(expression::Symbol* sym,
unsigned int line);
/**
* @brief Emits the quads of a member item symbol expression.
*
* @param sym the member item symbol expression, not null
* @param index the index of the member item symbol as a string
* @param line the currently parsed line, greater or equal to zero
*
* @return a new hidden table item symbol, not null
*/
expression::Symbol* MemberItem(expression::Symbol* sym,
const char* index, unsigned int line);
/**
* @brief Emits the quads of a call expression and
* creates a new call expression.
*
* @param called_symbol the called symbol, not null
* @param call_suffix the call suffix of the call, not null
* @param line the currently parsed line, greater or equal to zero
*
* @return the created call expression, not null
*/
expression::Call* MakeCall(expression::Symbol* called_symbol,
expression::CallSuffix* call_suffix,
unsigned int line);
/**
* @brief Backpatches all of the unpatched labels of the previously emitted
* jump/branch quads, in short circuit fashion.
*
* @param l_list the list of the unpatched labels of the previously emitted
* jump/branch quads
* @param q_label the label to patch the list of the unpatched labels of the
* previously emitted jump/branch quads
*/
void BackPatch(std::list<unsigned int> l_list,
unsigned int q_label);
/**
* @brief Concludes the short circuit evaluation for a boolean
* expression.
*
* @param expr the boolean expression for which the short circuit
* evaluation is to be concluded, not null
* @param line the currently parsed line, greater or equal to zero
*
* @return the new hidden variable generated for the emits of the
* short circuit evaluation, not null
*/
expression::Symbol* ConcludeShortCircuit(expression::BoolExpr* expr,
unsigned int line);
/**
* @brief Checks wether an arithmetic expression operation is valid.
*
* @param expr the arithmetic expression operation to be evaluated,
* not null
* @param line the currently parsed line, greater or equal to zero
*
* @return wether an arithmetic expression operation is valid
*/
bool IsValidArithmeticOp(expression::Expression* expr
, unsigned int line);
/**
* @brief Checks wether an arithmetic expression comparison is valid.
*
* @param expr the arithmetic expression comparison to be evaluated,
* not null
* @param line the currently parsed line, greater or equal to zero
*
* @return wether an arithmetic expression comparison is valid
*/
bool IsValidArithmeticComp(expression::Expression*
expr, unsigned int line);
/**
* @brief Checks wether an assignment expression is valid.
*
* @param expr the assignment expression to be evaluated,
* not null
* @param line the currently parsed line, greater or equal to zero
*
* @return wether an assignment expression is valid
*/
bool IsValidAssign(expression::Symbol* left_operand,
unsigned int line);
/**
* @brief Checks the validity of a break/continue quad.
*
* @return the validity of a break/continue quad
*/
bool IsValidBreakContinue();
/**
* @brief Checks wether a loop statement is being parsed.
*
* @return wether a loop statement is being parsed
*/
bool InLoop();
/**
* @brief Checks wether a function definition statement is being parsed.
*
* @return wether a function definition statement is being parsed
*/
bool InFuncDef();
}
}
#endif
| [
"stefanoss1498@gmail.com"
] | stefanoss1498@gmail.com |
cc10189e9feb1c485ecfd2dd57f9acd7d2c3d820 | 8c138073ff172613a436db90f5177ab8e3099135 | /q9.cpp | 8f19e824dace526e2d6e7d7d893b2a41729142d6 | [] | no_license | TeamSilverWing/Computer-Graphics-Assignments | e0536213c923e5c5f8ec7c1caca5a812e1e9c774 | d4b30b61a9ed2db532ad6aed4a2afd47dad9774c | refs/heads/master | 2021-01-11T19:44:03.452558 | 2016-10-30T12:56:25 | 2016-10-30T12:56:25 | 67,068,563 | 0 | 2 | null | 2017-10-31T13:46:41 | 2016-08-31T19:49:23 | C++ | UTF-8 | C++ | false | false | 1,621 | cpp | #include <GL/glut.h>
#include <stdio.h>
#include <math.h>
#include <iostream>
using namespace std;
void init(void)
{
glClearColor(1.0,1.0,1.0,0.0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(0.0,50.0,0.0,50.0);
}
void setPixel(GLint x,GLint y)
{
cout<<x<<", "<<y<<endl;
glBegin(GL_POINTS);
glVertex2i(x,y);
glEnd();
}
void plot_circle_points(int xCenter,int yCenter, int x, int y)
{
cout<<"Oct 1: "; setPixel(xCenter + y,yCenter + x);
cout<<"Oct 2: "; setPixel(xCenter + x,yCenter + y);
cout<<"Oct 3: "; setPixel(xCenter - x,yCenter + y);
cout<<"Oct 4: "; setPixel(xCenter - y,yCenter + x);
cout<<"Oct 5: "; setPixel(xCenter - y,yCenter - x);
cout<<"Oct 6: "; setPixel(xCenter - x,yCenter - y);
cout<<"Oct 7: "; setPixel(xCenter + x,yCenter - y);
cout<<"Oct 8: "; setPixel(xCenter + y,yCenter - x);
}
void circle_draw_mid_point(int xCenter, int yCenter, int radius)
{
int x = 0;
int y = radius;
int p = 1 - radius;
plot_circle_points(xCenter,yCenter, x,y);
while(x < y)
{
x++;
if(p < 0)
{
p += 2*x + 1;
}
else{
y--;
p += 2*(x-y) + 1;
}
plot_circle_points(xCenter,yCenter,x,y);
}
}
void update()
{
glTranslatef(8,8,0);
glClear(GL_COLOR_BUFFER_BIT);
glPointSize(3.0f);
// Marking Origin
glColor3f( 0 ,1, 0);
setPixel(0,0);
glColor3f( 1 ,0, 0);
circle_draw_mid_point(7,6,8);
glFlush();
}
int main(int argc,char **argv){
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowPosition(200,100);
glutInitWindowSize(640,480);
glutCreateWindow("Tutorial-1 Q9");
init();
glutDisplayFunc( update );
glutMainLoop();
return 0;
} | [
"anshulshah96@gmail.com"
] | anshulshah96@gmail.com |
52bc2d900721228b505dd77453533e85cff4a511 | 8c226f6fbb9a74c5230f1ec5b72e54242d18a62a | /Algos/Stacks And Queues/Nearest_Smaller_Element.cpp | b0b7ef5a31abeab9ca9b6e6bc40125e93db4fbfe | [] | no_license | ToDevelopersTeam/DS-Algos | 8ac23e2bc170ac5b5f032e49433b9fe7b3c926de | 5073c2c36d17569374f4736fc8f07379a111eafd | refs/heads/master | 2023-03-30T20:26:21.372008 | 2021-04-09T12:30:49 | 2021-04-09T12:30:49 | 522,973,009 | 0 | 0 | null | 2022-08-09T13:59:37 | 2022-08-09T13:59:36 | null | UTF-8 | C++ | false | false | 378 | cpp | vector<int> Solution::prevSmaller(vector<int> &A) {
vector<int> ans;
ans.resize(A.size());
stack<int> st;
for (int i = 0; i < A.size(); i++) {
while (!st.empty() && st.top() >= A[i]) st.pop();
if (st.empty()) {
ans[i] = -1;
} else {
ans[i] = st.top();
}
st.push(A[i]);
}
return ans;
} | [
"anish.mukherjee1996@gmail.com"
] | anish.mukherjee1996@gmail.com |
c4e0f534acf071fd125a43325420f59803d0d65e | 3d2d9cfd6cf274bc351e4357b9313444cbcf0751 | /CP13/String.h | 4bdf4da71d86baa0754e61d149b96447c1c3c958 | [] | no_license | blackeywong/CppPrimer | 82a819645d83bdf206a8631d0333de551b1c3eac | 75341936a875758539d5af697c7aabc789870b97 | refs/heads/master | 2021-05-23T09:11:53.267208 | 2020-04-05T11:14:30 | 2020-04-05T11:14:30 | 253,215,246 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,010 | h | #pragma once
#ifndef _STRING_H
#define _STRING_H
#include <memory>
using namespace std;
//13.44
class String {
friend ostream& operator<<(ostream& out, const String& s);
public:
String();
String(const char* s);
String(const String& s);
String(String&& s) noexcept;
String& operator=(const String& s);
String& operator=(String&& s) noexcept;
~String();
//14.16
bool operator==(const String& b) const;
bool operator!=(const String& b) const { return !(*this == b); }
//14.18
bool operator<(const String& b) const;
bool operator<=(const String& b) const { return *this < b || *this == b; }
bool operator>(const String& b) const { return b > *this; }
bool operator>=(const String& b) const { return b > *this || *this == b; }
//14.26
char& operator[](std::size_t n) { return *(element + n); }
const char& operator[](std::size_t n) const { return *(element + n); }
private:
void alloc_n_copy(const char* s, int size);
void free();
allocator<char> alloc;
char* element;
char* end;
};
#endif | [
"blackeywong@hotmail.com"
] | blackeywong@hotmail.com |
8e2643cdcb8c2c2cc842d77f9057cc93446875f6 | 023922d39d2dc2db93d153fe3116724430510015 | /OnlineGaming_Project1/Menu.h | 97db913b66f985968a82117d6e1df41557aa17d3 | [] | no_license | francis-carroll/OnlineGaming_Project1 | 25eb890a294538c86bb39ed2ac521a00690b72a7 | 7ad4ff3419d536909843675b619e09c0fa2f7bf4 | refs/heads/master | 2023-02-25T07:59:52.547153 | 2021-01-28T16:42:43 | 2021-01-28T16:42:43 | 319,598,270 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 692 | h | #pragma once
#include <SFML/Graphics.hpp>
#include <Button.h>
#include <Globals.h>
class Game;
using namespace std;
using namespace sf;
class Menu
{
public:
Menu(Game* t_game);
~Menu();
void update(Time t_dt);
void render(RenderWindow& t_window);
void handleInput(Event& t_event, RenderWindow& t_window);
private:
void setup();
void textInput(Event& t_event);
void animateCurrent(Time t_dt);
Game* m_game;
Button m_host;
Button m_join;
Button m_confirm;
Font m_font;
Text m_inputText;
string m_inputContents;
JoinType m_type = JoinType::None;
RectangleShape m_underline;
RectangleShape m_current;
bool m_animateCurrent;
Time m_animationTimer;
Text m_intro;
};
| [
"fcarroll29@gmail.com"
] | fcarroll29@gmail.com |
b49a80a3b641db07dc145218dff69d49a69ea667 | 17879403cafdd0d924352f58e431760b4548e5aa | /Util.cpp | 376da7588cdeff0fd7461a158c44fcf1d257e614 | [] | no_license | ELthomasoPostfix/TrafficSimulator | 2cc065b9803bf88e6f3e21b287fb3449bb55de67 | d9834cbfd29c410c13ae70f4c53a97be12f4b7b6 | refs/heads/master | 2022-08-25T16:26:10.222865 | 2020-05-27T02:35:06 | 2020-05-27T02:35:06 | 262,740,328 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 673 | cpp | //
// Created by Thomas Gueutal on 17.05.20.
//
#include "Util.h"
std::string Util::boolToString(const bool b) {
if (b) {
return "true";
} else {
return "false";
}
}
std::string Util::boolToArrowString(const bool isTwoWay, const bool LR) {
std::string arrow = "<--";
if (isTwoWay) arrow = "<-->";
else if (LR) arrow = "-->";
return arrow;
}
std::string Util::isTwoWayToString(bool twoWay) {
if (twoWay) {
return "twoWay";
} else {
return "oneWay";
}
}
std::string Util::boolToEnabledString(bool state) {
if (state) {
return "enabled";
} else {
return "disabled";
}
}
| [
"GueutalThomas@outlook.com"
] | GueutalThomas@outlook.com |
030473f9adf1c548512958136fe2e43c25700f7d | e9781716464add3d4b3d83973337bc2399d04260 | /C++ Lessons/Week 10 - Polymorphism/Poly incomplete/PolyWantAChracker/PolyWantAChracker/Driver.cpp | d83d5aa5e7e41c49e3045296cc32d7e834f1fb5a | [] | no_license | hal-oconnell/prog2100 | 2a668b1fb4a56946133a00eaaf27d2f3c6159354 | 68376a3667d2a47d1080ab9e0e235b8716808cb8 | refs/heads/master | 2021-07-13T07:29:44.573616 | 2017-10-17T16:45:01 | 2017-10-17T16:45:01 | 105,903,278 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 882 | cpp | //Driver.cpp file
#include <iostream>
#include <conio.h>
//#include "Vehicle.h"
//#include "Bicycle.h"
//#include "Boat.h"
using namespace std;
//prototypes
void withoutCasting();
void sliceExample();
void upCasting();
void downCasting();
void typeidExample();
void polyExample();
int main()
{
//withoutCasting();
//sliceExample();
//upCasting();
//downCasting();
//typeidExample();
//polyExample();
return 0;
}//end main
//example of method calls without casting
void withoutCasting()
{
}//end without Casting()
//example of slice
void sliceExample()
{
}//end method sliceExample
//example of upcasting
void upCasting()
{
}//end method upCasting
//example of downCasting
void downCasting()
{
}
//example of using typeid
void typeidExample()
{
}
//example of polymorphism aka a late bind
void polyExample()
{
} | [
"hal.oconnell@nscc.ca"
] | hal.oconnell@nscc.ca |
930a19f0c10c511f6c634684303834f22cb4c821 | 59578dc1381833bc9efa8730c48cfff045552b2d | /solution038.cpp | f5f62d887f16eb7c2c1ffb3f69539f80270f093a | [
"MIT"
] | permissive | motianlun99/leetcode | 46d5a27ee70ba3ec4ac8dbc539d24736c27659df | 956b2bcaddff1f6d49968ddb392a3641628374d9 | refs/heads/master | 2023-07-18T08:48:59.672012 | 2021-09-05T06:53:21 | 2021-09-05T06:53:21 | 399,427,627 | 0 | 0 | MIT | 2021-08-24T10:42:13 | 2021-08-24T10:42:12 | null | UTF-8 | C++ | false | false | 811 | cpp | /**
* Count and Say
*
* cpselvis(cpselvis@gmail.com)
* September 12th, 2016
*/
#include<iostream>
using namespace std;
class Solution {
public:
string countAndSay(int n) {
string ret = "1";
for (int i = 1; i < n; i ++)
{
int count = 1;
string tmp = "";
for (int j = 1; j < ret.size(); j ++)
{
if (ret[j] == ret[j - 1])
{
count ++;
}
else
{
tmp += to_string(count);
tmp += ret[j - 1];
count = 1;
}
}
tmp += to_string(count);
tmp += ret[ret.size() - 1];
ret = tmp;
}
return ret;
}
};
int main(int argc, char **argv)
{
Solution s;
cout << s.countAndSay(1) << endl;
cout << s.countAndSay(2) << endl;
cout << s.countAndSay(3) << endl;
cout << s.countAndSay(4) << endl;
cout << s.countAndSay(5) << endl;
}
| [
"cpselvis@gmail.com"
] | cpselvis@gmail.com |
b4d023d0838d07075241773b6cdf4c5903ec1319 | bc421359775657f09c88dddfd69473a12f71bca7 | /Uva solutaion/p1124.cpp | 987457822ac823f12c6ec88979384d2005d5600d | [] | no_license | mdnaimur/AllProgramCoding | c31b058071b0b1b18c968edded56a9980e265eb9 | b67ad04373404771a3bd629fe30301c1bdcf8b80 | refs/heads/master | 2021-02-09T10:35:34.774706 | 2020-03-31T04:30:02 | 2020-03-31T04:43:33 | 244,271,890 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 156 | cpp | #include<iostream>
using namespace std;
int main()
{
char a[1000];
while(cin.getline(a,sizeof(a))){
cout<<a<<endl;
}
return 0;
}
| [
"mdnaimurr@gmail.com"
] | mdnaimurr@gmail.com |
48dc3f8abd97d471ee8765adf25e398e11b24089 | 344be5840be33108d6f703ed05d8952fb16f63f1 | /opt/outliner/Outliner.cpp | e54c865cb9919d17a25dab338cc7f6fbe3de81f2 | [
"MIT"
] | permissive | jsjxsy/redex | 4ebfaf46534c7d18f6a9f9ebfd74288f9ea347d3 | 1fe1f97ea0b70cfa0768d9bbdf4d5e585c766cab | refs/heads/master | 2020-09-02T08:01:39.757308 | 2019-11-01T22:03:31 | 2019-11-01T22:05:18 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,727 | cpp | /*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#include "Outliner.h"
#include <algorithm>
#include <map>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include "Creators.h"
#include "DexAsm.h"
#include "DexClass.h"
#include "DexUtil.h"
#include "IRCode.h"
#include "IRInstruction.h"
#include "ReachableClasses.h"
#include "RedexResources.h"
#include "Trace.h"
#include "Walkers.h"
#include "Warning.h"
static Outliner s_pass;
namespace {
constexpr const char* DISPATCH_CLASS_NAME = "Lcom/facebook/redex/Outlined;";
constexpr const char* DISPATCH_METHOD_NAME = "$dispatch$throws";
using outlined_t = std::tuple<DexType*, DexString*>;
using namespace dex_asm;
DexMethodRef* get_ctor(DexType* type) {
DexMethodRef* ctor = DexMethod::make_method(
type,
DexString::make_string("<init>"),
DexProto::make_proto(
known_types::_void(),
DexTypeList::make_type_list({known_types::java_lang_String()})));
return ctor;
}
DexMethodRef* get_dispatch_method() {
auto ex_type = DexType::get_type("Ljava/lang/Exception;");
auto proto = DexProto::make_proto(
ex_type, DexTypeList::make_type_list({known_types::_int()}));
auto target = DexType::make_type(DISPATCH_CLASS_NAME);
return DexMethod::make_method(
target, DexString::make_string(DISPATCH_METHOD_NAME), proto);
}
void build_dispatcher(DexStoresVector& stores,
const std::vector<outlined_t>& outlined_throws) {
auto dispatch_method = get_dispatch_method();
// make sure dispatcher doesn't already exist
always_assert(!type_class(dispatch_method->get_class()));
// prepare our outlined method creator
MethodCreator* mc =
new MethodCreator(dispatch_method->get_class(),
DexString::make_string(DISPATCH_METHOD_NAME),
dispatch_method->get_proto(),
ACC_PUBLIC | ACC_STATIC);
// define args and locals
auto outline_arg = mc->get_local(0);
auto str_local = mc->make_local(known_types::java_lang_String());
auto ex_local = mc->make_local(DexType::get_type("Ljava/lang/Exception;"));
// build up our outlined method
auto mb = mc->get_main_block();
std::map<int, MethodBlock*> cases;
for (size_t idx = 0; idx < outlined_throws.size(); idx++) {
cases[idx] = nullptr;
}
mb->load_null(ex_local);
mb->switch_op(outline_arg, cases);
for (auto case_entry : cases) {
const outlined_t& outlined = outlined_throws.at(case_entry.first);
DexType* type = std::get<0>(outlined);
DexString* str = std::get<1>(outlined);
always_assert(type);
always_assert(str);
TRACE(OUTLINE,
1,
"Outlined: %d %s %s",
case_entry.first,
SHOW(type),
SHOW(str));
auto case_block = case_entry.second;
case_block->new_instance(type, ex_local);
case_block->load_const(str_local, str);
std::vector<Location> ctor_args{ex_local, str_local};
case_block->invoke(OPCODE_INVOKE_DIRECT, get_ctor(type), ctor_args);
}
mb->throwex(ex_local);
TRACE(OUTLINE, 1, "Method creator: %s", SHOW(mc));
// create outline class and dispatch method
auto dispatch_cls = new ClassCreator(dispatch_method->get_class());
dispatch_cls->set_super(known_types::java_lang_Object());
dispatch_cls->set_access(ACC_PUBLIC);
dispatch_cls->add_method(mc->create());
// add class to last dex of root store
always_assert(!stores.empty());
stores[0].get_dexen().rbegin()->emplace_back(dispatch_cls->create());
}
IRInstruction* make_invoke(const DexMethodRef* meth, uint16_t v0) {
auto invoke = new IRInstruction(OPCODE_INVOKE_STATIC);
invoke->set_method(const_cast<DexMethodRef*>(meth))
->set_srcs_size(1)
->set_src(0, v0);
return invoke;
}
/**
* We only take classes from the root store, and we only take classes
* in secondary dexes. (If there's only one dex in the root store, the
* whole optimization will do nothing.)
*/
Scope build_scope(DexStoresVector& stores, bool include_primary_dex) {
Scope v;
always_assert(!stores.empty());
const auto& dexen = stores[0].get_dexen();
size_t offset = include_primary_dex ? 0 : 1;
for (unsigned i = offset; i < dexen.size(); ++i) {
for (auto cls : dexen[i]) {
v.push_back(cls);
}
}
return v;
}
}
void Outliner::run_pass(DexStoresVector& stores,
ConfigFiles& /* unused */,
PassManager& mgr) {
auto scope = build_scope(stores, m_outline_primary_dex);
DexMethodRef* dispatch_method = get_dispatch_method();
// Outlining match pattern
auto exception_type = DexType::get_type("Ljava/lang/Exception;");
always_assert(exception_type);
auto match = std::make_tuple(
m::new_instance(m::opcode_type(m::is_assignable_to(exception_type))),
m::move_result_pseudo(),
m::const_string(),
m::move_result_pseudo(),
m::invoke_direct(m::opcode_method(m::can_be_constructor())),
m::throwex());
// Collect all throws we should outline
std::vector<outlined_t> outlined_throws;
walk::matching_opcodes_in_block(
scope,
match,
[&](DexMethod* method,
cfg::Block*,
const std::vector<IRInstruction*>& insns) {
always_assert(insns.size() == 6);
auto new_instance = insns[0];
auto new_instance_result = insns[1];
auto const_string = insns[2];
auto const_string_result = insns[3];
auto invoke_direct = insns[4];
IRInstruction* throwex = insns[5];
if (invoke_direct->srcs_size() == 2 &&
new_instance_result->dest() == invoke_direct->src(0) &&
const_string_result->dest() == invoke_direct->src(1) &&
new_instance_result->dest() == throwex->src(0)) {
TRACE(OUTLINE,
1,
"Found pattern in %s:\n %s\n %s\n %s\n %s",
SHOW(method),
SHOW(new_instance),
SHOW(const_string),
SHOW(invoke_direct),
SHOW(throwex));
auto const_int_extype =
dasm(OPCODE_CONST,
{{VREG, new_instance_result->dest()},
{LITERAL, static_cast<int64_t>(outlined_throws.size())}});
IRInstruction* invoke_static =
make_invoke(dispatch_method, new_instance_result->dest());
/*
Nice code you got there. Be a shame if someone ever put an
infinite loop into it.
(We have to emit a branch of some sort here to appease the
verifier - all blocks either need to exit the method or
jump somewhere)
new-instance <TYPE> -> {vA} => const-int {vA}, <EXTYPEORD>
const-string <STRING> -> {vB} => invoke-static <METHOD>,
invoke-direct {vA}, {vB}, <CTTOR> => goto/32 +0 // will never run
throw {vA} =>
*/
outlined_t outlined{new_instance->get_type(),
const_string->get_string()};
outlined_throws.emplace_back(outlined);
IRCode* code = method->get_code();
code->replace_opcode(new_instance, const_int_extype);
code->replace_opcode(const_string, invoke_static);
code->replace_opcode_with_infinite_loop(invoke_direct);
code->remove_opcode(throwex);
}
});
mgr.incr_metric("outlined_throws", outlined_throws.size());
if (outlined_throws.size() > 0) {
build_dispatcher(stores, outlined_throws);
}
}
| [
"facebook-github-bot@users.noreply.github.com"
] | facebook-github-bot@users.noreply.github.com |
d3689391d68b018efc23290ea81b2f21d445036c | ba82603652e7d0c1ba3a61369c1e00e7feb13d36 | /neXnova/3d/moon.h | c82841c2ec12db43a949ae45fff3b3e30a24aa83 | [] | no_license | qaz734913414/neXnova | 83b5eb2d7e49e402017e0eb7b7b397e6b8ce6fff | 49823ba90ab41122b99ada0d148c2be23efa69b0 | refs/heads/master | 2020-04-24T06:32:47.981530 | 2019-02-20T05:27:08 | 2019-02-20T05:27:08 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,170 | h | #ifndef MOON_H
#define MOON_H
#include <QObject>
#include <Qt3DCore>
#include <Qt3DExtras>
#include <Qt3DRender>
#include <Qt3DAnimation>
#include <Qt3DRender/QMesh>
#include <Qt3DExtras/QSphereMesh>
#include "rotation.h"
#define D3Debug 0
class moon : public Qt3DCore::QEntity
{
Q_OBJECT
Q_PROPERTY(QString eid READ eid WRITE setEid)
Q_PROPERTY(Qt3DExtras::QSphereMesh * moonmesh READ moonmesh WRITE setMoonmesh
NOTIFY moonmeshChanged)
Q_PROPERTY(Qt3DCore::QTransform * moontransform READ moontransform WRITE setMoontransform
NOTIFY moontransformChanged)
Q_PROPERTY(Qt3DRender::QMaterial * moonmaterial READ moonmaterial WRITE setMoonmaterial
NOTIFY moonmaterialChanged)
Q_PROPERTY(Qt3DRender::QPointLight * moonlight READ moonlight WRITE setMoonlight
NOTIFY moonlightChanged)
Q_PROPERTY(RotationParameters * moonrotation READ moonrotation WRITE setMoonrotation
NOTIFY moonrotationChanged)
Q_PROPERTY(float scale READ scale WRITE setScale NOTIFY scaleChanged)
Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
Q_PROPERTY(QString description READ description WRITE setDescription NOTIFY descriptionChanged)
Q_PROPERTY(int type READ type WRITE setType)
Q_PROPERTY(QJsonObject structures READ structures WRITE setStructures NOTIFY structuresChanged)
public:
explicit moon(Qt3DCore::QEntity *root = nullptr);
void ini();
static moon * iniFromJson(QJsonObject data, Qt3DCore::QEntity *parent);
signals:
void moonrotationChanged();
void moonlightChanged();
void moonmaterialChanged();
void moonmeshChanged();
void moontransformChanged();
void scaleChanged();
void nameChanged();
void descriptionChanged();
void structuresChanged();
void clicked(Qt3DRender::QPickEvent *pick);
public slots:
void animate(float day);
RotationParameters * moonrotation();
Qt3DRender::QPointLight *moonlight();
Qt3DRender::QMaterial * moonmaterial();
Qt3DCore::QTransform * moontransform();
Qt3DExtras::QSphereMesh * moonmesh();
float scale();
QString name();
QString description();
int type();
QJsonObject structures();
QString eid() const;
void setEid(QString eid);
void setMoonrotation(RotationParameters * rotation);
void setMoonlight (Qt3DRender::QPointLight * light);
void setMoonmaterial (Qt3DRender::QMaterial * mater);
void setMoontransform (Qt3DCore::QTransform * transform);
void setMoonmesh(Qt3DExtras::QSphereMesh * m);
void setScale(float newscale);
void setName(QString newname);
void setDescription(QString newdes);
void setStructures(QJsonObject newstructures);
void setType(int type);
private:
Qt3DExtras::QSphereMesh * mesh;
Qt3DRender::QMaterial * material;
Qt3DCore::QTransform* transformptr;
Qt3DRender::QPointLight * moonlightptr;
Qt3DRender::QObjectPicker * MrPickles;
RotationParameters * rotational;
float Scale;
QString Eid;
QString Name;
QString Description;
int Type;
QJsonObject Structures;
};
#endif // MOON_H
| [
"jdenis@uclv.cu"
] | jdenis@uclv.cu |
62e59cd2e9856d279c1d47357a28fa6e358767ed | 0569606dc4bd1ec1e0976ec79429686fddea38b4 | /Munchkin/include/Personnage/Joueur/EtatJoueur/Attente/Attente.cpp | 37e4dfc6fa33bc51ea41f9637d9a431e73525580 | [] | no_license | QuentinLeCorvec/Applications | f3cbedffc069cb9160a6aac8371899e6f7b84822 | 994d1a6a903898763f606ea002dee1433b8af086 | refs/heads/master | 2020-07-27T13:02:41.364506 | 2019-09-17T16:23:00 | 2019-09-17T16:23:00 | 209,098,841 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 215 | cpp | /**
* \file Attente.cpp
* \brief implémentation classe Attente
* \author Le Corvec Quentin
* \date Octobre 2014
*/
#include "Attente.hpp"
Attente::Attente(Joueur * j):EtatJoueur(j){}
Attente::~Attente(){}
| [
"50618902+QuentinLeCorvec@users.noreply.github.com"
] | 50618902+QuentinLeCorvec@users.noreply.github.com |
23dd6bdf98e91812c68335a1121fdde8b148294b | 49c35b6b3d0cd541aad735a43520f9ab57b7dec3 | /programa-5/main.cpp | 1f447bb1dac352374dd5b7073584f6a9499858e8 | [] | no_license | humbertowoody/algebra-lineal-escom | 6999eacc040896c016f4aa9efc0f90681f003d69 | ebd06c5971b5ee00878bddeaeacaafe838bbfb8a | refs/heads/main | 2023-02-17T11:27:31.647195 | 2021-01-20T22:42:48 | 2021-01-20T22:42:48 | 304,996,386 | 4 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 3,426 | cpp | /**
* Escuela Superior de Cómputo - Instituto Politécnico Nacional
* Dr. Dárwin Gutiérrez Mejía - Álgebra Lineal
*
* Programa que calcula las bases del espacio imagen y del espacio nulo a partir
* de una matriz inicial.
*
* Humberto Alejandro Ortega Alcocer (2016630495) <hortegaa1500@alumno.ipn.mx>
* Programa 5
* 20 de Diciembre del 2020
*
* Link de repositorio: https://github.com/humbertowoody/algebra-lineal-escom/tree/main/programa-5
*/
#include "./Librerias/Matriz.hpp" // Para modelar matrices.
#include "./Librerias/GaussJordan.hpp" // Para resolver sistemas de ecuaciones lineales.
#include "./Librerias/AlgebraLineal.hpp" // Funciones de Álgebra Lineal (espacio de nombres "algebralineal")
#include "./Librerias/UtileriasMatriz.hpp" // Utilerías generales.
#include "./Librerias/ExcepcionGaussJordan.hpp" // Para las excepciones de GaussJordan.
// Función principal.
int main(int argc, char *argv[])
{
// Variables locales.
Matriz<float> matrizOriginal; // Para almacenar la matriz original.
// Mensajes iniciales.
std::cout << "Generador de bases del espacio nulo e imagen a partir de una matriz inicial" << std::endl
<< "Escuela Superior de Cómputo - Instituto Politécnico Nacional" << std::endl
<< "Dr. Dárwin Gutiérrez Mejía - Álgebra Lineal" << std::endl
<< std::endl
<< "Alumno: Humberto Alejandro Ortega Alcocer (2016630495) <hortegaa1500@alumno.ipn.mx>" << std::endl
<< "Programa: 5" << std::endl
<< std::endl;
// Leemos la matriz de forma interactiva.
matrizOriginal = leerMatrizInteractiva<float>();
// Procedimiento con control de errores.
try
{
// Calculamos una base en el espacio nulo.
algebralineal::vectoresReales baseEspacioNulo = algebralineal::obtenerBaseEspacioNulo(matrizOriginal);
// Verificamos si hubo base para el espacio nulo.
if (baseEspacioNulo.size())
{
// Mostramos la base.
std::cout << "Una base del espacio nulo es:" << std::endl
<< "Nu(A) = ";
algebralineal::imprimirVectoresReales(baseEspacioNulo);
std::cout << std::endl;
}
else
{
// No hubo base.
std::cout << "No existe una base para el espacio nulo." << std::endl;
}
// Calculamos una base para el espacio imagen.
algebralineal::vectoresReales baseEspacioImagen = algebralineal::obtenerBaseEspacioImagen(matrizOriginal);
// Verificamos si hubo base para el espacio imagen.
if (baseEspacioImagen.size())
{
// Mostramos la base.
std::cout << std::endl
<< "Una base del espacio imagen es:" << std::endl
<< "Im(A) = ";
algebralineal::imprimirVectoresReales(baseEspacioImagen);
std::cout << std::endl;
}
else
{
// No hubo base.
std::cout << "No existe una base para el espacio imagen." << std::endl;
}
}
catch (const ExcepcionMatriz &excepcionMatriz)
{
std::cout << "Hubo un error manipulando una matriz: " << excepcionMatriz.id() << " ~ " << excepcionMatriz.mensaje() << std::endl;
}
catch (const ExcepcionGaussJordan &excepcionGaussJordan)
{
std::cout << "Hubo en error en el procedimiento Gauss-Jordan: " << excepcionGaussJordan.id() << " ~ " << excepcionGaussJordan.mensaje() << std::endl;
}
// En este punto la ejecución fue exitosa.
return 0;
} | [
"humbertowoody@gmail.com"
] | humbertowoody@gmail.com |
3f3bc0a54a96615e44bc95f6346d4d470b6305b1 | 790c74e6fb10857cd396e07f1eb39c4733596e91 | /include/oglplus/texgen/render_node.hpp | cdf10ce4a490a0ee253cafca05c764f4f3a721f1 | [
"BSL-1.0"
] | permissive | Blinky0815/oglplu2 | 838a4d9484359b8c381ab49827caad4bef7e0a39 | 8cc3f1d3305179e4ade8b3973f4862df7543ad2a | refs/heads/master | 2020-03-22T21:59:10.271736 | 2017-11-17T14:01:25 | 2017-11-17T14:01:25 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,828 | hpp | /**
* @file oglplus/texgen/render_node.hpp
*
* Copyright Matus Chochlik.
* Distributed under the Boost Software License, Version 1.0.
* See accompanying file LICENSE_1_0.txt or copy at
* http://www.boost.org/LICENSE_1_0.txt
*/
#ifndef OGLPLUS_TEXGEN_RENDER_NODE_1509260923_HPP
#define OGLPLUS_TEXGEN_RENDER_NODE_1509260923_HPP
#include "fallback_input.hpp"
#include "base_node.hpp"
#include "../program.hpp"
#include "../buffer.hpp"
#include "../vertex_array.hpp"
#include "../uniform.hpp"
#include <eagine/valid_if/positive.hpp>
namespace oglplus {
namespace texgen {
class render_node
: public base_node
{
private:
input_with_const_default<float[4]> _input;
owned<program_name> _prog;
owned<buffer_name> _data;
owned<vertex_array_name> _vao;
uniform_location _voxel_size;
void _init_screen(void);
void _update_program(void);
bool _needs_update;
int _xdiv, _ydiv, _tile;
unsigned _render_version;
render_params _render_params;
public:
render_node(void);
render_node(const render_node&) = delete;
~render_node(void);
std::ostream&
make_fragment_shader_source(std::ostream&, compile_context&);
void draw_screen(void);
cstr_ref type_name(void)
override;
span_size_t input_count(void)
override;
input_intf& input(span_size_t index)
override;
void update_needed(void)
override;
void update_if_needed(void);
bool render(const render_params&)
override;
bool render(void);
void set_divisions(
eagine::valid_if_positive<int> xdiv,
eagine::valid_if_positive<int> ydiv
);
void set_dimensions(
eagine::valid_if_positive<int> width,
eagine::valid_if_positive<int> height
);
};
} // namespace texgen
} // namespace oglplus
#if !OGLPLUS_LINK_LIBRARY || defined(OGLPLUS_IMPLEMENTING_LIBRARY)
#include <oglplus/texgen/render_node.inl>
#endif
#endif // include guard
| [
"chochlik@gmail.com"
] | chochlik@gmail.com |
df83297d35335b6aee5e9599559d44525d92b7c4 | 4fbdb56be0b723f42265f6d91d5662bf4a031ee5 | /src/ChunkData.pb.h | 80b6d4a0920017aa2da0780751b1fd90f1872600 | [
"BSD-2-Clause",
"BSD-3-Clause"
] | permissive | rgodha/hackIllinois2016 | b4d7f482f03841426f3cfe1588316a82b97b83ad | 3166a9f9b4a298212076ec2069800f73a494772e | refs/heads/master | 2021-01-10T05:11:38.873488 | 2016-02-21T06:42:38 | 2016-02-21T06:42:38 | 52,146,069 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | true | 16,519 | h | // Generated by the protocol buffer compiler. DO NOT EDIT!
// source: ChunkData.proto
#ifndef PROTOBUF_ChunkData_2eproto__INCLUDED
#define PROTOBUF_ChunkData_2eproto__INCLUDED
#include <string>
#include <google/protobuf/stubs/common.h>
#if GOOGLE_PROTOBUF_VERSION < 2006000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
// Internal implementation detail -- do not call these.
void protobuf_AddDesc_ChunkData_2eproto();
void protobuf_AssignDesc_ChunkData_2eproto();
void protobuf_ShutdownFile_ChunkData_2eproto();
class ChunkData;
enum ChunkData_ChunkType {
ChunkData_ChunkType_ADD = 0,
ChunkData_ChunkType_SUB = 1
};
bool ChunkData_ChunkType_IsValid(int value);
const ChunkData_ChunkType ChunkData_ChunkType_ChunkType_MIN = ChunkData_ChunkType_ADD;
const ChunkData_ChunkType ChunkData_ChunkType_ChunkType_MAX = ChunkData_ChunkType_SUB;
const int ChunkData_ChunkType_ChunkType_ARRAYSIZE = ChunkData_ChunkType_ChunkType_MAX + 1;
const ::google::protobuf::EnumDescriptor* ChunkData_ChunkType_descriptor();
inline const ::std::string& ChunkData_ChunkType_Name(ChunkData_ChunkType value) {
return ::google::protobuf::internal::NameOfEnum(
ChunkData_ChunkType_descriptor(), value);
}
inline bool ChunkData_ChunkType_Parse(
const ::std::string& name, ChunkData_ChunkType* value) {
return ::google::protobuf::internal::ParseNamedEnum<ChunkData_ChunkType>(
ChunkData_ChunkType_descriptor(), name, value);
}
enum ChunkData_PrefixType {
ChunkData_PrefixType_PREFIX_4B = 0,
ChunkData_PrefixType_FULL_32B = 1
};
bool ChunkData_PrefixType_IsValid(int value);
const ChunkData_PrefixType ChunkData_PrefixType_PrefixType_MIN = ChunkData_PrefixType_PREFIX_4B;
const ChunkData_PrefixType ChunkData_PrefixType_PrefixType_MAX = ChunkData_PrefixType_FULL_32B;
const int ChunkData_PrefixType_PrefixType_ARRAYSIZE = ChunkData_PrefixType_PrefixType_MAX + 1;
const ::google::protobuf::EnumDescriptor* ChunkData_PrefixType_descriptor();
inline const ::std::string& ChunkData_PrefixType_Name(ChunkData_PrefixType value) {
return ::google::protobuf::internal::NameOfEnum(
ChunkData_PrefixType_descriptor(), value);
}
inline bool ChunkData_PrefixType_Parse(
const ::std::string& name, ChunkData_PrefixType* value) {
return ::google::protobuf::internal::ParseNamedEnum<ChunkData_PrefixType>(
ChunkData_PrefixType_descriptor(), name, value);
}
// ===================================================================
class ChunkData : public ::google::protobuf::Message {
public:
ChunkData();
virtual ~ChunkData();
ChunkData(const ChunkData& from);
inline ChunkData& operator=(const ChunkData& from) {
CopyFrom(from);
return *this;
}
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _unknown_fields_;
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return &_unknown_fields_;
}
static const ::google::protobuf::Descriptor* descriptor();
static const ChunkData& default_instance();
void Swap(ChunkData* other);
// implements Message ----------------------------------------------
ChunkData* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ChunkData& from);
void MergeFrom(const ChunkData& from);
void Clear();
bool IsInitialized() const;
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const;
::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
int GetCachedSize() const { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
public:
::google::protobuf::Metadata GetMetadata() const;
// nested types ----------------------------------------------------
typedef ChunkData_ChunkType ChunkType;
static const ChunkType ADD = ChunkData_ChunkType_ADD;
static const ChunkType SUB = ChunkData_ChunkType_SUB;
static inline bool ChunkType_IsValid(int value) {
return ChunkData_ChunkType_IsValid(value);
}
static const ChunkType ChunkType_MIN =
ChunkData_ChunkType_ChunkType_MIN;
static const ChunkType ChunkType_MAX =
ChunkData_ChunkType_ChunkType_MAX;
static const int ChunkType_ARRAYSIZE =
ChunkData_ChunkType_ChunkType_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
ChunkType_descriptor() {
return ChunkData_ChunkType_descriptor();
}
static inline const ::std::string& ChunkType_Name(ChunkType value) {
return ChunkData_ChunkType_Name(value);
}
static inline bool ChunkType_Parse(const ::std::string& name,
ChunkType* value) {
return ChunkData_ChunkType_Parse(name, value);
}
typedef ChunkData_PrefixType PrefixType;
static const PrefixType PREFIX_4B = ChunkData_PrefixType_PREFIX_4B;
static const PrefixType FULL_32B = ChunkData_PrefixType_FULL_32B;
static inline bool PrefixType_IsValid(int value) {
return ChunkData_PrefixType_IsValid(value);
}
static const PrefixType PrefixType_MIN =
ChunkData_PrefixType_PrefixType_MIN;
static const PrefixType PrefixType_MAX =
ChunkData_PrefixType_PrefixType_MAX;
static const int PrefixType_ARRAYSIZE =
ChunkData_PrefixType_PrefixType_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
PrefixType_descriptor() {
return ChunkData_PrefixType_descriptor();
}
static inline const ::std::string& PrefixType_Name(PrefixType value) {
return ChunkData_PrefixType_Name(value);
}
static inline bool PrefixType_Parse(const ::std::string& name,
PrefixType* value) {
return ChunkData_PrefixType_Parse(name, value);
}
// accessors -------------------------------------------------------
// required int32 chunk_number = 1;
inline bool has_chunk_number() const;
inline void clear_chunk_number();
static const int kChunkNumberFieldNumber = 1;
inline ::google::protobuf::int32 chunk_number() const;
inline void set_chunk_number(::google::protobuf::int32 value);
// optional .ChunkData.ChunkType chunk_type = 2 [default = ADD];
inline bool has_chunk_type() const;
inline void clear_chunk_type();
static const int kChunkTypeFieldNumber = 2;
inline ::ChunkData_ChunkType chunk_type() const;
inline void set_chunk_type(::ChunkData_ChunkType value);
// optional .ChunkData.PrefixType prefix_type = 3 [default = PREFIX_4B];
inline bool has_prefix_type() const;
inline void clear_prefix_type();
static const int kPrefixTypeFieldNumber = 3;
inline ::ChunkData_PrefixType prefix_type() const;
inline void set_prefix_type(::ChunkData_PrefixType value);
// optional bytes hashes = 4;
inline bool has_hashes() const;
inline void clear_hashes();
static const int kHashesFieldNumber = 4;
inline const ::std::string& hashes() const;
inline void set_hashes(const ::std::string& value);
inline void set_hashes(const char* value);
inline void set_hashes(const void* value, size_t size);
inline ::std::string* mutable_hashes();
inline ::std::string* release_hashes();
inline void set_allocated_hashes(::std::string* hashes);
// repeated int32 add_numbers = 5 [packed = true];
inline int add_numbers_size() const;
inline void clear_add_numbers();
static const int kAddNumbersFieldNumber = 5;
inline ::google::protobuf::int32 add_numbers(int index) const;
inline void set_add_numbers(int index, ::google::protobuf::int32 value);
inline void add_add_numbers(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
add_numbers() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_add_numbers();
// @@protoc_insertion_point(class_scope:ChunkData)
private:
inline void set_has_chunk_number();
inline void clear_has_chunk_number();
inline void set_has_chunk_type();
inline void clear_has_chunk_type();
inline void set_has_prefix_type();
inline void clear_has_prefix_type();
inline void set_has_hashes();
inline void clear_has_hashes();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::uint32 _has_bits_[1];
mutable int _cached_size_;
::google::protobuf::int32 chunk_number_;
int chunk_type_;
::std::string* hashes_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > add_numbers_;
mutable int _add_numbers_cached_byte_size_;
int prefix_type_;
friend void protobuf_AddDesc_ChunkData_2eproto();
friend void protobuf_AssignDesc_ChunkData_2eproto();
friend void protobuf_ShutdownFile_ChunkData_2eproto();
void InitAsDefaultInstance();
static ChunkData* default_instance_;
};
// ===================================================================
// ===================================================================
// ChunkData
// required int32 chunk_number = 1;
inline bool ChunkData::has_chunk_number() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ChunkData::set_has_chunk_number() {
_has_bits_[0] |= 0x00000001u;
}
inline void ChunkData::clear_has_chunk_number() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ChunkData::clear_chunk_number() {
chunk_number_ = 0;
clear_has_chunk_number();
}
inline ::google::protobuf::int32 ChunkData::chunk_number() const {
// @@protoc_insertion_point(field_get:ChunkData.chunk_number)
return chunk_number_;
}
inline void ChunkData::set_chunk_number(::google::protobuf::int32 value) {
set_has_chunk_number();
chunk_number_ = value;
// @@protoc_insertion_point(field_set:ChunkData.chunk_number)
}
// optional .ChunkData.ChunkType chunk_type = 2 [default = ADD];
inline bool ChunkData::has_chunk_type() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ChunkData::set_has_chunk_type() {
_has_bits_[0] |= 0x00000002u;
}
inline void ChunkData::clear_has_chunk_type() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ChunkData::clear_chunk_type() {
chunk_type_ = 0;
clear_has_chunk_type();
}
inline ::ChunkData_ChunkType ChunkData::chunk_type() const {
// @@protoc_insertion_point(field_get:ChunkData.chunk_type)
return static_cast< ::ChunkData_ChunkType >(chunk_type_);
}
inline void ChunkData::set_chunk_type(::ChunkData_ChunkType value) {
assert(::ChunkData_ChunkType_IsValid(value));
set_has_chunk_type();
chunk_type_ = value;
// @@protoc_insertion_point(field_set:ChunkData.chunk_type)
}
// optional .ChunkData.PrefixType prefix_type = 3 [default = PREFIX_4B];
inline bool ChunkData::has_prefix_type() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ChunkData::set_has_prefix_type() {
_has_bits_[0] |= 0x00000004u;
}
inline void ChunkData::clear_has_prefix_type() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ChunkData::clear_prefix_type() {
prefix_type_ = 0;
clear_has_prefix_type();
}
inline ::ChunkData_PrefixType ChunkData::prefix_type() const {
// @@protoc_insertion_point(field_get:ChunkData.prefix_type)
return static_cast< ::ChunkData_PrefixType >(prefix_type_);
}
inline void ChunkData::set_prefix_type(::ChunkData_PrefixType value) {
assert(::ChunkData_PrefixType_IsValid(value));
set_has_prefix_type();
prefix_type_ = value;
// @@protoc_insertion_point(field_set:ChunkData.prefix_type)
}
// optional bytes hashes = 4;
inline bool ChunkData::has_hashes() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ChunkData::set_has_hashes() {
_has_bits_[0] |= 0x00000008u;
}
inline void ChunkData::clear_has_hashes() {
_has_bits_[0] &= ~0x00000008u;
}
inline void ChunkData::clear_hashes() {
if (hashes_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
hashes_->clear();
}
clear_has_hashes();
}
inline const ::std::string& ChunkData::hashes() const {
// @@protoc_insertion_point(field_get:ChunkData.hashes)
return *hashes_;
}
inline void ChunkData::set_hashes(const ::std::string& value) {
set_has_hashes();
if (hashes_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
hashes_ = new ::std::string;
}
hashes_->assign(value);
// @@protoc_insertion_point(field_set:ChunkData.hashes)
}
inline void ChunkData::set_hashes(const char* value) {
set_has_hashes();
if (hashes_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
hashes_ = new ::std::string;
}
hashes_->assign(value);
// @@protoc_insertion_point(field_set_char:ChunkData.hashes)
}
inline void ChunkData::set_hashes(const void* value, size_t size) {
set_has_hashes();
if (hashes_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
hashes_ = new ::std::string;
}
hashes_->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:ChunkData.hashes)
}
inline ::std::string* ChunkData::mutable_hashes() {
set_has_hashes();
if (hashes_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
hashes_ = new ::std::string;
}
// @@protoc_insertion_point(field_mutable:ChunkData.hashes)
return hashes_;
}
inline ::std::string* ChunkData::release_hashes() {
clear_has_hashes();
if (hashes_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
return NULL;
} else {
::std::string* temp = hashes_;
hashes_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
return temp;
}
}
inline void ChunkData::set_allocated_hashes(::std::string* hashes) {
if (hashes_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
delete hashes_;
}
if (hashes) {
set_has_hashes();
hashes_ = hashes;
} else {
clear_has_hashes();
hashes_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
// @@protoc_insertion_point(field_set_allocated:ChunkData.hashes)
}
// repeated int32 add_numbers = 5 [packed = true];
inline int ChunkData::add_numbers_size() const {
return add_numbers_.size();
}
inline void ChunkData::clear_add_numbers() {
add_numbers_.Clear();
}
inline ::google::protobuf::int32 ChunkData::add_numbers(int index) const {
// @@protoc_insertion_point(field_get:ChunkData.add_numbers)
return add_numbers_.Get(index);
}
inline void ChunkData::set_add_numbers(int index, ::google::protobuf::int32 value) {
add_numbers_.Set(index, value);
// @@protoc_insertion_point(field_set:ChunkData.add_numbers)
}
inline void ChunkData::add_add_numbers(::google::protobuf::int32 value) {
add_numbers_.Add(value);
// @@protoc_insertion_point(field_add:ChunkData.add_numbers)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ChunkData::add_numbers() const {
// @@protoc_insertion_point(field_list:ChunkData.add_numbers)
return add_numbers_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ChunkData::mutable_add_numbers() {
// @@protoc_insertion_point(field_mutable_list:ChunkData.add_numbers)
return &add_numbers_;
}
// @@protoc_insertion_point(namespace_scope)
#ifndef SWIG
namespace google {
namespace protobuf {
template <> struct is_proto_enum< ::ChunkData_ChunkType> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ChunkData_ChunkType>() {
return ::ChunkData_ChunkType_descriptor();
}
template <> struct is_proto_enum< ::ChunkData_PrefixType> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ChunkData_PrefixType>() {
return ::ChunkData_PrefixType_descriptor();
}
} // namespace google
} // namespace protobuf
#endif // SWIG
// @@protoc_insertion_point(global_scope)
#endif // PROTOBUF_ChunkData_2eproto__INCLUDED
| [
"grigorescu@gmail.com"
] | grigorescu@gmail.com |
67321d5b3e47c4b99a08403dde77b13648f9fdbd | 0d0e78c6262417fb1dff53901c6087b29fe260a0 | /postgres/include/tencentcloud/postgres/v20170312/model/DescribeDBXlogsRequest.h | 39640498c949076ebd009991f14a2ffe53ddfa64 | [
"Apache-2.0"
] | permissive | li5ch/tencentcloud-sdk-cpp | ae35ffb0c36773fd28e1b1a58d11755682ade2ee | 12ebfd75a399ee2791f6ac1220a79ce8a9faf7c4 | refs/heads/master | 2022-12-04T15:33:08.729850 | 2020-07-20T00:52:24 | 2020-07-20T00:52:24 | 281,135,686 | 1 | 0 | Apache-2.0 | 2020-07-20T14:14:47 | 2020-07-20T14:14:46 | null | UTF-8 | C++ | false | false | 6,728 | h | /*
* Copyright (c) 2017-2019 THL A29 Limited, a Tencent company. 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.
*/
#ifndef TENCENTCLOUD_POSTGRES_V20170312_MODEL_DESCRIBEDBXLOGSREQUEST_H_
#define TENCENTCLOUD_POSTGRES_V20170312_MODEL_DESCRIBEDBXLOGSREQUEST_H_
#include <string>
#include <vector>
#include <map>
#include <tencentcloud/core/AbstractModel.h>
namespace TencentCloud
{
namespace Postgres
{
namespace V20170312
{
namespace Model
{
/**
* DescribeDBXlogs请求参数结构体
*/
class DescribeDBXlogsRequest : public AbstractModel
{
public:
DescribeDBXlogsRequest();
~DescribeDBXlogsRequest() = default;
std::string ToJsonString() const;
/**
* 获取实例ID，形如postgres-4wdeb0zv。
* @return DBInstanceId 实例ID，形如postgres-4wdeb0zv。
*/
std::string GetDBInstanceId() const;
/**
* 设置实例ID，形如postgres-4wdeb0zv。
* @param DBInstanceId 实例ID，形如postgres-4wdeb0zv。
*/
void SetDBInstanceId(const std::string& _dBInstanceId);
/**
* 判断参数 DBInstanceId 是否已赋值
* @return DBInstanceId 是否已赋值
*/
bool DBInstanceIdHasBeenSet() const;
/**
* 获取查询开始时间，形如2018-06-10 17:06:38，起始时间不得小于7天以前
* @return StartTime 查询开始时间，形如2018-06-10 17:06:38，起始时间不得小于7天以前
*/
std::string GetStartTime() const;
/**
* 设置查询开始时间，形如2018-06-10 17:06:38，起始时间不得小于7天以前
* @param StartTime 查询开始时间，形如2018-06-10 17:06:38，起始时间不得小于7天以前
*/
void SetStartTime(const std::string& _startTime);
/**
* 判断参数 StartTime 是否已赋值
* @return StartTime 是否已赋值
*/
bool StartTimeHasBeenSet() const;
/**
* 获取查询结束时间，形如2018-06-10 17:06:38
* @return EndTime 查询结束时间，形如2018-06-10 17:06:38
*/
std::string GetEndTime() const;
/**
* 设置查询结束时间，形如2018-06-10 17:06:38
* @param EndTime 查询结束时间，形如2018-06-10 17:06:38
*/
void SetEndTime(const std::string& _endTime);
/**
* 判断参数 EndTime 是否已赋值
* @return EndTime 是否已赋值
*/
bool EndTimeHasBeenSet() const;
/**
* 获取分页返回，表示返回第几页的条目。从第0页开始计数。
* @return Offset 分页返回，表示返回第几页的条目。从第0页开始计数。
*/
int64_t GetOffset() const;
/**
* 设置分页返回，表示返回第几页的条目。从第0页开始计数。
* @param Offset 分页返回，表示返回第几页的条目。从第0页开始计数。
*/
void SetOffset(const int64_t& _offset);
/**
* 判断参数 Offset 是否已赋值
* @return Offset 是否已赋值
*/
bool OffsetHasBeenSet() const;
/**
* 获取分页返回，表示每页有多少条目。取值为1-100。
* @return Limit 分页返回，表示每页有多少条目。取值为1-100。
*/
int64_t GetLimit() const;
/**
* 设置分页返回，表示每页有多少条目。取值为1-100。
* @param Limit 分页返回，表示每页有多少条目。取值为1-100。
*/
void SetLimit(const int64_t& _limit);
/**
* 判断参数 Limit 是否已赋值
* @return Limit 是否已赋值
*/
bool LimitHasBeenSet() const;
private:
/**
* 实例ID，形如postgres-4wdeb0zv。
*/
std::string m_dBInstanceId;
bool m_dBInstanceIdHasBeenSet;
/**
* 查询开始时间，形如2018-06-10 17:06:38，起始时间不得小于7天以前
*/
std::string m_startTime;
bool m_startTimeHasBeenSet;
/**
* 查询结束时间，形如2018-06-10 17:06:38
*/
std::string m_endTime;
bool m_endTimeHasBeenSet;
/**
* 分页返回，表示返回第几页的条目。从第0页开始计数。
*/
int64_t m_offset;
bool m_offsetHasBeenSet;
/**
* 分页返回，表示每页有多少条目。取值为1-100。
*/
int64_t m_limit;
bool m_limitHasBeenSet;
};
}
}
}
}
#endif // !TENCENTCLOUD_POSTGRES_V20170312_MODEL_DESCRIBEDBXLOGSREQUEST_H_
| [
"jimmyzhuang@tencent.com"
] | jimmyzhuang@tencent.com |
619fc369a713af8d8dc6a8c888b3473692588428 | 4622b38786f36e09af1c1367135583e9043d1a60 | /Chapter03_05/Source/Main.cpp | fe605c36c577e7de38ebecb3e50132582afd7988 | [] | no_license | jplebre/Books.GettingStartedWithJuce | 3bf3941bbf17c2563a789d9ca0a9a403263d0aa2 | d75537518987c371e14fbb9c7cb7eb69a86734d4 | refs/heads/master | 2021-01-10T09:19:38.300288 | 2015-11-23T23:26:05 | 2015-11-23T23:26:05 | 46,193,317 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,757 | cpp | /*
==============================================================================
This file was auto-generated by the Introjucer!
It contains the basic startup code for a Juce application.
==============================================================================
*/
#include "../JuceLibraryCode/JuceHeader.h"
#include "MainComponent.h"
//==============================================================================
class Chapter03_05Application : public JUCEApplication
{
public:
//==============================================================================
Chapter03_05Application() {}
const String getApplicationName() override { return ProjectInfo::projectName; }
const String getApplicationVersion() override { return ProjectInfo::versionString; }
bool moreThanOneInstanceAllowed() override { return true; }
//==============================================================================
void initialise (const String& commandLine) override
{
// This method is where you should put your application's initialisation code..
mainWindow = new MainWindow();
}
void shutdown() override
{
// Add your application's shutdown code here..
mainWindow = nullptr; // (deletes our window)
}
//==============================================================================
void systemRequestedQuit() override
{
// This is called when the app is being asked to quit: you can ignore this
// request and let the app carry on running, or call quit() to allow the app to close.
quit();
}
void anotherInstanceStarted (const String& commandLine) override
{
// When another instance of the app is launched while this one is running,
// this method is invoked, and the commandLine parameter tells you what
// the other instance's command-line arguments were.
}
//==============================================================================
/*
This class implements the desktop window that contains an instance of
our MainContentComponent class.
*/
class MainWindow : public DocumentWindow
{
public:
MainWindow() : DocumentWindow ("MainWindow",
Colours::lightgrey,
DocumentWindow::allButtons)
{
setContentOwned (new MainContentComponent(), true);
centreWithSize (getWidth(), getHeight());
setVisible (true);
}
void closeButtonPressed()
{
// This is called when the user tries to close this window. Here, we'll just
// ask the app to quit when this happens, but you can change this to do
// whatever you need.
JUCEApplication::getInstance()->systemRequestedQuit();
}
/* Note: Be careful if you override any DocumentWindow methods - the base
class uses a lot of them, so by overriding you might break its functionality.
It's best to do all your work in your content component instead, but if
you really have to override any DocumentWindow methods, make sure your
subclass also calls the superclass's method.
*/
private:
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MainWindow)
};
private:
ScopedPointer<MainWindow> mainWindow;
};
//==============================================================================
// This macro generates the main() routine that launches the app.
START_JUCE_APPLICATION (Chapter03_05Application)
| [
"jplebre@gmail.com"
] | jplebre@gmail.com |
fef1e9b9313ff8ee03d6040575c6dfa68dd0bb9b | 83fa42dc9c60f2d7537b1bbe0894713156bc488f | /c++初级/001.Cppprimer_快速入门/demo5.cpp | 89ed257424ccf7c2a74cf432ad760605bf004b52 | [] | no_license | 15529343201/C-Plus-Plus | c4782b054ac0c0aac66711312209e13a8acf0a4f | 33d499dd94d720d0131afef4fe071624bc171ede | refs/heads/master | 2020-05-21T03:43:01.145036 | 2017-10-06T15:20:12 | 2017-10-06T15:20:12 | 84,566,994 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 168 | cpp | #include<iostream>
int main()
{
int sum=0;
for(int val=1;val<=100;++val)
{
sum+=val;
}
std::cout<<"Sum of 1 to 100 inclusive is "<<sum<<std::endl;
return 0;
}
| [
"15529343201@139.com"
] | 15529343201@139.com |
33f779da19276e4750df4a7e8aea0a53f6f71abc | c9fb34b4f10d30e71e7acde6f365d356694abf83 | /PBNeo/Server/Client/Client/ViewTree.cpp | e43d6b21b48e19ddd41f8586d6bc8b513f0dbda4 | [] | no_license | daekyuuu/DKGame2 | a52311e4df0d67132afada8d226ce45a0bd331ef | e5405499e7dcf02225757888c8fbaf847cb200cd | refs/heads/master | 2020-12-02T06:40:23.579274 | 2017-07-12T05:00:08 | 2017-07-12T05:00:08 | 96,866,994 | 9 | 2 | null | null | null | null | UHC | C++ | false | false | 842 | cpp |
#include "stdafx.h"
#include "ViewTree.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CViewTree
CViewTree::CViewTree()
{
}
CViewTree::~CViewTree()
{
}
BEGIN_MESSAGE_MAP(CViewTree, CTreeCtrl)
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CViewTree 메시지 처리기
BOOL CViewTree::OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* pResult)
{
BOOL bRes = CTreeCtrl::OnNotify(wParam, lParam, pResult);
NMHDR* pNMHDR = (NMHDR*)lParam;
ASSERT(pNMHDR != NULL);
if (pNMHDR && pNMHDR->code == TTN_SHOW && GetToolTips() != NULL)
{
GetToolTips()->SetWindowPos(&wndTop, -1, -1, -1, -1, SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOSIZE);
}
return bRes;
}
| [
"daekyu.park@zepetto.com"
] | daekyu.park@zepetto.com |
95595067d0d5d86fefee58167884ab256ddca9f3 | f373c3bb699c190b619f9a9171d32f63c1cbbf4e | /Framework/SkyDome.h | 95480a774ad012847a833d9e99afa5cfefe11881 | [
"MIT"
] | permissive | ian-wigley/DX9-3d-Framework | 535a555ed8851d92cf4489b8ac3ad0007b845656 | 8c7192a0fb00ee1a73ecde9ce1310c2d519f027b | refs/heads/master | 2023-05-02T07:08:42.017463 | 2023-04-18T16:39:03 | 2023-04-18T16:39:03 | 112,025,330 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 536 | h | #pragma once
#include "SceneNode.h"
#include "Framework.h"
#include "FrameWorkResourceManager.h"
#include "CameraRender.h"
class SkyDome :
public SceneNode
{
public:
SkyDome(void);
~SkyDome(void);
SkyDome(wstring name, Framework* frame, FrameWorkResourceManager* _frameResourcesManager);
HRESULT Render(void);
private:
void Shutdown(void);
HRESULT InitialiseDome(void);
void LoadDome(void);
D3DXMATRIX _saveView;
CameraRender* _renderCamera;
Framework* _frame;
FrameWorkResourceManager* _frameWorkResourcesManager;
};
| [
"ian.wigley2011@gmail.com"
] | ian.wigley2011@gmail.com |
6c21eadc4732a14bc7f1049446466746c2492a5f | 42197a436b880b3175dc5d6333866087cf6a7dbc | /kadas/gui/mapitems/kadascircleitem.h | 000e3fa96bc9674fcedf447bf7bee3c8ce34faf0 | [] | no_license | mhugent/kadas-albireo2 | 2a4dce3cc15592c2271bc7efc89088e8d168a0b8 | 8744ef1e1cbc772a51a02a6654556d9dc660824d | refs/heads/master | 2020-08-27T07:47:00.298743 | 2019-10-23T19:29:16 | 2019-10-23T20:21:24 | 217,289,123 | 0 | 0 | null | 2019-10-24T12:04:29 | 2019-10-24T12:04:29 | null | UTF-8 | C++ | false | false | 4,489 | h | /***************************************************************************
kadascircleitem.h
-----------------
copyright : (C) 2019 by Sandro Mani
email : smani at sourcepole dot ch
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#ifndef KADASCIRCLEITEM_H
#define KADASCIRCLEITEM_H
#include <kadas/gui/mapitems/kadasgeometryitem.h>
class QgsCurvePolygon;
class QgsMultiSurface;
class KADAS_GUI_EXPORT KadasCircleItem : public KadasGeometryItem
{
Q_OBJECT
Q_PROPERTY( bool geodesic READ geodesic WRITE setGeodesic )
public:
KadasCircleItem( const QgsCoordinateReferenceSystem &crs, bool geodesic = false, QObject *parent = nullptr );
bool geodesic() const { return mGeodesic; }
void setGeodesic( bool geodesic );
QString itemName() const override { return tr( "Circle" ); }
QList<KadasMapItem::Node> nodes( const QgsMapSettings &settings ) const override;
bool startPart( const KadasMapPos &firstPoint, const QgsMapSettings &mapSettings ) override;
bool startPart( const AttribValues &values, const QgsMapSettings &mapSettings ) override;
void setCurrentPoint( const KadasMapPos &p, const QgsMapSettings &mapSettings ) override;
void setCurrentAttributes( const AttribValues &values, const QgsMapSettings &mapSettings ) override;
bool continuePart( const QgsMapSettings &mapSettings ) override;
void endPart() override;
AttribDefs drawAttribs() const override;
AttribValues drawAttribsFromPosition( const KadasMapPos &pos, const QgsMapSettings &mapSettings ) const override;
KadasMapPos positionFromDrawAttribs( const AttribValues &values, const QgsMapSettings &mapSettings ) const override;
EditContext getEditContext( const KadasMapPos &pos, const QgsMapSettings &mapSettings ) const override;
void edit( const EditContext &context, const KadasMapPos &newPoint, const QgsMapSettings &mapSettings ) override;
void edit( const EditContext &context, const AttribValues &values, const QgsMapSettings &mapSettings ) override;
AttribValues editAttribsFromPosition( const EditContext &context, const KadasMapPos &pos, const QgsMapSettings &mapSettings ) const override;
KadasMapPos positionFromEditAttribs( const EditContext &context, const AttribValues &values, const QgsMapSettings &mapSettings ) const override;
KadasItemPos position() const override;
void setPosition( const KadasItemPos &pos ) override;
void addPartFromGeometry( const QgsAbstractGeometry &geom ) override;
QgsWkbTypes::GeometryType geometryType() const override { return QgsWkbTypes::PolygonGeometry; }
const QgsMultiSurface *geometry() const;
struct State : KadasMapItem::State
{
QList<KadasItemPos> centers;
QList<double> radii;
void assign( const KadasMapItem::State *other ) override { *this = *static_cast<const State *>( other ); }
State *clone() const override SIP_FACTORY { return new State( *this ); }
QJsonObject serialize() const override;
bool deserialize( const QJsonObject &json ) override;
};
const State *constState() const { return static_cast<State *>( mState ); }
protected:
KadasMapItem *_clone() const override { return new KadasCircleItem( crs() ); } SIP_FACTORY
State *createEmptyState() const override { return new State(); } SIP_FACTORY
void recomputeDerived() override;
void measureGeometry() override;
private:
enum AttribIds {AttrX, AttrY, AttrR};
bool mGeodesic = false;
QgsMultiSurface *geometry();
State *state() { return static_cast<State *>( mState ); }
void computeCircle( const KadasItemPos ¢er, double radius, QgsMultiSurface *multiGeom );
void computeGeoCircle( const KadasItemPos ¢er, double radius, QgsMultiSurface *multiGeom );
};
#endif // KADASCIRCLEITEM_H
| [
"manisandro@gmail.com"
] | manisandro@gmail.com |
34f8f77bdcc5c6d4af535a323390e3f6e64f966a | f86bc650e09483e1a032415aec68abddf64bdb98 | /C++/Chamber.cpp | 785a3d763bf5ea9988ede721b51a55267068fb61 | [] | no_license | Isur/Hunt-The-Wumpus | 1f7d10914790e73a1118c3a39492df064f88e3a5 | 72f2d529a9c3d164680a04e8abead9c51a0947e4 | refs/heads/master | 2021-08-27T23:43:33.198346 | 2017-12-10T20:26:50 | 2017-12-10T20:26:50 | 113,673,159 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 7,436 | cpp | #include "Chamber.h"
Chamber::Chamber(const int chamber)
:number{ chamber }
{
this->n1 = nullptr;
this->n2 = nullptr;
this->n3 = nullptr;
this->player = nullptr;
this->monster = nullptr;
catapult = false;
floor = true;
arrow = false;
}
Chamber::~Chamber()
{
}
Chamber* Chamber::addChamber(Chamber* n)
{
this->n3 = n;
n->n1 = this;
return n;
}
void Chamber::setConnection_1(Chamber *n)
{
this->n1 = n;
}
void Chamber::setConnection_2(Chamber *n)
{
this->n2 = n;
}
void Chamber::setConnection_3(Chamber *n)
{
this->n3 = n;
}
Chamber* Chamber::rewind()
{
if(this->n1->getNumber() != 1) return this->n1->rewind();
return this->n1;
}
Chamber* Chamber::shift(int n)
{
if(n > 0)
{
if(this->n3 != nullptr) return this->n3->shift(n-1);
else return this;
}
else if(n < 0)
{
if(this->n1 != nullptr) return this->n1->shift(n+1);
else return this;
}
return this;
}
void Chamber::printDebug()
{
for(int i = 0; i < 20; i++)
{
this->shift(i)->printInfo();
if(this->shift(i)->getPlayer() != nullptr) std::cout << "Player: " << this->shift(i)->getPlayer()->getName() << " has " << this->shift(i)->getPlayer()->getArrows() << " arrows and his life is " << this->shift(i)->getPlayer()->getLife();
if(this->shift(i)->getMonster() != nullptr) std::cout << "Monster: " << this->shift(i)->getMonster()->getName() << " and his life is " << this->shift(i)->getMonster()->getLife();
}
}
void Chamber::printInfo()
{
std::cout << "\n Chamber " << this->number << " contains: ";
if(this->n1 != nullptr) std::cout << "\t -> " << n1->getNumber();
if(this->n2 != nullptr) std::cout << "\t -> " << n2->getNumber();
if(this->n3 != nullptr) std::cout << "\t -> " << n3->getNumber();
std::cout << "\t";
if(this->player != nullptr) std::cout << "| " << player->getName() << " |";
if(this->monster != nullptr) std::cout << "| " << monster->getName() << " |";
if(this->catapult == true) std::cout << "| CATAPULT |";
if(this->floor == false) std::cout << "| NO FLOOR |";
if(this->arrow == true) std::cout << "| ARROW |";
}
bool Chamber::shoot(int direction)
{
if(player->getArrows() == 0)
{
std::cout << "\n You don't have arrows. Find or die.";
}
else
{
if(direction == 1)
{
player->useArrow();
if(this->n1->getMonster()!=nullptr)
{
return true;
}
}
else if(direction == 2)
{
player->useArrow();
if(this->n2->getMonster()!=nullptr)
{
return true;
}
}
else if(direction == 3)
{
player->useArrow();
if(this->n3->getMonster()!=nullptr)
{
return true;
}
}
else
{
std::cout << "\n Wrong choice... Try again.";
}
}
return false;
}
Chamber* Chamber::move(int direction)
{
if(direction == 1)
{
player->addMove();
this->n1->setPlayer(player);
player->setPosition(this->n1->getNumber());
this->setPlayer(nullptr);
return n1;
}
else if(direction == 2)
{
player->addMove();
this->n2->setPlayer(player);
player->setPosition(this->n2->getNumber());
this->setPlayer(nullptr);
return n2;
}
else if(direction == 3)
{
player->addMove();
this->n3->setPlayer(player);
player->setPosition(this->n3->getNumber());
this->setPlayer(nullptr);
return n3;
}
return this;
}
Chamber* Chamber::findChamber(int n)
{
if(this->getNumber() == n) return this;
else return this->n1->findChamber(n);
return this;
}
Chamber* Chamber::throwPlayer(int chamber)
{
this->player->setPosition(chamber);
this->findChamber(chamber)->setPlayer(player);
this->setPlayer(nullptr);
return this->findChamber(chamber);
}
Chamber* Chamber::check()
{
if(this->getArrow() == true)
{
this->setArrow(false);
player->addArrow();
std::cout << "\n You find an arrow! Now you have " << player->getArrows() << " arrow(s)!";
return this;
}
else if(this->getFloor() == false)
{
std::cout << "\n There is no floor... you die.";
player->die();
return this;
}
else if(this->getCatapult() == true)
{
int randomChamber = rand()%20+1;
std::cout << "\n Catapult here! It will throw you to chamber " << randomChamber << "!";
return this->throwPlayer(randomChamber);
}
else if(this->getMonster() != nullptr)
{
std::cout << "\n You found " << monster->getName() << ". You die.";
player->die();
return this;
}
else
{
std::cout << "\n This room is empty.";
return this;
}
}
void Chamber::infoForPlayer()
{
std::cout << "\n You are in chamber " << this->getNumber() <<". You can move [m][1,2,3] or shoot [s][1,2,3].";
std::cout << "\n You have " << this->player->getArrows() << " arrows.";
std::cout << "\n Chambers connected: " << this->n1->getNumber() << " | " << this->n2->getNumber() << " | " << this->n3->getNumber();
if(this->n1->getMonster() != nullptr) std::cout << "\n Something stinks here...";
if(this->n1->getCatapult() == true) std::cout << "\n Something big is nearby...";
if(this->n1->getFloor() == false) std::cout << "\n You feel draft...";
if(this->n2->getMonster() != nullptr) std::cout << "\n Something stinks here...";
if(this->n2->getCatapult() == true) std::cout << "\n Something big is nearby...";
if(this->n2->getFloor() == false) std::cout << "\n You feel draft...";
if(this->n3->getMonster() != nullptr) std::cout << "\n Something stinks here...";
if(this->n3->getCatapult() == true) std::cout << "\n Something big is nearby...";
if(this->n3->getFloor() == false) std::cout << "\n You feel draft...";
}
void Chamber::monsterMove(Chamber* m, Chamber* p)
{
if(m->n1->getNumber() == p->n1->getNumber() || m->n1->getNumber() == p->n2->getNumber() || m->n1->getNumber() == p->n3->getNumber())
{
m->monster->setPosition(m->n1->getNumber());
m->n1->setMonster(m->getMonster());
m->setMonster(nullptr);
}
else if(m->n2->getNumber() == p->n1->getNumber() || m->n2->getNumber() == p->n2->getNumber() || m->n2->getNumber() == p->n3->getNumber())
{
m->monster->setPosition(m->n2->getNumber());
m->n2->setMonster(m->getMonster());
m->setMonster(nullptr);
}
else if(m->n3->getNumber() == p->n1->getNumber() || m->n3->getNumber() == p->n2->getNumber() || m->n3->getNumber() == p->n3->getNumber())
{
m->monster->setPosition(m->n3->getNumber());
m->n3->setMonster(m->getMonster());
m->setMonster(nullptr);
}
else if(m->n1->getNumber() == p->getNumber())
{
m->monster->setPosition(p->getNumber());
m->n1->setMonster(m->getMonster());
m->setMonster(nullptr);
}
else if(m->n2->getNumber() == p->getNumber())
{
m->monster->setPosition(p->getNumber());
m->n2->setMonster(m->getMonster());
m->setMonster(nullptr);
}
else if(m->n3->getNumber() == p->getNumber())
{
m->monster->setPosition(p->getNumber());
m->n3->setMonster(m->getMonster());
m->setMonster(nullptr);
}
else
{
switch(rand()%3+1)
{
case 1:
m->monster->setPosition(m->n1->getNumber());
m->n1->setMonster(m->getMonster());
m->setMonster(nullptr);
break;
case 2:
m->monster->setPosition(m->n2->getNumber());
m->n2->setMonster(m->getMonster());
m->setMonster(nullptr);
break;
case 3:
m->monster->setPosition(m->n3->getNumber());
m->n3->setMonster(m->getMonster());
m->setMonster(nullptr);
break;
default:
break;
}
}
} | [
"arturbed96@gmail.com"
] | arturbed96@gmail.com |
5a260a46fd8aaa371569bf6ef7d5d8ce7be977b7 | eacdb2112c5f2251ba7fdcdc30ffec5fb1c40dd5 | /07-04-2/07-04-2/07-04-2.cpp | 3a6a5ba74175ef8e95c2e504b5347eb82cfe41af | [] | no_license | PeriD/alalei | 38630418eb4dcd4888d170b019b348868dcade6f | 54f865ff15b3adc1ac85c677a42777b09bda25f3 | refs/heads/master | 2020-06-11T05:34:00.829137 | 2020-03-05T15:15:08 | 2020-03-05T15:15:08 | 193,864,095 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 299 | cpp | #define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
int main()
{
int n;
int a, b;
while (cin >> n)
{
int i;
int tep = 1;
for (i = 0; i < n; i++)
{
tep *= 5;
a = 5 * (tep - 1) + 1;
}
b = n;
cout << a << ' ' << b << endl;
}
system("pause");
return 0;
} | [
"1002906778@qq.com"
] | 1002906778@qq.com |
a6ee70bd1cade0672eb0a57b2192489aef22a639 | 803c5084fb83c1b50c3bd0734f48f30792f783e1 | /SPOJ/icpc-acm6139.cc | b8903415fb9c87aa1bfe460c5a4117698f49a978 | [] | no_license | guilhermeleobas/maratona | 9627570276d4fd843918013c1fd5a702bbada0e4 | 5d46263b335d2e70b0156001116f7030a068cf5a | refs/heads/master | 2022-09-20T11:28:26.367178 | 2022-09-05T05:20:43 | 2022-09-05T05:20:43 | 21,397,024 | 5 | 5 | null | null | null | null | UTF-8 | C++ | false | false | 2,846 | cc | /*
Problema - 6139 - Interval Product
https://icpcarchive.ecs.baylor.edu/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=4150
Guilherme Leobas
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <set>
#include <vector>
#include <algorithm>
#include <utility>
#include <iomanip>
using namespace std;
int segtree[1001000];
int vetor[1001000];
int n, k;
void imprime (){
for (int i=0; i<pow(2, log2(n)+1); i++)
cout << segtree[i] << ' ';
cout << endl << endl;
}
void inicializa (int l, int r, int node){
if (l > r) return;
if (l == r){
segtree[node] = vetor[r];
}
else {
inicializa (l, (l+r)/2, 2*node+1);
inicializa ((l+r)/2+1, r, 2*node+2);
// cout << node << ' ' << 2*node+1 << ' ' << 2*node+2 << endl;
segtree[node] = segtree[2*node+1]*segtree[2*node+2];
}
}
void update (int node, int l, int r, int x){
if (l > r || l > x || r < x)
return;
if (l == r){
segtree[node] = vetor[l];
return;
}
update (2*node+1, l, (l+r)/2, x);
update (2*node+2, (l+r)/2+1, r, x);
segtree[node] = segtree[2*node+1]*segtree[2*node+2];
}
int query (int node, int l, int r, int i, int j){
int p1, p2;
//size overflow;
if (l > r || l > j || r < i)
return -100;
//Intervalo incluido
if (l >= i && r <= j)
return segtree[node];
//
p1 = query (2*node+1, l, (l+r)/2, i, j);
p2 = query (2*node+2, (l+r)/2+1, r, i, j);
// cout << p1 << ' ' << l << ' ' << r << ' ' << i << ' ' << j << endl;
if (p1 != -100 && p2 != -100)
return p1*p2;
else if (p1 == -100)
return p2;
else
return p1;
}
int main (){
char c;
int y, x;
int sz;
while (true){
cin >> n >> k;
if (!cin)
break;
for (int i=0; i<n; i++){
cin >> vetor[i];
if (vetor[i] > 0)
vetor[i] = 1;
else if (vetor[i] < 0)
vetor[i] = -1;
}
inicializa (0, n-1, 0);
// imprime();
for (int i=0; i<k; i++){
cin >> c >> x >> y;
//imprime ();
if (c == 'C'){
//Update;
if (y > 0)
vetor[x-1] = 1;
else if (y < 0)
vetor[x-1] = -1;
else
vetor[x-1] = 0;
update (0, 0, n-1, x-1);
}
else{
//Query
int r = query (0, 0, n-1, x-1, y-1);
if (r == 0)
cout << '0';
else if (r > 0)
cout << '+';
else
cout << '-';
// cout << endl;
}
}
cout << endl;
}
return 0;
} | [
"guilhermeleobas@gmail.com"
] | guilhermeleobas@gmail.com |
c9cfaf13ab4b0283769f8579c84df412e6a5be28 | 2cda4cee70a7b676520dcacd25fb928e00f7f77b | /src/sinbaram/SkillFunction/Morayion.cpp | 97c42fbc228cd91f9d65a5c513fd466703691030 | [] | no_license | GreenDamTan/priston | bbb23b6c9a10f8132f0534b48bd0e3c93c4320cb | 9c416f64332016ac3b040eecf8f31207719b8fbb | refs/heads/master | 2020-12-02T06:33:35.548117 | 2017-01-14T17:54:24 | 2017-01-14T17:54:24 | 96,853,442 | 1 | 1 | null | 2017-07-11T05:17:06 | 2017-07-11T05:17:06 | null | UHC | C++ | false | false | 23,427 | cpp | /*----------------------------------------------------------------------------*
* 파일명 : Morayion.cpp
* 하는일 : 모라이온의 스킬
* 작성일 : 최종업데이트 9월
* 적성자 : 박상열
*-----------------------------------------------------------------------------*/
#include "..\\sinLinkHeader.h"
/*----------------------------------------------------------------------------*
* 기본 설정 함수
*-----------------------------------------------------------------------------*/
//스킬을 사용할수있는지를 체크한다
DWORD sinNotToggleSkill_CODE[][5] = {
{SKILL_HOLY_BODY,SKILL_HOLY_VALOR,SKILL_DRASTIC_SPIRIT,0},
{SKILL_ZENITH,0},
{SKILL_WINDY,0},
{SKILL_HOLY_REFLECTION,0},
{SKILL_SPIRIT_ELEMENTAL,0},
{SKILL_DANCING_SWORD,0},
{SKILL_CONCENTRATION,0},
{SKILL_SWIFT_AXE,0},
{SKILL_FALCON,0},
{SKILL_GOLDEN_FALCON,0},
{SKILL_SCOUT_HAWK,0},
{SKILL_DIVINE_INHALATION,0},
{SKILL_METAL_ARMOR,0},
{SKILL_SPARK_SHIELD,0},
{SKILL_VANISH,0},
{SKILL_GODLY_SHIELD,0},
{SKILL_GOD_BLESS,0},
{SKILL_FROST_JAVELIN,0},
{SKILL_REGENERATION_FIELD,0},
{SKILL_SUMMON_MUSPELL,0},
{SKILL_FIRE_ELEMENTAL,0},
{SKILL_DISTORTION,0},
// {SKILL_COMPULSION,0}, // 장별 - 스킬밸런스 조정(10.08.10)
{SKILL_MAGNETIC_SPHERE,0},
{SKILL_METAL_GOLEM,0},
{SKILL_BERSERKER,0},
{SKILL_ASSASSIN_EYE,0},
{SKILL_VAGUE,0},
{SKILL_RECALL_WOLVERIN,0},
//공성전 아이템 스킬
{SCROLL_INVULNERABILITY,0},
{SCROLL_CRITICAL,0},
{SCROLL_EVASION,0},
{STONE_R_FIRECRYTAL,0},
{STONE_R_ICECRYTAL,0},
{STONE_R_LINGHTINGCRYTAL,0},
{STONE_A_FIGHTER,0},
{STONE_A_MECHANICIAN,0},
{STONE_A_PIKEMAN,0},
{STONE_A_ARCHER,0},
{STONE_A_KNIGHT,0},
{STONE_A_ATALANTA,0},
{STONE_A_MAGICIAN,0},
{STONE_A_PRIESTESS,0},
//{SKILL_TRIUMPH_OF_VALHALLA,SKILL_HALL_OF_VALHALLA,0},
0, //0을 써주지않으면 무한루프를 돌수있다
};
int sinCheckSkillUseOk(sSKILL *lpSkill)
{
ContinueSkillCancelFlag = 0; //이곳에서 초기화해준다
int i = 0;
//SkillInfo 데이타를 검사한다
if(!cSkill.CheckCharSkillInfo())return FALSE;
#define CHAR_SKILL_MASK 0xFF000000
//자신의 스킬이 맞는지를 체크한다
//DRZ_EDIT (add new class handling here)
int CharCode[8] = { JOBCODE_MECHANICIAN, JOBCODE_FIGHTER, JOBCODE_ARCHER, JOBCODE_PIKEMAN, JOBCODE_KNIGHT, JOBCODE_ATALANTA, JOBCODE_PRIESTESS, JOBCODE_MAGICIAN };
DWORD CharSkillCode[8] = {GROUP_MECHANICIAN,GROUP_FIGHTER , GROUP_ARCHER,GROUP_PIKEMAN,GROUP_KNIGHT,GROUP_ATALANTA,GROUP_PRIESTESS,GROUP_MAGICIAN};
for(int j= 0 ; j < 8 ; j++){
if(CharCode[j] == sinChar->JOB_CODE){
if((lpSkill->CODE & CHAR_SKILL_MASK) !=CharSkillCode[j] ){
return FALSE;
}
}
}
/*
//마나와 스테미나를 한번더 체크한다 // 장별-마나 리듀스 썼을 경우
if(lpSkill->Skill_Info.UseMana)
{
if( chaPremiumitem.m_ManaReducePotiontime > 0 )
{
if(sinGetMana() >= lpSkill->Skill_Info.UseMana[lpSkill->Point - 1] - (lpSkill->Skill_Info.UseMana[lpSkill->Point - 1] * chaPremiumitem.m_ManaReducePotionValue / 100) &&
sinGetStamina() >= lpSkill->Skill_Info.UseStamina[0] + (lpSkill->Skill_Info.UseStamina[1]*(lpSkill->Point-1)))
{
return TRUE;
}
else
return FALSE;
}
else
{
if((sinGetMana() - lpSkill->Skill_Info.UseMana[lpSkill->Point - 1]) < 0)
return FALSE;
}
}
if(lpSkill->Skill_Info.UseStamina[0]){
if((sinGetStamina() - (lpSkill->Skill_Info.UseStamina[0] + (lpSkill->Skill_Info.UseStamina[1]*(lpSkill->Point-1)))) < 0 )
return FALSE;
}
*/
/*
//마나와 스테미나를 한번더 체크한다 // 장별-마나 리듀스 썼을 경우
if(lpSkill->Skill_Info.UseMana)
{
if(chaPremiumitem.m_ManaReducePotiontime > 0) // 박재원 - 마나 리듀스 사용중일 경우 스킬 사용가능한 마나도 함께 줄인다.
{
if(sinGetMana() - ( lpSkill->Skill_Info.UseMana[lpSkill->Point - 1] - (lpSkill->Skill_Info.UseMana[lpSkill->Point - 1] * chaPremiumitem.m_ManaReducePotionValue / 100) ) < 0)
return FALSE;
}
else
{
if((sinGetMana() - lpSkill->Skill_Info.UseMana[lpSkill->Point - 1]) < 0)
return FALSE;
}
}
*/
// 장별 - 테리 속성
if(chaPremiumitem.m_ManaReducePotiontime > 0 && chaPremiumitem.m_TerryTime > 0 && sinChar->GravityScroolCheck[1] == 1) // 박재원 - 마나 리듀스 사용중일 경우 스킬 사용가능한 마나도 함께 줄인다.
{
if(sinGetMana() - ( lpSkill->Skill_Info.UseMana[lpSkill->Point - 1] - ((lpSkill->Skill_Info.UseMana[lpSkill->Point - 1] * chaPremiumitem.m_ManaReducePotionValue / 100) +
(lpSkill->Skill_Info.UseMana[lpSkill->Point - 1] * 20 / 100))) < 0)
return FALSE;
}
else if( chaPremiumitem.m_ManaReducePotiontime > 0 )
{
if(sinGetMana() - ( lpSkill->Skill_Info.UseMana[lpSkill->Point - 1] - (lpSkill->Skill_Info.UseMana[lpSkill->Point - 1] * chaPremiumitem.m_ManaReducePotionValue / 100) ) < 0)
return FALSE;
}
else if( chaPremiumitem.m_TerryTime > 0 && sinChar->GravityScroolCheck[1] == 1)
{
if(sinGetMana() - ( lpSkill->Skill_Info.UseMana[lpSkill->Point - 1] - (lpSkill->Skill_Info.UseMana[lpSkill->Point - 1] * 20 / 100) ) < 0)
return FALSE;
}
else
{
if((sinGetMana() - lpSkill->Skill_Info.UseMana[lpSkill->Point - 1]) < 0)
return FALSE;
}
//토글되면 안되는 스킬을 체크해준다
int CntSkillNum = 0; //스킬을 카운트 해준다
int k = 0;
int Index3 = 0; //포스오브네이처
if(Index3 = cSkill.SearchContiueSkillIndex(SKILL_FORCE_OF_NATURE)){
if(ContinueSkill[Index3-1].Flag == 1 && lpSkill->CODE == SKILL_FORCE_OF_NATURE)
return FALSE;
}
if(Index3 = cSkill.SearchContiueSkillIndex(SKILL_HALL_OF_VALHALLA)){
if(ContinueSkill[Index3-1].Flag == 1 && lpSkill->CODE == SKILL_HALL_OF_VALHALLA)
return FALSE;
}
while(1){
if(!sinNotToggleSkill_CODE[CntSkillNum][0])break; //지속형 스킬이 아니라면 while문을 빠져나온다.
for(i = 0 ; 0 != sinNotToggleSkill_CODE[CntSkillNum][i] ; i++){
if(sinNotToggleSkill_CODE[CntSkillNum][i] == lpSkill->CODE ){ //현재 사용된 지속형스킬을 찾는다.
//같이 사용하면 안돼는 스킬을 체크해준다.
for(k = 0 ; 0 != sinNotToggleSkill_CODE[CntSkillNum][k] ; k++){
for( int j = 0 ; j < MAX_CONTINUE_SKILL ; j++){
if(ContinueSkill[j].Flag && ContinueSkill[j].CODE == sinNotToggleSkill_CODE[CntSkillNum][k]){
return FALSE;
}
}
}
}
}
CntSkillNum++;
}
int UseFlag = 0;
int UseFlag2 = 0;
if(lpSkill->Skill_Info.UseWeaponCode[0]){
UseFlag = 1;
for(int i=0;i<8;i++){
if(lpSkill->Skill_Info.UseWeaponCode[i]){
if(lpSkill->Skill_Info.UseWeaponCode[i] == (cInvenTory.InvenItem[sInven[0].ItemIndex-1].CODE&sinITEM_MASK2)){ //
UseFlag2 = 1;
break;
}
}
}
}
//메탈아머 매특만 사용할수있음
if(lpSkill->CODE == SKILL_METAL_ARMOR){
if(sInven[2].ItemIndex){
if(cInvenTory.InvenItem[sInven[2].ItemIndex-1].sItemInfo.JobCodeMask == sinChar->JobBitMask){
if(lpSkill->UseSkillFlag){
return TRUE;
}
}
}
return FALSE;
}
if(UseFlag){
if(UseFlag2 && lpSkill->UseSkillFlag)
return TRUE;
}
else{
if(lpSkill->UseSkillFlag)
return TRUE;
}
//////////// 아틀란타 방패던지기 , 쉴드 스트라이크
if(lpSkill->CODE == SKILL_SHIELD_STRIKE || lpSkill->CODE == SKILL_EXTREME_SHIELD || lpSkill->CODE == SKILL_DIVINE_INHALATION || lpSkill->CODE == SKILL_SPARK_SHIELD || lpSkill->CODE == SKILL_GODLY_SHIELD){
if(lpSkill->UseSkillFlag){
if(lpSkill->Skill_Info.UseWeaponCode[0] == (cInvenTory.InvenItem[sInven[1].ItemIndex-1].CODE&sinITEM_MASK2)){ //
return TRUE;
}
}
}
/////////// 소울석커 (믹스쳐한 방패와 에이징한 방패만사용할수있다)
if(lpSkill->CODE == SKILL_SOUL_SUCKER){ //믹스처랑 에이징 아이템이 아닌경우는 사용할수없다
if(cInvenTory.InvenItem[sInven[1].ItemIndex-1].sItemInfo.ItemKindCode == ITEM_KIND_CRAFT ||
cInvenTory.InvenItem[sInven[1].ItemIndex-1].sItemInfo.ItemKindCode == ITEM_KIND_AGING ){
if(lpSkill->Skill_Info.UseWeaponCode[0] == (cInvenTory.InvenItem[sInven[1].ItemIndex-1].CODE&sinITEM_MASK2)){ //
if(lpSkill->UseSkillFlag){ //<============== 여기
return TRUE;
}
}
}
}
return FALSE;
}
//사용한 스킬의 기력과 마나를 소모한다
int sinUseManaStamina(sSKILL *lpSkill)
{
/*
if( chaPremiumitem.m_ManaReducePotiontime <= 0 ) // pluto 마나 리듀스 포션
{
if(lpSkill->Skill_Info.UseMana){
sinSetMana(sinGetMana() - lpSkill->Skill_Info.UseMana[lpSkill->Point - 1]);
}
}
else
{
if( lpSkill->Skill_Info.UseMana )
{
sinSetMana( sinGetMana() - ( lpSkill->Skill_Info.UseMana[ lpSkill->Point - 1] - (lpSkill->Skill_Info.UseMana[ lpSkill->Point - 1] * chaPremiumitem.m_ManaReducePotionValue / 100) ) );
}
}
*/
// 장별 - 테리 속성
if( chaPremiumitem.m_ManaReducePotiontime > 0 && chaPremiumitem.m_TerryTime > 0 && sinChar->GravityScroolCheck[1] == 1)
{
sinSetMana( sinGetMana() - ( lpSkill->Skill_Info.UseMana[ lpSkill->Point - 1] -
((lpSkill->Skill_Info.UseMana[ lpSkill->Point - 1] * chaPremiumitem.m_ManaReducePotionValue / 100) +
(lpSkill->Skill_Info.UseMana[ lpSkill->Point - 1] * 20 / 100)) ) );
}
else if( chaPremiumitem.m_ManaReducePotiontime > 0 )
{
sinSetMana( sinGetMana() - ( lpSkill->Skill_Info.UseMana[ lpSkill->Point - 1] - (lpSkill->Skill_Info.UseMana[ lpSkill->Point - 1] * chaPremiumitem.m_ManaReducePotionValue / 100) ) );
}
else if( chaPremiumitem.m_TerryTime > 0 && sinChar->GravityScroolCheck[1] == 1 )
{
sinSetMana( sinGetMana() - ( lpSkill->Skill_Info.UseMana[ lpSkill->Point - 1] - (lpSkill->Skill_Info.UseMana[ lpSkill->Point - 1] * 20 / 100) ) );
}
else
{
if(lpSkill->Skill_Info.UseMana)
sinSetMana(sinGetMana() - lpSkill->Skill_Info.UseMana[lpSkill->Point - 1]);
}
// 박재원 - 근력 리듀스 포션
if(lpSkill->Skill_Info.UseStamina[0])
{
if( chaPremiumitem.m_StaminaReducePotiontime <= 0 )
{
sinSetStamina(sinGetStamina() - (lpSkill->Skill_Info.UseStamina[0] + (lpSkill->Skill_Info.UseStamina[1]*(lpSkill->Point-1))));
}
else
{
sinSetStamina(sinGetStamina() - ( (lpSkill->Skill_Info.UseStamina[0] + (lpSkill->Skill_Info.UseStamina[1]*(lpSkill->Point-1)))
- ( (lpSkill->Skill_Info.UseStamina[0] + (lpSkill->Skill_Info.UseStamina[1]*(lpSkill->Point-1))) * chaPremiumitem.m_StaminaReducePotionValue / 100)) );
}
}
cSkill.CheckSkillMasteryForm(lpSkill); // 스킬 마스터리를 체크한다
lpSkill->Mastery =0; //사용후 딜레이값 초기화
cSkill.ReformSkillMasteryForm(lpSkill);
lpSkill->UseSKillIncreCount++;
if(lpSkill->UseSKillIncreCount >= sinMasteryIncreaIndex[lpSkill->Skill_Info.SkillNum]+((lpSkill->Point-1)/3)){
lpSkill->UseSKillIncreCount = 0;
lpSkill->UseSkillCount += USE_SKILL_MASTERY_COUNT;
}
return TRUE;
}
//지속적으로 사용될 스킬을 셋팅한다
int sinContinueSkillSet(sSKILL *lpSkill)
{
int i = 0;
//에너지 쉴드만 예외처리(해외)
if(lpSkill->CODE == SKILL_ENERGY_SHIELD|| lpSkill->CODE == SKILL_COMPULSION) // 장별 - 스킬밸런스 조정(10.08.10)
{
for( i = 0 ; i < MAX_CONTINUE_SKILL ; i++)
{
if(ContinueSkill[i].Flag )
{
if(ContinueSkill[i].CODE == SKILL_ENERGY_SHIELD || ContinueSkill[i].CODE == SKILL_COMPULSION) // 장별 - 스킬밸런스 조정(10.08.10)
{
memset(&ContinueSkill[i],0,sizeof(sSKILL));
break;
}
}
}
}
for(i = 0 ; i < MAX_CONTINUE_SKILL ; i++){
if(!ContinueSkill[i].Flag){
memcpy(&ContinueSkill[i],lpSkill,sizeof(sSKILL));
ContinueSkill[i].Flag = 1;
cSkill.SearchSkillDoc(&ContinueSkill[i]);
if((lpSkill->CODE != SKILL_FORCE_ORB && lpSkill->CODE != CHANGE_JOB3_QUEST &&lpSkill->CODE != CHANGE_ELEMENTARY_QUEST &&
lpSkill->CODE != BOOSTER_ITEM_LIFE && lpSkill->CODE != BOOSTER_ITEM_MANA && lpSkill->CODE != BOOSTER_ITEM_STAMINA)) // 박재원 - 부스터 아이템
ContinueSkill[i].MatIcon = 0;//초기화한번더해준다
break;
}
}
return TRUE;
}
//시간이 지나면 지속사용스킬셋팅을 초기화한다
int sinCheckContinueSkill()
{
//템스크론 cpp에서 체크하고있음
/*
for(int i = 0 ; i < MAX_CONTINUE_SKILL ; i++){
if(ContinueSkill[i].Flag){
ContinueSkill[i].Time[0]++;
if(ContinueSkill[i].Time[0] >= ContinueSkill[i].Time[1]*70){
memset(&ContinueSkill[i],0,sizeof(sSKILL));
cInvenTory.SetItemToChar(); //셋팅을 변경한다
}
}
}
*/
return TRUE;
}
/*----------------------------------------------------------------------------*
* 스킬을 토글한다
*-----------------------------------------------------------------------------*/
int sinSwitchSkill(sSKILL *pSkill)
{
/* 파티원 스킬때문에 스킬을 스위치하지않는다
int i = 0;
switch(pSkill->CODE){
case SKILL_HOLY_VALOR:
for(i = 0; i < 10 ; i++){
if(ContinueSkill[i].CODE == SKILL_HOLY_BODY || ContinueSkill[i].CODE == SKILL_DRASTIC_SPIRIT){
memset(&ContinueSkill[i],0,sizeof(sSKILL));
cInvenTory.SetItemToChar();
}
}
break;
case SKILL_HOLY_BODY:
for(i = 0; i < 10 ; i++){
if(ContinueSkill[i].CODE == SKILL_HOLY_VALOR || ContinueSkill[i].CODE == SKILL_DRASTIC_SPIRIT){
memset(&ContinueSkill[i],0,sizeof(sSKILL));
cInvenTory.SetItemToChar();
}
}
break;
case SKILL_DRASTIC_SPIRIT:
for(i = 0; i < 10 ; i++){
if(ContinueSkill[i].CODE == SKILL_HOLY_VALOR || ContinueSkill[i].CODE == SKILL_DRASTIC_SPIRIT){
memset(&ContinueSkill[i],0,sizeof(sSKILL));
cInvenTory.SetItemToChar();
}
}
break;
}
*/
return TRUE;
}
/*----------------------------------------------------------------------------*
* 모라이온 스킬함수
*-----------------------------------------------------------------------------*/
//////////////// 나이트
int F_Sword_Blast()
{
//할일엄따
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_HolyBody()
{
pUseSkill->UseTime = HolyBody_Time[pUseSkill->Point-1];
sinContinueSkillSet(pUseSkill);
sinUseManaStamina(pUseSkill);
sinSwitchSkill(pUseSkill);
return TRUE;
}
int F_Physical_Traning()
{
//할일엄따
return TRUE;
}
int F_Double_Crash()
{
//할일엄따
sinUseManaStamina(pUseSkill);
return TRUE;
}
/////////// 아틀란타
int F_S_Strike()
{
//할일엄따
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_Farina()
{
//할일 엄따
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_D_Mastery()
{
//으앙~~ 나두 할일엄따
return TRUE;
}
int F_V_Spear()
{
//으아아앙 나두 할일이 엄떠여 ㅜ.ㅜ
sinUseManaStamina(pUseSkill);
return TRUE;
}
/////////// 프리스티스
int F_Healing()
{
//에이 나두 할일엄떠여...
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_HolyBolt()
{
//으앙 난 모하라구
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_M_Spark()
{
//흑흑 일좀 시켜줘여...
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_HolyMind()
{
//으앙 나두 할일이 엄떠여...
sinUseManaStamina(pUseSkill);
return TRUE;
}
/////////// 메지션
int F_Agony()
{
short TempLife,TempLife2,TempMana;
sinUseManaStamina(pUseSkill);
TempLife = (short)(((float)sinChar->Life[1]/100.0f)*(float)Agony_ConvLife[pUseSkill->Point-1]);
TempMana = (short)(((float)sinChar->Mana[1]/100.0f)*(float)Agony_ConvLife[pUseSkill->Point-1]);
if((sinGetLife()-TempLife) > 0){
TempLife2 = sinGetLife()-TempLife;
sinSetLife(TempLife2);
TempMana = sinGetMana()+TempMana;
sinSetMana(TempMana);
};
//
//sinSetLife
return TRUE;
}
int F_FireBolt()
{
//메롱
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_Zenith()
{
//pUseSkill->Time[1] = Zenith_Time[pUseSkill->Point-1];
pUseSkill->UseTime = Zenith_Time[pUseSkill->Point-1];
sinContinueSkillSet(pUseSkill);
sinUseManaStamina(pUseSkill);
cInvenTory.SetItemToChar(); //셋팅을 변경한다
return TRUE;
}
int F_ZenithFromServer(int Time) //파티원에 적용시키기위해서 서버에서 받아온다
{
for(int i = 0 ; i < MAX_CONTINUE_SKILL ; i++){
if(!ContinueSkill[i].Flag){
ContinueSkill[i].Flag = 1;
ContinueSkill[i].CODE = SKILL_ZENITH;
ContinueSkill[i].Time[1] = Time;
ContinueSkill[i].PartyFlag = 1;
break;
}
}
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_FireBall()
{
//모라이온 끝!
sinUseManaStamina(pUseSkill);
return TRUE;
}
/*----------------------------------------------------------------------------*
* 모라이온 2차스킬함수
*-----------------------------------------------------------------------------*/
//나이트
int F_Holy_Valor()
{
pUseSkill->UseTime = Holy_Valor_Time[pUseSkill->Point-1];
sinContinueSkillSet(pUseSkill);
sinUseManaStamina(pUseSkill);
sinSwitchSkill(pUseSkill);
return TRUE;
}
/* 잠시대기
int F_Holy_Valor_Party() //파티원 적용
{
pUseSkill->UseTime = Holy_Valor_Time[pUseSkill->Point-1];
sinContinueSkillSet(pUseSkill);
sinUseManaStamina(pUseSkill);
sinSwitchSkill(pUseSkill);
return TRUE;
}
*/
int F_Brandish()
{
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_Piercing()
{
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_Drastic_Spirit()
{
pUseSkill->UseTime = Drastic_Spirit_Time[pUseSkill->Point-1];
sinContinueSkillSet(pUseSkill);
sinUseManaStamina(pUseSkill);
sinSwitchSkill(pUseSkill);
cInvenTory.SetItemToChar(); //셋팅을 변경한다
return TRUE;
}
int F_Windy()
{
pUseSkill->UseTime = Windy_Time[pUseSkill->Point-1];
sinContinueSkillSet(pUseSkill);
sinUseManaStamina(pUseSkill);
cInvenTory.SetItemToChar(); //셋팅을 변경한다
return TRUE;
}
int F_Twist_Javelin()
{
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_Soul_Sucker()
{
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_Fire_Javelin()
{
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_Meditation()
{
return TRUE;
}
int F_Divine_Lightning()
{
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_Holy_Reflection()
{
pUseSkill->UseTime = Holy_Reflection_Time[pUseSkill->Point-1];
sinContinueSkillSet(pUseSkill);
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_Grand_Healing()
{
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_Mental_Mastery()
{
return TRUE;
}
int F_Watornado()
{
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_Enchant_Weapon()
{
//pUseSkill->UseTime = Enchant_Weapon_Time[pUseSkill->Point-1];
//sinContinueSkillSet(pUseSkill);
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_Dead_Ray()
{
sinUseManaStamina(pUseSkill);
return TRUE;
}
/*----------------------------------------------------------------------------*
* 모라이온 3차스킬함수
*-----------------------------------------------------------------------------*/
//나이트
int F_S_Mastery()
{
return TRUE;
}
int F_D_Inhalation()
{
pUseSkill->UseTime = D_Inhalation_Time[pUseSkill->Point-1];
sinContinueSkillSet(pUseSkill);
sinUseManaStamina(pUseSkill);
SwitchSkill(pUseSkill);
cInvenTory.SetItemToChar(); //셋팅을 변경한다
return TRUE;
}
int F_Holy_Incantation()
{
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_Grand_Cross()
{
sinUseManaStamina(pUseSkill);
return TRUE;
}
//아탈란타
int F_Split_Javelin()
{
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_T_Of_Valhalla()
{
//pUseSkill->UseTime = T_Of_Valhalla_Time[pUseSkill->Point-1];
//sinContinueSkillSet(pUseSkill);
sinUseManaStamina(pUseSkill);
//sinSwitchSkill(pUseSkill); //지금 현제는 스위치할게 엄따
//cInvenTory.SetItemToChar(); //셋팅을 변경한다
if(!pUseSkill->SkillTaget_CODE)
SetT_Of_ValhallaFlag2 = 1;
return TRUE;
}
int F_Lightning_Javelin()
{
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_Storm_Javelin()
{
sinUseManaStamina(pUseSkill);
return TRUE;
}
//프리스티스
int F_Vigor_Ball()
{
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_Resurrection()
{
sinUseManaStamina(pUseSkill); //
return TRUE;
}
int F_Extinction()
{
sinUseManaStamina(pUseSkill); //
return TRUE;
}
int F_Virtual_Life() //요놈참 문제일세
{
//pUseSkill->UseTime = Virtual_Life_Time[pUseSkill->Point-1];
//sinContinueSkillSet(pUseSkill);
sinUseManaStamina(pUseSkill); //Set함수에서 해준다
//sinSwitchSkill(pUseSkill);
//cInvenTory.SetItemToChar(); //셋팅을 변경한다
return TRUE;
}
//메지션
int F_Energy_Shield()
{
pUseSkill->UseTime = Energy_Shield_Time[pUseSkill->Point-1];
sinContinueSkillSet(pUseSkill);
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_Diastrophism()
{
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_Spirit_Elemental()
{
pUseSkill->UseTime = Spirit_Elemental_Time[pUseSkill->Point-1];
sinContinueSkillSet(pUseSkill);
sinUseManaStamina(pUseSkill);
cInvenTory.SetItemToChar(); //셋팅을 변경한다
return TRUE;
}
int F_D_Sword()
{
pUseSkill->UseTime = Dancing_Sword_Time[pUseSkill->Point-1];
sinContinueSkillSet(pUseSkill);
sinUseManaStamina(pUseSkill);
cInvenTory.SetItemToChar(); //셋팅을 변경한다
return TRUE;
}
/*----------------------------------------------------------------------------*
* 모라이온 4차스킬함수
*-----------------------------------------------------------------------------*/
//나이트
int F_Divine_Piercing()
{
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_Godly_Shield()
{
pUseSkill->UseTime = Godly_Shield_Time[pUseSkill->Point-1];
sinContinueSkillSet(pUseSkill);
sinUseManaStamina(pUseSkill);
SwitchSkill(pUseSkill);
return TRUE;
}
int F_God_Bless()
{
pUseSkill->UseTime = God_Bless_Time[pUseSkill->Point-1];
sinContinueSkillSet(pUseSkill);
sinUseManaStamina(pUseSkill);
cInvenTory.SetItemToChar(); //셋팅을 변경한다
return TRUE;
}
int F_Sword_Of_Justice()
{
sinUseManaStamina(pUseSkill);
return TRUE;
}
//아틀란타
int F_Hall_Of_Valhalla()
{
//잠시대기
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_X_Rage()
{
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_Frost_Javelin()
{
pUseSkill->UseTime = Frost_Javelin_Time[pUseSkill->Point-1];
sinContinueSkillSet(pUseSkill);
sinUseManaStamina(pUseSkill);
cInvenTory.SetItemToChar(); //셋팅을 변경한다
return TRUE;
}
int F_Vengeance()
{
sinUseManaStamina(pUseSkill);
return TRUE;
}
//프리스티스
int F_Glacial_Spike()
{
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_Regeneration_Field()
{
//pUseSkill->UseTime = Regeneration_Field_Time[pUseSkill->Point-1];
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_Chain_Lightning()
{
sinUseManaStamina(pUseSkill);
return TRUE;
}
int F_Summon_Muspell()
{
pUseSkill->UseTime = Summon_Muspell_Time[pUseSkill->Point-1];
sinUseManaStamina(pUseSkill); //소환물은 어케해야할지 대기
sinContinueSkillSet(pUseSkill);
return TRUE;
}
//매지션
int F_Fire_Elemental() //조금 생각해봐야함
{
pUseSkill->UseTime = 6*60;;
sinContinueSkillSet(pUseSkill);
sinUseManaStamina(pUseSkill);
SummonSkillCodeIndex[1] = 0;
return TRUE;
}
int F_Flame_Wave()
{
sinUseManaStamina(pUseSkill); //소환물은 어케해야할지 대기
return TRUE;
}
int F_Distortion()
{
pUseSkill->UseTime = Distortion_Time[pUseSkill->Point-1];
//sinContinueSkillSet(pUseSkill);
sinUseManaStamina(pUseSkill);
//cInvenTory.SetItemToChar(); //셋팅을 변경한다
return TRUE;
}
int F_Meteo()
{
sinUseManaStamina(pUseSkill); //소환물은 어케해야할지 대기
return TRUE;
}
| [
"renan.toledo@live.com"
] | renan.toledo@live.com |
75833ec58496a76c294c146e3d5baff599ddd12c | 9d87d93adf445dff5bb174e72872efd053e14c07 | /bus_routes/main.cpp | c7a8c341d593447a890d79535c42b918798d93fd | [] | no_license | smhx/dmoj | c1064ab32d9609483bd3a072d09efa6b9bf254b1 | c4bb7cc5ac59427718ad08325b760b139c7c9487 | refs/heads/master | 2021-09-17T05:15:28.702218 | 2018-06-28T10:19:43 | 2018-06-28T10:19:43 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 107 | cpp | #include <bits/stdc++.h>
using namespace std;
int N, K, P;
int main() {
scanf("%d%d%d", &N, &K, &P);
} | [
"stevenmai132@yahoo.ca"
] | stevenmai132@yahoo.ca |
888e31bf52f2bc2e3250c304eca1b341098e344d | 2b3aa52fcc52d6fe45fde4d6aba280a95fce3f6e | /SML/sml/Value.cpp | 85eb3ac070f24767ca2d181156275821ee16e187 | [] | no_license | risooonho/SML | ee920d867dd4393837d7c24f8aadf39b5c40cf81 | b26210c0430745a0ab3e2af27dc8238eecaa4275 | refs/heads/master | 2021-05-29T08:03:10.968923 | 2015-04-21T12:04:13 | 2015-04-21T12:04:13 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,739 | cpp | #include "Value.hpp"
#include "Parser.hpp"
namespace sml
{
const String Value::defaultString;
const Array Value::defaultArray;
const Object Value::defaultObject;
const TypedObject Value::defaultTypedObject;
Value::Value(const Value & other)
{
*this = other;
}
void Value::loadFromStream(std::istream & input)
{
Parser parser;
parser.parseValue(input, *this);
}
void Value::reset()
{
switch (m_type)
{
case VT_STRING:
delete m_data.pString;
break;
case VT_ARRAY:
delete m_data.pArray;
break;
case VT_OBJECT:
delete m_data.pObject;
break;
case VT_TYPEDOBJECT:
delete m_data.pCustom;
break;
default:
break;
}
memset(&m_data, 0, sizeof(Data));
m_type = VT_NULL;
}
void Value::resetArray()
{
reset();
m_data.pArray = new Array();
m_type = VT_ARRAY;
}
void Value::resetObject()
{
reset();
m_data.pObject = new Object();
m_type = VT_OBJECT;
}
void Value::resetTypedObject()
{
reset();
m_data.pCustom = new TypedObject();
m_type = VT_TYPEDOBJECT;
}
void Value::resetString()
{
reset();
m_data.pString = new String();
m_type = VT_STRING;
}
void Value::setBool(bool v)
{
reset();
m_data.vBool = v;
m_type = VT_BOOL;
}
void Value::setInt(int v)
{
reset();
m_data.vInt = v;
m_type = VT_INT;
}
void Value::setReal(real v)
{
reset();
m_data.vReal = v;
m_type = VT_REAL;
}
void Value::setString(const String & str)
{
switch (m_type)
{
case VT_STRING:
*m_data.pString = str;
break;
default:
reset();
m_data.pString = new String(str);
break;
}
m_type = VT_STRING;
}
bool Value::getBool() const
{
return m_type == VT_BOOL ? m_data.vBool : false;
}
int Value::getInt() const
{
return m_type == VT_INT ? m_data.vInt : 0;
}
real Value::getReal() const
{
return m_type == VT_REAL ? m_data.vReal : 0;
}
const String & Value::getString() const
{
return m_type == VT_STRING ? *m_data.pString : defaultString;
}
const Array & Value::getArray() const
{
return m_type == VT_ARRAY ? *m_data.pArray : defaultArray;
}
const Object & Value::getObject() const
{
return m_type == VT_OBJECT ? *m_data.pObject : defaultObject;
}
const TypedObject & Value::getTypedObject() const
{
return m_type == VT_TYPEDOBJECT ? *m_data.pCustom : defaultTypedObject;
}
Value & Value::operator[](size_t i)
{
if (m_type != VT_ARRAY)
resetArray();
Array & a = *m_data.pArray;
if (i >= a.size())
a.resize(i + 1);
return a[i];
}
Value & Value::operator[](const std::string & key)
{
if (m_type != VT_OBJECT)
resetObject();
Object & a = *m_data.pObject;
return a[key];
}
Value & Value::operator=(const Value & rhs)
{
// TODO Break this into functions so they can be used individually?
switch (m_type)
{
case VT_STRING:
setString(*rhs.m_data.pString);
break;
case VT_ARRAY:
{
resetArray();
Array & src = *rhs.m_data.pArray;
Array & dst = *m_data.pArray;
for (unsigned int i = 0; i < src.size(); ++i)
{
dst[i] = src[i];
}
}
break;
case VT_OBJECT:
{
resetObject();
Object & src = *rhs.m_data.pObject;
Object & dst = *m_data.pObject;
for (auto it = src.begin(); it != src.end(); ++it)
{
dst[it->first] = it->second;
}
}
break;
case VT_TYPEDOBJECT:
resetTypedObject();
m_data.pCustom->typeName = rhs.m_data.pCustom->typeName;
m_data.pCustom->value = rhs.m_data.pCustom->value;
break;
default:
m_type = rhs.m_type;
m_data = rhs.m_data;
break;
}
return *this;
}
std::string toString(Type t)
{
switch (t)
{
case VT_BOOL: return "Bool";
case VT_INT: return "Int";
case VT_REAL: return "Real";
case VT_STRING: return "String";
case VT_ARRAY: return "Array";
case VT_OBJECT: return "Object";
case VT_TYPEDOBJECT: return "Custom";
default: return "Null";
}
}
} // namespace sml
| [
"marc.gilleron@ubisoft.com"
] | marc.gilleron@ubisoft.com |
1d7ff277ea2276019bbb12f91fbefa0107815fab | d26bb3fcd64ff9e9c54089fdf960ced904349113 | /logdevice/common/configuration/ServerConfig.cpp | 57405a45bf38ef253a83f4551bdad098d120dfe9 | [
"BSD-3-Clause"
] | permissive | zhaohaidao/LogDevice | 992056badd72a143f4ad236638382864d718fdbf | 7028e97d305981936056e1651542f54ef5c420f0 | refs/heads/master | 2020-05-19T14:01:19.766972 | 2019-05-05T02:37:40 | 2019-05-05T03:23:59 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 28,259 | cpp | /**
* Copyright (c) 2017-present, Facebook, Inc. and its affiliates.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree.
*/
#define __STDC_FORMAT_MACROS // pull in PRId64 etc
#include "logdevice/common/configuration/ServerConfig.h"
#include <algorithm>
#include <cinttypes>
#include <fcntl.h>
#include <netdb.h>
#include <utility>
#include <folly/Conv.h>
#include <folly/DynamicConverter.h>
#include <folly/FileUtil.h>
#include <folly/compression/Compression.h>
#include <folly/json.h>
#include <folly/synchronization/Baton.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "logdevice/common/FailureDomainNodeSet.h"
#include "logdevice/common/FlowGroupDependencies.h"
#include "logdevice/common/NodeID.h"
#include "logdevice/common/SlidingWindow.h"
#include "logdevice/common/commandline_util_chrono.h"
#include "logdevice/common/configuration/ConfigParser.h"
#include "logdevice/common/configuration/LogsConfigParser.h"
#include "logdevice/common/configuration/NodesConfigParser.h"
#include "logdevice/common/configuration/ParsingHelpers.h"
#include "logdevice/common/debug.h"
#include "logdevice/common/types_internal.h"
#include "logdevice/common/util.h"
#include "logdevice/include/Err.h"
using namespace facebook::logdevice::configuration::parser;
using facebook::logdevice::configuration::NodeRole;
namespace facebook { namespace logdevice {
// set of keys that are used in configuration json format
static const std::set<std::string> config_recognized_keys = {
"client_settings",
"cluster",
"cluster_creation_time",
"defaults",
"include_log_config",
"log_namespace_delimiter",
"logs",
"nodes",
"metadata_logs",
"principals",
"security_information",
"server_settings",
"trace-logger",
"traffic_shaping",
"read_throttling",
"version",
"zookeeper",
};
std::unique_ptr<ServerConfig>
ServerConfig::fromJson(const std::string& jsonPiece) {
auto parsed = parseJson(jsonPiece);
// Make sure the parsed string is actually an object
if (!parsed.isObject()) {
ld_error("configuration must be a map");
err = E::INVALID_CONFIG;
return nullptr;
}
return ServerConfig::fromJson(parsed);
}
std::unique_ptr<ServerConfig>
ServerConfig::fromJson(const folly::dynamic& parsed) {
std::string clusterName;
config_version_t version;
OptionalTimestamp clusterCreationTime;
NodesConfig nodesConfig;
MetaDataLogsConfig metaDataLogsConfig;
PrincipalsConfig principalsConfig;
SecurityConfig securityConfig;
TraceLoggerConfig traceLoggerConfig;
TrafficShapingConfig trafficShapingConfig;
ShapingConfig readIOShapingConfig(
std::set<NodeLocationScope>{NodeLocationScope::NODE},
std::set<NodeLocationScope>{NodeLocationScope::NODE});
SettingsConfig serverSettingsConfig;
SettingsConfig clientSettingsConfig;
// We need the namespace delimiter before loading log configuration, but we
// can only set it in the LogsConfig after we've chosen the final LogsConfig
// instance below.
std::string ns_delimiter = LogsConfig::default_namespace_delimiter_;
// This setting has to be in the main config, because a client that doesn't
// have the logs config should still be able to understand namespaces
// correctly
std::string ns_delim_fbstr;
if (getStringFromMap(parsed, "log_namespace_delimiter", ns_delim_fbstr)) {
// default delimiter
// validate that it's a single character.
if (ns_delim_fbstr.size() > 1) {
// this must be at most 1-character long.
ld_error("Cannot accept the value of \"log_namespace_delimiter\", value "
"is '%s'. This must be at most 1 character, failing!",
ns_delim_fbstr.c_str());
err = E::INVALID_CONFIG;
return nullptr;
}
ns_delimiter = ns_delim_fbstr;
}
InternalLogs internalLogs(ns_delimiter);
// ParseSecurityInfo should be called before ParseLogs and ParseMetaDataLog
// as the securityConfig is used in both.
bool success = parseClusterName(parsed, clusterName) &&
parsePrincipals(parsed, principalsConfig) &&
parseVersion(parsed, version) &&
parseClusterCreationTime(parsed, clusterCreationTime) &&
parseSecurityInfo(parsed, securityConfig) &&
parseTrafficShaping(parsed, trafficShapingConfig) &&
parseReadIOThrottling(parsed, readIOShapingConfig) &&
parseNodes(parsed, nodesConfig) &&
parseMetaDataLog(parsed, securityConfig, metaDataLogsConfig) &&
parseSettings(parsed, "server_settings", serverSettingsConfig) &&
parseSettings(parsed, "client_settings", clientSettingsConfig) &&
parseInternalLogs(parsed, internalLogs) &&
parseTraceLogger(parsed, traceLoggerConfig);
if (!success) {
return nullptr;
}
// TODO(T33035439): generate the new NodesConfiguration format based on
// existing NodesConfig and MetaDataLogsConfig parsed
if (!nodesConfig.generateNodesConfiguration(metaDataLogsConfig, version)) {
// unable to generate the new nodes configuration representation, consider
// the config invalid;
return nullptr;
}
ld_check(nodesConfig.hasNodesConfiguration());
folly::dynamic customFields = folly::dynamic::object;
for (auto& pair : parsed.items()) {
if (config_recognized_keys.find(pair.first.asString()) !=
config_recognized_keys.end()) {
// This key is supposed to be parsed by logdevice
continue;
}
customFields[pair.first] = pair.second;
}
auto config = fromData(std::move(clusterName),
std::move(nodesConfig),
std::move(metaDataLogsConfig),
std::move(principalsConfig),
std::move(securityConfig),
std::move(traceLoggerConfig),
std::move(trafficShapingConfig),
std::move(readIOShapingConfig),
std::move(serverSettingsConfig),
std::move(clientSettingsConfig),
std::move(internalLogs),
std::move(clusterCreationTime),
std::move(customFields),
ns_delimiter);
config->setVersion(version);
ld_check_eq(
membership::MembershipVersion::Type(config->getVersion().val()),
config->getNodesConfigurationFromServerConfigSource()->getVersion());
return config;
}
ServerConfig::ServerConfig(std::string cluster_name,
NodesConfig nodesConfig,
MetaDataLogsConfig metaDataLogsConfig,
PrincipalsConfig principalsConfig,
SecurityConfig securityConfig,
TraceLoggerConfig traceLoggerConfig,
TrafficShapingConfig trafficShapingConfig,
ShapingConfig readIOShapingConfig,
SettingsConfig serverSettingsConfig,
SettingsConfig clientSettingsConfig,
InternalLogs internalLogs,
OptionalTimestamp clusterCreationTime,
folly::dynamic customFields,
const std::string& ns_delimiter)
: clusterName_(std::move(cluster_name)),
clusterCreationTime_(std::move(clusterCreationTime)),
nodesConfig_(std::move(nodesConfig)),
metaDataLogsConfig_(std::move(metaDataLogsConfig)),
principalsConfig_(std::move(principalsConfig)),
securityConfig_(std::move(securityConfig)),
trafficShapingConfig_(std::move(trafficShapingConfig)),
readIOShapingConfig_(std::move(readIOShapingConfig)),
traceLoggerConfig_(std::move(traceLoggerConfig)),
serverSettingsConfig_(std::move(serverSettingsConfig)),
clientSettingsConfig_(std::move(clientSettingsConfig)),
internalLogs_(std::move(internalLogs)),
ns_delimiter_(ns_delimiter),
customFields_(std::move(customFields)) {
ld_check(nodesConfig_.hasNodesConfiguration());
// sequencersConfig_ needs consecutive node indexes, see comment in
// SequencersConfig.h.
// Pad with zero-weight invalid nodes if there are gaps in numbering.
size_t max_node = getMaxNodeIdx();
sequencersConfig_.nodes.resize(max_node + 1);
sequencersConfig_.weights.resize(max_node + 1);
for (const auto& it : nodesConfig_.getNodes()) {
node_index_t i = it.first;
const auto& node = it.second;
auto insert_result = addrToIndex_.insert(std::make_pair(node.address, i));
ld_check(insert_result.second);
if (node.isSequencingEnabled()) {
sequencersConfig_.nodes[i] = NodeID(i, node.generation);
sequencersConfig_.weights[i] = node.getSequencerWeight();
}
}
// Scale all weights to the [0, 1] range. Note that increasing the maximum
// weight will cause all nodes' weights to change, possibly resulting in
// many sequencers being relocated.
auto max_it = std::max_element(
sequencersConfig_.weights.begin(), sequencersConfig_.weights.end());
if (max_it != sequencersConfig_.weights.end() && *max_it > 0) {
double max_weight = *max_it;
for (double& weight : sequencersConfig_.weights) {
weight /= max_weight;
}
}
}
const ServerConfig::Node* ServerConfig::getNode(node_index_t index) const {
auto it = nodesConfig_.getNodes().find(index);
if (it == nodesConfig_.getNodes().end()) {
err = E::NOTFOUND;
return nullptr;
}
return &it->second;
}
const ServerConfig::Node* ServerConfig::getNode(const NodeID& id) const {
if (!id.isNodeID()) { // only possible if there was memory corruption
ld_error("invalid node ID passed: (%d, %d)", id.index(), id.generation());
err = E::INVALID_PARAM;
return nullptr;
}
const Node* node = getNode(id.index());
if (node == nullptr ||
(id.generation() != 0 && node->generation != id.generation())) {
// Generations don't match, it's not the right server
err = E::NOTFOUND;
return nullptr;
}
// Found it!
return node;
}
int ServerConfig::getNodeID(const Sockaddr& address, NodeID* node) const {
auto it = addrToIndex_.find(address);
if (it == addrToIndex_.end()) {
err = E::NOTFOUND;
return -1;
}
node_index_t index = it->second;
ld_check(nodesConfig_.getNodes().at(index).address == address);
ld_check(node != nullptr);
*node = NodeID(index, nodesConfig_.getNodes().at(index).generation);
return 0;
}
std::shared_ptr<const Principal>
ServerConfig::getPrincipalByName(const std::string* name) const {
return principalsConfig_.getPrincipalByName(name);
}
folly::Optional<double>
ServerConfig::getTracerSamplePercentage(const std::string& key) const {
return traceLoggerConfig_.getSamplePercentage(key);
}
double ServerConfig::getDefaultSamplePercentage() const {
return traceLoggerConfig_.getDefaultSamplePercentage();
}
std::unique_ptr<ServerConfig>
ServerConfig::fromData(std::string cluster_name,
NodesConfig nodes,
MetaDataLogsConfig metadata_logs,
PrincipalsConfig principalsConfig,
SecurityConfig securityConfig,
TraceLoggerConfig traceLoggerConfig,
TrafficShapingConfig trafficShapingConfig,
ShapingConfig readIOShapingConfig,
SettingsConfig serverSettingsConfig,
SettingsConfig clientSettingsConfig,
InternalLogs internalLogs,
OptionalTimestamp clusterCreationTime,
folly::dynamic customFields,
const std::string& ns_delimiter) {
ld_check(nodes.hasNodesConfiguration());
return std::unique_ptr<ServerConfig>(
new ServerConfig(std::move(cluster_name),
std::move(nodes),
std::move(metadata_logs),
std::move(principalsConfig),
std::move(securityConfig),
std::move(traceLoggerConfig),
std::move(trafficShapingConfig),
std::move(readIOShapingConfig),
std::move(serverSettingsConfig),
std::move(clientSettingsConfig),
std::move(internalLogs),
std::move(clusterCreationTime),
std::move(customFields),
ns_delimiter));
}
std::unique_ptr<ServerConfig>
ServerConfig::fromDataTest(std::string cluster_name,
NodesConfig nodes,
MetaDataLogsConfig metadata_logs,
PrincipalsConfig principalsConfig,
SecurityConfig securityConfig,
TraceLoggerConfig traceLoggerConfig,
TrafficShapingConfig trafficShapingConfig,
ShapingConfig readIOShapingConfig,
SettingsConfig serverSettingsConfig,
SettingsConfig clientSettingsConfig,
InternalLogs internalLogs,
OptionalTimestamp clusterCreationTime,
folly::dynamic customFields,
const std::string& ns_delimiter) {
// fromData() always generates config with version 1
if (!nodes.generateNodesConfiguration(metadata_logs, config_version_t(1))) {
return nullptr;
}
auto config = std::unique_ptr<ServerConfig>(
new ServerConfig(std::move(cluster_name),
std::move(nodes),
std::move(metadata_logs),
std::move(principalsConfig),
std::move(securityConfig),
std::move(traceLoggerConfig),
std::move(trafficShapingConfig),
std::move(readIOShapingConfig),
std::move(serverSettingsConfig),
std::move(clientSettingsConfig),
std::move(internalLogs),
std::move(clusterCreationTime),
std::move(customFields),
ns_delimiter));
ld_check_eq(
membership::MembershipVersion::Type(config->getVersion().val()),
config->getNodesConfigurationFromServerConfigSource()->getVersion());
return config;
}
std::unique_ptr<ServerConfig> ServerConfig::copy() const {
std::unique_ptr<ServerConfig> config = fromData(clusterName_,
nodesConfig_,
metaDataLogsConfig_,
principalsConfig_,
securityConfig_,
traceLoggerConfig_,
trafficShapingConfig_,
readIOShapingConfig_,
serverSettingsConfig_,
clientSettingsConfig_,
internalLogs_,
getClusterCreationTime(),
getCustomFields(),
ns_delimiter_);
config->setVersion(version_);
if (hasMyNodeID()) {
config->setMyNodeID(my_node_id_);
}
config->setServerOrigin(server_origin_);
config->setMainConfigMetadata(main_config_metadata_);
config->setIncludedConfigMetadata(included_config_metadata_);
return config;
}
std::shared_ptr<ServerConfig> ServerConfig::withNodes(NodesConfig nodes) const {
auto metaDataLogsConfig = getMetaDataLogsConfig();
std::vector<node_index_t> metadata_nodes;
auto& nodes_map = nodes.getNodes();
// make sure the metadata logs nodeset is consistent with the nodes config
for (auto n : metaDataLogsConfig.metadata_nodes) {
if (nodes_map.find(n) != nodes_map.end()) {
metadata_nodes.push_back(n);
}
}
if (metaDataLogsConfig.metadata_nodes != metadata_nodes) {
metaDataLogsConfig.metadata_nodes = metadata_nodes;
}
// generate the new NodesConfig representation
if (!nodes.generateNodesConfiguration(metaDataLogsConfig, version_)) {
return nullptr;
}
std::shared_ptr<ServerConfig> config = fromData(clusterName_,
std::move(nodes),
metaDataLogsConfig,
principalsConfig_,
securityConfig_,
traceLoggerConfig_,
trafficShapingConfig_,
readIOShapingConfig_,
serverSettingsConfig_,
clientSettingsConfig_,
internalLogs_,
getClusterCreationTime(),
getCustomFields(),
ns_delimiter_);
config->setVersion(version_);
if (hasMyNodeID()) {
config->setMyNodeID(my_node_id_);
}
config->setMainConfigMetadata(main_config_metadata_);
config->setIncludedConfigMetadata(included_config_metadata_);
return config;
}
std::shared_ptr<ServerConfig>
ServerConfig::withVersion(config_version_t version) const {
std::shared_ptr<ServerConfig> config = fromData(clusterName_,
nodesConfig_,
metaDataLogsConfig_,
principalsConfig_,
securityConfig_,
traceLoggerConfig_,
trafficShapingConfig_,
readIOShapingConfig_,
serverSettingsConfig_,
clientSettingsConfig_,
internalLogs_,
getClusterCreationTime(),
getCustomFields(),
ns_delimiter_);
config->setVersion(version);
config->setNodesConfigurationVersion(version);
if (hasMyNodeID()) {
config->setMyNodeID(my_node_id_);
}
config->setMainConfigMetadata(main_config_metadata_);
config->setIncludedConfigMetadata(included_config_metadata_);
return config;
}
std::shared_ptr<ServerConfig> ServerConfig::createEmpty() {
return fromData(
std::string(),
NodesConfig(),
MetaDataLogsConfig(),
PrincipalsConfig(),
SecurityConfig(),
TraceLoggerConfig(),
TrafficShapingConfig(),
ShapingConfig(std::set<NodeLocationScope>{NodeLocationScope::NODE},
std::set<NodeLocationScope>{NodeLocationScope::NODE}),
SettingsConfig(),
SettingsConfig(),
InternalLogs(),
OptionalTimestamp(),
folly::dynamic::object());
}
const std::string ServerConfig::toString(const LogsConfig* with_logs,
const ZookeeperConfig* with_zk,
bool compress) const {
// Grab the lock and initialize the cached result if this is the first call
// to toString()
std::lock_guard<std::mutex> guard(to_string_cache_mutex_);
// Normally LogsConfig::getVersion() uniquely defines the contents of the
// logs config, so we can use cached toString() result if version matches.
// However, unit tests may modify LocalLogsConfig in place without changing
// version. In this case we shouldn't use cache.
auto local_logs_config =
dynamic_cast<const configuration::LocalLogsConfig*>(with_logs);
bool no_cache = local_logs_config && local_logs_config->wasModifiedInPlace();
if (with_logs) {
uint64_t logs_config_version = with_logs->getVersion();
if (logs_config_version != last_to_string_logs_config_version_ ||
no_cache) {
// Clear the cache for the full config if the LogsConfig has changed
last_to_string_logs_config_version_ = LSN_INVALID;
all_to_string_cache_.clear();
compressed_all_to_string_cache_.clear();
}
}
std::string uncached_config_str;
std::string& config_str = no_cache
? uncached_config_str
: with_logs ? all_to_string_cache_ : main_to_string_cache_;
if (config_str.empty()) {
config_str = toStringImpl(with_logs, with_zk);
}
ld_check(!config_str.empty());
if (!compress) {
return config_str;
}
std::string uncached_compressed_config_str;
std::string& compressed_config_str = no_cache
? uncached_compressed_config_str
: with_logs ? compressed_all_to_string_cache_
: compressed_main_to_string_cache_;
if (compressed_config_str.empty()) {
using folly::IOBuf;
std::unique_ptr<IOBuf> input =
IOBuf::wrapBuffer(config_str.data(), config_str.size());
auto codec = folly::io::getCodec(folly::io::CodecType::GZIP);
std::unique_ptr<IOBuf> compressed;
try {
compressed = codec->compress(input.get());
} catch (const std::invalid_argument& ex) {
ld_error("gzip compression of config failed");
return compressed_config_str;
}
compressed_config_str = compressed->moveToFbString().toStdString();
}
return compressed_config_str;
}
std::string ServerConfig::toStringImpl(const LogsConfig* with_logs,
const ZookeeperConfig* with_zk) const {
auto json = toJson(with_logs, with_zk);
folly::json::serialization_opts opts;
opts.pretty_formatting = true;
opts.sort_keys = true;
return folly::json::serialize(json, opts);
}
folly::dynamic ServerConfig::toJson(const LogsConfig* with_logs,
const ZookeeperConfig* with_zk) const {
folly::dynamic output_nodes = folly::dynamic::array;
const auto& nodes = nodesConfig_.getNodes();
std::vector<node_index_t> sorted_node_ids(nodes.size());
std::transform(
nodes.begin(), nodes.end(), sorted_node_ids.begin(), [](const auto& src) {
return src.first;
});
std::sort(sorted_node_ids.begin(), sorted_node_ids.end());
for (const auto& nidx : sorted_node_ids) {
const ServerConfig::Node& node = nodes.at(nidx);
folly::dynamic node_dict = folly::dynamic::object("node_id", nidx)(
"host", node.address.toString())("generation", node.generation)(
"gossip_address", node.gossip_address.toString());
if (node.hasRole(NodeRole::STORAGE)) {
// TODO: Remove once all production configs and tooling
// No longer use this field.
node_dict["weight"] = node.getLegacyWeight();
}
// Optional Universal Attributes.
if (node.location.hasValue()) {
node_dict["location"] = node.locationStr();
}
if (node.ssl_address) {
node_dict["ssl_host"] = node.ssl_address->toString();
}
if (!node.settings.empty()) {
node_dict["settings"] = folly::toDynamic(node.settings);
}
// Sequencer Role Attributes.
auto roles = folly::dynamic::array();
if (node.hasRole(configuration::NodeRole::SEQUENCER)) {
roles.push_back("sequencer");
node_dict["sequencer"] = node.sequencer_attributes->enabled();
node_dict["sequencer_weight"] =
node.sequencer_attributes->getConfiguredWeight();
}
// Storage Role Attributes.
if (node.hasRole(configuration::NodeRole::STORAGE)) {
roles.push_back("storage");
auto* storage = node.storage_attributes.get();
node_dict["storage"] =
configuration::storageStateToString(storage->state);
node_dict["storage_capacity"] = storage->capacity;
node_dict["num_shards"] = storage->num_shards;
if (storage->exclude_from_nodesets) {
node_dict["exclude_from_nodesets"] = storage->exclude_from_nodesets;
}
}
node_dict["roles"] = roles;
output_nodes.push_back(node_dict);
}
folly::dynamic meta_nodeset = folly::dynamic::array;
for (auto index : metaDataLogsConfig_.metadata_nodes) {
meta_nodeset.push_back(index);
}
folly::dynamic metadata_logs =
getMetaDataLogGroupInDir().toFollyDynamic(true /*is_metadata*/);
metadata_logs["nodeset"] = meta_nodeset;
metadata_logs["nodeset_selector"] =
NodeSetSelectorTypeToString(metaDataLogsConfig_.nodeset_selector_type);
metadata_logs["sequencers_write_metadata_logs"] =
metaDataLogsConfig_.sequencers_write_metadata_logs;
metadata_logs["sequencers_provision_epoch_store"] =
metaDataLogsConfig_.sequencers_provision_epoch_store;
auto& metadata_version = metaDataLogsConfig_.metadata_version_to_write;
if (metadata_version.hasValue()) {
metadata_logs["metadata_version"] = metadata_version.value();
}
folly::dynamic json_all = folly::dynamic::object("cluster", clusterName_)(
"version", version_.val())("nodes", std::move(output_nodes))(
"metadata_logs", std::move(metadata_logs))(
"internal_logs", internalLogs_.toDynamic())(
"principals", principalsConfig_.toFollyDynamic())(
"read_throttling", readIOShapingConfig_.toFollyDynamic())(
"traffic_shaping", trafficShapingConfig_.toFollyDynamic())(
"server_settings", folly::toDynamic(serverSettingsConfig_))(
"client_settings", folly::toDynamic(clientSettingsConfig_))(
"trace-logger", traceLoggerConfig_.toFollyDynamic());
if (clusterCreationTime_.hasValue()) {
json_all["cluster_creation_time"] = clusterCreationTime_.value().count();
}
if (with_logs != nullptr) {
json_all["logs"] = with_logs->toJson();
}
if (ns_delimiter_ != LogsConfig::default_namespace_delimiter_) {
json_all["log_namespace_delimiter"] = ns_delimiter_;
}
// Authentication Information is optional
if (securityConfig_.securityOptionsEnabled()) {
json_all["security_information"] = securityConfig_.toFollyDynamic();
}
if (with_zk) {
json_all["zookeeper"] = with_zk->toFollyDynamic();
}
// insert custom fields
for (auto& pair : customFields_.items()) {
json_all[pair.first] = pair.second;
}
return json_all;
}
bool ServerConfig::getNodeSSL(folly::Optional<NodeLocation> my_location,
NodeID node,
NodeLocationScope diff_level) const {
if (diff_level == NodeLocationScope::ROOT) {
// Never use SSL
return false;
}
if (diff_level == NodeLocationScope::NODE) {
// Always use SSL
return true;
}
if (!my_location) {
RATELIMIT_ERROR(std::chrono::seconds(1),
10,
"--ssl-boundary specified, but no location available for "
"local machine. Defaulting to SSL.");
return true;
}
auto node_cfg = getNode(node);
ld_check(node_cfg);
if (!node_cfg->location) {
RATELIMIT_ERROR(std::chrono::seconds(1),
10,
"--ssl-boundary specified, but no location available for "
"node %s. Defaulting to SSL.",
node.toString().c_str());
return true;
}
if (!my_location->sharesScopeWith(*node_cfg->location, diff_level)) {
if (!node_cfg->ssl_address) {
RATELIMIT_ERROR(std::chrono::seconds(1),
10,
"--ssl-boundary specified, but no SSL address specified "
"for node %s.",
node.toString().c_str());
}
return true;
}
return false;
}
}} // namespace facebook::logdevice
| [
"facebook-github-bot@users.noreply.github.com"
] | facebook-github-bot@users.noreply.github.com |
c12f0fcdfbab70e68740cb71579fc7f2cb4fd3aa | 6b40e9cba1dd06cd31a289adff90e9ea622387ac | /Develop/Server/GameServer/main/GDBTaskExecCounter.cpp | 015d1ed197beada5939e11da53c0d4f6080c7647 | [] | no_license | AmesianX/SHZPublicDev | c70a84f9170438256bc9b2a4d397d22c9c0e1fb9 | 0f53e3b94a34cef1bc32a06c80730b0d8afaef7d | refs/heads/master | 2022-02-09T07:34:44.339038 | 2014-06-09T09:20:04 | 2014-06-09T09:20:04 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,188 | cpp | #include "stdafx.h"
#include "GDBTaskExecCounter.h"
GDBTaskExecCounter::GDBTaskExecCounter()
{
}
GDBTaskExecCounter::~GDBTaskExecCounter()
{
}
void GDBTaskExecCounter::AddCount( const SDBTASK_ID nID, const int64 nWorkTm )
{
CountMap::iterator it = m_mCounter.find(nID);
if (m_mCounter.end() == it)
{
COUNT c;
c.nCnt = 1;
c.nWorkTm = nWorkTm;
m_mCounter.insert(CountMap::value_type(nID, c));
return;
}
it->second.nCnt++;
it->second.nWorkTm += nWorkTm;
}
GDBTaskExecCounter::COUNT GDBTaskExecCounter::GetCount( const SDBTASK_ID nID )
{
CountMap::iterator it = m_mCounter.find(nID);
if (m_mCounter.end() == it)
return COUNT();
return it->second;
}
GDBTaskExecCounter::SortedList GDBTaskExecCounter::GetDecrSortedList()
{
SortedList sl;
if (m_mCounter.empty())
return sl;
for (CountMap::iterator it = m_mCounter.begin(); it != m_mCounter.end(); ++it)
{
SortedList::iterator iit = sl.begin();
for (; iit != sl.end(); ++iit)
{
if (iit->second.nCnt < it->second.nCnt)
{
sl.insert(iit, *it);
break;
}
}
if (sl.end() == iit)
sl.push_back(*it);
}
return sl;
} | [
"shzdev@8fd9ef21-cdc5-48af-8625-ea2f38c673c4"
] | shzdev@8fd9ef21-cdc5-48af-8625-ea2f38c673c4 |
cf3a5aa1b123939a58d7d0682e08b1cb2a004e76 | 8f463a8083a464ecccfb3e3c9febea95f3838959 | /deps/fbjni/cxx/fbjni/detail/Meta-inl.h | 6c51935199ba24cd8c7127fe733e5b708539e1ce | [
"Apache-2.0"
] | permissive | amanjeetsingh150/profilo | 6e9c4e43bc5d8bc4d0ad825fab238a991a822407 | a0d626d1c3889bdbaaa5c12ca2d2606f0fee45da | refs/heads/master | 2020-08-24T19:30:19.627944 | 2019-10-22T14:38:07 | 2019-10-22T14:39:38 | 216,891,585 | 0 | 0 | Apache-2.0 | 2019-10-22T19:16:53 | 2019-10-22T19:16:53 | null | UTF-8 | C++ | false | false | 17,232 | h | /**
* Copyright 2018-present, Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <jni.h>
#include "Common.h"
#include "Exceptions.h"
#include "MetaConvert.h"
#include "References.h"
#include "Boxed.h"
namespace facebook {
namespace jni {
// JMethod /////////////////////////////////////////////////////////////////////////////////////////
inline JMethodBase::JMethodBase(jmethodID method_id) noexcept
: method_id_{method_id}
{}
inline JMethodBase::operator bool() const noexcept {
return method_id_ != nullptr;
}
inline jmethodID JMethodBase::getId() const noexcept {
return method_id_;
}
namespace {
template <int idx, typename... Args>
struct ArgsArraySetter;
template <int idx, typename Arg, typename... Args>
struct ArgsArraySetter<idx, Arg, Args...> {
static void set(alias_ref<JArrayClass<jobject>> array, Arg arg0, Args... args) {
// TODO(xxxxxxxx): Use Convert<Args>... to do conversions like the fast path.
(*array)[idx] = autobox(arg0);
ArgsArraySetter<idx + 1, Args...>::set(array, args...);
}
};
template <int idx>
struct ArgsArraySetter<idx> {
static void set(alias_ref<JArrayClass<jobject>> array) {
(void)array;
}
};
template <typename... Args>
local_ref<JArrayClass<jobject>> makeArgsArray(Args... args) {
auto arr = JArrayClass<jobject>::newArray(sizeof...(args));
ArgsArraySetter<0, Args...>::set(arr, args...);
return arr;
}
}
template<typename... Args>
inline void JMethod<void(Args...)>::operator()(alias_ref<jobject> self, Args... args) const {
const auto env = Environment::current();
env->CallVoidMethod(
self.get(),
getId(),
detail::callToJni(detail::Convert<typename std::decay<Args>::type>::toCall(args))...);
FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
}
#pragma push_macro("DEFINE_PRIMITIVE_CALL")
#undef DEFINE_PRIMITIVE_CALL
#define DEFINE_PRIMITIVE_CALL(TYPE, METHOD) \
template<typename... Args> \
inline TYPE JMethod<TYPE(Args...)>::operator()(alias_ref<jobject> self, Args... args) const { \
const auto env = Environment::current(); \
auto result = env->Call ## METHOD ## Method( \
self.get(), \
getId(), \
detail::callToJni(detail::Convert<typename std::decay<Args>::type>::toCall(args))...); \
FACEBOOK_JNI_THROW_PENDING_EXCEPTION(); \
return result; \
}
DEFINE_PRIMITIVE_CALL(jboolean, Boolean)
DEFINE_PRIMITIVE_CALL(jbyte, Byte)
DEFINE_PRIMITIVE_CALL(jchar, Char)
DEFINE_PRIMITIVE_CALL(jshort, Short)
DEFINE_PRIMITIVE_CALL(jint, Int)
DEFINE_PRIMITIVE_CALL(jlong, Long)
DEFINE_PRIMITIVE_CALL(jfloat, Float)
DEFINE_PRIMITIVE_CALL(jdouble, Double)
#pragma pop_macro("DEFINE_PRIMITIVE_CALL")
/// JMethod specialization for references that wraps the return value in a @ref local_ref
template<typename R, typename... Args>
class JMethod<R(Args...)> : public JMethodBase {
public:
// TODO: static_assert is jobject-derived or local_ref jobject
using JniRet = typename detail::Convert<typename std::decay<R>::type>::jniType;
static_assert(IsPlainJniReference<JniRet>(), "JniRet must be a JNI reference");
using JMethodBase::JMethodBase;
JMethod() noexcept {};
JMethod(const JMethod& other) noexcept = default;
/// Invoke a method and return a local reference wrapping the result
local_ref<JniRet> operator()(alias_ref<jobject> self, Args... args) const;
friend class JClass;
};
template<typename R, typename... Args>
inline auto JMethod<R(Args...)>::operator()(alias_ref<jobject> self, Args... args) const -> local_ref<JniRet> {
const auto env = Environment::current();
auto result = env->CallObjectMethod(
self.get(),
getId(),
detail::callToJni(detail::Convert<typename std::decay<Args>::type>::toCall(args))...);
FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
return adopt_local(static_cast<JniRet>(result));
}
template<typename... Args>
inline void JStaticMethod<void(Args...)>::operator()(alias_ref<jclass> cls, Args... args) const {
const auto env = Environment::current();
env->CallStaticVoidMethod(
cls.get(),
getId(),
detail::callToJni(detail::Convert<typename std::decay<Args>::type>::toCall(args))...);
FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
}
#pragma push_macro("DEFINE_PRIMITIVE_STATIC_CALL")
#undef DEFINE_PRIMITIVE_STATIC_CALL
#define DEFINE_PRIMITIVE_STATIC_CALL(TYPE, METHOD) \
template<typename... Args> \
inline TYPE JStaticMethod<TYPE(Args...)>::operator()(alias_ref<jclass> cls, Args... args) const { \
const auto env = Environment::current(); \
auto result = env->CallStatic ## METHOD ## Method( \
cls.get(), \
getId(), \
detail::callToJni(detail::Convert<typename std::decay<Args>::type>::toCall(args))...); \
FACEBOOK_JNI_THROW_PENDING_EXCEPTION(); \
return result; \
}
DEFINE_PRIMITIVE_STATIC_CALL(jboolean, Boolean)
DEFINE_PRIMITIVE_STATIC_CALL(jbyte, Byte)
DEFINE_PRIMITIVE_STATIC_CALL(jchar, Char)
DEFINE_PRIMITIVE_STATIC_CALL(jshort, Short)
DEFINE_PRIMITIVE_STATIC_CALL(jint, Int)
DEFINE_PRIMITIVE_STATIC_CALL(jlong, Long)
DEFINE_PRIMITIVE_STATIC_CALL(jfloat, Float)
DEFINE_PRIMITIVE_STATIC_CALL(jdouble, Double)
#pragma pop_macro("DEFINE_PRIMITIVE_STATIC_CALL")
/// JStaticMethod specialization for references that wraps the return value in a @ref local_ref
template<typename R, typename... Args>
class JStaticMethod<R(Args...)> : public JMethodBase {
public:
using JniRet = typename detail::Convert<typename std::decay<R>::type>::jniType;
static_assert(IsPlainJniReference<JniRet>(), "T* must be a JNI reference");
using JMethodBase::JMethodBase;
JStaticMethod() noexcept {};
JStaticMethod(const JStaticMethod& other) noexcept = default;
/// Invoke a method and return a local reference wrapping the result
local_ref<JniRet> operator()(alias_ref<jclass> cls, Args... args) const {
const auto env = Environment::current();
auto result = env->CallStaticObjectMethod(
cls.get(),
getId(),
detail::callToJni(detail::Convert<typename std::decay<Args>::type>::toCall(args))...);
FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
return adopt_local(static_cast<JniRet>(result));
}
friend class JClass;
};
template<typename... Args>
inline void
JNonvirtualMethod<void(Args...)>::operator()(alias_ref<jobject> self, alias_ref<jclass> cls, Args... args) const {
const auto env = Environment::current();
env->CallNonvirtualVoidMethod(
self.get(),
cls.get(),
getId(),
detail::callToJni(detail::Convert<typename std::decay<Args>::type>::toCall(args))...);
FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
}
#pragma push_macro("DEFINE_PRIMITIVE_NON_VIRTUAL_CALL")
#undef DEFINE_PRIMITIVE_NON_VIRTUAL_CALL
#define DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(TYPE, METHOD) \
template<typename... Args> \
inline TYPE \
JNonvirtualMethod<TYPE(Args...)>::operator()(alias_ref<jobject> self, alias_ref<jclass> cls, Args... args) const { \
const auto env = Environment::current(); \
auto result = env->CallNonvirtual ## METHOD ## Method( \
self.get(), \
cls.get(), \
getId(), \
detail::callToJni(detail::Convert<typename std::decay<Args>::type>::toCall(args))...); \
FACEBOOK_JNI_THROW_PENDING_EXCEPTION(); \
return result; \
}
DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(jboolean, Boolean)
DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(jbyte, Byte)
DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(jchar, Char)
DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(jshort, Short)
DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(jint, Int)
DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(jlong, Long)
DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(jfloat, Float)
DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(jdouble, Double)
#pragma pop_macro("DEFINE_PRIMITIVE_NON_VIRTUAL_CALL")
/// JNonvirtualMethod specialization for references that wraps the return value in a @ref local_ref
template<typename R, typename... Args>
class JNonvirtualMethod<R(Args...)> : public JMethodBase {
public:
using JniRet = typename detail::Convert<typename std::decay<R>::type>::jniType;
static_assert(IsPlainJniReference<JniRet>(), "T* must be a JNI reference");
using JMethodBase::JMethodBase;
JNonvirtualMethod() noexcept {};
JNonvirtualMethod(const JNonvirtualMethod& other) noexcept = default;
/// Invoke a method and return a local reference wrapping the result
local_ref<JniRet> operator()(alias_ref<jobject> self, alias_ref<jclass> cls, Args... args) const {
const auto env = Environment::current();
auto result = env->CallNonvirtualObjectMethod(
self.get(),
cls.get(),
getId(),
detail::callToJni(detail::Convert<typename std::decay<Args>::type>::toCall(args))...);
FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
return adopt_local(static_cast<JniRet>(result));
}
friend class JClass;
};
template <typename... Args>
local_ref<jobject> slowCall(jmethodID method_id, alias_ref<jobject> self, Args... args) {
static auto invoke = findClassStatic("java/lang/reflect/Method")
->getMethod<jobject(jobject, JArrayClass<jobject>::javaobject)>("invoke");
// TODO(xxxxxxx): Provide fbjni interface to ToReflectedMethod.
auto reflected = adopt_local(Environment::current()->ToReflectedMethod(self->getClass().get(), method_id, JNI_FALSE));
FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
if (!reflected) throw std::runtime_error("Unable to get reflected java.lang.reflect.Method");
auto argsArray = makeArgsArray(args...);
// No need to check for exceptions since invoke is itself a JMethod that will do that for us.
return invoke(reflected, self.get(), argsArray.get());
}
// JField<T> ///////////////////////////////////////////////////////////////////////////////////////
template<typename T>
inline JField<T>::JField(jfieldID field) noexcept
: field_id_{field}
{}
template<typename T>
inline JField<T>::operator bool() const noexcept {
return field_id_ != nullptr;
}
template<typename T>
inline jfieldID JField<T>::getId() const noexcept {
return field_id_;
}
#pragma push_macro("DEFINE_FIELD_PRIMITIVE_GET_SET")
#undef DEFINE_FIELD_PRIMITIVE_GET_SET
#define DEFINE_FIELD_PRIMITIVE_GET_SET(TYPE, METHOD) \
template<> \
inline TYPE JField<TYPE>::get(jobject object) const noexcept { \
const auto env = Environment::current(); \
return env->Get ## METHOD ## Field(object, field_id_); \
} \
\
template<> \
inline void JField<TYPE>::set(jobject object, TYPE value) noexcept { \
const auto env = Environment::current(); \
env->Set ## METHOD ## Field(object, field_id_, value); \
}
DEFINE_FIELD_PRIMITIVE_GET_SET(jboolean, Boolean)
DEFINE_FIELD_PRIMITIVE_GET_SET(jbyte, Byte)
DEFINE_FIELD_PRIMITIVE_GET_SET(jchar, Char)
DEFINE_FIELD_PRIMITIVE_GET_SET(jshort, Short)
DEFINE_FIELD_PRIMITIVE_GET_SET(jint, Int)
DEFINE_FIELD_PRIMITIVE_GET_SET(jlong, Long)
DEFINE_FIELD_PRIMITIVE_GET_SET(jfloat, Float)
DEFINE_FIELD_PRIMITIVE_GET_SET(jdouble, Double)
#pragma pop_macro("DEFINE_FIELD_PRIMITIVE_GET_SET")
template<typename T>
inline T JField<T>::get(jobject object) const noexcept {
return static_cast<T>(Environment::current()->GetObjectField(object, field_id_));
}
template<typename T>
inline void JField<T>::set(jobject object, T value) noexcept {
Environment::current()->SetObjectField(object, field_id_, static_cast<jobject>(value));
}
// JStaticField<T> /////////////////////////////////////////////////////////////////////////////////
template<typename T>
inline JStaticField<T>::JStaticField(jfieldID field) noexcept
: field_id_{field}
{}
template<typename T>
inline JStaticField<T>::operator bool() const noexcept {
return field_id_ != nullptr;
}
template<typename T>
inline jfieldID JStaticField<T>::getId() const noexcept {
return field_id_;
}
#pragma push_macro("DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET")
#undef DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET
#define DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(TYPE, METHOD) \
template<> \
inline TYPE JStaticField<TYPE>::get(jclass jcls) const noexcept { \
const auto env = Environment::current(); \
return env->GetStatic ## METHOD ## Field(jcls, field_id_); \
} \
\
template<> \
inline void JStaticField<TYPE>::set(jclass jcls, TYPE value) noexcept { \
const auto env = Environment::current(); \
env->SetStatic ## METHOD ## Field(jcls, field_id_, value); \
}
DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(jboolean, Boolean)
DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(jbyte, Byte)
DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(jchar, Char)
DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(jshort, Short)
DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(jint, Int)
DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(jlong, Long)
DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(jfloat, Float)
DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(jdouble, Double)
#pragma pop_macro("DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET")
template<typename T>
inline T JStaticField<T>::get(jclass jcls) const noexcept {
const auto env = Environment::current();
return static_cast<T>(env->GetStaticObjectField(jcls, field_id_));
}
template<typename T>
inline void JStaticField<T>::set(jclass jcls, T value) noexcept {
Environment::current()->SetStaticObjectField(jcls, field_id_, value);
}
// jmethod_traits //////////////////////////////////////////////////////////////////////////////////
// TODO(T6608405) Adapt this to implement a register natives method that requires no descriptor
namespace internal {
template<typename Head>
inline std::string JavaDescriptor() {
return jtype_traits<Head>::descriptor();
}
template<typename Head, typename Elem, typename... Tail>
inline std::string JavaDescriptor() {
return JavaDescriptor<Head>() + JavaDescriptor<Elem, Tail...>();
}
template<typename R, typename Arg1, typename... Args>
inline std::string JMethodDescriptor() {
return "(" + JavaDescriptor<Arg1, Args...>() + ")" + JavaDescriptor<R>();
}
template<typename R>
inline std::string JMethodDescriptor() {
return "()" + JavaDescriptor<R>();
}
} // internal
template<typename R, typename... Args>
inline std::string jmethod_traits<R(Args...)>::descriptor() {
return internal::JMethodDescriptor<R, Args...>();
}
template<typename R, typename... Args>
inline std::string jmethod_traits<R(Args...)>::constructor_descriptor() {
return internal::JMethodDescriptor<void, Args...>();
}
}}
| [
"facebook-github-bot@users.noreply.github.com"
] | facebook-github-bot@users.noreply.github.com |
382bfa67bfae0853bd468bdec90b7536f854c1c3 | e326f6f04544dffbd5d6697c6ba95b22a0bfa227 | /FileServer/FileServer/FileServer.cpp | 541e6bbe67d58cc5cb496212d1d24d7ef3f85e57 | [] | no_license | FC-09/learn_test | dba6f77fb07c271983994aa4a2d88345c7565004 | 3bbcd31c8547fe96627692fe6a66f9427256fcc8 | refs/heads/master | 2020-12-30T12:22:44.741680 | 2017-06-08T12:12:25 | 2017-06-08T12:12:25 | 91,424,622 | 0 | 0 | null | 2017-05-16T06:42:31 | 2017-05-16T06:42:31 | null | GB18030 | C++ | false | false | 1,604 | cpp | #include "FileServer.h"
FileServer::FileServer()
{
sListen = 0;
sClient = INADDR_ANY;
sin = { 0 };
remoteAddr = { 0 };
sockVersion = MAKEWORD(2, 2);
nAddrLen = sizeof(sockaddr_in);
sin.sin_port = htons(1234);
sin.sin_family = AF_INET;
sin.sin_addr.S_un.S_addr = INADDR_ANY;
if (WSAStartup(sockVersion, &wsaData) != 0)
{
std::cout << "initlization failed !" << std::endl;
exit(0);
}
}
FileServer::~FileServer()
{
closesocket(sClient);
closesocket(sListen);
WSACleanup();
for (auto it = client_mgr_.begin(); it != client_mgr_.end(); ++it)
delete *it;
client_mgr_.clear(); //删除所有客户端
}
int FileServer::Run()
{
sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (bind(sListen, (LPSOCKADDR)&sin, sizeof(sin)) == SOCKET_ERROR)
{
std::cout << "bind failed !" << std::endl;
return 0;
}
if (listen(sListen, 2) == SOCKET_ERROR)
{
std::cout << "listen failed!" << std::endl;
return 0;
}
while (1)
{
sClient = accept(sListen, (SOCKADDR*)&remoteAddr, &nAddrLen);
if (sClient == INVALID_SOCKET)
{
std::cout << "accept failed !" << std::endl;
continue;
}
FileClient *client = new FileClient(this, sClient);
client_mgr_.push_front(client);
}
return 0;
}
void FileServer::RemoveClient(FileClient* client)
{
client_mgr_.remove(client); //删除指定客户端
delete client; //delete
} | [
"543268543@qq.com"
] | 543268543@qq.com |
680b9135891fe6d782a864188c71a0489afd21aa | 060a177359e580e461a5f9239972a53d23a474a9 | /sgpa.cpp | 10ec5d52e1f2d88a278bf1ab2ab68de57dfefd96 | [] | no_license | SayeedSA/Learn_Challenge | a1109a6f837389d6d8fa641b3261b85a2cfb254b | a2110b2f957cec13c6fd6456df5ee5d38fac55db | refs/heads/main | 2023-08-17T08:03:02.034351 | 2021-09-25T09:44:35 | 2021-09-25T09:44:35 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 827 | cpp | #include<iostream>
using namespace std;
class Result
{
public:
float c1,c2,c3,c4,c5,avg;
float sgpa(float x,float y,float z)
{
c1=x;
c2=y;
c3=z;
avg=(c1+c2+c3)/3;
return avg;
}
float sgpa(float x,float y,float z,float a)
{
c1=x;
c2=y;
c3=z;
c4=a;
avg=(c1+c2+c3+c4)/4;
return avg;
}
float sgpa(float x,float y,float z,float a,float b)
{
c1=x;
c2=y;
c3=z;
c4=a;
c5=b;
avg=(c1+c2+c3+c4+c5)/5;
return avg;
}
void show()
{
cout<<"SGPA:"<<avg;
}
};
int main()
{
Result ob;
float p=ob.sgpa(3.56,3.00,2.98);
float q=ob.sgpa(3.56,3.55,3.90,3.55);
float r=ob.sgpa(4,3.00,3.98,3.00,3.54);
ob.show();
}
| [
"39121672+sayeedahmedsabbir@users.noreply.github.com"
] | 39121672+sayeedahmedsabbir@users.noreply.github.com |
e8026af9245c5c5f2e6c587aed08b4cdc25e212d | 8ae14c7a045ae5382883ea44d58805e4b2ed0045 | /Arduino/AutoPilot_v4.9/xplane.h | 5a3a1b6749068163b312dfd03356425734bd8ed8 | [] | no_license | UAVWorks/Autopilot-for-XPlane-with-ESP8266 | a26e5e1c227005afcd922cfc6843403fa523845b | cad8c3f1668eecbcb1adc69d048b62e2f3b543ce | refs/heads/master | 2020-03-30T05:09:53.148790 | 2017-07-03T07:08:03 | 2017-07-03T07:08:03 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,411 | h | #ifndef XPLANE_H
#define XPLANE_H
#include <WiFiUDP.h>
#define UDPRATE 12.0F
#define UDPSPORT 49000
#define UDPRPORT 49003
#define MAXPAGES 30
#define MAXRREFS 20
#define DATASIZE 5 + MAXPAGES * 36
typedef void (*cbXplane0)(bool status);
typedef bool (*cbXplane2)(long a, float b);
class XPLANE {
private:
uint8_t pages[MAXPAGES];
uint8_t pageCount = 0;
String * rrefs[MAXRREFS];
uint8_t rrefCount = 0;
char data[DATASIZE];
int datalen = 0;
unsigned long toTimer; // time-out timer
bool oldStatus;
IPAddress ipMC = IPAddress(239, 255, 1, 1);
long portMC = 49707;
WiFiUDP udp;
int len;
cbXplane0 cb0;
cbXplane2 cb2;
String ip2str(IPAddress ip) {
char buf[20];
return (String(ip[0]) + "." + String(ip[1]) + "." + String(ip[2]) + "." + String(ip[3]));
}
void printbuf(char * buf, int len) {
for (int i = 0; i < len; i++) Serial.printf("%02x ", buf[i]);
Serial.print(" ");
for (int i = 0; i < len; i++) Serial.print(((buf[i] > 0x20) && (buf[i] < 0x80)) ? (char)buf[i] : '.');
Serial.println();
}
public:
bool online = true;
IPAddress ip;
bool onhold = false;
void hold() {
onhold = true;
}
void begin() {
online = true;
oldStatus = true;
}
void onStatusChanged(cbXplane0 _cb) {
cb0 = _cb;
}
void onRREF(cbXplane2 _cb) {
cb2 = _cb;
}
void addPage(uint8_t _page) {
for (int i = 0; i < pageCount; i++) if (pages[i] == _page) return;
pages[pageCount++] = _page;
}
void addRREF(char * rref) {
rrefs[rrefCount++] = (String*)rref;
}
void sendUDP(char * buf, int len) {
udp.beginPacket(ip, UDPSPORT);
udp.write(buf, len);
udp.endPacket();
}
void DSEL(char page) {
char buf[] = {"DSEL0\0\0\0\0"};
buf[5] = page;
sendUDP(buf, sizeof(buf));
delay(100);
}
void USEL(char page) {
char buf[] = {"USEL0\0\0\0\0"};
buf[5] = page;
sendUDP(buf, sizeof(buf));
}
void DSELall(uint8_t * list, int count) {
union {
char bytes[4];
long val;
} ui;
udp.beginPacket(ip, UDPSPORT);
udp.write("DSEL0");
for (int i = 0; i < count; i++) {
ui.val = (long)list[i];
udp.write(ui.bytes, 4);
}
udp.endPacket();
delay(5);
}
void USELall() {
union {
char bytes[4];
long val;
} ui;
udp.beginPacket(ip, UDPSPORT);
udp.write("USEL0");
for (int i = 0; i < 133; i++) {
ui.val = (long)i;
udp.write(ui.bytes, 4);
}
udp.endPacket();
delay(5);
}
void DREF(char * dref, byte bv[4]) {
int msglen = 500;
udp.beginPacket(ip, UDPSPORT);
udp.write("DREF0", 5);
udp.write(bv, 4);
uint i = 0;
while (dref[i]) {
udp.write(dref[i]);
i++;
}
while (i < msglen) {
udp.write((byte)0x00);
i++;
}
udp.endPacket();
}
void DREF(char * dref, float Data) {
union {
byte bv[4];
float fv;
} bf;
bf.fv = Data;
DREF(dref, bf.bv);
}
void RREF(char * dref, uint8_t idx) {
union {
char b[4];
float f;
} u_val;
u_val.f = UDPRATE;
int buflen = 413;
char buf[buflen];
memset(buf, 0x00, buflen);
memcpy(&buf[0], "RREF", 4);
memcpy(&buf[5], &u_val.b[0], 4);
buf[9] = (int8_t)idx;
int i = 0;
while (dref[i]) {
buf[i + 13] = dref[i];
i++;
}
while (i < buflen) {
buf[i + 13] = (byte)0x00;
i++;
}
sendUDP((char*)buf, buflen);
}
void CMND(char cmnd[]) {
udp.beginPacket(ip, UDPSPORT);
if (cmnd[1] == 0) udp.write("CHAR0");
else udp.write("CMND0");
//udp.write("sim/");
udp.write(cmnd) ;
udp.endPacket();
}
uint16_t getIndexOf(uint16_t page) {
uint16_t i = 5;
while (i < datalen) {
if (data[i] == page) return i;
i += 36;
}
return -1;
}
uint16_t getIndexOf(uint8_t page, uint8_t idx) {
uint16_t i = getIndexOf(page);
if (i == -1) return -1;
return i + 4 + idx * 4;
}
float value(uint8_t page, uint8_t idx) {
union {
uint8_t val[4];
float fval;
} fconv;
uint16_t pix = getIndexOf(page, idx);
if (pix < 0) return 0;
memcpy(&fconv.val, &data[pix], 4);
return fconv.fval;
}
void value(uint8_t page, uint8_t idx, float val) {
union {
uint8_t val[4];
float fval;
} fconv;
uint16_t pix = getIndexOf(page, idx);
if (pix < 0) return;
fconv.fval = val;
memcpy(&data[getIndexOf(page, idx)], &fconv.val, 4);
}
void updateIdx(uint8_t page, uint8_t idx) {
union {
uint8_t val[4];
float fval;
} fconv;
uint16_t pix = getIndexOf(page);
if (pix < 0) return;
uint8_t fix = 9 + (idx * 4);
uint8_t pbuf[50] = "DATA0";
pbuf[5] = page;
for (int i = 6; i < 9; i++) pbuf[i] = 0;
for (uint8_t i = 0; i < 8; i++) {
if (i == idx) fconv.fval = value(page, idx);
else fconv.fval = -999;
memcpy(&pbuf[9 + 4 * i], &fconv.val, 4);
}
sendUDP((char*)pbuf, sizeof(pbuf));
}
void setOnline() {
struct {
char hdr[5];
uint8_t code[4];
char ip[16];
char port[8];
uint8_t set[4];
} s_buf;
udp.stopAll();
udp.begin(UDPRPORT);
USELall();
DREF("sim/network/dataout/network_data_rate[0]", UDPRATE);
DSELall(pages, pageCount);
for (int i = 0; i < rrefCount; i++) RREF((char*)rrefs[i], i);
memset(&s_buf, 0x00, sizeof(s_buf));
strcpy(s_buf.hdr, "ISET");
s_buf.code[0] = 64;
strcpy(s_buf.ip, ip2str(WiFi.localIP()).c_str());
strcpy(s_buf.port, String(UDPRPORT).c_str());
s_buf.set[0] = 1;
sendUDP(&s_buf.hdr[0], sizeof(s_buf));
if (cb0 && !online) cb0(true);
online = true;
}
void setOffline() {
if (udp) udp.stopAll();
#if XPIP
ip = xp_ip;
udp.begin(UDPRPORT);
#else
udp.beginMulticast(WiFi.localIP(), ipMC, portMC);
#endif
udp.beginPacket(ip, UDPSPORT);
udp.write("DATA*");
udp.endPacket();
toTimer = millis() + 8000;
if (cb0 && online) cb0(false);
online = false;
}
bool scan() {
if (millis() > toTimer) setOffline();
len = udp.parsePacket();
if (!len) return false;
char buf[len];
udp.read(buf, len);
ip = udp.remoteIP();
if (!online) setOnline();
if (!memcmp(buf, "BECN", 4)) { }
else if (!memcmp(buf, "DATA", 4)) {
datalen = len;
memcpy(&data, &buf, datalen);
}
else if (!memcmp(buf, "RREF", 4)) {
int j = 5;
while (j < len) {
long a;
float b;
memcpy(&a, &buf[j], 4);
memcpy(&b, &buf[j + 4], 4);
if (cb2) cb2(a, b);
j += 8;
}
} else if (!memcmp(buf, "DREF", 4)) {
char cc[10];
union {
char b[4];
float f;
} u_f;
memcpy(u_f.b, &buf[5], 4);
printbuf(buf, 50);
}
toTimer = millis() + 2000;
return true;
}
} xplane;
#endif;
| [
"erik@palsbo.com"
] | erik@palsbo.com |
445897cc5d15217eb9efe4681826c60bb2fc9b40 | 1dbed0f84a670c787d2217d97ae3984401c7edb3 | /gj/h116.cpp | 9966b4eaac56825368c1019dc3f5f25b9aac635c | [] | no_license | prprprpony/oj | 311d12a25f06e6c54b88bc2bcd38003f7b6696a9 | 84988be500c06cb62130585333fddd1a278f0aaa | refs/heads/master | 2021-07-13T16:03:54.398841 | 2021-03-27T14:19:52 | 2021-03-27T14:19:52 | 46,796,050 | 9 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 529 | cpp | #include <iostream>
using namespace std;
int main()
{
int t, ans;
long long a[6];
long long m;
cin >> t;
while (t--) {
m = 1;
ans = 0;
for (int i = 0; i < 6; i++) {
cin >> a[i];
m *= a[i];
}
for (int i = 1; i <= 4; i++)
for (int j = i + 1; j <= 5; j++) {
int n = a[0] * a[i] * a[j];
if (m / n == n)
ans++;
}
cout << ans << endl;
}
return 0;
}
| [
"3254tg89@gmail.com"
] | 3254tg89@gmail.com |
3d8dd229c4c36643b002c8a4895448364ca0b40d | c8f29fbdbbfc42902427a60a69f500e360c39abc | /TestProject/src/TestProject.cpp | 50479adca0ff0455c8edd153e9bcd6eb25208d1e | [] | no_license | WirelessCaveman/AlgorithmsTest | 523ef14aa1f9ab8f23ca00abb4fe78fe34fc08e8 | 668f421d667a81859ae934dfb6b40a33923f0947 | refs/heads/master | 2021-01-19T02:17:46.955676 | 2016-06-20T07:10:06 | 2016-06-20T07:10:06 | 26,628,356 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 820 | cpp | //============================================================================
// Name : TestProject.cpp
// Author : Shailesh Kadamaje
// Version :
// Copyright : Your copyright notice
// Description : Small Test programs
// 1. int WithoutConditions(int a, int b, int c): without using conditional statements, if a != 0, return b, else return c
//============================================================================
#include <stdio.h>
#include <stdlib.h>
int WithoutConditions(int a, int b, int c)
{
// result = a ? b : c;
// return ((a/a) * b) + ((1 - (a/a))*c);
int result;
(a && (result = b, 1)) || (result = c, 0);
return result;
}
int main()
{
printf("WithoutConditions %d\n", WithoutConditions(5, 3,7));
printf("WithoutConditions %d\n", WithoutConditions(0, 3,7));
return 0;
}
| [
"wireless.caveman@gmail.com"
] | wireless.caveman@gmail.com |
a7b2c0b45ec31b676c46e0b1bb24629ebcc29ce7 | c02b8bbe6ddd03e3a6a4d0544f28c8848537d848 | /server/ManagerLogic.cpp | d1a8e4853e88df91e5ee586509423d6d9c7942bc | [
"MIT"
] | permissive | github188/net | 72a3c706974453dfbb9da73d45f0e35ed31e8b50 | add2c8ee93bee9c0a47e200e2c79297ab7a0c158 | refs/heads/master | 2021-01-15T13:50:23.955433 | 2014-04-14T06:03:51 | 2014-04-14T06:03:51 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,060 | cpp | #include "ManagerLogic.h"
#include "db.h"
#include "Info.h"
#include "start.h"
class PhysicNodeInfo_Table:public db::DBTable{
public:
LogicNodeInfo info;
std::string ip;
DEC_TABLE
};
TABLE_BEGIN(PhysicNodeInfo_Table)
FIELD(info.nodeType);
FIELD(info.port);
FIELD(ip);
TABLE_END
CLASS_MAP(ManagerLogic)
{
BIND_NET_FUNCTION(ManagerLogic,reqLogin);
}
void ManagerLogic::reqLogin(const PhysicNodeInfo &info)
{
db::DB db;
db.init("manager.info");
PhysicNodeInfo_Table *nodeInfo = NULL;
if (db.create(nodeInfo))
{
if (!nodeInfo->load(db,"where `ip`='127.0.0.1' and `info.port`='50'"))
{
nodeInfo->ip = "127.0.0.1";
nodeInfo->info.port = 50;
nodeInfo->save(db);
}
delete nodeInfo;
}
db.destroy();
LogicNodeInfo arg1;
strncpy(arg1.ip,"127.0.0.1",32);
arg1.port = 2353;
ManagerClient::R_retStart(this->getConnection(),arg1);
printf("ManagerLogic::reqLogin\n");
}
CLASS_MAP(ManagerClient)
{
BIND_NET_FUNCTION(ManagerClient,retStart);
}
void ManagerClient::retStart(const LogicNodeInfo &info)
{
server.init(info.ip,info.port);
} | [
"jjl_2009_hi@163.com"
] | jjl_2009_hi@163.com |
c8eaeaf303770fee3b26a83f0db9f7443e3efdaa | d53b5582454b38260b248e3a2900f14e5c060284 | /include/binder/MemoryHeapBase.h | 470a3403fb84f388083764ad5b06b31e8821be7d | [
"LicenseRef-scancode-unicode",
"Apache-2.0"
] | permissive | leoisright/android_frameworks_base | 3bb158f5515191b25b3d9245df7188268cc435f5 | 5bd346e46691ebbf16ad43e6b506ee1e4885e3c6 | refs/heads/master | 2021-01-19T04:50:55.175534 | 2012-03-01T02:19:35 | 2012-03-01T02:19:35 | 3,382,201 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,824 | h | /*
* Copyright (C) 2008 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.
*/
#ifndef ANDROID_MEMORY_HEAP_BASE_H
#define ANDROID_MEMORY_HEAP_BASE_H
#include <stdlib.h>
#include <stdint.h>
#include <binder/IMemory.h>
namespace android {
// ---------------------------------------------------------------------------
class MemoryHeapBase : public virtual BnMemoryHeap
{
public:
enum {
READ_ONLY = IMemoryHeap::READ_ONLY,
// memory won't be mapped locally, but will be mapped in the remote
// process.
DONT_MAP_LOCALLY = 0x00000100,
NO_CACHING = 0x00000200
};
/*
* maps the memory referenced by fd. but DOESN'T take ownership
* of the filedescriptor (it makes a copy with dup()
*/
MemoryHeapBase(int fd, size_t size, uint32_t flags = 0, uint32_t offset = 0);
/*
* maps memory from the given device
*/
MemoryHeapBase(const char* device, size_t size = 0, uint32_t flags = 0);
/*
* maps memory from ashmem, with the given name for debugging
*/
MemoryHeapBase(size_t size, uint32_t flags = 0, char const* name = NULL);
virtual ~MemoryHeapBase();
/* implement IMemoryHeap interface */
virtual int getHeapID() const;
virtual void* getBase() const;
virtual size_t getSize() const;
virtual uint32_t getFlags() const;
const char* getDevice() const;
/* this closes this heap -- use carefully */
void dispose();
/* this is only needed as a workaround, use only if you know
* what you are doing */
status_t setDevice(const char* device) {
if (mDevice == 0)
mDevice = device;
return mDevice ? NO_ERROR : ALREADY_EXISTS;
}
protected:
MemoryHeapBase();
// init() takes ownership of fd
status_t init(int fd, void *base, int size,
int flags = 0, const char* device = NULL);
private:
status_t mapfd(int fd, size_t size, uint32_t offset = 0);
int mFD;
size_t mSize;
void* mBase;
uint32_t mFlags;
const char* mDevice;
bool mNeedUnmap;
};
// ---------------------------------------------------------------------------
}; // namespace android
#endif // ANDROID_MEMORY_HEAP_BASE_H
| [
"leoisright@gmail.com"
] | leoisright@gmail.com |
fb2b90663c863d320db5a473c33720cf62f7a7d6 | cc7661edca4d5fb2fc226bd6605a533f50a2fb63 | /System.Xml/XmlSchemaAppInfo.h | 7ef2f41d54047dc319db7daf60a8ab42d271814e | [
"MIT"
] | permissive | g91/Rust-C-SDK | 698e5b573285d5793250099b59f5453c3c4599eb | d1cce1133191263cba5583c43a8d42d8d65c21b0 | refs/heads/master | 2020-03-27T05:49:01.747456 | 2017-08-23T09:07:35 | 2017-08-23T09:07:35 | 146,053,940 | 1 | 0 | null | 2018-08-25T01:13:44 | 2018-08-25T01:13:44 | null | UTF-8 | C++ | false | false | 399 | h | #pragma once
#include "..\System\Xml\XmlNode.h"
#include "..\UnityEngine\UnicodeString*.h"
namespace System
{
namespace Xml
{
{
namespace Schema
{
class XmlSchemaAppInfo : public XmlSchemaObject // 0x70
{
public:
System::Xml::XmlNode* markup; // 0x70 (size: 0x8, flags: 0x1, type: 0x1d)
UnityEngine::UnicodeString* source; // 0x78 (size: 0x8, flags: 0x1, type: 0xe)
}; // size = 0x80
}
| [
"info@cvm-solutions.co.uk"
] | info@cvm-solutions.co.uk |
c8227325474fc24ae10529b5e3b4b49f262af5d0 | 0841c948188711d194835bb19cf0b4dae04a5695 | /p2pserver_v2/ifox_track/sources/thelib/src/track/trackprocess.cpp | 2d559dc3ae563f932cc9c062497d4570d75a2da8 | [] | no_license | gjhbus/sh_project | 0cfd311b7c0e167e098bc4ec010822f1af2d0289 | 1d4d7df4e92cff93aba9d28226d3dbce71639ed6 | refs/heads/master | 2020-06-15T16:11:33.335499 | 2016-06-15T03:41:22 | 2016-06-15T03:41:22 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,413 | cpp | #include "netio/netio.h"
#include "p2p/p2p.h"
#include "track/trackprocess.h"
#include "track/trackworker.h"
#include "track/user.h"
#include "track/cmd.h"
TrackProcess::TrackProcess(TrackWorker *worker)
: BaseProcess(1024*1024)
{
worker_ = worker;
timer_ = NULL;
memset(&head_, 0, sizeof(head_));
memset(&sendHead_, 0, sizeof(sendHead_));
sendHead_.mark = P2P_MARK;
sendHead_.reserved = P2P_RESERVED;
writeState_ = false;
proxyIP_ = "";
}
TrackProcess::~TrackProcess()
{
if (timer_)
{
worker_->RemoveTimer(timer_);
delete timer_;
timer_ = NULL;
}
for (TrackUserMap::iterator i = users_.begin(); i != users_.end(); ++i)
{
MAP_VAL(i)->Close(MAP_VAL(i), worker_);
}
users_.clear();
INFO("[%s] Proxy %s close", STR(getLocalTimeString("%Y-%m-%d %H:%M:%S", time(0))), STR(proxyIP_));
}
bool TrackProcess::SignalInputData(int32_t recvAmount)
{
uint8_t *buffer = GETIBPOINTER(_inPutBuffer);
int32_t size = GETAVAILABLEBYTESCOUNT(_inPutBuffer);
uint32_t p2p_id;
TrackUserMap::iterator iter;
BinaryParser::AVal bv, ex, *pbv;
Cmd *cmd;
uint32_t op;
while(2 <= size)
{
if (!head_.length)
{
head_.length = BinaryParser::DecodeInt16(buffer);
}
if (head_.length > size)
break;
parser_.SetDecode(buffer);
parser_.DecodeHead(&head_);
if (P2P_MARK != head_.mark)
{
FATAL("Check mark 0x%X failed, size:%u, length:%u in TrackProcess::SignalInputData",
head_.mark, size, head_.length);
return false;
}
op = P2P_PROC_SERIAL(head_.opType);
if ( P2P_PROXY_AND_TRACK_PEERS == op )
{
p2p_id = parser_.DecodeInt32();
iter = users_.find(p2p_id);
if ( users_.end() == iter )
{
goto TRACK_PROCESS_END;
}
parser_.DecodeBuffer(&bv);
if ( parser_.DecodeInt8() )
{
parser_.DecodeBuffer(&ex);
}
else
{
ex.val = NULL;
}
MAP_VAL(iter)->CreateCmdGetPeers((const char*)bv.val, bv.len, MAP_VAL(iter), worker_, &ex);
}
else if ( P2P_PROXY_AND_TRACK_TEST_PEERS == op )
{
p2p_id = parser_.DecodeInt32();
iter = users_.find(p2p_id);
if ( users_.end() == iter )
{
goto TRACK_PROCESS_END;
}
parser_.DecodeBuffer(&bv);
if ( parser_.DecodeInt8() )
{
parser_.DecodeBuffer(&ex);
}
else
{
ex.val = NULL;
}
MAP_VAL(iter)->CreateCmdGetTestPeers((const char*)bv.val, bv.len, MAP_VAL(iter), worker_, &ex);
}
else if ( P2P_PROXY_AND_TRACK_ADDFILE == op )
{
p2p_id = parser_.DecodeInt32();
iter = users_.find(p2p_id);
if ( users_.end() == iter )
{
goto TRACK_PROCESS_END;
}
parser_.DecodeBuffer(&bv);
if ( parser_.DecodeInt8() )
{
parser_.DecodeBuffer(&ex);
}
else
{
ex.val = NULL;
}
MAP_VAL(iter)->CreateCmdAddFile((const char *)bv.val, bv.len, MAP_VAL(iter), worker_, &ex);
}
else if ( P2P_PROXY_AND_TRACK_REMOVEFILE == op )
{
p2p_id = parser_.DecodeInt32();
iter = users_.find(p2p_id);
if ( users_.end() == iter )
{
goto TRACK_PROCESS_END;
}
parser_.DecodeBuffer(&bv);
if ( parser_.DecodeInt8() )
{
parser_.DecodeBuffer(&ex);
}
else
{
ex.val = NULL;
}
MAP_VAL(iter)->CreateCmdRmFile((const char *)bv.val, bv.len, MAP_VAL(iter), worker_, &ex);
}
else if ( P2P_PROXY_AND_TRACK_ADDUSER == op )
{
p2p_id = parser_.DecodeInt32();
iter = users_.find(p2p_id);
if ( users_.end() != iter )
{
goto TRACK_PROCESS_END;
}
P2PEndType end_type = (P2PEndType)parser_.DecodeInt32();
TrackUser *user = worker_->CreateUser(this, end_type);
if ( !user )
{
FATAL("0x%X is unkown type of end", end_type);
return false;
}
// peerID
user->p2pID_ = p2p_id;
// endType
user->endType_ = end_type;
// proxyip
user->proxyIP_ = parser_.DecodeInt32();
// inip
user->inIP_ = parser_.DecodeInt32();
// outip
user->outIP_ = parser_.DecodeInt32();
// sp
user->sp_ = parser_.DecodeInt16();
// province
user->province_ = parser_.DecodeInt16();
// city
user->city_ = parser_.DecodeInt16();
// isextend
uint8_t is_extend = parser_.DecodeInt8();
if (is_extend)
{
parser_.DecodeBuffer(&bv);
user->UserExtendInfo(&bv);
}
if ( !user->Initialize() )
{
delete user;
goto TRACK_PROCESS_END;
}
users_[p2p_id] = User(user);
}
else if ( P2P_PROXY_AND_TRACK_REMOVEUSER == op )
{
p2p_id = parser_.DecodeInt32();
iter = users_.find(p2p_id);
if ( users_.end() == iter )
{
goto TRACK_PROCESS_END;
}
MAP_VAL(iter)->Close(MAP_VAL(iter), worker_);
users_.erase(iter);
}
else if ( P2P_HEART == op )
{
INFO("Recv heart from %s", STR(proxyIP_));
if ( parser_.DecodeInt8() )
{
}
}
else
{
p2p_id = parser_.DecodeInt32();
iter = users_.find(p2p_id);
if ( users_.end() == iter )
{
goto TRACK_PROCESS_END;
}
parser_.DecodeBuffer(&bv);
MAP_VAL(iter)->GetDataFromProxy(op, &bv, MAP_VAL(iter), worker_);
}
TRACK_PROCESS_END:
_inPutBuffer.Ignore(head_.length);
buffer += head_.length;
size -= head_.length;
head_.length = 0;
}
time_t now = time(0);
if (now > timer_->heart)
{
timer_->heart = now;
worker_->UpdateHeart(timer_);
}
return true;
}
bool TrackProcess::IsClose()
{
if (0 == GETAVAILABLEBYTESCOUNT(_outPutBuffer))
writeState_ = false;
return _isClose;
}
void TrackProcess::SetIOHandler(IOHandler *io)
{
BaseProcess::SetIOHandler(io);
if ( _ioHandler )
{
proxyIP_ = ((TCPCarrier*)_ioHandler)->GetIP();
}
INFO("A proxy %s connected", STR(proxyIP_));
}
bool TrackProcess::Initialize()
{
if (timer_)
return false;
timer_ = new P2PTimerEvent(this, SERVER_TIMEOUT*3);
return worker_->AddTimer(timer_);
}
void TrackProcess::SendMsg(Cmd *cmd, IOHandlerManager *manager)
{
BinaryParser::AVal bv, *pbv;
parser_.SetEncode();
sendHead_.opType = P2P_PROC_PACKAGE(P2P_RESPONSE, P2P_END_TRACK, P2P_END_PROXY, cmd->protocol_);
parser_.EncodeHead(&sendHead_);
// peerID
parser_.EncodeInt32(cmd->user_->p2pID_);
bv.val = GETIBPOINTER(cmd->buffer_);
bv.len = GETAVAILABLEBYTESCOUNT(cmd->buffer_);
parser_.EncodeBuffer(&bv);
pbv = parser_.SetLength();
_outPutBuffer.ReadFromBuffer(pbv->val, pbv->len);
if (!writeState_)
{
writeState_ = true;
manager->EnableWriteData(_ioHandler);
}
}
uint32_t TrackProcess::GetOutPutBufferSize()
{
return _outPutBuffer._size;
}
uint32_t TrackProcess::GetInPutBufferSize()
{
return _inPutBuffer._size;
}
| [
"greatmiffa@gmail.com"
] | greatmiffa@gmail.com |
5afb43ab2126a251636d072221dbe3ca810d862d | 1bfbeb5bddf83d05f8d8bc1be0b191346ba38f88 | /settings.cpp | 0bb768101603992ed83f7b92b59184db156895bf | [] | no_license | emmios/synth-greeter | 00c41fff561de69e5b78e8b24f0bfe750aaf172d | 85c7688d1ec34f1b2fb80612eb871119e3954555 | refs/heads/master | 2020-03-31T01:26:53.200976 | 2018-10-05T21:53:53 | 2018-10-05T21:53:53 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 683 | cpp | #include "settings.h"
Settings::Settings() : QSettings("/etc/lightdm/emmi-greeter.conf", QSettings::NativeFormat)
{
beginGroup("Config");
this->backgroundImage = value("greeter-background-image").toString();
this->userImage = value("greeter-user-image").toString();
this->lastSession = value("last-session").toString();
this->lastUser = value("last-user").toString();
endGroup();
}
QString Settings::setLastSession(QString lastSession)
{
beginGroup("Config");
setValue("last-session", lastSession);
endGroup();
}
QString Settings::setLastUser(QString lastUser)
{
beginGroup("Config");
setValue("last-user", lastUser);
endGroup();
}
| [
"kamikazi3200"
] | kamikazi3200 |
2d1e208a5f456183a07856aa3a51be535f6ddd08 | 9c54d9d6e081bc38f5ba60fa8f50d93460d02b66 | /177.cpp | f768d12e2a24aa61e0d4a0b93bae1804f98bb94d | [] | no_license | HaiZeizhouyuan/HZOJ | 8444281e7ac8a30a507db810edc0ac1144044434 | 9b5adb02da476e19578327d3a90bf41d9e0e68ef | refs/heads/master | 2023-03-24T08:00:57.835764 | 2021-03-23T05:42:44 | 2021-03-23T05:42:44 | 274,556,449 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 615 | cpp | /*************************************************************************
> File Name: 177.cpp
> Author:
> Mail:
> Created Time: Fri May 29 01:49:09 2020
************************************************************************/
#include<iostream>
#include<cstring>
using namespace std;
int main() {
char str[30];
cin >> str;
int a = 0, len = strlen(str);
for (int i = 0; i < len; i++ ) {
for (int j = 0; j < len; j++) {
cout << str[a];
a++;
a %= len;
}
cout << endl;
a += len - 2;
a %= len;
}
return 0;
}
| [
"3623936813@qq.com"
] | 3623936813@qq.com |
b48b9bea0e87af0430d7f8a0685203da1f3ffba0 | 4febf57a9c1d0f72efb24c774feb9023eb5119e5 | /lib/Maxbotix/Maxbotix.cpp | 3a65061767b69954288ae2bf07d4446123890bae | [] | no_license | smaug-g/floodfellas-sonar | 1c856b1bb973255089260ee1ab43be96227e1d50 | 0b5df69a58ec97a90edda78c9fa01f8d1a4b7bfe | refs/heads/master | 2022-04-18T15:56:31.162659 | 2020-04-13T16:32:24 | 2020-04-13T16:32:24 | 255,382,212 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,006 | cpp | #include <Maxbotix.h>
SoftwareSerial *mySerial;
int EN_pin;
void begin_maxbotix(SoftwareSerial* port, int _EN_pin)
{
mySerial = port;
EN_pin = _EN_pin;
pinMode(EN_pin, OUTPUT);
digitalWrite(EN_pin, LOW);
}
void read_maxbotix(char *buffer, int len_buffer)
{
mySerial->listen();
int i = 0;
char incoming_char;
while(mySerial->available() != 0)
incoming_char = mySerial->read();
digitalWrite(EN_pin, HIGH);
delay(200);
int chars_available = mySerial->available();
while(chars_available) {
if((incoming_char = mySerial->read()) != 13) {
buffer[i] = incoming_char;
} else {
buffer[i] = '\0';
digitalWrite(EN_pin, LOW);
break;
}
chars_available--;
i++;
}
while(mySerial->available() != 0)
incoming_char = mySerial->read();
}
int read_maxbotix_int()
{
char data_buffer[10];
read_maxbotix(data_buffer, 10);
int i;
for (i = 1; i < 10; ++i)
data_buffer[i-1] = data_buffer[i];
return atoi(data_buffer);
}
| [
"smg10@rice.edu"
] | smg10@rice.edu |
36d8f9310405f97cdbe4e9fd087b3d93e10b7da0 | 38a6e516e34082b24c443b07234fa3cc2b31df43 | /tools/test/windows/tw.cc | ca57d369392b7cad4f5cc97e1d6312e3d4ce59ac | [
"Apache-2.0"
] | permissive | rachcatch/bazel | 4d6c641342621fba95f530f34c018e6cd2dd3710 | 1b4aa06432ac98505ddcdb5c72b8a8b9105d73fa | refs/heads/master | 2020-04-03T14:34:09.372844 | 2018-10-30T00:00:51 | 2018-10-30T00:02:30 | 155,326,573 | 0 | 0 | Apache-2.0 | 2018-10-30T04:55:50 | 2018-10-30T04:55:49 | null | UTF-8 | C++ | false | false | 35,726 | cc | // Copyright 2018 The Bazel 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.
// Test wrapper implementation for Windows.
// Design:
// https://github.com/laszlocsomor/proposals/blob/win-test-runner/designs/2018-07-18-windows-native-test-runner.md
#define WIN32_LEAN_AND_MEAN
#include <lmcons.h> // UNLEN
#include <windows.h>
#include <stdio.h>
#include <string.h>
#include <wchar.h>
#include <algorithm>
#include <functional>
#include <memory>
#include <string>
#include <vector>
#include "src/main/cpp/util/file_platform.h"
#include "src/main/cpp/util/path_platform.h"
#include "src/main/cpp/util/strings.h"
#include "src/main/native/windows/file.h"
#include "third_party/ijar/common.h"
#include "third_party/ijar/platform_utils.h"
#include "third_party/ijar/zip.h"
#include "tools/cpp/runfiles/runfiles.h"
#include "tools/test/windows/tw.h"
namespace bazel {
namespace tools {
namespace test_wrapper {
namespace {
class Defer {
public:
explicit Defer(std::function<void()> f) : f_(f) {}
~Defer() { f_(); }
void DoNow() {
f_();
f_ = kEmpty;
}
private:
std::function<void()> f_;
static const std::function<void()> kEmpty;
};
const std::function<void()> Defer::kEmpty = []() {};
// A lightweight path abstraction that stores a Unicode Windows path.
//
// The class allows extracting the underlying path as a (immutable) string so
// it's easy to pass the path to WinAPI functions, but the class does not allow
// mutating the unterlying path so it's safe to pass around Path objects.
class Path {
public:
Path() {}
Path(const Path& other) : path_(other.path_) {}
Path(Path&& other) : path_(std::move(other.path_)) {}
Path& operator=(const Path& other) = delete;
const std::wstring& Get() const { return path_; }
bool Set(const std::wstring& path);
// Makes this path absolute.
// Returns true if the path was changed (i.e. was not absolute before).
// Returns false and has no effect if this path was empty or already absolute.
bool Absolutize(const Path& cwd);
Path Dirname() const;
private:
std::wstring path_;
};
struct UndeclaredOutputs {
Path root;
Path zip;
Path manifest;
Path annotations;
Path annotations_dir;
};
void LogError(const int line, const char* msg) {
printf("ERROR(" __FILE__ ":%d) %s\n", line, msg);
}
void LogError(const int line, const wchar_t* msg) {
#define _WSTR_HELPER_1(x) L##x
#define _WSTR_HELPER_2(x) _WSTR_HELPER_1(x)
wprintf(L"ERROR(" _WSTR_HELPER_2(__FILE__) L":%d) %s\n", line, msg);
#undef _WSTR_HELPER_2
#undef _WSTR_HELPER_1
}
void LogErrorWithValue(const int line, const char* msg, DWORD error_code) {
printf("ERROR(" __FILE__ ":%d) error code: %d (0x%08x): %s\n", line,
error_code, error_code, msg);
}
void LogErrorWithArgAndValue(const int line, const char* msg, const char* arg,
DWORD error_code) {
printf("ERROR(" __FILE__ ":%d) error code: %d (0x%08x), argument: %s: %s\n",
line, error_code, error_code, arg, msg);
}
void LogErrorWithArgAndValue(const int line, const char* msg,
const wchar_t* arg, DWORD error_code) {
printf("ERROR(" __FILE__ ":%d) error code: %d (0x%08x), argument: %ls: %s\n",
line, error_code, error_code, arg, msg);
}
inline bool CreateDirectories(const Path& path) {
blaze_util::MakeDirectoriesW(bazel::windows::HasUncPrefix(path.Get().c_str())
? path.Get()
: L"\\\\?\\" + path.Get(),
0777);
return true;
}
inline bool ToInt(const wchar_t* s, int* result) {
return swscanf_s(s, L"%d", result) == 1;
}
bool WcsToAcp(const std::wstring& wcs, std::string* acp) {
uint32_t err;
if (!blaze_util::WcsToAcp(wcs, acp, &err)) {
LogErrorWithArgAndValue(__LINE__, "Failed to convert string", wcs.c_str(),
err);
return false;
}
return true;
}
// Converts a Windows-style path to a mixed (Unix-Windows) style.
// The path is mixed-style because it is a Windows path (begins with a drive
// letter) but uses forward slashes as directory separators.
// We must export envvars as mixed style path because some tools confuse the
// backslashes in Windows paths for Unix-style escape characters.
std::wstring AsMixedPath(const std::wstring& path) {
std::wstring value = path;
std::replace(value.begin(), value.end(), L'\\', L'/');
return value;
}
bool GetEnv(const wchar_t* name, std::wstring* result) {
static constexpr size_t kSmallBuf = MAX_PATH;
WCHAR value[kSmallBuf];
DWORD size = GetEnvironmentVariableW(name, value, kSmallBuf);
DWORD err = GetLastError();
if (size == 0 && err == ERROR_ENVVAR_NOT_FOUND) {
result->clear();
return true;
} else if (0 < size && size < kSmallBuf) {
*result = value;
return true;
} else if (size >= kSmallBuf) {
std::unique_ptr<WCHAR[]> value_big(new WCHAR[size]);
GetEnvironmentVariableW(name, value_big.get(), size);
*result = value_big.get();
return true;
} else {
LogErrorWithArgAndValue(__LINE__, "Failed to read envvar", name, err);
return false;
}
}
bool GetPathEnv(const wchar_t* name, Path* result) {
std::wstring value;
if (!GetEnv(name, &value)) {
return false;
}
return result->Set(value);
}
bool SetEnv(const wchar_t* name, const std::wstring& value) {
if (SetEnvironmentVariableW(name, value.c_str()) != 0) {
return true;
} else {
DWORD err = GetLastError();
LogErrorWithArgAndValue(__LINE__, "Failed to set envvar", name, err);
return false;
}
}
bool SetPathEnv(const wchar_t* name, const Path& path) {
return SetEnv(name, AsMixedPath(path.Get()));
}
bool UnsetEnv(const wchar_t* name) {
if (SetEnvironmentVariableW(name, NULL) != 0) {
return true;
} else {
DWORD err = GetLastError();
LogErrorWithArgAndValue(__LINE__, "Failed to unset envvar", name, err);
return false;
}
}
bool GetCwd(Path* result) {
static constexpr size_t kSmallBuf = MAX_PATH;
WCHAR value[kSmallBuf];
DWORD size = GetCurrentDirectoryW(kSmallBuf, value);
DWORD err = GetLastError();
if (size > 0 && size < kSmallBuf) {
return result->Set(value);
} else if (size >= kSmallBuf) {
std::unique_ptr<WCHAR[]> value_big(new WCHAR[size]);
GetCurrentDirectoryW(size, value_big.get());
return result->Set(value_big.get());
} else {
LogErrorWithValue(__LINE__, "Failed to get current directory", err);
return false;
}
}
// Set USER as required by the Bazel Test Encyclopedia.
bool ExportUserName() {
std::wstring value;
if (!GetEnv(L"USER", &value)) {
return false;
}
if (!value.empty()) {
// Respect the value passed by Bazel via --test_env.
return true;
}
WCHAR buffer[UNLEN + 1];
DWORD len = UNLEN + 1;
if (GetUserNameW(buffer, &len) == 0) {
DWORD err = GetLastError();
LogErrorWithValue(__LINE__, "Failed to query user name", err);
return false;
}
return SetEnv(L"USER", buffer);
}
// Set TEST_SRCDIR as required by the Bazel Test Encyclopedia.
bool ExportSrcPath(const Path& cwd, Path* result) {
if (!GetPathEnv(L"TEST_SRCDIR", result)) {
return false;
}
return !result->Absolutize(cwd) || SetPathEnv(L"TEST_SRCDIR", *result);
}
// Set TEST_TMPDIR as required by the Bazel Test Encyclopedia.
bool ExportTmpPath(const Path& cwd, Path* result) {
if (!GetPathEnv(L"TEST_TMPDIR", result) ||
(result->Absolutize(cwd) && !SetPathEnv(L"TEST_TMPDIR", *result))) {
return false;
}
// Create the test temp directory, which may not exist on the remote host when
// doing a remote build.
return CreateDirectories(*result);
}
// Set HOME as required by the Bazel Test Encyclopedia.
bool ExportHome(const Path& test_tmpdir) {
Path home;
if (!GetPathEnv(L"HOME", &home)) {
return false;
}
if (blaze_util::IsAbsolute(home.Get())) {
// Respect the user-defined HOME in case they set passed it with
// --test_env=HOME or --test_env=HOME=C:\\foo
return true;
} else {
// Set TEST_TMPDIR as required by the Bazel Test Encyclopedia.
return SetPathEnv(L"HOME", test_tmpdir);
}
}
bool ExportRunfiles(const Path& cwd, const Path& test_srcdir) {
Path runfiles_dir;
if (!GetPathEnv(L"RUNFILES_DIR", &runfiles_dir) ||
(runfiles_dir.Absolutize(cwd) &&
!SetPathEnv(L"RUNFILES_DIR", runfiles_dir))) {
return false;
}
// TODO(ulfjack): Standardize on RUNFILES_DIR and remove the
// {JAVA,PYTHON}_RUNFILES vars.
Path java_rf, py_rf;
if (!GetPathEnv(L"JAVA_RUNFILES", &java_rf) ||
(java_rf.Absolutize(cwd) && !SetPathEnv(L"JAVA_RUNFILES", java_rf)) ||
!GetPathEnv(L"PYTHON_RUNFILES", &py_rf) ||
(py_rf.Absolutize(cwd) && !SetPathEnv(L"PYTHON_RUNFILES", py_rf))) {
return false;
}
std::wstring mf_only_str;
int mf_only_value = 0;
if (!GetEnv(L"RUNFILES_MANIFEST_ONLY", &mf_only_str) ||
(!mf_only_str.empty() && !ToInt(mf_only_str.c_str(), &mf_only_value))) {
return false;
}
if (mf_only_value == 1) {
// If RUNFILES_MANIFEST_ONLY is set to 1 then test programs should use the
// manifest file to find their runfiles.
Path runfiles_mf;
if (!runfiles_mf.Set(test_srcdir.Get() + L"\\MANIFEST") ||
!SetPathEnv(L"RUNFILES_MANIFEST_FILE", runfiles_mf)) {
return false;
}
}
return true;
}
bool ExportShardStatusFile(const Path& cwd) {
Path status_file;
if (!GetPathEnv(L"TEST_SHARD_STATUS_FILE", &status_file) ||
(!status_file.Get().empty() && status_file.Absolutize(cwd) &&
!SetPathEnv(L"TEST_SHARD_STATUS_FILE", status_file))) {
return false;
}
return status_file.Get().empty() ||
// The test shard status file is only set for sharded tests.
CreateDirectories(status_file.Dirname());
}
bool ExportGtestVariables(const Path& test_tmpdir) {
// # Tell googletest about Bazel sharding.
std::wstring total_shards_str;
int total_shards_value = 0;
if (!GetEnv(L"TEST_TOTAL_SHARDS", &total_shards_str) ||
(!total_shards_str.empty() &&
!ToInt(total_shards_str.c_str(), &total_shards_value))) {
return false;
}
if (total_shards_value > 0) {
std::wstring shard_index;
if (!GetEnv(L"TEST_SHARD_INDEX", &shard_index) ||
!SetEnv(L"GTEST_SHARD_INDEX", shard_index) ||
!SetEnv(L"GTEST_TOTAL_SHARDS", total_shards_str)) {
return false;
}
}
return SetPathEnv(L"GTEST_TMP_DIR", test_tmpdir);
}
bool ExportMiscEnvvars(const Path& cwd) {
for (const wchar_t* name :
{L"TEST_INFRASTRUCTURE_FAILURE_FILE", L"TEST_LOGSPLITTER_OUTPUT_FILE",
L"TEST_PREMATURE_EXIT_FILE", L"TEST_UNUSED_RUNFILES_LOG_FILE",
L"TEST_WARNINGS_OUTPUT_FILE"}) {
Path value;
if (!GetPathEnv(name, &value) ||
(value.Absolutize(cwd) && !SetPathEnv(name, value))) {
return false;
}
}
return true;
}
bool _GetFileListRelativeTo(
const std::wstring& unc_root, const std::wstring& subdir,
std::vector<bazel::tools::test_wrapper::FileInfo>* result) {
const std::wstring full_subdir =
unc_root + (subdir.empty() ? L"" : (L"\\" + subdir)) + L"\\*";
WIN32_FIND_DATAW info;
HANDLE handle = FindFirstFileW(full_subdir.c_str(), &info);
if (handle == INVALID_HANDLE_VALUE) {
DWORD err = GetLastError();
if (err == ERROR_FILE_NOT_FOUND) {
// No files found, nothing to do.
return true;
}
LogErrorWithArgAndValue(__LINE__, "Failed to list directory contents",
full_subdir.c_str(), err);
return false;
}
Defer close_handle([handle]() { FindClose(handle); });
static const std::wstring kDot(1, L'.');
static const std::wstring kDotDot(2, L'.');
std::vector<std::wstring> subdirectories;
while (true) {
if (kDot != info.cFileName && kDotDot != info.cFileName) {
std::wstring rel_path =
subdir.empty() ? info.cFileName : (subdir + L"\\" + info.cFileName);
if (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
subdirectories.push_back(rel_path);
} else {
if (info.nFileSizeHigh > 0 || info.nFileSizeLow > INT_MAX) {
// devtools_ijar::Stat::total_size is declared as `int`, so the file
// size limit is INT_MAX. Additionally we limit the files to be below
// 4 GiB, not only because int is typically 4 bytes long, but also
// because such huge files are unreasonably large as an undeclared
// output.
LogErrorWithArgAndValue(__LINE__, "File is too large to archive",
rel_path.c_str(), 0);
return false;
}
result->push_back({rel_path,
// File size is already validated to be smaller than
// min(INT_MAX, 4 GiB)
static_cast<int>(info.nFileSizeLow)});
}
}
if (FindNextFileW(handle, &info) == 0) {
DWORD err = GetLastError();
if (err == ERROR_NO_MORE_FILES) {
break;
}
LogErrorWithArgAndValue(__LINE__,
"Failed to get next element in directory",
(unc_root + L"\\" + subdir).c_str(), err);
return false;
}
}
close_handle.DoNow();
for (const auto& s : subdirectories) {
if (!_GetFileListRelativeTo(unc_root, s, result)) {
return false;
}
}
return true;
}
bool GetFileListRelativeTo(
const Path& root,
std::vector<bazel::tools::test_wrapper::FileInfo>* result) {
if (!blaze_util::IsAbsolute(root.Get())) {
LogError(__LINE__, "Root should be absolute");
return false;
}
return _GetFileListRelativeTo(bazel::windows::HasUncPrefix(root.Get().c_str())
? root.Get()
: L"\\\\?\\" + root.Get(),
std::wstring(), result);
}
bool ToZipEntryPaths(
const Path& root,
const std::vector<bazel::tools::test_wrapper::FileInfo>& files,
ZipEntryPaths* result) {
std::string acp_root;
if (!WcsToAcp(AsMixedPath(bazel::windows::HasUncPrefix(root.Get().c_str())
? root.Get().substr(4)
: root.Get()),
&acp_root)) {
LogError(__LINE__,
(std::wstring(L"Failed to convert path \"") + root.Get() + L"\"")
.c_str());
return false;
}
// Convert all UTF-16 paths to ANSI paths.
std::vector<std::string> acp_file_list;
acp_file_list.reserve(files.size());
for (const auto& e : files) {
std::string acp_path;
if (!WcsToAcp(AsMixedPath(e.rel_path), &acp_path)) {
LogError(__LINE__,
(std::wstring(L"Failed to convert path ") + e.rel_path + L"\"")
.c_str());
return false;
}
acp_file_list.push_back(acp_path);
}
result->Create(acp_root, acp_file_list);
return true;
}
bool CreateZipBuilder(const Path& zip, const ZipEntryPaths& entry_paths,
std::unique_ptr<devtools_ijar::ZipBuilder>* result) {
const devtools_ijar::u8 estimated_size =
devtools_ijar::ZipBuilder::EstimateSize(entry_paths.AbsPathPtrs(),
entry_paths.EntryPathPtrs(),
entry_paths.Size());
if (estimated_size == 0) {
LogError(__LINE__, "Failed to estimate zip size");
return false;
}
std::string acp_zip;
if (!WcsToAcp(zip.Get(), &acp_zip)) {
LogError(
__LINE__,
(std::wstring(L"Failed to convert path ") + zip.Get() + L"\"").c_str());
return false;
}
result->reset(
devtools_ijar::ZipBuilder::Create(acp_zip.c_str(), estimated_size));
if (result->get() == nullptr) {
LogErrorWithValue(__LINE__, "Failed to create zip builder", errno);
return false;
}
return true;
}
bool OpenFileForWriting(const std::wstring& path, HANDLE* result) {
*result = CreateFileW(bazel::windows::HasUncPrefix(path.c_str())
? path.c_str()
: (L"\\\\?\\" + path).c_str(),
GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_DELETE,
NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (*result == INVALID_HANDLE_VALUE) {
DWORD err = GetLastError();
LogErrorWithArgAndValue(__LINE__, "Failed to open file", path.c_str(), err);
return false;
}
return true;
}
bool OpenExistingFileForRead(const Path& abs_path, HANDLE* result) {
*result = CreateFileW(bazel::windows::HasUncPrefix(abs_path.Get().c_str())
? abs_path.Get().c_str()
: (L"\\\\?\\" + abs_path.Get()).c_str(),
GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_DELETE, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (*result == INVALID_HANDLE_VALUE) {
DWORD err = GetLastError();
LogErrorWithArgAndValue(__LINE__, "Failed to open file",
abs_path.Get().c_str(), err);
return false;
}
return true;
}
bool TouchFile(const std::wstring& path) {
HANDLE handle;
if (!OpenFileForWriting(path, &handle)) {
return false;
}
CloseHandle(handle);
return true;
}
bool ReadCompleteFile(HANDLE handle, uint8_t* dest, DWORD max_read) {
if (max_read == 0) {
return true;
}
DWORD total_read = 0;
DWORD read = 0;
do {
if (!ReadFile(handle, dest + total_read, max_read - total_read, &read,
NULL)) {
DWORD err = GetLastError();
LogErrorWithValue(__LINE__, "Failed to read file", err);
return false;
}
total_read += read;
} while (read > 0 && total_read < max_read);
return true;
}
bool ExportXmlPath(const Path& cwd) {
Path result;
if (!GetPathEnv(L"XML_OUTPUT_FILE", &result)) {
return false;
}
result.Absolutize(cwd);
std::wstring unix_result = AsMixedPath(result.Get());
return SetEnv(L"XML_OUTPUT_FILE", unix_result) &&
// TODO(ulfjack): Update Gunit to accept XML_OUTPUT_FILE and drop the
// GUNIT_OUTPUT env variable.
SetEnv(L"GUNIT_OUTPUT", L"xml:" + unix_result) &&
CreateDirectories(result.Dirname()) &&
TouchFile(result.Get() + L".log");
}
devtools_ijar::u4 GetZipAttr(const FileInfo& info) {
devtools_ijar::Stat file_stat;
file_stat.total_size = info.size;
file_stat.is_directory = false;
// Set 0777 permission mask inside the zip for sake of simplicity.
file_stat.file_mode = S_IFREG | 0777;
return devtools_ijar::stat_to_zipattr(file_stat);
}
bool GetZipEntryPtr(devtools_ijar::ZipBuilder* zip_builder,
const char* entry_name, const devtools_ijar::u4 attr,
devtools_ijar::u1** result) {
*result = zip_builder->NewFile(entry_name, attr);
if (*result == nullptr) {
LogError(__LINE__, (std::string("Failed to add new zip entry for file \"") +
entry_name + "\": " + zip_builder->GetError())
.c_str());
return false;
}
return true;
}
bool CreateZip(const Path& root, const std::vector<FileInfo>& files,
const Path& abs_zip) {
bool restore_oem_api = false;
if (!AreFileApisANSI()) {
// devtools_ijar::ZipBuilder uses the ANSI file APIs so we must set the
// active code page to ANSI.
SetFileApisToANSI();
restore_oem_api = true;
}
Defer restore_file_apis([restore_oem_api]() {
if (restore_oem_api) {
SetFileApisToOEM();
}
});
ZipEntryPaths zip_entry_paths;
if (!ToZipEntryPaths(root, files, &zip_entry_paths)) {
LogError(__LINE__, "Failed to create zip entry paths");
return false;
}
std::unique_ptr<devtools_ijar::ZipBuilder> zip_builder;
if (!CreateZipBuilder(abs_zip, zip_entry_paths, &zip_builder)) {
LogError(__LINE__, "Failed to create zip builder");
return false;
}
for (size_t i = 0; i < files.size(); ++i) {
HANDLE handle;
Path path;
if (!path.Set(root.Get() + L"\\" + files[i].rel_path) ||
!OpenExistingFileForRead(path, &handle)) {
LogError(__LINE__,
(std::wstring(L"Failed to open file \"") + path.Get() + L"\"")
.c_str());
return false;
}
Defer close_file([handle]() { CloseHandle(handle); });
devtools_ijar::u1* dest;
if (!GetZipEntryPtr(zip_builder.get(), zip_entry_paths.EntryPathPtrs()[i],
GetZipAttr(files[i]), &dest) ||
!ReadCompleteFile(handle, dest, files[i].size)) {
LogError(__LINE__, (std::wstring(L"Failed to dump file \"") + path.Get() +
+L"\" into zip")
.c_str());
return false;
}
if (zip_builder->FinishFile(files[i].size, /* compress */ false,
/* compute_crc */ true) == -1) {
LogError(__LINE__, (std::wstring(L"Failed to finish writing file \"") +
path.Get() + L"\" to zip")
.c_str());
return false;
}
}
if (zip_builder->Finish() == -1) {
LogError(__LINE__, (std::string("Failed to add file to zip: ") +
zip_builder->GetError())
.c_str());
return false;
}
return true;
}
bool GetAndUnexportUndeclaredOutputsEnvvars(const Path& cwd,
UndeclaredOutputs* result) {
// The test may only see TEST_UNDECLARED_OUTPUTS_DIR and
// TEST_UNDECLARED_OUTPUTS_ANNOTATIONS_DIR, so keep those but unexport others.
if (!GetPathEnv(L"TEST_UNDECLARED_OUTPUTS_ZIP", &(result->zip)) ||
!UnsetEnv(L"TEST_UNDECLARED_OUTPUTS_ZIP") ||
!GetPathEnv(L"TEST_UNDECLARED_OUTPUTS_MANIFEST", &(result->manifest)) ||
!UnsetEnv(L"TEST_UNDECLARED_OUTPUTS_MANIFEST") ||
!GetPathEnv(L"TEST_UNDECLARED_OUTPUTS_ANNOTATIONS",
&(result->annotations)) ||
!UnsetEnv(L"TEST_UNDECLARED_OUTPUTS_ANNOTATIONS") ||
!GetPathEnv(L"TEST_UNDECLARED_OUTPUTS_DIR", &(result->root)) ||
!GetPathEnv(L"TEST_UNDECLARED_OUTPUTS_ANNOTATIONS_DIR",
&(result->annotations_dir))) {
return false;
}
result->root.Absolutize(cwd);
result->annotations_dir.Absolutize(cwd);
result->zip.Absolutize(cwd);
result->manifest.Absolutize(cwd);
result->annotations.Absolutize(cwd);
return SetPathEnv(L"TEST_UNDECLARED_OUTPUTS_DIR", result->root) &&
SetPathEnv(L"TEST_UNDECLARED_OUTPUTS_ANNOTATIONS_DIR",
result->annotations_dir) &&
CreateDirectories(result->root) &&
CreateDirectories(result->annotations_dir);
}
inline bool PrintTestLogStartMarker(bool suppress_output) {
if (suppress_output) {
return true;
}
std::wstring test_target;
if (!GetEnv(L"TEST_TARGET", &test_target)) {
return false;
}
if (test_target.empty()) {
// According to the Bazel Test Encyclopedia, setting TEST_TARGET is
// optional.
wprintf(L"Executing tests from unknown target\n");
} else {
wprintf(L"Executing tests from %s\n", test_target.c_str());
}
// This header marks where --test_output=streamed will start being printed.
printf(
"------------------------------------------------------------------------"
"-----\n");
return true;
}
inline bool GetWorkspaceName(std::wstring* result) {
return GetEnv(L"TEST_WORKSPACE", result) && !result->empty();
}
inline void StripLeadingDotSlash(std::wstring* s) {
if (s->size() >= 2 && (*s)[0] == L'.' && (*s)[1] == L'/') {
s->erase(0, 2);
}
}
bool FindTestBinary(const Path& argv0, std::wstring test_path, Path* result) {
if (!blaze_util::IsAbsolute(test_path)) {
std::string argv0_acp;
if (!WcsToAcp(argv0.Get(), &argv0_acp)) {
LogError(__LINE__,
(std::wstring(L"Failed to convert path ") + argv0.Get() + L"\"")
.c_str());
return false;
}
std::string error;
std::unique_ptr<bazel::tools::cpp::runfiles::Runfiles> runfiles(
bazel::tools::cpp::runfiles::Runfiles::Create(argv0_acp, &error));
if (runfiles == nullptr) {
LogError(__LINE__, "Failed to load runfiles");
return false;
}
std::wstring workspace;
if (!GetWorkspaceName(&workspace)) {
LogError(__LINE__, "Failed to read %TEST_WORKSPACE%");
return false;
}
StripLeadingDotSlash(&test_path);
test_path = workspace + L"/" + test_path;
std::string utf8_test_path;
uint32_t err;
if (!blaze_util::WcsToUtf8(test_path, &utf8_test_path, &err)) {
LogErrorWithArgAndValue(__LINE__, "Failed to convert string to UTF-8",
test_path.c_str(), err);
return false;
}
std::string rloc = runfiles->Rlocation(utf8_test_path);
if (!blaze_util::Utf8ToWcs(rloc, &test_path, &err)) {
LogErrorWithArgAndValue(__LINE__, "Failed to convert string",
utf8_test_path.c_str(), err);
}
}
return result->Set(test_path);
}
bool AddCommandLineArg(const wchar_t* arg, const size_t arg_size,
const bool first, wchar_t* cmdline,
const size_t cmdline_limit, size_t* inout_cmdline_len) {
if (arg_size == 0) {
const size_t len = (first ? 0 : 1) + 2;
if (*inout_cmdline_len + len >= cmdline_limit) {
LogError(__LINE__,
(std::wstring(L"Failed to add command line argument \"") + arg +
L"\"; command would be too long")
.c_str());
return false;
}
size_t offset = *inout_cmdline_len;
if (!first) {
cmdline[offset] = L' ';
offset += 1;
}
cmdline[offset] = L'"';
cmdline[offset + 1] = L'"';
*inout_cmdline_len += len;
return true;
} else {
const size_t len = (first ? 0 : 1) + arg_size;
if (*inout_cmdline_len + len >= cmdline_limit) {
LogError(__LINE__,
(std::wstring(L"Failed to add command line argument \"") + arg +
L"\"; command would be too long")
.c_str());
return false;
}
size_t offset = *inout_cmdline_len;
if (!first) {
cmdline[offset] = L' ';
offset += 1;
}
wcsncpy(cmdline + offset, arg, arg_size);
offset += arg_size;
*inout_cmdline_len += len;
return true;
}
}
bool CreateCommandLine(const Path& path,
const std::vector<const wchar_t*>& args,
std::unique_ptr<WCHAR[]>* result) {
// kMaxCmdline value: see lpCommandLine parameter of CreateProcessW.
static constexpr size_t kMaxCmdline = 32767;
// Add an extra character for the final null-terminator.
result->reset(new WCHAR[kMaxCmdline + 1]);
size_t total_len = 0;
if (!AddCommandLineArg(path.Get().c_str(), path.Get().size(), true,
result->get(), kMaxCmdline, &total_len)) {
return false;
}
for (const auto arg : args) {
if (!AddCommandLineArg(arg, wcslen(arg), false, result->get(), kMaxCmdline,
&total_len)) {
return false;
}
}
// Add final null-terminator. There's surely enough room for it:
// AddCommandLineArg kept validating that we stay under the limit of
// kMaxCmdline, and the buffer is one WCHAR larger than that.
result->get()[total_len] = 0;
return true;
}
bool StartSubprocess(const Path& path, const std::vector<const wchar_t*>& args,
HANDLE* process) {
std::unique_ptr<WCHAR[]> cmdline;
if (!CreateCommandLine(path, args, &cmdline)) {
return false;
}
PROCESS_INFORMATION processInfo;
STARTUPINFOW startupInfo = {0};
if (CreateProcessW(NULL, cmdline.get(), NULL, NULL, FALSE,
CREATE_UNICODE_ENVIRONMENT, NULL, NULL, &startupInfo,
&processInfo) != 0) {
CloseHandle(processInfo.hThread);
*process = processInfo.hProcess;
return true;
} else {
DWORD err = GetLastError();
LogErrorWithValue(__LINE__, "CreateProcessW failed", err);
return false;
}
}
int WaitForSubprocess(HANDLE process) {
DWORD result = WaitForSingleObject(process, INFINITE);
switch (result) {
case WAIT_OBJECT_0: {
DWORD exit_code;
if (!GetExitCodeProcess(process, &exit_code)) {
DWORD err = GetLastError();
LogErrorWithValue(__LINE__, "GetExitCodeProcess failed", err);
return 1;
}
return exit_code;
}
case WAIT_FAILED: {
DWORD err = GetLastError();
LogErrorWithValue(__LINE__, "WaitForSingleObject failed", err);
return 1;
}
default:
LogErrorWithValue(
__LINE__, "WaitForSingleObject returned unexpected result", result);
return 1;
}
}
bool ParseArgs(int argc, wchar_t** argv, Path* out_argv0,
std::wstring* out_test_path_arg, bool* out_suppress_output,
std::vector<const wchar_t*>* out_args) {
if (!out_argv0->Set(argv[0])) {
return false;
}
argc--;
argv++;
*out_suppress_output = false;
if (argc > 0 && wcscmp(argv[0], L"--no_echo") == 0) {
// Don't print anything to stdout in this special case.
// Currently needed for persistent test runner.
*out_suppress_output = true;
argc--;
argv++;
}
if (argc < 1) {
LogError(__LINE__, "Usage: $0 [--no_echo] <test_path> [test_args...]");
return false;
}
*out_test_path_arg = argv[0];
out_args->clear();
out_args->reserve(argc - 1);
for (int i = 1; i < argc; i++) {
out_args->push_back(argv[i]);
}
return true;
}
int RunSubprocess(const Path& test_path,
const std::vector<const wchar_t*>& args) {
HANDLE process;
if (!StartSubprocess(test_path, args, &process)) {
return 1;
}
Defer close_process([process]() { CloseHandle(process); });
return WaitForSubprocess(process);
}
bool Path::Set(const std::wstring& path) {
std::wstring result;
std::string error;
if (!blaze_util::AsWindowsPath(path, &result, &error)) {
LogError(__LINE__, error.c_str());
return false;
}
path_ = result;
return true;
}
bool Path::Absolutize(const Path& cwd) {
if (!path_.empty() && !blaze_util::IsAbsolute(path_)) {
path_ = cwd.path_ + L"\\" + path_;
return true;
} else {
return false;
}
}
Path Path::Dirname() const {
Path result;
result.path_ = blaze_util::SplitPathW(path_).first;
return result;
}
} // namespace
void ZipEntryPaths::Create(const std::string& root,
const std::vector<std::string>& relative_paths) {
size_ = relative_paths.size();
size_t total_size = 0;
for (const auto& e : relative_paths) {
// Increase total size for absolute paths by <root> + "/" + <path> +
// null-terminator.
total_size += root.size() + 1 + e.size() + 1;
}
// Store all absolute paths in one continuous char array.
abs_paths_.reset(new char[total_size]);
// Store pointers in two arrays. The pointers point into `abs_path`.
// We'll pass these paths to devtools_ijar::ZipBuilder::EstimateSize that
// expects an array of char pointers. The last element must be NULL, so
// allocate one extra pointer.
abs_path_ptrs_.reset(new char*[relative_paths.size() + 1]);
entry_path_ptrs_.reset(new char*[relative_paths.size() + 1]);
char* p = abs_paths_.get();
// Create all full paths (root + '/' + relative_paths[i] + '\0').
//
// If `root` is "c:/foo", then store the following:
//
// - Store each absolute path consecutively in `abs_paths_` (via `p`).
// Store paths with forward slashes and not backslashes, because we use them
// as zip entry paths, as well as paths we open with CreateFileA (which can
// convert these paths internally to Windows-style).
// Example: "c:/foo/bar.txt\0c:/foo/sub/baz.txt\0"
//
// - Store pointers in `abs_path_ptrs_`, pointing to the start of each
// string inside `abs_paths_`.
// Example: "c:/foo/bar.txt\0c:/foo/sub/baz.txt\0"
// ^ here ^ here
//
// - Store pointers in `entry_path_ptrs_`, pointing to the start of each
// zip entry path inside `abs_paths_`, which is the part of each path
// that's relative to `root`.
// Example: "c:/foo/bar.txt\0c:/foo/sub/baz.txt\0"
// ^ here ^ here
//
// - Because the ZipBuilder requires that the file paths and zip entry paths
// are null-terminated arrays, we insert an extra null at their ends.
for (size_t i = 0; i < relative_paths.size(); ++i) {
abs_path_ptrs_.get()[i] = p;
strncpy(p, root.c_str(), root.size());
p += root.size();
*p++ = '/';
entry_path_ptrs_.get()[i] = p;
strncpy(p, relative_paths[i].c_str(), relative_paths[i].size() + 1);
p += relative_paths[i].size() + 1;
}
abs_path_ptrs_.get()[relative_paths.size()] = nullptr;
entry_path_ptrs_.get()[relative_paths.size()] = nullptr;
}
int Main(int argc, wchar_t** argv) {
Path argv0;
std::wstring test_path_arg;
bool suppress_output = false;
Path test_path, exec_root, srcdir, tmpdir, xml_output;
UndeclaredOutputs undecl;
std::vector<const wchar_t*> args;
if (!ParseArgs(argc, argv, &argv0, &test_path_arg, &suppress_output, &args) ||
!PrintTestLogStartMarker(suppress_output) ||
!FindTestBinary(argv0, test_path_arg, &test_path) ||
!GetCwd(&exec_root) || !ExportUserName() ||
!ExportSrcPath(exec_root, &srcdir) ||
!ExportTmpPath(exec_root, &tmpdir) || !ExportHome(tmpdir) ||
!ExportRunfiles(exec_root, srcdir) || !ExportShardStatusFile(exec_root) ||
!ExportGtestVariables(tmpdir) || !ExportMiscEnvvars(exec_root) ||
!ExportXmlPath(exec_root) ||
!GetAndUnexportUndeclaredOutputsEnvvars(exec_root, &undecl)) {
return 1;
}
return RunSubprocess(test_path, args);
}
namespace testing {
bool TestOnly_GetEnv(const wchar_t* name, std::wstring* result) {
return GetEnv(name, result);
}
bool TestOnly_GetFileListRelativeTo(const std::wstring& abs_root,
std::vector<FileInfo>* result) {
Path root;
return blaze_util::IsAbsolute(abs_root) && root.Set(abs_root) &&
GetFileListRelativeTo(root, result);
}
bool TestOnly_ToZipEntryPaths(
const std::wstring& abs_root,
const std::vector<bazel::tools::test_wrapper::FileInfo>& files,
ZipEntryPaths* result) {
Path root;
return blaze_util::IsAbsolute(abs_root) && root.Set(abs_root) &&
ToZipEntryPaths(root, files, result);
}
bool TestOnly_CreateZip(const std::wstring& abs_root,
const std::vector<FileInfo>& files,
const std::wstring& abs_zip) {
Path root, zip;
return blaze_util::IsAbsolute(abs_root) && root.Set(abs_root) &&
blaze_util::IsAbsolute(abs_zip) && zip.Set(abs_zip) &&
CreateZip(root, files, zip);
}
bool TestOnly_AsMixedPath(const std::wstring& path, std::string* result) {
return WcsToAcp(
AsMixedPath(bazel::windows::HasUncPrefix(path.c_str()) ? path.substr(4)
: path),
result);
}
} // namespace testing
} // namespace test_wrapper
} // namespace tools
} // namespace bazel
| [
"copybara-piper@google.com"
] | copybara-piper@google.com |
1bda57066d1ee82a035ba525036ffecc30b9e833 | 81a3d9fdd4a6ed1854396fe12076dc97d13a5731 | /graph adjacency matrix.cpp | 83771bae595f0aa0e3b4b2d8d4f91f13791113da | [] | no_license | acodebreaker/practice-codes- | 1de1ce32f7270fdb81b7d66ee68e75188eab3986 | 5a02cc01f1a7940e6762aeb1814ec9a02f87766b | refs/heads/master | 2021-01-10T01:02:34.663920 | 2014-12-31T13:07:36 | 2014-12-31T13:07:36 | 19,846,191 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 722 | cpp | #include<bits/stdc++.h>
#define MAX 101
int adj[MAX][MAX];
using namespace std;
int main()
{
int choice;
printf("enter 1 for directed , 2 for undirected graph\n ");
scanf("%d",&choice);
printf("enter number of vertex\n");
int n,i,j;
int source,dest;
scanf("%d",&n);
int max_edges;
if(choice==1)
max_edges=n*(n-1);
if(choice==2)
max_edges=n*(n-1)/2;
for(i=1;i<=max_edges;i++)
{
printf("enter source and dest , -1 ,-1 to exit \n");
scanf("%d%d",&source,&dest);
if(source==-1&&dest==-1)
break;
if(source<0||source>n||dest<0||dest>n)
printf("invalid entry");
adj[source][dest]=1;
if(choice==2)
adj[dest][source]=1;
}
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
printf("%d ",adj[i][j]);
printf("\n");
}
return 0;
}
| [
"itsankitrawat@gmail.com"
] | itsankitrawat@gmail.com |
cab631685dfad985801fff2f0acee2f5290e2880 | 3cb4924e93ac5214f4a86e356e2b6fa200c75235 | /Homework/5/BinaryTreeQ9Mirror/BinaryTreeQ9Mirror/BinarySearchTree.h | 49ff67bccdf0ecd2dcbaf70b46e0d64297f3e700 | [] | no_license | LauraKirby/data-structures-and-algorithms-cpp | 885c0879c48703ccb76a137fa21b234dfc03171e | a6803583d267650359e6f1aba7bcd1e9054a0047 | refs/heads/master | 2021-08-31T16:09:23.146426 | 2017-12-22T01:20:07 | 2017-12-22T01:24:47 | 107,609,484 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,099 | h | //
// BinaryTreeNode.h
// BinaryTreeQ8BST
//
// Created by Laura Kirby on 12/3/17.
// Copyright © 2017 LK. All rights reserved.
//
// This file includes all of the pieces of the
// Binary Search Tree implementation
#ifndef BinarySearchTree_h
#define BinarySearchTree_h
// Node implementation
#include "BinarySearchTreeNode.h"
// Dictionary ADT
#include "dictionary.h"
using namespace std;
// Binary Search Tree implementation for the Dictionary ADT
template <typename Key, typename E>
class BST : public Dictionary<Key,E> {
private:
BinarySearchTreeNode<Key,E>* root; // Root of the BST
int nodecount; // Number of nodes in the BST
// Private "helper" functions
void clearHelper(BinarySearchTreeNode<Key, E>*);
BinarySearchTreeNode<Key,E>* insertHelper(BinarySearchTreeNode<Key, E>*,
const Key&, const E&);
BinarySearchTreeNode<Key,E>* deleteMin(BinarySearchTreeNode<Key, E>*);
BinarySearchTreeNode<Key,E>* getMin(BinarySearchTreeNode<Key, E>*);
BinarySearchTreeNode<Key,E>* removeHelper(BinarySearchTreeNode<Key, E>*, const Key&);
E findHelper(BinarySearchTreeNode<Key, E>*, const Key&) const;
void printHelper(BinarySearchTreeNode<Key, E>*, int) const;
public:
BST() { root = NULL; nodecount = 0; } // Constructor
~BST() { clearHelper(root); } // Destructor
void clear() // Reinitialize tree
{ clearHelper(root); root = NULL; nodecount = 0; }
// Insert a record into the tree.
// k Key value of the record.
// e The record to insert.
void insert(const Key& k, const E& e) {
root = insertHelper(root, k, e);
nodecount++;
}
// Get root of current tree
BinaryNode<Key>* getroot() {
BinaryNode<int>* node = root;
return node;
};
// Remove a record from the tree.
// k Key value of record to remove.
// Return: The record removed, or NULL if there is none.
E remove(const Key& k) {
E temp = findHelper(root, k); // First find it
if (temp != NULL) {
root = removeHelper(root, k);
nodecount--;
}
return temp;
}
// Remove and return the root node from the dictionary.
// Return: The record removed, null if tree is empty.
E removeAny() { // Delete min value
if (root != NULL) {
E temp = root->element();
root = removeHelper(root, root->key());
nodecount--;
return temp;
}
else return NULL;
}
// Return Record with key value k, NULL if none exist.
// k: The key value to find. */
// Return some record matching "k".
// Return true if such exists, false otherwise. If
// multiple records match "k", return an arbitrary one.
E find(const Key& k) const { return findHelper(root, k); }
// Return the number of records in the dictionary.
int size() { return nodecount; }
void print() const { // Print the contents of the BST
if (root == NULL) cout << "The BST is empty.\n";
else printHelper(root, 0);
}
};
// Clean up BST by releasing space back free store
template <typename Key, typename E>
void BST<Key, E>::
clearHelper(BinarySearchTreeNode<Key, E>* root) {
if (root == NULL) return;
clearHelper(root->left());
clearHelper(root->right());
delete root;
}
// Insert a node into the BST, returning the updated tree
template <typename Key, typename E>
BinarySearchTreeNode<Key, E>* BST<Key, E>::
insertHelper( BinarySearchTreeNode<Key, E>* root, const Key& k, const E& it ) {
if (root == NULL) // Empty tree: create node
return new BinarySearchTreeNode<Key, E>(k, it, NULL, NULL);
if (k < root->key())
root->setLeft(insertHelper(root->left(), k, it));
else root->setRight(insertHelper(root->right(), k, it));
return root; // Return tree with node inserted
}
// Delete the minimum value from the BST, returning the revised BST
template <typename Key, typename E>
BinarySearchTreeNode<Key, E>* BST<Key, E>::
getMin(BinarySearchTreeNode<Key, E>* rightTree) {
if (rightTree->left() == NULL)
return rightTree;
else return getMin(rightTree->left());
}
template <typename Key, typename E>
BinarySearchTreeNode<Key, E>* BST<Key, E>::
deleteMin(BinarySearchTreeNode<Key, E>* rightTree) {
if (rightTree->left() == NULL) // Found min
return rightTree->right();
else { // Continue left
rightTree->setLeft(deleteMin(rightTree->left()));
return rightTree;
}
}
// Remove a node with key value k
// Return: The tree with the node removed
template <typename Key, typename E>
BinarySearchTreeNode<Key, E>* BST<Key, E>::
removeHelper(BinarySearchTreeNode<Key, E>* rightTree, const Key& k) {
if (rightTree == NULL) return NULL; // k is not in tree
else if (k < rightTree->key())
rightTree->setLeft(removeHelper(rightTree->left(), k));
else if (k > rightTree->key())
rightTree->setRight(removeHelper(rightTree->right(), k));
else { // Found: remove it
BinarySearchTreeNode<Key, E>* temp = rightTree;
if (rightTree->left() == NULL) { // Only a right child
rightTree = rightTree->right(); // so point to right
delete temp;
}
else if (rightTree->right() == NULL) { // Only a left child
rightTree = rightTree->left(); // so point to left
delete temp;
}
else { // Both children are non-empty
BinarySearchTreeNode<Key, E>* temp = getMin(rightTree->right());
rightTree->setElement(temp->element());
rightTree->setKey(temp->key());
rightTree->setRight(deleteMin(rightTree->right()));
delete temp;
}
}
return rightTree;
}
// Find a node with the given key value
template <typename Key, typename E>
E BST<Key, E>::
findHelper(BinarySearchTreeNode<Key, E>* root, const Key& k) const {
if (root == NULL) return NULL; // Return if empty tree
if (k < root->key())
return findHelper(root->left(), k); // Check left
else if (k > root->key())
return findHelper(root->right(), k); // Check right
else return root->element(); // Found it
}
// Print out a BST
template <typename Key, typename E>
void BST<Key, E>::
printHelper(BinarySearchTreeNode<Key, E>* root, int level) const {
if (root == NULL) return; // Return if empty tree
printHelper(root->left(), level+1); // Move down left subtree
cout << "level: " << level;
for (int i=0; i<level; i++) // Indent to level
cout << " ";
cout << root->key() << "\n"; // Print node value
printHelper(root->right(), level+1); // Do right subtree
}
#endif
| [
"laurakirby26@gmail.com"
] | laurakirby26@gmail.com |
4ad6bef6df0a2e63d8d60e6c4294f447dddb5341 | 8a957f9111645551f196d3fd07b98e5f39d70513 | /Assignment1Final/Assignment1Final/DFS.cpp | e67130f8adcfce961af3b3ef780ff0349655937e | [] | no_license | SuperNova911/DataStructure-Class | 7eb39b0e38978d7b20c611b4773541ffd1bdc083 | 948265248a8ea1667328103dea078115b8853bd7 | refs/heads/master | 2020-03-30T12:25:53.510498 | 2018-12-25T13:48:52 | 2018-12-25T13:48:52 | 151,223,834 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 2,799 | cpp | #include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include "GenericStackDL.h"
#include "GenericDoublyListP.h"
#define MAX_GRAPH_SIZE 256
#define BRANCH_NUM 10
using namespace std;
template<typename Out>
void Split(const string &s, char delim, Out result);
vector<string> Split(const string &s, char delim);
void DFS(const int graph[MAX_GRAPH_SIZE][BRANCH_NUM], int row, int column, int start, int end);
int main()
{
char fileName[] = "sample_graph3.txt";
FILE *stream;
if (fopen_s(&stream, fileName, "r") != 0)
{
cout << "파일을 열 수 없습니다. FileName: " << fileName << endl;
return 0;
}
int graph[MAX_GRAPH_SIZE][BRANCH_NUM];
for (int i = 0; i < MAX_GRAPH_SIZE; i++)
for (int j = 0; j < BRANCH_NUM; j++)
graph[i][j] = -1;
int node;
char buffer[1024];
while (fgets(buffer, sizeof(buffer), stream) != NULL)
{
vector<string> elements = Split(buffer, ' ');
node = stoi(elements[0]);
for (int index = 1; index <= BRANCH_NUM && index < elements.size(); index++)
{
graph[node][index - 1] = stoi(elements[index]);
}
}
fclose(stream);
int start, end;
while (true)
{
cout << "enter staring and ending vertices> ";
cin >> start >> end;
DFS(graph, MAX_GRAPH_SIZE, BRANCH_NUM, start, end);
}
return 0;
}
template<typename Out>
void Split(const string &s, char delim, Out result)
{
stringstream ss(s);
string item;
while (getline(ss, item, delim)) {
*(result++) = item;
}
}
vector<string> Split(const string &s, char delim)
{
vector<string> elements;
Split(s, delim, back_inserter(elements));
return elements;
}
void DFS(const int graph[MAX_GRAPH_SIZE][BRANCH_NUM], int row, int column, int start, int end)
{
if (start < 0 || MAX_GRAPH_SIZE - 1 < start || end < 0 || MAX_GRAPH_SIZE - 1 < end)
{
cout << "out of range" << endl;
return;
}
StackClass<int> stack = StackClass<int>();
bool visited[MAX_GRAPH_SIZE] = { false };
visited[start] = true;
stack.Push(start);
int target;
while (stack.IsEmpty() == false)
{
stack.GetTop(target);
if (target == end)
break;
bool fallback = true;
for (int index = 0; index < column; index++)
{
if (graph[target][index] != -1 && visited[graph[target][index]] == false)
{
stack.Push(graph[target][index]);
visited[graph[target][index]] = true;
fallback = false;
break;
}
}
if (fallback == true)
stack.Pop();
}
if (stack.GetSize() > 0)
{
printf("path length: %d\n", stack.GetSize() - 1);
int path;
vector<int> pathList;
while (stack.IsEmpty() == false)
{
stack.GetTop(path);
stack.Pop();
pathList.insert(pathList.begin(), path);
}
for (int index = 0; index < pathList.size(); index++)
{
printf("%d ", pathList[index]);
}
printf("\n");
}
else
{
printf("not found\n");
}
} | [
"suwhan77@naver.com"
] | suwhan77@naver.com |
b40cd17fb729b56bf0883fd4013834395809fd4f | 7e6ec74f3e6eab63bb4f4b57bc0f58450f3113b5 | /GeneratedFiles/ui_DirectManipulatorDlg.h | 64a660dc4fa1ae5a3435187e4253c9cc8c0c0d06 | [] | no_license | asdln/EarthGlobal | c4ce96abbc84e7e1ea5906770f7405cb851bd4b7 | 2ac9d84965d27b90fb52d9e95ffc5fce2b5abbcf | refs/heads/master | 2020-03-21T12:09:02.287370 | 2018-11-28T14:48:10 | 2018-11-28T14:48:10 | 138,538,096 | 9 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 6,599 | h | /********************************************************************************
** Form generated from reading UI file 'DirectManipulatorDlg.ui'
**
** Created by: Qt User Interface Compiler version 5.6.0
**
** WARNING! All changes made in this file will be lost when recompiling UI file!
********************************************************************************/
#ifndef UI_DIRECTMANIPULATORDLG_H
#define UI_DIRECTMANIPULATORDLG_H
#include <QtCore/QVariant>
#include <QtWidgets/QAction>
#include <QtWidgets/QApplication>
#include <QtWidgets/QButtonGroup>
#include <QtWidgets/QGridLayout>
#include <QtWidgets/QHeaderView>
#include <QtWidgets/QLabel>
#include <QtWidgets/QLineEdit>
#include <QtWidgets/QPushButton>
#include <QtWidgets/QWidget>
QT_BEGIN_NAMESPACE
class Ui_DirectManipulatorDlg
{
public:
QWidget *gridLayoutWidget;
QGridLayout *gridLayout;
QLabel *label;
QLabel *label_2;
QLabel *label_3;
QLabel *label_7;
QLabel *label_4;
QLabel *label_5;
QLabel *label_6;
QLineEdit *lineEdit_EyeLon;
QLineEdit *lineEdit_EyeLat;
QLineEdit *lineEdit_EyeHei;
QLineEdit *lineEdit_Angle;
QLineEdit *lineEdit_TargetLon;
QLineEdit *lineEdit_TargetLat;
QLineEdit *lineEdit_TargetHei;
QPushButton *pushButton_Set;
QPushButton *pushButton_Revert;
void setupUi(QWidget *DirectManipulatorDlg)
{
if (DirectManipulatorDlg->objectName().isEmpty())
DirectManipulatorDlg->setObjectName(QStringLiteral("DirectManipulatorDlg"));
DirectManipulatorDlg->resize(273, 275);
gridLayoutWidget = new QWidget(DirectManipulatorDlg);
gridLayoutWidget->setObjectName(QStringLiteral("gridLayoutWidget"));
gridLayoutWidget->setGeometry(QRect(20, 20, 221, 191));
gridLayout = new QGridLayout(gridLayoutWidget);
gridLayout->setSpacing(6);
gridLayout->setContentsMargins(11, 11, 11, 11);
gridLayout->setObjectName(QStringLiteral("gridLayout"));
gridLayout->setContentsMargins(0, 0, 0, 0);
label = new QLabel(gridLayoutWidget);
label->setObjectName(QStringLiteral("label"));
gridLayout->addWidget(label, 0, 0, 1, 1);
label_2 = new QLabel(gridLayoutWidget);
label_2->setObjectName(QStringLiteral("label_2"));
gridLayout->addWidget(label_2, 1, 0, 1, 1);
label_3 = new QLabel(gridLayoutWidget);
label_3->setObjectName(QStringLiteral("label_3"));
gridLayout->addWidget(label_3, 2, 0, 1, 1);
label_7 = new QLabel(gridLayoutWidget);
label_7->setObjectName(QStringLiteral("label_7"));
gridLayout->addWidget(label_7, 3, 0, 1, 1);
label_4 = new QLabel(gridLayoutWidget);
label_4->setObjectName(QStringLiteral("label_4"));
gridLayout->addWidget(label_4, 4, 0, 1, 1);
label_5 = new QLabel(gridLayoutWidget);
label_5->setObjectName(QStringLiteral("label_5"));
gridLayout->addWidget(label_5, 5, 0, 1, 1);
label_6 = new QLabel(gridLayoutWidget);
label_6->setObjectName(QStringLiteral("label_6"));
gridLayout->addWidget(label_6, 6, 0, 1, 1);
lineEdit_EyeLon = new QLineEdit(gridLayoutWidget);
lineEdit_EyeLon->setObjectName(QStringLiteral("lineEdit_EyeLon"));
gridLayout->addWidget(lineEdit_EyeLon, 0, 1, 1, 1);
lineEdit_EyeLat = new QLineEdit(gridLayoutWidget);
lineEdit_EyeLat->setObjectName(QStringLiteral("lineEdit_EyeLat"));
gridLayout->addWidget(lineEdit_EyeLat, 1, 1, 1, 1);
lineEdit_EyeHei = new QLineEdit(gridLayoutWidget);
lineEdit_EyeHei->setObjectName(QStringLiteral("lineEdit_EyeHei"));
gridLayout->addWidget(lineEdit_EyeHei, 2, 1, 1, 1);
lineEdit_Angle = new QLineEdit(gridLayoutWidget);
lineEdit_Angle->setObjectName(QStringLiteral("lineEdit_Angle"));
gridLayout->addWidget(lineEdit_Angle, 3, 1, 1, 1);
lineEdit_TargetLon = new QLineEdit(gridLayoutWidget);
lineEdit_TargetLon->setObjectName(QStringLiteral("lineEdit_TargetLon"));
gridLayout->addWidget(lineEdit_TargetLon, 4, 1, 1, 1);
lineEdit_TargetLat = new QLineEdit(gridLayoutWidget);
lineEdit_TargetLat->setObjectName(QStringLiteral("lineEdit_TargetLat"));
gridLayout->addWidget(lineEdit_TargetLat, 5, 1, 1, 1);
lineEdit_TargetHei = new QLineEdit(gridLayoutWidget);
lineEdit_TargetHei->setObjectName(QStringLiteral("lineEdit_TargetHei"));
gridLayout->addWidget(lineEdit_TargetHei, 6, 1, 1, 1);
pushButton_Set = new QPushButton(DirectManipulatorDlg);
pushButton_Set->setObjectName(QStringLiteral("pushButton_Set"));
pushButton_Set->setGeometry(QRect(30, 230, 75, 23));
pushButton_Revert = new QPushButton(DirectManipulatorDlg);
pushButton_Revert->setObjectName(QStringLiteral("pushButton_Revert"));
pushButton_Revert->setGeometry(QRect(150, 230, 75, 23));
retranslateUi(DirectManipulatorDlg);
QMetaObject::connectSlotsByName(DirectManipulatorDlg);
} // setupUi
void retranslateUi(QWidget *DirectManipulatorDlg)
{
DirectManipulatorDlg->setWindowTitle(QApplication::translate("DirectManipulatorDlg", "DirectManipulatorDlg", 0));
label->setText(QApplication::translate("DirectManipulatorDlg", "\350\247\206\347\202\271\347\273\217\345\272\246", 0));
label_2->setText(QApplication::translate("DirectManipulatorDlg", "\350\247\206\347\202\271\347\272\254\345\272\246", 0));
label_3->setText(QApplication::translate("DirectManipulatorDlg", "\350\247\206\347\202\271\351\253\230\345\272\246", 0));
label_7->setText(QApplication::translate("DirectManipulatorDlg", "\346\227\213\350\275\254\350\247\222\345\272\246", 0));
label_4->setText(QApplication::translate("DirectManipulatorDlg", "\347\233\256\346\240\207\347\273\217\345\272\246", 0));
label_5->setText(QApplication::translate("DirectManipulatorDlg", "\347\233\256\346\240\207\347\272\254\345\272\246", 0));
label_6->setText(QApplication::translate("DirectManipulatorDlg", "\347\233\256\346\240\207\351\253\230\345\272\246", 0));
pushButton_Set->setText(QApplication::translate("DirectManipulatorDlg", "\350\256\276\347\275\256", 0));
pushButton_Revert->setText(QApplication::translate("DirectManipulatorDlg", "\346\201\242\345\244\215", 0));
} // retranslateUi
};
namespace Ui {
class DirectManipulatorDlg: public Ui_DirectManipulatorDlg {};
} // namespace Ui
QT_END_NAMESPACE
#endif // UI_DIRECTMANIPULATORDLG_H
| [
"93347786@qq.com"
] | 93347786@qq.com |
d7b71b46b7c3c8af2ef50f54fb58b03e885ce840 | 0e6e81a3788fd9847084991c3177481470546051 | /Explore/Algorithm Interview/code by cpp/395_Longest Substring with At Least K Repeating Characters.cpp | d6e006eb344a475a88a35d21079317da5c82625f | [] | no_license | Azhao1993/Leetcode | 6f84c62620f1bb60f82d4383764b777a4caa2715 | 1c1f2438e80d7958736dbc28b7ede562ec1356f7 | refs/heads/master | 2020-03-25T19:34:30.946119 | 2020-03-05T14:28:17 | 2020-03-05T14:28:17 | 144,089,629 | 4 | 2 | null | 2019-11-18T00:30:31 | 2018-08-09T02:10:26 | C++ | UTF-8 | C++ | false | false | 1,820 | cpp | #include<iostream>
#include<unordered_set>
#include<vector>
using namespace std;
/*
395. 至少有K个重复字符的最长子串
找到给定字符串（由小写字符组成）中的最长子串 T ， 要求 T 中的每一字符出现次数都不少于 k 。输出 T 的长度。
示例 1:
输入: s = "aaabb", k = 3 输出: 3
最长子串为 "aaa" ，其中 'a' 重复了 3 次。
示例 2:
输入: s = "ababbc", k = 2 输出: 5
最长子串为 "ababb" ，其中 'a' 重复了 2 次， 'b' 重复了 3 次。
*/
class Solution {
public:
int longestSubstring(string s, int k) {
// 若s字符串小于k,直接返回0
if(s.size()<k)return 0;
// 字符串的hash
int hash[26]={0};
for(int i=0;i<s.size();++i)
hash[s[i]-'a']++;
// 是否有隔断的标识
bool flag = true;
int res = 0,start = 0;
for(int i=0;i<s.size();++i){
// 连着出现好多个不符合的字符
if(hash[s[i]-'a']<k && i==start)flag = false,start = i+1;
// 当前字符的个数若小于k，则不能出现在结果里
if(hash[s[i]-'a']<k && start<=i){
string tem = s.substr(start,i-start);
res = max(res,longestSubstring(tem,k));
start = i+1;
flag = false;
}
}
// 若没有截断，则说明当前字符串符合
if(flag)return s.size();
// 最后的字符串还没有进行查找
if(start<=s.size()-k){
string tem = s.substr(start,s.size()-start);
res = max(res,longestSubstring(tem,k));
}
return res;
}
};
int main(){
Solution* so = new Solution();
int n = so->longestSubstring("weitong",3);
cout<<n<<endl;
return 0;
}
| [
"1358227862@qq.com"
] | 1358227862@qq.com |
5f434c2e62a6fda8befaa4babbf121ed3e0f3264 | 868214cb91fb1967c4fa18d5fbfd5e5a7c94b1d0 | /student/11/yatzy/yatzygame.cpp | 81b9ebdefdf1ff3a86b4c9ffa16a8ae5c6acadc6 | [] | no_license | OskariNiemela/OperskTy-t | 97d525580c39786b0c2fffbfcf8f0e2d7d416441 | dde5aad4f2302915e59cd1b06c981429ea23f653 | refs/heads/master | 2020-04-09T15:28:09.936192 | 2018-04-26T09:26:48 | 2018-04-26T09:26:48 | 160,427,039 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,938 | cpp | #include "yatzygame.hh"
#include "yatzyrules.hh"
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <iostream>
YatzyGame::YatzyGame(unsigned int seedValue) :
rollsLeft_(YatzyRules::ROLLS_PER_TURN),
dieRolls_(YatzyRules::NUMBER_OF_DICE, 1),
keepDie_(YatzyRules::NUMBER_OF_DICE, false),
scores_()
{
// Required for random number generation in roll().
if(seedValue == 0) {
// If there was no seed value given as a parameter for the
// constructor, use a seed value from the clock.
randomEngine_.seed(time(NULL));
} else {
// Otherwise use the seed value given as a parameter.
randomEngine_.seed(seedValue);
}
}
YatzyGame::~YatzyGame()
{
}
unsigned int YatzyGame::getNumberOfRollsLeft() const
{
return rollsLeft_;
}
std::vector<unsigned int> YatzyGame::roll()
{
for (int dieNumber = 0; dieNumber < YatzyRules::NUMBER_OF_DICE; dieNumber++)
{
if (keepDie_.at(dieNumber) == false)
{
// Roll a random number in range 1-6.
std::uniform_int_distribution<int> distribution (1,6);
int rollNumber = distribution(randomEngine_);
dieRolls_[dieNumber] = rollNumber;
}
}
rollsLeft_--;
return dieRolls_;
}
bool YatzyGame::canKeep(unsigned int dieNumber) const
{
return 0 < rollsLeft_ && rollsLeft_ <= YatzyRules::ROLLS_PER_TURN - 1 && keepDie_.at(dieNumber) == false;
}
void YatzyGame::keepRoll(unsigned int dieNumber)
{
keepDie_[dieNumber] = true;
}
bool YatzyGame::canScore(YatzyRules::ScoreCombination combination) const
{
return rollsLeft_ <= YatzyRules::ROLLS_PER_TURN - 1 && scores_.count(combination) == 0;
}
unsigned int YatzyGame::scoreOnes()
{
unsigned int score = std::count(dieRolls_.cbegin(), dieRolls_.cend(), 1);
scores_.insert({YatzyRules::ONES, score});
resetRolls();
return score;
}
unsigned int YatzyGame::scoreOnePair()
{
unsigned int score = 0;
for (int i = 0; i < YatzyRules::NUMBER_OF_DICE; i++)
{
for (int j = i + 1; j< YatzyRules::NUMBER_OF_DICE; j++)
{
if (dieRolls_.at(i) == dieRolls_.at(j))
{
score = std::max(dieRolls_.at(i)*2, score);
}
}
}
scores_.insert({YatzyRules::ONE_PAIR, score});
resetRolls();
return score;
}
unsigned int YatzyGame::scoreTwoPairs()
{
unsigned int score = 0;
unsigned int firstPair = 0;
for (int i = 0; i < YatzyRules::NUMBER_OF_DICE; i++)
{
for (int j = i + 1; j< YatzyRules::NUMBER_OF_DICE; j++)
{
if ((dieRolls_.at(i) == dieRolls_.at(j))&&(dieRolls_.at(i)!=firstPair))
{
if(firstPair==0)
{
firstPair = dieRolls_.at(i);
}
else
{
score = std::max(dieRolls_.at(i)*2+firstPair*2, score);
if(dieRolls_.at(i)>firstPair)
{
firstPair = dieRolls_.at(i);
}
}
}
}
}
scores_.insert({YatzyRules::TWO_PAIRS, score});
resetRolls();
return score;
}
unsigned int YatzyGame::scoreYatzy()
{
unsigned int score = 0;
for (int i = 0; i < YatzyRules::NUMBER_OF_DICE; i++)
{
for (int j = i + 1; j< YatzyRules::NUMBER_OF_DICE; j++)
{
if (dieRolls_.at(i) != dieRolls_.at(j))
{
scores_.insert({YatzyRules::YATZY, score});
resetRolls();
return score;
}
}
}
score = 50;
scores_.insert({YatzyRules::YATZY, score});
resetRolls();
return score;
}
unsigned int YatzyGame::scoreSmallStraight()
{
unsigned int score = 0;
std::map<unsigned int,bool> map;
map[1] = false;
map[2] = false;
map[3] = false;
map[4] = false;
map[5] = false;
for (int i = 0; i < YatzyRules::NUMBER_OF_DICE; i++)
{
if(map.find(dieRolls_.at(i))!=map.end())
{
map[i] = true;
}
else
{
scores_.insert({YatzyRules::SMALL_STRAIGHT, score});
resetRolls();
return score;
}
}
score = 15;
scores_.insert({YatzyRules::SMALL_STRAIGHT, score});
resetRolls();
return score;
}
unsigned int YatzyGame::getTotalScore() const
{
unsigned int total = 0;
for (std::map<YatzyRules::ScoreCombination, unsigned int>::const_iterator iter = scores_.cbegin();
iter != scores_.cend();
iter++)
{
total += iter->second;
}
return total;
}
void YatzyGame::reset()
{
scores_.clear();
resetRolls();
}
void YatzyGame::resetRolls()
{
rollsLeft_ = YatzyRules::ROLLS_PER_TURN;
for (int i = 0; i < YatzyRules::NUMBER_OF_DICE; i++)
{
keepDie_[i] = false;
}
}
| [
"oskari.niemela@student.tut.fi"
] | oskari.niemela@student.tut.fi |
b4de7841140949a51e401ac385692aee3e381c62 | ea169e62e49ce529439a8323ca0e54e7a3056d13 | /d03/ex02/ClapTrap.hpp | 3b0153a20450d1b54b52dcc78f99d02bd7a3bcbd | [] | no_license | abarriel/cpp | 58d0994e50d0c36fac3e94835b45eaa9bbb6f816 | a1f8d1d97a7c0749efe2d6939014128cf70c2403 | refs/heads/master | 2021-09-11T09:55:37.862177 | 2018-04-06T16:31:03 | 2018-04-06T16:31:03 | 125,994,872 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,015 | hpp | // ClapTrap
#ifndef CLAPTRAP_HPP
#define CLAPTRAP_HPP
#include <iostream>
class ClapTrap {
public:
ClapTrap(void); // Canonical
ClapTrap(ClapTrap const & src); // Canonical
~ClapTrap(void); // Canonical
ClapTrap& operator=(ClapTrap const & rhs); // Canonical
bool rangedAttack(std::string const & target);
bool meleeAttack(std::string const & target);
bool takeDamage(unsigned int amount);
bool beRepaired(unsigned int amount);
void infos();
protected:
bool checkEnergy(std::string attack, std::string target, int energy);
void messageAttack(std::string const target, std::string const attack, int const damage) const;
std::string name;
std::string type;
int hitPoints, maxhitPoints, energyPoints, maxEnergyPoints,
level, meleeAttackDamage, rangedAttackDamage, ArmorDamageReduction;
};
// std::ostream& operator<<(std::ostream& o, ClapTrap const &i);
#endif
// FR4G-TP <name> attacks <target> at range, causing <damage> points of damage !
| [
"abarriel@student.42.fr"
] | abarriel@student.42.fr |
413b4f20b7cd83f453a0e5bd065f2b0d92734849 | 527fcb7e82754a310ecd77cb7d7bf6658afe6c57 | /Table2.h | 735ce9cc51daa9c18055e44f20b3449d2cdb9522 | [] | no_license | JFergen/Hash-Table-Project | 475a2e0a73111d8244831e51a3c33118706a2bd7 | 3cbf280c24b0d5f66e27305d15b60d54ed9ec6e4 | refs/heads/master | 2020-04-29T06:46:56.835563 | 2019-04-08T19:03:10 | 2019-04-08T19:03:10 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,202 | h | //
// Created by Joseph Fergen on 3/16/2019.
//
//Very similar to that of Table1 class
#ifndef INC_2110PROJECT2_TABLE2_H
#define INC_2110PROJECT2_TABLE2_H
#include <string>
#include <vector>
#include <sstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <fstream>
using namespace std;
struct itemScheme
{
int ID = -1;
string name;
string type;
string rarity;
string price;
};
class Table2
{
public:
Table2();
void SetTableName(string t);
void SetKey(int k);
void SetItemID(int ID);
void SetSchemeData(istringstream& dataHelp);
bool InsertData(istringstream& dataHelp);
bool UpdateData(istringstream& dataHelp); // Updates the data in the hash table
void SelectData(istringstream& dataHelp); // Selects and returns data if found
void DeleteData(istringstream& dataHelp); // Selects and returns data if found
void WriteData(); // Writes out the data to an output file
bool IsEmpty(int p);
void DisplayItems();
string GetTableName();
private:
string tableName; // Name of the table (items)
int key;
itemScheme dataEntry;
vector<itemScheme> hashTableItem;
};
#endif //INC_2110PROJECT2_TABLE2_H
| [
"josephfergen150@gmail.com"
] | josephfergen150@gmail.com |
c08cb2896ac684bdc9a1befad11bbc7911ea833a | 8be7a7efbaa6a4034e435bc8221cc5fb54f8067c | /Bots/Other/code/Chapter9_FluidInteractionUsingKinect/KinectController.h | eb2a89e98d49677f397ce76ac5a51cb7fdfc8ed1 | [] | no_license | RinatB2017/Qt_github | 9faaa54e3c8e7a5f84f742d49f4559dcdd5622dd | 5177baa735c0140d39d8b0e84fc6af3dcb581abd | refs/heads/master | 2023-08-08T08:36:17.664868 | 2023-07-28T07:39:35 | 2023-07-28T07:39:35 | 163,097,727 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 5,291 | h | /*****************************************************************************
* Ch9 of the book "Mastering OpenCV with Practical Computer Vision Projects"
* Copyright Packt Publishing 2012.
* http://www.packtpub.com/cool-projects-with-opencv/book
* http://code.google.com/p/fluidwall/
*****************************************************************************/
/**
* @file KinectController.h
* @author Naureen Mahmood
* @copyright 2011 Austin Hines, Naureen Mahmood, and Texas A&M Dept. of Visualization
* @version 1.0.1
*
* This file is part of Fluid Wall. 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.
*
* Fluid Wall 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 Fluid Wall. If not, see <http://www.gnu.org/licenses/>.
*
* Version History:
* 1.0.0
* - Initial Release
*/
#ifndef KINECT_CONTROLLER_H
#define KINECT_CONTROLLER_H
//OpenNI includes
#include <XnOpenNI.h>
#include <XnCppWrapper.h>
//OpenCV includes
#include <cv.h>
#include <cxcore.h>
#include <highgui.h>
#include <iostream>
#define HEIGHT XN_VGA_Y_RES
#define WIDTH XN_VGA_X_RES
#define SAMPLE_XML_PATH "Data/SamplesConfig.xml"
#define CHECK_RC(nRetVal, what) \
if (nRetVal != XN_STATUS_OK) \
{ \
printf("%s failed: %s\n", what, xnGetStatusString(nRetVal));\
return xnRetVal; \
}
#define MAX_USERS 6
#define MAX_DEPTH 3000
#define ITERATIONS_BEFORE_RESET 10000
using namespace std;
using namespace cv;
//! KinectController Class
/*!
KinectController Class initializes and runs all the modules
for controlling the kinect camera devices.
*/
class KinectController
{
public:
/*
* (Default) Constructor with initialization list.
* @param _maxDepth initialize depth threshold for Kinect depth data stream(less than 6000)
* @param _maxUsers initialize maximum users to be detected (between 1-6)
* @param _depthMatrix initialize an empty cvMatrix to store the kinect depth-map
* @param _usersMatrix initialize an empty cvMatrix to store the kinect userID-map
*/
/*! Constructor with initialization lists */
KinectController () : _maxDepth( MAX_DEPTH ),
_maxUsers( MAX_USERS ),
_depthMatrix( Mat::zeros(480,640,CV_8UC1) ),
_usersMatrix( Mat::zeros(480,640,CV_8UC1) )
{ init(); }
/*! Destructor */
~KinectController() { kinectCleanupExit(); }
/*! Initialize all KinectController variables & modules */
XnStatus init();
/*! Depth & User Tracking Modules */
XnStatus update();
/*! Update the XnOpenNI Depth & User tracking data for each frame of video captured */
XnStatus reset();
/*! Set Depth Threshold */
void setDepth(int depthDelta);
/*! Get depth matrix for current video frame */
void getDepthMat(Mat &depth) { _depthMatrix.copyTo(depth); }
/*! Get matrix of tracked users for current video frame */
void getUsersMat(Mat &users) { _usersMatrix.copyTo(users); }
/*! Get maximum number of users to be tracked */
int getMaxUsers() { return _maxUsers; }
private:
// OPENNI DEPTH & USER TRACKING VARIABLES
xn::Context xnContext; /*! context object that creates depth and user data nodes */
xn::DepthGenerator xnDepthGenerator; /*! captures and returns depth values at each frame */
xn::UserGenerator xnUserGenerator; /*! captures and returns user detection data at each frame */
xn::SceneMetaData xnSceneMD; /*! scene metadata: gives access to IDs of detected users at each pixel of a captured frame */
xn::DepthMetaData xnDepthMD; /*! depth metadata: gives access to depth data at each pixel of a captured frame */
XnStatus xnRetVal; /*! used to check the status of each call to an XNOpenNI function */
int _maxUsers; /*! users to detect */
int _maxDepth; /*! depth threshold for how far the Kinect should capture */
int _maxIterate; /*! iterations to run before reset */
int _iterationCount; /*! running iterations so far (goes up to maxIterate then resets to 0) */
Mat _depthMatrix; /*! image-sized matrix containing the depth values at each pixel */
Mat _usersMatrix; /*! image-sized matrix containing the userID's of detected people at
/*! each pixel (or 0 if no detected user at that pixel) */
/*! Initialize XnOpenNI depth control & user tracking modules */
XnStatus initDepthControl();
/*! Destroy & shutdown XnOpenNI depth control & user tracking modules */
void stopDepthControl() { xnContext.Shutdown(); }
/*! Run Shutdown functions for Depth control */
void kinectCleanupExit();
};
#endif | [
"tux4096@gmail.com"
] | tux4096@gmail.com |
0e8fd04670712fd92d785e1a7687ad1801079e3e | 259ef188ee78e35f96ca94ce3a00569e99cb8fa6 | /BDSJSRunner/BDSJSRunner/net/net.cpp | 1d2eaa6629cf76354653b1a66dc0228bca74a68d | [] | no_license | Rosireity/DUnion-IE | c4016f03516ff76f08df39f2e3f29db79b345c7e | 643ded34eb42925ddcac158c89782cab54095edc | refs/heads/master | 2023-01-10T01:09:56.942721 | 2020-11-09T09:11:22 | 2020-11-09T09:11:22 | 311,224,513 | 5 | 1 | null | null | null | null | GB18030 | C++ | false | false | 1,365 | cpp | #include "net.h"
#include <curl\curl.h>
// 注意参数 size * nmemb 是数据的总长度
static size_t netwirte_callback(char* ptr, size_t size, size_t nmemb, void* userdata)
{
int l = size * nmemb;
char* buf = new char[l + 3]{ 0 };
memcpy(buf, ptr, size * nmemb);
buf[size * nmemb] = 0;
*(std::string*)userdata = *(std::string*)userdata + buf;
delete[] buf;
return l;
}
std::string netrequest(std::string strUrl, bool mode, std::string& params)
{
CURL* curl;
CURLcode res;
std::string str = "";
std::string uep = URLTool::UrlEncode(params);
std::string ueurl = URLTool::UrlEncode(strUrl);
curl = curl_easy_init();
if (curl) {
if (!mode) {
ueurl += (params != "" ? ("?" + uep) : "");
}
curl_easy_setopt(curl, CURLOPT_URL, ueurl.c_str());
if (mode) {
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, uep.c_str());
// 设置post的长度，如果是文本可以不用设置
curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, uep.length());
// 设置post提交方式
curl_easy_setopt(curl, CURLOPT_POST, 1);
}
else {
curl_easy_setopt(curl, CURLOPT_POST, 0);
}
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, netwirte_callback); // 设置回调函数
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &str);
res = curl_easy_perform(curl);
if (res == CURLE_OK) {
// do nothing
}
curl_easy_cleanup(curl);
}
return str;
}
| [
"2601683266@qq.com"
] | 2601683266@qq.com |
cefac4d7aa2ef8f3cdc869364213644e26ec32fa | 59409fab0056c63eb8b43c6bebc46ad2320e5f3f | /MAX10/tsbs/common_sw_library/tsb/ip/software/ltc2123/ltc2123_virtual_uart.cpp | 034a7abcbd8b145f2433b49811078671b81ef551 | [] | no_license | thomaslindner/xu1-max10-testing | ce96004e9ee51c927ec64fdc8d2438bc95742a46 | a44bdeff1bf533632bfaea5ab9c8cf22d0529e85 | refs/heads/master | 2022-12-22T20:14:30.665124 | 2020-05-19T22:53:52 | 2020-05-19T22:53:52 | 295,867,338 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 3,072 | cpp | /*
* ltc2123_virtual_uart.cpp
*
* Created on: Feb 7, 2014
* Author: yairlinn
*/
#include "ltc2123_virtual_uart.h"
#include "basedef.h"
#include <sstream>
#include <iostream>
#include <string>
#include <stdio.h>
#include "linnux_utils.h"
#include "basedef.h"
#include <vector>
extern "C" {
#include <xprintf.h>
}
#define u(x) do { if (UART_REG_DEBUG) {x;} } while (0)
#define dureg(x) do { safe_print(xprintf("[%s][%s][%d]:\n",__FILE__,__func__,__LINE__);); x; safe_print(xprintf("\n");); } while (0)
#define debureg(x) do { if (UART_REG_DEBUG) { safe_print(xprintf("[%s][%s][%d]:\n",__FILE__,__func__,__LINE__);); x; safe_print(xprintf("\n"););} } while (0)
unsigned long long ltc2123_virtual_uart::read_control_reg(unsigned long address,
unsigned long secondary_uart_address,
int* errorptr)
{
if (!is_valid_secondary_uart(secondary_uart_address)) {
dureg(safe_print(std::cout << "invalid secondary Address: " << secondary_uart_address<< std::endl););
return 0;
}
return this->ltc2123_read(address);
};
void ltc2123_virtual_uart::write_control_reg(unsigned long address,
unsigned long long data,
unsigned long secondary_uart_address,
int* errorptr)
{
if (!is_valid_secondary_uart(secondary_uart_address)) {
dureg(safe_print(std::cout << "invalid secondary Address: " << secondary_uart_address<< std::endl););
return;
}
this->ltc2123_write(address,data);
};
ltc2123_virtual_uart::ltc2123_virtual_uart(unsigned long chipselect, unsigned long id_no, unsigned long jesd_subclass) :
virtual_uart_register_file(),
ltc2123_driver(chipselect, id_no, jesd_subclass){
default_register_descriptions[0x000] = "Reset" ;
default_register_descriptions[0x001] = "PowerDown" ;
default_register_descriptions[0x002] = "ADC_CNTL" ;
default_register_descriptions[0x003] = "JESD_DID" ;
default_register_descriptions[0x004] = "JESD_BID" ;
default_register_descriptions[0x005] = "JESD_L" ;
default_register_descriptions[0x006] = "JESD_K" ;
default_register_descriptions[0x007] = "JESD_MODES" ;
default_register_descriptions[0x008] = "SUBCLASS" ;
default_register_descriptions[0x009] = "TEST_PATTERN" ;
default_register_descriptions[0x00A] = "CML_MANGNITUDE" ;
uart_regfile_single_uart_included_regs_type the_included_regs = get_all_map_keys<register_desc_map_type>(default_register_descriptions);
this->set_control_reg_map_desc(default_register_descriptions);
this->set_included_ctrl_regs(the_included_regs);
dureg(safe_print(std::cout << " set included registers to: (" << this->get_included_ctrl_regs_as_string() << ")" << std::endl;););
};
| [
"rypayne@hotmail.ca"
] | rypayne@hotmail.ca |
220cdd95e86baac31136bc5c9e2c57e6b8fa9565 | e1bafb9c94db3a6cfd86ce4b3a641e79583220b3 | /muduo_test/34_TcpConnection_LifeTime/esft.cpp | 9794e565f76381d7da17a225874442f86d310f3f | [] | no_license | lightjameslyy/lt-cpp | 055b0245ba9cc4608db6a0d08dc081d1c2766ba2 | 525c3f0fbeb4b112361a6650bf3ef445fdb61e2c | refs/heads/master | 2021-07-09T08:32:24.405308 | 2020-06-08T08:45:10 | 2020-06-08T08:45:10 | 128,907,003 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 764 | cpp | #include <boost/enable_shared_from_this.hpp>
#include <boost/shared_ptr.hpp>
#include <cassert>
#include <iostream>
class Y: public boost::enable_shared_from_this<Y>
{
public:
boost::shared_ptr<Y> f()
{
return shared_from_this();
}
Y* f2()
{
return this;
}
};
int main()
{
boost::shared_ptr<Y> p(new Y);//p的引用计数为1，
boost::shared_ptr<Y> q = p->f();//引用计数为2
Y* r = p->f2();
assert(p == q);//正确
assert(p.get() == r);//p的指针（即new Y)=r
std::cout<<p.use_count()<<std::endl;//2
boost::shared_ptr<Y> s(r);//等于又构造了一个独立share_ptr对象,并不是把某个share_ptr对象赋值给另外一个，后者的引用计数才+1=3
std::cout<<s.use_count()<<std::endl;//1
assert(p == s);
return 0;
}
| [
"lightjameslyy@gmail.com"
] | lightjameslyy@gmail.com |
1c544c50528d6d6e5fa058ab8055aa09fb7e6a4d | 753a70bc416e8dced2853f278b08ef60cdb3c768 | /include/tensorflow/lite/schema/schema_generated.h | b5c80ed55b17c6699d146ba44f88f8052fece5e0 | [
"MIT"
] | permissive | finnickniu/tensorflow_object_detection_tflite | ef94158e5350613590641880cb3c1062f7dd0efb | a115d918f6894a69586174653172be0b5d1de952 | refs/heads/master | 2023-04-06T04:59:24.985923 | 2022-09-20T16:29:08 | 2022-09-20T16:29:08 | 230,891,552 | 60 | 19 | MIT | 2023-03-25T00:31:18 | 2019-12-30T09:58:41 | C++ | UTF-8 | C++ | false | false | 615,564 | h | /* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
// automatically generated by the FlatBuffers compiler, do not modify
#ifndef FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_
#define FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_
#include "flatbuffers/flatbuffers.h"
namespace tflite {
struct CustomQuantization;
struct CustomQuantizationT;
struct QuantizationParameters;
struct QuantizationParametersT;
struct DimensionMetadata;
struct DimensionMetadataT;
struct SparsityParameters;
struct SparsityParametersT;
struct Tensor;
struct TensorT;
struct Conv2DOptions;
struct Conv2DOptionsT;
struct Pool2DOptions;
struct Pool2DOptionsT;
struct DepthwiseConv2DOptions;
struct DepthwiseConv2DOptionsT;
struct ConcatEmbeddingsOptions;
struct ConcatEmbeddingsOptionsT;
struct LSHProjectionOptions;
struct LSHProjectionOptionsT;
struct SVDFOptions;
struct SVDFOptionsT;
struct RNNOptions;
struct RNNOptionsT;
struct SequenceRNNOptions;
struct SequenceRNNOptionsT;
struct BidirectionalSequenceRNNOptions;
struct BidirectionalSequenceRNNOptionsT;
struct FullyConnectedOptions;
struct FullyConnectedOptionsT;
struct SoftmaxOptions;
struct SoftmaxOptionsT;
struct ConcatenationOptions;
struct ConcatenationOptionsT;
struct AddOptions;
struct AddOptionsT;
struct MulOptions;
struct MulOptionsT;
struct L2NormOptions;
struct L2NormOptionsT;
struct LocalResponseNormalizationOptions;
struct LocalResponseNormalizationOptionsT;
struct LSTMOptions;
struct LSTMOptionsT;
struct UnidirectionalSequenceLSTMOptions;
struct UnidirectionalSequenceLSTMOptionsT;
struct BidirectionalSequenceLSTMOptions;
struct BidirectionalSequenceLSTMOptionsT;
struct ResizeBilinearOptions;
struct ResizeBilinearOptionsT;
struct ResizeNearestNeighborOptions;
struct ResizeNearestNeighborOptionsT;
struct CallOptions;
struct CallOptionsT;
struct PadOptions;
struct PadOptionsT;
struct PadV2Options;
struct PadV2OptionsT;
struct ReshapeOptions;
struct ReshapeOptionsT;
struct SpaceToBatchNDOptions;
struct SpaceToBatchNDOptionsT;
struct BatchToSpaceNDOptions;
struct BatchToSpaceNDOptionsT;
struct SkipGramOptions;
struct SkipGramOptionsT;
struct SpaceToDepthOptions;
struct SpaceToDepthOptionsT;
struct DepthToSpaceOptions;
struct DepthToSpaceOptionsT;
struct SubOptions;
struct SubOptionsT;
struct DivOptions;
struct DivOptionsT;
struct TopKV2Options;
struct TopKV2OptionsT;
struct EmbeddingLookupSparseOptions;
struct EmbeddingLookupSparseOptionsT;
struct GatherOptions;
struct GatherOptionsT;
struct TransposeOptions;
struct TransposeOptionsT;
struct ExpOptions;
struct ExpOptionsT;
struct CosOptions;
struct CosOptionsT;
struct ReducerOptions;
struct ReducerOptionsT;
struct SqueezeOptions;
struct SqueezeOptionsT;
struct SplitOptions;
struct SplitOptionsT;
struct SplitVOptions;
struct SplitVOptionsT;
struct StridedSliceOptions;
struct StridedSliceOptionsT;
struct LogSoftmaxOptions;
struct LogSoftmaxOptionsT;
struct CastOptions;
struct CastOptionsT;
struct DequantizeOptions;
struct DequantizeOptionsT;
struct MaximumMinimumOptions;
struct MaximumMinimumOptionsT;
struct TileOptions;
struct TileOptionsT;
struct ArgMaxOptions;
struct ArgMaxOptionsT;
struct ArgMinOptions;
struct ArgMinOptionsT;
struct GreaterOptions;
struct GreaterOptionsT;
struct GreaterEqualOptions;
struct GreaterEqualOptionsT;
struct LessOptions;
struct LessOptionsT;
struct LessEqualOptions;
struct LessEqualOptionsT;
struct NegOptions;
struct NegOptionsT;
struct SelectOptions;
struct SelectOptionsT;
struct SliceOptions;
struct SliceOptionsT;
struct TransposeConvOptions;
struct TransposeConvOptionsT;
struct ExpandDimsOptions;
struct ExpandDimsOptionsT;
struct SparseToDenseOptions;
struct SparseToDenseOptionsT;
struct EqualOptions;
struct EqualOptionsT;
struct NotEqualOptions;
struct NotEqualOptionsT;
struct ShapeOptions;
struct ShapeOptionsT;
struct RankOptions;
struct RankOptionsT;
struct PowOptions;
struct PowOptionsT;
struct FakeQuantOptions;
struct FakeQuantOptionsT;
struct PackOptions;
struct PackOptionsT;
struct LogicalOrOptions;
struct LogicalOrOptionsT;
struct OneHotOptions;
struct OneHotOptionsT;
struct AbsOptions;
struct AbsOptionsT;
struct HardSwishOptions;
struct HardSwishOptionsT;
struct LogicalAndOptions;
struct LogicalAndOptionsT;
struct LogicalNotOptions;
struct LogicalNotOptionsT;
struct UnpackOptions;
struct UnpackOptionsT;
struct FloorDivOptions;
struct FloorDivOptionsT;
struct SquareOptions;
struct SquareOptionsT;
struct ZerosLikeOptions;
struct ZerosLikeOptionsT;
struct FillOptions;
struct FillOptionsT;
struct FloorModOptions;
struct FloorModOptionsT;
struct RangeOptions;
struct RangeOptionsT;
struct LeakyReluOptions;
struct LeakyReluOptionsT;
struct SquaredDifferenceOptions;
struct SquaredDifferenceOptionsT;
struct MirrorPadOptions;
struct MirrorPadOptionsT;
struct UniqueOptions;
struct UniqueOptionsT;
struct ReverseV2Options;
struct ReverseV2OptionsT;
struct AddNOptions;
struct AddNOptionsT;
struct GatherNdOptions;
struct GatherNdOptionsT;
struct WhereOptions;
struct WhereOptionsT;
struct ReverseSequenceOptions;
struct ReverseSequenceOptionsT;
struct MatrixDiagOptions;
struct MatrixDiagOptionsT;
struct QuantizeOptions;
struct QuantizeOptionsT;
struct MatrixSetDiagOptions;
struct MatrixSetDiagOptionsT;
struct IfOptions;
struct IfOptionsT;
struct WhileOptions;
struct WhileOptionsT;
struct NonMaxSuppressionV4Options;
struct NonMaxSuppressionV4OptionsT;
struct NonMaxSuppressionV5Options;
struct NonMaxSuppressionV5OptionsT;
struct ScatterNdOptions;
struct ScatterNdOptionsT;
struct SelectV2Options;
struct SelectV2OptionsT;
struct OperatorCode;
struct OperatorCodeT;
struct Operator;
struct OperatorT;
struct SubGraph;
struct SubGraphT;
struct Buffer;
struct BufferT;
struct Metadata;
struct MetadataT;
struct Model;
struct ModelT;
enum TensorType {
TensorType_FLOAT32 = 0,
TensorType_FLOAT16 = 1,
TensorType_INT32 = 2,
TensorType_UINT8 = 3,
TensorType_INT64 = 4,
TensorType_STRING = 5,
TensorType_BOOL = 6,
TensorType_INT16 = 7,
TensorType_COMPLEX64 = 8,
TensorType_INT8 = 9,
TensorType_MIN = TensorType_FLOAT32,
TensorType_MAX = TensorType_INT8
};
inline const TensorType (&EnumValuesTensorType())[10] {
static const TensorType values[] = {
TensorType_FLOAT32,
TensorType_FLOAT16,
TensorType_INT32,
TensorType_UINT8,
TensorType_INT64,
TensorType_STRING,
TensorType_BOOL,
TensorType_INT16,
TensorType_COMPLEX64,
TensorType_INT8
};
return values;
}
inline const char * const *EnumNamesTensorType() {
static const char * const names[] = {
"FLOAT32",
"FLOAT16",
"INT32",
"UINT8",
"INT64",
"STRING",
"BOOL",
"INT16",
"COMPLEX64",
"INT8",
nullptr
};
return names;
}
inline const char *EnumNameTensorType(TensorType e) {
if (e < TensorType_FLOAT32 || e > TensorType_INT8) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesTensorType()[index];
}
enum QuantizationDetails {
QuantizationDetails_NONE = 0,
QuantizationDetails_CustomQuantization = 1,
QuantizationDetails_MIN = QuantizationDetails_NONE,
QuantizationDetails_MAX = QuantizationDetails_CustomQuantization
};
inline const QuantizationDetails (&EnumValuesQuantizationDetails())[2] {
static const QuantizationDetails values[] = {
QuantizationDetails_NONE,
QuantizationDetails_CustomQuantization
};
return values;
}
inline const char * const *EnumNamesQuantizationDetails() {
static const char * const names[] = {
"NONE",
"CustomQuantization",
nullptr
};
return names;
}
inline const char *EnumNameQuantizationDetails(QuantizationDetails e) {
if (e < QuantizationDetails_NONE || e > QuantizationDetails_CustomQuantization) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesQuantizationDetails()[index];
}
template<typename T> struct QuantizationDetailsTraits {
static const QuantizationDetails enum_value = QuantizationDetails_NONE;
};
template<> struct QuantizationDetailsTraits<CustomQuantization> {
static const QuantizationDetails enum_value = QuantizationDetails_CustomQuantization;
};
struct QuantizationDetailsUnion {
QuantizationDetails type;
void *value;
QuantizationDetailsUnion() : type(QuantizationDetails_NONE), value(nullptr) {}
QuantizationDetailsUnion(QuantizationDetailsUnion&& u) FLATBUFFERS_NOEXCEPT :
type(QuantizationDetails_NONE), value(nullptr)
{ std::swap(type, u.type); std::swap(value, u.value); }
QuantizationDetailsUnion(const QuantizationDetailsUnion &) FLATBUFFERS_NOEXCEPT;
QuantizationDetailsUnion &operator=(const QuantizationDetailsUnion &u) FLATBUFFERS_NOEXCEPT
{ QuantizationDetailsUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
QuantizationDetailsUnion &operator=(QuantizationDetailsUnion &&u) FLATBUFFERS_NOEXCEPT
{ std::swap(type, u.type); std::swap(value, u.value); return *this; }
~QuantizationDetailsUnion() { Reset(); }
void Reset();
#ifndef FLATBUFFERS_CPP98_STL
template <typename T>
void Set(T&& val) {
using RT = typename std::remove_reference<T>::type;
Reset();
type = QuantizationDetailsTraits<typename RT::TableType>::enum_value;
if (type != QuantizationDetails_NONE) {
value = new RT(std::forward<T>(val));
}
}
#endif // FLATBUFFERS_CPP98_STL
static void *UnPack(const void *obj, QuantizationDetails type, const flatbuffers::resolver_function_t *resolver);
flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
CustomQuantizationT *AsCustomQuantization() {
return type == QuantizationDetails_CustomQuantization ?
reinterpret_cast<CustomQuantizationT *>(value) : nullptr;
}
const CustomQuantizationT *AsCustomQuantization() const {
return type == QuantizationDetails_CustomQuantization ?
reinterpret_cast<const CustomQuantizationT *>(value) : nullptr;
}
};
bool VerifyQuantizationDetails(flatbuffers::Verifier &verifier, const void *obj, QuantizationDetails type);
bool VerifyQuantizationDetailsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
enum DimensionType {
DimensionType_DENSE = 0,
DimensionType_SPARSE_CSR = 1,
DimensionType_MIN = DimensionType_DENSE,
DimensionType_MAX = DimensionType_SPARSE_CSR
};
inline const DimensionType (&EnumValuesDimensionType())[2] {
static const DimensionType values[] = {
DimensionType_DENSE,
DimensionType_SPARSE_CSR
};
return values;
}
inline const char * const *EnumNamesDimensionType() {
static const char * const names[] = {
"DENSE",
"SPARSE_CSR",
nullptr
};
return names;
}
inline const char *EnumNameDimensionType(DimensionType e) {
if (e < DimensionType_DENSE || e > DimensionType_SPARSE_CSR) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesDimensionType()[index];
}
enum BuiltinOperator {
BuiltinOperator_ADD = 0,
BuiltinOperator_AVERAGE_POOL_2D = 1,
BuiltinOperator_CONCATENATION = 2,
BuiltinOperator_CONV_2D = 3,
BuiltinOperator_DEPTHWISE_CONV_2D = 4,
BuiltinOperator_DEPTH_TO_SPACE = 5,
BuiltinOperator_DEQUANTIZE = 6,
BuiltinOperator_EMBEDDING_LOOKUP = 7,
BuiltinOperator_FLOOR = 8,
BuiltinOperator_FULLY_CONNECTED = 9,
BuiltinOperator_HASHTABLE_LOOKUP = 10,
BuiltinOperator_L2_NORMALIZATION = 11,
BuiltinOperator_L2_POOL_2D = 12,
BuiltinOperator_LOCAL_RESPONSE_NORMALIZATION = 13,
BuiltinOperator_LOGISTIC = 14,
BuiltinOperator_LSH_PROJECTION = 15,
BuiltinOperator_LSTM = 16,
BuiltinOperator_MAX_POOL_2D = 17,
BuiltinOperator_MUL = 18,
BuiltinOperator_RELU = 19,
BuiltinOperator_RELU_N1_TO_1 = 20,
BuiltinOperator_RELU6 = 21,
BuiltinOperator_RESHAPE = 22,
BuiltinOperator_RESIZE_BILINEAR = 23,
BuiltinOperator_RNN = 24,
BuiltinOperator_SOFTMAX = 25,
BuiltinOperator_SPACE_TO_DEPTH = 26,
BuiltinOperator_SVDF = 27,
BuiltinOperator_TANH = 28,
BuiltinOperator_CONCAT_EMBEDDINGS = 29,
BuiltinOperator_SKIP_GRAM = 30,
BuiltinOperator_CALL = 31,
BuiltinOperator_CUSTOM = 32,
BuiltinOperator_EMBEDDING_LOOKUP_SPARSE = 33,
BuiltinOperator_PAD = 34,
BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_RNN = 35,
BuiltinOperator_GATHER = 36,
BuiltinOperator_BATCH_TO_SPACE_ND = 37,
BuiltinOperator_SPACE_TO_BATCH_ND = 38,
BuiltinOperator_TRANSPOSE = 39,
BuiltinOperator_MEAN = 40,
BuiltinOperator_SUB = 41,
BuiltinOperator_DIV = 42,
BuiltinOperator_SQUEEZE = 43,
BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM = 44,
BuiltinOperator_STRIDED_SLICE = 45,
BuiltinOperator_BIDIRECTIONAL_SEQUENCE_RNN = 46,
BuiltinOperator_EXP = 47,
BuiltinOperator_TOPK_V2 = 48,
BuiltinOperator_SPLIT = 49,
BuiltinOperator_LOG_SOFTMAX = 50,
BuiltinOperator_DELEGATE = 51,
BuiltinOperator_BIDIRECTIONAL_SEQUENCE_LSTM = 52,
BuiltinOperator_CAST = 53,
BuiltinOperator_PRELU = 54,
BuiltinOperator_MAXIMUM = 55,
BuiltinOperator_ARG_MAX = 56,
BuiltinOperator_MINIMUM = 57,
BuiltinOperator_LESS = 58,
BuiltinOperator_NEG = 59,
BuiltinOperator_PADV2 = 60,
BuiltinOperator_GREATER = 61,
BuiltinOperator_GREATER_EQUAL = 62,
BuiltinOperator_LESS_EQUAL = 63,
BuiltinOperator_SELECT = 64,
BuiltinOperator_SLICE = 65,
BuiltinOperator_SIN = 66,
BuiltinOperator_TRANSPOSE_CONV = 67,
BuiltinOperator_SPARSE_TO_DENSE = 68,
BuiltinOperator_TILE = 69,
BuiltinOperator_EXPAND_DIMS = 70,
BuiltinOperator_EQUAL = 71,
BuiltinOperator_NOT_EQUAL = 72,
BuiltinOperator_LOG = 73,
BuiltinOperator_SUM = 74,
BuiltinOperator_SQRT = 75,
BuiltinOperator_RSQRT = 76,
BuiltinOperator_SHAPE = 77,
BuiltinOperator_POW = 78,
BuiltinOperator_ARG_MIN = 79,
BuiltinOperator_FAKE_QUANT = 80,
BuiltinOperator_REDUCE_PROD = 81,
BuiltinOperator_REDUCE_MAX = 82,
BuiltinOperator_PACK = 83,
BuiltinOperator_LOGICAL_OR = 84,
BuiltinOperator_ONE_HOT = 85,
BuiltinOperator_LOGICAL_AND = 86,
BuiltinOperator_LOGICAL_NOT = 87,
BuiltinOperator_UNPACK = 88,
BuiltinOperator_REDUCE_MIN = 89,
BuiltinOperator_FLOOR_DIV = 90,
BuiltinOperator_REDUCE_ANY = 91,
BuiltinOperator_SQUARE = 92,
BuiltinOperator_ZEROS_LIKE = 93,
BuiltinOperator_FILL = 94,
BuiltinOperator_FLOOR_MOD = 95,
BuiltinOperator_RANGE = 96,
BuiltinOperator_RESIZE_NEAREST_NEIGHBOR = 97,
BuiltinOperator_LEAKY_RELU = 98,
BuiltinOperator_SQUARED_DIFFERENCE = 99,
BuiltinOperator_MIRROR_PAD = 100,
BuiltinOperator_ABS = 101,
BuiltinOperator_SPLIT_V = 102,
BuiltinOperator_UNIQUE = 103,
BuiltinOperator_CEIL = 104,
BuiltinOperator_REVERSE_V2 = 105,
BuiltinOperator_ADD_N = 106,
BuiltinOperator_GATHER_ND = 107,
BuiltinOperator_COS = 108,
BuiltinOperator_WHERE = 109,
BuiltinOperator_RANK = 110,
BuiltinOperator_ELU = 111,
BuiltinOperator_REVERSE_SEQUENCE = 112,
BuiltinOperator_MATRIX_DIAG = 113,
BuiltinOperator_QUANTIZE = 114,
BuiltinOperator_MATRIX_SET_DIAG = 115,
BuiltinOperator_ROUND = 116,
BuiltinOperator_HARD_SWISH = 117,
BuiltinOperator_IF = 118,
BuiltinOperator_WHILE = 119,
BuiltinOperator_NON_MAX_SUPPRESSION_V4 = 120,
BuiltinOperator_NON_MAX_SUPPRESSION_V5 = 121,
BuiltinOperator_SCATTER_ND = 122,
BuiltinOperator_SELECT_V2 = 123,
BuiltinOperator_MIN = BuiltinOperator_ADD,
BuiltinOperator_MAX = BuiltinOperator_SELECT_V2
};
inline const BuiltinOperator (&EnumValuesBuiltinOperator())[124] {
static const BuiltinOperator values[] = {
BuiltinOperator_ADD,
BuiltinOperator_AVERAGE_POOL_2D,
BuiltinOperator_CONCATENATION,
BuiltinOperator_CONV_2D,
BuiltinOperator_DEPTHWISE_CONV_2D,
BuiltinOperator_DEPTH_TO_SPACE,
BuiltinOperator_DEQUANTIZE,
BuiltinOperator_EMBEDDING_LOOKUP,
BuiltinOperator_FLOOR,
BuiltinOperator_FULLY_CONNECTED,
BuiltinOperator_HASHTABLE_LOOKUP,
BuiltinOperator_L2_NORMALIZATION,
BuiltinOperator_L2_POOL_2D,
BuiltinOperator_LOCAL_RESPONSE_NORMALIZATION,
BuiltinOperator_LOGISTIC,
BuiltinOperator_LSH_PROJECTION,
BuiltinOperator_LSTM,
BuiltinOperator_MAX_POOL_2D,
BuiltinOperator_MUL,
BuiltinOperator_RELU,
BuiltinOperator_RELU_N1_TO_1,
BuiltinOperator_RELU6,
BuiltinOperator_RESHAPE,
BuiltinOperator_RESIZE_BILINEAR,
BuiltinOperator_RNN,
BuiltinOperator_SOFTMAX,
BuiltinOperator_SPACE_TO_DEPTH,
BuiltinOperator_SVDF,
BuiltinOperator_TANH,
BuiltinOperator_CONCAT_EMBEDDINGS,
BuiltinOperator_SKIP_GRAM,
BuiltinOperator_CALL,
BuiltinOperator_CUSTOM,
BuiltinOperator_EMBEDDING_LOOKUP_SPARSE,
BuiltinOperator_PAD,
BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_RNN,
BuiltinOperator_GATHER,
BuiltinOperator_BATCH_TO_SPACE_ND,
BuiltinOperator_SPACE_TO_BATCH_ND,
BuiltinOperator_TRANSPOSE,
BuiltinOperator_MEAN,
BuiltinOperator_SUB,
BuiltinOperator_DIV,
BuiltinOperator_SQUEEZE,
BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM,
BuiltinOperator_STRIDED_SLICE,
BuiltinOperator_BIDIRECTIONAL_SEQUENCE_RNN,
BuiltinOperator_EXP,
BuiltinOperator_TOPK_V2,
BuiltinOperator_SPLIT,
BuiltinOperator_LOG_SOFTMAX,
BuiltinOperator_DELEGATE,
BuiltinOperator_BIDIRECTIONAL_SEQUENCE_LSTM,
BuiltinOperator_CAST,
BuiltinOperator_PRELU,
BuiltinOperator_MAXIMUM,
BuiltinOperator_ARG_MAX,
BuiltinOperator_MINIMUM,
BuiltinOperator_LESS,
BuiltinOperator_NEG,
BuiltinOperator_PADV2,
BuiltinOperator_GREATER,
BuiltinOperator_GREATER_EQUAL,
BuiltinOperator_LESS_EQUAL,
BuiltinOperator_SELECT,
BuiltinOperator_SLICE,
BuiltinOperator_SIN,
BuiltinOperator_TRANSPOSE_CONV,
BuiltinOperator_SPARSE_TO_DENSE,
BuiltinOperator_TILE,
BuiltinOperator_EXPAND_DIMS,
BuiltinOperator_EQUAL,
BuiltinOperator_NOT_EQUAL,
BuiltinOperator_LOG,
BuiltinOperator_SUM,
BuiltinOperator_SQRT,
BuiltinOperator_RSQRT,
BuiltinOperator_SHAPE,
BuiltinOperator_POW,
BuiltinOperator_ARG_MIN,
BuiltinOperator_FAKE_QUANT,
BuiltinOperator_REDUCE_PROD,
BuiltinOperator_REDUCE_MAX,
BuiltinOperator_PACK,
BuiltinOperator_LOGICAL_OR,
BuiltinOperator_ONE_HOT,
BuiltinOperator_LOGICAL_AND,
BuiltinOperator_LOGICAL_NOT,
BuiltinOperator_UNPACK,
BuiltinOperator_REDUCE_MIN,
BuiltinOperator_FLOOR_DIV,
BuiltinOperator_REDUCE_ANY,
BuiltinOperator_SQUARE,
BuiltinOperator_ZEROS_LIKE,
BuiltinOperator_FILL,
BuiltinOperator_FLOOR_MOD,
BuiltinOperator_RANGE,
BuiltinOperator_RESIZE_NEAREST_NEIGHBOR,
BuiltinOperator_LEAKY_RELU,
BuiltinOperator_SQUARED_DIFFERENCE,
BuiltinOperator_MIRROR_PAD,
BuiltinOperator_ABS,
BuiltinOperator_SPLIT_V,
BuiltinOperator_UNIQUE,
BuiltinOperator_CEIL,
BuiltinOperator_REVERSE_V2,
BuiltinOperator_ADD_N,
BuiltinOperator_GATHER_ND,
BuiltinOperator_COS,
BuiltinOperator_WHERE,
BuiltinOperator_RANK,
BuiltinOperator_ELU,
BuiltinOperator_REVERSE_SEQUENCE,
BuiltinOperator_MATRIX_DIAG,
BuiltinOperator_QUANTIZE,
BuiltinOperator_MATRIX_SET_DIAG,
BuiltinOperator_ROUND,
BuiltinOperator_HARD_SWISH,
BuiltinOperator_IF,
BuiltinOperator_WHILE,
BuiltinOperator_NON_MAX_SUPPRESSION_V4,
BuiltinOperator_NON_MAX_SUPPRESSION_V5,
BuiltinOperator_SCATTER_ND,
BuiltinOperator_SELECT_V2
};
return values;
}
inline const char * const *EnumNamesBuiltinOperator() {
static const char * const names[] = {
"ADD",
"AVERAGE_POOL_2D",
"CONCATENATION",
"CONV_2D",
"DEPTHWISE_CONV_2D",
"DEPTH_TO_SPACE",
"DEQUANTIZE",
"EMBEDDING_LOOKUP",
"FLOOR",
"FULLY_CONNECTED",
"HASHTABLE_LOOKUP",
"L2_NORMALIZATION",
"L2_POOL_2D",
"LOCAL_RESPONSE_NORMALIZATION",
"LOGISTIC",
"LSH_PROJECTION",
"LSTM",
"MAX_POOL_2D",
"MUL",
"RELU",
"RELU_N1_TO_1",
"RELU6",
"RESHAPE",
"RESIZE_BILINEAR",
"RNN",
"SOFTMAX",
"SPACE_TO_DEPTH",
"SVDF",
"TANH",
"CONCAT_EMBEDDINGS",
"SKIP_GRAM",
"CALL",
"CUSTOM",
"EMBEDDING_LOOKUP_SPARSE",
"PAD",
"UNIDIRECTIONAL_SEQUENCE_RNN",
"GATHER",
"BATCH_TO_SPACE_ND",
"SPACE_TO_BATCH_ND",
"TRANSPOSE",
"MEAN",
"SUB",
"DIV",
"SQUEEZE",
"UNIDIRECTIONAL_SEQUENCE_LSTM",
"STRIDED_SLICE",
"BIDIRECTIONAL_SEQUENCE_RNN",
"EXP",
"TOPK_V2",
"SPLIT",
"LOG_SOFTMAX",
"DELEGATE",
"BIDIRECTIONAL_SEQUENCE_LSTM",
"CAST",
"PRELU",
"MAXIMUM",
"ARG_MAX",
"MINIMUM",
"LESS",
"NEG",
"PADV2",
"GREATER",
"GREATER_EQUAL",
"LESS_EQUAL",
"SELECT",
"SLICE",
"SIN",
"TRANSPOSE_CONV",
"SPARSE_TO_DENSE",
"TILE",
"EXPAND_DIMS",
"EQUAL",
"NOT_EQUAL",
"LOG",
"SUM",
"SQRT",
"RSQRT",
"SHAPE",
"POW",
"ARG_MIN",
"FAKE_QUANT",
"REDUCE_PROD",
"REDUCE_MAX",
"PACK",
"LOGICAL_OR",
"ONE_HOT",
"LOGICAL_AND",
"LOGICAL_NOT",
"UNPACK",
"REDUCE_MIN",
"FLOOR_DIV",
"REDUCE_ANY",
"SQUARE",
"ZEROS_LIKE",
"FILL",
"FLOOR_MOD",
"RANGE",
"RESIZE_NEAREST_NEIGHBOR",
"LEAKY_RELU",
"SQUARED_DIFFERENCE",
"MIRROR_PAD",
"ABS",
"SPLIT_V",
"UNIQUE",
"CEIL",
"REVERSE_V2",
"ADD_N",
"GATHER_ND",
"COS",
"WHERE",
"RANK",
"ELU",
"REVERSE_SEQUENCE",
"MATRIX_DIAG",
"QUANTIZE",
"MATRIX_SET_DIAG",
"ROUND",
"HARD_SWISH",
"IF",
"WHILE",
"NON_MAX_SUPPRESSION_V4",
"NON_MAX_SUPPRESSION_V5",
"SCATTER_ND",
"SELECT_V2",
nullptr
};
return names;
}
inline const char *EnumNameBuiltinOperator(BuiltinOperator e) {
if (e < BuiltinOperator_ADD || e > BuiltinOperator_SELECT_V2) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesBuiltinOperator()[index];
}
enum BuiltinOptions {
BuiltinOptions_NONE = 0,
BuiltinOptions_Conv2DOptions = 1,
BuiltinOptions_DepthwiseConv2DOptions = 2,
BuiltinOptions_ConcatEmbeddingsOptions = 3,
BuiltinOptions_LSHProjectionOptions = 4,
BuiltinOptions_Pool2DOptions = 5,
BuiltinOptions_SVDFOptions = 6,
BuiltinOptions_RNNOptions = 7,
BuiltinOptions_FullyConnectedOptions = 8,
BuiltinOptions_SoftmaxOptions = 9,
BuiltinOptions_ConcatenationOptions = 10,
BuiltinOptions_AddOptions = 11,
BuiltinOptions_L2NormOptions = 12,
BuiltinOptions_LocalResponseNormalizationOptions = 13,
BuiltinOptions_LSTMOptions = 14,
BuiltinOptions_ResizeBilinearOptions = 15,
BuiltinOptions_CallOptions = 16,
BuiltinOptions_ReshapeOptions = 17,
BuiltinOptions_SkipGramOptions = 18,
BuiltinOptions_SpaceToDepthOptions = 19,
BuiltinOptions_EmbeddingLookupSparseOptions = 20,
BuiltinOptions_MulOptions = 21,
BuiltinOptions_PadOptions = 22,
BuiltinOptions_GatherOptions = 23,
BuiltinOptions_BatchToSpaceNDOptions = 24,
BuiltinOptions_SpaceToBatchNDOptions = 25,
BuiltinOptions_TransposeOptions = 26,
BuiltinOptions_ReducerOptions = 27,
BuiltinOptions_SubOptions = 28,
BuiltinOptions_DivOptions = 29,
BuiltinOptions_SqueezeOptions = 30,
BuiltinOptions_SequenceRNNOptions = 31,
BuiltinOptions_StridedSliceOptions = 32,
BuiltinOptions_ExpOptions = 33,
BuiltinOptions_TopKV2Options = 34,
BuiltinOptions_SplitOptions = 35,
BuiltinOptions_LogSoftmaxOptions = 36,
BuiltinOptions_CastOptions = 37,
BuiltinOptions_DequantizeOptions = 38,
BuiltinOptions_MaximumMinimumOptions = 39,
BuiltinOptions_ArgMaxOptions = 40,
BuiltinOptions_LessOptions = 41,
BuiltinOptions_NegOptions = 42,
BuiltinOptions_PadV2Options = 43,
BuiltinOptions_GreaterOptions = 44,
BuiltinOptions_GreaterEqualOptions = 45,
BuiltinOptions_LessEqualOptions = 46,
BuiltinOptions_SelectOptions = 47,
BuiltinOptions_SliceOptions = 48,
BuiltinOptions_TransposeConvOptions = 49,
BuiltinOptions_SparseToDenseOptions = 50,
BuiltinOptions_TileOptions = 51,
BuiltinOptions_ExpandDimsOptions = 52,
BuiltinOptions_EqualOptions = 53,
BuiltinOptions_NotEqualOptions = 54,
BuiltinOptions_ShapeOptions = 55,
BuiltinOptions_PowOptions = 56,
BuiltinOptions_ArgMinOptions = 57,
BuiltinOptions_FakeQuantOptions = 58,
BuiltinOptions_PackOptions = 59,
BuiltinOptions_LogicalOrOptions = 60,
BuiltinOptions_OneHotOptions = 61,
BuiltinOptions_LogicalAndOptions = 62,
BuiltinOptions_LogicalNotOptions = 63,
BuiltinOptions_UnpackOptions = 64,
BuiltinOptions_FloorDivOptions = 65,
BuiltinOptions_SquareOptions = 66,
BuiltinOptions_ZerosLikeOptions = 67,
BuiltinOptions_FillOptions = 68,
BuiltinOptions_BidirectionalSequenceLSTMOptions = 69,
BuiltinOptions_BidirectionalSequenceRNNOptions = 70,
BuiltinOptions_UnidirectionalSequenceLSTMOptions = 71,
BuiltinOptions_FloorModOptions = 72,
BuiltinOptions_RangeOptions = 73,
BuiltinOptions_ResizeNearestNeighborOptions = 74,
BuiltinOptions_LeakyReluOptions = 75,
BuiltinOptions_SquaredDifferenceOptions = 76,
BuiltinOptions_MirrorPadOptions = 77,
BuiltinOptions_AbsOptions = 78,
BuiltinOptions_SplitVOptions = 79,
BuiltinOptions_UniqueOptions = 80,
BuiltinOptions_ReverseV2Options = 81,
BuiltinOptions_AddNOptions = 82,
BuiltinOptions_GatherNdOptions = 83,
BuiltinOptions_CosOptions = 84,
BuiltinOptions_WhereOptions = 85,
BuiltinOptions_RankOptions = 86,
BuiltinOptions_ReverseSequenceOptions = 87,
BuiltinOptions_MatrixDiagOptions = 88,
BuiltinOptions_QuantizeOptions = 89,
BuiltinOptions_MatrixSetDiagOptions = 90,
BuiltinOptions_HardSwishOptions = 91,
BuiltinOptions_IfOptions = 92,
BuiltinOptions_WhileOptions = 93,
BuiltinOptions_DepthToSpaceOptions = 94,
BuiltinOptions_NonMaxSuppressionV4Options = 95,
BuiltinOptions_NonMaxSuppressionV5Options = 96,
BuiltinOptions_ScatterNdOptions = 97,
BuiltinOptions_SelectV2Options = 98,
BuiltinOptions_MIN = BuiltinOptions_NONE,
BuiltinOptions_MAX = BuiltinOptions_SelectV2Options
};
inline const BuiltinOptions (&EnumValuesBuiltinOptions())[99] {
static const BuiltinOptions values[] = {
BuiltinOptions_NONE,
BuiltinOptions_Conv2DOptions,
BuiltinOptions_DepthwiseConv2DOptions,
BuiltinOptions_ConcatEmbeddingsOptions,
BuiltinOptions_LSHProjectionOptions,
BuiltinOptions_Pool2DOptions,
BuiltinOptions_SVDFOptions,
BuiltinOptions_RNNOptions,
BuiltinOptions_FullyConnectedOptions,
BuiltinOptions_SoftmaxOptions,
BuiltinOptions_ConcatenationOptions,
BuiltinOptions_AddOptions,
BuiltinOptions_L2NormOptions,
BuiltinOptions_LocalResponseNormalizationOptions,
BuiltinOptions_LSTMOptions,
BuiltinOptions_ResizeBilinearOptions,
BuiltinOptions_CallOptions,
BuiltinOptions_ReshapeOptions,
BuiltinOptions_SkipGramOptions,
BuiltinOptions_SpaceToDepthOptions,
BuiltinOptions_EmbeddingLookupSparseOptions,
BuiltinOptions_MulOptions,
BuiltinOptions_PadOptions,
BuiltinOptions_GatherOptions,
BuiltinOptions_BatchToSpaceNDOptions,
BuiltinOptions_SpaceToBatchNDOptions,
BuiltinOptions_TransposeOptions,
BuiltinOptions_ReducerOptions,
BuiltinOptions_SubOptions,
BuiltinOptions_DivOptions,
BuiltinOptions_SqueezeOptions,
BuiltinOptions_SequenceRNNOptions,
BuiltinOptions_StridedSliceOptions,
BuiltinOptions_ExpOptions,
BuiltinOptions_TopKV2Options,
BuiltinOptions_SplitOptions,
BuiltinOptions_LogSoftmaxOptions,
BuiltinOptions_CastOptions,
BuiltinOptions_DequantizeOptions,
BuiltinOptions_MaximumMinimumOptions,
BuiltinOptions_ArgMaxOptions,
BuiltinOptions_LessOptions,
BuiltinOptions_NegOptions,
BuiltinOptions_PadV2Options,
BuiltinOptions_GreaterOptions,
BuiltinOptions_GreaterEqualOptions,
BuiltinOptions_LessEqualOptions,
BuiltinOptions_SelectOptions,
BuiltinOptions_SliceOptions,
BuiltinOptions_TransposeConvOptions,
BuiltinOptions_SparseToDenseOptions,
BuiltinOptions_TileOptions,
BuiltinOptions_ExpandDimsOptions,
BuiltinOptions_EqualOptions,
BuiltinOptions_NotEqualOptions,
BuiltinOptions_ShapeOptions,
BuiltinOptions_PowOptions,
BuiltinOptions_ArgMinOptions,
BuiltinOptions_FakeQuantOptions,
BuiltinOptions_PackOptions,
BuiltinOptions_LogicalOrOptions,
BuiltinOptions_OneHotOptions,
BuiltinOptions_LogicalAndOptions,
BuiltinOptions_LogicalNotOptions,
BuiltinOptions_UnpackOptions,
BuiltinOptions_FloorDivOptions,
BuiltinOptions_SquareOptions,
BuiltinOptions_ZerosLikeOptions,
BuiltinOptions_FillOptions,
BuiltinOptions_BidirectionalSequenceLSTMOptions,
BuiltinOptions_BidirectionalSequenceRNNOptions,
BuiltinOptions_UnidirectionalSequenceLSTMOptions,
BuiltinOptions_FloorModOptions,
BuiltinOptions_RangeOptions,
BuiltinOptions_ResizeNearestNeighborOptions,
BuiltinOptions_LeakyReluOptions,
BuiltinOptions_SquaredDifferenceOptions,
BuiltinOptions_MirrorPadOptions,
BuiltinOptions_AbsOptions,
BuiltinOptions_SplitVOptions,
BuiltinOptions_UniqueOptions,
BuiltinOptions_ReverseV2Options,
BuiltinOptions_AddNOptions,
BuiltinOptions_GatherNdOptions,
BuiltinOptions_CosOptions,
BuiltinOptions_WhereOptions,
BuiltinOptions_RankOptions,
BuiltinOptions_ReverseSequenceOptions,
BuiltinOptions_MatrixDiagOptions,
BuiltinOptions_QuantizeOptions,
BuiltinOptions_MatrixSetDiagOptions,
BuiltinOptions_HardSwishOptions,
BuiltinOptions_IfOptions,
BuiltinOptions_WhileOptions,
BuiltinOptions_DepthToSpaceOptions,
BuiltinOptions_NonMaxSuppressionV4Options,
BuiltinOptions_NonMaxSuppressionV5Options,
BuiltinOptions_ScatterNdOptions,
BuiltinOptions_SelectV2Options
};
return values;
}
inline const char * const *EnumNamesBuiltinOptions() {
static const char * const names[] = {
"NONE",
"Conv2DOptions",
"DepthwiseConv2DOptions",
"ConcatEmbeddingsOptions",
"LSHProjectionOptions",
"Pool2DOptions",
"SVDFOptions",
"RNNOptions",
"FullyConnectedOptions",
"SoftmaxOptions",
"ConcatenationOptions",
"AddOptions",
"L2NormOptions",
"LocalResponseNormalizationOptions",
"LSTMOptions",
"ResizeBilinearOptions",
"CallOptions",
"ReshapeOptions",
"SkipGramOptions",
"SpaceToDepthOptions",
"EmbeddingLookupSparseOptions",
"MulOptions",
"PadOptions",
"GatherOptions",
"BatchToSpaceNDOptions",
"SpaceToBatchNDOptions",
"TransposeOptions",
"ReducerOptions",
"SubOptions",
"DivOptions",
"SqueezeOptions",
"SequenceRNNOptions",
"StridedSliceOptions",
"ExpOptions",
"TopKV2Options",
"SplitOptions",
"LogSoftmaxOptions",
"CastOptions",
"DequantizeOptions",
"MaximumMinimumOptions",
"ArgMaxOptions",
"LessOptions",
"NegOptions",
"PadV2Options",
"GreaterOptions",
"GreaterEqualOptions",
"LessEqualOptions",
"SelectOptions",
"SliceOptions",
"TransposeConvOptions",
"SparseToDenseOptions",
"TileOptions",
"ExpandDimsOptions",
"EqualOptions",
"NotEqualOptions",
"ShapeOptions",
"PowOptions",
"ArgMinOptions",
"FakeQuantOptions",
"PackOptions",
"LogicalOrOptions",
"OneHotOptions",
"LogicalAndOptions",
"LogicalNotOptions",
"UnpackOptions",
"FloorDivOptions",
"SquareOptions",
"ZerosLikeOptions",
"FillOptions",
"BidirectionalSequenceLSTMOptions",
"BidirectionalSequenceRNNOptions",
"UnidirectionalSequenceLSTMOptions",
"FloorModOptions",
"RangeOptions",
"ResizeNearestNeighborOptions",
"LeakyReluOptions",
"SquaredDifferenceOptions",
"MirrorPadOptions",
"AbsOptions",
"SplitVOptions",
"UniqueOptions",
"ReverseV2Options",
"AddNOptions",
"GatherNdOptions",
"CosOptions",
"WhereOptions",
"RankOptions",
"ReverseSequenceOptions",
"MatrixDiagOptions",
"QuantizeOptions",
"MatrixSetDiagOptions",
"HardSwishOptions",
"IfOptions",
"WhileOptions",
"DepthToSpaceOptions",
"NonMaxSuppressionV4Options",
"NonMaxSuppressionV5Options",
"ScatterNdOptions",
"SelectV2Options",
nullptr
};
return names;
}
inline const char *EnumNameBuiltinOptions(BuiltinOptions e) {
if (e < BuiltinOptions_NONE || e > BuiltinOptions_SelectV2Options) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesBuiltinOptions()[index];
}
template<typename T> struct BuiltinOptionsTraits {
static const BuiltinOptions enum_value = BuiltinOptions_NONE;
};
template<> struct BuiltinOptionsTraits<Conv2DOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_Conv2DOptions;
};
template<> struct BuiltinOptionsTraits<DepthwiseConv2DOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_DepthwiseConv2DOptions;
};
template<> struct BuiltinOptionsTraits<ConcatEmbeddingsOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_ConcatEmbeddingsOptions;
};
template<> struct BuiltinOptionsTraits<LSHProjectionOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_LSHProjectionOptions;
};
template<> struct BuiltinOptionsTraits<Pool2DOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_Pool2DOptions;
};
template<> struct BuiltinOptionsTraits<SVDFOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_SVDFOptions;
};
template<> struct BuiltinOptionsTraits<RNNOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_RNNOptions;
};
template<> struct BuiltinOptionsTraits<FullyConnectedOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_FullyConnectedOptions;
};
template<> struct BuiltinOptionsTraits<SoftmaxOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_SoftmaxOptions;
};
template<> struct BuiltinOptionsTraits<ConcatenationOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_ConcatenationOptions;
};
template<> struct BuiltinOptionsTraits<AddOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_AddOptions;
};
template<> struct BuiltinOptionsTraits<L2NormOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_L2NormOptions;
};
template<> struct BuiltinOptionsTraits<LocalResponseNormalizationOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_LocalResponseNormalizationOptions;
};
template<> struct BuiltinOptionsTraits<LSTMOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_LSTMOptions;
};
template<> struct BuiltinOptionsTraits<ResizeBilinearOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_ResizeBilinearOptions;
};
template<> struct BuiltinOptionsTraits<CallOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_CallOptions;
};
template<> struct BuiltinOptionsTraits<ReshapeOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_ReshapeOptions;
};
template<> struct BuiltinOptionsTraits<SkipGramOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_SkipGramOptions;
};
template<> struct BuiltinOptionsTraits<SpaceToDepthOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_SpaceToDepthOptions;
};
template<> struct BuiltinOptionsTraits<EmbeddingLookupSparseOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_EmbeddingLookupSparseOptions;
};
template<> struct BuiltinOptionsTraits<MulOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_MulOptions;
};
template<> struct BuiltinOptionsTraits<PadOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_PadOptions;
};
template<> struct BuiltinOptionsTraits<GatherOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_GatherOptions;
};
template<> struct BuiltinOptionsTraits<BatchToSpaceNDOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_BatchToSpaceNDOptions;
};
template<> struct BuiltinOptionsTraits<SpaceToBatchNDOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_SpaceToBatchNDOptions;
};
template<> struct BuiltinOptionsTraits<TransposeOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_TransposeOptions;
};
template<> struct BuiltinOptionsTraits<ReducerOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_ReducerOptions;
};
template<> struct BuiltinOptionsTraits<SubOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_SubOptions;
};
template<> struct BuiltinOptionsTraits<DivOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_DivOptions;
};
template<> struct BuiltinOptionsTraits<SqueezeOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_SqueezeOptions;
};
template<> struct BuiltinOptionsTraits<SequenceRNNOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_SequenceRNNOptions;
};
template<> struct BuiltinOptionsTraits<StridedSliceOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_StridedSliceOptions;
};
template<> struct BuiltinOptionsTraits<ExpOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_ExpOptions;
};
template<> struct BuiltinOptionsTraits<TopKV2Options> {
static const BuiltinOptions enum_value = BuiltinOptions_TopKV2Options;
};
template<> struct BuiltinOptionsTraits<SplitOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_SplitOptions;
};
template<> struct BuiltinOptionsTraits<LogSoftmaxOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_LogSoftmaxOptions;
};
template<> struct BuiltinOptionsTraits<CastOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_CastOptions;
};
template<> struct BuiltinOptionsTraits<DequantizeOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_DequantizeOptions;
};
template<> struct BuiltinOptionsTraits<MaximumMinimumOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_MaximumMinimumOptions;
};
template<> struct BuiltinOptionsTraits<ArgMaxOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_ArgMaxOptions;
};
template<> struct BuiltinOptionsTraits<LessOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_LessOptions;
};
template<> struct BuiltinOptionsTraits<NegOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_NegOptions;
};
template<> struct BuiltinOptionsTraits<PadV2Options> {
static const BuiltinOptions enum_value = BuiltinOptions_PadV2Options;
};
template<> struct BuiltinOptionsTraits<GreaterOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_GreaterOptions;
};
template<> struct BuiltinOptionsTraits<GreaterEqualOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_GreaterEqualOptions;
};
template<> struct BuiltinOptionsTraits<LessEqualOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_LessEqualOptions;
};
template<> struct BuiltinOptionsTraits<SelectOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_SelectOptions;
};
template<> struct BuiltinOptionsTraits<SliceOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_SliceOptions;
};
template<> struct BuiltinOptionsTraits<TransposeConvOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_TransposeConvOptions;
};
template<> struct BuiltinOptionsTraits<SparseToDenseOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_SparseToDenseOptions;
};
template<> struct BuiltinOptionsTraits<TileOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_TileOptions;
};
template<> struct BuiltinOptionsTraits<ExpandDimsOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_ExpandDimsOptions;
};
template<> struct BuiltinOptionsTraits<EqualOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_EqualOptions;
};
template<> struct BuiltinOptionsTraits<NotEqualOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_NotEqualOptions;
};
template<> struct BuiltinOptionsTraits<ShapeOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_ShapeOptions;
};
template<> struct BuiltinOptionsTraits<PowOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_PowOptions;
};
template<> struct BuiltinOptionsTraits<ArgMinOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_ArgMinOptions;
};
template<> struct BuiltinOptionsTraits<FakeQuantOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_FakeQuantOptions;
};
template<> struct BuiltinOptionsTraits<PackOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_PackOptions;
};
template<> struct BuiltinOptionsTraits<LogicalOrOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_LogicalOrOptions;
};
template<> struct BuiltinOptionsTraits<OneHotOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_OneHotOptions;
};
template<> struct BuiltinOptionsTraits<LogicalAndOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_LogicalAndOptions;
};
template<> struct BuiltinOptionsTraits<LogicalNotOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_LogicalNotOptions;
};
template<> struct BuiltinOptionsTraits<UnpackOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_UnpackOptions;
};
template<> struct BuiltinOptionsTraits<FloorDivOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_FloorDivOptions;
};
template<> struct BuiltinOptionsTraits<SquareOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_SquareOptions;
};
template<> struct BuiltinOptionsTraits<ZerosLikeOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_ZerosLikeOptions;
};
template<> struct BuiltinOptionsTraits<FillOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_FillOptions;
};
template<> struct BuiltinOptionsTraits<BidirectionalSequenceLSTMOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_BidirectionalSequenceLSTMOptions;
};
template<> struct BuiltinOptionsTraits<BidirectionalSequenceRNNOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_BidirectionalSequenceRNNOptions;
};
template<> struct BuiltinOptionsTraits<UnidirectionalSequenceLSTMOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_UnidirectionalSequenceLSTMOptions;
};
template<> struct BuiltinOptionsTraits<FloorModOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_FloorModOptions;
};
template<> struct BuiltinOptionsTraits<RangeOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_RangeOptions;
};
template<> struct BuiltinOptionsTraits<ResizeNearestNeighborOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_ResizeNearestNeighborOptions;
};
template<> struct BuiltinOptionsTraits<LeakyReluOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_LeakyReluOptions;
};
template<> struct BuiltinOptionsTraits<SquaredDifferenceOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_SquaredDifferenceOptions;
};
template<> struct BuiltinOptionsTraits<MirrorPadOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_MirrorPadOptions;
};
template<> struct BuiltinOptionsTraits<AbsOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_AbsOptions;
};
template<> struct BuiltinOptionsTraits<SplitVOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_SplitVOptions;
};
template<> struct BuiltinOptionsTraits<UniqueOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_UniqueOptions;
};
template<> struct BuiltinOptionsTraits<ReverseV2Options> {
static const BuiltinOptions enum_value = BuiltinOptions_ReverseV2Options;
};
template<> struct BuiltinOptionsTraits<AddNOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_AddNOptions;
};
template<> struct BuiltinOptionsTraits<GatherNdOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_GatherNdOptions;
};
template<> struct BuiltinOptionsTraits<CosOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_CosOptions;
};
template<> struct BuiltinOptionsTraits<WhereOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_WhereOptions;
};
template<> struct BuiltinOptionsTraits<RankOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_RankOptions;
};
template<> struct BuiltinOptionsTraits<ReverseSequenceOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_ReverseSequenceOptions;
};
template<> struct BuiltinOptionsTraits<MatrixDiagOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_MatrixDiagOptions;
};
template<> struct BuiltinOptionsTraits<QuantizeOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_QuantizeOptions;
};
template<> struct BuiltinOptionsTraits<MatrixSetDiagOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_MatrixSetDiagOptions;
};
template<> struct BuiltinOptionsTraits<HardSwishOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_HardSwishOptions;
};
template<> struct BuiltinOptionsTraits<IfOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_IfOptions;
};
template<> struct BuiltinOptionsTraits<WhileOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_WhileOptions;
};
template<> struct BuiltinOptionsTraits<DepthToSpaceOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_DepthToSpaceOptions;
};
template<> struct BuiltinOptionsTraits<NonMaxSuppressionV4Options> {
static const BuiltinOptions enum_value = BuiltinOptions_NonMaxSuppressionV4Options;
};
template<> struct BuiltinOptionsTraits<NonMaxSuppressionV5Options> {
static const BuiltinOptions enum_value = BuiltinOptions_NonMaxSuppressionV5Options;
};
template<> struct BuiltinOptionsTraits<ScatterNdOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_ScatterNdOptions;
};
template<> struct BuiltinOptionsTraits<SelectV2Options> {
static const BuiltinOptions enum_value = BuiltinOptions_SelectV2Options;
};
struct BuiltinOptionsUnion {
BuiltinOptions type;
void *value;
BuiltinOptionsUnion() : type(BuiltinOptions_NONE), value(nullptr) {}
BuiltinOptionsUnion(BuiltinOptionsUnion&& u) FLATBUFFERS_NOEXCEPT :
type(BuiltinOptions_NONE), value(nullptr)
{ std::swap(type, u.type); std::swap(value, u.value); }
BuiltinOptionsUnion(const BuiltinOptionsUnion &) FLATBUFFERS_NOEXCEPT;
BuiltinOptionsUnion &operator=(const BuiltinOptionsUnion &u) FLATBUFFERS_NOEXCEPT
{ BuiltinOptionsUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
BuiltinOptionsUnion &operator=(BuiltinOptionsUnion &&u) FLATBUFFERS_NOEXCEPT
{ std::swap(type, u.type); std::swap(value, u.value); return *this; }
~BuiltinOptionsUnion() { Reset(); }
void Reset();
#ifndef FLATBUFFERS_CPP98_STL
template <typename T>
void Set(T&& val) {
using RT = typename std::remove_reference<T>::type;
Reset();
type = BuiltinOptionsTraits<typename RT::TableType>::enum_value;
if (type != BuiltinOptions_NONE) {
value = new RT(std::forward<T>(val));
}
}
#endif // FLATBUFFERS_CPP98_STL
static void *UnPack(const void *obj, BuiltinOptions type, const flatbuffers::resolver_function_t *resolver);
flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
Conv2DOptionsT *AsConv2DOptions() {
return type == BuiltinOptions_Conv2DOptions ?
reinterpret_cast<Conv2DOptionsT *>(value) : nullptr;
}
const Conv2DOptionsT *AsConv2DOptions() const {
return type == BuiltinOptions_Conv2DOptions ?
reinterpret_cast<const Conv2DOptionsT *>(value) : nullptr;
}
DepthwiseConv2DOptionsT *AsDepthwiseConv2DOptions() {
return type == BuiltinOptions_DepthwiseConv2DOptions ?
reinterpret_cast<DepthwiseConv2DOptionsT *>(value) : nullptr;
}
const DepthwiseConv2DOptionsT *AsDepthwiseConv2DOptions() const {
return type == BuiltinOptions_DepthwiseConv2DOptions ?
reinterpret_cast<const DepthwiseConv2DOptionsT *>(value) : nullptr;
}
ConcatEmbeddingsOptionsT *AsConcatEmbeddingsOptions() {
return type == BuiltinOptions_ConcatEmbeddingsOptions ?
reinterpret_cast<ConcatEmbeddingsOptionsT *>(value) : nullptr;
}
const ConcatEmbeddingsOptionsT *AsConcatEmbeddingsOptions() const {
return type == BuiltinOptions_ConcatEmbeddingsOptions ?
reinterpret_cast<const ConcatEmbeddingsOptionsT *>(value) : nullptr;
}
LSHProjectionOptionsT *AsLSHProjectionOptions() {
return type == BuiltinOptions_LSHProjectionOptions ?
reinterpret_cast<LSHProjectionOptionsT *>(value) : nullptr;
}
const LSHProjectionOptionsT *AsLSHProjectionOptions() const {
return type == BuiltinOptions_LSHProjectionOptions ?
reinterpret_cast<const LSHProjectionOptionsT *>(value) : nullptr;
}
Pool2DOptionsT *AsPool2DOptions() {
return type == BuiltinOptions_Pool2DOptions ?
reinterpret_cast<Pool2DOptionsT *>(value) : nullptr;
}
const Pool2DOptionsT *AsPool2DOptions() const {
return type == BuiltinOptions_Pool2DOptions ?
reinterpret_cast<const Pool2DOptionsT *>(value) : nullptr;
}
SVDFOptionsT *AsSVDFOptions() {
return type == BuiltinOptions_SVDFOptions ?
reinterpret_cast<SVDFOptionsT *>(value) : nullptr;
}
const SVDFOptionsT *AsSVDFOptions() const {
return type == BuiltinOptions_SVDFOptions ?
reinterpret_cast<const SVDFOptionsT *>(value) : nullptr;
}
RNNOptionsT *AsRNNOptions() {
return type == BuiltinOptions_RNNOptions ?
reinterpret_cast<RNNOptionsT *>(value) : nullptr;
}
const RNNOptionsT *AsRNNOptions() const {
return type == BuiltinOptions_RNNOptions ?
reinterpret_cast<const RNNOptionsT *>(value) : nullptr;
}
FullyConnectedOptionsT *AsFullyConnectedOptions() {
return type == BuiltinOptions_FullyConnectedOptions ?
reinterpret_cast<FullyConnectedOptionsT *>(value) : nullptr;
}
const FullyConnectedOptionsT *AsFullyConnectedOptions() const {
return type == BuiltinOptions_FullyConnectedOptions ?
reinterpret_cast<const FullyConnectedOptionsT *>(value) : nullptr;
}
SoftmaxOptionsT *AsSoftmaxOptions() {
return type == BuiltinOptions_SoftmaxOptions ?
reinterpret_cast<SoftmaxOptionsT *>(value) : nullptr;
}
const SoftmaxOptionsT *AsSoftmaxOptions() const {
return type == BuiltinOptions_SoftmaxOptions ?
reinterpret_cast<const SoftmaxOptionsT *>(value) : nullptr;
}
ConcatenationOptionsT *AsConcatenationOptions() {
return type == BuiltinOptions_ConcatenationOptions ?
reinterpret_cast<ConcatenationOptionsT *>(value) : nullptr;
}
const ConcatenationOptionsT *AsConcatenationOptions() const {
return type == BuiltinOptions_ConcatenationOptions ?
reinterpret_cast<const ConcatenationOptionsT *>(value) : nullptr;
}
AddOptionsT *AsAddOptions() {
return type == BuiltinOptions_AddOptions ?
reinterpret_cast<AddOptionsT *>(value) : nullptr;
}
const AddOptionsT *AsAddOptions() const {
return type == BuiltinOptions_AddOptions ?
reinterpret_cast<const AddOptionsT *>(value) : nullptr;
}
L2NormOptionsT *AsL2NormOptions() {
return type == BuiltinOptions_L2NormOptions ?
reinterpret_cast<L2NormOptionsT *>(value) : nullptr;
}
const L2NormOptionsT *AsL2NormOptions() const {
return type == BuiltinOptions_L2NormOptions ?
reinterpret_cast<const L2NormOptionsT *>(value) : nullptr;
}
LocalResponseNormalizationOptionsT *AsLocalResponseNormalizationOptions() {
return type == BuiltinOptions_LocalResponseNormalizationOptions ?
reinterpret_cast<LocalResponseNormalizationOptionsT *>(value) : nullptr;
}
const LocalResponseNormalizationOptionsT *AsLocalResponseNormalizationOptions() const {
return type == BuiltinOptions_LocalResponseNormalizationOptions ?
reinterpret_cast<const LocalResponseNormalizationOptionsT *>(value) : nullptr;
}
LSTMOptionsT *AsLSTMOptions() {
return type == BuiltinOptions_LSTMOptions ?
reinterpret_cast<LSTMOptionsT *>(value) : nullptr;
}
const LSTMOptionsT *AsLSTMOptions() const {
return type == BuiltinOptions_LSTMOptions ?
reinterpret_cast<const LSTMOptionsT *>(value) : nullptr;
}
ResizeBilinearOptionsT *AsResizeBilinearOptions() {
return type == BuiltinOptions_ResizeBilinearOptions ?
reinterpret_cast<ResizeBilinearOptionsT *>(value) : nullptr;
}
const ResizeBilinearOptionsT *AsResizeBilinearOptions() const {
return type == BuiltinOptions_ResizeBilinearOptions ?
reinterpret_cast<const ResizeBilinearOptionsT *>(value) : nullptr;
}
CallOptionsT *AsCallOptions() {
return type == BuiltinOptions_CallOptions ?
reinterpret_cast<CallOptionsT *>(value) : nullptr;
}
const CallOptionsT *AsCallOptions() const {
return type == BuiltinOptions_CallOptions ?
reinterpret_cast<const CallOptionsT *>(value) : nullptr;
}
ReshapeOptionsT *AsReshapeOptions() {
return type == BuiltinOptions_ReshapeOptions ?
reinterpret_cast<ReshapeOptionsT *>(value) : nullptr;
}
const ReshapeOptionsT *AsReshapeOptions() const {
return type == BuiltinOptions_ReshapeOptions ?
reinterpret_cast<const ReshapeOptionsT *>(value) : nullptr;
}
SkipGramOptionsT *AsSkipGramOptions() {
return type == BuiltinOptions_SkipGramOptions ?
reinterpret_cast<SkipGramOptionsT *>(value) : nullptr;
}
const SkipGramOptionsT *AsSkipGramOptions() const {
return type == BuiltinOptions_SkipGramOptions ?
reinterpret_cast<const SkipGramOptionsT *>(value) : nullptr;
}
SpaceToDepthOptionsT *AsSpaceToDepthOptions() {
return type == BuiltinOptions_SpaceToDepthOptions ?
reinterpret_cast<SpaceToDepthOptionsT *>(value) : nullptr;
}
const SpaceToDepthOptionsT *AsSpaceToDepthOptions() const {
return type == BuiltinOptions_SpaceToDepthOptions ?
reinterpret_cast<const SpaceToDepthOptionsT *>(value) : nullptr;
}
EmbeddingLookupSparseOptionsT *AsEmbeddingLookupSparseOptions() {
return type == BuiltinOptions_EmbeddingLookupSparseOptions ?
reinterpret_cast<EmbeddingLookupSparseOptionsT *>(value) : nullptr;
}
const EmbeddingLookupSparseOptionsT *AsEmbeddingLookupSparseOptions() const {
return type == BuiltinOptions_EmbeddingLookupSparseOptions ?
reinterpret_cast<const EmbeddingLookupSparseOptionsT *>(value) : nullptr;
}
MulOptionsT *AsMulOptions() {
return type == BuiltinOptions_MulOptions ?
reinterpret_cast<MulOptionsT *>(value) : nullptr;
}
const MulOptionsT *AsMulOptions() const {
return type == BuiltinOptions_MulOptions ?
reinterpret_cast<const MulOptionsT *>(value) : nullptr;
}
PadOptionsT *AsPadOptions() {
return type == BuiltinOptions_PadOptions ?
reinterpret_cast<PadOptionsT *>(value) : nullptr;
}
const PadOptionsT *AsPadOptions() const {
return type == BuiltinOptions_PadOptions ?
reinterpret_cast<const PadOptionsT *>(value) : nullptr;
}
GatherOptionsT *AsGatherOptions() {
return type == BuiltinOptions_GatherOptions ?
reinterpret_cast<GatherOptionsT *>(value) : nullptr;
}
const GatherOptionsT *AsGatherOptions() const {
return type == BuiltinOptions_GatherOptions ?
reinterpret_cast<const GatherOptionsT *>(value) : nullptr;
}
BatchToSpaceNDOptionsT *AsBatchToSpaceNDOptions() {
return type == BuiltinOptions_BatchToSpaceNDOptions ?
reinterpret_cast<BatchToSpaceNDOptionsT *>(value) : nullptr;
}
const BatchToSpaceNDOptionsT *AsBatchToSpaceNDOptions() const {
return type == BuiltinOptions_BatchToSpaceNDOptions ?
reinterpret_cast<const BatchToSpaceNDOptionsT *>(value) : nullptr;
}
SpaceToBatchNDOptionsT *AsSpaceToBatchNDOptions() {
return type == BuiltinOptions_SpaceToBatchNDOptions ?
reinterpret_cast<SpaceToBatchNDOptionsT *>(value) : nullptr;
}
const SpaceToBatchNDOptionsT *AsSpaceToBatchNDOptions() const {
return type == BuiltinOptions_SpaceToBatchNDOptions ?
reinterpret_cast<const SpaceToBatchNDOptionsT *>(value) : nullptr;
}
TransposeOptionsT *AsTransposeOptions() {
return type == BuiltinOptions_TransposeOptions ?
reinterpret_cast<TransposeOptionsT *>(value) : nullptr;
}
const TransposeOptionsT *AsTransposeOptions() const {
return type == BuiltinOptions_TransposeOptions ?
reinterpret_cast<const TransposeOptionsT *>(value) : nullptr;
}
ReducerOptionsT *AsReducerOptions() {
return type == BuiltinOptions_ReducerOptions ?
reinterpret_cast<ReducerOptionsT *>(value) : nullptr;
}
const ReducerOptionsT *AsReducerOptions() const {
return type == BuiltinOptions_ReducerOptions ?
reinterpret_cast<const ReducerOptionsT *>(value) : nullptr;
}
SubOptionsT *AsSubOptions() {
return type == BuiltinOptions_SubOptions ?
reinterpret_cast<SubOptionsT *>(value) : nullptr;
}
const SubOptionsT *AsSubOptions() const {
return type == BuiltinOptions_SubOptions ?
reinterpret_cast<const SubOptionsT *>(value) : nullptr;
}
DivOptionsT *AsDivOptions() {
return type == BuiltinOptions_DivOptions ?
reinterpret_cast<DivOptionsT *>(value) : nullptr;
}
const DivOptionsT *AsDivOptions() const {
return type == BuiltinOptions_DivOptions ?
reinterpret_cast<const DivOptionsT *>(value) : nullptr;
}
SqueezeOptionsT *AsSqueezeOptions() {
return type == BuiltinOptions_SqueezeOptions ?
reinterpret_cast<SqueezeOptionsT *>(value) : nullptr;
}
const SqueezeOptionsT *AsSqueezeOptions() const {
return type == BuiltinOptions_SqueezeOptions ?
reinterpret_cast<const SqueezeOptionsT *>(value) : nullptr;
}
SequenceRNNOptionsT *AsSequenceRNNOptions() {
return type == BuiltinOptions_SequenceRNNOptions ?
reinterpret_cast<SequenceRNNOptionsT *>(value) : nullptr;
}
const SequenceRNNOptionsT *AsSequenceRNNOptions() const {
return type == BuiltinOptions_SequenceRNNOptions ?
reinterpret_cast<const SequenceRNNOptionsT *>(value) : nullptr;
}
StridedSliceOptionsT *AsStridedSliceOptions() {
return type == BuiltinOptions_StridedSliceOptions ?
reinterpret_cast<StridedSliceOptionsT *>(value) : nullptr;
}
const StridedSliceOptionsT *AsStridedSliceOptions() const {
return type == BuiltinOptions_StridedSliceOptions ?
reinterpret_cast<const StridedSliceOptionsT *>(value) : nullptr;
}
ExpOptionsT *AsExpOptions() {
return type == BuiltinOptions_ExpOptions ?
reinterpret_cast<ExpOptionsT *>(value) : nullptr;
}
const ExpOptionsT *AsExpOptions() const {
return type == BuiltinOptions_ExpOptions ?
reinterpret_cast<const ExpOptionsT *>(value) : nullptr;
}
TopKV2OptionsT *AsTopKV2Options() {
return type == BuiltinOptions_TopKV2Options ?
reinterpret_cast<TopKV2OptionsT *>(value) : nullptr;
}
const TopKV2OptionsT *AsTopKV2Options() const {
return type == BuiltinOptions_TopKV2Options ?
reinterpret_cast<const TopKV2OptionsT *>(value) : nullptr;
}
SplitOptionsT *AsSplitOptions() {
return type == BuiltinOptions_SplitOptions ?
reinterpret_cast<SplitOptionsT *>(value) : nullptr;
}
const SplitOptionsT *AsSplitOptions() const {
return type == BuiltinOptions_SplitOptions ?
reinterpret_cast<const SplitOptionsT *>(value) : nullptr;
}
LogSoftmaxOptionsT *AsLogSoftmaxOptions() {
return type == BuiltinOptions_LogSoftmaxOptions ?
reinterpret_cast<LogSoftmaxOptionsT *>(value) : nullptr;
}
const LogSoftmaxOptionsT *AsLogSoftmaxOptions() const {
return type == BuiltinOptions_LogSoftmaxOptions ?
reinterpret_cast<const LogSoftmaxOptionsT *>(value) : nullptr;
}
CastOptionsT *AsCastOptions() {
return type == BuiltinOptions_CastOptions ?
reinterpret_cast<CastOptionsT *>(value) : nullptr;
}
const CastOptionsT *AsCastOptions() const {
return type == BuiltinOptions_CastOptions ?
reinterpret_cast<const CastOptionsT *>(value) : nullptr;
}
DequantizeOptionsT *AsDequantizeOptions() {
return type == BuiltinOptions_DequantizeOptions ?
reinterpret_cast<DequantizeOptionsT *>(value) : nullptr;
}
const DequantizeOptionsT *AsDequantizeOptions() const {
return type == BuiltinOptions_DequantizeOptions ?
reinterpret_cast<const DequantizeOptionsT *>(value) : nullptr;
}
MaximumMinimumOptionsT *AsMaximumMinimumOptions() {
return type == BuiltinOptions_MaximumMinimumOptions ?
reinterpret_cast<MaximumMinimumOptionsT *>(value) : nullptr;
}
const MaximumMinimumOptionsT *AsMaximumMinimumOptions() const {
return type == BuiltinOptions_MaximumMinimumOptions ?
reinterpret_cast<const MaximumMinimumOptionsT *>(value) : nullptr;
}
ArgMaxOptionsT *AsArgMaxOptions() {
return type == BuiltinOptions_ArgMaxOptions ?
reinterpret_cast<ArgMaxOptionsT *>(value) : nullptr;
}
const ArgMaxOptionsT *AsArgMaxOptions() const {
return type == BuiltinOptions_ArgMaxOptions ?
reinterpret_cast<const ArgMaxOptionsT *>(value) : nullptr;
}
LessOptionsT *AsLessOptions() {
return type == BuiltinOptions_LessOptions ?
reinterpret_cast<LessOptionsT *>(value) : nullptr;
}
const LessOptionsT *AsLessOptions() const {
return type == BuiltinOptions_LessOptions ?
reinterpret_cast<const LessOptionsT *>(value) : nullptr;
}
NegOptionsT *AsNegOptions() {
return type == BuiltinOptions_NegOptions ?
reinterpret_cast<NegOptionsT *>(value) : nullptr;
}
const NegOptionsT *AsNegOptions() const {
return type == BuiltinOptions_NegOptions ?
reinterpret_cast<const NegOptionsT *>(value) : nullptr;
}
PadV2OptionsT *AsPadV2Options() {
return type == BuiltinOptions_PadV2Options ?
reinterpret_cast<PadV2OptionsT *>(value) : nullptr;
}
const PadV2OptionsT *AsPadV2Options() const {
return type == BuiltinOptions_PadV2Options ?
reinterpret_cast<const PadV2OptionsT *>(value) : nullptr;
}
GreaterOptionsT *AsGreaterOptions() {
return type == BuiltinOptions_GreaterOptions ?
reinterpret_cast<GreaterOptionsT *>(value) : nullptr;
}
const GreaterOptionsT *AsGreaterOptions() const {
return type == BuiltinOptions_GreaterOptions ?
reinterpret_cast<const GreaterOptionsT *>(value) : nullptr;
}
GreaterEqualOptionsT *AsGreaterEqualOptions() {
return type == BuiltinOptions_GreaterEqualOptions ?
reinterpret_cast<GreaterEqualOptionsT *>(value) : nullptr;
}
const GreaterEqualOptionsT *AsGreaterEqualOptions() const {
return type == BuiltinOptions_GreaterEqualOptions ?
reinterpret_cast<const GreaterEqualOptionsT *>(value) : nullptr;
}
LessEqualOptionsT *AsLessEqualOptions() {
return type == BuiltinOptions_LessEqualOptions ?
reinterpret_cast<LessEqualOptionsT *>(value) : nullptr;
}
const LessEqualOptionsT *AsLessEqualOptions() const {
return type == BuiltinOptions_LessEqualOptions ?
reinterpret_cast<const LessEqualOptionsT *>(value) : nullptr;
}
SelectOptionsT *AsSelectOptions() {
return type == BuiltinOptions_SelectOptions ?
reinterpret_cast<SelectOptionsT *>(value) : nullptr;
}
const SelectOptionsT *AsSelectOptions() const {
return type == BuiltinOptions_SelectOptions ?
reinterpret_cast<const SelectOptionsT *>(value) : nullptr;
}
SliceOptionsT *AsSliceOptions() {
return type == BuiltinOptions_SliceOptions ?
reinterpret_cast<SliceOptionsT *>(value) : nullptr;
}
const SliceOptionsT *AsSliceOptions() const {
return type == BuiltinOptions_SliceOptions ?
reinterpret_cast<const SliceOptionsT *>(value) : nullptr;
}
TransposeConvOptionsT *AsTransposeConvOptions() {
return type == BuiltinOptions_TransposeConvOptions ?
reinterpret_cast<TransposeConvOptionsT *>(value) : nullptr;
}
const TransposeConvOptionsT *AsTransposeConvOptions() const {
return type == BuiltinOptions_TransposeConvOptions ?
reinterpret_cast<const TransposeConvOptionsT *>(value) : nullptr;
}
SparseToDenseOptionsT *AsSparseToDenseOptions() {
return type == BuiltinOptions_SparseToDenseOptions ?
reinterpret_cast<SparseToDenseOptionsT *>(value) : nullptr;
}
const SparseToDenseOptionsT *AsSparseToDenseOptions() const {
return type == BuiltinOptions_SparseToDenseOptions ?
reinterpret_cast<const SparseToDenseOptionsT *>(value) : nullptr;
}
TileOptionsT *AsTileOptions() {
return type == BuiltinOptions_TileOptions ?
reinterpret_cast<TileOptionsT *>(value) : nullptr;
}
const TileOptionsT *AsTileOptions() const {
return type == BuiltinOptions_TileOptions ?
reinterpret_cast<const TileOptionsT *>(value) : nullptr;
}
ExpandDimsOptionsT *AsExpandDimsOptions() {
return type == BuiltinOptions_ExpandDimsOptions ?
reinterpret_cast<ExpandDimsOptionsT *>(value) : nullptr;
}
const ExpandDimsOptionsT *AsExpandDimsOptions() const {
return type == BuiltinOptions_ExpandDimsOptions ?
reinterpret_cast<const ExpandDimsOptionsT *>(value) : nullptr;
}
EqualOptionsT *AsEqualOptions() {
return type == BuiltinOptions_EqualOptions ?
reinterpret_cast<EqualOptionsT *>(value) : nullptr;
}
const EqualOptionsT *AsEqualOptions() const {
return type == BuiltinOptions_EqualOptions ?
reinterpret_cast<const EqualOptionsT *>(value) : nullptr;
}
NotEqualOptionsT *AsNotEqualOptions() {
return type == BuiltinOptions_NotEqualOptions ?
reinterpret_cast<NotEqualOptionsT *>(value) : nullptr;
}
const NotEqualOptionsT *AsNotEqualOptions() const {
return type == BuiltinOptions_NotEqualOptions ?
reinterpret_cast<const NotEqualOptionsT *>(value) : nullptr;
}
ShapeOptionsT *AsShapeOptions() {
return type == BuiltinOptions_ShapeOptions ?
reinterpret_cast<ShapeOptionsT *>(value) : nullptr;
}
const ShapeOptionsT *AsShapeOptions() const {
return type == BuiltinOptions_ShapeOptions ?
reinterpret_cast<const ShapeOptionsT *>(value) : nullptr;
}
PowOptionsT *AsPowOptions() {
return type == BuiltinOptions_PowOptions ?
reinterpret_cast<PowOptionsT *>(value) : nullptr;
}
const PowOptionsT *AsPowOptions() const {
return type == BuiltinOptions_PowOptions ?
reinterpret_cast<const PowOptionsT *>(value) : nullptr;
}
ArgMinOptionsT *AsArgMinOptions() {
return type == BuiltinOptions_ArgMinOptions ?
reinterpret_cast<ArgMinOptionsT *>(value) : nullptr;
}
const ArgMinOptionsT *AsArgMinOptions() const {
return type == BuiltinOptions_ArgMinOptions ?
reinterpret_cast<const ArgMinOptionsT *>(value) : nullptr;
}
FakeQuantOptionsT *AsFakeQuantOptions() {
return type == BuiltinOptions_FakeQuantOptions ?
reinterpret_cast<FakeQuantOptionsT *>(value) : nullptr;
}
const FakeQuantOptionsT *AsFakeQuantOptions() const {
return type == BuiltinOptions_FakeQuantOptions ?
reinterpret_cast<const FakeQuantOptionsT *>(value) : nullptr;
}
PackOptionsT *AsPackOptions() {
return type == BuiltinOptions_PackOptions ?
reinterpret_cast<PackOptionsT *>(value) : nullptr;
}
const PackOptionsT *AsPackOptions() const {
return type == BuiltinOptions_PackOptions ?
reinterpret_cast<const PackOptionsT *>(value) : nullptr;
}
LogicalOrOptionsT *AsLogicalOrOptions() {
return type == BuiltinOptions_LogicalOrOptions ?
reinterpret_cast<LogicalOrOptionsT *>(value) : nullptr;
}
const LogicalOrOptionsT *AsLogicalOrOptions() const {
return type == BuiltinOptions_LogicalOrOptions ?
reinterpret_cast<const LogicalOrOptionsT *>(value) : nullptr;
}
OneHotOptionsT *AsOneHotOptions() {
return type == BuiltinOptions_OneHotOptions ?
reinterpret_cast<OneHotOptionsT *>(value) : nullptr;
}
const OneHotOptionsT *AsOneHotOptions() const {
return type == BuiltinOptions_OneHotOptions ?
reinterpret_cast<const OneHotOptionsT *>(value) : nullptr;
}
LogicalAndOptionsT *AsLogicalAndOptions() {
return type == BuiltinOptions_LogicalAndOptions ?
reinterpret_cast<LogicalAndOptionsT *>(value) : nullptr;
}
const LogicalAndOptionsT *AsLogicalAndOptions() const {
return type == BuiltinOptions_LogicalAndOptions ?
reinterpret_cast<const LogicalAndOptionsT *>(value) : nullptr;
}
LogicalNotOptionsT *AsLogicalNotOptions() {
return type == BuiltinOptions_LogicalNotOptions ?
reinterpret_cast<LogicalNotOptionsT *>(value) : nullptr;
}
const LogicalNotOptionsT *AsLogicalNotOptions() const {
return type == BuiltinOptions_LogicalNotOptions ?
reinterpret_cast<const LogicalNotOptionsT *>(value) : nullptr;
}
UnpackOptionsT *AsUnpackOptions() {
return type == BuiltinOptions_UnpackOptions ?
reinterpret_cast<UnpackOptionsT *>(value) : nullptr;
}
const UnpackOptionsT *AsUnpackOptions() const {
return type == BuiltinOptions_UnpackOptions ?
reinterpret_cast<const UnpackOptionsT *>(value) : nullptr;
}
FloorDivOptionsT *AsFloorDivOptions() {
return type == BuiltinOptions_FloorDivOptions ?
reinterpret_cast<FloorDivOptionsT *>(value) : nullptr;
}
const FloorDivOptionsT *AsFloorDivOptions() const {
return type == BuiltinOptions_FloorDivOptions ?
reinterpret_cast<const FloorDivOptionsT *>(value) : nullptr;
}
SquareOptionsT *AsSquareOptions() {
return type == BuiltinOptions_SquareOptions ?
reinterpret_cast<SquareOptionsT *>(value) : nullptr;
}
const SquareOptionsT *AsSquareOptions() const {
return type == BuiltinOptions_SquareOptions ?
reinterpret_cast<const SquareOptionsT *>(value) : nullptr;
}
ZerosLikeOptionsT *AsZerosLikeOptions() {
return type == BuiltinOptions_ZerosLikeOptions ?
reinterpret_cast<ZerosLikeOptionsT *>(value) : nullptr;
}
const ZerosLikeOptionsT *AsZerosLikeOptions() const {
return type == BuiltinOptions_ZerosLikeOptions ?
reinterpret_cast<const ZerosLikeOptionsT *>(value) : nullptr;
}
FillOptionsT *AsFillOptions() {
return type == BuiltinOptions_FillOptions ?
reinterpret_cast<FillOptionsT *>(value) : nullptr;
}
const FillOptionsT *AsFillOptions() const {
return type == BuiltinOptions_FillOptions ?
reinterpret_cast<const FillOptionsT *>(value) : nullptr;
}
BidirectionalSequenceLSTMOptionsT *AsBidirectionalSequenceLSTMOptions() {
return type == BuiltinOptions_BidirectionalSequenceLSTMOptions ?
reinterpret_cast<BidirectionalSequenceLSTMOptionsT *>(value) : nullptr;
}
const BidirectionalSequenceLSTMOptionsT *AsBidirectionalSequenceLSTMOptions() const {
return type == BuiltinOptions_BidirectionalSequenceLSTMOptions ?
reinterpret_cast<const BidirectionalSequenceLSTMOptionsT *>(value) : nullptr;
}
BidirectionalSequenceRNNOptionsT *AsBidirectionalSequenceRNNOptions() {
return type == BuiltinOptions_BidirectionalSequenceRNNOptions ?
reinterpret_cast<BidirectionalSequenceRNNOptionsT *>(value) : nullptr;
}
const BidirectionalSequenceRNNOptionsT *AsBidirectionalSequenceRNNOptions() const {
return type == BuiltinOptions_BidirectionalSequenceRNNOptions ?
reinterpret_cast<const BidirectionalSequenceRNNOptionsT *>(value) : nullptr;
}
UnidirectionalSequenceLSTMOptionsT *AsUnidirectionalSequenceLSTMOptions() {
return type == BuiltinOptions_UnidirectionalSequenceLSTMOptions ?
reinterpret_cast<UnidirectionalSequenceLSTMOptionsT *>(value) : nullptr;
}
const UnidirectionalSequenceLSTMOptionsT *AsUnidirectionalSequenceLSTMOptions() const {
return type == BuiltinOptions_UnidirectionalSequenceLSTMOptions ?
reinterpret_cast<const UnidirectionalSequenceLSTMOptionsT *>(value) : nullptr;
}
FloorModOptionsT *AsFloorModOptions() {
return type == BuiltinOptions_FloorModOptions ?
reinterpret_cast<FloorModOptionsT *>(value) : nullptr;
}
const FloorModOptionsT *AsFloorModOptions() const {
return type == BuiltinOptions_FloorModOptions ?
reinterpret_cast<const FloorModOptionsT *>(value) : nullptr;
}
RangeOptionsT *AsRangeOptions() {
return type == BuiltinOptions_RangeOptions ?
reinterpret_cast<RangeOptionsT *>(value) : nullptr;
}
const RangeOptionsT *AsRangeOptions() const {
return type == BuiltinOptions_RangeOptions ?
reinterpret_cast<const RangeOptionsT *>(value) : nullptr;
}
ResizeNearestNeighborOptionsT *AsResizeNearestNeighborOptions() {
return type == BuiltinOptions_ResizeNearestNeighborOptions ?
reinterpret_cast<ResizeNearestNeighborOptionsT *>(value) : nullptr;
}
const ResizeNearestNeighborOptionsT *AsResizeNearestNeighborOptions() const {
return type == BuiltinOptions_ResizeNearestNeighborOptions ?
reinterpret_cast<const ResizeNearestNeighborOptionsT *>(value) : nullptr;
}
LeakyReluOptionsT *AsLeakyReluOptions() {
return type == BuiltinOptions_LeakyReluOptions ?
reinterpret_cast<LeakyReluOptionsT *>(value) : nullptr;
}
const LeakyReluOptionsT *AsLeakyReluOptions() const {
return type == BuiltinOptions_LeakyReluOptions ?
reinterpret_cast<const LeakyReluOptionsT *>(value) : nullptr;
}
SquaredDifferenceOptionsT *AsSquaredDifferenceOptions() {
return type == BuiltinOptions_SquaredDifferenceOptions ?
reinterpret_cast<SquaredDifferenceOptionsT *>(value) : nullptr;
}
const SquaredDifferenceOptionsT *AsSquaredDifferenceOptions() const {
return type == BuiltinOptions_SquaredDifferenceOptions ?
reinterpret_cast<const SquaredDifferenceOptionsT *>(value) : nullptr;
}
MirrorPadOptionsT *AsMirrorPadOptions() {
return type == BuiltinOptions_MirrorPadOptions ?
reinterpret_cast<MirrorPadOptionsT *>(value) : nullptr;
}
const MirrorPadOptionsT *AsMirrorPadOptions() const {
return type == BuiltinOptions_MirrorPadOptions ?
reinterpret_cast<const MirrorPadOptionsT *>(value) : nullptr;
}
AbsOptionsT *AsAbsOptions() {
return type == BuiltinOptions_AbsOptions ?
reinterpret_cast<AbsOptionsT *>(value) : nullptr;
}
const AbsOptionsT *AsAbsOptions() const {
return type == BuiltinOptions_AbsOptions ?
reinterpret_cast<const AbsOptionsT *>(value) : nullptr;
}
SplitVOptionsT *AsSplitVOptions() {
return type == BuiltinOptions_SplitVOptions ?
reinterpret_cast<SplitVOptionsT *>(value) : nullptr;
}
const SplitVOptionsT *AsSplitVOptions() const {
return type == BuiltinOptions_SplitVOptions ?
reinterpret_cast<const SplitVOptionsT *>(value) : nullptr;
}
UniqueOptionsT *AsUniqueOptions() {
return type == BuiltinOptions_UniqueOptions ?
reinterpret_cast<UniqueOptionsT *>(value) : nullptr;
}
const UniqueOptionsT *AsUniqueOptions() const {
return type == BuiltinOptions_UniqueOptions ?
reinterpret_cast<const UniqueOptionsT *>(value) : nullptr;
}
ReverseV2OptionsT *AsReverseV2Options() {
return type == BuiltinOptions_ReverseV2Options ?
reinterpret_cast<ReverseV2OptionsT *>(value) : nullptr;
}
const ReverseV2OptionsT *AsReverseV2Options() const {
return type == BuiltinOptions_ReverseV2Options ?
reinterpret_cast<const ReverseV2OptionsT *>(value) : nullptr;
}
AddNOptionsT *AsAddNOptions() {
return type == BuiltinOptions_AddNOptions ?
reinterpret_cast<AddNOptionsT *>(value) : nullptr;
}
const AddNOptionsT *AsAddNOptions() const {
return type == BuiltinOptions_AddNOptions ?
reinterpret_cast<const AddNOptionsT *>(value) : nullptr;
}
GatherNdOptionsT *AsGatherNdOptions() {
return type == BuiltinOptions_GatherNdOptions ?
reinterpret_cast<GatherNdOptionsT *>(value) : nullptr;
}
const GatherNdOptionsT *AsGatherNdOptions() const {
return type == BuiltinOptions_GatherNdOptions ?
reinterpret_cast<const GatherNdOptionsT *>(value) : nullptr;
}
CosOptionsT *AsCosOptions() {
return type == BuiltinOptions_CosOptions ?
reinterpret_cast<CosOptionsT *>(value) : nullptr;
}
const CosOptionsT *AsCosOptions() const {
return type == BuiltinOptions_CosOptions ?
reinterpret_cast<const CosOptionsT *>(value) : nullptr;
}
WhereOptionsT *AsWhereOptions() {
return type == BuiltinOptions_WhereOptions ?
reinterpret_cast<WhereOptionsT *>(value) : nullptr;
}
const WhereOptionsT *AsWhereOptions() const {
return type == BuiltinOptions_WhereOptions ?
reinterpret_cast<const WhereOptionsT *>(value) : nullptr;
}
RankOptionsT *AsRankOptions() {
return type == BuiltinOptions_RankOptions ?
reinterpret_cast<RankOptionsT *>(value) : nullptr;
}
const RankOptionsT *AsRankOptions() const {
return type == BuiltinOptions_RankOptions ?
reinterpret_cast<const RankOptionsT *>(value) : nullptr;
}
ReverseSequenceOptionsT *AsReverseSequenceOptions() {
return type == BuiltinOptions_ReverseSequenceOptions ?
reinterpret_cast<ReverseSequenceOptionsT *>(value) : nullptr;
}
const ReverseSequenceOptionsT *AsReverseSequenceOptions() const {
return type == BuiltinOptions_ReverseSequenceOptions ?
reinterpret_cast<const ReverseSequenceOptionsT *>(value) : nullptr;
}
MatrixDiagOptionsT *AsMatrixDiagOptions() {
return type == BuiltinOptions_MatrixDiagOptions ?
reinterpret_cast<MatrixDiagOptionsT *>(value) : nullptr;
}
const MatrixDiagOptionsT *AsMatrixDiagOptions() const {
return type == BuiltinOptions_MatrixDiagOptions ?
reinterpret_cast<const MatrixDiagOptionsT *>(value) : nullptr;
}
QuantizeOptionsT *AsQuantizeOptions() {
return type == BuiltinOptions_QuantizeOptions ?
reinterpret_cast<QuantizeOptionsT *>(value) : nullptr;
}
const QuantizeOptionsT *AsQuantizeOptions() const {
return type == BuiltinOptions_QuantizeOptions ?
reinterpret_cast<const QuantizeOptionsT *>(value) : nullptr;
}
MatrixSetDiagOptionsT *AsMatrixSetDiagOptions() {
return type == BuiltinOptions_MatrixSetDiagOptions ?
reinterpret_cast<MatrixSetDiagOptionsT *>(value) : nullptr;
}
const MatrixSetDiagOptionsT *AsMatrixSetDiagOptions() const {
return type == BuiltinOptions_MatrixSetDiagOptions ?
reinterpret_cast<const MatrixSetDiagOptionsT *>(value) : nullptr;
}
HardSwishOptionsT *AsHardSwishOptions() {
return type == BuiltinOptions_HardSwishOptions ?
reinterpret_cast<HardSwishOptionsT *>(value) : nullptr;
}
const HardSwishOptionsT *AsHardSwishOptions() const {
return type == BuiltinOptions_HardSwishOptions ?
reinterpret_cast<const HardSwishOptionsT *>(value) : nullptr;
}
IfOptionsT *AsIfOptions() {
return type == BuiltinOptions_IfOptions ?
reinterpret_cast<IfOptionsT *>(value) : nullptr;
}
const IfOptionsT *AsIfOptions() const {
return type == BuiltinOptions_IfOptions ?
reinterpret_cast<const IfOptionsT *>(value) : nullptr;
}
WhileOptionsT *AsWhileOptions() {
return type == BuiltinOptions_WhileOptions ?
reinterpret_cast<WhileOptionsT *>(value) : nullptr;
}
const WhileOptionsT *AsWhileOptions() const {
return type == BuiltinOptions_WhileOptions ?
reinterpret_cast<const WhileOptionsT *>(value) : nullptr;
}
DepthToSpaceOptionsT *AsDepthToSpaceOptions() {
return type == BuiltinOptions_DepthToSpaceOptions ?
reinterpret_cast<DepthToSpaceOptionsT *>(value) : nullptr;
}
const DepthToSpaceOptionsT *AsDepthToSpaceOptions() const {
return type == BuiltinOptions_DepthToSpaceOptions ?
reinterpret_cast<const DepthToSpaceOptionsT *>(value) : nullptr;
}
NonMaxSuppressionV4OptionsT *AsNonMaxSuppressionV4Options() {
return type == BuiltinOptions_NonMaxSuppressionV4Options ?
reinterpret_cast<NonMaxSuppressionV4OptionsT *>(value) : nullptr;
}
const NonMaxSuppressionV4OptionsT *AsNonMaxSuppressionV4Options() const {
return type == BuiltinOptions_NonMaxSuppressionV4Options ?
reinterpret_cast<const NonMaxSuppressionV4OptionsT *>(value) : nullptr;
}
NonMaxSuppressionV5OptionsT *AsNonMaxSuppressionV5Options() {
return type == BuiltinOptions_NonMaxSuppressionV5Options ?
reinterpret_cast<NonMaxSuppressionV5OptionsT *>(value) : nullptr;
}
const NonMaxSuppressionV5OptionsT *AsNonMaxSuppressionV5Options() const {
return type == BuiltinOptions_NonMaxSuppressionV5Options ?
reinterpret_cast<const NonMaxSuppressionV5OptionsT *>(value) : nullptr;
}
ScatterNdOptionsT *AsScatterNdOptions() {
return type == BuiltinOptions_ScatterNdOptions ?
reinterpret_cast<ScatterNdOptionsT *>(value) : nullptr;
}
const ScatterNdOptionsT *AsScatterNdOptions() const {
return type == BuiltinOptions_ScatterNdOptions ?
reinterpret_cast<const ScatterNdOptionsT *>(value) : nullptr;
}
SelectV2OptionsT *AsSelectV2Options() {
return type == BuiltinOptions_SelectV2Options ?
reinterpret_cast<SelectV2OptionsT *>(value) : nullptr;
}
const SelectV2OptionsT *AsSelectV2Options() const {
return type == BuiltinOptions_SelectV2Options ?
reinterpret_cast<const SelectV2OptionsT *>(value) : nullptr;
}
};
bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type);
bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
enum Padding {
Padding_SAME = 0,
Padding_VALID = 1,
Padding_MIN = Padding_SAME,
Padding_MAX = Padding_VALID
};
inline const Padding (&EnumValuesPadding())[2] {
static const Padding values[] = {
Padding_SAME,
Padding_VALID
};
return values;
}
inline const char * const *EnumNamesPadding() {
static const char * const names[] = {
"SAME",
"VALID",
nullptr
};
return names;
}
inline const char *EnumNamePadding(Padding e) {
if (e < Padding_SAME || e > Padding_VALID) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesPadding()[index];
}
enum ActivationFunctionType {
ActivationFunctionType_NONE = 0,
ActivationFunctionType_RELU = 1,
ActivationFunctionType_RELU_N1_TO_1 = 2,
ActivationFunctionType_RELU6 = 3,
ActivationFunctionType_TANH = 4,
ActivationFunctionType_SIGN_BIT = 5,
ActivationFunctionType_MIN = ActivationFunctionType_NONE,
ActivationFunctionType_MAX = ActivationFunctionType_SIGN_BIT
};
inline const ActivationFunctionType (&EnumValuesActivationFunctionType())[6] {
static const ActivationFunctionType values[] = {
ActivationFunctionType_NONE,
ActivationFunctionType_RELU,
ActivationFunctionType_RELU_N1_TO_1,
ActivationFunctionType_RELU6,
ActivationFunctionType_TANH,
ActivationFunctionType_SIGN_BIT
};
return values;
}
inline const char * const *EnumNamesActivationFunctionType() {
static const char * const names[] = {
"NONE",
"RELU",
"RELU_N1_TO_1",
"RELU6",
"TANH",
"SIGN_BIT",
nullptr
};
return names;
}
inline const char *EnumNameActivationFunctionType(ActivationFunctionType e) {
if (e < ActivationFunctionType_NONE || e > ActivationFunctionType_SIGN_BIT) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesActivationFunctionType()[index];
}
enum LSHProjectionType {
LSHProjectionType_UNKNOWN = 0,
LSHProjectionType_SPARSE = 1,
LSHProjectionType_DENSE = 2,
LSHProjectionType_MIN = LSHProjectionType_UNKNOWN,
LSHProjectionType_MAX = LSHProjectionType_DENSE
};
inline const LSHProjectionType (&EnumValuesLSHProjectionType())[3] {
static const LSHProjectionType values[] = {
LSHProjectionType_UNKNOWN,
LSHProjectionType_SPARSE,
LSHProjectionType_DENSE
};
return values;
}
inline const char * const *EnumNamesLSHProjectionType() {
static const char * const names[] = {
"UNKNOWN",
"SPARSE",
"DENSE",
nullptr
};
return names;
}
inline const char *EnumNameLSHProjectionType(LSHProjectionType e) {
if (e < LSHProjectionType_UNKNOWN || e > LSHProjectionType_DENSE) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesLSHProjectionType()[index];
}
enum FullyConnectedOptionsWeightsFormat {
FullyConnectedOptionsWeightsFormat_DEFAULT = 0,
FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8 = 1,
FullyConnectedOptionsWeightsFormat_MIN = FullyConnectedOptionsWeightsFormat_DEFAULT,
FullyConnectedOptionsWeightsFormat_MAX = FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8
};
inline const FullyConnectedOptionsWeightsFormat (&EnumValuesFullyConnectedOptionsWeightsFormat())[2] {
static const FullyConnectedOptionsWeightsFormat values[] = {
FullyConnectedOptionsWeightsFormat_DEFAULT,
FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8
};
return values;
}
inline const char * const *EnumNamesFullyConnectedOptionsWeightsFormat() {
static const char * const names[] = {
"DEFAULT",
"SHUFFLED4x16INT8",
nullptr
};
return names;
}
inline const char *EnumNameFullyConnectedOptionsWeightsFormat(FullyConnectedOptionsWeightsFormat e) {
if (e < FullyConnectedOptionsWeightsFormat_DEFAULT || e > FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesFullyConnectedOptionsWeightsFormat()[index];
}
enum LSTMKernelType {
LSTMKernelType_FULL = 0,
LSTMKernelType_BASIC = 1,
LSTMKernelType_MIN = LSTMKernelType_FULL,
LSTMKernelType_MAX = LSTMKernelType_BASIC
};
inline const LSTMKernelType (&EnumValuesLSTMKernelType())[2] {
static const LSTMKernelType values[] = {
LSTMKernelType_FULL,
LSTMKernelType_BASIC
};
return values;
}
inline const char * const *EnumNamesLSTMKernelType() {
static const char * const names[] = {
"FULL",
"BASIC",
nullptr
};
return names;
}
inline const char *EnumNameLSTMKernelType(LSTMKernelType e) {
if (e < LSTMKernelType_FULL || e > LSTMKernelType_BASIC) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesLSTMKernelType()[index];
}
enum CombinerType {
CombinerType_SUM = 0,
CombinerType_MEAN = 1,
CombinerType_SQRTN = 2,
CombinerType_MIN = CombinerType_SUM,
CombinerType_MAX = CombinerType_SQRTN
};
inline const CombinerType (&EnumValuesCombinerType())[3] {
static const CombinerType values[] = {
CombinerType_SUM,
CombinerType_MEAN,
CombinerType_SQRTN
};
return values;
}
inline const char * const *EnumNamesCombinerType() {
static const char * const names[] = {
"SUM",
"MEAN",
"SQRTN",
nullptr
};
return names;
}
inline const char *EnumNameCombinerType(CombinerType e) {
if (e < CombinerType_SUM || e > CombinerType_SQRTN) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesCombinerType()[index];
}
enum MirrorPadMode {
MirrorPadMode_REFLECT = 0,
MirrorPadMode_SYMMETRIC = 1,
MirrorPadMode_MIN = MirrorPadMode_REFLECT,
MirrorPadMode_MAX = MirrorPadMode_SYMMETRIC
};
inline const MirrorPadMode (&EnumValuesMirrorPadMode())[2] {
static const MirrorPadMode values[] = {
MirrorPadMode_REFLECT,
MirrorPadMode_SYMMETRIC
};
return values;
}
inline const char * const *EnumNamesMirrorPadMode() {
static const char * const names[] = {
"REFLECT",
"SYMMETRIC",
nullptr
};
return names;
}
inline const char *EnumNameMirrorPadMode(MirrorPadMode e) {
if (e < MirrorPadMode_REFLECT || e > MirrorPadMode_SYMMETRIC) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesMirrorPadMode()[index];
}
enum CustomOptionsFormat {
CustomOptionsFormat_FLEXBUFFERS = 0,
CustomOptionsFormat_MIN = CustomOptionsFormat_FLEXBUFFERS,
CustomOptionsFormat_MAX = CustomOptionsFormat_FLEXBUFFERS
};
inline const CustomOptionsFormat (&EnumValuesCustomOptionsFormat())[1] {
static const CustomOptionsFormat values[] = {
CustomOptionsFormat_FLEXBUFFERS
};
return values;
}
inline const char * const *EnumNamesCustomOptionsFormat() {
static const char * const names[] = {
"FLEXBUFFERS",
nullptr
};
return names;
}
inline const char *EnumNameCustomOptionsFormat(CustomOptionsFormat e) {
if (e < CustomOptionsFormat_FLEXBUFFERS || e > CustomOptionsFormat_FLEXBUFFERS) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesCustomOptionsFormat()[index];
}
struct CustomQuantizationT : public flatbuffers::NativeTable {
typedef CustomQuantization TableType;
std::vector<uint8_t> custom;
CustomQuantizationT() {
}
};
struct CustomQuantization FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef CustomQuantizationT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_CUSTOM = 4
};
const flatbuffers::Vector<uint8_t> *custom() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CUSTOM);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_CUSTOM) &&
verifier.VerifyVector(custom()) &&
verifier.EndTable();
}
CustomQuantizationT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(CustomQuantizationT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<CustomQuantization> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct CustomQuantizationBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_custom(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom) {
fbb_.AddOffset(CustomQuantization::VT_CUSTOM, custom);
}
explicit CustomQuantizationBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
CustomQuantizationBuilder &operator=(const CustomQuantizationBuilder &);
flatbuffers::Offset<CustomQuantization> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<CustomQuantization>(end);
return o;
}
};
inline flatbuffers::Offset<CustomQuantization> CreateCustomQuantization(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom = 0) {
CustomQuantizationBuilder builder_(_fbb);
builder_.add_custom(custom);
return builder_.Finish();
}
inline flatbuffers::Offset<CustomQuantization> CreateCustomQuantizationDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *custom = nullptr) {
auto custom__ = custom ? _fbb.CreateVector<uint8_t>(*custom) : 0;
return tflite::CreateCustomQuantization(
_fbb,
custom__);
}
flatbuffers::Offset<CustomQuantization> CreateCustomQuantization(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct QuantizationParametersT : public flatbuffers::NativeTable {
typedef QuantizationParameters TableType;
std::vector<float> min;
std::vector<float> max;
std::vector<float> scale;
std::vector<int64_t> zero_point;
QuantizationDetailsUnion details;
int32_t quantized_dimension;
QuantizationParametersT()
: quantized_dimension(0) {
}
};
struct QuantizationParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef QuantizationParametersT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_MIN = 4,
VT_MAX = 6,
VT_SCALE = 8,
VT_ZERO_POINT = 10,
VT_DETAILS_TYPE = 12,
VT_DETAILS = 14,
VT_QUANTIZED_DIMENSION = 16
};
const flatbuffers::Vector<float> *min() const {
return GetPointer<const flatbuffers::Vector<float> *>(VT_MIN);
}
const flatbuffers::Vector<float> *max() const {
return GetPointer<const flatbuffers::Vector<float> *>(VT_MAX);
}
const flatbuffers::Vector<float> *scale() const {
return GetPointer<const flatbuffers::Vector<float> *>(VT_SCALE);
}
const flatbuffers::Vector<int64_t> *zero_point() const {
return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_ZERO_POINT);
}
QuantizationDetails details_type() const {
return static_cast<QuantizationDetails>(GetField<uint8_t>(VT_DETAILS_TYPE, 0));
}
const void *details() const {
return GetPointer<const void *>(VT_DETAILS);
}
template<typename T> const T *details_as() const;
const CustomQuantization *details_as_CustomQuantization() const {
return details_type() == QuantizationDetails_CustomQuantization ? static_cast<const CustomQuantization *>(details()) : nullptr;
}
int32_t quantized_dimension() const {
return GetField<int32_t>(VT_QUANTIZED_DIMENSION, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_MIN) &&
verifier.VerifyVector(min()) &&
VerifyOffset(verifier, VT_MAX) &&
verifier.VerifyVector(max()) &&
VerifyOffset(verifier, VT_SCALE) &&
verifier.VerifyVector(scale()) &&
VerifyOffset(verifier, VT_ZERO_POINT) &&
verifier.VerifyVector(zero_point()) &&
VerifyField<uint8_t>(verifier, VT_DETAILS_TYPE) &&
VerifyOffset(verifier, VT_DETAILS) &&
VerifyQuantizationDetails(verifier, details(), details_type()) &&
VerifyField<int32_t>(verifier, VT_QUANTIZED_DIMENSION) &&
verifier.EndTable();
}
QuantizationParametersT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(QuantizationParametersT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<QuantizationParameters> Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
template<> inline const CustomQuantization *QuantizationParameters::details_as<CustomQuantization>() const {
return details_as_CustomQuantization();
}
struct QuantizationParametersBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_min(flatbuffers::Offset<flatbuffers::Vector<float>> min) {
fbb_.AddOffset(QuantizationParameters::VT_MIN, min);
}
void add_max(flatbuffers::Offset<flatbuffers::Vector<float>> max) {
fbb_.AddOffset(QuantizationParameters::VT_MAX, max);
}
void add_scale(flatbuffers::Offset<flatbuffers::Vector<float>> scale) {
fbb_.AddOffset(QuantizationParameters::VT_SCALE, scale);
}
void add_zero_point(flatbuffers::Offset<flatbuffers::Vector<int64_t>> zero_point) {
fbb_.AddOffset(QuantizationParameters::VT_ZERO_POINT, zero_point);
}
void add_details_type(QuantizationDetails details_type) {
fbb_.AddElement<uint8_t>(QuantizationParameters::VT_DETAILS_TYPE, static_cast<uint8_t>(details_type), 0);
}
void add_details(flatbuffers::Offset<void> details) {
fbb_.AddOffset(QuantizationParameters::VT_DETAILS, details);
}
void add_quantized_dimension(int32_t quantized_dimension) {
fbb_.AddElement<int32_t>(QuantizationParameters::VT_QUANTIZED_DIMENSION, quantized_dimension, 0);
}
explicit QuantizationParametersBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
QuantizationParametersBuilder &operator=(const QuantizationParametersBuilder &);
flatbuffers::Offset<QuantizationParameters> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<QuantizationParameters>(end);
return o;
}
};
inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<float>> min = 0,
flatbuffers::Offset<flatbuffers::Vector<float>> max = 0,
flatbuffers::Offset<flatbuffers::Vector<float>> scale = 0,
flatbuffers::Offset<flatbuffers::Vector<int64_t>> zero_point = 0,
QuantizationDetails details_type = QuantizationDetails_NONE,
flatbuffers::Offset<void> details = 0,
int32_t quantized_dimension = 0) {
QuantizationParametersBuilder builder_(_fbb);
builder_.add_quantized_dimension(quantized_dimension);
builder_.add_details(details);
builder_.add_zero_point(zero_point);
builder_.add_scale(scale);
builder_.add_max(max);
builder_.add_min(min);
builder_.add_details_type(details_type);
return builder_.Finish();
}
inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParametersDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<float> *min = nullptr,
const std::vector<float> *max = nullptr,
const std::vector<float> *scale = nullptr,
const std::vector<int64_t> *zero_point = nullptr,
QuantizationDetails details_type = QuantizationDetails_NONE,
flatbuffers::Offset<void> details = 0,
int32_t quantized_dimension = 0) {
auto min__ = min ? _fbb.CreateVector<float>(*min) : 0;
auto max__ = max ? _fbb.CreateVector<float>(*max) : 0;
auto scale__ = scale ? _fbb.CreateVector<float>(*scale) : 0;
auto zero_point__ = zero_point ? _fbb.CreateVector<int64_t>(*zero_point) : 0;
return tflite::CreateQuantizationParameters(
_fbb,
min__,
max__,
scale__,
zero_point__,
details_type,
details,
quantized_dimension);
}
flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct DimensionMetadataT : public flatbuffers::NativeTable {
typedef DimensionMetadata TableType;
DimensionType format;
int32_t dense_size;
std::vector<int32_t> array_segments;
std::vector<int32_t> array_indices;
DimensionMetadataT()
: format(DimensionType_DENSE),
dense_size(0) {
}
};
struct DimensionMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef DimensionMetadataT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_FORMAT = 4,
VT_DENSE_SIZE = 6,
VT_ARRAY_SEGMENTS = 8,
VT_ARRAY_INDICES = 10
};
DimensionType format() const {
return static_cast<DimensionType>(GetField<int8_t>(VT_FORMAT, 0));
}
int32_t dense_size() const {
return GetField<int32_t>(VT_DENSE_SIZE, 0);
}
const flatbuffers::Vector<int32_t> *array_segments() const {
return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_ARRAY_SEGMENTS);
}
const flatbuffers::Vector<int32_t> *array_indices() const {
return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_ARRAY_INDICES);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FORMAT) &&
VerifyField<int32_t>(verifier, VT_DENSE_SIZE) &&
VerifyOffset(verifier, VT_ARRAY_SEGMENTS) &&
verifier.VerifyVector(array_segments()) &&
VerifyOffset(verifier, VT_ARRAY_INDICES) &&
verifier.VerifyVector(array_indices()) &&
verifier.EndTable();
}
DimensionMetadataT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(DimensionMetadataT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<DimensionMetadata> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct DimensionMetadataBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_format(DimensionType format) {
fbb_.AddElement<int8_t>(DimensionMetadata::VT_FORMAT, static_cast<int8_t>(format), 0);
}
void add_dense_size(int32_t dense_size) {
fbb_.AddElement<int32_t>(DimensionMetadata::VT_DENSE_SIZE, dense_size, 0);
}
void add_array_segments(flatbuffers::Offset<flatbuffers::Vector<int32_t>> array_segments) {
fbb_.AddOffset(DimensionMetadata::VT_ARRAY_SEGMENTS, array_segments);
}
void add_array_indices(flatbuffers::Offset<flatbuffers::Vector<int32_t>> array_indices) {
fbb_.AddOffset(DimensionMetadata::VT_ARRAY_INDICES, array_indices);
}
explicit DimensionMetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
DimensionMetadataBuilder &operator=(const DimensionMetadataBuilder &);
flatbuffers::Offset<DimensionMetadata> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<DimensionMetadata>(end);
return o;
}
};
inline flatbuffers::Offset<DimensionMetadata> CreateDimensionMetadata(
flatbuffers::FlatBufferBuilder &_fbb,
DimensionType format = DimensionType_DENSE,
int32_t dense_size = 0,
flatbuffers::Offset<flatbuffers::Vector<int32_t>> array_segments = 0,
flatbuffers::Offset<flatbuffers::Vector<int32_t>> array_indices = 0) {
DimensionMetadataBuilder builder_(_fbb);
builder_.add_array_indices(array_indices);
builder_.add_array_segments(array_segments);
builder_.add_dense_size(dense_size);
builder_.add_format(format);
return builder_.Finish();
}
inline flatbuffers::Offset<DimensionMetadata> CreateDimensionMetadataDirect(
flatbuffers::FlatBufferBuilder &_fbb,
DimensionType format = DimensionType_DENSE,
int32_t dense_size = 0,
const std::vector<int32_t> *array_segments = nullptr,
const std::vector<int32_t> *array_indices = nullptr) {
auto array_segments__ = array_segments ? _fbb.CreateVector<int32_t>(*array_segments) : 0;
auto array_indices__ = array_indices ? _fbb.CreateVector<int32_t>(*array_indices) : 0;
return tflite::CreateDimensionMetadata(
_fbb,
format,
dense_size,
array_segments__,
array_indices__);
}
flatbuffers::Offset<DimensionMetadata> CreateDimensionMetadata(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct SparsityParametersT : public flatbuffers::NativeTable {
typedef SparsityParameters TableType;
std::vector<int32_t> traversal_order;
std::vector<int32_t> block_map;
std::vector<std::unique_ptr<DimensionMetadataT>> dim_metadata;
SparsityParametersT() {
}
};
struct SparsityParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SparsityParametersT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_TRAVERSAL_ORDER = 4,
VT_BLOCK_MAP = 6,
VT_DIM_METADATA = 8
};
const flatbuffers::Vector<int32_t> *traversal_order() const {
return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_TRAVERSAL_ORDER);
}
const flatbuffers::Vector<int32_t> *block_map() const {
return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_BLOCK_MAP);
}
const flatbuffers::Vector<flatbuffers::Offset<DimensionMetadata>> *dim_metadata() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<DimensionMetadata>> *>(VT_DIM_METADATA);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_TRAVERSAL_ORDER) &&
verifier.VerifyVector(traversal_order()) &&
VerifyOffset(verifier, VT_BLOCK_MAP) &&
verifier.VerifyVector(block_map()) &&
VerifyOffset(verifier, VT_DIM_METADATA) &&
verifier.VerifyVector(dim_metadata()) &&
verifier.VerifyVectorOfTables(dim_metadata()) &&
verifier.EndTable();
}
SparsityParametersT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(SparsityParametersT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<SparsityParameters> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct SparsityParametersBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_traversal_order(flatbuffers::Offset<flatbuffers::Vector<int32_t>> traversal_order) {
fbb_.AddOffset(SparsityParameters::VT_TRAVERSAL_ORDER, traversal_order);
}
void add_block_map(flatbuffers::Offset<flatbuffers::Vector<int32_t>> block_map) {
fbb_.AddOffset(SparsityParameters::VT_BLOCK_MAP, block_map);
}
void add_dim_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<DimensionMetadata>>> dim_metadata) {
fbb_.AddOffset(SparsityParameters::VT_DIM_METADATA, dim_metadata);
}
explicit SparsityParametersBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SparsityParametersBuilder &operator=(const SparsityParametersBuilder &);
flatbuffers::Offset<SparsityParameters> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<SparsityParameters>(end);
return o;
}
};
inline flatbuffers::Offset<SparsityParameters> CreateSparsityParameters(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<int32_t>> traversal_order = 0,
flatbuffers::Offset<flatbuffers::Vector<int32_t>> block_map = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<DimensionMetadata>>> dim_metadata = 0) {
SparsityParametersBuilder builder_(_fbb);
builder_.add_dim_metadata(dim_metadata);
builder_.add_block_map(block_map);
builder_.add_traversal_order(traversal_order);
return builder_.Finish();
}
inline flatbuffers::Offset<SparsityParameters> CreateSparsityParametersDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<int32_t> *traversal_order = nullptr,
const std::vector<int32_t> *block_map = nullptr,
const std::vector<flatbuffers::Offset<DimensionMetadata>> *dim_metadata = nullptr) {
auto traversal_order__ = traversal_order ? _fbb.CreateVector<int32_t>(*traversal_order) : 0;
auto block_map__ = block_map ? _fbb.CreateVector<int32_t>(*block_map) : 0;
auto dim_metadata__ = dim_metadata ? _fbb.CreateVector<flatbuffers::Offset<DimensionMetadata>>(*dim_metadata) : 0;
return tflite::CreateSparsityParameters(
_fbb,
traversal_order__,
block_map__,
dim_metadata__);
}
flatbuffers::Offset<SparsityParameters> CreateSparsityParameters(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct TensorT : public flatbuffers::NativeTable {
typedef Tensor TableType;
std::vector<int32_t> shape;
TensorType type;
uint32_t buffer;
std::string name;
std::unique_ptr<QuantizationParametersT> quantization;
bool is_variable;
std::unique_ptr<SparsityParametersT> sparsity;
TensorT()
: type(TensorType_FLOAT32),
buffer(0),
is_variable(false) {
}
};
struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef TensorT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_SHAPE = 4,
VT_TYPE = 6,
VT_BUFFER = 8,
VT_NAME = 10,
VT_QUANTIZATION = 12,
VT_IS_VARIABLE = 14,
VT_SPARSITY = 16
};
const flatbuffers::Vector<int32_t> *shape() const {
return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE);
}
TensorType type() const {
return static_cast<TensorType>(GetField<int8_t>(VT_TYPE, 0));
}
uint32_t buffer() const {
return GetField<uint32_t>(VT_BUFFER, 0);
}
const flatbuffers::String *name() const {
return GetPointer<const flatbuffers::String *>(VT_NAME);
}
const QuantizationParameters *quantization() const {
return GetPointer<const QuantizationParameters *>(VT_QUANTIZATION);
}
bool is_variable() const {
return GetField<uint8_t>(VT_IS_VARIABLE, 0) != 0;
}
const SparsityParameters *sparsity() const {
return GetPointer<const SparsityParameters *>(VT_SPARSITY);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_SHAPE) &&
verifier.VerifyVector(shape()) &&
VerifyField<int8_t>(verifier, VT_TYPE) &&
VerifyField<uint32_t>(verifier, VT_BUFFER) &&
VerifyOffset(verifier, VT_NAME) &&
verifier.VerifyString(name()) &&
VerifyOffset(verifier, VT_QUANTIZATION) &&
verifier.VerifyTable(quantization()) &&
VerifyField<uint8_t>(verifier, VT_IS_VARIABLE) &&
VerifyOffset(verifier, VT_SPARSITY) &&
verifier.VerifyTable(sparsity()) &&
verifier.EndTable();
}
TensorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(TensorT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<Tensor> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct TensorBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape) {
fbb_.AddOffset(Tensor::VT_SHAPE, shape);
}
void add_type(TensorType type) {
fbb_.AddElement<int8_t>(Tensor::VT_TYPE, static_cast<int8_t>(type), 0);
}
void add_buffer(uint32_t buffer) {
fbb_.AddElement<uint32_t>(Tensor::VT_BUFFER, buffer, 0);
}
void add_name(flatbuffers::Offset<flatbuffers::String> name) {
fbb_.AddOffset(Tensor::VT_NAME, name);
}
void add_quantization(flatbuffers::Offset<QuantizationParameters> quantization) {
fbb_.AddOffset(Tensor::VT_QUANTIZATION, quantization);
}
void add_is_variable(bool is_variable) {
fbb_.AddElement<uint8_t>(Tensor::VT_IS_VARIABLE, static_cast<uint8_t>(is_variable), 0);
}
void add_sparsity(flatbuffers::Offset<SparsityParameters> sparsity) {
fbb_.AddOffset(Tensor::VT_SPARSITY, sparsity);
}
explicit TensorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
TensorBuilder &operator=(const TensorBuilder &);
flatbuffers::Offset<Tensor> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Tensor>(end);
return o;
}
};
inline flatbuffers::Offset<Tensor> CreateTensor(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape = 0,
TensorType type = TensorType_FLOAT32,
uint32_t buffer = 0,
flatbuffers::Offset<flatbuffers::String> name = 0,
flatbuffers::Offset<QuantizationParameters> quantization = 0,
bool is_variable = false,
flatbuffers::Offset<SparsityParameters> sparsity = 0) {
TensorBuilder builder_(_fbb);
builder_.add_sparsity(sparsity);
builder_.add_quantization(quantization);
builder_.add_name(name);
builder_.add_buffer(buffer);
builder_.add_shape(shape);
builder_.add_is_variable(is_variable);
builder_.add_type(type);
return builder_.Finish();
}
inline flatbuffers::Offset<Tensor> CreateTensorDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<int32_t> *shape = nullptr,
TensorType type = TensorType_FLOAT32,
uint32_t buffer = 0,
const char *name = nullptr,
flatbuffers::Offset<QuantizationParameters> quantization = 0,
bool is_variable = false,
flatbuffers::Offset<SparsityParameters> sparsity = 0) {
auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0;
auto name__ = name ? _fbb.CreateString(name) : 0;
return tflite::CreateTensor(
_fbb,
shape__,
type,
buffer,
name__,
quantization,
is_variable,
sparsity);
}
flatbuffers::Offset<Tensor> CreateTensor(flatbuffers::FlatBufferBuilder &_fbb, const TensorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct Conv2DOptionsT : public flatbuffers::NativeTable {
typedef Conv2DOptions TableType;
Padding padding;
int32_t stride_w;
int32_t stride_h;
ActivationFunctionType fused_activation_function;
int32_t dilation_w_factor;
int32_t dilation_h_factor;
Conv2DOptionsT()
: padding(Padding_SAME),
stride_w(0),
stride_h(0),
fused_activation_function(ActivationFunctionType_NONE),
dilation_w_factor(1),
dilation_h_factor(1) {
}
};
struct Conv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef Conv2DOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_PADDING = 4,
VT_STRIDE_W = 6,
VT_STRIDE_H = 8,
VT_FUSED_ACTIVATION_FUNCTION = 10,
VT_DILATION_W_FACTOR = 12,
VT_DILATION_H_FACTOR = 14
};
Padding padding() const {
return static_cast<Padding>(GetField<int8_t>(VT_PADDING, 0));
}
int32_t stride_w() const {
return GetField<int32_t>(VT_STRIDE_W, 0);
}
int32_t stride_h() const {
return GetField<int32_t>(VT_STRIDE_H, 0);
}
ActivationFunctionType fused_activation_function() const {
return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
int32_t dilation_w_factor() const {
return GetField<int32_t>(VT_DILATION_W_FACTOR, 1);
}
int32_t dilation_h_factor() const {
return GetField<int32_t>(VT_DILATION_H_FACTOR, 1);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_PADDING) &&
VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR) &&
VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR) &&
verifier.EndTable();
}
Conv2DOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(Conv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<Conv2DOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct Conv2DOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_padding(Padding padding) {
fbb_.AddElement<int8_t>(Conv2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
}
void add_stride_w(int32_t stride_w) {
fbb_.AddElement<int32_t>(Conv2DOptions::VT_STRIDE_W, stride_w, 0);
}
void add_stride_h(int32_t stride_h) {
fbb_.AddElement<int32_t>(Conv2DOptions::VT_STRIDE_H, stride_h, 0);
}
void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
fbb_.AddElement<int8_t>(Conv2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
void add_dilation_w_factor(int32_t dilation_w_factor) {
fbb_.AddElement<int32_t>(Conv2DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, 1);
}
void add_dilation_h_factor(int32_t dilation_h_factor) {
fbb_.AddElement<int32_t>(Conv2DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, 1);
}
explicit Conv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
Conv2DOptionsBuilder &operator=(const Conv2DOptionsBuilder &);
flatbuffers::Offset<Conv2DOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Conv2DOptions>(end);
return o;
}
};
inline flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(
flatbuffers::FlatBufferBuilder &_fbb,
Padding padding = Padding_SAME,
int32_t stride_w = 0,
int32_t stride_h = 0,
ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE,
int32_t dilation_w_factor = 1,
int32_t dilation_h_factor = 1) {
Conv2DOptionsBuilder builder_(_fbb);
builder_.add_dilation_h_factor(dilation_h_factor);
builder_.add_dilation_w_factor(dilation_w_factor);
builder_.add_stride_h(stride_h);
builder_.add_stride_w(stride_w);
builder_.add_fused_activation_function(fused_activation_function);
builder_.add_padding(padding);
return builder_.Finish();
}
flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct Pool2DOptionsT : public flatbuffers::NativeTable {
typedef Pool2DOptions TableType;
Padding padding;
int32_t stride_w;
int32_t stride_h;
int32_t filter_width;
int32_t filter_height;
ActivationFunctionType fused_activation_function;
Pool2DOptionsT()
: padding(Padding_SAME),
stride_w(0),
stride_h(0),
filter_width(0),
filter_height(0),
fused_activation_function(ActivationFunctionType_NONE) {
}
};
struct Pool2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef Pool2DOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_PADDING = 4,
VT_STRIDE_W = 6,
VT_STRIDE_H = 8,
VT_FILTER_WIDTH = 10,
VT_FILTER_HEIGHT = 12,
VT_FUSED_ACTIVATION_FUNCTION = 14
};
Padding padding() const {
return static_cast<Padding>(GetField<int8_t>(VT_PADDING, 0));
}
int32_t stride_w() const {
return GetField<int32_t>(VT_STRIDE_W, 0);
}
int32_t stride_h() const {
return GetField<int32_t>(VT_STRIDE_H, 0);
}
int32_t filter_width() const {
return GetField<int32_t>(VT_FILTER_WIDTH, 0);
}
int32_t filter_height() const {
return GetField<int32_t>(VT_FILTER_HEIGHT, 0);
}
ActivationFunctionType fused_activation_function() const {
return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_PADDING) &&
VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
VerifyField<int32_t>(verifier, VT_FILTER_WIDTH) &&
VerifyField<int32_t>(verifier, VT_FILTER_HEIGHT) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
verifier.EndTable();
}
Pool2DOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(Pool2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<Pool2DOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct Pool2DOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_padding(Padding padding) {
fbb_.AddElement<int8_t>(Pool2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
}
void add_stride_w(int32_t stride_w) {
fbb_.AddElement<int32_t>(Pool2DOptions::VT_STRIDE_W, stride_w, 0);
}
void add_stride_h(int32_t stride_h) {
fbb_.AddElement<int32_t>(Pool2DOptions::VT_STRIDE_H, stride_h, 0);
}
void add_filter_width(int32_t filter_width) {
fbb_.AddElement<int32_t>(Pool2DOptions::VT_FILTER_WIDTH, filter_width, 0);
}
void add_filter_height(int32_t filter_height) {
fbb_.AddElement<int32_t>(Pool2DOptions::VT_FILTER_HEIGHT, filter_height, 0);
}
void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
fbb_.AddElement<int8_t>(Pool2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
explicit Pool2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
Pool2DOptionsBuilder &operator=(const Pool2DOptionsBuilder &);
flatbuffers::Offset<Pool2DOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Pool2DOptions>(end);
return o;
}
};
inline flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(
flatbuffers::FlatBufferBuilder &_fbb,
Padding padding = Padding_SAME,
int32_t stride_w = 0,
int32_t stride_h = 0,
int32_t filter_width = 0,
int32_t filter_height = 0,
ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) {
Pool2DOptionsBuilder builder_(_fbb);
builder_.add_filter_height(filter_height);
builder_.add_filter_width(filter_width);
builder_.add_stride_h(stride_h);
builder_.add_stride_w(stride_w);
builder_.add_fused_activation_function(fused_activation_function);
builder_.add_padding(padding);
return builder_.Finish();
}
flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct DepthwiseConv2DOptionsT : public flatbuffers::NativeTable {
typedef DepthwiseConv2DOptions TableType;
Padding padding;
int32_t stride_w;
int32_t stride_h;
int32_t depth_multiplier;
ActivationFunctionType fused_activation_function;
int32_t dilation_w_factor;
int32_t dilation_h_factor;
DepthwiseConv2DOptionsT()
: padding(Padding_SAME),
stride_w(0),
stride_h(0),
depth_multiplier(0),
fused_activation_function(ActivationFunctionType_NONE),
dilation_w_factor(1),
dilation_h_factor(1) {
}
};
struct DepthwiseConv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef DepthwiseConv2DOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_PADDING = 4,
VT_STRIDE_W = 6,
VT_STRIDE_H = 8,
VT_DEPTH_MULTIPLIER = 10,
VT_FUSED_ACTIVATION_FUNCTION = 12,
VT_DILATION_W_FACTOR = 14,
VT_DILATION_H_FACTOR = 16
};
Padding padding() const {
return static_cast<Padding>(GetField<int8_t>(VT_PADDING, 0));
}
int32_t stride_w() const {
return GetField<int32_t>(VT_STRIDE_W, 0);
}
int32_t stride_h() const {
return GetField<int32_t>(VT_STRIDE_H, 0);
}
int32_t depth_multiplier() const {
return GetField<int32_t>(VT_DEPTH_MULTIPLIER, 0);
}
ActivationFunctionType fused_activation_function() const {
return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
int32_t dilation_w_factor() const {
return GetField<int32_t>(VT_DILATION_W_FACTOR, 1);
}
int32_t dilation_h_factor() const {
return GetField<int32_t>(VT_DILATION_H_FACTOR, 1);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_PADDING) &&
VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
VerifyField<int32_t>(verifier, VT_DEPTH_MULTIPLIER) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR) &&
VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR) &&
verifier.EndTable();
}
DepthwiseConv2DOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(DepthwiseConv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<DepthwiseConv2DOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct DepthwiseConv2DOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_padding(Padding padding) {
fbb_.AddElement<int8_t>(DepthwiseConv2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
}
void add_stride_w(int32_t stride_w) {
fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_STRIDE_W, stride_w, 0);
}
void add_stride_h(int32_t stride_h) {
fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_STRIDE_H, stride_h, 0);
}
void add_depth_multiplier(int32_t depth_multiplier) {
fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DEPTH_MULTIPLIER, depth_multiplier, 0);
}
void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
fbb_.AddElement<int8_t>(DepthwiseConv2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
void add_dilation_w_factor(int32_t dilation_w_factor) {
fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, 1);
}
void add_dilation_h_factor(int32_t dilation_h_factor) {
fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, 1);
}
explicit DepthwiseConv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
DepthwiseConv2DOptionsBuilder &operator=(const DepthwiseConv2DOptionsBuilder &);
flatbuffers::Offset<DepthwiseConv2DOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<DepthwiseConv2DOptions>(end);
return o;
}
};
inline flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(
flatbuffers::FlatBufferBuilder &_fbb,
Padding padding = Padding_SAME,
int32_t stride_w = 0,
int32_t stride_h = 0,
int32_t depth_multiplier = 0,
ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE,
int32_t dilation_w_factor = 1,
int32_t dilation_h_factor = 1) {
DepthwiseConv2DOptionsBuilder builder_(_fbb);
builder_.add_dilation_h_factor(dilation_h_factor);
builder_.add_dilation_w_factor(dilation_w_factor);
builder_.add_depth_multiplier(depth_multiplier);
builder_.add_stride_h(stride_h);
builder_.add_stride_w(stride_w);
builder_.add_fused_activation_function(fused_activation_function);
builder_.add_padding(padding);
return builder_.Finish();
}
flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct ConcatEmbeddingsOptionsT : public flatbuffers::NativeTable {
typedef ConcatEmbeddingsOptions TableType;
int32_t num_channels;
std::vector<int32_t> num_columns_per_channel;
std::vector<int32_t> embedding_dim_per_channel;
ConcatEmbeddingsOptionsT()
: num_channels(0) {
}
};
struct ConcatEmbeddingsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ConcatEmbeddingsOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NUM_CHANNELS = 4,
VT_NUM_COLUMNS_PER_CHANNEL = 6,
VT_EMBEDDING_DIM_PER_CHANNEL = 8
};
int32_t num_channels() const {
return GetField<int32_t>(VT_NUM_CHANNELS, 0);
}
const flatbuffers::Vector<int32_t> *num_columns_per_channel() const {
return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_NUM_COLUMNS_PER_CHANNEL);
}
const flatbuffers::Vector<int32_t> *embedding_dim_per_channel() const {
return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_EMBEDDING_DIM_PER_CHANNEL);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_NUM_CHANNELS) &&
VerifyOffset(verifier, VT_NUM_COLUMNS_PER_CHANNEL) &&
verifier.VerifyVector(num_columns_per_channel()) &&
VerifyOffset(verifier, VT_EMBEDDING_DIM_PER_CHANNEL) &&
verifier.VerifyVector(embedding_dim_per_channel()) &&
verifier.EndTable();
}
ConcatEmbeddingsOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(ConcatEmbeddingsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<ConcatEmbeddingsOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct ConcatEmbeddingsOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_num_channels(int32_t num_channels) {
fbb_.AddElement<int32_t>(ConcatEmbeddingsOptions::VT_NUM_CHANNELS, num_channels, 0);
}
void add_num_columns_per_channel(flatbuffers::Offset<flatbuffers::Vector<int32_t>> num_columns_per_channel) {
fbb_.AddOffset(ConcatEmbeddingsOptions::VT_NUM_COLUMNS_PER_CHANNEL, num_columns_per_channel);
}
void add_embedding_dim_per_channel(flatbuffers::Offset<flatbuffers::Vector<int32_t>> embedding_dim_per_channel) {
fbb_.AddOffset(ConcatEmbeddingsOptions::VT_EMBEDDING_DIM_PER_CHANNEL, embedding_dim_per_channel);
}
explicit ConcatEmbeddingsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ConcatEmbeddingsOptionsBuilder &operator=(const ConcatEmbeddingsOptionsBuilder &);
flatbuffers::Offset<ConcatEmbeddingsOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ConcatEmbeddingsOptions>(end);
return o;
}
};
inline flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t num_channels = 0,
flatbuffers::Offset<flatbuffers::Vector<int32_t>> num_columns_per_channel = 0,
flatbuffers::Offset<flatbuffers::Vector<int32_t>> embedding_dim_per_channel = 0) {
ConcatEmbeddingsOptionsBuilder builder_(_fbb);
builder_.add_embedding_dim_per_channel(embedding_dim_per_channel);
builder_.add_num_columns_per_channel(num_columns_per_channel);
builder_.add_num_channels(num_channels);
return builder_.Finish();
}
inline flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptionsDirect(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t num_channels = 0,
const std::vector<int32_t> *num_columns_per_channel = nullptr,
const std::vector<int32_t> *embedding_dim_per_channel = nullptr) {
auto num_columns_per_channel__ = num_columns_per_channel ? _fbb.CreateVector<int32_t>(*num_columns_per_channel) : 0;
auto embedding_dim_per_channel__ = embedding_dim_per_channel ? _fbb.CreateVector<int32_t>(*embedding_dim_per_channel) : 0;
return tflite::CreateConcatEmbeddingsOptions(
_fbb,
num_channels,
num_columns_per_channel__,
embedding_dim_per_channel__);
}
flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct LSHProjectionOptionsT : public flatbuffers::NativeTable {
typedef LSHProjectionOptions TableType;
LSHProjectionType type;
LSHProjectionOptionsT()
: type(LSHProjectionType_UNKNOWN) {
}
};
struct LSHProjectionOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef LSHProjectionOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_TYPE = 4
};
LSHProjectionType type() const {
return static_cast<LSHProjectionType>(GetField<int8_t>(VT_TYPE, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_TYPE) &&
verifier.EndTable();
}
LSHProjectionOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(LSHProjectionOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<LSHProjectionOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct LSHProjectionOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_type(LSHProjectionType type) {
fbb_.AddElement<int8_t>(LSHProjectionOptions::VT_TYPE, static_cast<int8_t>(type), 0);
}
explicit LSHProjectionOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
LSHProjectionOptionsBuilder &operator=(const LSHProjectionOptionsBuilder &);
flatbuffers::Offset<LSHProjectionOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<LSHProjectionOptions>(end);
return o;
}
};
inline flatbuffers::Offset<LSHProjectionOptions> CreateLSHProjectionOptions(
flatbuffers::FlatBufferBuilder &_fbb,
LSHProjectionType type = LSHProjectionType_UNKNOWN) {
LSHProjectionOptionsBuilder builder_(_fbb);
builder_.add_type(type);
return builder_.Finish();
}
flatbuffers::Offset<LSHProjectionOptions> CreateLSHProjectionOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct SVDFOptionsT : public flatbuffers::NativeTable {
typedef SVDFOptions TableType;
int32_t rank;
ActivationFunctionType fused_activation_function;
SVDFOptionsT()
: rank(0),
fused_activation_function(ActivationFunctionType_NONE) {
}
};
struct SVDFOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SVDFOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_RANK = 4,
VT_FUSED_ACTIVATION_FUNCTION = 6
};
int32_t rank() const {
return GetField<int32_t>(VT_RANK, 0);
}
ActivationFunctionType fused_activation_function() const {
return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_RANK) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
verifier.EndTable();
}
SVDFOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(SVDFOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<SVDFOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct SVDFOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_rank(int32_t rank) {
fbb_.AddElement<int32_t>(SVDFOptions::VT_RANK, rank, 0);
}
void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
fbb_.AddElement<int8_t>(SVDFOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
explicit SVDFOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SVDFOptionsBuilder &operator=(const SVDFOptionsBuilder &);
flatbuffers::Offset<SVDFOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<SVDFOptions>(end);
return o;
}
};
inline flatbuffers::Offset<SVDFOptions> CreateSVDFOptions(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t rank = 0,
ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) {
SVDFOptionsBuilder builder_(_fbb);
builder_.add_rank(rank);
builder_.add_fused_activation_function(fused_activation_function);
return builder_.Finish();
}
flatbuffers::Offset<SVDFOptions> CreateSVDFOptions(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct RNNOptionsT : public flatbuffers::NativeTable {
typedef RNNOptions TableType;
ActivationFunctionType fused_activation_function;
RNNOptionsT()
: fused_activation_function(ActivationFunctionType_NONE) {
}
};
struct RNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef RNNOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_FUSED_ACTIVATION_FUNCTION = 4
};
ActivationFunctionType fused_activation_function() const {
return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
verifier.EndTable();
}
RNNOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(RNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<RNNOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct RNNOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
fbb_.AddElement<int8_t>(RNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
explicit RNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
RNNOptionsBuilder &operator=(const RNNOptionsBuilder &);
flatbuffers::Offset<RNNOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<RNNOptions>(end);
return o;
}
};
inline flatbuffers::Offset<RNNOptions> CreateRNNOptions(
flatbuffers::FlatBufferBuilder &_fbb,
ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) {
RNNOptionsBuilder builder_(_fbb);
builder_.add_fused_activation_function(fused_activation_function);
return builder_.Finish();
}
flatbuffers::Offset<RNNOptions> CreateRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct SequenceRNNOptionsT : public flatbuffers::NativeTable {
typedef SequenceRNNOptions TableType;
bool time_major;
ActivationFunctionType fused_activation_function;
SequenceRNNOptionsT()
: time_major(false),
fused_activation_function(ActivationFunctionType_NONE) {
}
};
struct SequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SequenceRNNOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_TIME_MAJOR = 4,
VT_FUSED_ACTIVATION_FUNCTION = 6
};
bool time_major() const {
return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0;
}
ActivationFunctionType fused_activation_function() const {
return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
verifier.EndTable();
}
SequenceRNNOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(SequenceRNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<SequenceRNNOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct SequenceRNNOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_time_major(bool time_major) {
fbb_.AddElement<uint8_t>(SequenceRNNOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), 0);
}
void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
fbb_.AddElement<int8_t>(SequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
explicit SequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SequenceRNNOptionsBuilder &operator=(const SequenceRNNOptionsBuilder &);
flatbuffers::Offset<SequenceRNNOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<SequenceRNNOptions>(end);
return o;
}
};
inline flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions(
flatbuffers::FlatBufferBuilder &_fbb,
bool time_major = false,
ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) {
SequenceRNNOptionsBuilder builder_(_fbb);
builder_.add_fused_activation_function(fused_activation_function);
builder_.add_time_major(time_major);
return builder_.Finish();
}
flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct BidirectionalSequenceRNNOptionsT : public flatbuffers::NativeTable {
typedef BidirectionalSequenceRNNOptions TableType;
bool time_major;
ActivationFunctionType fused_activation_function;
bool merge_outputs;
BidirectionalSequenceRNNOptionsT()
: time_major(false),
fused_activation_function(ActivationFunctionType_NONE),
merge_outputs(false) {
}
};
struct BidirectionalSequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef BidirectionalSequenceRNNOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_TIME_MAJOR = 4,
VT_FUSED_ACTIVATION_FUNCTION = 6,
VT_MERGE_OUTPUTS = 8
};
bool time_major() const {
return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0;
}
ActivationFunctionType fused_activation_function() const {
return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
bool merge_outputs() const {
return GetField<uint8_t>(VT_MERGE_OUTPUTS, 0) != 0;
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
VerifyField<uint8_t>(verifier, VT_MERGE_OUTPUTS) &&
verifier.EndTable();
}
BidirectionalSequenceRNNOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(BidirectionalSequenceRNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<BidirectionalSequenceRNNOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct BidirectionalSequenceRNNOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_time_major(bool time_major) {
fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), 0);
}
void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
fbb_.AddElement<int8_t>(BidirectionalSequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
void add_merge_outputs(bool merge_outputs) {
fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_MERGE_OUTPUTS, static_cast<uint8_t>(merge_outputs), 0);
}
explicit BidirectionalSequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
BidirectionalSequenceRNNOptionsBuilder &operator=(const BidirectionalSequenceRNNOptionsBuilder &);
flatbuffers::Offset<BidirectionalSequenceRNNOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<BidirectionalSequenceRNNOptions>(end);
return o;
}
};
inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(
flatbuffers::FlatBufferBuilder &_fbb,
bool time_major = false,
ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE,
bool merge_outputs = false) {
BidirectionalSequenceRNNOptionsBuilder builder_(_fbb);
builder_.add_merge_outputs(merge_outputs);
builder_.add_fused_activation_function(fused_activation_function);
builder_.add_time_major(time_major);
return builder_.Finish();
}
flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct FullyConnectedOptionsT : public flatbuffers::NativeTable {
typedef FullyConnectedOptions TableType;
ActivationFunctionType fused_activation_function;
FullyConnectedOptionsWeightsFormat weights_format;
bool keep_num_dims;
FullyConnectedOptionsT()
: fused_activation_function(ActivationFunctionType_NONE),
weights_format(FullyConnectedOptionsWeightsFormat_DEFAULT),
keep_num_dims(false) {
}
};
struct FullyConnectedOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef FullyConnectedOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_FUSED_ACTIVATION_FUNCTION = 4,
VT_WEIGHTS_FORMAT = 6,
VT_KEEP_NUM_DIMS = 8
};
ActivationFunctionType fused_activation_function() const {
return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
FullyConnectedOptionsWeightsFormat weights_format() const {
return static_cast<FullyConnectedOptionsWeightsFormat>(GetField<int8_t>(VT_WEIGHTS_FORMAT, 0));
}
bool keep_num_dims() const {
return GetField<uint8_t>(VT_KEEP_NUM_DIMS, 0) != 0;
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
VerifyField<int8_t>(verifier, VT_WEIGHTS_FORMAT) &&
VerifyField<uint8_t>(verifier, VT_KEEP_NUM_DIMS) &&
verifier.EndTable();
}
FullyConnectedOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(FullyConnectedOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<FullyConnectedOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct FullyConnectedOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
void add_weights_format(FullyConnectedOptionsWeightsFormat weights_format) {
fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_WEIGHTS_FORMAT, static_cast<int8_t>(weights_format), 0);
}
void add_keep_num_dims(bool keep_num_dims) {
fbb_.AddElement<uint8_t>(FullyConnectedOptions::VT_KEEP_NUM_DIMS, static_cast<uint8_t>(keep_num_dims), 0);
}
explicit FullyConnectedOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
FullyConnectedOptionsBuilder &operator=(const FullyConnectedOptionsBuilder &);
flatbuffers::Offset<FullyConnectedOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<FullyConnectedOptions>(end);
return o;
}
};
inline flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions(
flatbuffers::FlatBufferBuilder &_fbb,
ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE,
FullyConnectedOptionsWeightsFormat weights_format = FullyConnectedOptionsWeightsFormat_DEFAULT,
bool keep_num_dims = false) {
FullyConnectedOptionsBuilder builder_(_fbb);
builder_.add_keep_num_dims(keep_num_dims);
builder_.add_weights_format(weights_format);
builder_.add_fused_activation_function(fused_activation_function);
return builder_.Finish();
}
flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct SoftmaxOptionsT : public flatbuffers::NativeTable {
typedef SoftmaxOptions TableType;
float beta;
SoftmaxOptionsT()
: beta(0.0f) {
}
};
struct SoftmaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SoftmaxOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_BETA = 4
};
float beta() const {
return GetField<float>(VT_BETA, 0.0f);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<float>(verifier, VT_BETA) &&
verifier.EndTable();
}
SoftmaxOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(SoftmaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<SoftmaxOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct SoftmaxOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_beta(float beta) {
fbb_.AddElement<float>(SoftmaxOptions::VT_BETA, beta, 0.0f);
}
explicit SoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SoftmaxOptionsBuilder &operator=(const SoftmaxOptionsBuilder &);
flatbuffers::Offset<SoftmaxOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<SoftmaxOptions>(end);
return o;
}
};
inline flatbuffers::Offset<SoftmaxOptions> CreateSoftmaxOptions(
flatbuffers::FlatBufferBuilder &_fbb,
float beta = 0.0f) {
SoftmaxOptionsBuilder builder_(_fbb);
builder_.add_beta(beta);
return builder_.Finish();
}
flatbuffers::Offset<SoftmaxOptions> CreateSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct ConcatenationOptionsT : public flatbuffers::NativeTable {
typedef ConcatenationOptions TableType;
int32_t axis;
ActivationFunctionType fused_activation_function;
ConcatenationOptionsT()
: axis(0),
fused_activation_function(ActivationFunctionType_NONE) {
}
};
struct ConcatenationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ConcatenationOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_AXIS = 4,
VT_FUSED_ACTIVATION_FUNCTION = 6
};
int32_t axis() const {
return GetField<int32_t>(VT_AXIS, 0);
}
ActivationFunctionType fused_activation_function() const {
return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_AXIS) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
verifier.EndTable();
}
ConcatenationOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(ConcatenationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<ConcatenationOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct ConcatenationOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_axis(int32_t axis) {
fbb_.AddElement<int32_t>(ConcatenationOptions::VT_AXIS, axis, 0);
}
void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
fbb_.AddElement<int8_t>(ConcatenationOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
explicit ConcatenationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ConcatenationOptionsBuilder &operator=(const ConcatenationOptionsBuilder &);
flatbuffers::Offset<ConcatenationOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ConcatenationOptions>(end);
return o;
}
};
inline flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t axis = 0,
ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) {
ConcatenationOptionsBuilder builder_(_fbb);
builder_.add_axis(axis);
builder_.add_fused_activation_function(fused_activation_function);
return builder_.Finish();
}
flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct AddOptionsT : public flatbuffers::NativeTable {
typedef AddOptions TableType;
ActivationFunctionType fused_activation_function;
AddOptionsT()
: fused_activation_function(ActivationFunctionType_NONE) {
}
};
struct AddOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef AddOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_FUSED_ACTIVATION_FUNCTION = 4
};
ActivationFunctionType fused_activation_function() const {
return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
verifier.EndTable();
}
AddOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(AddOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<AddOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct AddOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
fbb_.AddElement<int8_t>(AddOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
explicit AddOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
AddOptionsBuilder &operator=(const AddOptionsBuilder &);
flatbuffers::Offset<AddOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<AddOptions>(end);
return o;
}
};
inline flatbuffers::Offset<AddOptions> CreateAddOptions(
flatbuffers::FlatBufferBuilder &_fbb,
ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) {
AddOptionsBuilder builder_(_fbb);
builder_.add_fused_activation_function(fused_activation_function);
return builder_.Finish();
}
flatbuffers::Offset<AddOptions> CreateAddOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct MulOptionsT : public flatbuffers::NativeTable {
typedef MulOptions TableType;
ActivationFunctionType fused_activation_function;
MulOptionsT()
: fused_activation_function(ActivationFunctionType_NONE) {
}
};
struct MulOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef MulOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_FUSED_ACTIVATION_FUNCTION = 4
};
ActivationFunctionType fused_activation_function() const {
return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
verifier.EndTable();
}
MulOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(MulOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<MulOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct MulOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
fbb_.AddElement<int8_t>(MulOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
explicit MulOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
MulOptionsBuilder &operator=(const MulOptionsBuilder &);
flatbuffers::Offset<MulOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<MulOptions>(end);
return o;
}
};
inline flatbuffers::Offset<MulOptions> CreateMulOptions(
flatbuffers::FlatBufferBuilder &_fbb,
ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) {
MulOptionsBuilder builder_(_fbb);
builder_.add_fused_activation_function(fused_activation_function);
return builder_.Finish();
}
flatbuffers::Offset<MulOptions> CreateMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct L2NormOptionsT : public flatbuffers::NativeTable {
typedef L2NormOptions TableType;
ActivationFunctionType fused_activation_function;
L2NormOptionsT()
: fused_activation_function(ActivationFunctionType_NONE) {
}
};
struct L2NormOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef L2NormOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_FUSED_ACTIVATION_FUNCTION = 4
};
ActivationFunctionType fused_activation_function() const {
return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
verifier.EndTable();
}
L2NormOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(L2NormOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<L2NormOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct L2NormOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
fbb_.AddElement<int8_t>(L2NormOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
explicit L2NormOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
L2NormOptionsBuilder &operator=(const L2NormOptionsBuilder &);
flatbuffers::Offset<L2NormOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<L2NormOptions>(end);
return o;
}
};
inline flatbuffers::Offset<L2NormOptions> CreateL2NormOptions(
flatbuffers::FlatBufferBuilder &_fbb,
ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) {
L2NormOptionsBuilder builder_(_fbb);
builder_.add_fused_activation_function(fused_activation_function);
return builder_.Finish();
}
flatbuffers::Offset<L2NormOptions> CreateL2NormOptions(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct LocalResponseNormalizationOptionsT : public flatbuffers::NativeTable {
typedef LocalResponseNormalizationOptions TableType;
int32_t radius;
float bias;
float alpha;
float beta;
LocalResponseNormalizationOptionsT()
: radius(0),
bias(0.0f),
alpha(0.0f),
beta(0.0f) {
}
};
struct LocalResponseNormalizationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef LocalResponseNormalizationOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_RADIUS = 4,
VT_BIAS = 6,
VT_ALPHA = 8,
VT_BETA = 10
};
int32_t radius() const {
return GetField<int32_t>(VT_RADIUS, 0);
}
float bias() const {
return GetField<float>(VT_BIAS, 0.0f);
}
float alpha() const {
return GetField<float>(VT_ALPHA, 0.0f);
}
float beta() const {
return GetField<float>(VT_BETA, 0.0f);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_RADIUS) &&
VerifyField<float>(verifier, VT_BIAS) &&
VerifyField<float>(verifier, VT_ALPHA) &&
VerifyField<float>(verifier, VT_BETA) &&
verifier.EndTable();
}
LocalResponseNormalizationOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(LocalResponseNormalizationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<LocalResponseNormalizationOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct LocalResponseNormalizationOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_radius(int32_t radius) {
fbb_.AddElement<int32_t>(LocalResponseNormalizationOptions::VT_RADIUS, radius, 0);
}
void add_bias(float bias) {
fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BIAS, bias, 0.0f);
}
void add_alpha(float alpha) {
fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_ALPHA, alpha, 0.0f);
}
void add_beta(float beta) {
fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BETA, beta, 0.0f);
}
explicit LocalResponseNormalizationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
LocalResponseNormalizationOptionsBuilder &operator=(const LocalResponseNormalizationOptionsBuilder &);
flatbuffers::Offset<LocalResponseNormalizationOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<LocalResponseNormalizationOptions>(end);
return o;
}
};
inline flatbuffers::Offset<LocalResponseNormalizationOptions> CreateLocalResponseNormalizationOptions(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t radius = 0,
float bias = 0.0f,
float alpha = 0.0f,
float beta = 0.0f) {
LocalResponseNormalizationOptionsBuilder builder_(_fbb);
builder_.add_beta(beta);
builder_.add_alpha(alpha);
builder_.add_bias(bias);
builder_.add_radius(radius);
return builder_.Finish();
}
flatbuffers::Offset<LocalResponseNormalizationOptions> CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct LSTMOptionsT : public flatbuffers::NativeTable {
typedef LSTMOptions TableType;
ActivationFunctionType fused_activation_function;
float cell_clip;
float proj_clip;
LSTMKernelType kernel_type;
LSTMOptionsT()
: fused_activation_function(ActivationFunctionType_NONE),
cell_clip(0.0f),
proj_clip(0.0f),
kernel_type(LSTMKernelType_FULL) {
}
};
struct LSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef LSTMOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_FUSED_ACTIVATION_FUNCTION = 4,
VT_CELL_CLIP = 6,
VT_PROJ_CLIP = 8,
VT_KERNEL_TYPE = 10
};
ActivationFunctionType fused_activation_function() const {
return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
float cell_clip() const {
return GetField<float>(VT_CELL_CLIP, 0.0f);
}
float proj_clip() const {
return GetField<float>(VT_PROJ_CLIP, 0.0f);
}
LSTMKernelType kernel_type() const {
return static_cast<LSTMKernelType>(GetField<int8_t>(VT_KERNEL_TYPE, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
VerifyField<float>(verifier, VT_CELL_CLIP) &&
VerifyField<float>(verifier, VT_PROJ_CLIP) &&
VerifyField<int8_t>(verifier, VT_KERNEL_TYPE) &&
verifier.EndTable();
}
LSTMOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(LSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<LSTMOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct LSTMOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
fbb_.AddElement<int8_t>(LSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
void add_cell_clip(float cell_clip) {
fbb_.AddElement<float>(LSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f);
}
void add_proj_clip(float proj_clip) {
fbb_.AddElement<float>(LSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f);
}
void add_kernel_type(LSTMKernelType kernel_type) {
fbb_.AddElement<int8_t>(LSTMOptions::VT_KERNEL_TYPE, static_cast<int8_t>(kernel_type), 0);
}
explicit LSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
LSTMOptionsBuilder &operator=(const LSTMOptionsBuilder &);
flatbuffers::Offset<LSTMOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<LSTMOptions>(end);
return o;
}
};
inline flatbuffers::Offset<LSTMOptions> CreateLSTMOptions(
flatbuffers::FlatBufferBuilder &_fbb,
ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE,
float cell_clip = 0.0f,
float proj_clip = 0.0f,
LSTMKernelType kernel_type = LSTMKernelType_FULL) {
LSTMOptionsBuilder builder_(_fbb);
builder_.add_proj_clip(proj_clip);
builder_.add_cell_clip(cell_clip);
builder_.add_kernel_type(kernel_type);
builder_.add_fused_activation_function(fused_activation_function);
return builder_.Finish();
}
flatbuffers::Offset<LSTMOptions> CreateLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct UnidirectionalSequenceLSTMOptionsT : public flatbuffers::NativeTable {
typedef UnidirectionalSequenceLSTMOptions TableType;
ActivationFunctionType fused_activation_function;
float cell_clip;
float proj_clip;
bool time_major;
UnidirectionalSequenceLSTMOptionsT()
: fused_activation_function(ActivationFunctionType_NONE),
cell_clip(0.0f),
proj_clip(0.0f),
time_major(false) {
}
};
struct UnidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef UnidirectionalSequenceLSTMOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_FUSED_ACTIVATION_FUNCTION = 4,
VT_CELL_CLIP = 6,
VT_PROJ_CLIP = 8,
VT_TIME_MAJOR = 10
};
ActivationFunctionType fused_activation_function() const {
return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
float cell_clip() const {
return GetField<float>(VT_CELL_CLIP, 0.0f);
}
float proj_clip() const {
return GetField<float>(VT_PROJ_CLIP, 0.0f);
}
bool time_major() const {
return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0;
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
VerifyField<float>(verifier, VT_CELL_CLIP) &&
VerifyField<float>(verifier, VT_PROJ_CLIP) &&
VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
verifier.EndTable();
}
UnidirectionalSequenceLSTMOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(UnidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct UnidirectionalSequenceLSTMOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
fbb_.AddElement<int8_t>(UnidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
void add_cell_clip(float cell_clip) {
fbb_.AddElement<float>(UnidirectionalSequenceLSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f);
}
void add_proj_clip(float proj_clip) {
fbb_.AddElement<float>(UnidirectionalSequenceLSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f);
}
void add_time_major(bool time_major) {
fbb_.AddElement<uint8_t>(UnidirectionalSequenceLSTMOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), 0);
}
explicit UnidirectionalSequenceLSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
UnidirectionalSequenceLSTMOptionsBuilder &operator=(const UnidirectionalSequenceLSTMOptionsBuilder &);
flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<UnidirectionalSequenceLSTMOptions>(end);
return o;
}
};
inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> CreateUnidirectionalSequenceLSTMOptions(
flatbuffers::FlatBufferBuilder &_fbb,
ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE,
float cell_clip = 0.0f,
float proj_clip = 0.0f,
bool time_major = false) {
UnidirectionalSequenceLSTMOptionsBuilder builder_(_fbb);
builder_.add_proj_clip(proj_clip);
builder_.add_cell_clip(cell_clip);
builder_.add_time_major(time_major);
builder_.add_fused_activation_function(fused_activation_function);
return builder_.Finish();
}
flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> CreateUnidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct BidirectionalSequenceLSTMOptionsT : public flatbuffers::NativeTable {
typedef BidirectionalSequenceLSTMOptions TableType;
ActivationFunctionType fused_activation_function;
float cell_clip;
float proj_clip;
bool merge_outputs;
bool time_major;
BidirectionalSequenceLSTMOptionsT()
: fused_activation_function(ActivationFunctionType_NONE),
cell_clip(0.0f),
proj_clip(0.0f),
merge_outputs(false),
time_major(true) {
}
};
struct BidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef BidirectionalSequenceLSTMOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_FUSED_ACTIVATION_FUNCTION = 4,
VT_CELL_CLIP = 6,
VT_PROJ_CLIP = 8,
VT_MERGE_OUTPUTS = 10,
VT_TIME_MAJOR = 12
};
ActivationFunctionType fused_activation_function() const {
return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
float cell_clip() const {
return GetField<float>(VT_CELL_CLIP, 0.0f);
}
float proj_clip() const {
return GetField<float>(VT_PROJ_CLIP, 0.0f);
}
bool merge_outputs() const {
return GetField<uint8_t>(VT_MERGE_OUTPUTS, 0) != 0;
}
bool time_major() const {
return GetField<uint8_t>(VT_TIME_MAJOR, 1) != 0;
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
VerifyField<float>(verifier, VT_CELL_CLIP) &&
VerifyField<float>(verifier, VT_PROJ_CLIP) &&
VerifyField<uint8_t>(verifier, VT_MERGE_OUTPUTS) &&
VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
verifier.EndTable();
}
BidirectionalSequenceLSTMOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(BidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<BidirectionalSequenceLSTMOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct BidirectionalSequenceLSTMOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
fbb_.AddElement<int8_t>(BidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
void add_cell_clip(float cell_clip) {
fbb_.AddElement<float>(BidirectionalSequenceLSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f);
}
void add_proj_clip(float proj_clip) {
fbb_.AddElement<float>(BidirectionalSequenceLSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f);
}
void add_merge_outputs(bool merge_outputs) {
fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_MERGE_OUTPUTS, static_cast<uint8_t>(merge_outputs), 0);
}
void add_time_major(bool time_major) {
fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), 1);
}
explicit BidirectionalSequenceLSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
BidirectionalSequenceLSTMOptionsBuilder &operator=(const BidirectionalSequenceLSTMOptionsBuilder &);
flatbuffers::Offset<BidirectionalSequenceLSTMOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<BidirectionalSequenceLSTMOptions>(end);
return o;
}
};
inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions(
flatbuffers::FlatBufferBuilder &_fbb,
ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE,
float cell_clip = 0.0f,
float proj_clip = 0.0f,
bool merge_outputs = false,
bool time_major = true) {
BidirectionalSequenceLSTMOptionsBuilder builder_(_fbb);
builder_.add_proj_clip(proj_clip);
builder_.add_cell_clip(cell_clip);
builder_.add_time_major(time_major);
builder_.add_merge_outputs(merge_outputs);
builder_.add_fused_activation_function(fused_activation_function);
return builder_.Finish();
}
flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct ResizeBilinearOptionsT : public flatbuffers::NativeTable {
typedef ResizeBilinearOptions TableType;
bool align_corners;
ResizeBilinearOptionsT()
: align_corners(false) {
}
};
struct ResizeBilinearOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ResizeBilinearOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ALIGN_CORNERS = 8
};
bool align_corners() const {
return GetField<uint8_t>(VT_ALIGN_CORNERS, 0) != 0;
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_ALIGN_CORNERS) &&
verifier.EndTable();
}
ResizeBilinearOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(ResizeBilinearOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<ResizeBilinearOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct ResizeBilinearOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_align_corners(bool align_corners) {
fbb_.AddElement<uint8_t>(ResizeBilinearOptions::VT_ALIGN_CORNERS, static_cast<uint8_t>(align_corners), 0);
}
explicit ResizeBilinearOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ResizeBilinearOptionsBuilder &operator=(const ResizeBilinearOptionsBuilder &);
flatbuffers::Offset<ResizeBilinearOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ResizeBilinearOptions>(end);
return o;
}
};
inline flatbuffers::Offset<ResizeBilinearOptions> CreateResizeBilinearOptions(
flatbuffers::FlatBufferBuilder &_fbb,
bool align_corners = false) {
ResizeBilinearOptionsBuilder builder_(_fbb);
builder_.add_align_corners(align_corners);
return builder_.Finish();
}
flatbuffers::Offset<ResizeBilinearOptions> CreateResizeBilinearOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct ResizeNearestNeighborOptionsT : public flatbuffers::NativeTable {
typedef ResizeNearestNeighborOptions TableType;
bool align_corners;
ResizeNearestNeighborOptionsT()
: align_corners(false) {
}
};
struct ResizeNearestNeighborOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ResizeNearestNeighborOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ALIGN_CORNERS = 4
};
bool align_corners() const {
return GetField<uint8_t>(VT_ALIGN_CORNERS, 0) != 0;
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_ALIGN_CORNERS) &&
verifier.EndTable();
}
ResizeNearestNeighborOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(ResizeNearestNeighborOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<ResizeNearestNeighborOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct ResizeNearestNeighborOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_align_corners(bool align_corners) {
fbb_.AddElement<uint8_t>(ResizeNearestNeighborOptions::VT_ALIGN_CORNERS, static_cast<uint8_t>(align_corners), 0);
}
explicit ResizeNearestNeighborOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ResizeNearestNeighborOptionsBuilder &operator=(const ResizeNearestNeighborOptionsBuilder &);
flatbuffers::Offset<ResizeNearestNeighborOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ResizeNearestNeighborOptions>(end);
return o;
}
};
inline flatbuffers::Offset<ResizeNearestNeighborOptions> CreateResizeNearestNeighborOptions(
flatbuffers::FlatBufferBuilder &_fbb,
bool align_corners = false) {
ResizeNearestNeighborOptionsBuilder builder_(_fbb);
builder_.add_align_corners(align_corners);
return builder_.Finish();
}
flatbuffers::Offset<ResizeNearestNeighborOptions> CreateResizeNearestNeighborOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct CallOptionsT : public flatbuffers::NativeTable {
typedef CallOptions TableType;
uint32_t subgraph;
CallOptionsT()
: subgraph(0) {
}
};
struct CallOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef CallOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_SUBGRAPH = 4
};
uint32_t subgraph() const {
return GetField<uint32_t>(VT_SUBGRAPH, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_SUBGRAPH) &&
verifier.EndTable();
}
CallOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(CallOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<CallOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct CallOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_subgraph(uint32_t subgraph) {
fbb_.AddElement<uint32_t>(CallOptions::VT_SUBGRAPH, subgraph, 0);
}
explicit CallOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
CallOptionsBuilder &operator=(const CallOptionsBuilder &);
flatbuffers::Offset<CallOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<CallOptions>(end);
return o;
}
};
inline flatbuffers::Offset<CallOptions> CreateCallOptions(
flatbuffers::FlatBufferBuilder &_fbb,
uint32_t subgraph = 0) {
CallOptionsBuilder builder_(_fbb);
builder_.add_subgraph(subgraph);
return builder_.Finish();
}
flatbuffers::Offset<CallOptions> CreateCallOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct PadOptionsT : public flatbuffers::NativeTable {
typedef PadOptions TableType;
PadOptionsT() {
}
};
struct PadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef PadOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
PadOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(PadOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<PadOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct PadOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit PadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
PadOptionsBuilder &operator=(const PadOptionsBuilder &);
flatbuffers::Offset<PadOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<PadOptions>(end);
return o;
}
};
inline flatbuffers::Offset<PadOptions> CreatePadOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
PadOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<PadOptions> CreatePadOptions(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct PadV2OptionsT : public flatbuffers::NativeTable {
typedef PadV2Options TableType;
PadV2OptionsT() {
}
};
struct PadV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef PadV2OptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
PadV2OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(PadV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<PadV2Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct PadV2OptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit PadV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
PadV2OptionsBuilder &operator=(const PadV2OptionsBuilder &);
flatbuffers::Offset<PadV2Options> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<PadV2Options>(end);
return o;
}
};
inline flatbuffers::Offset<PadV2Options> CreatePadV2Options(
flatbuffers::FlatBufferBuilder &_fbb) {
PadV2OptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<PadV2Options> CreatePadV2Options(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct ReshapeOptionsT : public flatbuffers::NativeTable {
typedef ReshapeOptions TableType;
std::vector<int32_t> new_shape;
ReshapeOptionsT() {
}
};
struct ReshapeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ReshapeOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NEW_SHAPE = 4
};
const flatbuffers::Vector<int32_t> *new_shape() const {
return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_NEW_SHAPE);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_NEW_SHAPE) &&
verifier.VerifyVector(new_shape()) &&
verifier.EndTable();
}
ReshapeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(ReshapeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<ReshapeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct ReshapeOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_new_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> new_shape) {
fbb_.AddOffset(ReshapeOptions::VT_NEW_SHAPE, new_shape);
}
explicit ReshapeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ReshapeOptionsBuilder &operator=(const ReshapeOptionsBuilder &);
flatbuffers::Offset<ReshapeOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ReshapeOptions>(end);
return o;
}
};
inline flatbuffers::Offset<ReshapeOptions> CreateReshapeOptions(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<int32_t>> new_shape = 0) {
ReshapeOptionsBuilder builder_(_fbb);
builder_.add_new_shape(new_shape);
return builder_.Finish();
}
inline flatbuffers::Offset<ReshapeOptions> CreateReshapeOptionsDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<int32_t> *new_shape = nullptr) {
auto new_shape__ = new_shape ? _fbb.CreateVector<int32_t>(*new_shape) : 0;
return tflite::CreateReshapeOptions(
_fbb,
new_shape__);
}
flatbuffers::Offset<ReshapeOptions> CreateReshapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct SpaceToBatchNDOptionsT : public flatbuffers::NativeTable {
typedef SpaceToBatchNDOptions TableType;
SpaceToBatchNDOptionsT() {
}
};
struct SpaceToBatchNDOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SpaceToBatchNDOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
SpaceToBatchNDOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(SpaceToBatchNDOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<SpaceToBatchNDOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct SpaceToBatchNDOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit SpaceToBatchNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SpaceToBatchNDOptionsBuilder &operator=(const SpaceToBatchNDOptionsBuilder &);
flatbuffers::Offset<SpaceToBatchNDOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<SpaceToBatchNDOptions>(end);
return o;
}
};
inline flatbuffers::Offset<SpaceToBatchNDOptions> CreateSpaceToBatchNDOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
SpaceToBatchNDOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<SpaceToBatchNDOptions> CreateSpaceToBatchNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct BatchToSpaceNDOptionsT : public flatbuffers::NativeTable {
typedef BatchToSpaceNDOptions TableType;
BatchToSpaceNDOptionsT() {
}
};
struct BatchToSpaceNDOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef BatchToSpaceNDOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
BatchToSpaceNDOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(BatchToSpaceNDOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<BatchToSpaceNDOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct BatchToSpaceNDOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit BatchToSpaceNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
BatchToSpaceNDOptionsBuilder &operator=(const BatchToSpaceNDOptionsBuilder &);
flatbuffers::Offset<BatchToSpaceNDOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<BatchToSpaceNDOptions>(end);
return o;
}
};
inline flatbuffers::Offset<BatchToSpaceNDOptions> CreateBatchToSpaceNDOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
BatchToSpaceNDOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<BatchToSpaceNDOptions> CreateBatchToSpaceNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct SkipGramOptionsT : public flatbuffers::NativeTable {
typedef SkipGramOptions TableType;
int32_t ngram_size;
int32_t max_skip_size;
bool include_all_ngrams;
SkipGramOptionsT()
: ngram_size(0),
max_skip_size(0),
include_all_ngrams(false) {
}
};
struct SkipGramOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SkipGramOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NGRAM_SIZE = 4,
VT_MAX_SKIP_SIZE = 6,
VT_INCLUDE_ALL_NGRAMS = 8
};
int32_t ngram_size() const {
return GetField<int32_t>(VT_NGRAM_SIZE, 0);
}
int32_t max_skip_size() const {
return GetField<int32_t>(VT_MAX_SKIP_SIZE, 0);
}
bool include_all_ngrams() const {
return GetField<uint8_t>(VT_INCLUDE_ALL_NGRAMS, 0) != 0;
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_NGRAM_SIZE) &&
VerifyField<int32_t>(verifier, VT_MAX_SKIP_SIZE) &&
VerifyField<uint8_t>(verifier, VT_INCLUDE_ALL_NGRAMS) &&
verifier.EndTable();
}
SkipGramOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(SkipGramOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<SkipGramOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct SkipGramOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_ngram_size(int32_t ngram_size) {
fbb_.AddElement<int32_t>(SkipGramOptions::VT_NGRAM_SIZE, ngram_size, 0);
}
void add_max_skip_size(int32_t max_skip_size) {
fbb_.AddElement<int32_t>(SkipGramOptions::VT_MAX_SKIP_SIZE, max_skip_size, 0);
}
void add_include_all_ngrams(bool include_all_ngrams) {
fbb_.AddElement<uint8_t>(SkipGramOptions::VT_INCLUDE_ALL_NGRAMS, static_cast<uint8_t>(include_all_ngrams), 0);
}
explicit SkipGramOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SkipGramOptionsBuilder &operator=(const SkipGramOptionsBuilder &);
flatbuffers::Offset<SkipGramOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<SkipGramOptions>(end);
return o;
}
};
inline flatbuffers::Offset<SkipGramOptions> CreateSkipGramOptions(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t ngram_size = 0,
int32_t max_skip_size = 0,
bool include_all_ngrams = false) {
SkipGramOptionsBuilder builder_(_fbb);
builder_.add_max_skip_size(max_skip_size);
builder_.add_ngram_size(ngram_size);
builder_.add_include_all_ngrams(include_all_ngrams);
return builder_.Finish();
}
flatbuffers::Offset<SkipGramOptions> CreateSkipGramOptions(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct SpaceToDepthOptionsT : public flatbuffers::NativeTable {
typedef SpaceToDepthOptions TableType;
int32_t block_size;
SpaceToDepthOptionsT()
: block_size(0) {
}
};
struct SpaceToDepthOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SpaceToDepthOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_BLOCK_SIZE = 4
};
int32_t block_size() const {
return GetField<int32_t>(VT_BLOCK_SIZE, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_BLOCK_SIZE) &&
verifier.EndTable();
}
SpaceToDepthOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(SpaceToDepthOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<SpaceToDepthOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct SpaceToDepthOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_block_size(int32_t block_size) {
fbb_.AddElement<int32_t>(SpaceToDepthOptions::VT_BLOCK_SIZE, block_size, 0);
}
explicit SpaceToDepthOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SpaceToDepthOptionsBuilder &operator=(const SpaceToDepthOptionsBuilder &);
flatbuffers::Offset<SpaceToDepthOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<SpaceToDepthOptions>(end);
return o;
}
};
inline flatbuffers::Offset<SpaceToDepthOptions> CreateSpaceToDepthOptions(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t block_size = 0) {
SpaceToDepthOptionsBuilder builder_(_fbb);
builder_.add_block_size(block_size);
return builder_.Finish();
}
flatbuffers::Offset<SpaceToDepthOptions> CreateSpaceToDepthOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct DepthToSpaceOptionsT : public flatbuffers::NativeTable {
typedef DepthToSpaceOptions TableType;
int32_t block_size;
DepthToSpaceOptionsT()
: block_size(0) {
}
};
struct DepthToSpaceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef DepthToSpaceOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_BLOCK_SIZE = 4
};
int32_t block_size() const {
return GetField<int32_t>(VT_BLOCK_SIZE, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_BLOCK_SIZE) &&
verifier.EndTable();
}
DepthToSpaceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(DepthToSpaceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<DepthToSpaceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct DepthToSpaceOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_block_size(int32_t block_size) {
fbb_.AddElement<int32_t>(DepthToSpaceOptions::VT_BLOCK_SIZE, block_size, 0);
}
explicit DepthToSpaceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
DepthToSpaceOptionsBuilder &operator=(const DepthToSpaceOptionsBuilder &);
flatbuffers::Offset<DepthToSpaceOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<DepthToSpaceOptions>(end);
return o;
}
};
inline flatbuffers::Offset<DepthToSpaceOptions> CreateDepthToSpaceOptions(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t block_size = 0) {
DepthToSpaceOptionsBuilder builder_(_fbb);
builder_.add_block_size(block_size);
return builder_.Finish();
}
flatbuffers::Offset<DepthToSpaceOptions> CreateDepthToSpaceOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct SubOptionsT : public flatbuffers::NativeTable {
typedef SubOptions TableType;
ActivationFunctionType fused_activation_function;
SubOptionsT()
: fused_activation_function(ActivationFunctionType_NONE) {
}
};
struct SubOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SubOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_FUSED_ACTIVATION_FUNCTION = 4
};
ActivationFunctionType fused_activation_function() const {
return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
verifier.EndTable();
}
SubOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(SubOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<SubOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct SubOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
fbb_.AddElement<int8_t>(SubOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
explicit SubOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SubOptionsBuilder &operator=(const SubOptionsBuilder &);
flatbuffers::Offset<SubOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<SubOptions>(end);
return o;
}
};
inline flatbuffers::Offset<SubOptions> CreateSubOptions(
flatbuffers::FlatBufferBuilder &_fbb,
ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) {
SubOptionsBuilder builder_(_fbb);
builder_.add_fused_activation_function(fused_activation_function);
return builder_.Finish();
}
flatbuffers::Offset<SubOptions> CreateSubOptions(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct DivOptionsT : public flatbuffers::NativeTable {
typedef DivOptions TableType;
ActivationFunctionType fused_activation_function;
DivOptionsT()
: fused_activation_function(ActivationFunctionType_NONE) {
}
};
struct DivOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef DivOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_FUSED_ACTIVATION_FUNCTION = 4
};
ActivationFunctionType fused_activation_function() const {
return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
verifier.EndTable();
}
DivOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(DivOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<DivOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct DivOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
fbb_.AddElement<int8_t>(DivOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
explicit DivOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
DivOptionsBuilder &operator=(const DivOptionsBuilder &);
flatbuffers::Offset<DivOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<DivOptions>(end);
return o;
}
};
inline flatbuffers::Offset<DivOptions> CreateDivOptions(
flatbuffers::FlatBufferBuilder &_fbb,
ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) {
DivOptionsBuilder builder_(_fbb);
builder_.add_fused_activation_function(fused_activation_function);
return builder_.Finish();
}
flatbuffers::Offset<DivOptions> CreateDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct TopKV2OptionsT : public flatbuffers::NativeTable {
typedef TopKV2Options TableType;
TopKV2OptionsT() {
}
};
struct TopKV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef TopKV2OptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
TopKV2OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(TopKV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<TopKV2Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct TopKV2OptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit TopKV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
TopKV2OptionsBuilder &operator=(const TopKV2OptionsBuilder &);
flatbuffers::Offset<TopKV2Options> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<TopKV2Options>(end);
return o;
}
};
inline flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(
flatbuffers::FlatBufferBuilder &_fbb) {
TopKV2OptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct EmbeddingLookupSparseOptionsT : public flatbuffers::NativeTable {
typedef EmbeddingLookupSparseOptions TableType;
CombinerType combiner;
EmbeddingLookupSparseOptionsT()
: combiner(CombinerType_SUM) {
}
};
struct EmbeddingLookupSparseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef EmbeddingLookupSparseOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_COMBINER = 4
};
CombinerType combiner() const {
return static_cast<CombinerType>(GetField<int8_t>(VT_COMBINER, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_COMBINER) &&
verifier.EndTable();
}
EmbeddingLookupSparseOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(EmbeddingLookupSparseOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<EmbeddingLookupSparseOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct EmbeddingLookupSparseOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_combiner(CombinerType combiner) {
fbb_.AddElement<int8_t>(EmbeddingLookupSparseOptions::VT_COMBINER, static_cast<int8_t>(combiner), 0);
}
explicit EmbeddingLookupSparseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
EmbeddingLookupSparseOptionsBuilder &operator=(const EmbeddingLookupSparseOptionsBuilder &);
flatbuffers::Offset<EmbeddingLookupSparseOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<EmbeddingLookupSparseOptions>(end);
return o;
}
};
inline flatbuffers::Offset<EmbeddingLookupSparseOptions> CreateEmbeddingLookupSparseOptions(
flatbuffers::FlatBufferBuilder &_fbb,
CombinerType combiner = CombinerType_SUM) {
EmbeddingLookupSparseOptionsBuilder builder_(_fbb);
builder_.add_combiner(combiner);
return builder_.Finish();
}
flatbuffers::Offset<EmbeddingLookupSparseOptions> CreateEmbeddingLookupSparseOptions(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct GatherOptionsT : public flatbuffers::NativeTable {
typedef GatherOptions TableType;
int32_t axis;
GatherOptionsT()
: axis(0) {
}
};
struct GatherOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef GatherOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_AXIS = 4
};
int32_t axis() const {
return GetField<int32_t>(VT_AXIS, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_AXIS) &&
verifier.EndTable();
}
GatherOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(GatherOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<GatherOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct GatherOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_axis(int32_t axis) {
fbb_.AddElement<int32_t>(GatherOptions::VT_AXIS, axis, 0);
}
explicit GatherOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
GatherOptionsBuilder &operator=(const GatherOptionsBuilder &);
flatbuffers::Offset<GatherOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<GatherOptions>(end);
return o;
}
};
inline flatbuffers::Offset<GatherOptions> CreateGatherOptions(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t axis = 0) {
GatherOptionsBuilder builder_(_fbb);
builder_.add_axis(axis);
return builder_.Finish();
}
flatbuffers::Offset<GatherOptions> CreateGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct TransposeOptionsT : public flatbuffers::NativeTable {
typedef TransposeOptions TableType;
TransposeOptionsT() {
}
};
struct TransposeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef TransposeOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
TransposeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(TransposeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<TransposeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct TransposeOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit TransposeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
TransposeOptionsBuilder &operator=(const TransposeOptionsBuilder &);
flatbuffers::Offset<TransposeOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<TransposeOptions>(end);
return o;
}
};
inline flatbuffers::Offset<TransposeOptions> CreateTransposeOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
TransposeOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<TransposeOptions> CreateTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct ExpOptionsT : public flatbuffers::NativeTable {
typedef ExpOptions TableType;
ExpOptionsT() {
}
};
struct ExpOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ExpOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
ExpOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(ExpOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<ExpOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct ExpOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit ExpOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ExpOptionsBuilder &operator=(const ExpOptionsBuilder &);
flatbuffers::Offset<ExpOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ExpOptions>(end);
return o;
}
};
inline flatbuffers::Offset<ExpOptions> CreateExpOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
ExpOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<ExpOptions> CreateExpOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct CosOptionsT : public flatbuffers::NativeTable {
typedef CosOptions TableType;
CosOptionsT() {
}
};
struct CosOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef CosOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
CosOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(CosOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<CosOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct CosOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit CosOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
CosOptionsBuilder &operator=(const CosOptionsBuilder &);
flatbuffers::Offset<CosOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<CosOptions>(end);
return o;
}
};
inline flatbuffers::Offset<CosOptions> CreateCosOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
CosOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<CosOptions> CreateCosOptions(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct ReducerOptionsT : public flatbuffers::NativeTable {
typedef ReducerOptions TableType;
bool keep_dims;
ReducerOptionsT()
: keep_dims(false) {
}
};
struct ReducerOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ReducerOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_KEEP_DIMS = 4
};
bool keep_dims() const {
return GetField<uint8_t>(VT_KEEP_DIMS, 0) != 0;
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_KEEP_DIMS) &&
verifier.EndTable();
}
ReducerOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(ReducerOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<ReducerOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct ReducerOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_keep_dims(bool keep_dims) {
fbb_.AddElement<uint8_t>(ReducerOptions::VT_KEEP_DIMS, static_cast<uint8_t>(keep_dims), 0);
}
explicit ReducerOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ReducerOptionsBuilder &operator=(const ReducerOptionsBuilder &);
flatbuffers::Offset<ReducerOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ReducerOptions>(end);
return o;
}
};
inline flatbuffers::Offset<ReducerOptions> CreateReducerOptions(
flatbuffers::FlatBufferBuilder &_fbb,
bool keep_dims = false) {
ReducerOptionsBuilder builder_(_fbb);
builder_.add_keep_dims(keep_dims);
return builder_.Finish();
}
flatbuffers::Offset<ReducerOptions> CreateReducerOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct SqueezeOptionsT : public flatbuffers::NativeTable {
typedef SqueezeOptions TableType;
std::vector<int32_t> squeeze_dims;
SqueezeOptionsT() {
}
};
struct SqueezeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SqueezeOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_SQUEEZE_DIMS = 4
};
const flatbuffers::Vector<int32_t> *squeeze_dims() const {
return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SQUEEZE_DIMS);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_SQUEEZE_DIMS) &&
verifier.VerifyVector(squeeze_dims()) &&
verifier.EndTable();
}
SqueezeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(SqueezeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<SqueezeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct SqueezeOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_squeeze_dims(flatbuffers::Offset<flatbuffers::Vector<int32_t>> squeeze_dims) {
fbb_.AddOffset(SqueezeOptions::VT_SQUEEZE_DIMS, squeeze_dims);
}
explicit SqueezeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SqueezeOptionsBuilder &operator=(const SqueezeOptionsBuilder &);
flatbuffers::Offset<SqueezeOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<SqueezeOptions>(end);
return o;
}
};
inline flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptions(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<int32_t>> squeeze_dims = 0) {
SqueezeOptionsBuilder builder_(_fbb);
builder_.add_squeeze_dims(squeeze_dims);
return builder_.Finish();
}
inline flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptionsDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<int32_t> *squeeze_dims = nullptr) {
auto squeeze_dims__ = squeeze_dims ? _fbb.CreateVector<int32_t>(*squeeze_dims) : 0;
return tflite::CreateSqueezeOptions(
_fbb,
squeeze_dims__);
}
flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptions(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct SplitOptionsT : public flatbuffers::NativeTable {
typedef SplitOptions TableType;
int32_t num_splits;
SplitOptionsT()
: num_splits(0) {
}
};
struct SplitOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SplitOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NUM_SPLITS = 4
};
int32_t num_splits() const {
return GetField<int32_t>(VT_NUM_SPLITS, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_NUM_SPLITS) &&
verifier.EndTable();
}
SplitOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(SplitOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<SplitOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct SplitOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_num_splits(int32_t num_splits) {
fbb_.AddElement<int32_t>(SplitOptions::VT_NUM_SPLITS, num_splits, 0);
}
explicit SplitOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SplitOptionsBuilder &operator=(const SplitOptionsBuilder &);
flatbuffers::Offset<SplitOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<SplitOptions>(end);
return o;
}
};
inline flatbuffers::Offset<SplitOptions> CreateSplitOptions(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t num_splits = 0) {
SplitOptionsBuilder builder_(_fbb);
builder_.add_num_splits(num_splits);
return builder_.Finish();
}
flatbuffers::Offset<SplitOptions> CreateSplitOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct SplitVOptionsT : public flatbuffers::NativeTable {
typedef SplitVOptions TableType;
int32_t num_splits;
SplitVOptionsT()
: num_splits(0) {
}
};
struct SplitVOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SplitVOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NUM_SPLITS = 4
};
int32_t num_splits() const {
return GetField<int32_t>(VT_NUM_SPLITS, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_NUM_SPLITS) &&
verifier.EndTable();
}
SplitVOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(SplitVOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<SplitVOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct SplitVOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_num_splits(int32_t num_splits) {
fbb_.AddElement<int32_t>(SplitVOptions::VT_NUM_SPLITS, num_splits, 0);
}
explicit SplitVOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SplitVOptionsBuilder &operator=(const SplitVOptionsBuilder &);
flatbuffers::Offset<SplitVOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<SplitVOptions>(end);
return o;
}
};
inline flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t num_splits = 0) {
SplitVOptionsBuilder builder_(_fbb);
builder_.add_num_splits(num_splits);
return builder_.Finish();
}
flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct StridedSliceOptionsT : public flatbuffers::NativeTable {
typedef StridedSliceOptions TableType;
int32_t begin_mask;
int32_t end_mask;
int32_t ellipsis_mask;
int32_t new_axis_mask;
int32_t shrink_axis_mask;
StridedSliceOptionsT()
: begin_mask(0),
end_mask(0),
ellipsis_mask(0),
new_axis_mask(0),
shrink_axis_mask(0) {
}
};
struct StridedSliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef StridedSliceOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_BEGIN_MASK = 4,
VT_END_MASK = 6,
VT_ELLIPSIS_MASK = 8,
VT_NEW_AXIS_MASK = 10,
VT_SHRINK_AXIS_MASK = 12
};
int32_t begin_mask() const {
return GetField<int32_t>(VT_BEGIN_MASK, 0);
}
int32_t end_mask() const {
return GetField<int32_t>(VT_END_MASK, 0);
}
int32_t ellipsis_mask() const {
return GetField<int32_t>(VT_ELLIPSIS_MASK, 0);
}
int32_t new_axis_mask() const {
return GetField<int32_t>(VT_NEW_AXIS_MASK, 0);
}
int32_t shrink_axis_mask() const {
return GetField<int32_t>(VT_SHRINK_AXIS_MASK, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_BEGIN_MASK) &&
VerifyField<int32_t>(verifier, VT_END_MASK) &&
VerifyField<int32_t>(verifier, VT_ELLIPSIS_MASK) &&
VerifyField<int32_t>(verifier, VT_NEW_AXIS_MASK) &&
VerifyField<int32_t>(verifier, VT_SHRINK_AXIS_MASK) &&
verifier.EndTable();
}
StridedSliceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(StridedSliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<StridedSliceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct StridedSliceOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_begin_mask(int32_t begin_mask) {
fbb_.AddElement<int32_t>(StridedSliceOptions::VT_BEGIN_MASK, begin_mask, 0);
}
void add_end_mask(int32_t end_mask) {
fbb_.AddElement<int32_t>(StridedSliceOptions::VT_END_MASK, end_mask, 0);
}
void add_ellipsis_mask(int32_t ellipsis_mask) {
fbb_.AddElement<int32_t>(StridedSliceOptions::VT_ELLIPSIS_MASK, ellipsis_mask, 0);
}
void add_new_axis_mask(int32_t new_axis_mask) {
fbb_.AddElement<int32_t>(StridedSliceOptions::VT_NEW_AXIS_MASK, new_axis_mask, 0);
}
void add_shrink_axis_mask(int32_t shrink_axis_mask) {
fbb_.AddElement<int32_t>(StridedSliceOptions::VT_SHRINK_AXIS_MASK, shrink_axis_mask, 0);
}
explicit StridedSliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
StridedSliceOptionsBuilder &operator=(const StridedSliceOptionsBuilder &);
flatbuffers::Offset<StridedSliceOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<StridedSliceOptions>(end);
return o;
}
};
inline flatbuffers::Offset<StridedSliceOptions> CreateStridedSliceOptions(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t begin_mask = 0,
int32_t end_mask = 0,
int32_t ellipsis_mask = 0,
int32_t new_axis_mask = 0,
int32_t shrink_axis_mask = 0) {
StridedSliceOptionsBuilder builder_(_fbb);
builder_.add_shrink_axis_mask(shrink_axis_mask);
builder_.add_new_axis_mask(new_axis_mask);
builder_.add_ellipsis_mask(ellipsis_mask);
builder_.add_end_mask(end_mask);
builder_.add_begin_mask(begin_mask);
return builder_.Finish();
}
flatbuffers::Offset<StridedSliceOptions> CreateStridedSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct LogSoftmaxOptionsT : public flatbuffers::NativeTable {
typedef LogSoftmaxOptions TableType;
LogSoftmaxOptionsT() {
}
};
struct LogSoftmaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef LogSoftmaxOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
LogSoftmaxOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(LogSoftmaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<LogSoftmaxOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct LogSoftmaxOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit LogSoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
LogSoftmaxOptionsBuilder &operator=(const LogSoftmaxOptionsBuilder &);
flatbuffers::Offset<LogSoftmaxOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<LogSoftmaxOptions>(end);
return o;
}
};
inline flatbuffers::Offset<LogSoftmaxOptions> CreateLogSoftmaxOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
LogSoftmaxOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<LogSoftmaxOptions> CreateLogSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct CastOptionsT : public flatbuffers::NativeTable {
typedef CastOptions TableType;
TensorType in_data_type;
TensorType out_data_type;
CastOptionsT()
: in_data_type(TensorType_FLOAT32),
out_data_type(TensorType_FLOAT32) {
}
};
struct CastOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef CastOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_IN_DATA_TYPE = 4,
VT_OUT_DATA_TYPE = 6
};
TensorType in_data_type() const {
return static_cast<TensorType>(GetField<int8_t>(VT_IN_DATA_TYPE, 0));
}
TensorType out_data_type() const {
return static_cast<TensorType>(GetField<int8_t>(VT_OUT_DATA_TYPE, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_IN_DATA_TYPE) &&
VerifyField<int8_t>(verifier, VT_OUT_DATA_TYPE) &&
verifier.EndTable();
}
CastOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(CastOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<CastOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct CastOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_in_data_type(TensorType in_data_type) {
fbb_.AddElement<int8_t>(CastOptions::VT_IN_DATA_TYPE, static_cast<int8_t>(in_data_type), 0);
}
void add_out_data_type(TensorType out_data_type) {
fbb_.AddElement<int8_t>(CastOptions::VT_OUT_DATA_TYPE, static_cast<int8_t>(out_data_type), 0);
}
explicit CastOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
CastOptionsBuilder &operator=(const CastOptionsBuilder &);
flatbuffers::Offset<CastOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<CastOptions>(end);
return o;
}
};
inline flatbuffers::Offset<CastOptions> CreateCastOptions(
flatbuffers::FlatBufferBuilder &_fbb,
TensorType in_data_type = TensorType_FLOAT32,
TensorType out_data_type = TensorType_FLOAT32) {
CastOptionsBuilder builder_(_fbb);
builder_.add_out_data_type(out_data_type);
builder_.add_in_data_type(in_data_type);
return builder_.Finish();
}
flatbuffers::Offset<CastOptions> CreateCastOptions(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct DequantizeOptionsT : public flatbuffers::NativeTable {
typedef DequantizeOptions TableType;
DequantizeOptionsT() {
}
};
struct DequantizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef DequantizeOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
DequantizeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(DequantizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<DequantizeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct DequantizeOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit DequantizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
DequantizeOptionsBuilder &operator=(const DequantizeOptionsBuilder &);
flatbuffers::Offset<DequantizeOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<DequantizeOptions>(end);
return o;
}
};
inline flatbuffers::Offset<DequantizeOptions> CreateDequantizeOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
DequantizeOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<DequantizeOptions> CreateDequantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct MaximumMinimumOptionsT : public flatbuffers::NativeTable {
typedef MaximumMinimumOptions TableType;
MaximumMinimumOptionsT() {
}
};
struct MaximumMinimumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef MaximumMinimumOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
MaximumMinimumOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(MaximumMinimumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<MaximumMinimumOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct MaximumMinimumOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit MaximumMinimumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
MaximumMinimumOptionsBuilder &operator=(const MaximumMinimumOptionsBuilder &);
flatbuffers::Offset<MaximumMinimumOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<MaximumMinimumOptions>(end);
return o;
}
};
inline flatbuffers::Offset<MaximumMinimumOptions> CreateMaximumMinimumOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
MaximumMinimumOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<MaximumMinimumOptions> CreateMaximumMinimumOptions(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct TileOptionsT : public flatbuffers::NativeTable {
typedef TileOptions TableType;
TileOptionsT() {
}
};
struct TileOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef TileOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
TileOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(TileOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<TileOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct TileOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit TileOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
TileOptionsBuilder &operator=(const TileOptionsBuilder &);
flatbuffers::Offset<TileOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<TileOptions>(end);
return o;
}
};
inline flatbuffers::Offset<TileOptions> CreateTileOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
TileOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<TileOptions> CreateTileOptions(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct ArgMaxOptionsT : public flatbuffers::NativeTable {
typedef ArgMaxOptions TableType;
TensorType output_type;
ArgMaxOptionsT()
: output_type(TensorType_FLOAT32) {
}
};
struct ArgMaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ArgMaxOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_OUTPUT_TYPE = 4
};
TensorType output_type() const {
return static_cast<TensorType>(GetField<int8_t>(VT_OUTPUT_TYPE, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_OUTPUT_TYPE) &&
verifier.EndTable();
}
ArgMaxOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(ArgMaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<ArgMaxOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct ArgMaxOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_output_type(TensorType output_type) {
fbb_.AddElement<int8_t>(ArgMaxOptions::VT_OUTPUT_TYPE, static_cast<int8_t>(output_type), 0);
}
explicit ArgMaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ArgMaxOptionsBuilder &operator=(const ArgMaxOptionsBuilder &);
flatbuffers::Offset<ArgMaxOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ArgMaxOptions>(end);
return o;
}
};
inline flatbuffers::Offset<ArgMaxOptions> CreateArgMaxOptions(
flatbuffers::FlatBufferBuilder &_fbb,
TensorType output_type = TensorType_FLOAT32) {
ArgMaxOptionsBuilder builder_(_fbb);
builder_.add_output_type(output_type);
return builder_.Finish();
}
flatbuffers::Offset<ArgMaxOptions> CreateArgMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct ArgMinOptionsT : public flatbuffers::NativeTable {
typedef ArgMinOptions TableType;
TensorType output_type;
ArgMinOptionsT()
: output_type(TensorType_FLOAT32) {
}
};
struct ArgMinOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ArgMinOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_OUTPUT_TYPE = 4
};
TensorType output_type() const {
return static_cast<TensorType>(GetField<int8_t>(VT_OUTPUT_TYPE, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_OUTPUT_TYPE) &&
verifier.EndTable();
}
ArgMinOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(ArgMinOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<ArgMinOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct ArgMinOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_output_type(TensorType output_type) {
fbb_.AddElement<int8_t>(ArgMinOptions::VT_OUTPUT_TYPE, static_cast<int8_t>(output_type), 0);
}
explicit ArgMinOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ArgMinOptionsBuilder &operator=(const ArgMinOptionsBuilder &);
flatbuffers::Offset<ArgMinOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ArgMinOptions>(end);
return o;
}
};
inline flatbuffers::Offset<ArgMinOptions> CreateArgMinOptions(
flatbuffers::FlatBufferBuilder &_fbb,
TensorType output_type = TensorType_FLOAT32) {
ArgMinOptionsBuilder builder_(_fbb);
builder_.add_output_type(output_type);
return builder_.Finish();
}
flatbuffers::Offset<ArgMinOptions> CreateArgMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct GreaterOptionsT : public flatbuffers::NativeTable {
typedef GreaterOptions TableType;
GreaterOptionsT() {
}
};
struct GreaterOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef GreaterOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
GreaterOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(GreaterOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<GreaterOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct GreaterOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit GreaterOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
GreaterOptionsBuilder &operator=(const GreaterOptionsBuilder &);
flatbuffers::Offset<GreaterOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<GreaterOptions>(end);
return o;
}
};
inline flatbuffers::Offset<GreaterOptions> CreateGreaterOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
GreaterOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<GreaterOptions> CreateGreaterOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct GreaterEqualOptionsT : public flatbuffers::NativeTable {
typedef GreaterEqualOptions TableType;
GreaterEqualOptionsT() {
}
};
struct GreaterEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef GreaterEqualOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
GreaterEqualOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(GreaterEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<GreaterEqualOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct GreaterEqualOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit GreaterEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
GreaterEqualOptionsBuilder &operator=(const GreaterEqualOptionsBuilder &);
flatbuffers::Offset<GreaterEqualOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<GreaterEqualOptions>(end);
return o;
}
};
inline flatbuffers::Offset<GreaterEqualOptions> CreateGreaterEqualOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
GreaterEqualOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<GreaterEqualOptions> CreateGreaterEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct LessOptionsT : public flatbuffers::NativeTable {
typedef LessOptions TableType;
LessOptionsT() {
}
};
struct LessOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef LessOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
LessOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(LessOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<LessOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct LessOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit LessOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
LessOptionsBuilder &operator=(const LessOptionsBuilder &);
flatbuffers::Offset<LessOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<LessOptions>(end);
return o;
}
};
inline flatbuffers::Offset<LessOptions> CreateLessOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
LessOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<LessOptions> CreateLessOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct LessEqualOptionsT : public flatbuffers::NativeTable {
typedef LessEqualOptions TableType;
LessEqualOptionsT() {
}
};
struct LessEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef LessEqualOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
LessEqualOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(LessEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<LessEqualOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct LessEqualOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit LessEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
LessEqualOptionsBuilder &operator=(const LessEqualOptionsBuilder &);
flatbuffers::Offset<LessEqualOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<LessEqualOptions>(end);
return o;
}
};
inline flatbuffers::Offset<LessEqualOptions> CreateLessEqualOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
LessEqualOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<LessEqualOptions> CreateLessEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct NegOptionsT : public flatbuffers::NativeTable {
typedef NegOptions TableType;
NegOptionsT() {
}
};
struct NegOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef NegOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
NegOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(NegOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<NegOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct NegOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit NegOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
NegOptionsBuilder &operator=(const NegOptionsBuilder &);
flatbuffers::Offset<NegOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<NegOptions>(end);
return o;
}
};
inline flatbuffers::Offset<NegOptions> CreateNegOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
NegOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<NegOptions> CreateNegOptions(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct SelectOptionsT : public flatbuffers::NativeTable {
typedef SelectOptions TableType;
SelectOptionsT() {
}
};
struct SelectOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SelectOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
SelectOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(SelectOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<SelectOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct SelectOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit SelectOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SelectOptionsBuilder &operator=(const SelectOptionsBuilder &);
flatbuffers::Offset<SelectOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<SelectOptions>(end);
return o;
}
};
inline flatbuffers::Offset<SelectOptions> CreateSelectOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
SelectOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<SelectOptions> CreateSelectOptions(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct SliceOptionsT : public flatbuffers::NativeTable {
typedef SliceOptions TableType;
SliceOptionsT() {
}
};
struct SliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SliceOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
SliceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(SliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<SliceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct SliceOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit SliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SliceOptionsBuilder &operator=(const SliceOptionsBuilder &);
flatbuffers::Offset<SliceOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<SliceOptions>(end);
return o;
}
};
inline flatbuffers::Offset<SliceOptions> CreateSliceOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
SliceOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<SliceOptions> CreateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct TransposeConvOptionsT : public flatbuffers::NativeTable {
typedef TransposeConvOptions TableType;
Padding padding;
int32_t stride_w;
int32_t stride_h;
TransposeConvOptionsT()
: padding(Padding_SAME),
stride_w(0),
stride_h(0) {
}
};
struct TransposeConvOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef TransposeConvOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_PADDING = 4,
VT_STRIDE_W = 6,
VT_STRIDE_H = 8
};
Padding padding() const {
return static_cast<Padding>(GetField<int8_t>(VT_PADDING, 0));
}
int32_t stride_w() const {
return GetField<int32_t>(VT_STRIDE_W, 0);
}
int32_t stride_h() const {
return GetField<int32_t>(VT_STRIDE_H, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_PADDING) &&
VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
verifier.EndTable();
}
TransposeConvOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(TransposeConvOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<TransposeConvOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct TransposeConvOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_padding(Padding padding) {
fbb_.AddElement<int8_t>(TransposeConvOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
}
void add_stride_w(int32_t stride_w) {
fbb_.AddElement<int32_t>(TransposeConvOptions::VT_STRIDE_W, stride_w, 0);
}
void add_stride_h(int32_t stride_h) {
fbb_.AddElement<int32_t>(TransposeConvOptions::VT_STRIDE_H, stride_h, 0);
}
explicit TransposeConvOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
TransposeConvOptionsBuilder &operator=(const TransposeConvOptionsBuilder &);
flatbuffers::Offset<TransposeConvOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<TransposeConvOptions>(end);
return o;
}
};
inline flatbuffers::Offset<TransposeConvOptions> CreateTransposeConvOptions(
flatbuffers::FlatBufferBuilder &_fbb,
Padding padding = Padding_SAME,
int32_t stride_w = 0,
int32_t stride_h = 0) {
TransposeConvOptionsBuilder builder_(_fbb);
builder_.add_stride_h(stride_h);
builder_.add_stride_w(stride_w);
builder_.add_padding(padding);
return builder_.Finish();
}
flatbuffers::Offset<TransposeConvOptions> CreateTransposeConvOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct ExpandDimsOptionsT : public flatbuffers::NativeTable {
typedef ExpandDimsOptions TableType;
ExpandDimsOptionsT() {
}
};
struct ExpandDimsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ExpandDimsOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
ExpandDimsOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(ExpandDimsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<ExpandDimsOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct ExpandDimsOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit ExpandDimsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ExpandDimsOptionsBuilder &operator=(const ExpandDimsOptionsBuilder &);
flatbuffers::Offset<ExpandDimsOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ExpandDimsOptions>(end);
return o;
}
};
inline flatbuffers::Offset<ExpandDimsOptions> CreateExpandDimsOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
ExpandDimsOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<ExpandDimsOptions> CreateExpandDimsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct SparseToDenseOptionsT : public flatbuffers::NativeTable {
typedef SparseToDenseOptions TableType;
bool validate_indices;
SparseToDenseOptionsT()
: validate_indices(false) {
}
};
struct SparseToDenseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SparseToDenseOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_VALIDATE_INDICES = 4
};
bool validate_indices() const {
return GetField<uint8_t>(VT_VALIDATE_INDICES, 0) != 0;
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_VALIDATE_INDICES) &&
verifier.EndTable();
}
SparseToDenseOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(SparseToDenseOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<SparseToDenseOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct SparseToDenseOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_validate_indices(bool validate_indices) {
fbb_.AddElement<uint8_t>(SparseToDenseOptions::VT_VALIDATE_INDICES, static_cast<uint8_t>(validate_indices), 0);
}
explicit SparseToDenseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SparseToDenseOptionsBuilder &operator=(const SparseToDenseOptionsBuilder &);
flatbuffers::Offset<SparseToDenseOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<SparseToDenseOptions>(end);
return o;
}
};
inline flatbuffers::Offset<SparseToDenseOptions> CreateSparseToDenseOptions(
flatbuffers::FlatBufferBuilder &_fbb,
bool validate_indices = false) {
SparseToDenseOptionsBuilder builder_(_fbb);
builder_.add_validate_indices(validate_indices);
return builder_.Finish();
}
flatbuffers::Offset<SparseToDenseOptions> CreateSparseToDenseOptions(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct EqualOptionsT : public flatbuffers::NativeTable {
typedef EqualOptions TableType;
EqualOptionsT() {
}
};
struct EqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef EqualOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
EqualOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(EqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<EqualOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct EqualOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit EqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
EqualOptionsBuilder &operator=(const EqualOptionsBuilder &);
flatbuffers::Offset<EqualOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<EqualOptions>(end);
return o;
}
};
inline flatbuffers::Offset<EqualOptions> CreateEqualOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
EqualOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<EqualOptions> CreateEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct NotEqualOptionsT : public flatbuffers::NativeTable {
typedef NotEqualOptions TableType;
NotEqualOptionsT() {
}
};
struct NotEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef NotEqualOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
NotEqualOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(NotEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<NotEqualOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct NotEqualOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit NotEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
NotEqualOptionsBuilder &operator=(const NotEqualOptionsBuilder &);
flatbuffers::Offset<NotEqualOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<NotEqualOptions>(end);
return o;
}
};
inline flatbuffers::Offset<NotEqualOptions> CreateNotEqualOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
NotEqualOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<NotEqualOptions> CreateNotEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct ShapeOptionsT : public flatbuffers::NativeTable {
typedef ShapeOptions TableType;
TensorType out_type;
ShapeOptionsT()
: out_type(TensorType_FLOAT32) {
}
};
struct ShapeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ShapeOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_OUT_TYPE = 4
};
TensorType out_type() const {
return static_cast<TensorType>(GetField<int8_t>(VT_OUT_TYPE, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_OUT_TYPE) &&
verifier.EndTable();
}
ShapeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(ShapeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<ShapeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct ShapeOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_out_type(TensorType out_type) {
fbb_.AddElement<int8_t>(ShapeOptions::VT_OUT_TYPE, static_cast<int8_t>(out_type), 0);
}
explicit ShapeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ShapeOptionsBuilder &operator=(const ShapeOptionsBuilder &);
flatbuffers::Offset<ShapeOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ShapeOptions>(end);
return o;
}
};
inline flatbuffers::Offset<ShapeOptions> CreateShapeOptions(
flatbuffers::FlatBufferBuilder &_fbb,
TensorType out_type = TensorType_FLOAT32) {
ShapeOptionsBuilder builder_(_fbb);
builder_.add_out_type(out_type);
return builder_.Finish();
}
flatbuffers::Offset<ShapeOptions> CreateShapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct RankOptionsT : public flatbuffers::NativeTable {
typedef RankOptions TableType;
RankOptionsT() {
}
};
struct RankOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef RankOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
RankOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(RankOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<RankOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct RankOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit RankOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
RankOptionsBuilder &operator=(const RankOptionsBuilder &);
flatbuffers::Offset<RankOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<RankOptions>(end);
return o;
}
};
inline flatbuffers::Offset<RankOptions> CreateRankOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
RankOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<RankOptions> CreateRankOptions(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct PowOptionsT : public flatbuffers::NativeTable {
typedef PowOptions TableType;
PowOptionsT() {
}
};
struct PowOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef PowOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
PowOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(PowOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<PowOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct PowOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit PowOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
PowOptionsBuilder &operator=(const PowOptionsBuilder &);
flatbuffers::Offset<PowOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<PowOptions>(end);
return o;
}
};
inline flatbuffers::Offset<PowOptions> CreatePowOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
PowOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<PowOptions> CreatePowOptions(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct FakeQuantOptionsT : public flatbuffers::NativeTable {
typedef FakeQuantOptions TableType;
float min;
float max;
int32_t num_bits;
bool narrow_range;
FakeQuantOptionsT()
: min(0.0f),
max(0.0f),
num_bits(0),
narrow_range(false) {
}
};
struct FakeQuantOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef FakeQuantOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_MIN = 4,
VT_MAX = 6,
VT_NUM_BITS = 8,
VT_NARROW_RANGE = 10
};
float min() const {
return GetField<float>(VT_MIN, 0.0f);
}
float max() const {
return GetField<float>(VT_MAX, 0.0f);
}
int32_t num_bits() const {
return GetField<int32_t>(VT_NUM_BITS, 0);
}
bool narrow_range() const {
return GetField<uint8_t>(VT_NARROW_RANGE, 0) != 0;
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<float>(verifier, VT_MIN) &&
VerifyField<float>(verifier, VT_MAX) &&
VerifyField<int32_t>(verifier, VT_NUM_BITS) &&
VerifyField<uint8_t>(verifier, VT_NARROW_RANGE) &&
verifier.EndTable();
}
FakeQuantOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(FakeQuantOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<FakeQuantOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct FakeQuantOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_min(float min) {
fbb_.AddElement<float>(FakeQuantOptions::VT_MIN, min, 0.0f);
}
void add_max(float max) {
fbb_.AddElement<float>(FakeQuantOptions::VT_MAX, max, 0.0f);
}
void add_num_bits(int32_t num_bits) {
fbb_.AddElement<int32_t>(FakeQuantOptions::VT_NUM_BITS, num_bits, 0);
}
void add_narrow_range(bool narrow_range) {
fbb_.AddElement<uint8_t>(FakeQuantOptions::VT_NARROW_RANGE, static_cast<uint8_t>(narrow_range), 0);
}
explicit FakeQuantOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
FakeQuantOptionsBuilder &operator=(const FakeQuantOptionsBuilder &);
flatbuffers::Offset<FakeQuantOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<FakeQuantOptions>(end);
return o;
}
};
inline flatbuffers::Offset<FakeQuantOptions> CreateFakeQuantOptions(
flatbuffers::FlatBufferBuilder &_fbb,
float min = 0.0f,
float max = 0.0f,
int32_t num_bits = 0,
bool narrow_range = false) {
FakeQuantOptionsBuilder builder_(_fbb);
builder_.add_num_bits(num_bits);
builder_.add_max(max);
builder_.add_min(min);
builder_.add_narrow_range(narrow_range);
return builder_.Finish();
}
flatbuffers::Offset<FakeQuantOptions> CreateFakeQuantOptions(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct PackOptionsT : public flatbuffers::NativeTable {
typedef PackOptions TableType;
int32_t values_count;
int32_t axis;
PackOptionsT()
: values_count(0),
axis(0) {
}
};
struct PackOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef PackOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_VALUES_COUNT = 4,
VT_AXIS = 6
};
int32_t values_count() const {
return GetField<int32_t>(VT_VALUES_COUNT, 0);
}
int32_t axis() const {
return GetField<int32_t>(VT_AXIS, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_VALUES_COUNT) &&
VerifyField<int32_t>(verifier, VT_AXIS) &&
verifier.EndTable();
}
PackOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(PackOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<PackOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct PackOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_values_count(int32_t values_count) {
fbb_.AddElement<int32_t>(PackOptions::VT_VALUES_COUNT, values_count, 0);
}
void add_axis(int32_t axis) {
fbb_.AddElement<int32_t>(PackOptions::VT_AXIS, axis, 0);
}
explicit PackOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
PackOptionsBuilder &operator=(const PackOptionsBuilder &);
flatbuffers::Offset<PackOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<PackOptions>(end);
return o;
}
};
inline flatbuffers::Offset<PackOptions> CreatePackOptions(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t values_count = 0,
int32_t axis = 0) {
PackOptionsBuilder builder_(_fbb);
builder_.add_axis(axis);
builder_.add_values_count(values_count);
return builder_.Finish();
}
flatbuffers::Offset<PackOptions> CreatePackOptions(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct LogicalOrOptionsT : public flatbuffers::NativeTable {
typedef LogicalOrOptions TableType;
LogicalOrOptionsT() {
}
};
struct LogicalOrOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef LogicalOrOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
LogicalOrOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(LogicalOrOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<LogicalOrOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct LogicalOrOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit LogicalOrOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
LogicalOrOptionsBuilder &operator=(const LogicalOrOptionsBuilder &);
flatbuffers::Offset<LogicalOrOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<LogicalOrOptions>(end);
return o;
}
};
inline flatbuffers::Offset<LogicalOrOptions> CreateLogicalOrOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
LogicalOrOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<LogicalOrOptions> CreateLogicalOrOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct OneHotOptionsT : public flatbuffers::NativeTable {
typedef OneHotOptions TableType;
int32_t axis;
OneHotOptionsT()
: axis(0) {
}
};
struct OneHotOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef OneHotOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_AXIS = 4
};
int32_t axis() const {
return GetField<int32_t>(VT_AXIS, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_AXIS) &&
verifier.EndTable();
}
OneHotOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(OneHotOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<OneHotOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct OneHotOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_axis(int32_t axis) {
fbb_.AddElement<int32_t>(OneHotOptions::VT_AXIS, axis, 0);
}
explicit OneHotOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
OneHotOptionsBuilder &operator=(const OneHotOptionsBuilder &);
flatbuffers::Offset<OneHotOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<OneHotOptions>(end);
return o;
}
};
inline flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t axis = 0) {
OneHotOptionsBuilder builder_(_fbb);
builder_.add_axis(axis);
return builder_.Finish();
}
flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct AbsOptionsT : public flatbuffers::NativeTable {
typedef AbsOptions TableType;
AbsOptionsT() {
}
};
struct AbsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef AbsOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
AbsOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(AbsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<AbsOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct AbsOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit AbsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
AbsOptionsBuilder &operator=(const AbsOptionsBuilder &);
flatbuffers::Offset<AbsOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<AbsOptions>(end);
return o;
}
};
inline flatbuffers::Offset<AbsOptions> CreateAbsOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
AbsOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<AbsOptions> CreateAbsOptions(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct HardSwishOptionsT : public flatbuffers::NativeTable {
typedef HardSwishOptions TableType;
HardSwishOptionsT() {
}
};
struct HardSwishOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef HardSwishOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
HardSwishOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(HardSwishOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<HardSwishOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct HardSwishOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit HardSwishOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
HardSwishOptionsBuilder &operator=(const HardSwishOptionsBuilder &);
flatbuffers::Offset<HardSwishOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<HardSwishOptions>(end);
return o;
}
};
inline flatbuffers::Offset<HardSwishOptions> CreateHardSwishOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
HardSwishOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<HardSwishOptions> CreateHardSwishOptions(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct LogicalAndOptionsT : public flatbuffers::NativeTable {
typedef LogicalAndOptions TableType;
LogicalAndOptionsT() {
}
};
struct LogicalAndOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef LogicalAndOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
LogicalAndOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(LogicalAndOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<LogicalAndOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct LogicalAndOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit LogicalAndOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
LogicalAndOptionsBuilder &operator=(const LogicalAndOptionsBuilder &);
flatbuffers::Offset<LogicalAndOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<LogicalAndOptions>(end);
return o;
}
};
inline flatbuffers::Offset<LogicalAndOptions> CreateLogicalAndOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
LogicalAndOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<LogicalAndOptions> CreateLogicalAndOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct LogicalNotOptionsT : public flatbuffers::NativeTable {
typedef LogicalNotOptions TableType;
LogicalNotOptionsT() {
}
};
struct LogicalNotOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef LogicalNotOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
LogicalNotOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(LogicalNotOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<LogicalNotOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct LogicalNotOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit LogicalNotOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
LogicalNotOptionsBuilder &operator=(const LogicalNotOptionsBuilder &);
flatbuffers::Offset<LogicalNotOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<LogicalNotOptions>(end);
return o;
}
};
inline flatbuffers::Offset<LogicalNotOptions> CreateLogicalNotOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
LogicalNotOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<LogicalNotOptions> CreateLogicalNotOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct UnpackOptionsT : public flatbuffers::NativeTable {
typedef UnpackOptions TableType;
int32_t num;
int32_t axis;
UnpackOptionsT()
: num(0),
axis(0) {
}
};
struct UnpackOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef UnpackOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NUM = 4,
VT_AXIS = 6
};
int32_t num() const {
return GetField<int32_t>(VT_NUM, 0);
}
int32_t axis() const {
return GetField<int32_t>(VT_AXIS, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_NUM) &&
VerifyField<int32_t>(verifier, VT_AXIS) &&
verifier.EndTable();
}
UnpackOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(UnpackOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<UnpackOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct UnpackOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_num(int32_t num) {
fbb_.AddElement<int32_t>(UnpackOptions::VT_NUM, num, 0);
}
void add_axis(int32_t axis) {
fbb_.AddElement<int32_t>(UnpackOptions::VT_AXIS, axis, 0);
}
explicit UnpackOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
UnpackOptionsBuilder &operator=(const UnpackOptionsBuilder &);
flatbuffers::Offset<UnpackOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<UnpackOptions>(end);
return o;
}
};
inline flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t num = 0,
int32_t axis = 0) {
UnpackOptionsBuilder builder_(_fbb);
builder_.add_axis(axis);
builder_.add_num(num);
return builder_.Finish();
}
flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct FloorDivOptionsT : public flatbuffers::NativeTable {
typedef FloorDivOptions TableType;
FloorDivOptionsT() {
}
};
struct FloorDivOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef FloorDivOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
FloorDivOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(FloorDivOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<FloorDivOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct FloorDivOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit FloorDivOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
FloorDivOptionsBuilder &operator=(const FloorDivOptionsBuilder &);
flatbuffers::Offset<FloorDivOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<FloorDivOptions>(end);
return o;
}
};
inline flatbuffers::Offset<FloorDivOptions> CreateFloorDivOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
FloorDivOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<FloorDivOptions> CreateFloorDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct SquareOptionsT : public flatbuffers::NativeTable {
typedef SquareOptions TableType;
SquareOptionsT() {
}
};
struct SquareOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SquareOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
SquareOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(SquareOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<SquareOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct SquareOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit SquareOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SquareOptionsBuilder &operator=(const SquareOptionsBuilder &);
flatbuffers::Offset<SquareOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<SquareOptions>(end);
return o;
}
};
inline flatbuffers::Offset<SquareOptions> CreateSquareOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
SquareOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<SquareOptions> CreateSquareOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct ZerosLikeOptionsT : public flatbuffers::NativeTable {
typedef ZerosLikeOptions TableType;
ZerosLikeOptionsT() {
}
};
struct ZerosLikeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ZerosLikeOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
ZerosLikeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(ZerosLikeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<ZerosLikeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct ZerosLikeOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit ZerosLikeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ZerosLikeOptionsBuilder &operator=(const ZerosLikeOptionsBuilder &);
flatbuffers::Offset<ZerosLikeOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ZerosLikeOptions>(end);
return o;
}
};
inline flatbuffers::Offset<ZerosLikeOptions> CreateZerosLikeOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
ZerosLikeOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<ZerosLikeOptions> CreateZerosLikeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct FillOptionsT : public flatbuffers::NativeTable {
typedef FillOptions TableType;
FillOptionsT() {
}
};
struct FillOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef FillOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
FillOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(FillOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<FillOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct FillOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit FillOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
FillOptionsBuilder &operator=(const FillOptionsBuilder &);
flatbuffers::Offset<FillOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<FillOptions>(end);
return o;
}
};
inline flatbuffers::Offset<FillOptions> CreateFillOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
FillOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<FillOptions> CreateFillOptions(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct FloorModOptionsT : public flatbuffers::NativeTable {
typedef FloorModOptions TableType;
FloorModOptionsT() {
}
};
struct FloorModOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef FloorModOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
FloorModOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(FloorModOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<FloorModOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct FloorModOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit FloorModOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
FloorModOptionsBuilder &operator=(const FloorModOptionsBuilder &);
flatbuffers::Offset<FloorModOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<FloorModOptions>(end);
return o;
}
};
inline flatbuffers::Offset<FloorModOptions> CreateFloorModOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
FloorModOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<FloorModOptions> CreateFloorModOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct RangeOptionsT : public flatbuffers::NativeTable {
typedef RangeOptions TableType;
RangeOptionsT() {
}
};
struct RangeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef RangeOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
RangeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(RangeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<RangeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct RangeOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit RangeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
RangeOptionsBuilder &operator=(const RangeOptionsBuilder &);
flatbuffers::Offset<RangeOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<RangeOptions>(end);
return o;
}
};
inline flatbuffers::Offset<RangeOptions> CreateRangeOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
RangeOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<RangeOptions> CreateRangeOptions(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct LeakyReluOptionsT : public flatbuffers::NativeTable {
typedef LeakyReluOptions TableType;
float alpha;
LeakyReluOptionsT()
: alpha(0.0f) {
}
};
struct LeakyReluOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef LeakyReluOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ALPHA = 4
};
float alpha() const {
return GetField<float>(VT_ALPHA, 0.0f);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<float>(verifier, VT_ALPHA) &&
verifier.EndTable();
}
LeakyReluOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(LeakyReluOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<LeakyReluOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct LeakyReluOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_alpha(float alpha) {
fbb_.AddElement<float>(LeakyReluOptions::VT_ALPHA, alpha, 0.0f);
}
explicit LeakyReluOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
LeakyReluOptionsBuilder &operator=(const LeakyReluOptionsBuilder &);
flatbuffers::Offset<LeakyReluOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<LeakyReluOptions>(end);
return o;
}
};
inline flatbuffers::Offset<LeakyReluOptions> CreateLeakyReluOptions(
flatbuffers::FlatBufferBuilder &_fbb,
float alpha = 0.0f) {
LeakyReluOptionsBuilder builder_(_fbb);
builder_.add_alpha(alpha);
return builder_.Finish();
}
flatbuffers::Offset<LeakyReluOptions> CreateLeakyReluOptions(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct SquaredDifferenceOptionsT : public flatbuffers::NativeTable {
typedef SquaredDifferenceOptions TableType;
SquaredDifferenceOptionsT() {
}
};
struct SquaredDifferenceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SquaredDifferenceOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
SquaredDifferenceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(SquaredDifferenceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<SquaredDifferenceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct SquaredDifferenceOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit SquaredDifferenceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SquaredDifferenceOptionsBuilder &operator=(const SquaredDifferenceOptionsBuilder &);
flatbuffers::Offset<SquaredDifferenceOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<SquaredDifferenceOptions>(end);
return o;
}
};
inline flatbuffers::Offset<SquaredDifferenceOptions> CreateSquaredDifferenceOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
SquaredDifferenceOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<SquaredDifferenceOptions> CreateSquaredDifferenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct MirrorPadOptionsT : public flatbuffers::NativeTable {
typedef MirrorPadOptions TableType;
MirrorPadMode mode;
MirrorPadOptionsT()
: mode(MirrorPadMode_REFLECT) {
}
};
struct MirrorPadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef MirrorPadOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_MODE = 4
};
MirrorPadMode mode() const {
return static_cast<MirrorPadMode>(GetField<int8_t>(VT_MODE, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_MODE) &&
verifier.EndTable();
}
MirrorPadOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(MirrorPadOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<MirrorPadOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct MirrorPadOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_mode(MirrorPadMode mode) {
fbb_.AddElement<int8_t>(MirrorPadOptions::VT_MODE, static_cast<int8_t>(mode), 0);
}
explicit MirrorPadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
MirrorPadOptionsBuilder &operator=(const MirrorPadOptionsBuilder &);
flatbuffers::Offset<MirrorPadOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<MirrorPadOptions>(end);
return o;
}
};
inline flatbuffers::Offset<MirrorPadOptions> CreateMirrorPadOptions(
flatbuffers::FlatBufferBuilder &_fbb,
MirrorPadMode mode = MirrorPadMode_REFLECT) {
MirrorPadOptionsBuilder builder_(_fbb);
builder_.add_mode(mode);
return builder_.Finish();
}
flatbuffers::Offset<MirrorPadOptions> CreateMirrorPadOptions(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct UniqueOptionsT : public flatbuffers::NativeTable {
typedef UniqueOptions TableType;
TensorType idx_out_type;
UniqueOptionsT()
: idx_out_type(TensorType_INT32) {
}
};
struct UniqueOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef UniqueOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_IDX_OUT_TYPE = 4
};
TensorType idx_out_type() const {
return static_cast<TensorType>(GetField<int8_t>(VT_IDX_OUT_TYPE, 2));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_IDX_OUT_TYPE) &&
verifier.EndTable();
}
UniqueOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(UniqueOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<UniqueOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct UniqueOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_idx_out_type(TensorType idx_out_type) {
fbb_.AddElement<int8_t>(UniqueOptions::VT_IDX_OUT_TYPE, static_cast<int8_t>(idx_out_type), 2);
}
explicit UniqueOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
UniqueOptionsBuilder &operator=(const UniqueOptionsBuilder &);
flatbuffers::Offset<UniqueOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<UniqueOptions>(end);
return o;
}
};
inline flatbuffers::Offset<UniqueOptions> CreateUniqueOptions(
flatbuffers::FlatBufferBuilder &_fbb,
TensorType idx_out_type = TensorType_INT32) {
UniqueOptionsBuilder builder_(_fbb);
builder_.add_idx_out_type(idx_out_type);
return builder_.Finish();
}
flatbuffers::Offset<UniqueOptions> CreateUniqueOptions(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct ReverseV2OptionsT : public flatbuffers::NativeTable {
typedef ReverseV2Options TableType;
ReverseV2OptionsT() {
}
};
struct ReverseV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ReverseV2OptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
ReverseV2OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(ReverseV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<ReverseV2Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct ReverseV2OptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit ReverseV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ReverseV2OptionsBuilder &operator=(const ReverseV2OptionsBuilder &);
flatbuffers::Offset<ReverseV2Options> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ReverseV2Options>(end);
return o;
}
};
inline flatbuffers::Offset<ReverseV2Options> CreateReverseV2Options(
flatbuffers::FlatBufferBuilder &_fbb) {
ReverseV2OptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<ReverseV2Options> CreateReverseV2Options(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct AddNOptionsT : public flatbuffers::NativeTable {
typedef AddNOptions TableType;
AddNOptionsT() {
}
};
struct AddNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef AddNOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
AddNOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(AddNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<AddNOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct AddNOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit AddNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
AddNOptionsBuilder &operator=(const AddNOptionsBuilder &);
flatbuffers::Offset<AddNOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<AddNOptions>(end);
return o;
}
};
inline flatbuffers::Offset<AddNOptions> CreateAddNOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
AddNOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<AddNOptions> CreateAddNOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct GatherNdOptionsT : public flatbuffers::NativeTable {
typedef GatherNdOptions TableType;
GatherNdOptionsT() {
}
};
struct GatherNdOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef GatherNdOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
GatherNdOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(GatherNdOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<GatherNdOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct GatherNdOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit GatherNdOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
GatherNdOptionsBuilder &operator=(const GatherNdOptionsBuilder &);
flatbuffers::Offset<GatherNdOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<GatherNdOptions>(end);
return o;
}
};
inline flatbuffers::Offset<GatherNdOptions> CreateGatherNdOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
GatherNdOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<GatherNdOptions> CreateGatherNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct WhereOptionsT : public flatbuffers::NativeTable {
typedef WhereOptions TableType;
WhereOptionsT() {
}
};
struct WhereOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef WhereOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
WhereOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(WhereOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<WhereOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct WhereOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit WhereOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
WhereOptionsBuilder &operator=(const WhereOptionsBuilder &);
flatbuffers::Offset<WhereOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<WhereOptions>(end);
return o;
}
};
inline flatbuffers::Offset<WhereOptions> CreateWhereOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
WhereOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<WhereOptions> CreateWhereOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct ReverseSequenceOptionsT : public flatbuffers::NativeTable {
typedef ReverseSequenceOptions TableType;
int32_t seq_dim;
int32_t batch_dim;
ReverseSequenceOptionsT()
: seq_dim(0),
batch_dim(0) {
}
};
struct ReverseSequenceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ReverseSequenceOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_SEQ_DIM = 4,
VT_BATCH_DIM = 6
};
int32_t seq_dim() const {
return GetField<int32_t>(VT_SEQ_DIM, 0);
}
int32_t batch_dim() const {
return GetField<int32_t>(VT_BATCH_DIM, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_SEQ_DIM) &&
VerifyField<int32_t>(verifier, VT_BATCH_DIM) &&
verifier.EndTable();
}
ReverseSequenceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(ReverseSequenceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<ReverseSequenceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct ReverseSequenceOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_seq_dim(int32_t seq_dim) {
fbb_.AddElement<int32_t>(ReverseSequenceOptions::VT_SEQ_DIM, seq_dim, 0);
}
void add_batch_dim(int32_t batch_dim) {
fbb_.AddElement<int32_t>(ReverseSequenceOptions::VT_BATCH_DIM, batch_dim, 0);
}
explicit ReverseSequenceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ReverseSequenceOptionsBuilder &operator=(const ReverseSequenceOptionsBuilder &);
flatbuffers::Offset<ReverseSequenceOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ReverseSequenceOptions>(end);
return o;
}
};
inline flatbuffers::Offset<ReverseSequenceOptions> CreateReverseSequenceOptions(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t seq_dim = 0,
int32_t batch_dim = 0) {
ReverseSequenceOptionsBuilder builder_(_fbb);
builder_.add_batch_dim(batch_dim);
builder_.add_seq_dim(seq_dim);
return builder_.Finish();
}
flatbuffers::Offset<ReverseSequenceOptions> CreateReverseSequenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct MatrixDiagOptionsT : public flatbuffers::NativeTable {
typedef MatrixDiagOptions TableType;
MatrixDiagOptionsT() {
}
};
struct MatrixDiagOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef MatrixDiagOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
MatrixDiagOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(MatrixDiagOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<MatrixDiagOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct MatrixDiagOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit MatrixDiagOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
MatrixDiagOptionsBuilder &operator=(const MatrixDiagOptionsBuilder &);
flatbuffers::Offset<MatrixDiagOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<MatrixDiagOptions>(end);
return o;
}
};
inline flatbuffers::Offset<MatrixDiagOptions> CreateMatrixDiagOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
MatrixDiagOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<MatrixDiagOptions> CreateMatrixDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct QuantizeOptionsT : public flatbuffers::NativeTable {
typedef QuantizeOptions TableType;
QuantizeOptionsT() {
}
};
struct QuantizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef QuantizeOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
QuantizeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(QuantizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<QuantizeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct QuantizeOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit QuantizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
QuantizeOptionsBuilder &operator=(const QuantizeOptionsBuilder &);
flatbuffers::Offset<QuantizeOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<QuantizeOptions>(end);
return o;
}
};
inline flatbuffers::Offset<QuantizeOptions> CreateQuantizeOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
QuantizeOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<QuantizeOptions> CreateQuantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct MatrixSetDiagOptionsT : public flatbuffers::NativeTable {
typedef MatrixSetDiagOptions TableType;
MatrixSetDiagOptionsT() {
}
};
struct MatrixSetDiagOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef MatrixSetDiagOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
MatrixSetDiagOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(MatrixSetDiagOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<MatrixSetDiagOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct MatrixSetDiagOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit MatrixSetDiagOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
MatrixSetDiagOptionsBuilder &operator=(const MatrixSetDiagOptionsBuilder &);
flatbuffers::Offset<MatrixSetDiagOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<MatrixSetDiagOptions>(end);
return o;
}
};
inline flatbuffers::Offset<MatrixSetDiagOptions> CreateMatrixSetDiagOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
MatrixSetDiagOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<MatrixSetDiagOptions> CreateMatrixSetDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct IfOptionsT : public flatbuffers::NativeTable {
typedef IfOptions TableType;
int32_t then_subgraph_index;
int32_t else_subgraph_index;
IfOptionsT()
: then_subgraph_index(0),
else_subgraph_index(0) {
}
};
struct IfOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef IfOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_THEN_SUBGRAPH_INDEX = 4,
VT_ELSE_SUBGRAPH_INDEX = 6
};
int32_t then_subgraph_index() const {
return GetField<int32_t>(VT_THEN_SUBGRAPH_INDEX, 0);
}
int32_t else_subgraph_index() const {
return GetField<int32_t>(VT_ELSE_SUBGRAPH_INDEX, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_THEN_SUBGRAPH_INDEX) &&
VerifyField<int32_t>(verifier, VT_ELSE_SUBGRAPH_INDEX) &&
verifier.EndTable();
}
IfOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(IfOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<IfOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct IfOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_then_subgraph_index(int32_t then_subgraph_index) {
fbb_.AddElement<int32_t>(IfOptions::VT_THEN_SUBGRAPH_INDEX, then_subgraph_index, 0);
}
void add_else_subgraph_index(int32_t else_subgraph_index) {
fbb_.AddElement<int32_t>(IfOptions::VT_ELSE_SUBGRAPH_INDEX, else_subgraph_index, 0);
}
explicit IfOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
IfOptionsBuilder &operator=(const IfOptionsBuilder &);
flatbuffers::Offset<IfOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<IfOptions>(end);
return o;
}
};
inline flatbuffers::Offset<IfOptions> CreateIfOptions(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t then_subgraph_index = 0,
int32_t else_subgraph_index = 0) {
IfOptionsBuilder builder_(_fbb);
builder_.add_else_subgraph_index(else_subgraph_index);
builder_.add_then_subgraph_index(then_subgraph_index);
return builder_.Finish();
}
flatbuffers::Offset<IfOptions> CreateIfOptions(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct WhileOptionsT : public flatbuffers::NativeTable {
typedef WhileOptions TableType;
int32_t cond_subgraph_index;
int32_t body_subgraph_index;
WhileOptionsT()
: cond_subgraph_index(0),
body_subgraph_index(0) {
}
};
struct WhileOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef WhileOptionsT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_COND_SUBGRAPH_INDEX = 4,
VT_BODY_SUBGRAPH_INDEX = 6
};
int32_t cond_subgraph_index() const {
return GetField<int32_t>(VT_COND_SUBGRAPH_INDEX, 0);
}
int32_t body_subgraph_index() const {
return GetField<int32_t>(VT_BODY_SUBGRAPH_INDEX, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_COND_SUBGRAPH_INDEX) &&
VerifyField<int32_t>(verifier, VT_BODY_SUBGRAPH_INDEX) &&
verifier.EndTable();
}
WhileOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(WhileOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<WhileOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct WhileOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_cond_subgraph_index(int32_t cond_subgraph_index) {
fbb_.AddElement<int32_t>(WhileOptions::VT_COND_SUBGRAPH_INDEX, cond_subgraph_index, 0);
}
void add_body_subgraph_index(int32_t body_subgraph_index) {
fbb_.AddElement<int32_t>(WhileOptions::VT_BODY_SUBGRAPH_INDEX, body_subgraph_index, 0);
}
explicit WhileOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
WhileOptionsBuilder &operator=(const WhileOptionsBuilder &);
flatbuffers::Offset<WhileOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<WhileOptions>(end);
return o;
}
};
inline flatbuffers::Offset<WhileOptions> CreateWhileOptions(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t cond_subgraph_index = 0,
int32_t body_subgraph_index = 0) {
WhileOptionsBuilder builder_(_fbb);
builder_.add_body_subgraph_index(body_subgraph_index);
builder_.add_cond_subgraph_index(cond_subgraph_index);
return builder_.Finish();
}
flatbuffers::Offset<WhileOptions> CreateWhileOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct NonMaxSuppressionV4OptionsT : public flatbuffers::NativeTable {
typedef NonMaxSuppressionV4Options TableType;
NonMaxSuppressionV4OptionsT() {
}
};
struct NonMaxSuppressionV4Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef NonMaxSuppressionV4OptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
NonMaxSuppressionV4OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(NonMaxSuppressionV4OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<NonMaxSuppressionV4Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct NonMaxSuppressionV4OptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit NonMaxSuppressionV4OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
NonMaxSuppressionV4OptionsBuilder &operator=(const NonMaxSuppressionV4OptionsBuilder &);
flatbuffers::Offset<NonMaxSuppressionV4Options> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<NonMaxSuppressionV4Options>(end);
return o;
}
};
inline flatbuffers::Offset<NonMaxSuppressionV4Options> CreateNonMaxSuppressionV4Options(
flatbuffers::FlatBufferBuilder &_fbb) {
NonMaxSuppressionV4OptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<NonMaxSuppressionV4Options> CreateNonMaxSuppressionV4Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct NonMaxSuppressionV5OptionsT : public flatbuffers::NativeTable {
typedef NonMaxSuppressionV5Options TableType;
NonMaxSuppressionV5OptionsT() {
}
};
struct NonMaxSuppressionV5Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef NonMaxSuppressionV5OptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
NonMaxSuppressionV5OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(NonMaxSuppressionV5OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<NonMaxSuppressionV5Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct NonMaxSuppressionV5OptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit NonMaxSuppressionV5OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
NonMaxSuppressionV5OptionsBuilder &operator=(const NonMaxSuppressionV5OptionsBuilder &);
flatbuffers::Offset<NonMaxSuppressionV5Options> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<NonMaxSuppressionV5Options>(end);
return o;
}
};
inline flatbuffers::Offset<NonMaxSuppressionV5Options> CreateNonMaxSuppressionV5Options(
flatbuffers::FlatBufferBuilder &_fbb) {
NonMaxSuppressionV5OptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<NonMaxSuppressionV5Options> CreateNonMaxSuppressionV5Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct ScatterNdOptionsT : public flatbuffers::NativeTable {
typedef ScatterNdOptions TableType;
ScatterNdOptionsT() {
}
};
struct ScatterNdOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ScatterNdOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
ScatterNdOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(ScatterNdOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<ScatterNdOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct ScatterNdOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit ScatterNdOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ScatterNdOptionsBuilder &operator=(const ScatterNdOptionsBuilder &);
flatbuffers::Offset<ScatterNdOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ScatterNdOptions>(end);
return o;
}
};
inline flatbuffers::Offset<ScatterNdOptions> CreateScatterNdOptions(
flatbuffers::FlatBufferBuilder &_fbb) {
ScatterNdOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<ScatterNdOptions> CreateScatterNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct SelectV2OptionsT : public flatbuffers::NativeTable {
typedef SelectV2Options TableType;
SelectV2OptionsT() {
}
};
struct SelectV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SelectV2OptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
SelectV2OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(SelectV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<SelectV2Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct SelectV2OptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
explicit SelectV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SelectV2OptionsBuilder &operator=(const SelectV2OptionsBuilder &);
flatbuffers::Offset<SelectV2Options> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<SelectV2Options>(end);
return o;
}
};
inline flatbuffers::Offset<SelectV2Options> CreateSelectV2Options(
flatbuffers::FlatBufferBuilder &_fbb) {
SelectV2OptionsBuilder builder_(_fbb);
return builder_.Finish();
}
flatbuffers::Offset<SelectV2Options> CreateSelectV2Options(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct OperatorCodeT : public flatbuffers::NativeTable {
typedef OperatorCode TableType;
BuiltinOperator builtin_code;
std::string custom_code;
int32_t version;
OperatorCodeT()
: builtin_code(BuiltinOperator_ADD),
version(1) {
}
};
struct OperatorCode FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef OperatorCodeT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_BUILTIN_CODE = 4,
VT_CUSTOM_CODE = 6,
VT_VERSION = 8
};
BuiltinOperator builtin_code() const {
return static_cast<BuiltinOperator>(GetField<int8_t>(VT_BUILTIN_CODE, 0));
}
const flatbuffers::String *custom_code() const {
return GetPointer<const flatbuffers::String *>(VT_CUSTOM_CODE);
}
int32_t version() const {
return GetField<int32_t>(VT_VERSION, 1);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_BUILTIN_CODE) &&
VerifyOffset(verifier, VT_CUSTOM_CODE) &&
verifier.VerifyString(custom_code()) &&
VerifyField<int32_t>(verifier, VT_VERSION) &&
verifier.EndTable();
}
OperatorCodeT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(OperatorCodeT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<OperatorCode> Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct OperatorCodeBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_builtin_code(BuiltinOperator builtin_code) {
fbb_.AddElement<int8_t>(OperatorCode::VT_BUILTIN_CODE, static_cast<int8_t>(builtin_code), 0);
}
void add_custom_code(flatbuffers::Offset<flatbuffers::String> custom_code) {
fbb_.AddOffset(OperatorCode::VT_CUSTOM_CODE, custom_code);
}
void add_version(int32_t version) {
fbb_.AddElement<int32_t>(OperatorCode::VT_VERSION, version, 1);
}
explicit OperatorCodeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
OperatorCodeBuilder &operator=(const OperatorCodeBuilder &);
flatbuffers::Offset<OperatorCode> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<OperatorCode>(end);
return o;
}
};
inline flatbuffers::Offset<OperatorCode> CreateOperatorCode(
flatbuffers::FlatBufferBuilder &_fbb,
BuiltinOperator builtin_code = BuiltinOperator_ADD,
flatbuffers::Offset<flatbuffers::String> custom_code = 0,
int32_t version = 1) {
OperatorCodeBuilder builder_(_fbb);
builder_.add_version(version);
builder_.add_custom_code(custom_code);
builder_.add_builtin_code(builtin_code);
return builder_.Finish();
}
inline flatbuffers::Offset<OperatorCode> CreateOperatorCodeDirect(
flatbuffers::FlatBufferBuilder &_fbb,
BuiltinOperator builtin_code = BuiltinOperator_ADD,
const char *custom_code = nullptr,
int32_t version = 1) {
auto custom_code__ = custom_code ? _fbb.CreateString(custom_code) : 0;
return tflite::CreateOperatorCode(
_fbb,
builtin_code,
custom_code__,
version);
}
flatbuffers::Offset<OperatorCode> CreateOperatorCode(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct OperatorT : public flatbuffers::NativeTable {
typedef Operator TableType;
uint32_t opcode_index;
std::vector<int32_t> inputs;
std::vector<int32_t> outputs;
BuiltinOptionsUnion builtin_options;
std::vector<uint8_t> custom_options;
CustomOptionsFormat custom_options_format;
std::vector<bool> mutating_variable_inputs;
std::vector<int32_t> intermediates;
OperatorT()
: opcode_index(0),
custom_options_format(CustomOptionsFormat_FLEXBUFFERS) {
}
};
struct Operator FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef OperatorT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_OPCODE_INDEX = 4,
VT_INPUTS = 6,
VT_OUTPUTS = 8,
VT_BUILTIN_OPTIONS_TYPE = 10,
VT_BUILTIN_OPTIONS = 12,
VT_CUSTOM_OPTIONS = 14,
VT_CUSTOM_OPTIONS_FORMAT = 16,
VT_MUTATING_VARIABLE_INPUTS = 18,
VT_INTERMEDIATES = 20
};
uint32_t opcode_index() const {
return GetField<uint32_t>(VT_OPCODE_INDEX, 0);
}
const flatbuffers::Vector<int32_t> *inputs() const {
return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INPUTS);
}
const flatbuffers::Vector<int32_t> *outputs() const {
return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
}
BuiltinOptions builtin_options_type() const {
return static_cast<BuiltinOptions>(GetField<uint8_t>(VT_BUILTIN_OPTIONS_TYPE, 0));
}
const void *builtin_options() const {
return GetPointer<const void *>(VT_BUILTIN_OPTIONS);
}
template<typename T> const T *builtin_options_as() const;
const Conv2DOptions *builtin_options_as_Conv2DOptions() const {
return builtin_options_type() == BuiltinOptions_Conv2DOptions ? static_cast<const Conv2DOptions *>(builtin_options()) : nullptr;
}
const DepthwiseConv2DOptions *builtin_options_as_DepthwiseConv2DOptions() const {
return builtin_options_type() == BuiltinOptions_DepthwiseConv2DOptions ? static_cast<const DepthwiseConv2DOptions *>(builtin_options()) : nullptr;
}
const ConcatEmbeddingsOptions *builtin_options_as_ConcatEmbeddingsOptions() const {
return builtin_options_type() == BuiltinOptions_ConcatEmbeddingsOptions ? static_cast<const ConcatEmbeddingsOptions *>(builtin_options()) : nullptr;
}
const LSHProjectionOptions *builtin_options_as_LSHProjectionOptions() const {
return builtin_options_type() == BuiltinOptions_LSHProjectionOptions ? static_cast<const LSHProjectionOptions *>(builtin_options()) : nullptr;
}
const Pool2DOptions *builtin_options_as_Pool2DOptions() const {
return builtin_options_type() == BuiltinOptions_Pool2DOptions ? static_cast<const Pool2DOptions *>(builtin_options()) : nullptr;
}
const SVDFOptions *builtin_options_as_SVDFOptions() const {
return builtin_options_type() == BuiltinOptions_SVDFOptions ? static_cast<const SVDFOptions *>(builtin_options()) : nullptr;
}
const RNNOptions *builtin_options_as_RNNOptions() const {
return builtin_options_type() == BuiltinOptions_RNNOptions ? static_cast<const RNNOptions *>(builtin_options()) : nullptr;
}
const FullyConnectedOptions *builtin_options_as_FullyConnectedOptions() const {
return builtin_options_type() == BuiltinOptions_FullyConnectedOptions ? static_cast<const FullyConnectedOptions *>(builtin_options()) : nullptr;
}
const SoftmaxOptions *builtin_options_as_SoftmaxOptions() const {
return builtin_options_type() == BuiltinOptions_SoftmaxOptions ? static_cast<const SoftmaxOptions *>(builtin_options()) : nullptr;
}
const ConcatenationOptions *builtin_options_as_ConcatenationOptions() const {
return builtin_options_type() == BuiltinOptions_ConcatenationOptions ? static_cast<const ConcatenationOptions *>(builtin_options()) : nullptr;
}
const AddOptions *builtin_options_as_AddOptions() const {
return builtin_options_type() == BuiltinOptions_AddOptions ? static_cast<const AddOptions *>(builtin_options()) : nullptr;
}
const L2NormOptions *builtin_options_as_L2NormOptions() const {
return builtin_options_type() == BuiltinOptions_L2NormOptions ? static_cast<const L2NormOptions *>(builtin_options()) : nullptr;
}
const LocalResponseNormalizationOptions *builtin_options_as_LocalResponseNormalizationOptions() const {
return builtin_options_type() == BuiltinOptions_LocalResponseNormalizationOptions ? static_cast<const LocalResponseNormalizationOptions *>(builtin_options()) : nullptr;
}
const LSTMOptions *builtin_options_as_LSTMOptions() const {
return builtin_options_type() == BuiltinOptions_LSTMOptions ? static_cast<const LSTMOptions *>(builtin_options()) : nullptr;
}
const ResizeBilinearOptions *builtin_options_as_ResizeBilinearOptions() const {
return builtin_options_type() == BuiltinOptions_ResizeBilinearOptions ? static_cast<const ResizeBilinearOptions *>(builtin_options()) : nullptr;
}
const CallOptions *builtin_options_as_CallOptions() const {
return builtin_options_type() == BuiltinOptions_CallOptions ? static_cast<const CallOptions *>(builtin_options()) : nullptr;
}
const ReshapeOptions *builtin_options_as_ReshapeOptions() const {
return builtin_options_type() == BuiltinOptions_ReshapeOptions ? static_cast<const ReshapeOptions *>(builtin_options()) : nullptr;
}
const SkipGramOptions *builtin_options_as_SkipGramOptions() const {
return builtin_options_type() == BuiltinOptions_SkipGramOptions ? static_cast<const SkipGramOptions *>(builtin_options()) : nullptr;
}
const SpaceToDepthOptions *builtin_options_as_SpaceToDepthOptions() const {
return builtin_options_type() == BuiltinOptions_SpaceToDepthOptions ? static_cast<const SpaceToDepthOptions *>(builtin_options()) : nullptr;
}
const EmbeddingLookupSparseOptions *builtin_options_as_EmbeddingLookupSparseOptions() const {
return builtin_options_type() == BuiltinOptions_EmbeddingLookupSparseOptions ? static_cast<const EmbeddingLookupSparseOptions *>(builtin_options()) : nullptr;
}
const MulOptions *builtin_options_as_MulOptions() const {
return builtin_options_type() == BuiltinOptions_MulOptions ? static_cast<const MulOptions *>(builtin_options()) : nullptr;
}
const PadOptions *builtin_options_as_PadOptions() const {
return builtin_options_type() == BuiltinOptions_PadOptions ? static_cast<const PadOptions *>(builtin_options()) : nullptr;
}
const GatherOptions *builtin_options_as_GatherOptions() const {
return builtin_options_type() == BuiltinOptions_GatherOptions ? static_cast<const GatherOptions *>(builtin_options()) : nullptr;
}
const BatchToSpaceNDOptions *builtin_options_as_BatchToSpaceNDOptions() const {
return builtin_options_type() == BuiltinOptions_BatchToSpaceNDOptions ? static_cast<const BatchToSpaceNDOptions *>(builtin_options()) : nullptr;
}
const SpaceToBatchNDOptions *builtin_options_as_SpaceToBatchNDOptions() const {
return builtin_options_type() == BuiltinOptions_SpaceToBatchNDOptions ? static_cast<const SpaceToBatchNDOptions *>(builtin_options()) : nullptr;
}
const TransposeOptions *builtin_options_as_TransposeOptions() const {
return builtin_options_type() == BuiltinOptions_TransposeOptions ? static_cast<const TransposeOptions *>(builtin_options()) : nullptr;
}
const ReducerOptions *builtin_options_as_ReducerOptions() const {
return builtin_options_type() == BuiltinOptions_ReducerOptions ? static_cast<const ReducerOptions *>(builtin_options()) : nullptr;
}
const SubOptions *builtin_options_as_SubOptions() const {
return builtin_options_type() == BuiltinOptions_SubOptions ? static_cast<const SubOptions *>(builtin_options()) : nullptr;
}
const DivOptions *builtin_options_as_DivOptions() const {
return builtin_options_type() == BuiltinOptions_DivOptions ? static_cast<const DivOptions *>(builtin_options()) : nullptr;
}
const SqueezeOptions *builtin_options_as_SqueezeOptions() const {
return builtin_options_type() == BuiltinOptions_SqueezeOptions ? static_cast<const SqueezeOptions *>(builtin_options()) : nullptr;
}
const SequenceRNNOptions *builtin_options_as_SequenceRNNOptions() const {
return builtin_options_type() == BuiltinOptions_SequenceRNNOptions ? static_cast<const SequenceRNNOptions *>(builtin_options()) : nullptr;
}
const StridedSliceOptions *builtin_options_as_StridedSliceOptions() const {
return builtin_options_type() == BuiltinOptions_StridedSliceOptions ? static_cast<const StridedSliceOptions *>(builtin_options()) : nullptr;
}
const ExpOptions *builtin_options_as_ExpOptions() const {
return builtin_options_type() == BuiltinOptions_ExpOptions ? static_cast<const ExpOptions *>(builtin_options()) : nullptr;
}
const TopKV2Options *builtin_options_as_TopKV2Options() const {
return builtin_options_type() == BuiltinOptions_TopKV2Options ? static_cast<const TopKV2Options *>(builtin_options()) : nullptr;
}
const SplitOptions *builtin_options_as_SplitOptions() const {
return builtin_options_type() == BuiltinOptions_SplitOptions ? static_cast<const SplitOptions *>(builtin_options()) : nullptr;
}
const LogSoftmaxOptions *builtin_options_as_LogSoftmaxOptions() const {
return builtin_options_type() == BuiltinOptions_LogSoftmaxOptions ? static_cast<const LogSoftmaxOptions *>(builtin_options()) : nullptr;
}
const CastOptions *builtin_options_as_CastOptions() const {
return builtin_options_type() == BuiltinOptions_CastOptions ? static_cast<const CastOptions *>(builtin_options()) : nullptr;
}
const DequantizeOptions *builtin_options_as_DequantizeOptions() const {
return builtin_options_type() == BuiltinOptions_DequantizeOptions ? static_cast<const DequantizeOptions *>(builtin_options()) : nullptr;
}
const MaximumMinimumOptions *builtin_options_as_MaximumMinimumOptions() const {
return builtin_options_type() == BuiltinOptions_MaximumMinimumOptions ? static_cast<const MaximumMinimumOptions *>(builtin_options()) : nullptr;
}
const ArgMaxOptions *builtin_options_as_ArgMaxOptions() const {
return builtin_options_type() == BuiltinOptions_ArgMaxOptions ? static_cast<const ArgMaxOptions *>(builtin_options()) : nullptr;
}
const LessOptions *builtin_options_as_LessOptions() const {
return builtin_options_type() == BuiltinOptions_LessOptions ? static_cast<const LessOptions *>(builtin_options()) : nullptr;
}
const NegOptions *builtin_options_as_NegOptions() const {
return builtin_options_type() == BuiltinOptions_NegOptions ? static_cast<const NegOptions *>(builtin_options()) : nullptr;
}
const PadV2Options *builtin_options_as_PadV2Options() const {
return builtin_options_type() == BuiltinOptions_PadV2Options ? static_cast<const PadV2Options *>(builtin_options()) : nullptr;
}
const GreaterOptions *builtin_options_as_GreaterOptions() const {
return builtin_options_type() == BuiltinOptions_GreaterOptions ? static_cast<const GreaterOptions *>(builtin_options()) : nullptr;
}
const GreaterEqualOptions *builtin_options_as_GreaterEqualOptions() const {
return builtin_options_type() == BuiltinOptions_GreaterEqualOptions ? static_cast<const GreaterEqualOptions *>(builtin_options()) : nullptr;
}
const LessEqualOptions *builtin_options_as_LessEqualOptions() const {
return builtin_options_type() == BuiltinOptions_LessEqualOptions ? static_cast<const LessEqualOptions *>(builtin_options()) : nullptr;
}
const SelectOptions *builtin_options_as_SelectOptions() const {
return builtin_options_type() == BuiltinOptions_SelectOptions ? static_cast<const SelectOptions *>(builtin_options()) : nullptr;
}
const SliceOptions *builtin_options_as_SliceOptions() const {
return builtin_options_type() == BuiltinOptions_SliceOptions ? static_cast<const SliceOptions *>(builtin_options()) : nullptr;
}
const TransposeConvOptions *builtin_options_as_TransposeConvOptions() const {
return builtin_options_type() == BuiltinOptions_TransposeConvOptions ? static_cast<const TransposeConvOptions *>(builtin_options()) : nullptr;
}
const SparseToDenseOptions *builtin_options_as_SparseToDenseOptions() const {
return builtin_options_type() == BuiltinOptions_SparseToDenseOptions ? static_cast<const SparseToDenseOptions *>(builtin_options()) : nullptr;
}
const TileOptions *builtin_options_as_TileOptions() const {
return builtin_options_type() == BuiltinOptions_TileOptions ? static_cast<const TileOptions *>(builtin_options()) : nullptr;
}
const ExpandDimsOptions *builtin_options_as_ExpandDimsOptions() const {
return builtin_options_type() == BuiltinOptions_ExpandDimsOptions ? static_cast<const ExpandDimsOptions *>(builtin_options()) : nullptr;
}
const EqualOptions *builtin_options_as_EqualOptions() const {
return builtin_options_type() == BuiltinOptions_EqualOptions ? static_cast<const EqualOptions *>(builtin_options()) : nullptr;
}
const NotEqualOptions *builtin_options_as_NotEqualOptions() const {
return builtin_options_type() == BuiltinOptions_NotEqualOptions ? static_cast<const NotEqualOptions *>(builtin_options()) : nullptr;
}
const ShapeOptions *builtin_options_as_ShapeOptions() const {
return builtin_options_type() == BuiltinOptions_ShapeOptions ? static_cast<const ShapeOptions *>(builtin_options()) : nullptr;
}
const PowOptions *builtin_options_as_PowOptions() const {
return builtin_options_type() == BuiltinOptions_PowOptions ? static_cast<const PowOptions *>(builtin_options()) : nullptr;
}
const ArgMinOptions *builtin_options_as_ArgMinOptions() const {
return builtin_options_type() == BuiltinOptions_ArgMinOptions ? static_cast<const ArgMinOptions *>(builtin_options()) : nullptr;
}
const FakeQuantOptions *builtin_options_as_FakeQuantOptions() const {
return builtin_options_type() == BuiltinOptions_FakeQuantOptions ? static_cast<const FakeQuantOptions *>(builtin_options()) : nullptr;
}
const PackOptions *builtin_options_as_PackOptions() const {
return builtin_options_type() == BuiltinOptions_PackOptions ? static_cast<const PackOptions *>(builtin_options()) : nullptr;
}
const LogicalOrOptions *builtin_options_as_LogicalOrOptions() const {
return builtin_options_type() == BuiltinOptions_LogicalOrOptions ? static_cast<const LogicalOrOptions *>(builtin_options()) : nullptr;
}
const OneHotOptions *builtin_options_as_OneHotOptions() const {
return builtin_options_type() == BuiltinOptions_OneHotOptions ? static_cast<const OneHotOptions *>(builtin_options()) : nullptr;
}
const LogicalAndOptions *builtin_options_as_LogicalAndOptions() const {
return builtin_options_type() == BuiltinOptions_LogicalAndOptions ? static_cast<const LogicalAndOptions *>(builtin_options()) : nullptr;
}
const LogicalNotOptions *builtin_options_as_LogicalNotOptions() const {
return builtin_options_type() == BuiltinOptions_LogicalNotOptions ? static_cast<const LogicalNotOptions *>(builtin_options()) : nullptr;
}
const UnpackOptions *builtin_options_as_UnpackOptions() const {
return builtin_options_type() == BuiltinOptions_UnpackOptions ? static_cast<const UnpackOptions *>(builtin_options()) : nullptr;
}
const FloorDivOptions *builtin_options_as_FloorDivOptions() const {
return builtin_options_type() == BuiltinOptions_FloorDivOptions ? static_cast<const FloorDivOptions *>(builtin_options()) : nullptr;
}
const SquareOptions *builtin_options_as_SquareOptions() const {
return builtin_options_type() == BuiltinOptions_SquareOptions ? static_cast<const SquareOptions *>(builtin_options()) : nullptr;
}
const ZerosLikeOptions *builtin_options_as_ZerosLikeOptions() const {
return builtin_options_type() == BuiltinOptions_ZerosLikeOptions ? static_cast<const ZerosLikeOptions *>(builtin_options()) : nullptr;
}
const FillOptions *builtin_options_as_FillOptions() const {
return builtin_options_type() == BuiltinOptions_FillOptions ? static_cast<const FillOptions *>(builtin_options()) : nullptr;
}
const BidirectionalSequenceLSTMOptions *builtin_options_as_BidirectionalSequenceLSTMOptions() const {
return builtin_options_type() == BuiltinOptions_BidirectionalSequenceLSTMOptions ? static_cast<const BidirectionalSequenceLSTMOptions *>(builtin_options()) : nullptr;
}
const BidirectionalSequenceRNNOptions *builtin_options_as_BidirectionalSequenceRNNOptions() const {
return builtin_options_type() == BuiltinOptions_BidirectionalSequenceRNNOptions ? static_cast<const BidirectionalSequenceRNNOptions *>(builtin_options()) : nullptr;
}
const UnidirectionalSequenceLSTMOptions *builtin_options_as_UnidirectionalSequenceLSTMOptions() const {
return builtin_options_type() == BuiltinOptions_UnidirectionalSequenceLSTMOptions ? static_cast<const UnidirectionalSequenceLSTMOptions *>(builtin_options()) : nullptr;
}
const FloorModOptions *builtin_options_as_FloorModOptions() const {
return builtin_options_type() == BuiltinOptions_FloorModOptions ? static_cast<const FloorModOptions *>(builtin_options()) : nullptr;
}
const RangeOptions *builtin_options_as_RangeOptions() const {
return builtin_options_type() == BuiltinOptions_RangeOptions ? static_cast<const RangeOptions *>(builtin_options()) : nullptr;
}
const ResizeNearestNeighborOptions *builtin_options_as_ResizeNearestNeighborOptions() const {
return builtin_options_type() == BuiltinOptions_ResizeNearestNeighborOptions ? static_cast<const ResizeNearestNeighborOptions *>(builtin_options()) : nullptr;
}
const LeakyReluOptions *builtin_options_as_LeakyReluOptions() const {
return builtin_options_type() == BuiltinOptions_LeakyReluOptions ? static_cast<const LeakyReluOptions *>(builtin_options()) : nullptr;
}
const SquaredDifferenceOptions *builtin_options_as_SquaredDifferenceOptions() const {
return builtin_options_type() == BuiltinOptions_SquaredDifferenceOptions ? static_cast<const SquaredDifferenceOptions *>(builtin_options()) : nullptr;
}
const MirrorPadOptions *builtin_options_as_MirrorPadOptions() const {
return builtin_options_type() == BuiltinOptions_MirrorPadOptions ? static_cast<const MirrorPadOptions *>(builtin_options()) : nullptr;
}
const AbsOptions *builtin_options_as_AbsOptions() const {
return builtin_options_type() == BuiltinOptions_AbsOptions ? static_cast<const AbsOptions *>(builtin_options()) : nullptr;
}
const SplitVOptions *builtin_options_as_SplitVOptions() const {
return builtin_options_type() == BuiltinOptions_SplitVOptions ? static_cast<const SplitVOptions *>(builtin_options()) : nullptr;
}
const UniqueOptions *builtin_options_as_UniqueOptions() const {
return builtin_options_type() == BuiltinOptions_UniqueOptions ? static_cast<const UniqueOptions *>(builtin_options()) : nullptr;
}
const ReverseV2Options *builtin_options_as_ReverseV2Options() const {
return builtin_options_type() == BuiltinOptions_ReverseV2Options ? static_cast<const ReverseV2Options *>(builtin_options()) : nullptr;
}
const AddNOptions *builtin_options_as_AddNOptions() const {
return builtin_options_type() == BuiltinOptions_AddNOptions ? static_cast<const AddNOptions *>(builtin_options()) : nullptr;
}
const GatherNdOptions *builtin_options_as_GatherNdOptions() const {
return builtin_options_type() == BuiltinOptions_GatherNdOptions ? static_cast<const GatherNdOptions *>(builtin_options()) : nullptr;
}
const CosOptions *builtin_options_as_CosOptions() const {
return builtin_options_type() == BuiltinOptions_CosOptions ? static_cast<const CosOptions *>(builtin_options()) : nullptr;
}
const WhereOptions *builtin_options_as_WhereOptions() const {
return builtin_options_type() == BuiltinOptions_WhereOptions ? static_cast<const WhereOptions *>(builtin_options()) : nullptr;
}
const RankOptions *builtin_options_as_RankOptions() const {
return builtin_options_type() == BuiltinOptions_RankOptions ? static_cast<const RankOptions *>(builtin_options()) : nullptr;
}
const ReverseSequenceOptions *builtin_options_as_ReverseSequenceOptions() const {
return builtin_options_type() == BuiltinOptions_ReverseSequenceOptions ? static_cast<const ReverseSequenceOptions *>(builtin_options()) : nullptr;
}
const MatrixDiagOptions *builtin_options_as_MatrixDiagOptions() const {
return builtin_options_type() == BuiltinOptions_MatrixDiagOptions ? static_cast<const MatrixDiagOptions *>(builtin_options()) : nullptr;
}
const QuantizeOptions *builtin_options_as_QuantizeOptions() const {
return builtin_options_type() == BuiltinOptions_QuantizeOptions ? static_cast<const QuantizeOptions *>(builtin_options()) : nullptr;
}
const MatrixSetDiagOptions *builtin_options_as_MatrixSetDiagOptions() const {
return builtin_options_type() == BuiltinOptions_MatrixSetDiagOptions ? static_cast<const MatrixSetDiagOptions *>(builtin_options()) : nullptr;
}
const HardSwishOptions *builtin_options_as_HardSwishOptions() const {
return builtin_options_type() == BuiltinOptions_HardSwishOptions ? static_cast<const HardSwishOptions *>(builtin_options()) : nullptr;
}
const IfOptions *builtin_options_as_IfOptions() const {
return builtin_options_type() == BuiltinOptions_IfOptions ? static_cast<const IfOptions *>(builtin_options()) : nullptr;
}
const WhileOptions *builtin_options_as_WhileOptions() const {
return builtin_options_type() == BuiltinOptions_WhileOptions ? static_cast<const WhileOptions *>(builtin_options()) : nullptr;
}
const DepthToSpaceOptions *builtin_options_as_DepthToSpaceOptions() const {
return builtin_options_type() == BuiltinOptions_DepthToSpaceOptions ? static_cast<const DepthToSpaceOptions *>(builtin_options()) : nullptr;
}
const NonMaxSuppressionV4Options *builtin_options_as_NonMaxSuppressionV4Options() const {
return builtin_options_type() == BuiltinOptions_NonMaxSuppressionV4Options ? static_cast<const NonMaxSuppressionV4Options *>(builtin_options()) : nullptr;
}
const NonMaxSuppressionV5Options *builtin_options_as_NonMaxSuppressionV5Options() const {
return builtin_options_type() == BuiltinOptions_NonMaxSuppressionV5Options ? static_cast<const NonMaxSuppressionV5Options *>(builtin_options()) : nullptr;
}
const ScatterNdOptions *builtin_options_as_ScatterNdOptions() const {
return builtin_options_type() == BuiltinOptions_ScatterNdOptions ? static_cast<const ScatterNdOptions *>(builtin_options()) : nullptr;
}
const SelectV2Options *builtin_options_as_SelectV2Options() const {
return builtin_options_type() == BuiltinOptions_SelectV2Options ? static_cast<const SelectV2Options *>(builtin_options()) : nullptr;
}
const flatbuffers::Vector<uint8_t> *custom_options() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CUSTOM_OPTIONS);
}
CustomOptionsFormat custom_options_format() const {
return static_cast<CustomOptionsFormat>(GetField<int8_t>(VT_CUSTOM_OPTIONS_FORMAT, 0));
}
const flatbuffers::Vector<uint8_t> *mutating_variable_inputs() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MUTATING_VARIABLE_INPUTS);
}
const flatbuffers::Vector<int32_t> *intermediates() const {
return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INTERMEDIATES);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_OPCODE_INDEX) &&
VerifyOffset(verifier, VT_INPUTS) &&
verifier.VerifyVector(inputs()) &&
VerifyOffset(verifier, VT_OUTPUTS) &&
verifier.VerifyVector(outputs()) &&
VerifyField<uint8_t>(verifier, VT_BUILTIN_OPTIONS_TYPE) &&
VerifyOffset(verifier, VT_BUILTIN_OPTIONS) &&
VerifyBuiltinOptions(verifier, builtin_options(), builtin_options_type()) &&
VerifyOffset(verifier, VT_CUSTOM_OPTIONS) &&
verifier.VerifyVector(custom_options()) &&
VerifyField<int8_t>(verifier, VT_CUSTOM_OPTIONS_FORMAT) &&
VerifyOffset(verifier, VT_MUTATING_VARIABLE_INPUTS) &&
verifier.VerifyVector(mutating_variable_inputs()) &&
VerifyOffset(verifier, VT_INTERMEDIATES) &&
verifier.VerifyVector(intermediates()) &&
verifier.EndTable();
}
OperatorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(OperatorT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<Operator> Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
template<> inline const Conv2DOptions *Operator::builtin_options_as<Conv2DOptions>() const {
return builtin_options_as_Conv2DOptions();
}
template<> inline const DepthwiseConv2DOptions *Operator::builtin_options_as<DepthwiseConv2DOptions>() const {
return builtin_options_as_DepthwiseConv2DOptions();
}
template<> inline const ConcatEmbeddingsOptions *Operator::builtin_options_as<ConcatEmbeddingsOptions>() const {
return builtin_options_as_ConcatEmbeddingsOptions();
}
template<> inline const LSHProjectionOptions *Operator::builtin_options_as<LSHProjectionOptions>() const {
return builtin_options_as_LSHProjectionOptions();
}
template<> inline const Pool2DOptions *Operator::builtin_options_as<Pool2DOptions>() const {
return builtin_options_as_Pool2DOptions();
}
template<> inline const SVDFOptions *Operator::builtin_options_as<SVDFOptions>() const {
return builtin_options_as_SVDFOptions();
}
template<> inline const RNNOptions *Operator::builtin_options_as<RNNOptions>() const {
return builtin_options_as_RNNOptions();
}
template<> inline const FullyConnectedOptions *Operator::builtin_options_as<FullyConnectedOptions>() const {
return builtin_options_as_FullyConnectedOptions();
}
template<> inline const SoftmaxOptions *Operator::builtin_options_as<SoftmaxOptions>() const {
return builtin_options_as_SoftmaxOptions();
}
template<> inline const ConcatenationOptions *Operator::builtin_options_as<ConcatenationOptions>() const {
return builtin_options_as_ConcatenationOptions();
}
template<> inline const AddOptions *Operator::builtin_options_as<AddOptions>() const {
return builtin_options_as_AddOptions();
}
template<> inline const L2NormOptions *Operator::builtin_options_as<L2NormOptions>() const {
return builtin_options_as_L2NormOptions();
}
template<> inline const LocalResponseNormalizationOptions *Operator::builtin_options_as<LocalResponseNormalizationOptions>() const {
return builtin_options_as_LocalResponseNormalizationOptions();
}
template<> inline const LSTMOptions *Operator::builtin_options_as<LSTMOptions>() const {
return builtin_options_as_LSTMOptions();
}
template<> inline const ResizeBilinearOptions *Operator::builtin_options_as<ResizeBilinearOptions>() const {
return builtin_options_as_ResizeBilinearOptions();
}
template<> inline const CallOptions *Operator::builtin_options_as<CallOptions>() const {
return builtin_options_as_CallOptions();
}
template<> inline const ReshapeOptions *Operator::builtin_options_as<ReshapeOptions>() const {
return builtin_options_as_ReshapeOptions();
}
template<> inline const SkipGramOptions *Operator::builtin_options_as<SkipGramOptions>() const {
return builtin_options_as_SkipGramOptions();
}
template<> inline const SpaceToDepthOptions *Operator::builtin_options_as<SpaceToDepthOptions>() const {
return builtin_options_as_SpaceToDepthOptions();
}
template<> inline const EmbeddingLookupSparseOptions *Operator::builtin_options_as<EmbeddingLookupSparseOptions>() const {
return builtin_options_as_EmbeddingLookupSparseOptions();
}
template<> inline const MulOptions *Operator::builtin_options_as<MulOptions>() const {
return builtin_options_as_MulOptions();
}
template<> inline const PadOptions *Operator::builtin_options_as<PadOptions>() const {
return builtin_options_as_PadOptions();
}
template<> inline const GatherOptions *Operator::builtin_options_as<GatherOptions>() const {
return builtin_options_as_GatherOptions();
}
template<> inline const BatchToSpaceNDOptions *Operator::builtin_options_as<BatchToSpaceNDOptions>() const {
return builtin_options_as_BatchToSpaceNDOptions();
}
template<> inline const SpaceToBatchNDOptions *Operator::builtin_options_as<SpaceToBatchNDOptions>() const {
return builtin_options_as_SpaceToBatchNDOptions();
}
template<> inline const TransposeOptions *Operator::builtin_options_as<TransposeOptions>() const {
return builtin_options_as_TransposeOptions();
}
template<> inline const ReducerOptions *Operator::builtin_options_as<ReducerOptions>() const {
return builtin_options_as_ReducerOptions();
}
template<> inline const SubOptions *Operator::builtin_options_as<SubOptions>() const {
return builtin_options_as_SubOptions();
}
template<> inline const DivOptions *Operator::builtin_options_as<DivOptions>() const {
return builtin_options_as_DivOptions();
}
template<> inline const SqueezeOptions *Operator::builtin_options_as<SqueezeOptions>() const {
return builtin_options_as_SqueezeOptions();
}
template<> inline const SequenceRNNOptions *Operator::builtin_options_as<SequenceRNNOptions>() const {
return builtin_options_as_SequenceRNNOptions();
}
template<> inline const StridedSliceOptions *Operator::builtin_options_as<StridedSliceOptions>() const {
return builtin_options_as_StridedSliceOptions();
}
template<> inline const ExpOptions *Operator::builtin_options_as<ExpOptions>() const {
return builtin_options_as_ExpOptions();
}
template<> inline const TopKV2Options *Operator::builtin_options_as<TopKV2Options>() const {
return builtin_options_as_TopKV2Options();
}
template<> inline const SplitOptions *Operator::builtin_options_as<SplitOptions>() const {
return builtin_options_as_SplitOptions();
}
template<> inline const LogSoftmaxOptions *Operator::builtin_options_as<LogSoftmaxOptions>() const {
return builtin_options_as_LogSoftmaxOptions();
}
template<> inline const CastOptions *Operator::builtin_options_as<CastOptions>() const {
return builtin_options_as_CastOptions();
}
template<> inline const DequantizeOptions *Operator::builtin_options_as<DequantizeOptions>() const {
return builtin_options_as_DequantizeOptions();
}
template<> inline const MaximumMinimumOptions *Operator::builtin_options_as<MaximumMinimumOptions>() const {
return builtin_options_as_MaximumMinimumOptions();
}
template<> inline const ArgMaxOptions *Operator::builtin_options_as<ArgMaxOptions>() const {
return builtin_options_as_ArgMaxOptions();
}
template<> inline const LessOptions *Operator::builtin_options_as<LessOptions>() const {
return builtin_options_as_LessOptions();
}
template<> inline const NegOptions *Operator::builtin_options_as<NegOptions>() const {
return builtin_options_as_NegOptions();
}
template<> inline const PadV2Options *Operator::builtin_options_as<PadV2Options>() const {
return builtin_options_as_PadV2Options();
}
template<> inline const GreaterOptions *Operator::builtin_options_as<GreaterOptions>() const {
return builtin_options_as_GreaterOptions();
}
template<> inline const GreaterEqualOptions *Operator::builtin_options_as<GreaterEqualOptions>() const {
return builtin_options_as_GreaterEqualOptions();
}
template<> inline const LessEqualOptions *Operator::builtin_options_as<LessEqualOptions>() const {
return builtin_options_as_LessEqualOptions();
}
template<> inline const SelectOptions *Operator::builtin_options_as<SelectOptions>() const {
return builtin_options_as_SelectOptions();
}
template<> inline const SliceOptions *Operator::builtin_options_as<SliceOptions>() const {
return builtin_options_as_SliceOptions();
}
template<> inline const TransposeConvOptions *Operator::builtin_options_as<TransposeConvOptions>() const {
return builtin_options_as_TransposeConvOptions();
}
template<> inline const SparseToDenseOptions *Operator::builtin_options_as<SparseToDenseOptions>() const {
return builtin_options_as_SparseToDenseOptions();
}
template<> inline const TileOptions *Operator::builtin_options_as<TileOptions>() const {
return builtin_options_as_TileOptions();
}
template<> inline const ExpandDimsOptions *Operator::builtin_options_as<ExpandDimsOptions>() const {
return builtin_options_as_ExpandDimsOptions();
}
template<> inline const EqualOptions *Operator::builtin_options_as<EqualOptions>() const {
return builtin_options_as_EqualOptions();
}
template<> inline const NotEqualOptions *Operator::builtin_options_as<NotEqualOptions>() const {
return builtin_options_as_NotEqualOptions();
}
template<> inline const ShapeOptions *Operator::builtin_options_as<ShapeOptions>() const {
return builtin_options_as_ShapeOptions();
}
template<> inline const PowOptions *Operator::builtin_options_as<PowOptions>() const {
return builtin_options_as_PowOptions();
}
template<> inline const ArgMinOptions *Operator::builtin_options_as<ArgMinOptions>() const {
return builtin_options_as_ArgMinOptions();
}
template<> inline const FakeQuantOptions *Operator::builtin_options_as<FakeQuantOptions>() const {
return builtin_options_as_FakeQuantOptions();
}
template<> inline const PackOptions *Operator::builtin_options_as<PackOptions>() const {
return builtin_options_as_PackOptions();
}
template<> inline const LogicalOrOptions *Operator::builtin_options_as<LogicalOrOptions>() const {
return builtin_options_as_LogicalOrOptions();
}
template<> inline const OneHotOptions *Operator::builtin_options_as<OneHotOptions>() const {
return builtin_options_as_OneHotOptions();
}
template<> inline const LogicalAndOptions *Operator::builtin_options_as<LogicalAndOptions>() const {
return builtin_options_as_LogicalAndOptions();
}
template<> inline const LogicalNotOptions *Operator::builtin_options_as<LogicalNotOptions>() const {
return builtin_options_as_LogicalNotOptions();
}
template<> inline const UnpackOptions *Operator::builtin_options_as<UnpackOptions>() const {
return builtin_options_as_UnpackOptions();
}
template<> inline const FloorDivOptions *Operator::builtin_options_as<FloorDivOptions>() const {
return builtin_options_as_FloorDivOptions();
}
template<> inline const SquareOptions *Operator::builtin_options_as<SquareOptions>() const {
return builtin_options_as_SquareOptions();
}
template<> inline const ZerosLikeOptions *Operator::builtin_options_as<ZerosLikeOptions>() const {
return builtin_options_as_ZerosLikeOptions();
}
template<> inline const FillOptions *Operator::builtin_options_as<FillOptions>() const {
return builtin_options_as_FillOptions();
}
template<> inline const BidirectionalSequenceLSTMOptions *Operator::builtin_options_as<BidirectionalSequenceLSTMOptions>() const {
return builtin_options_as_BidirectionalSequenceLSTMOptions();
}
template<> inline const BidirectionalSequenceRNNOptions *Operator::builtin_options_as<BidirectionalSequenceRNNOptions>() const {
return builtin_options_as_BidirectionalSequenceRNNOptions();
}
template<> inline const UnidirectionalSequenceLSTMOptions *Operator::builtin_options_as<UnidirectionalSequenceLSTMOptions>() const {
return builtin_options_as_UnidirectionalSequenceLSTMOptions();
}
template<> inline const FloorModOptions *Operator::builtin_options_as<FloorModOptions>() const {
return builtin_options_as_FloorModOptions();
}
template<> inline const RangeOptions *Operator::builtin_options_as<RangeOptions>() const {
return builtin_options_as_RangeOptions();
}
template<> inline const ResizeNearestNeighborOptions *Operator::builtin_options_as<ResizeNearestNeighborOptions>() const {
return builtin_options_as_ResizeNearestNeighborOptions();
}
template<> inline const LeakyReluOptions *Operator::builtin_options_as<LeakyReluOptions>() const {
return builtin_options_as_LeakyReluOptions();
}
template<> inline const SquaredDifferenceOptions *Operator::builtin_options_as<SquaredDifferenceOptions>() const {
return builtin_options_as_SquaredDifferenceOptions();
}
template<> inline const MirrorPadOptions *Operator::builtin_options_as<MirrorPadOptions>() const {
return builtin_options_as_MirrorPadOptions();
}
template<> inline const AbsOptions *Operator::builtin_options_as<AbsOptions>() const {
return builtin_options_as_AbsOptions();
}
template<> inline const SplitVOptions *Operator::builtin_options_as<SplitVOptions>() const {
return builtin_options_as_SplitVOptions();
}
template<> inline const UniqueOptions *Operator::builtin_options_as<UniqueOptions>() const {
return builtin_options_as_UniqueOptions();
}
template<> inline const ReverseV2Options *Operator::builtin_options_as<ReverseV2Options>() const {
return builtin_options_as_ReverseV2Options();
}
template<> inline const AddNOptions *Operator::builtin_options_as<AddNOptions>() const {
return builtin_options_as_AddNOptions();
}
template<> inline const GatherNdOptions *Operator::builtin_options_as<GatherNdOptions>() const {
return builtin_options_as_GatherNdOptions();
}
template<> inline const CosOptions *Operator::builtin_options_as<CosOptions>() const {
return builtin_options_as_CosOptions();
}
template<> inline const WhereOptions *Operator::builtin_options_as<WhereOptions>() const {
return builtin_options_as_WhereOptions();
}
template<> inline const RankOptions *Operator::builtin_options_as<RankOptions>() const {
return builtin_options_as_RankOptions();
}
template<> inline const ReverseSequenceOptions *Operator::builtin_options_as<ReverseSequenceOptions>() const {
return builtin_options_as_ReverseSequenceOptions();
}
template<> inline const MatrixDiagOptions *Operator::builtin_options_as<MatrixDiagOptions>() const {
return builtin_options_as_MatrixDiagOptions();
}
template<> inline const QuantizeOptions *Operator::builtin_options_as<QuantizeOptions>() const {
return builtin_options_as_QuantizeOptions();
}
template<> inline const MatrixSetDiagOptions *Operator::builtin_options_as<MatrixSetDiagOptions>() const {
return builtin_options_as_MatrixSetDiagOptions();
}
template<> inline const HardSwishOptions *Operator::builtin_options_as<HardSwishOptions>() const {
return builtin_options_as_HardSwishOptions();
}
template<> inline const IfOptions *Operator::builtin_options_as<IfOptions>() const {
return builtin_options_as_IfOptions();
}
template<> inline const WhileOptions *Operator::builtin_options_as<WhileOptions>() const {
return builtin_options_as_WhileOptions();
}
template<> inline const DepthToSpaceOptions *Operator::builtin_options_as<DepthToSpaceOptions>() const {
return builtin_options_as_DepthToSpaceOptions();
}
template<> inline const NonMaxSuppressionV4Options *Operator::builtin_options_as<NonMaxSuppressionV4Options>() const {
return builtin_options_as_NonMaxSuppressionV4Options();
}
template<> inline const NonMaxSuppressionV5Options *Operator::builtin_options_as<NonMaxSuppressionV5Options>() const {
return builtin_options_as_NonMaxSuppressionV5Options();
}
template<> inline const ScatterNdOptions *Operator::builtin_options_as<ScatterNdOptions>() const {
return builtin_options_as_ScatterNdOptions();
}
template<> inline const SelectV2Options *Operator::builtin_options_as<SelectV2Options>() const {
return builtin_options_as_SelectV2Options();
}
struct OperatorBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_opcode_index(uint32_t opcode_index) {
fbb_.AddElement<uint32_t>(Operator::VT_OPCODE_INDEX, opcode_index, 0);
}
void add_inputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs) {
fbb_.AddOffset(Operator::VT_INPUTS, inputs);
}
void add_outputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs) {
fbb_.AddOffset(Operator::VT_OUTPUTS, outputs);
}
void add_builtin_options_type(BuiltinOptions builtin_options_type) {
fbb_.AddElement<uint8_t>(Operator::VT_BUILTIN_OPTIONS_TYPE, static_cast<uint8_t>(builtin_options_type), 0);
}
void add_builtin_options(flatbuffers::Offset<void> builtin_options) {
fbb_.AddOffset(Operator::VT_BUILTIN_OPTIONS, builtin_options);
}
void add_custom_options(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom_options) {
fbb_.AddOffset(Operator::VT_CUSTOM_OPTIONS, custom_options);
}
void add_custom_options_format(CustomOptionsFormat custom_options_format) {
fbb_.AddElement<int8_t>(Operator::VT_CUSTOM_OPTIONS_FORMAT, static_cast<int8_t>(custom_options_format), 0);
}
void add_mutating_variable_inputs(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> mutating_variable_inputs) {
fbb_.AddOffset(Operator::VT_MUTATING_VARIABLE_INPUTS, mutating_variable_inputs);
}
void add_intermediates(flatbuffers::Offset<flatbuffers::Vector<int32_t>> intermediates) {
fbb_.AddOffset(Operator::VT_INTERMEDIATES, intermediates);
}
explicit OperatorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
OperatorBuilder &operator=(const OperatorBuilder &);
flatbuffers::Offset<Operator> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Operator>(end);
return o;
}
};
inline flatbuffers::Offset<Operator> CreateOperator(
flatbuffers::FlatBufferBuilder &_fbb,
uint32_t opcode_index = 0,
flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs = 0,
flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs = 0,
BuiltinOptions builtin_options_type = BuiltinOptions_NONE,
flatbuffers::Offset<void> builtin_options = 0,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom_options = 0,
CustomOptionsFormat custom_options_format = CustomOptionsFormat_FLEXBUFFERS,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> mutating_variable_inputs = 0,
flatbuffers::Offset<flatbuffers::Vector<int32_t>> intermediates = 0) {
OperatorBuilder builder_(_fbb);
builder_.add_intermediates(intermediates);
builder_.add_mutating_variable_inputs(mutating_variable_inputs);
builder_.add_custom_options(custom_options);
builder_.add_builtin_options(builtin_options);
builder_.add_outputs(outputs);
builder_.add_inputs(inputs);
builder_.add_opcode_index(opcode_index);
builder_.add_custom_options_format(custom_options_format);
builder_.add_builtin_options_type(builtin_options_type);
return builder_.Finish();
}
inline flatbuffers::Offset<Operator> CreateOperatorDirect(
flatbuffers::FlatBufferBuilder &_fbb,
uint32_t opcode_index = 0,
const std::vector<int32_t> *inputs = nullptr,
const std::vector<int32_t> *outputs = nullptr,
BuiltinOptions builtin_options_type = BuiltinOptions_NONE,
flatbuffers::Offset<void> builtin_options = 0,
const std::vector<uint8_t> *custom_options = nullptr,
CustomOptionsFormat custom_options_format = CustomOptionsFormat_FLEXBUFFERS,
const std::vector<uint8_t> *mutating_variable_inputs = nullptr,
const std::vector<int32_t> *intermediates = nullptr) {
auto inputs__ = inputs ? _fbb.CreateVector<int32_t>(*inputs) : 0;
auto outputs__ = outputs ? _fbb.CreateVector<int32_t>(*outputs) : 0;
auto custom_options__ = custom_options ? _fbb.CreateVector<uint8_t>(*custom_options) : 0;
auto mutating_variable_inputs__ = mutating_variable_inputs ? _fbb.CreateVector<uint8_t>(*mutating_variable_inputs) : 0;
auto intermediates__ = intermediates ? _fbb.CreateVector<int32_t>(*intermediates) : 0;
return tflite::CreateOperator(
_fbb,
opcode_index,
inputs__,
outputs__,
builtin_options_type,
builtin_options,
custom_options__,
custom_options_format,
mutating_variable_inputs__,
intermediates__);
}
flatbuffers::Offset<Operator> CreateOperator(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct SubGraphT : public flatbuffers::NativeTable {
typedef SubGraph TableType;
std::vector<std::unique_ptr<TensorT>> tensors;
std::vector<int32_t> inputs;
std::vector<int32_t> outputs;
std::vector<std::unique_ptr<OperatorT>> operators;
std::string name;
SubGraphT() {
}
};
struct SubGraph FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SubGraphT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_TENSORS = 4,
VT_INPUTS = 6,
VT_OUTPUTS = 8,
VT_OPERATORS = 10,
VT_NAME = 12
};
const flatbuffers::Vector<flatbuffers::Offset<Tensor>> *tensors() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Tensor>> *>(VT_TENSORS);
}
const flatbuffers::Vector<int32_t> *inputs() const {
return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INPUTS);
}
const flatbuffers::Vector<int32_t> *outputs() const {
return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
}
const flatbuffers::Vector<flatbuffers::Offset<Operator>> *operators() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Operator>> *>(VT_OPERATORS);
}
const flatbuffers::String *name() const {
return GetPointer<const flatbuffers::String *>(VT_NAME);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_TENSORS) &&
verifier.VerifyVector(tensors()) &&
verifier.VerifyVectorOfTables(tensors()) &&
VerifyOffset(verifier, VT_INPUTS) &&
verifier.VerifyVector(inputs()) &&
VerifyOffset(verifier, VT_OUTPUTS) &&
verifier.VerifyVector(outputs()) &&
VerifyOffset(verifier, VT_OPERATORS) &&
verifier.VerifyVector(operators()) &&
verifier.VerifyVectorOfTables(operators()) &&
VerifyOffset(verifier, VT_NAME) &&
verifier.VerifyString(name()) &&
verifier.EndTable();
}
SubGraphT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(SubGraphT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<SubGraph> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct SubGraphBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_tensors(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Tensor>>> tensors) {
fbb_.AddOffset(SubGraph::VT_TENSORS, tensors);
}
void add_inputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs) {
fbb_.AddOffset(SubGraph::VT_INPUTS, inputs);
}
void add_outputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs) {
fbb_.AddOffset(SubGraph::VT_OUTPUTS, outputs);
}
void add_operators(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Operator>>> operators) {
fbb_.AddOffset(SubGraph::VT_OPERATORS, operators);
}
void add_name(flatbuffers::Offset<flatbuffers::String> name) {
fbb_.AddOffset(SubGraph::VT_NAME, name);
}
explicit SubGraphBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SubGraphBuilder &operator=(const SubGraphBuilder &);
flatbuffers::Offset<SubGraph> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<SubGraph>(end);
return o;
}
};
inline flatbuffers::Offset<SubGraph> CreateSubGraph(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Tensor>>> tensors = 0,
flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs = 0,
flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Operator>>> operators = 0,
flatbuffers::Offset<flatbuffers::String> name = 0) {
SubGraphBuilder builder_(_fbb);
builder_.add_name(name);
builder_.add_operators(operators);
builder_.add_outputs(outputs);
builder_.add_inputs(inputs);
builder_.add_tensors(tensors);
return builder_.Finish();
}
inline flatbuffers::Offset<SubGraph> CreateSubGraphDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<flatbuffers::Offset<Tensor>> *tensors = nullptr,
const std::vector<int32_t> *inputs = nullptr,
const std::vector<int32_t> *outputs = nullptr,
const std::vector<flatbuffers::Offset<Operator>> *operators = nullptr,
const char *name = nullptr) {
auto tensors__ = tensors ? _fbb.CreateVector<flatbuffers::Offset<Tensor>>(*tensors) : 0;
auto inputs__ = inputs ? _fbb.CreateVector<int32_t>(*inputs) : 0;
auto outputs__ = outputs ? _fbb.CreateVector<int32_t>(*outputs) : 0;
auto operators__ = operators ? _fbb.CreateVector<flatbuffers::Offset<Operator>>(*operators) : 0;
auto name__ = name ? _fbb.CreateString(name) : 0;
return tflite::CreateSubGraph(
_fbb,
tensors__,
inputs__,
outputs__,
operators__,
name__);
}
flatbuffers::Offset<SubGraph> CreateSubGraph(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct BufferT : public flatbuffers::NativeTable {
typedef Buffer TableType;
std::vector<uint8_t> data;
BufferT() {
}
};
struct Buffer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef BufferT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_DATA = 4
};
const flatbuffers::Vector<uint8_t> *data() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_DATA) &&
verifier.VerifyVector(data()) &&
verifier.EndTable();
}
BufferT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(BufferT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<Buffer> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BufferT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct BufferBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
fbb_.AddOffset(Buffer::VT_DATA, data);
}
explicit BufferBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
BufferBuilder &operator=(const BufferBuilder &);
flatbuffers::Offset<Buffer> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Buffer>(end);
return o;
}
};
inline flatbuffers::Offset<Buffer> CreateBuffer(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0) {
BufferBuilder builder_(_fbb);
builder_.add_data(data);
return builder_.Finish();
}
inline flatbuffers::Offset<Buffer> CreateBufferDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *data = nullptr) {
auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
return tflite::CreateBuffer(
_fbb,
data__);
}
flatbuffers::Offset<Buffer> CreateBuffer(flatbuffers::FlatBufferBuilder &_fbb, const BufferT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct MetadataT : public flatbuffers::NativeTable {
typedef Metadata TableType;
std::string name;
uint32_t buffer;
MetadataT()
: buffer(0) {
}
};
struct Metadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef MetadataT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NAME = 4,
VT_BUFFER = 6
};
const flatbuffers::String *name() const {
return GetPointer<const flatbuffers::String *>(VT_NAME);
}
uint32_t buffer() const {
return GetField<uint32_t>(VT_BUFFER, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_NAME) &&
verifier.VerifyString(name()) &&
VerifyField<uint32_t>(verifier, VT_BUFFER) &&
verifier.EndTable();
}
MetadataT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(MetadataT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<Metadata> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct MetadataBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_name(flatbuffers::Offset<flatbuffers::String> name) {
fbb_.AddOffset(Metadata::VT_NAME, name);
}
void add_buffer(uint32_t buffer) {
fbb_.AddElement<uint32_t>(Metadata::VT_BUFFER, buffer, 0);
}
explicit MetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
MetadataBuilder &operator=(const MetadataBuilder &);
flatbuffers::Offset<Metadata> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Metadata>(end);
return o;
}
};
inline flatbuffers::Offset<Metadata> CreateMetadata(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::String> name = 0,
uint32_t buffer = 0) {
MetadataBuilder builder_(_fbb);
builder_.add_buffer(buffer);
builder_.add_name(name);
return builder_.Finish();
}
inline flatbuffers::Offset<Metadata> CreateMetadataDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const char *name = nullptr,
uint32_t buffer = 0) {
auto name__ = name ? _fbb.CreateString(name) : 0;
return tflite::CreateMetadata(
_fbb,
name__,
buffer);
}
flatbuffers::Offset<Metadata> CreateMetadata(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct ModelT : public flatbuffers::NativeTable {
typedef Model TableType;
uint32_t version;
std::vector<std::unique_ptr<OperatorCodeT>> operator_codes;
std::vector<std::unique_ptr<SubGraphT>> subgraphs;
std::string description;
std::vector<std::unique_ptr<BufferT>> buffers;
std::vector<int32_t> metadata_buffer;
std::vector<std::unique_ptr<MetadataT>> metadata;
ModelT()
: version(0) {
}
};
struct Model FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ModelT NativeTableType;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_VERSION = 4,
VT_OPERATOR_CODES = 6,
VT_SUBGRAPHS = 8,
VT_DESCRIPTION = 10,
VT_BUFFERS = 12,
VT_METADATA_BUFFER = 14,
VT_METADATA = 16
};
uint32_t version() const {
return GetField<uint32_t>(VT_VERSION, 0);
}
const flatbuffers::Vector<flatbuffers::Offset<OperatorCode>> *operator_codes() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<OperatorCode>> *>(VT_OPERATOR_CODES);
}
const flatbuffers::Vector<flatbuffers::Offset<SubGraph>> *subgraphs() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<SubGraph>> *>(VT_SUBGRAPHS);
}
const flatbuffers::String *description() const {
return GetPointer<const flatbuffers::String *>(VT_DESCRIPTION);
}
const flatbuffers::Vector<flatbuffers::Offset<Buffer>> *buffers() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Buffer>> *>(VT_BUFFERS);
}
const flatbuffers::Vector<int32_t> *metadata_buffer() const {
return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_METADATA_BUFFER);
}
const flatbuffers::Vector<flatbuffers::Offset<Metadata>> *metadata() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Metadata>> *>(VT_METADATA);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_VERSION) &&
VerifyOffset(verifier, VT_OPERATOR_CODES) &&
verifier.VerifyVector(operator_codes()) &&
verifier.VerifyVectorOfTables(operator_codes()) &&
VerifyOffset(verifier, VT_SUBGRAPHS) &&
verifier.VerifyVector(subgraphs()) &&
verifier.VerifyVectorOfTables(subgraphs()) &&
VerifyOffset(verifier, VT_DESCRIPTION) &&
verifier.VerifyString(description()) &&
VerifyOffset(verifier, VT_BUFFERS) &&
verifier.VerifyVector(buffers()) &&
verifier.VerifyVectorOfTables(buffers()) &&
VerifyOffset(verifier, VT_METADATA_BUFFER) &&
verifier.VerifyVector(metadata_buffer()) &&
VerifyOffset(verifier, VT_METADATA) &&
verifier.VerifyVector(metadata()) &&
verifier.VerifyVectorOfTables(metadata()) &&
verifier.EndTable();
}
ModelT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(ModelT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<Model> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ModelT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct ModelBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_version(uint32_t version) {
fbb_.AddElement<uint32_t>(Model::VT_VERSION, version, 0);
}
void add_operator_codes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<OperatorCode>>> operator_codes) {
fbb_.AddOffset(Model::VT_OPERATOR_CODES, operator_codes);
}
void add_subgraphs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<SubGraph>>> subgraphs) {
fbb_.AddOffset(Model::VT_SUBGRAPHS, subgraphs);
}
void add_description(flatbuffers::Offset<flatbuffers::String> description) {
fbb_.AddOffset(Model::VT_DESCRIPTION, description);
}
void add_buffers(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Buffer>>> buffers) {
fbb_.AddOffset(Model::VT_BUFFERS, buffers);
}
void add_metadata_buffer(flatbuffers::Offset<flatbuffers::Vector<int32_t>> metadata_buffer) {
fbb_.AddOffset(Model::VT_METADATA_BUFFER, metadata_buffer);
}
void add_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Metadata>>> metadata) {
fbb_.AddOffset(Model::VT_METADATA, metadata);
}
explicit ModelBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ModelBuilder &operator=(const ModelBuilder &);
flatbuffers::Offset<Model> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Model>(end);
return o;
}
};
inline flatbuffers::Offset<Model> CreateModel(
flatbuffers::FlatBufferBuilder &_fbb,
uint32_t version = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<OperatorCode>>> operator_codes = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<SubGraph>>> subgraphs = 0,
flatbuffers::Offset<flatbuffers::String> description = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Buffer>>> buffers = 0,
flatbuffers::Offset<flatbuffers::Vector<int32_t>> metadata_buffer = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Metadata>>> metadata = 0) {
ModelBuilder builder_(_fbb);
builder_.add_metadata(metadata);
builder_.add_metadata_buffer(metadata_buffer);
builder_.add_buffers(buffers);
builder_.add_description(description);
builder_.add_subgraphs(subgraphs);
builder_.add_operator_codes(operator_codes);
builder_.add_version(version);
return builder_.Finish();
}
inline flatbuffers::Offset<Model> CreateModelDirect(
flatbuffers::FlatBufferBuilder &_fbb,
uint32_t version = 0,
const std::vector<flatbuffers::Offset<OperatorCode>> *operator_codes = nullptr,
const std::vector<flatbuffers::Offset<SubGraph>> *subgraphs = nullptr,
const char *description = nullptr,
const std::vector<flatbuffers::Offset<Buffer>> *buffers = nullptr,
const std::vector<int32_t> *metadata_buffer = nullptr,
const std::vector<flatbuffers::Offset<Metadata>> *metadata = nullptr) {
auto operator_codes__ = operator_codes ? _fbb.CreateVector<flatbuffers::Offset<OperatorCode>>(*operator_codes) : 0;
auto subgraphs__ = subgraphs ? _fbb.CreateVector<flatbuffers::Offset<SubGraph>>(*subgraphs) : 0;
auto description__ = description ? _fbb.CreateString(description) : 0;
auto buffers__ = buffers ? _fbb.CreateVector<flatbuffers::Offset<Buffer>>(*buffers) : 0;
auto metadata_buffer__ = metadata_buffer ? _fbb.CreateVector<int32_t>(*metadata_buffer) : 0;
auto metadata__ = metadata ? _fbb.CreateVector<flatbuffers::Offset<Metadata>>(*metadata) : 0;
return tflite::CreateModel(
_fbb,
version,
operator_codes__,
subgraphs__,
description__,
buffers__,
metadata_buffer__,
metadata__);
}
flatbuffers::Offset<Model> CreateModel(flatbuffers::FlatBufferBuilder &_fbb, const ModelT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
inline CustomQuantizationT *CustomQuantization::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new CustomQuantizationT();
UnPackTo(_o, _resolver);
return _o;
}
inline void CustomQuantization::UnPackTo(CustomQuantizationT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = custom(); if (_e) { _o->custom.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->custom[_i] = _e->Get(_i); } } };
}
inline flatbuffers::Offset<CustomQuantization> CustomQuantization::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateCustomQuantization(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<CustomQuantization> CreateCustomQuantization(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CustomQuantizationT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _custom = _o->custom.size() ? _fbb.CreateVector(_o->custom) : 0;
return tflite::CreateCustomQuantization(
_fbb,
_custom);
}
inline QuantizationParametersT *QuantizationParameters::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new QuantizationParametersT();
UnPackTo(_o, _resolver);
return _o;
}
inline void QuantizationParameters::UnPackTo(QuantizationParametersT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = min(); if (_e) { _o->min.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->min[_i] = _e->Get(_i); } } };
{ auto _e = max(); if (_e) { _o->max.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->max[_i] = _e->Get(_i); } } };
{ auto _e = scale(); if (_e) { _o->scale.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->scale[_i] = _e->Get(_i); } } };
{ auto _e = zero_point(); if (_e) { _o->zero_point.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->zero_point[_i] = _e->Get(_i); } } };
{ auto _e = details_type(); _o->details.type = _e; };
{ auto _e = details(); if (_e) _o->details.value = QuantizationDetailsUnion::UnPack(_e, details_type(), _resolver); };
{ auto _e = quantized_dimension(); _o->quantized_dimension = _e; };
}
inline flatbuffers::Offset<QuantizationParameters> QuantizationParameters::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateQuantizationParameters(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const QuantizationParametersT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _min = _o->min.size() ? _fbb.CreateVector(_o->min) : 0;
auto _max = _o->max.size() ? _fbb.CreateVector(_o->max) : 0;
auto _scale = _o->scale.size() ? _fbb.CreateVector(_o->scale) : 0;
auto _zero_point = _o->zero_point.size() ? _fbb.CreateVector(_o->zero_point) : 0;
auto _details_type = _o->details.type;
auto _details = _o->details.Pack(_fbb);
auto _quantized_dimension = _o->quantized_dimension;
return tflite::CreateQuantizationParameters(
_fbb,
_min,
_max,
_scale,
_zero_point,
_details_type,
_details,
_quantized_dimension);
}
inline DimensionMetadataT *DimensionMetadata::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new DimensionMetadataT();
UnPackTo(_o, _resolver);
return _o;
}
inline void DimensionMetadata::UnPackTo(DimensionMetadataT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = format(); _o->format = _e; };
{ auto _e = dense_size(); _o->dense_size = _e; };
{ auto _e = array_segments(); if (_e) { _o->array_segments.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->array_segments[_i] = _e->Get(_i); } } };
{ auto _e = array_indices(); if (_e) { _o->array_indices.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->array_indices[_i] = _e->Get(_i); } } };
}
inline flatbuffers::Offset<DimensionMetadata> DimensionMetadata::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateDimensionMetadata(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<DimensionMetadata> CreateDimensionMetadata(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DimensionMetadataT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _format = _o->format;
auto _dense_size = _o->dense_size;
auto _array_segments = _o->array_segments.size() ? _fbb.CreateVector(_o->array_segments) : 0;
auto _array_indices = _o->array_indices.size() ? _fbb.CreateVector(_o->array_indices) : 0;
return tflite::CreateDimensionMetadata(
_fbb,
_format,
_dense_size,
_array_segments,
_array_indices);
}
inline SparsityParametersT *SparsityParameters::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new SparsityParametersT();
UnPackTo(_o, _resolver);
return _o;
}
inline void SparsityParameters::UnPackTo(SparsityParametersT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = traversal_order(); if (_e) { _o->traversal_order.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->traversal_order[_i] = _e->Get(_i); } } };
{ auto _e = block_map(); if (_e) { _o->block_map.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->block_map[_i] = _e->Get(_i); } } };
{ auto _e = dim_metadata(); if (_e) { _o->dim_metadata.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->dim_metadata[_i] = std::unique_ptr<DimensionMetadataT>(_e->Get(_i)->UnPack(_resolver)); } } };
}
inline flatbuffers::Offset<SparsityParameters> SparsityParameters::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateSparsityParameters(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<SparsityParameters> CreateSparsityParameters(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SparsityParametersT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _traversal_order = _o->traversal_order.size() ? _fbb.CreateVector(_o->traversal_order) : 0;
auto _block_map = _o->block_map.size() ? _fbb.CreateVector(_o->block_map) : 0;
auto _dim_metadata = _o->dim_metadata.size() ? _fbb.CreateVector<flatbuffers::Offset<DimensionMetadata>> (_o->dim_metadata.size(), [](size_t i, _VectorArgs *__va) { return CreateDimensionMetadata(*__va->__fbb, __va->__o->dim_metadata[i].get(), __va->__rehasher); }, &_va ) : 0;
return tflite::CreateSparsityParameters(
_fbb,
_traversal_order,
_block_map,
_dim_metadata);
}
inline TensorT *Tensor::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new TensorT();
UnPackTo(_o, _resolver);
return _o;
}
inline void Tensor::UnPackTo(TensorT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = shape(); if (_e) { _o->shape.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->shape[_i] = _e->Get(_i); } } };
{ auto _e = type(); _o->type = _e; };
{ auto _e = buffer(); _o->buffer = _e; };
{ auto _e = name(); if (_e) _o->name = _e->str(); };
{ auto _e = quantization(); if (_e) _o->quantization = std::unique_ptr<QuantizationParametersT>(_e->UnPack(_resolver)); };
{ auto _e = is_variable(); _o->is_variable = _e; };
{ auto _e = sparsity(); if (_e) _o->sparsity = std::unique_ptr<SparsityParametersT>(_e->UnPack(_resolver)); };
}
inline flatbuffers::Offset<Tensor> Tensor::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateTensor(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<Tensor> CreateTensor(flatbuffers::FlatBufferBuilder &_fbb, const TensorT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TensorT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _shape = _o->shape.size() ? _fbb.CreateVector(_o->shape) : 0;
auto _type = _o->type;
auto _buffer = _o->buffer;
auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
auto _quantization = _o->quantization ? CreateQuantizationParameters(_fbb, _o->quantization.get(), _rehasher) : 0;
auto _is_variable = _o->is_variable;
auto _sparsity = _o->sparsity ? CreateSparsityParameters(_fbb, _o->sparsity.get(), _rehasher) : 0;
return tflite::CreateTensor(
_fbb,
_shape,
_type,
_buffer,
_name,
_quantization,
_is_variable,
_sparsity);
}
inline Conv2DOptionsT *Conv2DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new Conv2DOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void Conv2DOptions::UnPackTo(Conv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = padding(); _o->padding = _e; };
{ auto _e = stride_w(); _o->stride_w = _e; };
{ auto _e = stride_h(); _o->stride_h = _e; };
{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; };
{ auto _e = dilation_w_factor(); _o->dilation_w_factor = _e; };
{ auto _e = dilation_h_factor(); _o->dilation_h_factor = _e; };
}
inline flatbuffers::Offset<Conv2DOptions> Conv2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateConv2DOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Conv2DOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _padding = _o->padding;
auto _stride_w = _o->stride_w;
auto _stride_h = _o->stride_h;
auto _fused_activation_function = _o->fused_activation_function;
auto _dilation_w_factor = _o->dilation_w_factor;
auto _dilation_h_factor = _o->dilation_h_factor;
return tflite::CreateConv2DOptions(
_fbb,
_padding,
_stride_w,
_stride_h,
_fused_activation_function,
_dilation_w_factor,
_dilation_h_factor);
}
inline Pool2DOptionsT *Pool2DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new Pool2DOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void Pool2DOptions::UnPackTo(Pool2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = padding(); _o->padding = _e; };
{ auto _e = stride_w(); _o->stride_w = _e; };
{ auto _e = stride_h(); _o->stride_h = _e; };
{ auto _e = filter_width(); _o->filter_width = _e; };
{ auto _e = filter_height(); _o->filter_height = _e; };
{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; };
}
inline flatbuffers::Offset<Pool2DOptions> Pool2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreatePool2DOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Pool2DOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _padding = _o->padding;
auto _stride_w = _o->stride_w;
auto _stride_h = _o->stride_h;
auto _filter_width = _o->filter_width;
auto _filter_height = _o->filter_height;
auto _fused_activation_function = _o->fused_activation_function;
return tflite::CreatePool2DOptions(
_fbb,
_padding,
_stride_w,
_stride_h,
_filter_width,
_filter_height,
_fused_activation_function);
}
inline DepthwiseConv2DOptionsT *DepthwiseConv2DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new DepthwiseConv2DOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void DepthwiseConv2DOptions::UnPackTo(DepthwiseConv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = padding(); _o->padding = _e; };
{ auto _e = stride_w(); _o->stride_w = _e; };
{ auto _e = stride_h(); _o->stride_h = _e; };
{ auto _e = depth_multiplier(); _o->depth_multiplier = _e; };
{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; };
{ auto _e = dilation_w_factor(); _o->dilation_w_factor = _e; };
{ auto _e = dilation_h_factor(); _o->dilation_h_factor = _e; };
}
inline flatbuffers::Offset<DepthwiseConv2DOptions> DepthwiseConv2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateDepthwiseConv2DOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DepthwiseConv2DOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _padding = _o->padding;
auto _stride_w = _o->stride_w;
auto _stride_h = _o->stride_h;
auto _depth_multiplier = _o->depth_multiplier;
auto _fused_activation_function = _o->fused_activation_function;
auto _dilation_w_factor = _o->dilation_w_factor;
auto _dilation_h_factor = _o->dilation_h_factor;
return tflite::CreateDepthwiseConv2DOptions(
_fbb,
_padding,
_stride_w,
_stride_h,
_depth_multiplier,
_fused_activation_function,
_dilation_w_factor,
_dilation_h_factor);
}
inline ConcatEmbeddingsOptionsT *ConcatEmbeddingsOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new ConcatEmbeddingsOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void ConcatEmbeddingsOptions::UnPackTo(ConcatEmbeddingsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = num_channels(); _o->num_channels = _e; };
{ auto _e = num_columns_per_channel(); if (_e) { _o->num_columns_per_channel.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->num_columns_per_channel[_i] = _e->Get(_i); } } };
{ auto _e = embedding_dim_per_channel(); if (_e) { _o->embedding_dim_per_channel.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->embedding_dim_per_channel[_i] = _e->Get(_i); } } };
}
inline flatbuffers::Offset<ConcatEmbeddingsOptions> ConcatEmbeddingsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateConcatEmbeddingsOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ConcatEmbeddingsOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _num_channels = _o->num_channels;
auto _num_columns_per_channel = _o->num_columns_per_channel.size() ? _fbb.CreateVector(_o->num_columns_per_channel) : 0;
auto _embedding_dim_per_channel = _o->embedding_dim_per_channel.size() ? _fbb.CreateVector(_o->embedding_dim_per_channel) : 0;
return tflite::CreateConcatEmbeddingsOptions(
_fbb,
_num_channels,
_num_columns_per_channel,
_embedding_dim_per_channel);
}
inline LSHProjectionOptionsT *LSHProjectionOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new LSHProjectionOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void LSHProjectionOptions::UnPackTo(LSHProjectionOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = type(); _o->type = _e; };
}
inline flatbuffers::Offset<LSHProjectionOptions> LSHProjectionOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateLSHProjectionOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<LSHProjectionOptions> CreateLSHProjectionOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LSHProjectionOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _type = _o->type;
return tflite::CreateLSHProjectionOptions(
_fbb,
_type);
}
inline SVDFOptionsT *SVDFOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new SVDFOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void SVDFOptions::UnPackTo(SVDFOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = rank(); _o->rank = _e; };
{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; };
}
inline flatbuffers::Offset<SVDFOptions> SVDFOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateSVDFOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<SVDFOptions> CreateSVDFOptions(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SVDFOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _rank = _o->rank;
auto _fused_activation_function = _o->fused_activation_function;
return tflite::CreateSVDFOptions(
_fbb,
_rank,
_fused_activation_function);
}
inline RNNOptionsT *RNNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new RNNOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void RNNOptions::UnPackTo(RNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; };
}
inline flatbuffers::Offset<RNNOptions> RNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateRNNOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<RNNOptions> CreateRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RNNOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _fused_activation_function = _o->fused_activation_function;
return tflite::CreateRNNOptions(
_fbb,
_fused_activation_function);
}
inline SequenceRNNOptionsT *SequenceRNNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new SequenceRNNOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void SequenceRNNOptions::UnPackTo(SequenceRNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = time_major(); _o->time_major = _e; };
{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; };
}
inline flatbuffers::Offset<SequenceRNNOptions> SequenceRNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateSequenceRNNOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SequenceRNNOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _time_major = _o->time_major;
auto _fused_activation_function = _o->fused_activation_function;
return tflite::CreateSequenceRNNOptions(
_fbb,
_time_major,
_fused_activation_function);
}
inline BidirectionalSequenceRNNOptionsT *BidirectionalSequenceRNNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new BidirectionalSequenceRNNOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void BidirectionalSequenceRNNOptions::UnPackTo(BidirectionalSequenceRNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = time_major(); _o->time_major = _e; };
{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; };
{ auto _e = merge_outputs(); _o->merge_outputs = _e; };
}
inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> BidirectionalSequenceRNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateBidirectionalSequenceRNNOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BidirectionalSequenceRNNOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _time_major = _o->time_major;
auto _fused_activation_function = _o->fused_activation_function;
auto _merge_outputs = _o->merge_outputs;
return tflite::CreateBidirectionalSequenceRNNOptions(
_fbb,
_time_major,
_fused_activation_function,
_merge_outputs);
}
inline FullyConnectedOptionsT *FullyConnectedOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new FullyConnectedOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void FullyConnectedOptions::UnPackTo(FullyConnectedOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; };
{ auto _e = weights_format(); _o->weights_format = _e; };
{ auto _e = keep_num_dims(); _o->keep_num_dims = _e; };
}
inline flatbuffers::Offset<FullyConnectedOptions> FullyConnectedOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateFullyConnectedOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FullyConnectedOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _fused_activation_function = _o->fused_activation_function;
auto _weights_format = _o->weights_format;
auto _keep_num_dims = _o->keep_num_dims;
return tflite::CreateFullyConnectedOptions(
_fbb,
_fused_activation_function,
_weights_format,
_keep_num_dims);
}
inline SoftmaxOptionsT *SoftmaxOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new SoftmaxOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void SoftmaxOptions::UnPackTo(SoftmaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = beta(); _o->beta = _e; };
}
inline flatbuffers::Offset<SoftmaxOptions> SoftmaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateSoftmaxOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<SoftmaxOptions> CreateSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SoftmaxOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _beta = _o->beta;
return tflite::CreateSoftmaxOptions(
_fbb,
_beta);
}
inline ConcatenationOptionsT *ConcatenationOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new ConcatenationOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void ConcatenationOptions::UnPackTo(ConcatenationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = axis(); _o->axis = _e; };
{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; };
}
inline flatbuffers::Offset<ConcatenationOptions> ConcatenationOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateConcatenationOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ConcatenationOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _axis = _o->axis;
auto _fused_activation_function = _o->fused_activation_function;
return tflite::CreateConcatenationOptions(
_fbb,
_axis,
_fused_activation_function);
}
inline AddOptionsT *AddOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new AddOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void AddOptions::UnPackTo(AddOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; };
}
inline flatbuffers::Offset<AddOptions> AddOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateAddOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<AddOptions> CreateAddOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AddOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _fused_activation_function = _o->fused_activation_function;
return tflite::CreateAddOptions(
_fbb,
_fused_activation_function);
}
inline MulOptionsT *MulOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new MulOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void MulOptions::UnPackTo(MulOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; };
}
inline flatbuffers::Offset<MulOptions> MulOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateMulOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<MulOptions> CreateMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MulOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _fused_activation_function = _o->fused_activation_function;
return tflite::CreateMulOptions(
_fbb,
_fused_activation_function);
}
inline L2NormOptionsT *L2NormOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new L2NormOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void L2NormOptions::UnPackTo(L2NormOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; };
}
inline flatbuffers::Offset<L2NormOptions> L2NormOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateL2NormOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<L2NormOptions> CreateL2NormOptions(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const L2NormOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _fused_activation_function = _o->fused_activation_function;
return tflite::CreateL2NormOptions(
_fbb,
_fused_activation_function);
}
inline LocalResponseNormalizationOptionsT *LocalResponseNormalizationOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new LocalResponseNormalizationOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void LocalResponseNormalizationOptions::UnPackTo(LocalResponseNormalizationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = radius(); _o->radius = _e; };
{ auto _e = bias(); _o->bias = _e; };
{ auto _e = alpha(); _o->alpha = _e; };
{ auto _e = beta(); _o->beta = _e; };
}
inline flatbuffers::Offset<LocalResponseNormalizationOptions> LocalResponseNormalizationOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateLocalResponseNormalizationOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<LocalResponseNormalizationOptions> CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LocalResponseNormalizationOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _radius = _o->radius;
auto _bias = _o->bias;
auto _alpha = _o->alpha;
auto _beta = _o->beta;
return tflite::CreateLocalResponseNormalizationOptions(
_fbb,
_radius,
_bias,
_alpha,
_beta);
}
inline LSTMOptionsT *LSTMOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new LSTMOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void LSTMOptions::UnPackTo(LSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; };
{ auto _e = cell_clip(); _o->cell_clip = _e; };
{ auto _e = proj_clip(); _o->proj_clip = _e; };
{ auto _e = kernel_type(); _o->kernel_type = _e; };
}
inline flatbuffers::Offset<LSTMOptions> LSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateLSTMOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<LSTMOptions> CreateLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LSTMOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _fused_activation_function = _o->fused_activation_function;
auto _cell_clip = _o->cell_clip;
auto _proj_clip = _o->proj_clip;
auto _kernel_type = _o->kernel_type;
return tflite::CreateLSTMOptions(
_fbb,
_fused_activation_function,
_cell_clip,
_proj_clip,
_kernel_type);
}
inline UnidirectionalSequenceLSTMOptionsT *UnidirectionalSequenceLSTMOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new UnidirectionalSequenceLSTMOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void UnidirectionalSequenceLSTMOptions::UnPackTo(UnidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; };
{ auto _e = cell_clip(); _o->cell_clip = _e; };
{ auto _e = proj_clip(); _o->proj_clip = _e; };
{ auto _e = time_major(); _o->time_major = _e; };
}
inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> UnidirectionalSequenceLSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateUnidirectionalSequenceLSTMOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> CreateUnidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UnidirectionalSequenceLSTMOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _fused_activation_function = _o->fused_activation_function;
auto _cell_clip = _o->cell_clip;
auto _proj_clip = _o->proj_clip;
auto _time_major = _o->time_major;
return tflite::CreateUnidirectionalSequenceLSTMOptions(
_fbb,
_fused_activation_function,
_cell_clip,
_proj_clip,
_time_major);
}
inline BidirectionalSequenceLSTMOptionsT *BidirectionalSequenceLSTMOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new BidirectionalSequenceLSTMOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void BidirectionalSequenceLSTMOptions::UnPackTo(BidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; };
{ auto _e = cell_clip(); _o->cell_clip = _e; };
{ auto _e = proj_clip(); _o->proj_clip = _e; };
{ auto _e = merge_outputs(); _o->merge_outputs = _e; };
{ auto _e = time_major(); _o->time_major = _e; };
}
inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions> BidirectionalSequenceLSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateBidirectionalSequenceLSTMOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BidirectionalSequenceLSTMOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _fused_activation_function = _o->fused_activation_function;
auto _cell_clip = _o->cell_clip;
auto _proj_clip = _o->proj_clip;
auto _merge_outputs = _o->merge_outputs;
auto _time_major = _o->time_major;
return tflite::CreateBidirectionalSequenceLSTMOptions(
_fbb,
_fused_activation_function,
_cell_clip,
_proj_clip,
_merge_outputs,
_time_major);
}
inline ResizeBilinearOptionsT *ResizeBilinearOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new ResizeBilinearOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void ResizeBilinearOptions::UnPackTo(ResizeBilinearOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = align_corners(); _o->align_corners = _e; };
}
inline flatbuffers::Offset<ResizeBilinearOptions> ResizeBilinearOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateResizeBilinearOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<ResizeBilinearOptions> CreateResizeBilinearOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ResizeBilinearOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _align_corners = _o->align_corners;
return tflite::CreateResizeBilinearOptions(
_fbb,
_align_corners);
}
inline ResizeNearestNeighborOptionsT *ResizeNearestNeighborOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new ResizeNearestNeighborOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void ResizeNearestNeighborOptions::UnPackTo(ResizeNearestNeighborOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = align_corners(); _o->align_corners = _e; };
}
inline flatbuffers::Offset<ResizeNearestNeighborOptions> ResizeNearestNeighborOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateResizeNearestNeighborOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<ResizeNearestNeighborOptions> CreateResizeNearestNeighborOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ResizeNearestNeighborOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _align_corners = _o->align_corners;
return tflite::CreateResizeNearestNeighborOptions(
_fbb,
_align_corners);
}
inline CallOptionsT *CallOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new CallOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void CallOptions::UnPackTo(CallOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = subgraph(); _o->subgraph = _e; };
}
inline flatbuffers::Offset<CallOptions> CallOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateCallOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<CallOptions> CreateCallOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CallOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _subgraph = _o->subgraph;
return tflite::CreateCallOptions(
_fbb,
_subgraph);
}
inline PadOptionsT *PadOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new PadOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void PadOptions::UnPackTo(PadOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<PadOptions> PadOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreatePadOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<PadOptions> CreatePadOptions(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PadOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreatePadOptions(
_fbb);
}
inline PadV2OptionsT *PadV2Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new PadV2OptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void PadV2Options::UnPackTo(PadV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<PadV2Options> PadV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreatePadV2Options(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<PadV2Options> CreatePadV2Options(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PadV2OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreatePadV2Options(
_fbb);
}
inline ReshapeOptionsT *ReshapeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new ReshapeOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void ReshapeOptions::UnPackTo(ReshapeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = new_shape(); if (_e) { _o->new_shape.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->new_shape[_i] = _e->Get(_i); } } };
}
inline flatbuffers::Offset<ReshapeOptions> ReshapeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateReshapeOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<ReshapeOptions> CreateReshapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReshapeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _new_shape = _o->new_shape.size() ? _fbb.CreateVector(_o->new_shape) : 0;
return tflite::CreateReshapeOptions(
_fbb,
_new_shape);
}
inline SpaceToBatchNDOptionsT *SpaceToBatchNDOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new SpaceToBatchNDOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void SpaceToBatchNDOptions::UnPackTo(SpaceToBatchNDOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<SpaceToBatchNDOptions> SpaceToBatchNDOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateSpaceToBatchNDOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<SpaceToBatchNDOptions> CreateSpaceToBatchNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SpaceToBatchNDOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateSpaceToBatchNDOptions(
_fbb);
}
inline BatchToSpaceNDOptionsT *BatchToSpaceNDOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new BatchToSpaceNDOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void BatchToSpaceNDOptions::UnPackTo(BatchToSpaceNDOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<BatchToSpaceNDOptions> BatchToSpaceNDOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateBatchToSpaceNDOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<BatchToSpaceNDOptions> CreateBatchToSpaceNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BatchToSpaceNDOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateBatchToSpaceNDOptions(
_fbb);
}
inline SkipGramOptionsT *SkipGramOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new SkipGramOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void SkipGramOptions::UnPackTo(SkipGramOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = ngram_size(); _o->ngram_size = _e; };
{ auto _e = max_skip_size(); _o->max_skip_size = _e; };
{ auto _e = include_all_ngrams(); _o->include_all_ngrams = _e; };
}
inline flatbuffers::Offset<SkipGramOptions> SkipGramOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateSkipGramOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<SkipGramOptions> CreateSkipGramOptions(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SkipGramOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _ngram_size = _o->ngram_size;
auto _max_skip_size = _o->max_skip_size;
auto _include_all_ngrams = _o->include_all_ngrams;
return tflite::CreateSkipGramOptions(
_fbb,
_ngram_size,
_max_skip_size,
_include_all_ngrams);
}
inline SpaceToDepthOptionsT *SpaceToDepthOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new SpaceToDepthOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void SpaceToDepthOptions::UnPackTo(SpaceToDepthOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = block_size(); _o->block_size = _e; };
}
inline flatbuffers::Offset<SpaceToDepthOptions> SpaceToDepthOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateSpaceToDepthOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<SpaceToDepthOptions> CreateSpaceToDepthOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SpaceToDepthOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _block_size = _o->block_size;
return tflite::CreateSpaceToDepthOptions(
_fbb,
_block_size);
}
inline DepthToSpaceOptionsT *DepthToSpaceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new DepthToSpaceOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void DepthToSpaceOptions::UnPackTo(DepthToSpaceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = block_size(); _o->block_size = _e; };
}
inline flatbuffers::Offset<DepthToSpaceOptions> DepthToSpaceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateDepthToSpaceOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<DepthToSpaceOptions> CreateDepthToSpaceOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DepthToSpaceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _block_size = _o->block_size;
return tflite::CreateDepthToSpaceOptions(
_fbb,
_block_size);
}
inline SubOptionsT *SubOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new SubOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void SubOptions::UnPackTo(SubOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; };
}
inline flatbuffers::Offset<SubOptions> SubOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateSubOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<SubOptions> CreateSubOptions(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SubOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _fused_activation_function = _o->fused_activation_function;
return tflite::CreateSubOptions(
_fbb,
_fused_activation_function);
}
inline DivOptionsT *DivOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new DivOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void DivOptions::UnPackTo(DivOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; };
}
inline flatbuffers::Offset<DivOptions> DivOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateDivOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<DivOptions> CreateDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DivOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _fused_activation_function = _o->fused_activation_function;
return tflite::CreateDivOptions(
_fbb,
_fused_activation_function);
}
inline TopKV2OptionsT *TopKV2Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new TopKV2OptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void TopKV2Options::UnPackTo(TopKV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<TopKV2Options> TopKV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateTopKV2Options(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TopKV2OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateTopKV2Options(
_fbb);
}
inline EmbeddingLookupSparseOptionsT *EmbeddingLookupSparseOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new EmbeddingLookupSparseOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void EmbeddingLookupSparseOptions::UnPackTo(EmbeddingLookupSparseOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = combiner(); _o->combiner = _e; };
}
inline flatbuffers::Offset<EmbeddingLookupSparseOptions> EmbeddingLookupSparseOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateEmbeddingLookupSparseOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<EmbeddingLookupSparseOptions> CreateEmbeddingLookupSparseOptions(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const EmbeddingLookupSparseOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _combiner = _o->combiner;
return tflite::CreateEmbeddingLookupSparseOptions(
_fbb,
_combiner);
}
inline GatherOptionsT *GatherOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new GatherOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void GatherOptions::UnPackTo(GatherOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = axis(); _o->axis = _e; };
}
inline flatbuffers::Offset<GatherOptions> GatherOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateGatherOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<GatherOptions> CreateGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GatherOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _axis = _o->axis;
return tflite::CreateGatherOptions(
_fbb,
_axis);
}
inline TransposeOptionsT *TransposeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new TransposeOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void TransposeOptions::UnPackTo(TransposeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<TransposeOptions> TransposeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateTransposeOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<TransposeOptions> CreateTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TransposeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateTransposeOptions(
_fbb);
}
inline ExpOptionsT *ExpOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new ExpOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void ExpOptions::UnPackTo(ExpOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<ExpOptions> ExpOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateExpOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<ExpOptions> CreateExpOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ExpOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateExpOptions(
_fbb);
}
inline CosOptionsT *CosOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new CosOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void CosOptions::UnPackTo(CosOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<CosOptions> CosOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateCosOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<CosOptions> CreateCosOptions(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CosOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateCosOptions(
_fbb);
}
inline ReducerOptionsT *ReducerOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new ReducerOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void ReducerOptions::UnPackTo(ReducerOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = keep_dims(); _o->keep_dims = _e; };
}
inline flatbuffers::Offset<ReducerOptions> ReducerOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateReducerOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<ReducerOptions> CreateReducerOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReducerOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _keep_dims = _o->keep_dims;
return tflite::CreateReducerOptions(
_fbb,
_keep_dims);
}
inline SqueezeOptionsT *SqueezeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new SqueezeOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void SqueezeOptions::UnPackTo(SqueezeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = squeeze_dims(); if (_e) { _o->squeeze_dims.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->squeeze_dims[_i] = _e->Get(_i); } } };
}
inline flatbuffers::Offset<SqueezeOptions> SqueezeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateSqueezeOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptions(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SqueezeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _squeeze_dims = _o->squeeze_dims.size() ? _fbb.CreateVector(_o->squeeze_dims) : 0;
return tflite::CreateSqueezeOptions(
_fbb,
_squeeze_dims);
}
inline SplitOptionsT *SplitOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new SplitOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void SplitOptions::UnPackTo(SplitOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = num_splits(); _o->num_splits = _e; };
}
inline flatbuffers::Offset<SplitOptions> SplitOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateSplitOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<SplitOptions> CreateSplitOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SplitOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _num_splits = _o->num_splits;
return tflite::CreateSplitOptions(
_fbb,
_num_splits);
}
inline SplitVOptionsT *SplitVOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new SplitVOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void SplitVOptions::UnPackTo(SplitVOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = num_splits(); _o->num_splits = _e; };
}
inline flatbuffers::Offset<SplitVOptions> SplitVOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateSplitVOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SplitVOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _num_splits = _o->num_splits;
return tflite::CreateSplitVOptions(
_fbb,
_num_splits);
}
inline StridedSliceOptionsT *StridedSliceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new StridedSliceOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void StridedSliceOptions::UnPackTo(StridedSliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = begin_mask(); _o->begin_mask = _e; };
{ auto _e = end_mask(); _o->end_mask = _e; };
{ auto _e = ellipsis_mask(); _o->ellipsis_mask = _e; };
{ auto _e = new_axis_mask(); _o->new_axis_mask = _e; };
{ auto _e = shrink_axis_mask(); _o->shrink_axis_mask = _e; };
}
inline flatbuffers::Offset<StridedSliceOptions> StridedSliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateStridedSliceOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<StridedSliceOptions> CreateStridedSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StridedSliceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _begin_mask = _o->begin_mask;
auto _end_mask = _o->end_mask;
auto _ellipsis_mask = _o->ellipsis_mask;
auto _new_axis_mask = _o->new_axis_mask;
auto _shrink_axis_mask = _o->shrink_axis_mask;
return tflite::CreateStridedSliceOptions(
_fbb,
_begin_mask,
_end_mask,
_ellipsis_mask,
_new_axis_mask,
_shrink_axis_mask);
}
inline LogSoftmaxOptionsT *LogSoftmaxOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new LogSoftmaxOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void LogSoftmaxOptions::UnPackTo(LogSoftmaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<LogSoftmaxOptions> LogSoftmaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateLogSoftmaxOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<LogSoftmaxOptions> CreateLogSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LogSoftmaxOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateLogSoftmaxOptions(
_fbb);
}
inline CastOptionsT *CastOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new CastOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void CastOptions::UnPackTo(CastOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = in_data_type(); _o->in_data_type = _e; };
{ auto _e = out_data_type(); _o->out_data_type = _e; };
}
inline flatbuffers::Offset<CastOptions> CastOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateCastOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<CastOptions> CreateCastOptions(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CastOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _in_data_type = _o->in_data_type;
auto _out_data_type = _o->out_data_type;
return tflite::CreateCastOptions(
_fbb,
_in_data_type,
_out_data_type);
}
inline DequantizeOptionsT *DequantizeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new DequantizeOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void DequantizeOptions::UnPackTo(DequantizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<DequantizeOptions> DequantizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateDequantizeOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<DequantizeOptions> CreateDequantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DequantizeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateDequantizeOptions(
_fbb);
}
inline MaximumMinimumOptionsT *MaximumMinimumOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new MaximumMinimumOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void MaximumMinimumOptions::UnPackTo(MaximumMinimumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<MaximumMinimumOptions> MaximumMinimumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateMaximumMinimumOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<MaximumMinimumOptions> CreateMaximumMinimumOptions(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MaximumMinimumOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateMaximumMinimumOptions(
_fbb);
}
inline TileOptionsT *TileOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new TileOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void TileOptions::UnPackTo(TileOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<TileOptions> TileOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateTileOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<TileOptions> CreateTileOptions(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TileOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateTileOptions(
_fbb);
}
inline ArgMaxOptionsT *ArgMaxOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new ArgMaxOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void ArgMaxOptions::UnPackTo(ArgMaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = output_type(); _o->output_type = _e; };
}
inline flatbuffers::Offset<ArgMaxOptions> ArgMaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateArgMaxOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<ArgMaxOptions> CreateArgMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ArgMaxOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _output_type = _o->output_type;
return tflite::CreateArgMaxOptions(
_fbb,
_output_type);
}
inline ArgMinOptionsT *ArgMinOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new ArgMinOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void ArgMinOptions::UnPackTo(ArgMinOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = output_type(); _o->output_type = _e; };
}
inline flatbuffers::Offset<ArgMinOptions> ArgMinOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateArgMinOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<ArgMinOptions> CreateArgMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ArgMinOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _output_type = _o->output_type;
return tflite::CreateArgMinOptions(
_fbb,
_output_type);
}
inline GreaterOptionsT *GreaterOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new GreaterOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void GreaterOptions::UnPackTo(GreaterOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<GreaterOptions> GreaterOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateGreaterOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<GreaterOptions> CreateGreaterOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GreaterOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateGreaterOptions(
_fbb);
}
inline GreaterEqualOptionsT *GreaterEqualOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new GreaterEqualOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void GreaterEqualOptions::UnPackTo(GreaterEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<GreaterEqualOptions> GreaterEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateGreaterEqualOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<GreaterEqualOptions> CreateGreaterEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GreaterEqualOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateGreaterEqualOptions(
_fbb);
}
inline LessOptionsT *LessOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new LessOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void LessOptions::UnPackTo(LessOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<LessOptions> LessOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateLessOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<LessOptions> CreateLessOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LessOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateLessOptions(
_fbb);
}
inline LessEqualOptionsT *LessEqualOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new LessEqualOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void LessEqualOptions::UnPackTo(LessEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<LessEqualOptions> LessEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateLessEqualOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<LessEqualOptions> CreateLessEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LessEqualOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateLessEqualOptions(
_fbb);
}
inline NegOptionsT *NegOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new NegOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void NegOptions::UnPackTo(NegOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<NegOptions> NegOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateNegOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<NegOptions> CreateNegOptions(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NegOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateNegOptions(
_fbb);
}
inline SelectOptionsT *SelectOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new SelectOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void SelectOptions::UnPackTo(SelectOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<SelectOptions> SelectOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateSelectOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<SelectOptions> CreateSelectOptions(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SelectOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateSelectOptions(
_fbb);
}
inline SliceOptionsT *SliceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new SliceOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void SliceOptions::UnPackTo(SliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<SliceOptions> SliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateSliceOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<SliceOptions> CreateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SliceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateSliceOptions(
_fbb);
}
inline TransposeConvOptionsT *TransposeConvOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new TransposeConvOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void TransposeConvOptions::UnPackTo(TransposeConvOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = padding(); _o->padding = _e; };
{ auto _e = stride_w(); _o->stride_w = _e; };
{ auto _e = stride_h(); _o->stride_h = _e; };
}
inline flatbuffers::Offset<TransposeConvOptions> TransposeConvOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateTransposeConvOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<TransposeConvOptions> CreateTransposeConvOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TransposeConvOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _padding = _o->padding;
auto _stride_w = _o->stride_w;
auto _stride_h = _o->stride_h;
return tflite::CreateTransposeConvOptions(
_fbb,
_padding,
_stride_w,
_stride_h);
}
inline ExpandDimsOptionsT *ExpandDimsOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new ExpandDimsOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void ExpandDimsOptions::UnPackTo(ExpandDimsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<ExpandDimsOptions> ExpandDimsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateExpandDimsOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<ExpandDimsOptions> CreateExpandDimsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ExpandDimsOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateExpandDimsOptions(
_fbb);
}
inline SparseToDenseOptionsT *SparseToDenseOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new SparseToDenseOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void SparseToDenseOptions::UnPackTo(SparseToDenseOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = validate_indices(); _o->validate_indices = _e; };
}
inline flatbuffers::Offset<SparseToDenseOptions> SparseToDenseOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateSparseToDenseOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<SparseToDenseOptions> CreateSparseToDenseOptions(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SparseToDenseOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _validate_indices = _o->validate_indices;
return tflite::CreateSparseToDenseOptions(
_fbb,
_validate_indices);
}
inline EqualOptionsT *EqualOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new EqualOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void EqualOptions::UnPackTo(EqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<EqualOptions> EqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateEqualOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<EqualOptions> CreateEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const EqualOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateEqualOptions(
_fbb);
}
inline NotEqualOptionsT *NotEqualOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new NotEqualOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void NotEqualOptions::UnPackTo(NotEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<NotEqualOptions> NotEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateNotEqualOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<NotEqualOptions> CreateNotEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NotEqualOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateNotEqualOptions(
_fbb);
}
inline ShapeOptionsT *ShapeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new ShapeOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void ShapeOptions::UnPackTo(ShapeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = out_type(); _o->out_type = _e; };
}
inline flatbuffers::Offset<ShapeOptions> ShapeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateShapeOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<ShapeOptions> CreateShapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ShapeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _out_type = _o->out_type;
return tflite::CreateShapeOptions(
_fbb,
_out_type);
}
inline RankOptionsT *RankOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new RankOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void RankOptions::UnPackTo(RankOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<RankOptions> RankOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateRankOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<RankOptions> CreateRankOptions(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RankOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateRankOptions(
_fbb);
}
inline PowOptionsT *PowOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new PowOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void PowOptions::UnPackTo(PowOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<PowOptions> PowOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreatePowOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<PowOptions> CreatePowOptions(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PowOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreatePowOptions(
_fbb);
}
inline FakeQuantOptionsT *FakeQuantOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new FakeQuantOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void FakeQuantOptions::UnPackTo(FakeQuantOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = min(); _o->min = _e; };
{ auto _e = max(); _o->max = _e; };
{ auto _e = num_bits(); _o->num_bits = _e; };
{ auto _e = narrow_range(); _o->narrow_range = _e; };
}
inline flatbuffers::Offset<FakeQuantOptions> FakeQuantOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateFakeQuantOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<FakeQuantOptions> CreateFakeQuantOptions(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FakeQuantOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _min = _o->min;
auto _max = _o->max;
auto _num_bits = _o->num_bits;
auto _narrow_range = _o->narrow_range;
return tflite::CreateFakeQuantOptions(
_fbb,
_min,
_max,
_num_bits,
_narrow_range);
}
inline PackOptionsT *PackOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new PackOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void PackOptions::UnPackTo(PackOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = values_count(); _o->values_count = _e; };
{ auto _e = axis(); _o->axis = _e; };
}
inline flatbuffers::Offset<PackOptions> PackOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreatePackOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<PackOptions> CreatePackOptions(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PackOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _values_count = _o->values_count;
auto _axis = _o->axis;
return tflite::CreatePackOptions(
_fbb,
_values_count,
_axis);
}
inline LogicalOrOptionsT *LogicalOrOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new LogicalOrOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void LogicalOrOptions::UnPackTo(LogicalOrOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<LogicalOrOptions> LogicalOrOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateLogicalOrOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<LogicalOrOptions> CreateLogicalOrOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LogicalOrOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateLogicalOrOptions(
_fbb);
}
inline OneHotOptionsT *OneHotOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new OneHotOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void OneHotOptions::UnPackTo(OneHotOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = axis(); _o->axis = _e; };
}
inline flatbuffers::Offset<OneHotOptions> OneHotOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateOneHotOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const OneHotOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _axis = _o->axis;
return tflite::CreateOneHotOptions(
_fbb,
_axis);
}
inline AbsOptionsT *AbsOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new AbsOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void AbsOptions::UnPackTo(AbsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<AbsOptions> AbsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateAbsOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<AbsOptions> CreateAbsOptions(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AbsOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateAbsOptions(
_fbb);
}
inline HardSwishOptionsT *HardSwishOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new HardSwishOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void HardSwishOptions::UnPackTo(HardSwishOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<HardSwishOptions> HardSwishOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateHardSwishOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<HardSwishOptions> CreateHardSwishOptions(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HardSwishOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateHardSwishOptions(
_fbb);
}
inline LogicalAndOptionsT *LogicalAndOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new LogicalAndOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void LogicalAndOptions::UnPackTo(LogicalAndOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<LogicalAndOptions> LogicalAndOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateLogicalAndOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<LogicalAndOptions> CreateLogicalAndOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LogicalAndOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateLogicalAndOptions(
_fbb);
}
inline LogicalNotOptionsT *LogicalNotOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new LogicalNotOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void LogicalNotOptions::UnPackTo(LogicalNotOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<LogicalNotOptions> LogicalNotOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateLogicalNotOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<LogicalNotOptions> CreateLogicalNotOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LogicalNotOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateLogicalNotOptions(
_fbb);
}
inline UnpackOptionsT *UnpackOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new UnpackOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void UnpackOptions::UnPackTo(UnpackOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = num(); _o->num = _e; };
{ auto _e = axis(); _o->axis = _e; };
}
inline flatbuffers::Offset<UnpackOptions> UnpackOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateUnpackOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UnpackOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _num = _o->num;
auto _axis = _o->axis;
return tflite::CreateUnpackOptions(
_fbb,
_num,
_axis);
}
inline FloorDivOptionsT *FloorDivOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new FloorDivOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void FloorDivOptions::UnPackTo(FloorDivOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<FloorDivOptions> FloorDivOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateFloorDivOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<FloorDivOptions> CreateFloorDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FloorDivOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateFloorDivOptions(
_fbb);
}
inline SquareOptionsT *SquareOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new SquareOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void SquareOptions::UnPackTo(SquareOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<SquareOptions> SquareOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateSquareOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<SquareOptions> CreateSquareOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SquareOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateSquareOptions(
_fbb);
}
inline ZerosLikeOptionsT *ZerosLikeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new ZerosLikeOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void ZerosLikeOptions::UnPackTo(ZerosLikeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<ZerosLikeOptions> ZerosLikeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateZerosLikeOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<ZerosLikeOptions> CreateZerosLikeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ZerosLikeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateZerosLikeOptions(
_fbb);
}
inline FillOptionsT *FillOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new FillOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void FillOptions::UnPackTo(FillOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<FillOptions> FillOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateFillOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<FillOptions> CreateFillOptions(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FillOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateFillOptions(
_fbb);
}
inline FloorModOptionsT *FloorModOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new FloorModOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void FloorModOptions::UnPackTo(FloorModOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<FloorModOptions> FloorModOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateFloorModOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<FloorModOptions> CreateFloorModOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FloorModOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateFloorModOptions(
_fbb);
}
inline RangeOptionsT *RangeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new RangeOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void RangeOptions::UnPackTo(RangeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<RangeOptions> RangeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateRangeOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<RangeOptions> CreateRangeOptions(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RangeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateRangeOptions(
_fbb);
}
inline LeakyReluOptionsT *LeakyReluOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new LeakyReluOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void LeakyReluOptions::UnPackTo(LeakyReluOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = alpha(); _o->alpha = _e; };
}
inline flatbuffers::Offset<LeakyReluOptions> LeakyReluOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateLeakyReluOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<LeakyReluOptions> CreateLeakyReluOptions(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LeakyReluOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _alpha = _o->alpha;
return tflite::CreateLeakyReluOptions(
_fbb,
_alpha);
}
inline SquaredDifferenceOptionsT *SquaredDifferenceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new SquaredDifferenceOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void SquaredDifferenceOptions::UnPackTo(SquaredDifferenceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<SquaredDifferenceOptions> SquaredDifferenceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateSquaredDifferenceOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<SquaredDifferenceOptions> CreateSquaredDifferenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SquaredDifferenceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateSquaredDifferenceOptions(
_fbb);
}
inline MirrorPadOptionsT *MirrorPadOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new MirrorPadOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void MirrorPadOptions::UnPackTo(MirrorPadOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = mode(); _o->mode = _e; };
}
inline flatbuffers::Offset<MirrorPadOptions> MirrorPadOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateMirrorPadOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<MirrorPadOptions> CreateMirrorPadOptions(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MirrorPadOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _mode = _o->mode;
return tflite::CreateMirrorPadOptions(
_fbb,
_mode);
}
inline UniqueOptionsT *UniqueOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new UniqueOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void UniqueOptions::UnPackTo(UniqueOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = idx_out_type(); _o->idx_out_type = _e; };
}
inline flatbuffers::Offset<UniqueOptions> UniqueOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateUniqueOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<UniqueOptions> CreateUniqueOptions(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UniqueOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _idx_out_type = _o->idx_out_type;
return tflite::CreateUniqueOptions(
_fbb,
_idx_out_type);
}
inline ReverseV2OptionsT *ReverseV2Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new ReverseV2OptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void ReverseV2Options::UnPackTo(ReverseV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<ReverseV2Options> ReverseV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateReverseV2Options(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<ReverseV2Options> CreateReverseV2Options(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReverseV2OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateReverseV2Options(
_fbb);
}
inline AddNOptionsT *AddNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new AddNOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void AddNOptions::UnPackTo(AddNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<AddNOptions> AddNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateAddNOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<AddNOptions> CreateAddNOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AddNOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateAddNOptions(
_fbb);
}
inline GatherNdOptionsT *GatherNdOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new GatherNdOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void GatherNdOptions::UnPackTo(GatherNdOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<GatherNdOptions> GatherNdOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateGatherNdOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<GatherNdOptions> CreateGatherNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GatherNdOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateGatherNdOptions(
_fbb);
}
inline WhereOptionsT *WhereOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new WhereOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void WhereOptions::UnPackTo(WhereOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<WhereOptions> WhereOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateWhereOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<WhereOptions> CreateWhereOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const WhereOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateWhereOptions(
_fbb);
}
inline ReverseSequenceOptionsT *ReverseSequenceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new ReverseSequenceOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void ReverseSequenceOptions::UnPackTo(ReverseSequenceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = seq_dim(); _o->seq_dim = _e; };
{ auto _e = batch_dim(); _o->batch_dim = _e; };
}
inline flatbuffers::Offset<ReverseSequenceOptions> ReverseSequenceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateReverseSequenceOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<ReverseSequenceOptions> CreateReverseSequenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReverseSequenceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _seq_dim = _o->seq_dim;
auto _batch_dim = _o->batch_dim;
return tflite::CreateReverseSequenceOptions(
_fbb,
_seq_dim,
_batch_dim);
}
inline MatrixDiagOptionsT *MatrixDiagOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new MatrixDiagOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void MatrixDiagOptions::UnPackTo(MatrixDiagOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<MatrixDiagOptions> MatrixDiagOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateMatrixDiagOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<MatrixDiagOptions> CreateMatrixDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MatrixDiagOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateMatrixDiagOptions(
_fbb);
}
inline QuantizeOptionsT *QuantizeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new QuantizeOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void QuantizeOptions::UnPackTo(QuantizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<QuantizeOptions> QuantizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateQuantizeOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<QuantizeOptions> CreateQuantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const QuantizeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateQuantizeOptions(
_fbb);
}
inline MatrixSetDiagOptionsT *MatrixSetDiagOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new MatrixSetDiagOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void MatrixSetDiagOptions::UnPackTo(MatrixSetDiagOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<MatrixSetDiagOptions> MatrixSetDiagOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateMatrixSetDiagOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<MatrixSetDiagOptions> CreateMatrixSetDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MatrixSetDiagOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateMatrixSetDiagOptions(
_fbb);
}
inline IfOptionsT *IfOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new IfOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void IfOptions::UnPackTo(IfOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = then_subgraph_index(); _o->then_subgraph_index = _e; };
{ auto _e = else_subgraph_index(); _o->else_subgraph_index = _e; };
}
inline flatbuffers::Offset<IfOptions> IfOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateIfOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<IfOptions> CreateIfOptions(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const IfOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _then_subgraph_index = _o->then_subgraph_index;
auto _else_subgraph_index = _o->else_subgraph_index;
return tflite::CreateIfOptions(
_fbb,
_then_subgraph_index,
_else_subgraph_index);
}
inline WhileOptionsT *WhileOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new WhileOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void WhileOptions::UnPackTo(WhileOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = cond_subgraph_index(); _o->cond_subgraph_index = _e; };
{ auto _e = body_subgraph_index(); _o->body_subgraph_index = _e; };
}
inline flatbuffers::Offset<WhileOptions> WhileOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateWhileOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<WhileOptions> CreateWhileOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const WhileOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _cond_subgraph_index = _o->cond_subgraph_index;
auto _body_subgraph_index = _o->body_subgraph_index;
return tflite::CreateWhileOptions(
_fbb,
_cond_subgraph_index,
_body_subgraph_index);
}
inline NonMaxSuppressionV4OptionsT *NonMaxSuppressionV4Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new NonMaxSuppressionV4OptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void NonMaxSuppressionV4Options::UnPackTo(NonMaxSuppressionV4OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<NonMaxSuppressionV4Options> NonMaxSuppressionV4Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateNonMaxSuppressionV4Options(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<NonMaxSuppressionV4Options> CreateNonMaxSuppressionV4Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NonMaxSuppressionV4OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateNonMaxSuppressionV4Options(
_fbb);
}
inline NonMaxSuppressionV5OptionsT *NonMaxSuppressionV5Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new NonMaxSuppressionV5OptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void NonMaxSuppressionV5Options::UnPackTo(NonMaxSuppressionV5OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<NonMaxSuppressionV5Options> NonMaxSuppressionV5Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateNonMaxSuppressionV5Options(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<NonMaxSuppressionV5Options> CreateNonMaxSuppressionV5Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NonMaxSuppressionV5OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateNonMaxSuppressionV5Options(
_fbb);
}
inline ScatterNdOptionsT *ScatterNdOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new ScatterNdOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void ScatterNdOptions::UnPackTo(ScatterNdOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<ScatterNdOptions> ScatterNdOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateScatterNdOptions(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<ScatterNdOptions> CreateScatterNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ScatterNdOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateScatterNdOptions(
_fbb);
}
inline SelectV2OptionsT *SelectV2Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new SelectV2OptionsT();
UnPackTo(_o, _resolver);
return _o;
}
inline void SelectV2Options::UnPackTo(SelectV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
}
inline flatbuffers::Offset<SelectV2Options> SelectV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateSelectV2Options(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<SelectV2Options> CreateSelectV2Options(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SelectV2OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
return tflite::CreateSelectV2Options(
_fbb);
}
inline OperatorCodeT *OperatorCode::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new OperatorCodeT();
UnPackTo(_o, _resolver);
return _o;
}
inline void OperatorCode::UnPackTo(OperatorCodeT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = builtin_code(); _o->builtin_code = _e; };
{ auto _e = custom_code(); if (_e) _o->custom_code = _e->str(); };
{ auto _e = version(); _o->version = _e; };
}
inline flatbuffers::Offset<OperatorCode> OperatorCode::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateOperatorCode(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<OperatorCode> CreateOperatorCode(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const OperatorCodeT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _builtin_code = _o->builtin_code;
auto _custom_code = _o->custom_code.empty() ? 0 : _fbb.CreateString(_o->custom_code);
auto _version = _o->version;
return tflite::CreateOperatorCode(
_fbb,
_builtin_code,
_custom_code,
_version);
}
inline OperatorT *Operator::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new OperatorT();
UnPackTo(_o, _resolver);
return _o;
}
inline void Operator::UnPackTo(OperatorT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = opcode_index(); _o->opcode_index = _e; };
{ auto _e = inputs(); if (_e) { _o->inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inputs[_i] = _e->Get(_i); } } };
{ auto _e = outputs(); if (_e) { _o->outputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->outputs[_i] = _e->Get(_i); } } };
{ auto _e = builtin_options_type(); _o->builtin_options.type = _e; };
{ auto _e = builtin_options(); if (_e) _o->builtin_options.value = BuiltinOptionsUnion::UnPack(_e, builtin_options_type(), _resolver); };
{ auto _e = custom_options(); if (_e) { _o->custom_options.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->custom_options[_i] = _e->Get(_i); } } };
{ auto _e = custom_options_format(); _o->custom_options_format = _e; };
{ auto _e = mutating_variable_inputs(); if (_e) { _o->mutating_variable_inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->mutating_variable_inputs[_i] = _e->Get(_i) != 0; } } };
{ auto _e = intermediates(); if (_e) { _o->intermediates.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->intermediates[_i] = _e->Get(_i); } } };
}
inline flatbuffers::Offset<Operator> Operator::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateOperator(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<Operator> CreateOperator(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const OperatorT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _opcode_index = _o->opcode_index;
auto _inputs = _o->inputs.size() ? _fbb.CreateVector(_o->inputs) : 0;
auto _outputs = _o->outputs.size() ? _fbb.CreateVector(_o->outputs) : 0;
auto _builtin_options_type = _o->builtin_options.type;
auto _builtin_options = _o->builtin_options.Pack(_fbb);
auto _custom_options = _o->custom_options.size() ? _fbb.CreateVector(_o->custom_options) : 0;
auto _custom_options_format = _o->custom_options_format;
auto _mutating_variable_inputs = _o->mutating_variable_inputs.size() ? _fbb.CreateVector(_o->mutating_variable_inputs) : 0;
auto _intermediates = _o->intermediates.size() ? _fbb.CreateVector(_o->intermediates) : 0;
return tflite::CreateOperator(
_fbb,
_opcode_index,
_inputs,
_outputs,
_builtin_options_type,
_builtin_options,
_custom_options,
_custom_options_format,
_mutating_variable_inputs,
_intermediates);
}
inline SubGraphT *SubGraph::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new SubGraphT();
UnPackTo(_o, _resolver);
return _o;
}
inline void SubGraph::UnPackTo(SubGraphT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = tensors(); if (_e) { _o->tensors.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->tensors[_i] = std::unique_ptr<TensorT>(_e->Get(_i)->UnPack(_resolver)); } } };
{ auto _e = inputs(); if (_e) { _o->inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inputs[_i] = _e->Get(_i); } } };
{ auto _e = outputs(); if (_e) { _o->outputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->outputs[_i] = _e->Get(_i); } } };
{ auto _e = operators(); if (_e) { _o->operators.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->operators[_i] = std::unique_ptr<OperatorT>(_e->Get(_i)->UnPack(_resolver)); } } };
{ auto _e = name(); if (_e) _o->name = _e->str(); };
}
inline flatbuffers::Offset<SubGraph> SubGraph::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateSubGraph(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<SubGraph> CreateSubGraph(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SubGraphT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _tensors = _o->tensors.size() ? _fbb.CreateVector<flatbuffers::Offset<Tensor>> (_o->tensors.size(), [](size_t i, _VectorArgs *__va) { return CreateTensor(*__va->__fbb, __va->__o->tensors[i].get(), __va->__rehasher); }, &_va ) : 0;
auto _inputs = _o->inputs.size() ? _fbb.CreateVector(_o->inputs) : 0;
auto _outputs = _o->outputs.size() ? _fbb.CreateVector(_o->outputs) : 0;
auto _operators = _o->operators.size() ? _fbb.CreateVector<flatbuffers::Offset<Operator>> (_o->operators.size(), [](size_t i, _VectorArgs *__va) { return CreateOperator(*__va->__fbb, __va->__o->operators[i].get(), __va->__rehasher); }, &_va ) : 0;
auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
return tflite::CreateSubGraph(
_fbb,
_tensors,
_inputs,
_outputs,
_operators,
_name);
}
inline BufferT *Buffer::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new BufferT();
UnPackTo(_o, _resolver);
return _o;
}
inline void Buffer::UnPackTo(BufferT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = data(); if (_e) { _o->data.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->data[_i] = _e->Get(_i); } } };
}
inline flatbuffers::Offset<Buffer> Buffer::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BufferT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateBuffer(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<Buffer> CreateBuffer(flatbuffers::FlatBufferBuilder &_fbb, const BufferT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BufferT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _data = _o->data.size() ? _fbb.CreateVector(_o->data) : 0;
return tflite::CreateBuffer(
_fbb,
_data);
}
inline MetadataT *Metadata::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new MetadataT();
UnPackTo(_o, _resolver);
return _o;
}
inline void Metadata::UnPackTo(MetadataT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = name(); if (_e) _o->name = _e->str(); };
{ auto _e = buffer(); _o->buffer = _e; };
}
inline flatbuffers::Offset<Metadata> Metadata::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateMetadata(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<Metadata> CreateMetadata(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MetadataT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
auto _buffer = _o->buffer;
return tflite::CreateMetadata(
_fbb,
_name,
_buffer);
}
inline ModelT *Model::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new ModelT();
UnPackTo(_o, _resolver);
return _o;
}
inline void Model::UnPackTo(ModelT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = version(); _o->version = _e; };
{ auto _e = operator_codes(); if (_e) { _o->operator_codes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->operator_codes[_i] = std::unique_ptr<OperatorCodeT>(_e->Get(_i)->UnPack(_resolver)); } } };
{ auto _e = subgraphs(); if (_e) { _o->subgraphs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->subgraphs[_i] = std::unique_ptr<SubGraphT>(_e->Get(_i)->UnPack(_resolver)); } } };
{ auto _e = description(); if (_e) _o->description = _e->str(); };
{ auto _e = buffers(); if (_e) { _o->buffers.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->buffers[_i] = std::unique_ptr<BufferT>(_e->Get(_i)->UnPack(_resolver)); } } };
{ auto _e = metadata_buffer(); if (_e) { _o->metadata_buffer.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->metadata_buffer[_i] = _e->Get(_i); } } };
{ auto _e = metadata(); if (_e) { _o->metadata.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->metadata[_i] = std::unique_ptr<MetadataT>(_e->Get(_i)->UnPack(_resolver)); } } };
}
inline flatbuffers::Offset<Model> Model::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ModelT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateModel(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<Model> CreateModel(flatbuffers::FlatBufferBuilder &_fbb, const ModelT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ModelT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _version = _o->version;
auto _operator_codes = _o->operator_codes.size() ? _fbb.CreateVector<flatbuffers::Offset<OperatorCode>> (_o->operator_codes.size(), [](size_t i, _VectorArgs *__va) { return CreateOperatorCode(*__va->__fbb, __va->__o->operator_codes[i].get(), __va->__rehasher); }, &_va ) : 0;
auto _subgraphs = _o->subgraphs.size() ? _fbb.CreateVector<flatbuffers::Offset<SubGraph>> (_o->subgraphs.size(), [](size_t i, _VectorArgs *__va) { return CreateSubGraph(*__va->__fbb, __va->__o->subgraphs[i].get(), __va->__rehasher); }, &_va ) : 0;
auto _description = _o->description.empty() ? 0 : _fbb.CreateString(_o->description);
auto _buffers = _o->buffers.size() ? _fbb.CreateVector<flatbuffers::Offset<Buffer>> (_o->buffers.size(), [](size_t i, _VectorArgs *__va) { return CreateBuffer(*__va->__fbb, __va->__o->buffers[i].get(), __va->__rehasher); }, &_va ) : 0;
auto _metadata_buffer = _o->metadata_buffer.size() ? _fbb.CreateVector(_o->metadata_buffer) : 0;
auto _metadata = _o->metadata.size() ? _fbb.CreateVector<flatbuffers::Offset<Metadata>> (_o->metadata.size(), [](size_t i, _VectorArgs *__va) { return CreateMetadata(*__va->__fbb, __va->__o->metadata[i].get(), __va->__rehasher); }, &_va ) : 0;
return tflite::CreateModel(
_fbb,
_version,
_operator_codes,
_subgraphs,
_description,
_buffers,
_metadata_buffer,
_metadata);
}
inline bool VerifyQuantizationDetails(flatbuffers::Verifier &verifier, const void *obj, QuantizationDetails type) {
switch (type) {
case QuantizationDetails_NONE: {
return true;
}
case QuantizationDetails_CustomQuantization: {
auto ptr = reinterpret_cast<const CustomQuantization *>(obj);
return verifier.VerifyTable(ptr);
}
default: return true;
}
}
inline bool VerifyQuantizationDetailsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
if (!values || !types) return !values && !types;
if (values->size() != types->size()) return false;
for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
if (!VerifyQuantizationDetails(
verifier, values->Get(i), types->GetEnum<QuantizationDetails>(i))) {
return false;
}
}
return true;
}
inline void *QuantizationDetailsUnion::UnPack(const void *obj, QuantizationDetails type, const flatbuffers::resolver_function_t *resolver) {
switch (type) {
case QuantizationDetails_CustomQuantization: {
auto ptr = reinterpret_cast<const CustomQuantization *>(obj);
return ptr->UnPack(resolver);
}
default: return nullptr;
}
}
inline flatbuffers::Offset<void> QuantizationDetailsUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
switch (type) {
case QuantizationDetails_CustomQuantization: {
auto ptr = reinterpret_cast<const CustomQuantizationT *>(value);
return CreateCustomQuantization(_fbb, ptr, _rehasher).Union();
}
default: return 0;
}
}
inline QuantizationDetailsUnion::QuantizationDetailsUnion(const QuantizationDetailsUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) {
switch (type) {
case QuantizationDetails_CustomQuantization: {
value = new CustomQuantizationT(*reinterpret_cast<CustomQuantizationT *>(u.value));
break;
}
default:
break;
}
}
inline void QuantizationDetailsUnion::Reset() {
switch (type) {
case QuantizationDetails_CustomQuantization: {
auto ptr = reinterpret_cast<CustomQuantizationT *>(value);
delete ptr;
break;
}
default: break;
}
value = nullptr;
type = QuantizationDetails_NONE;
}
inline bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type) {
switch (type) {
case BuiltinOptions_NONE: {
return true;
}
case BuiltinOptions_Conv2DOptions: {
auto ptr = reinterpret_cast<const Conv2DOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_DepthwiseConv2DOptions: {
auto ptr = reinterpret_cast<const DepthwiseConv2DOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_ConcatEmbeddingsOptions: {
auto ptr = reinterpret_cast<const ConcatEmbeddingsOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_LSHProjectionOptions: {
auto ptr = reinterpret_cast<const LSHProjectionOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_Pool2DOptions: {
auto ptr = reinterpret_cast<const Pool2DOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_SVDFOptions: {
auto ptr = reinterpret_cast<const SVDFOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_RNNOptions: {
auto ptr = reinterpret_cast<const RNNOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_FullyConnectedOptions: {
auto ptr = reinterpret_cast<const FullyConnectedOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_SoftmaxOptions: {
auto ptr = reinterpret_cast<const SoftmaxOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_ConcatenationOptions: {
auto ptr = reinterpret_cast<const ConcatenationOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_AddOptions: {
auto ptr = reinterpret_cast<const AddOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_L2NormOptions: {
auto ptr = reinterpret_cast<const L2NormOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_LocalResponseNormalizationOptions: {
auto ptr = reinterpret_cast<const LocalResponseNormalizationOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_LSTMOptions: {
auto ptr = reinterpret_cast<const LSTMOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_ResizeBilinearOptions: {
auto ptr = reinterpret_cast<const ResizeBilinearOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_CallOptions: {
auto ptr = reinterpret_cast<const CallOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_ReshapeOptions: {
auto ptr = reinterpret_cast<const ReshapeOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_SkipGramOptions: {
auto ptr = reinterpret_cast<const SkipGramOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_SpaceToDepthOptions: {
auto ptr = reinterpret_cast<const SpaceToDepthOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_EmbeddingLookupSparseOptions: {
auto ptr = reinterpret_cast<const EmbeddingLookupSparseOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_MulOptions: {
auto ptr = reinterpret_cast<const MulOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_PadOptions: {
auto ptr = reinterpret_cast<const PadOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_GatherOptions: {
auto ptr = reinterpret_cast<const GatherOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_BatchToSpaceNDOptions: {
auto ptr = reinterpret_cast<const BatchToSpaceNDOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_SpaceToBatchNDOptions: {
auto ptr = reinterpret_cast<const SpaceToBatchNDOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_TransposeOptions: {
auto ptr = reinterpret_cast<const TransposeOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_ReducerOptions: {
auto ptr = reinterpret_cast<const ReducerOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_SubOptions: {
auto ptr = reinterpret_cast<const SubOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_DivOptions: {
auto ptr = reinterpret_cast<const DivOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_SqueezeOptions: {
auto ptr = reinterpret_cast<const SqueezeOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_SequenceRNNOptions: {
auto ptr = reinterpret_cast<const SequenceRNNOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_StridedSliceOptions: {
auto ptr = reinterpret_cast<const StridedSliceOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_ExpOptions: {
auto ptr = reinterpret_cast<const ExpOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_TopKV2Options: {
auto ptr = reinterpret_cast<const TopKV2Options *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_SplitOptions: {
auto ptr = reinterpret_cast<const SplitOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_LogSoftmaxOptions: {
auto ptr = reinterpret_cast<const LogSoftmaxOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_CastOptions: {
auto ptr = reinterpret_cast<const CastOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_DequantizeOptions: {
auto ptr = reinterpret_cast<const DequantizeOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_MaximumMinimumOptions: {
auto ptr = reinterpret_cast<const MaximumMinimumOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_ArgMaxOptions: {
auto ptr = reinterpret_cast<const ArgMaxOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_LessOptions: {
auto ptr = reinterpret_cast<const LessOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_NegOptions: {
auto ptr = reinterpret_cast<const NegOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_PadV2Options: {
auto ptr = reinterpret_cast<const PadV2Options *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_GreaterOptions: {
auto ptr = reinterpret_cast<const GreaterOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_GreaterEqualOptions: {
auto ptr = reinterpret_cast<const GreaterEqualOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_LessEqualOptions: {
auto ptr = reinterpret_cast<const LessEqualOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_SelectOptions: {
auto ptr = reinterpret_cast<const SelectOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_SliceOptions: {
auto ptr = reinterpret_cast<const SliceOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_TransposeConvOptions: {
auto ptr = reinterpret_cast<const TransposeConvOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_SparseToDenseOptions: {
auto ptr = reinterpret_cast<const SparseToDenseOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_TileOptions: {
auto ptr = reinterpret_cast<const TileOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_ExpandDimsOptions: {
auto ptr = reinterpret_cast<const ExpandDimsOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_EqualOptions: {
auto ptr = reinterpret_cast<const EqualOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_NotEqualOptions: {
auto ptr = reinterpret_cast<const NotEqualOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_ShapeOptions: {
auto ptr = reinterpret_cast<const ShapeOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_PowOptions: {
auto ptr = reinterpret_cast<const PowOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_ArgMinOptions: {
auto ptr = reinterpret_cast<const ArgMinOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_FakeQuantOptions: {
auto ptr = reinterpret_cast<const FakeQuantOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_PackOptions: {
auto ptr = reinterpret_cast<const PackOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_LogicalOrOptions: {
auto ptr = reinterpret_cast<const LogicalOrOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_OneHotOptions: {
auto ptr = reinterpret_cast<const OneHotOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_LogicalAndOptions: {
auto ptr = reinterpret_cast<const LogicalAndOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_LogicalNotOptions: {
auto ptr = reinterpret_cast<const LogicalNotOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_UnpackOptions: {
auto ptr = reinterpret_cast<const UnpackOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_FloorDivOptions: {
auto ptr = reinterpret_cast<const FloorDivOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_SquareOptions: {
auto ptr = reinterpret_cast<const SquareOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_ZerosLikeOptions: {
auto ptr = reinterpret_cast<const ZerosLikeOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_FillOptions: {
auto ptr = reinterpret_cast<const FillOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_BidirectionalSequenceLSTMOptions: {
auto ptr = reinterpret_cast<const BidirectionalSequenceLSTMOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_BidirectionalSequenceRNNOptions: {
auto ptr = reinterpret_cast<const BidirectionalSequenceRNNOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_UnidirectionalSequenceLSTMOptions: {
auto ptr = reinterpret_cast<const UnidirectionalSequenceLSTMOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_FloorModOptions: {
auto ptr = reinterpret_cast<const FloorModOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_RangeOptions: {
auto ptr = reinterpret_cast<const RangeOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_ResizeNearestNeighborOptions: {
auto ptr = reinterpret_cast<const ResizeNearestNeighborOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_LeakyReluOptions: {
auto ptr = reinterpret_cast<const LeakyReluOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_SquaredDifferenceOptions: {
auto ptr = reinterpret_cast<const SquaredDifferenceOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_MirrorPadOptions: {
auto ptr = reinterpret_cast<const MirrorPadOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_AbsOptions: {
auto ptr = reinterpret_cast<const AbsOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_SplitVOptions: {
auto ptr = reinterpret_cast<const SplitVOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_UniqueOptions: {
auto ptr = reinterpret_cast<const UniqueOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_ReverseV2Options: {
auto ptr = reinterpret_cast<const ReverseV2Options *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_AddNOptions: {
auto ptr = reinterpret_cast<const AddNOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_GatherNdOptions: {
auto ptr = reinterpret_cast<const GatherNdOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_CosOptions: {
auto ptr = reinterpret_cast<const CosOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_WhereOptions: {
auto ptr = reinterpret_cast<const WhereOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_RankOptions: {
auto ptr = reinterpret_cast<const RankOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_ReverseSequenceOptions: {
auto ptr = reinterpret_cast<const ReverseSequenceOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_MatrixDiagOptions: {
auto ptr = reinterpret_cast<const MatrixDiagOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_QuantizeOptions: {
auto ptr = reinterpret_cast<const QuantizeOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_MatrixSetDiagOptions: {
auto ptr = reinterpret_cast<const MatrixSetDiagOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_HardSwishOptions: {
auto ptr = reinterpret_cast<const HardSwishOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_IfOptions: {
auto ptr = reinterpret_cast<const IfOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_WhileOptions: {
auto ptr = reinterpret_cast<const WhileOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_DepthToSpaceOptions: {
auto ptr = reinterpret_cast<const DepthToSpaceOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_NonMaxSuppressionV4Options: {
auto ptr = reinterpret_cast<const NonMaxSuppressionV4Options *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_NonMaxSuppressionV5Options: {
auto ptr = reinterpret_cast<const NonMaxSuppressionV5Options *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_ScatterNdOptions: {
auto ptr = reinterpret_cast<const ScatterNdOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_SelectV2Options: {
auto ptr = reinterpret_cast<const SelectV2Options *>(obj);
return verifier.VerifyTable(ptr);
}
default: return true;
}
}
inline bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
if (!values || !types) return !values && !types;
if (values->size() != types->size()) return false;
for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
if (!VerifyBuiltinOptions(
verifier, values->Get(i), types->GetEnum<BuiltinOptions>(i))) {
return false;
}
}
return true;
}
inline void *BuiltinOptionsUnion::UnPack(const void *obj, BuiltinOptions type, const flatbuffers::resolver_function_t *resolver) {
switch (type) {
case BuiltinOptions_Conv2DOptions: {
auto ptr = reinterpret_cast<const Conv2DOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_DepthwiseConv2DOptions: {
auto ptr = reinterpret_cast<const DepthwiseConv2DOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_ConcatEmbeddingsOptions: {
auto ptr = reinterpret_cast<const ConcatEmbeddingsOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_LSHProjectionOptions: {
auto ptr = reinterpret_cast<const LSHProjectionOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_Pool2DOptions: {
auto ptr = reinterpret_cast<const Pool2DOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_SVDFOptions: {
auto ptr = reinterpret_cast<const SVDFOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_RNNOptions: {
auto ptr = reinterpret_cast<const RNNOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_FullyConnectedOptions: {
auto ptr = reinterpret_cast<const FullyConnectedOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_SoftmaxOptions: {
auto ptr = reinterpret_cast<const SoftmaxOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_ConcatenationOptions: {
auto ptr = reinterpret_cast<const ConcatenationOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_AddOptions: {
auto ptr = reinterpret_cast<const AddOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_L2NormOptions: {
auto ptr = reinterpret_cast<const L2NormOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_LocalResponseNormalizationOptions: {
auto ptr = reinterpret_cast<const LocalResponseNormalizationOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_LSTMOptions: {
auto ptr = reinterpret_cast<const LSTMOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_ResizeBilinearOptions: {
auto ptr = reinterpret_cast<const ResizeBilinearOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_CallOptions: {
auto ptr = reinterpret_cast<const CallOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_ReshapeOptions: {
auto ptr = reinterpret_cast<const ReshapeOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_SkipGramOptions: {
auto ptr = reinterpret_cast<const SkipGramOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_SpaceToDepthOptions: {
auto ptr = reinterpret_cast<const SpaceToDepthOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_EmbeddingLookupSparseOptions: {
auto ptr = reinterpret_cast<const EmbeddingLookupSparseOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_MulOptions: {
auto ptr = reinterpret_cast<const MulOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_PadOptions: {
auto ptr = reinterpret_cast<const PadOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_GatherOptions: {
auto ptr = reinterpret_cast<const GatherOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_BatchToSpaceNDOptions: {
auto ptr = reinterpret_cast<const BatchToSpaceNDOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_SpaceToBatchNDOptions: {
auto ptr = reinterpret_cast<const SpaceToBatchNDOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_TransposeOptions: {
auto ptr = reinterpret_cast<const TransposeOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_ReducerOptions: {
auto ptr = reinterpret_cast<const ReducerOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_SubOptions: {
auto ptr = reinterpret_cast<const SubOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_DivOptions: {
auto ptr = reinterpret_cast<const DivOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_SqueezeOptions: {
auto ptr = reinterpret_cast<const SqueezeOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_SequenceRNNOptions: {
auto ptr = reinterpret_cast<const SequenceRNNOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_StridedSliceOptions: {
auto ptr = reinterpret_cast<const StridedSliceOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_ExpOptions: {
auto ptr = reinterpret_cast<const ExpOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_TopKV2Options: {
auto ptr = reinterpret_cast<const TopKV2Options *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_SplitOptions: {
auto ptr = reinterpret_cast<const SplitOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_LogSoftmaxOptions: {
auto ptr = reinterpret_cast<const LogSoftmaxOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_CastOptions: {
auto ptr = reinterpret_cast<const CastOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_DequantizeOptions: {
auto ptr = reinterpret_cast<const DequantizeOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_MaximumMinimumOptions: {
auto ptr = reinterpret_cast<const MaximumMinimumOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_ArgMaxOptions: {
auto ptr = reinterpret_cast<const ArgMaxOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_LessOptions: {
auto ptr = reinterpret_cast<const LessOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_NegOptions: {
auto ptr = reinterpret_cast<const NegOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_PadV2Options: {
auto ptr = reinterpret_cast<const PadV2Options *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_GreaterOptions: {
auto ptr = reinterpret_cast<const GreaterOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_GreaterEqualOptions: {
auto ptr = reinterpret_cast<const GreaterEqualOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_LessEqualOptions: {
auto ptr = reinterpret_cast<const LessEqualOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_SelectOptions: {
auto ptr = reinterpret_cast<const SelectOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_SliceOptions: {
auto ptr = reinterpret_cast<const SliceOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_TransposeConvOptions: {
auto ptr = reinterpret_cast<const TransposeConvOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_SparseToDenseOptions: {
auto ptr = reinterpret_cast<const SparseToDenseOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_TileOptions: {
auto ptr = reinterpret_cast<const TileOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_ExpandDimsOptions: {
auto ptr = reinterpret_cast<const ExpandDimsOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_EqualOptions: {
auto ptr = reinterpret_cast<const EqualOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_NotEqualOptions: {
auto ptr = reinterpret_cast<const NotEqualOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_ShapeOptions: {
auto ptr = reinterpret_cast<const ShapeOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_PowOptions: {
auto ptr = reinterpret_cast<const PowOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_ArgMinOptions: {
auto ptr = reinterpret_cast<const ArgMinOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_FakeQuantOptions: {
auto ptr = reinterpret_cast<const FakeQuantOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_PackOptions: {
auto ptr = reinterpret_cast<const PackOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_LogicalOrOptions: {
auto ptr = reinterpret_cast<const LogicalOrOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_OneHotOptions: {
auto ptr = reinterpret_cast<const OneHotOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_LogicalAndOptions: {
auto ptr = reinterpret_cast<const LogicalAndOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_LogicalNotOptions: {
auto ptr = reinterpret_cast<const LogicalNotOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_UnpackOptions: {
auto ptr = reinterpret_cast<const UnpackOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_FloorDivOptions: {
auto ptr = reinterpret_cast<const FloorDivOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_SquareOptions: {
auto ptr = reinterpret_cast<const SquareOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_ZerosLikeOptions: {
auto ptr = reinterpret_cast<const ZerosLikeOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_FillOptions: {
auto ptr = reinterpret_cast<const FillOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_BidirectionalSequenceLSTMOptions: {
auto ptr = reinterpret_cast<const BidirectionalSequenceLSTMOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_BidirectionalSequenceRNNOptions: {
auto ptr = reinterpret_cast<const BidirectionalSequenceRNNOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_UnidirectionalSequenceLSTMOptions: {
auto ptr = reinterpret_cast<const UnidirectionalSequenceLSTMOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_FloorModOptions: {
auto ptr = reinterpret_cast<const FloorModOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_RangeOptions: {
auto ptr = reinterpret_cast<const RangeOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_ResizeNearestNeighborOptions: {
auto ptr = reinterpret_cast<const ResizeNearestNeighborOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_LeakyReluOptions: {
auto ptr = reinterpret_cast<const LeakyReluOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_SquaredDifferenceOptions: {
auto ptr = reinterpret_cast<const SquaredDifferenceOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_MirrorPadOptions: {
auto ptr = reinterpret_cast<const MirrorPadOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_AbsOptions: {
auto ptr = reinterpret_cast<const AbsOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_SplitVOptions: {
auto ptr = reinterpret_cast<const SplitVOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_UniqueOptions: {
auto ptr = reinterpret_cast<const UniqueOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_ReverseV2Options: {
auto ptr = reinterpret_cast<const ReverseV2Options *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_AddNOptions: {
auto ptr = reinterpret_cast<const AddNOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_GatherNdOptions: {
auto ptr = reinterpret_cast<const GatherNdOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_CosOptions: {
auto ptr = reinterpret_cast<const CosOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_WhereOptions: {
auto ptr = reinterpret_cast<const WhereOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_RankOptions: {
auto ptr = reinterpret_cast<const RankOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_ReverseSequenceOptions: {
auto ptr = reinterpret_cast<const ReverseSequenceOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_MatrixDiagOptions: {
auto ptr = reinterpret_cast<const MatrixDiagOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_QuantizeOptions: {
auto ptr = reinterpret_cast<const QuantizeOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_MatrixSetDiagOptions: {
auto ptr = reinterpret_cast<const MatrixSetDiagOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_HardSwishOptions: {
auto ptr = reinterpret_cast<const HardSwishOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_IfOptions: {
auto ptr = reinterpret_cast<const IfOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_WhileOptions: {
auto ptr = reinterpret_cast<const WhileOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_DepthToSpaceOptions: {
auto ptr = reinterpret_cast<const DepthToSpaceOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_NonMaxSuppressionV4Options: {
auto ptr = reinterpret_cast<const NonMaxSuppressionV4Options *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_NonMaxSuppressionV5Options: {
auto ptr = reinterpret_cast<const NonMaxSuppressionV5Options *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_ScatterNdOptions: {
auto ptr = reinterpret_cast<const ScatterNdOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_SelectV2Options: {
auto ptr = reinterpret_cast<const SelectV2Options *>(obj);
return ptr->UnPack(resolver);
}
default: return nullptr;
}
}
inline flatbuffers::Offset<void> BuiltinOptionsUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
switch (type) {
case BuiltinOptions_Conv2DOptions: {
auto ptr = reinterpret_cast<const Conv2DOptionsT *>(value);
return CreateConv2DOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_DepthwiseConv2DOptions: {
auto ptr = reinterpret_cast<const DepthwiseConv2DOptionsT *>(value);
return CreateDepthwiseConv2DOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_ConcatEmbeddingsOptions: {
auto ptr = reinterpret_cast<const ConcatEmbeddingsOptionsT *>(value);
return CreateConcatEmbeddingsOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_LSHProjectionOptions: {
auto ptr = reinterpret_cast<const LSHProjectionOptionsT *>(value);
return CreateLSHProjectionOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_Pool2DOptions: {
auto ptr = reinterpret_cast<const Pool2DOptionsT *>(value);
return CreatePool2DOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_SVDFOptions: {
auto ptr = reinterpret_cast<const SVDFOptionsT *>(value);
return CreateSVDFOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_RNNOptions: {
auto ptr = reinterpret_cast<const RNNOptionsT *>(value);
return CreateRNNOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_FullyConnectedOptions: {
auto ptr = reinterpret_cast<const FullyConnectedOptionsT *>(value);
return CreateFullyConnectedOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_SoftmaxOptions: {
auto ptr = reinterpret_cast<const SoftmaxOptionsT *>(value);
return CreateSoftmaxOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_ConcatenationOptions: {
auto ptr = reinterpret_cast<const ConcatenationOptionsT *>(value);
return CreateConcatenationOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_AddOptions: {
auto ptr = reinterpret_cast<const AddOptionsT *>(value);
return CreateAddOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_L2NormOptions: {
auto ptr = reinterpret_cast<const L2NormOptionsT *>(value);
return CreateL2NormOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_LocalResponseNormalizationOptions: {
auto ptr = reinterpret_cast<const LocalResponseNormalizationOptionsT *>(value);
return CreateLocalResponseNormalizationOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_LSTMOptions: {
auto ptr = reinterpret_cast<const LSTMOptionsT *>(value);
return CreateLSTMOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_ResizeBilinearOptions: {
auto ptr = reinterpret_cast<const ResizeBilinearOptionsT *>(value);
return CreateResizeBilinearOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_CallOptions: {
auto ptr = reinterpret_cast<const CallOptionsT *>(value);
return CreateCallOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_ReshapeOptions: {
auto ptr = reinterpret_cast<const ReshapeOptionsT *>(value);
return CreateReshapeOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_SkipGramOptions: {
auto ptr = reinterpret_cast<const SkipGramOptionsT *>(value);
return CreateSkipGramOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_SpaceToDepthOptions: {
auto ptr = reinterpret_cast<const SpaceToDepthOptionsT *>(value);
return CreateSpaceToDepthOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_EmbeddingLookupSparseOptions: {
auto ptr = reinterpret_cast<const EmbeddingLookupSparseOptionsT *>(value);
return CreateEmbeddingLookupSparseOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_MulOptions: {
auto ptr = reinterpret_cast<const MulOptionsT *>(value);
return CreateMulOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_PadOptions: {
auto ptr = reinterpret_cast<const PadOptionsT *>(value);
return CreatePadOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_GatherOptions: {
auto ptr = reinterpret_cast<const GatherOptionsT *>(value);
return CreateGatherOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_BatchToSpaceNDOptions: {
auto ptr = reinterpret_cast<const BatchToSpaceNDOptionsT *>(value);
return CreateBatchToSpaceNDOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_SpaceToBatchNDOptions: {
auto ptr = reinterpret_cast<const SpaceToBatchNDOptionsT *>(value);
return CreateSpaceToBatchNDOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_TransposeOptions: {
auto ptr = reinterpret_cast<const TransposeOptionsT *>(value);
return CreateTransposeOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_ReducerOptions: {
auto ptr = reinterpret_cast<const ReducerOptionsT *>(value);
return CreateReducerOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_SubOptions: {
auto ptr = reinterpret_cast<const SubOptionsT *>(value);
return CreateSubOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_DivOptions: {
auto ptr = reinterpret_cast<const DivOptionsT *>(value);
return CreateDivOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_SqueezeOptions: {
auto ptr = reinterpret_cast<const SqueezeOptionsT *>(value);
return CreateSqueezeOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_SequenceRNNOptions: {
auto ptr = reinterpret_cast<const SequenceRNNOptionsT *>(value);
return CreateSequenceRNNOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_StridedSliceOptions: {
auto ptr = reinterpret_cast<const StridedSliceOptionsT *>(value);
return CreateStridedSliceOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_ExpOptions: {
auto ptr = reinterpret_cast<const ExpOptionsT *>(value);
return CreateExpOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_TopKV2Options: {
auto ptr = reinterpret_cast<const TopKV2OptionsT *>(value);
return CreateTopKV2Options(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_SplitOptions: {
auto ptr = reinterpret_cast<const SplitOptionsT *>(value);
return CreateSplitOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_LogSoftmaxOptions: {
auto ptr = reinterpret_cast<const LogSoftmaxOptionsT *>(value);
return CreateLogSoftmaxOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_CastOptions: {
auto ptr = reinterpret_cast<const CastOptionsT *>(value);
return CreateCastOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_DequantizeOptions: {
auto ptr = reinterpret_cast<const DequantizeOptionsT *>(value);
return CreateDequantizeOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_MaximumMinimumOptions: {
auto ptr = reinterpret_cast<const MaximumMinimumOptionsT *>(value);
return CreateMaximumMinimumOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_ArgMaxOptions: {
auto ptr = reinterpret_cast<const ArgMaxOptionsT *>(value);
return CreateArgMaxOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_LessOptions: {
auto ptr = reinterpret_cast<const LessOptionsT *>(value);
return CreateLessOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_NegOptions: {
auto ptr = reinterpret_cast<const NegOptionsT *>(value);
return CreateNegOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_PadV2Options: {
auto ptr = reinterpret_cast<const PadV2OptionsT *>(value);
return CreatePadV2Options(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_GreaterOptions: {
auto ptr = reinterpret_cast<const GreaterOptionsT *>(value);
return CreateGreaterOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_GreaterEqualOptions: {
auto ptr = reinterpret_cast<const GreaterEqualOptionsT *>(value);
return CreateGreaterEqualOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_LessEqualOptions: {
auto ptr = reinterpret_cast<const LessEqualOptionsT *>(value);
return CreateLessEqualOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_SelectOptions: {
auto ptr = reinterpret_cast<const SelectOptionsT *>(value);
return CreateSelectOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_SliceOptions: {
auto ptr = reinterpret_cast<const SliceOptionsT *>(value);
return CreateSliceOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_TransposeConvOptions: {
auto ptr = reinterpret_cast<const TransposeConvOptionsT *>(value);
return CreateTransposeConvOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_SparseToDenseOptions: {
auto ptr = reinterpret_cast<const SparseToDenseOptionsT *>(value);
return CreateSparseToDenseOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_TileOptions: {
auto ptr = reinterpret_cast<const TileOptionsT *>(value);
return CreateTileOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_ExpandDimsOptions: {
auto ptr = reinterpret_cast<const ExpandDimsOptionsT *>(value);
return CreateExpandDimsOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_EqualOptions: {
auto ptr = reinterpret_cast<const EqualOptionsT *>(value);
return CreateEqualOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_NotEqualOptions: {
auto ptr = reinterpret_cast<const NotEqualOptionsT *>(value);
return CreateNotEqualOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_ShapeOptions: {
auto ptr = reinterpret_cast<const ShapeOptionsT *>(value);
return CreateShapeOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_PowOptions: {
auto ptr = reinterpret_cast<const PowOptionsT *>(value);
return CreatePowOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_ArgMinOptions: {
auto ptr = reinterpret_cast<const ArgMinOptionsT *>(value);
return CreateArgMinOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_FakeQuantOptions: {
auto ptr = reinterpret_cast<const FakeQuantOptionsT *>(value);
return CreateFakeQuantOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_PackOptions: {
auto ptr = reinterpret_cast<const PackOptionsT *>(value);
return CreatePackOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_LogicalOrOptions: {
auto ptr = reinterpret_cast<const LogicalOrOptionsT *>(value);
return CreateLogicalOrOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_OneHotOptions: {
auto ptr = reinterpret_cast<const OneHotOptionsT *>(value);
return CreateOneHotOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_LogicalAndOptions: {
auto ptr = reinterpret_cast<const LogicalAndOptionsT *>(value);
return CreateLogicalAndOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_LogicalNotOptions: {
auto ptr = reinterpret_cast<const LogicalNotOptionsT *>(value);
return CreateLogicalNotOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_UnpackOptions: {
auto ptr = reinterpret_cast<const UnpackOptionsT *>(value);
return CreateUnpackOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_FloorDivOptions: {
auto ptr = reinterpret_cast<const FloorDivOptionsT *>(value);
return CreateFloorDivOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_SquareOptions: {
auto ptr = reinterpret_cast<const SquareOptionsT *>(value);
return CreateSquareOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_ZerosLikeOptions: {
auto ptr = reinterpret_cast<const ZerosLikeOptionsT *>(value);
return CreateZerosLikeOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_FillOptions: {
auto ptr = reinterpret_cast<const FillOptionsT *>(value);
return CreateFillOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_BidirectionalSequenceLSTMOptions: {
auto ptr = reinterpret_cast<const BidirectionalSequenceLSTMOptionsT *>(value);
return CreateBidirectionalSequenceLSTMOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_BidirectionalSequenceRNNOptions: {
auto ptr = reinterpret_cast<const BidirectionalSequenceRNNOptionsT *>(value);
return CreateBidirectionalSequenceRNNOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_UnidirectionalSequenceLSTMOptions: {
auto ptr = reinterpret_cast<const UnidirectionalSequenceLSTMOptionsT *>(value);
return CreateUnidirectionalSequenceLSTMOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_FloorModOptions: {
auto ptr = reinterpret_cast<const FloorModOptionsT *>(value);
return CreateFloorModOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_RangeOptions: {
auto ptr = reinterpret_cast<const RangeOptionsT *>(value);
return CreateRangeOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_ResizeNearestNeighborOptions: {
auto ptr = reinterpret_cast<const ResizeNearestNeighborOptionsT *>(value);
return CreateResizeNearestNeighborOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_LeakyReluOptions: {
auto ptr = reinterpret_cast<const LeakyReluOptionsT *>(value);
return CreateLeakyReluOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_SquaredDifferenceOptions: {
auto ptr = reinterpret_cast<const SquaredDifferenceOptionsT *>(value);
return CreateSquaredDifferenceOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_MirrorPadOptions: {
auto ptr = reinterpret_cast<const MirrorPadOptionsT *>(value);
return CreateMirrorPadOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_AbsOptions: {
auto ptr = reinterpret_cast<const AbsOptionsT *>(value);
return CreateAbsOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_SplitVOptions: {
auto ptr = reinterpret_cast<const SplitVOptionsT *>(value);
return CreateSplitVOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_UniqueOptions: {
auto ptr = reinterpret_cast<const UniqueOptionsT *>(value);
return CreateUniqueOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_ReverseV2Options: {
auto ptr = reinterpret_cast<const ReverseV2OptionsT *>(value);
return CreateReverseV2Options(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_AddNOptions: {
auto ptr = reinterpret_cast<const AddNOptionsT *>(value);
return CreateAddNOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_GatherNdOptions: {
auto ptr = reinterpret_cast<const GatherNdOptionsT *>(value);
return CreateGatherNdOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_CosOptions: {
auto ptr = reinterpret_cast<const CosOptionsT *>(value);
return CreateCosOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_WhereOptions: {
auto ptr = reinterpret_cast<const WhereOptionsT *>(value);
return CreateWhereOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_RankOptions: {
auto ptr = reinterpret_cast<const RankOptionsT *>(value);
return CreateRankOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_ReverseSequenceOptions: {
auto ptr = reinterpret_cast<const ReverseSequenceOptionsT *>(value);
return CreateReverseSequenceOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_MatrixDiagOptions: {
auto ptr = reinterpret_cast<const MatrixDiagOptionsT *>(value);
return CreateMatrixDiagOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_QuantizeOptions: {
auto ptr = reinterpret_cast<const QuantizeOptionsT *>(value);
return CreateQuantizeOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_MatrixSetDiagOptions: {
auto ptr = reinterpret_cast<const MatrixSetDiagOptionsT *>(value);
return CreateMatrixSetDiagOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_HardSwishOptions: {
auto ptr = reinterpret_cast<const HardSwishOptionsT *>(value);
return CreateHardSwishOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_IfOptions: {
auto ptr = reinterpret_cast<const IfOptionsT *>(value);
return CreateIfOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_WhileOptions: {
auto ptr = reinterpret_cast<const WhileOptionsT *>(value);
return CreateWhileOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_DepthToSpaceOptions: {
auto ptr = reinterpret_cast<const DepthToSpaceOptionsT *>(value);
return CreateDepthToSpaceOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_NonMaxSuppressionV4Options: {
auto ptr = reinterpret_cast<const NonMaxSuppressionV4OptionsT *>(value);
return CreateNonMaxSuppressionV4Options(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_NonMaxSuppressionV5Options: {
auto ptr = reinterpret_cast<const NonMaxSuppressionV5OptionsT *>(value);
return CreateNonMaxSuppressionV5Options(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_ScatterNdOptions: {
auto ptr = reinterpret_cast<const ScatterNdOptionsT *>(value);
return CreateScatterNdOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_SelectV2Options: {
auto ptr = reinterpret_cast<const SelectV2OptionsT *>(value);
return CreateSelectV2Options(_fbb, ptr, _rehasher).Union();
}
default: return 0;
}
}
inline BuiltinOptionsUnion::BuiltinOptionsUnion(const BuiltinOptionsUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) {
switch (type) {
case BuiltinOptions_Conv2DOptions: {
value = new Conv2DOptionsT(*reinterpret_cast<Conv2DOptionsT *>(u.value));
break;
}
case BuiltinOptions_DepthwiseConv2DOptions: {
value = new DepthwiseConv2DOptionsT(*reinterpret_cast<DepthwiseConv2DOptionsT *>(u.value));
break;
}
case BuiltinOptions_ConcatEmbeddingsOptions: {
value = new ConcatEmbeddingsOptionsT(*reinterpret_cast<ConcatEmbeddingsOptionsT *>(u.value));
break;
}
case BuiltinOptions_LSHProjectionOptions: {
value = new LSHProjectionOptionsT(*reinterpret_cast<LSHProjectionOptionsT *>(u.value));
break;
}
case BuiltinOptions_Pool2DOptions: {
value = new Pool2DOptionsT(*reinterpret_cast<Pool2DOptionsT *>(u.value));
break;
}
case BuiltinOptions_SVDFOptions: {
value = new SVDFOptionsT(*reinterpret_cast<SVDFOptionsT *>(u.value));
break;
}
case BuiltinOptions_RNNOptions: {
value = new RNNOptionsT(*reinterpret_cast<RNNOptionsT *>(u.value));
break;
}
case BuiltinOptions_FullyConnectedOptions: {
value = new FullyConnectedOptionsT(*reinterpret_cast<FullyConnectedOptionsT *>(u.value));
break;
}
case BuiltinOptions_SoftmaxOptions: {
value = new SoftmaxOptionsT(*reinterpret_cast<SoftmaxOptionsT *>(u.value));
break;
}
case BuiltinOptions_ConcatenationOptions: {
value = new ConcatenationOptionsT(*reinterpret_cast<ConcatenationOptionsT *>(u.value));
break;
}
case BuiltinOptions_AddOptions: {
value = new AddOptionsT(*reinterpret_cast<AddOptionsT *>(u.value));
break;
}
case BuiltinOptions_L2NormOptions: {
value = new L2NormOptionsT(*reinterpret_cast<L2NormOptionsT *>(u.value));
break;
}
case BuiltinOptions_LocalResponseNormalizationOptions: {
value = new LocalResponseNormalizationOptionsT(*reinterpret_cast<LocalResponseNormalizationOptionsT *>(u.value));
break;
}
case BuiltinOptions_LSTMOptions: {
value = new LSTMOptionsT(*reinterpret_cast<LSTMOptionsT *>(u.value));
break;
}
case BuiltinOptions_ResizeBilinearOptions: {
value = new ResizeBilinearOptionsT(*reinterpret_cast<ResizeBilinearOptionsT *>(u.value));
break;
}
case BuiltinOptions_CallOptions: {
value = new CallOptionsT(*reinterpret_cast<CallOptionsT *>(u.value));
break;
}
case BuiltinOptions_ReshapeOptions: {
value = new ReshapeOptionsT(*reinterpret_cast<ReshapeOptionsT *>(u.value));
break;
}
case BuiltinOptions_SkipGramOptions: {
value = new SkipGramOptionsT(*reinterpret_cast<SkipGramOptionsT *>(u.value));
break;
}
case BuiltinOptions_SpaceToDepthOptions: {
value = new SpaceToDepthOptionsT(*reinterpret_cast<SpaceToDepthOptionsT *>(u.value));
break;
}
case BuiltinOptions_EmbeddingLookupSparseOptions: {
value = new EmbeddingLookupSparseOptionsT(*reinterpret_cast<EmbeddingLookupSparseOptionsT *>(u.value));
break;
}
case BuiltinOptions_MulOptions: {
value = new MulOptionsT(*reinterpret_cast<MulOptionsT *>(u.value));
break;
}
case BuiltinOptions_PadOptions: {
value = new PadOptionsT(*reinterpret_cast<PadOptionsT *>(u.value));
break;
}
case BuiltinOptions_GatherOptions: {
value = new GatherOptionsT(*reinterpret_cast<GatherOptionsT *>(u.value));
break;
}
case BuiltinOptions_BatchToSpaceNDOptions: {
value = new BatchToSpaceNDOptionsT(*reinterpret_cast<BatchToSpaceNDOptionsT *>(u.value));
break;
}
case BuiltinOptions_SpaceToBatchNDOptions: {
value = new SpaceToBatchNDOptionsT(*reinterpret_cast<SpaceToBatchNDOptionsT *>(u.value));
break;
}
case BuiltinOptions_TransposeOptions: {
value = new TransposeOptionsT(*reinterpret_cast<TransposeOptionsT *>(u.value));
break;
}
case BuiltinOptions_ReducerOptions: {
value = new ReducerOptionsT(*reinterpret_cast<ReducerOptionsT *>(u.value));
break;
}
case BuiltinOptions_SubOptions: {
value = new SubOptionsT(*reinterpret_cast<SubOptionsT *>(u.value));
break;
}
case BuiltinOptions_DivOptions: {
value = new DivOptionsT(*reinterpret_cast<DivOptionsT *>(u.value));
break;
}
case BuiltinOptions_SqueezeOptions: {
value = new SqueezeOptionsT(*reinterpret_cast<SqueezeOptionsT *>(u.value));
break;
}
case BuiltinOptions_SequenceRNNOptions: {
value = new SequenceRNNOptionsT(*reinterpret_cast<SequenceRNNOptionsT *>(u.value));
break;
}
case BuiltinOptions_StridedSliceOptions: {
value = new StridedSliceOptionsT(*reinterpret_cast<StridedSliceOptionsT *>(u.value));
break;
}
case BuiltinOptions_ExpOptions: {
value = new ExpOptionsT(*reinterpret_cast<ExpOptionsT *>(u.value));
break;
}
case BuiltinOptions_TopKV2Options: {
value = new TopKV2OptionsT(*reinterpret_cast<TopKV2OptionsT *>(u.value));
break;
}
case BuiltinOptions_SplitOptions: {
value = new SplitOptionsT(*reinterpret_cast<SplitOptionsT *>(u.value));
break;
}
case BuiltinOptions_LogSoftmaxOptions: {
value = new LogSoftmaxOptionsT(*reinterpret_cast<LogSoftmaxOptionsT *>(u.value));
break;
}
case BuiltinOptions_CastOptions: {
value = new CastOptionsT(*reinterpret_cast<CastOptionsT *>(u.value));
break;
}
case BuiltinOptions_DequantizeOptions: {
value = new DequantizeOptionsT(*reinterpret_cast<DequantizeOptionsT *>(u.value));
break;
}
case BuiltinOptions_MaximumMinimumOptions: {
value = new MaximumMinimumOptionsT(*reinterpret_cast<MaximumMinimumOptionsT *>(u.value));
break;
}
case BuiltinOptions_ArgMaxOptions: {
value = new ArgMaxOptionsT(*reinterpret_cast<ArgMaxOptionsT *>(u.value));
break;
}
case BuiltinOptions_LessOptions: {
value = new LessOptionsT(*reinterpret_cast<LessOptionsT *>(u.value));
break;
}
case BuiltinOptions_NegOptions: {
value = new NegOptionsT(*reinterpret_cast<NegOptionsT *>(u.value));
break;
}
case BuiltinOptions_PadV2Options: {
value = new PadV2OptionsT(*reinterpret_cast<PadV2OptionsT *>(u.value));
break;
}
case BuiltinOptions_GreaterOptions: {
value = new GreaterOptionsT(*reinterpret_cast<GreaterOptionsT *>(u.value));
break;
}
case BuiltinOptions_GreaterEqualOptions: {
value = new GreaterEqualOptionsT(*reinterpret_cast<GreaterEqualOptionsT *>(u.value));
break;
}
case BuiltinOptions_LessEqualOptions: {
value = new LessEqualOptionsT(*reinterpret_cast<LessEqualOptionsT *>(u.value));
break;
}
case BuiltinOptions_SelectOptions: {
value = new SelectOptionsT(*reinterpret_cast<SelectOptionsT *>(u.value));
break;
}
case BuiltinOptions_SliceOptions: {
value = new SliceOptionsT(*reinterpret_cast<SliceOptionsT *>(u.value));
break;
}
case BuiltinOptions_TransposeConvOptions: {
value = new TransposeConvOptionsT(*reinterpret_cast<TransposeConvOptionsT *>(u.value));
break;
}
case BuiltinOptions_SparseToDenseOptions: {
value = new SparseToDenseOptionsT(*reinterpret_cast<SparseToDenseOptionsT *>(u.value));
break;
}
case BuiltinOptions_TileOptions: {
value = new TileOptionsT(*reinterpret_cast<TileOptionsT *>(u.value));
break;
}
case BuiltinOptions_ExpandDimsOptions: {
value = new ExpandDimsOptionsT(*reinterpret_cast<ExpandDimsOptionsT *>(u.value));
break;
}
case BuiltinOptions_EqualOptions: {
value = new EqualOptionsT(*reinterpret_cast<EqualOptionsT *>(u.value));
break;
}
case BuiltinOptions_NotEqualOptions: {
value = new NotEqualOptionsT(*reinterpret_cast<NotEqualOptionsT *>(u.value));
break;
}
case BuiltinOptions_ShapeOptions: {
value = new ShapeOptionsT(*reinterpret_cast<ShapeOptionsT *>(u.value));
break;
}
case BuiltinOptions_PowOptions: {
value = new PowOptionsT(*reinterpret_cast<PowOptionsT *>(u.value));
break;
}
case BuiltinOptions_ArgMinOptions: {
value = new ArgMinOptionsT(*reinterpret_cast<ArgMinOptionsT *>(u.value));
break;
}
case BuiltinOptions_FakeQuantOptions: {
value = new FakeQuantOptionsT(*reinterpret_cast<FakeQuantOptionsT *>(u.value));
break;
}
case BuiltinOptions_PackOptions: {
value = new PackOptionsT(*reinterpret_cast<PackOptionsT *>(u.value));
break;
}
case BuiltinOptions_LogicalOrOptions: {
value = new LogicalOrOptionsT(*reinterpret_cast<LogicalOrOptionsT *>(u.value));
break;
}
case BuiltinOptions_OneHotOptions: {
value = new OneHotOptionsT(*reinterpret_cast<OneHotOptionsT *>(u.value));
break;
}
case BuiltinOptions_LogicalAndOptions: {
value = new LogicalAndOptionsT(*reinterpret_cast<LogicalAndOptionsT *>(u.value));
break;
}
case BuiltinOptions_LogicalNotOptions: {
value = new LogicalNotOptionsT(*reinterpret_cast<LogicalNotOptionsT *>(u.value));
break;
}
case BuiltinOptions_UnpackOptions: {
value = new UnpackOptionsT(*reinterpret_cast<UnpackOptionsT *>(u.value));
break;
}
case BuiltinOptions_FloorDivOptions: {
value = new FloorDivOptionsT(*reinterpret_cast<FloorDivOptionsT *>(u.value));
break;
}
case BuiltinOptions_SquareOptions: {
value = new SquareOptionsT(*reinterpret_cast<SquareOptionsT *>(u.value));
break;
}
case BuiltinOptions_ZerosLikeOptions: {
value = new ZerosLikeOptionsT(*reinterpret_cast<ZerosLikeOptionsT *>(u.value));
break;
}
case BuiltinOptions_FillOptions: {
value = new FillOptionsT(*reinterpret_cast<FillOptionsT *>(u.value));
break;
}
case BuiltinOptions_BidirectionalSequenceLSTMOptions: {
value = new BidirectionalSequenceLSTMOptionsT(*reinterpret_cast<BidirectionalSequenceLSTMOptionsT *>(u.value));
break;
}
case BuiltinOptions_BidirectionalSequenceRNNOptions: {
value = new BidirectionalSequenceRNNOptionsT(*reinterpret_cast<BidirectionalSequenceRNNOptionsT *>(u.value));
break;
}
case BuiltinOptions_UnidirectionalSequenceLSTMOptions: {
value = new UnidirectionalSequenceLSTMOptionsT(*reinterpret_cast<UnidirectionalSequenceLSTMOptionsT *>(u.value));
break;
}
case BuiltinOptions_FloorModOptions: {
value = new FloorModOptionsT(*reinterpret_cast<FloorModOptionsT *>(u.value));
break;
}
case BuiltinOptions_RangeOptions: {
value = new RangeOptionsT(*reinterpret_cast<RangeOptionsT *>(u.value));
break;
}
case BuiltinOptions_ResizeNearestNeighborOptions: {
value = new ResizeNearestNeighborOptionsT(*reinterpret_cast<ResizeNearestNeighborOptionsT *>(u.value));
break;
}
case BuiltinOptions_LeakyReluOptions: {
value = new LeakyReluOptionsT(*reinterpret_cast<LeakyReluOptionsT *>(u.value));
break;
}
case BuiltinOptions_SquaredDifferenceOptions: {
value = new SquaredDifferenceOptionsT(*reinterpret_cast<SquaredDifferenceOptionsT *>(u.value));
break;
}
case BuiltinOptions_MirrorPadOptions: {
value = new MirrorPadOptionsT(*reinterpret_cast<MirrorPadOptionsT *>(u.value));
break;
}
case BuiltinOptions_AbsOptions: {
value = new AbsOptionsT(*reinterpret_cast<AbsOptionsT *>(u.value));
break;
}
case BuiltinOptions_SplitVOptions: {
value = new SplitVOptionsT(*reinterpret_cast<SplitVOptionsT *>(u.value));
break;
}
case BuiltinOptions_UniqueOptions: {
value = new UniqueOptionsT(*reinterpret_cast<UniqueOptionsT *>(u.value));
break;
}
case BuiltinOptions_ReverseV2Options: {
value = new ReverseV2OptionsT(*reinterpret_cast<ReverseV2OptionsT *>(u.value));
break;
}
case BuiltinOptions_AddNOptions: {
value = new AddNOptionsT(*reinterpret_cast<AddNOptionsT *>(u.value));
break;
}
case BuiltinOptions_GatherNdOptions: {
value = new GatherNdOptionsT(*reinterpret_cast<GatherNdOptionsT *>(u.value));
break;
}
case BuiltinOptions_CosOptions: {
value = new CosOptionsT(*reinterpret_cast<CosOptionsT *>(u.value));
break;
}
case BuiltinOptions_WhereOptions: {
value = new WhereOptionsT(*reinterpret_cast<WhereOptionsT *>(u.value));
break;
}
case BuiltinOptions_RankOptions: {
value = new RankOptionsT(*reinterpret_cast<RankOptionsT *>(u.value));
break;
}
case BuiltinOptions_ReverseSequenceOptions: {
value = new ReverseSequenceOptionsT(*reinterpret_cast<ReverseSequenceOptionsT *>(u.value));
break;
}
case BuiltinOptions_MatrixDiagOptions: {
value = new MatrixDiagOptionsT(*reinterpret_cast<MatrixDiagOptionsT *>(u.value));
break;
}
case BuiltinOptions_QuantizeOptions: {
value = new QuantizeOptionsT(*reinterpret_cast<QuantizeOptionsT *>(u.value));
break;
}
case BuiltinOptions_MatrixSetDiagOptions: {
value = new MatrixSetDiagOptionsT(*reinterpret_cast<MatrixSetDiagOptionsT *>(u.value));
break;
}
case BuiltinOptions_HardSwishOptions: {
value = new HardSwishOptionsT(*reinterpret_cast<HardSwishOptionsT *>(u.value));
break;
}
case BuiltinOptions_IfOptions: {
value = new IfOptionsT(*reinterpret_cast<IfOptionsT *>(u.value));
break;
}
case BuiltinOptions_WhileOptions: {
value = new WhileOptionsT(*reinterpret_cast<WhileOptionsT *>(u.value));
break;
}
case BuiltinOptions_DepthToSpaceOptions: {
value = new DepthToSpaceOptionsT(*reinterpret_cast<DepthToSpaceOptionsT *>(u.value));
break;
}
case BuiltinOptions_NonMaxSuppressionV4Options: {
value = new NonMaxSuppressionV4OptionsT(*reinterpret_cast<NonMaxSuppressionV4OptionsT *>(u.value));
break;
}
case BuiltinOptions_NonMaxSuppressionV5Options: {
value = new NonMaxSuppressionV5OptionsT(*reinterpret_cast<NonMaxSuppressionV5OptionsT *>(u.value));
break;
}
case BuiltinOptions_ScatterNdOptions: {
value = new ScatterNdOptionsT(*reinterpret_cast<ScatterNdOptionsT *>(u.value));
break;
}
case BuiltinOptions_SelectV2Options: {
value = new SelectV2OptionsT(*reinterpret_cast<SelectV2OptionsT *>(u.value));
break;
}
default:
break;
}
}
inline void BuiltinOptionsUnion::Reset() {
switch (type) {
case BuiltinOptions_Conv2DOptions: {
auto ptr = reinterpret_cast<Conv2DOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_DepthwiseConv2DOptions: {
auto ptr = reinterpret_cast<DepthwiseConv2DOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_ConcatEmbeddingsOptions: {
auto ptr = reinterpret_cast<ConcatEmbeddingsOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_LSHProjectionOptions: {
auto ptr = reinterpret_cast<LSHProjectionOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_Pool2DOptions: {
auto ptr = reinterpret_cast<Pool2DOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_SVDFOptions: {
auto ptr = reinterpret_cast<SVDFOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_RNNOptions: {
auto ptr = reinterpret_cast<RNNOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_FullyConnectedOptions: {
auto ptr = reinterpret_cast<FullyConnectedOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_SoftmaxOptions: {
auto ptr = reinterpret_cast<SoftmaxOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_ConcatenationOptions: {
auto ptr = reinterpret_cast<ConcatenationOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_AddOptions: {
auto ptr = reinterpret_cast<AddOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_L2NormOptions: {
auto ptr = reinterpret_cast<L2NormOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_LocalResponseNormalizationOptions: {
auto ptr = reinterpret_cast<LocalResponseNormalizationOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_LSTMOptions: {
auto ptr = reinterpret_cast<LSTMOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_ResizeBilinearOptions: {
auto ptr = reinterpret_cast<ResizeBilinearOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_CallOptions: {
auto ptr = reinterpret_cast<CallOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_ReshapeOptions: {
auto ptr = reinterpret_cast<ReshapeOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_SkipGramOptions: {
auto ptr = reinterpret_cast<SkipGramOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_SpaceToDepthOptions: {
auto ptr = reinterpret_cast<SpaceToDepthOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_EmbeddingLookupSparseOptions: {
auto ptr = reinterpret_cast<EmbeddingLookupSparseOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_MulOptions: {
auto ptr = reinterpret_cast<MulOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_PadOptions: {
auto ptr = reinterpret_cast<PadOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_GatherOptions: {
auto ptr = reinterpret_cast<GatherOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_BatchToSpaceNDOptions: {
auto ptr = reinterpret_cast<BatchToSpaceNDOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_SpaceToBatchNDOptions: {
auto ptr = reinterpret_cast<SpaceToBatchNDOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_TransposeOptions: {
auto ptr = reinterpret_cast<TransposeOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_ReducerOptions: {
auto ptr = reinterpret_cast<ReducerOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_SubOptions: {
auto ptr = reinterpret_cast<SubOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_DivOptions: {
auto ptr = reinterpret_cast<DivOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_SqueezeOptions: {
auto ptr = reinterpret_cast<SqueezeOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_SequenceRNNOptions: {
auto ptr = reinterpret_cast<SequenceRNNOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_StridedSliceOptions: {
auto ptr = reinterpret_cast<StridedSliceOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_ExpOptions: {
auto ptr = reinterpret_cast<ExpOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_TopKV2Options: {
auto ptr = reinterpret_cast<TopKV2OptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_SplitOptions: {
auto ptr = reinterpret_cast<SplitOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_LogSoftmaxOptions: {
auto ptr = reinterpret_cast<LogSoftmaxOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_CastOptions: {
auto ptr = reinterpret_cast<CastOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_DequantizeOptions: {
auto ptr = reinterpret_cast<DequantizeOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_MaximumMinimumOptions: {
auto ptr = reinterpret_cast<MaximumMinimumOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_ArgMaxOptions: {
auto ptr = reinterpret_cast<ArgMaxOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_LessOptions: {
auto ptr = reinterpret_cast<LessOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_NegOptions: {
auto ptr = reinterpret_cast<NegOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_PadV2Options: {
auto ptr = reinterpret_cast<PadV2OptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_GreaterOptions: {
auto ptr = reinterpret_cast<GreaterOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_GreaterEqualOptions: {
auto ptr = reinterpret_cast<GreaterEqualOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_LessEqualOptions: {
auto ptr = reinterpret_cast<LessEqualOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_SelectOptions: {
auto ptr = reinterpret_cast<SelectOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_SliceOptions: {
auto ptr = reinterpret_cast<SliceOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_TransposeConvOptions: {
auto ptr = reinterpret_cast<TransposeConvOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_SparseToDenseOptions: {
auto ptr = reinterpret_cast<SparseToDenseOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_TileOptions: {
auto ptr = reinterpret_cast<TileOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_ExpandDimsOptions: {
auto ptr = reinterpret_cast<ExpandDimsOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_EqualOptions: {
auto ptr = reinterpret_cast<EqualOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_NotEqualOptions: {
auto ptr = reinterpret_cast<NotEqualOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_ShapeOptions: {
auto ptr = reinterpret_cast<ShapeOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_PowOptions: {
auto ptr = reinterpret_cast<PowOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_ArgMinOptions: {
auto ptr = reinterpret_cast<ArgMinOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_FakeQuantOptions: {
auto ptr = reinterpret_cast<FakeQuantOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_PackOptions: {
auto ptr = reinterpret_cast<PackOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_LogicalOrOptions: {
auto ptr = reinterpret_cast<LogicalOrOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_OneHotOptions: {
auto ptr = reinterpret_cast<OneHotOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_LogicalAndOptions: {
auto ptr = reinterpret_cast<LogicalAndOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_LogicalNotOptions: {
auto ptr = reinterpret_cast<LogicalNotOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_UnpackOptions: {
auto ptr = reinterpret_cast<UnpackOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_FloorDivOptions: {
auto ptr = reinterpret_cast<FloorDivOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_SquareOptions: {
auto ptr = reinterpret_cast<SquareOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_ZerosLikeOptions: {
auto ptr = reinterpret_cast<ZerosLikeOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_FillOptions: {
auto ptr = reinterpret_cast<FillOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_BidirectionalSequenceLSTMOptions: {
auto ptr = reinterpret_cast<BidirectionalSequenceLSTMOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_BidirectionalSequenceRNNOptions: {
auto ptr = reinterpret_cast<BidirectionalSequenceRNNOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_UnidirectionalSequenceLSTMOptions: {
auto ptr = reinterpret_cast<UnidirectionalSequenceLSTMOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_FloorModOptions: {
auto ptr = reinterpret_cast<FloorModOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_RangeOptions: {
auto ptr = reinterpret_cast<RangeOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_ResizeNearestNeighborOptions: {
auto ptr = reinterpret_cast<ResizeNearestNeighborOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_LeakyReluOptions: {
auto ptr = reinterpret_cast<LeakyReluOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_SquaredDifferenceOptions: {
auto ptr = reinterpret_cast<SquaredDifferenceOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_MirrorPadOptions: {
auto ptr = reinterpret_cast<MirrorPadOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_AbsOptions: {
auto ptr = reinterpret_cast<AbsOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_SplitVOptions: {
auto ptr = reinterpret_cast<SplitVOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_UniqueOptions: {
auto ptr = reinterpret_cast<UniqueOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_ReverseV2Options: {
auto ptr = reinterpret_cast<ReverseV2OptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_AddNOptions: {
auto ptr = reinterpret_cast<AddNOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_GatherNdOptions: {
auto ptr = reinterpret_cast<GatherNdOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_CosOptions: {
auto ptr = reinterpret_cast<CosOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_WhereOptions: {
auto ptr = reinterpret_cast<WhereOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_RankOptions: {
auto ptr = reinterpret_cast<RankOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_ReverseSequenceOptions: {
auto ptr = reinterpret_cast<ReverseSequenceOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_MatrixDiagOptions: {
auto ptr = reinterpret_cast<MatrixDiagOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_QuantizeOptions: {
auto ptr = reinterpret_cast<QuantizeOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_MatrixSetDiagOptions: {
auto ptr = reinterpret_cast<MatrixSetDiagOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_HardSwishOptions: {
auto ptr = reinterpret_cast<HardSwishOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_IfOptions: {
auto ptr = reinterpret_cast<IfOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_WhileOptions: {
auto ptr = reinterpret_cast<WhileOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_DepthToSpaceOptions: {
auto ptr = reinterpret_cast<DepthToSpaceOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_NonMaxSuppressionV4Options: {
auto ptr = reinterpret_cast<NonMaxSuppressionV4OptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_NonMaxSuppressionV5Options: {
auto ptr = reinterpret_cast<NonMaxSuppressionV5OptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_ScatterNdOptions: {
auto ptr = reinterpret_cast<ScatterNdOptionsT *>(value);
delete ptr;
break;
}
case BuiltinOptions_SelectV2Options: {
auto ptr = reinterpret_cast<SelectV2OptionsT *>(value);
delete ptr;
break;
}
default: break;
}
value = nullptr;
type = BuiltinOptions_NONE;
}
inline const tflite::Model *GetModel(const void *buf) {
return flatbuffers::GetRoot<tflite::Model>(buf);
}
inline const tflite::Model *GetSizePrefixedModel(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<tflite::Model>(buf);
}
inline const char *ModelIdentifier() {
return "TFL3";
}
inline bool ModelBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier(
buf, ModelIdentifier());
}
inline bool VerifyModelBuffer(
flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<tflite::Model>(ModelIdentifier());
}
inline bool VerifySizePrefixedModelBuffer(
flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<tflite::Model>(ModelIdentifier());
}
inline const char *ModelExtension() {
return "tflite";
}
inline void FinishModelBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<tflite::Model> root) {
fbb.Finish(root, ModelIdentifier());
}
inline void FinishSizePrefixedModelBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<tflite::Model> root) {
fbb.FinishSizePrefixed(root, ModelIdentifier());
}
inline std::unique_ptr<ModelT> UnPackModel(
const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) {
return std::unique_ptr<ModelT>(GetModel(buf)->UnPack(res));
}
} // namespace tflite
#endif // FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_
| [
"finn.niu@apptech.com.hk"
] | finn.niu@apptech.com.hk |
b39d2aaebda4d7e1e0d805943b8b2d3626d61214 | b405fd9cd3c53a3ed279e75aca3fec89ba745df5 | /261.Graph Valid Tree/261.Graph Valid Tree/main.cpp | 3b48db0a685ef31f80ace5dfedf3aec0b94a656f | [] | no_license | Abysman/MyLeetCode | 4842db63f4914022a3773be1e9d9ce068cb6d3bd | a4eb8af658996e7ba4501342f4aa4bbd113e6cfb | refs/heads/master | 2021-04-06T20:48:17.260497 | 2020-01-23T23:09:35 | 2020-01-23T23:09:35 | 125,452,898 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,172 | cpp | //
// main.cpp
// 261.Graph Valid Tree
//
// Created by Abysman on 2018/10/30.
// Copyright © 2018年 Abysman. All rights reserved.
//
#include <iostream>
#include <vector>
class Solution {
public:
bool validTree(int n, std::vector<std::pair<int, int>>& edges) {
std::vector<std::vector<int>> neighbors(n);
for (auto e : edges) {
neighbors[e.first].push_back(e.second);
neighbors[e.second].push_back(e.first);
}
std::vector<bool> visited(n, false);
if (hasCycle(neighbors, 0, -1, visited))
return false;
for (bool v : visited)
if (!v) return false;
return true;
}
private:
bool hasCycle(std::vector<std::vector<int>>& neighbors, int kid, int parent, std::vector<bool>& visited) {
if (visited[kid]) return true;
visited[kid] = true;
for (auto neigh : neighbors[kid])
if (neigh != parent && hasCycle(neighbors, neigh, kid, visited))
return true;
return false;
}
};
int main(int argc, const char * argv[]) {
// insert code here...
std::cout << "Hello, World!\n";
return 0;
}
| [
"756884429@qq.com"
] | 756884429@qq.com |
d79df45e10c93ca10b064539b9318e3529f17976 | 7c5d7fb6a64df1a118a64bdf6087ecf395a3a722 | /data/spb-team-f/sources/503-f-5.cpp | a56ff482d90a5179c905d3087dcec647a2991d0c | [] | no_license | alexhein189/code-plagiarism-detector | e66df71c46cc5043b6825ef76a940b658c0e5015 | 68d21639d4b37bb2c801befe6f7ce0007d7eccc5 | refs/heads/master | 2023-03-18T06:02:45.508614 | 2016-05-04T14:29:57 | 2016-05-04T14:54:19 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,157 | cpp | #include <iostream>
#include <fstream>
#include "io.h"
#include "stdio.h"
using namespace std;
int max(int a, int b)
{
return ((a > b) ? a : b);
}
int min(int a, int b)
{
return ((a < b) ? a : b);
}
int NOD(int a, int b)
{
int i;
for (i = min(a, b); i > 0; i--)
{
if ((a%i == 0) && (b%i == 0))
{
return i;
break;
}
}
return i;
}
int NOK(int x, int y)
{
int a = min(x, y);
int b = max(x, y);
int i = 0;
for (i = b; i < a*b + 1; i++)
{
if ((i%b == 0) && (i%a == 0))
{
return i;
break;
}
}
return a*b;
}
int main()
{
ifstream fin("gcm.in");
ofstream fout("gcm.out");
int x;
int y;
int a;
int b;
fin >> a >> b;
bool g = false;
for (x = 1; x < max(a, b); x++)
{
for (y = 1; y < max(a, b); y++)
{
if ((NOD(a, b) == NOD(x, y)) && (NOK(a, b) == NOK(x, y)))
{
g = true;
fout << x << " " << y;
fout.close();
fin.close();
exit(0);
}
}
}
if (g == false)
{
fout << a << " " << b;
}
fin.close();
fout.close();
return 0;
} | [
"shk.slava@gmail.com"
] | shk.slava@gmail.com |
d443d9f528b44d7038aacc67edf0b4e585b56da4 | 1bf404fe821694258a4f44204fde126553dc4bed | /6.DoubleHashing/main.cpp | d856632b7f151eb5bffe52869ceedfa39212f909 | [] | no_license | Cass2046/DataStructure | f159a32de8985b79b13d59f9a9436d202e8c1acd | 3961d0c6c0ad57eab8b7bda8db843ff2e2386a01 | refs/heads/master | 2020-04-27T16:19:24.709340 | 2019-03-08T06:23:01 | 2019-03-08T06:23:01 | 174,480,782 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 132 | cpp | #include <string>
#include "Executive.h"
int main(int argc, char* argv[])
{
Executive E;
E.run("data.txt");
return 0;
}
| [
"lu.yin2046@gmail.com"
] | lu.yin2046@gmail.com |
c58183dd9fe652b6acf07d9028bf17a05c4ad47d | 5a2996a8a78779bebe455aca5f723abe8d43e607 | /task1.cpp | fe0b51562613ea64e60fbb2fa287bf7c6ec087db | [] | no_license | pokachopotun/hpc-acad-2018 | e2ef5c458ef9bac9addb75ce5438e1d11a381b31 | 13973cf88032426a2e461e5b4f2b8dc620d8549a | refs/heads/master | 2021-09-24T00:29:30.629402 | 2018-09-30T15:26:22 | 2018-09-30T15:26:22 | 149,976,386 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,026 | cpp | #include <omp.h>
#include <cstdio>
#include <iostream>
using namespace std;
#define VECTOR_SIZE 10000000
int main(){
int v[VECTOR_SIZE];
mp_set_num_threads(4);
#pragma omp parallel for
for( int i = 0; i < VECTOR_SIZE; ++i)
{
v[i] = i;
}
for(int threadNum = 1; threadNum <= 4; threadNum++){
printf("threadNum = %d\n", threadNum);
omp_set_num_threads(threadNum);
int secSize = VECTOR_SIZE / threadNum + ( VECTOR_SIZE % threadNum > 0);
int gm = v[0];
double tick = omp_get_wtime();
#pragma omp parallel
{
int procId = omp_get_thread_num();
int s = procId * secSize;
if( s < VECTOR_SIZE ){
int f = min( (procId + 1) * secSize, VECTOR_SIZE);
int lm = v[s];
for(int i = s; i < f; i++){
lm = max(lm, v[i]);
}
printf("%d %d max is: %d\n", s, f, lm);
#pragma omp critical
if(lm > gm){
gm = lm;
}
}
}
double tack = omp_get_wtime();
double time = tick - tack;
printf("Array max is: %d\n", gm );
printf("Time is: %d\n", time );
}
return 0;
} | [
"mr.salixnew@gmail.com"
] | mr.salixnew@gmail.com |
4d506d21bbd44f00e83e56632f63c3d63cd0c59d | fb316bfb0fdb2318d3ecc872e2d61ff272638dab | /app/file/file-operation-manager.cpp | 3cff9dd8742f4182518e0af43a66f3fa94e0372d | [
"MIT"
] | permissive | dingjingmaster/filesystem | 88acd30fc3158128a700617827b49823b251f670 | 5ff321e62c87c4fa3a709ad71c59616ee7ddb23e | refs/heads/master | 2022-12-13T05:56:17.618978 | 2020-09-05T10:53:33 | 2020-09-05T10:53:33 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,670 | cpp | #include "file-operation-manager.h"
#include <QUrl>
#include <file-utils.h>
#include <file/file-watcher.h>
#include <QMessageBox>
#include <QApplication>
#include <QtConcurrent>
#include <QStandardPaths>
#include <global-settings.h>
#include "global-settings.h"
#include "file-copy-operation.h"
#include "file-move-operation.h"
#include "file-trash-operation.h"
#include "file-delete-operation.h"
#include "file-rename-operation.h"
#include "file-untrash-operation.h"
#include "file-operation-error-dialog.h"
#include "file-operation-progress-wizard.h"
static FileOperationManager *globalInstance = nullptr;
FileOperationManager *FileOperationManager::getInstance()
{
if (globalInstance == nullptr) {
globalInstance = new FileOperationManager;
}
return globalInstance;
}
void FileOperationManager::close()
{
disconnect();
deleteLater();
globalInstance = nullptr;
Q_EMIT closed();
}
bool FileOperationManager::isAllowParallel()
{
return mAllowParallel;
}
/**
*
* @note FIXME://
*/
void FileOperationManager::setAllowParallel(bool allow)
{
mAllowParallel = allow;
if (allow) {
mThreadPool->setMaxThreadCount(9999);
} else {
mThreadPool->setMaxThreadCount(1);
}
// GlobalSettings::getInstance()->setValue(ALLOW_FILE_OP_PARALLEL, allow);
}
void FileOperationManager::slotUndo()
{
if(!slotCanUndo())
return;
auto undoInfo = mUndoStack.pop();
mRedoStack.push(undoInfo);
auto oppositeInfo = undoInfo->getOppositeInfo(*undoInfo.get());
slotStartUndoOrRedo(oppositeInfo);
}
void FileOperationManager::slotRedo()
{
if (!slotCanRedo())
return;
auto redoInfo = mRedoStack.pop();
mUndoStack.push(redoInfo);
slotStartUndoOrRedo(redoInfo);
}
bool FileOperationManager::slotCanRedo()
{
return !mRedoStack.isEmpty();
}
bool FileOperationManager::slotCanUndo()
{
return !mUndoStack.isEmpty();
}
void FileOperationManager::slotClearHistory()
{
mUndoStack.clear();
mRedoStack.clear();
}
void FileOperationManager::registerFileWatcher(FileWatcher *watcher)
{
mWatchers << watcher;
}
void FileOperationManager::unregisterFileWatcher(FileWatcher *watcher)
{
mWatchers.removeOne(watcher);
}
void FileOperationManager::slotOnFilesDeleted(const QStringList &uris)
{
slotClearHistory();
}
std::shared_ptr<FileOperationInfo> FileOperationManager::slotGetRedoInfo()
{
return mRedoStack.top();
}
std::shared_ptr<FileOperationInfo> FileOperationManager::slotGetUndoInfo()
{
return mUndoStack.top();
}
void FileOperationManager::manuallyNotifyDirectoryChanged(FileOperationInfo *info)
{
if (!info)
return;
// skip create template opeartion, it will be handled by operation itself.
if (info->mSrcDirUri == QStandardPaths::writableLocation(QStandardPaths::TempLocation))
return;
for (auto watcher : mWatchers) {
if (!watcher->supportMonitor()) {
auto srcDir = info->mSrcDirUri;
auto destDir = info->mDestDirUri;
if (info->operationType() == FileOperationInfo::Link || info->operationType() == FileOperationInfo::Rename) {
srcDir = FileUtils::getParentUri(info->mSrcUris.first());
}
// check watcher directory
if (watcher->currentUri() == srcDir || watcher->currentUri() == destDir) {
// tell the view/model the directory should be updated
watcher->requestUpdateDirectory();
}
}
}
}
void FileOperationManager::slotStartUndoOrRedo(std::shared_ptr<FileOperationInfo> info)
{
FileOperation *op = nullptr;
switch (info->mType) {
case FileOperationInfo::Copy: {
op = new FileCopyOperation(info->mSrcUris, info->mDestDirUri);
break;
}
case FileOperationInfo::Delete: {
if (info->mNodeMap.isEmpty())
op = new FileDeleteOperation(info->mSrcUris);
else
op = new FileDeleteOperation(info->mNodeMap.keys());
break;
}
case FileOperationInfo::Link: {
op = new FileDeleteOperation(info->mSrcUris);
break;
}
case FileOperationInfo::Move: {
op = new FileMoveOperation(info->mSrcUris, info->mDestDirUri);
break;
}
case FileOperationInfo::Rename: {
if (info->mNodeMap.isEmpty()) {
op = new FileRenameOperation(info->mSrcUris.isEmpty()? nullptr: info->mSrcUris.at(0), info->mDestDirUri);
} else {
auto destUri = info->mNodeMap.first();
QUrl url = destUri;
op = new FileRenameOperation(info->mNodeMap.firstKey(), url.fileName());
}
break;
}
case FileOperationInfo::Trash: {
op = new FileTrashOperation(info->mSrcUris);
break;
}
case FileOperationInfo::Untrash: {
op = new FileUntrashOperation(info->mSrcUris);
break;
}
default:
break;
}
if (op) {
slotStartOperation(op, false);
}
}
void FileOperationManager::slotStartOperation(FileOperation *operation, bool addToHistory)
{
QApplication::setQuitOnLastWindowClosed(false);
connect(operation, &FileOperation::operationFinished, this, [=]() {
operation->notifyFileWatcherOperationFinished();
auto settings = GlobalSettings::getInstance();
bool runbackend = settings->getInstance()->getValue(RESIDENT_IN_BACKEND).toBool();
QApplication::setQuitOnLastWindowClosed(!runbackend);
#if QT_VERSION > QT_VERSION_CHECK(5, 12, 0)
QTimer::singleShot(1000, this, [=]() {
#else
QTimer::singleShot(1000, [=]() {
#endif
int lastOpCount = mThreadPool->children().count();
if (lastOpCount == 0) {
if (qApp->allWidgets().isEmpty()) {
if (!runbackend) {
qApp->quit();
}
}
}
});
});
auto operationInfo = operation->getOperationInfo();
bool allowParallel = mAllowParallel;
auto opType = operationInfo->operationType();
switch (opType) {
case FileOperationInfo::Trash:
case FileOperationInfo::Delete: {
allowParallel = true;
auto operationSrcs = operationInfo->sources();
auto currentOps = mThreadPool->children();
QList<FileOperation *> ops;
for (auto child : currentOps) {
auto op = qobject_cast<FileOperation *>(child);
auto opInfo = op->getOperationInfo();
{
for (auto src : operationSrcs) {
if (opInfo->sources().contains(src)) {
//do not allow operation.
QMessageBox::critical(nullptr,
tr("Can't delete."),
tr("You can't delete a file when"
"the file is doing another operation"));
return;
}
}
}
}
break;
}
default:
break;
}
FileOperationProgressWizard *wizard = new FileOperationProgressWizard;
wizard->setAttribute(Qt::WA_DeleteOnClose);
wizard->connect(operation, &FileOperation::operationRequestShowWizard, wizard, &FileOperationProgressWizard::delayShow);
wizard->connect(operation, &FileOperation::operationRequestShowWizard, wizard, &FileOperationProgressWizard::switchToPreparedPage);
wizard->connect(operation, &FileOperation::operationPreparedOne, wizard, &FileOperationProgressWizard::onElementFoundOne);
wizard->connect(operation, &FileOperation::operationPrepared, wizard, &FileOperationProgressWizard::onElementFoundAll);
wizard->connect(operation, &FileOperation::operationProgressedOne, wizard, &FileOperationProgressWizard::onFileOperationProgressedOne);
wizard->connect(operation, &FileOperation::FileProgressCallback, wizard, &FileOperationProgressWizard::updateProgress);
wizard->connect(operation, &FileOperation::operationProgressed, wizard, &FileOperationProgressWizard::onFileOperationProgressedAll);
wizard->connect(operation, &FileOperation::operationAfterProgressedOne, wizard, &FileOperationProgressWizard::onElementClearOne);
wizard->connect(operation, &FileOperation::operationAfterProgressed, wizard, &FileOperationProgressWizard::switchToRollbackPage);
wizard->connect(operation, &FileOperation::operationStartRollbacked, wizard, &FileOperationProgressWizard::switchToRollbackPage);
wizard->connect(operation, &FileOperation::operationRollbackedOne, wizard, &FileOperationProgressWizard::onFileRollbacked);
wizard->connect(operation, &FileOperation::operationStartSnyc, wizard, &FileOperationProgressWizard::onStartSync);
wizard->connect(operation, &FileOperation::operationFinished, wizard, &FileOperationProgressWizard::deleteLater);
connect(wizard, &FileOperationProgressWizard::cancelled,
operation, &FileOperation::slotCancel);
operation->connect(operation, &FileOperation::errored, [=]() {
operation->setHasError(true);
});
operation->connect(operation, &FileOperation::errored, this, &FileOperationManager::slotHandleError, Qt::BlockingQueuedConnection);
operation->connect(operation, &FileOperation::operationFinished, [=]() {
if (operation->hasError()) {
this->slotClearHistory();
return ;
}
if (addToHistory) {
auto info = operation->getOperationInfo();
if (!info)
return;
if (info->operationType() != FileOperationInfo::Delete) {
mUndoStack.push(info);
mRedoStack.clear();
} else {
this->slotClearHistory();
}
}
});
if (!allowParallel) {
if (mThreadPool->activeThreadCount() > 0) {
QMessageBox::warning(nullptr,
tr("File Operation is Busy"),
tr("There have been one or more file"
"operation(s) executing before. Your"
"operation will wait for executing"
"until it/them done. If you really "
"want to execute file operations "
"parallelly anyway, you can change "
"the default option \"Allow Parallel\" "
"in option menu."));
}
operation->setParent(mThreadPool);
mThreadPool->start(operation);
} else {
QtConcurrent::run([=] {
operation->setParent(mThreadPool);
operation->setAutoDelete(false);
operation->run();
operation->setParent(nullptr);
operation->deleteLater();
});
}
}
QVariant FileOperationManager::slotHandleError(const QString &srcUri, const QString &destUri, const GerrorWrapperPtr &err, bool critical)
{
FileOperationErrorDialog dlg;
return dlg.slotHandleError(srcUri, destUri, err, critical);
}
FileOperationManager::FileOperationManager(QObject *parent) : QObject(parent)
{
mAllowParallel = GlobalSettings::getInstance()->getValue(ALLOW_FILE_OP_PARALLEL).toBool();
qRegisterMetaType<GerrorWrapperPtr>("GerrorWrapperPtr");
qRegisterMetaType<GerrorWrapperPtr>("GerrorWrapperPtr&");
mThreadPool = new QThreadPool(this);
if (!mAllowParallel) {
mThreadPool->setMaxThreadCount(1);
}
}
FileOperationManager::~FileOperationManager()
{
}
| [
"dingjing@live.cn"
] | dingjing@live.cn |
fc188b3628ca02e0e6ba71972b1d575354abbdbe | ff85890b9926f57c7a920c569811c5f7dcc539ca | /ENIGMATH.cpp | f637ed5cc9f38542f381b243619e1c86e0487c96 | [] | no_license | vd-07/Spoj-List | c40034be58b18124d3f8185fd25581de3a68b095 | 60b0a8de4de12d843a948d1417d469a2a5c885d5 | refs/heads/master | 2020-12-22T04:47:09.296636 | 2020-05-03T15:12:31 | 2020-05-03T15:12:31 | 236,673,871 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 602 | cpp | //Author : Vivek Dubey
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define ull unsigned long long int
#define f(i,s,e) for(int i=s;i<e;i++)
#define test ll t;cin>>t;while(t--)
#define mod 1000000007
void solve(){
ll A,B;
cin>>A>>B;
set<ll> factors;
for(ll i=1;i*i<=B;i++){
if(B%i)
continue;
factors.insert(B/i);
factors.insert(i);
}
for(auto fac : factors){
if(A%(B/fac))
continue;
cout<<fac<<" "<<((A*fac)/B)<<"\n";
break;
}
}
int main(){
test solve();
return 0;
} | [
"dubey.vivek.2805@gmail.com"
] | dubey.vivek.2805@gmail.com |
4f5fb437779088c6d7cb5d2dac6449471266b968 | ad273708d98b1f73b3855cc4317bca2e56456d15 | /aws-cpp-sdk-codecommit/include/aws/codecommit/model/EvaluatePullRequestApprovalRulesResult.h | 7daeb26de3acbc6e6cdd71dfff25c19c335ea398 | [
"MIT",
"Apache-2.0",
"JSON"
] | permissive | novaquark/aws-sdk-cpp | b390f2e29f86f629f9efcf41c4990169b91f4f47 | a0969508545bec9ae2864c9e1e2bb9aff109f90c | refs/heads/master | 2022-08-28T18:28:12.742810 | 2020-05-27T15:46:18 | 2020-05-27T15:46:18 | 267,351,721 | 1 | 0 | Apache-2.0 | 2020-05-27T15:08:16 | 2020-05-27T15:08:15 | null | UTF-8 | C++ | false | false | 3,678 | h | /*
* Copyright 2010-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#pragma once
#include <aws/codecommit/CodeCommit_EXPORTS.h>
#include <aws/codecommit/model/Evaluation.h>
#include <utility>
namespace Aws
{
template<typename RESULT_TYPE>
class AmazonWebServiceResult;
namespace Utils
{
namespace Json
{
class JsonValue;
} // namespace Json
} // namespace Utils
namespace CodeCommit
{
namespace Model
{
class AWS_CODECOMMIT_API EvaluatePullRequestApprovalRulesResult
{
public:
EvaluatePullRequestApprovalRulesResult();
EvaluatePullRequestApprovalRulesResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
EvaluatePullRequestApprovalRulesResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
/**
* <p>The result of the evaluation, including the names of the rules whose
* conditions have been met (if any), the names of the rules whose conditions have
* not been met (if any), whether the pull request is in the approved state, and
* whether the pull request approval rule has been set aside by an override. </p>
*/
inline const Evaluation& GetEvaluation() const{ return m_evaluation; }
/**
* <p>The result of the evaluation, including the names of the rules whose
* conditions have been met (if any), the names of the rules whose conditions have
* not been met (if any), whether the pull request is in the approved state, and
* whether the pull request approval rule has been set aside by an override. </p>
*/
inline void SetEvaluation(const Evaluation& value) { m_evaluation = value; }
/**
* <p>The result of the evaluation, including the names of the rules whose
* conditions have been met (if any), the names of the rules whose conditions have
* not been met (if any), whether the pull request is in the approved state, and
* whether the pull request approval rule has been set aside by an override. </p>
*/
inline void SetEvaluation(Evaluation&& value) { m_evaluation = std::move(value); }
/**
* <p>The result of the evaluation, including the names of the rules whose
* conditions have been met (if any), the names of the rules whose conditions have
* not been met (if any), whether the pull request is in the approved state, and
* whether the pull request approval rule has been set aside by an override. </p>
*/
inline EvaluatePullRequestApprovalRulesResult& WithEvaluation(const Evaluation& value) { SetEvaluation(value); return *this;}
/**
* <p>The result of the evaluation, including the names of the rules whose
* conditions have been met (if any), the names of the rules whose conditions have
* not been met (if any), whether the pull request is in the approved state, and
* whether the pull request approval rule has been set aside by an override. </p>
*/
inline EvaluatePullRequestApprovalRulesResult& WithEvaluation(Evaluation&& value) { SetEvaluation(std::move(value)); return *this;}
private:
Evaluation m_evaluation;
};
} // namespace Model
} // namespace CodeCommit
} // namespace Aws
| [
"aws-sdk-cpp-automation@github.com"
] | aws-sdk-cpp-automation@github.com |
c2ebf471a45571ee92b5d54ad464f9258c340da6 | e9c02bb0df7ad3a928cf7c97b8294451eaa8dbc8 | /graph-source-code/417-C/12143104.cpp | dea5461403339ca5188fe61e6647312b8351ca21 | [
"MIT"
] | permissive | AmrARaouf/algorithm-detection | b157a534545fa8920bbe94e7307d4b937a74aa60 | 59f3028d2298804870b32729415d71eec6116557 | refs/heads/master | 2021-01-13T14:37:04.074339 | 2015-12-06T21:14:31 | 2015-12-06T21:14:31 | 45,905,817 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 19,300 | cpp | //Language: GNU C++11
#include <iostream>
#include <vector>
#include <queue>
#include <stack>
#include <algorithm>
#include <string>
#include <string.h>
#include <functional>
#include <list>
#include <set>
#include <map>
#include <stdio.h>
#include <math.h>
typedef long long ll;
#define INF_MAX 2147483647
#define INF_MIN -2147483647
#define INF_LL 9223372036854775807LL
#define INF 2000000000
using namespace std;
/*
int bear[200001];
int maxv[200001];
int main()
{
int n; cin >> n;
memset(maxv, 0, sizeof(maxv));
for (int i = 0; i < n; i++)
{
int t; scanf("%d", &t);
bear[i] = t;
maxv[0] = max(maxv[0], t);
}
int idx = 1;
for (int i = n - 1; i > 0; i--)
{
for (int j = 0; j < i; j++)
{
bear[j] = min(bear[j], bear[j + 1]);
maxv[idx] = max(maxv[idx], bear[j]);
}
idx++;
}
for (int i = 0; i < n; i++)
{
cout << maxv[i] << " ";
}
return 0;
}
*/
/*
//CF_Round_300.Quasi Binary
int cache[1000000];
vector<int> bv;
void makeBinary(vector<int>& v,int n,int sum)
{
if (n == -1)
{
if (sum!=0)
v.push_back(sum);
return;
}
makeBinary(v, n - 1, sum);
makeBinary(v, n - 1, sum + (int)pow(10.0, (double)n));
}
//이번 함수는 정수가 주어지면 최소 몇번이 필요한지 계산한다.
int countFunc(int n)
{
if (n == 0)
return 0;
int& ret = cache[n];
if (ret != -1)
return ret;
ret = 987654321;
for (int i = 0; i < bv.size(); i++)
{
if (bv[i] > n)
break;
ret = min(ret, countFunc(n - bv[i]) + 1);
}
return ret;
}
//reconstruct는 countFunc를 역추적한다.
void reconstruct(vector<int>& v,int n)
{
if (n == 0)
return;
for (int i = 0; i < bv.size(); i++)
{
if (countFunc(n) == countFunc(n - bv[i]) + 1)
{
v.push_back(bv[i]);
reconstruct(v, n - bv[i]);
return;
}
}
}
int main()
{
memset(cache, -1, sizeof(cache));
makeBinary(bv, 6, 0);
sort(bv.begin(), bv.end());
int k; cin >> k;
if (k == 1000000)
{
cout << "1" << endl;
cout << "1000000";
return 0;
}
cout << countFunc(k) << endl;
vector<int> lv;
reconstruct(lv, k);
for (int i = 0; i < lv.size(); i++)
{
cout << lv[i] << " ";
}
return 0;
}
*/
/*
//R_303_Div2_C.WoodCutters
int n;
vector<ll> vx;
vector<ll> vh;
int maxTree(ll lb, int idx) //lb means left boundary and idx means index
{
ll curX = vx[idx];
ll curH = vh[idx];
if (idx == n - 1)
return 1;
if (lb < curX - curH)
return maxTree(curX, idx + 1) + 1;
else if (vx[idx + 1] > curX + curH)
return maxTree(curX + curH, idx + 1) + 1;
else
return maxTree(curX, idx + 1);
}
int main()
{
cin >> n;
for (int i = 0; i < n; i++)
{
int t1, t2; cin >> t1 >> t2;
vx.push_back(t1);
vh.push_back(t2);
}
cout << maxTree(-1000000001, 0);
return 0;
}
*/
//298_Div2_B.Covered Path
/*
int v1, v2, t, d;
int main()
{
cin >> v1 >> v2;
cin >> t >> d;
int sum = v1;
int cur = v1;
for (int i = 0; i < t - 1; i++)
{
for (int j = d; j >= -d; j--)
{
if (cur + j - (t-2 - i) * d <= v2)
{
cur = cur + j;
break;
}
}
sum += cur;
}
cout << sum;
return 0;
}
*/
//277.5_Div2_C.Given Length and Sum of Digits
/*
int main()
{
int m, s; cin >> m >> s;
int minv[100];
int maxv[100];
if (s == 0)
{
if (m == 1)
cout << "0 0" << endl;
else
cout << "-1 -1" << endl;
return 0;
}
int first = -1;
for (int i = 1; i <= 9; i++)
{
if (i + (m - 1) * 9 >= s)
{
first = i;
break;
}
}
if (first == -1)
{
cout << "-1 -1"; return 0;
}
minv[0] = first; int curSum = first;
for (int i = 1; i < m; i++)
{
for (int j = 0; j <= 9; j++)
{
if (j + (m - i - 1) * 9 >= s-curSum)
{
curSum += j;
minv[i] = j;
break;
}
}
}
for (int i = 0; i < m; i++)
{
cout << minv[i];
}
int second = -1;
for (int i = 9; i >= 1; i--)
{
if (i <= s){
second = i;
break;
}
}
maxv[0] = second; int curSum2 = second;
for (int i = 1; i < m; i++)
{
for (int j = 9; j >= 0; j--)
{
if (j <= s - curSum2)
{
curSum2 += j;
maxv[i] = j;
break;
}
}
}
cout << " ";
for (int i = 0; i < m; i++)
{
cout << maxv[i];
}
return 0;
}
*/
//272_Div2_B.Dreamoon and Wifi
/*
string s1; string s2;
int l; int a;
int countMethod(int idx,int sum)
{
if (idx == l)
{
if (sum == a)
return 1;
else
return 0;
}
if (s2[idx] == '+')
return countMethod(idx + 1, sum + 1);
else if (s2[idx] == '-')
return countMethod(idx + 1, sum - 1);
else
{
return countMethod(idx + 1, sum + 1) + countMethod(idx + 1, sum - 1);
}
}
int main()
{
cin >> s1 >> s2;
l = s1.length();
a = 0;
for (int i = 0; i < l; i++)
{
if (s1[i] == '+')
a++;
else
a--;
}
int ret = countMethod(0, 0);
int m = 0;
for (int i = 0; i < l; i++)
{
if (s2[i] == '?')
m++;
}
double mm = pow(2.0, (double)m);
printf("%.14f", (double)ret / mm);
return 0;
}
*/
/*
int n;
ll cache[1001][1001];
int l[1000];
int pack(int idx, int q)
{
if (idx == n)
return 0;
ll& ret = cache[idx][q];
if (ret != -1)
return ret;
ret = max(pack(idx + 1, q), pack(idx + 1, q + 1) + (q + 1) * l[idx]);
return ret;
}
int main()
{
cin >> n;
memset(cache, -1, sizeof(cache));
for (int i = 0; i < n; i++)
{
cin >> l[i];
}
for (int i = n; i >= 0; i--)
{
for (int j = n ; j >= 0; j--)
{
if (i == n) cache[i][j] = 0;
else
{
cache[i][j] = max(cache[i + 1][j], cache[i + 1][j + 1] + (j + 1)*l[i]);
}
}
}
cout<<cache[0][0]<<endl;
return 0;
}
*/
/*
int arrayN[65600];
int arrayK[65600];
int visited[65600];
int count1(int n)
{
if (n == 0)
return 0;
return count1(n / 2) + n % 2;
}
void f
int main()
{
memset(visited, -1, sizeof(visited));
int n, k; cin >> n >> k;
int size = (int)pow(2.0, (double)n);
int sum = 0;
for (int i = 0; i < size; i++)
{
arrayN[i] = count1(i);
sum += arrayN[i];
}
int size2 = (int)pow(2.0, (double)k);
int gaesu = size / size2;
int each = sum / size2;
for (int i = 0; i < size; i++)
{
if (visited[i] == -1)
find1(i);
}
return 0;
}
*/
//266_Div2.C Number of Ways
/*
int a[500000];
ll psum[500000];
ll pcount[500000];
int n;
ll pie;
int main()
{
cin >> n;
ll sum = 0;
for (int i = 0; i < n; i++)
{
int t; cin >> t;
a[i] = t;
sum += t;
psum[i] = sum;
}
if (psum[n - 1] % 3)
{
cout << "0";
return 0;
}
pie = psum[n - 1] / 3;
ll csum = 0;
for (int i = n-1; i >=0; i--)
{
csum += a[i];
if (csum == pie)
pcount[i] = 1;
}
for (int i = n - 2; i >= 0; i--)
pcount[i] += pcount[i + 1];
ll count = 0;
for (int i = 0; i < n-2; i++)
{
if (psum[i] == pie)
{
count += pcount[i + 2];
}
}
cout << count;
return 0;
}
*/
//267_Div2_C.George and Job
/*
int n, m, k;
int p[5001];
ll cache[5001][5001];
ll psum[5001];
ll f(int idx, int remained)
{
if (remained == 0)
return 0;
if (idx == n)
return -987654321;
ll& ret = cache[idx][remained];
if (ret != -1)
return ret;
if (idx + m - 1 <= n - 1)
{
return ret=max(f(idx + m, remained - 1) + psum[idx + m - 1] - psum[idx]+p[idx],
f(idx + 1, remained));
}
else
{
return -987654321;
}
}
int main()
{
cin >> n >> m >> k;
memset(cache, -1, sizeof(cache));
ll sum = 0;
for (int i = 0; i < n; i++)
{
cin >> p[i];
sum += p[i];
psum[i] = sum;
}
cout << f(0, k);
return 0;
}
*/
//271_Div2_D.Flowers
/*
int t, k;
int a[100001];
int b[100001];
ll cache[100001];
ll psum[100001];
int l;
int r = 1000000007;
int countMethod(int n)
{
if (n == l)
return 1;
ll& ret = cache[n];
if (ret != -1)
return ret;
ret = countMethod(n + 1);
if (n + k <= l)
ret += countMethod(n + k);
return ret=ret % 1000000007;
}
int main()
{
cin >> t >> k;
for (int i = 0; i < t; i++)
{
cin >> a[i] >> b[i];
}
memset(cache, -1, sizeof(cache));
l = 100000;
countMethod(0);
ll sum = 0;
for (int i = 0; i < l; i++)
{
sum += cache[i];
sum %= r;
psum[i] = sum;
}
for (int i = 0; i < t; i++)
{
ll t1 = psum[l - a[i]] + r;
ll t2 = psum[l - b[i]] - cache[l - b[i]];
ll t3 = (t1 - t2) % r;
cout << t3<< endl;
}
return 0;
}
*/
//256_Div2_C. Painting Fence
/*
int n;
int a[5001];
int f(int l, int r, int offset)
{
if (l == r) return 1;
if (l > r) return 0;
int minh = 1000000001;
for (int i = l; i <= r; i++)
{
minh = min(minh, a[i]-offset);
}
vector<int> v;
v.push_back(l - 1);
for (int i = l; i <= r; i++)
{
if (a[i] - offset - minh == 0)
v.push_back(i);
}
v.push_back(r + 1);
int sum = 0;
for (int i = 0; i < v.size()-1; i++)
{
sum+=f(v[i] + 1, v[i + 1] - 1, offset + minh);
}
return min(sum + minh,r-l+1);
}
int main()
{
cin >> n;
for (int i = 1; i <= n; i++)
{
cin >> a[i];
}
cout << f(1, n, 0);
return 0;
}
*/
//#FF_Div1_A.DZY Loves Sequences
/*
int n; int a[100001];
int cache[100001][2];
int ls(int idx, int flag)
{
if (idx == n - 1)
return 1;
int& ret = cache[idx][flag];
if (ret != -1)
return ret;
if (flag == 0)
{
return ret=ls(idx + 1, 0) + (a[idx] < a[idx + 1]) ? 1 : 0;
}
else
{
if (a[idx] < a[idx + 1])
return ret = ls(idx + 1, 1) + 1;
else
{
}
return ret = ls(idx + 1, 0) + 1;
}
}
int main()
{
cin >> n;
memset(cache, -1, sizeof(cache));
for (int i = 0; i < n; i++)
{
cin >> a[i];
}
cout << ls(0, 1);
return 0;
}
*/
/*
int n;
vector<pair<int,int>> xp;
vector<pair<int,int>> xm;
int main()
{
cin >> n;
for (int i = 0; i < n; i++)
{
int t1, t2;
cin >> t1 >> t2;
if (t1 > 0)
{
xp.push_back(make_pair(t1,t2));
}
else
{
xm.push_back(make_pair(t1, t2));
}
}
sort(xp.begin(), xp.end());
sort(xm.begin(), xm.end());
int sum = 0;
if (xp.size() >= xm.size() + 2)
{
for (int i = 0; i < xm.size(); i++)
{
sum += xm[i].second;
}
for (int i = 0; i< xm.size()+1; i++)
{
sum += xp[i].second;
}
}
else if (xm.size() >= xp.size() + 2)
{
for (int i = 0; i < xp.size(); i++)
{
sum += xp[i].second;
}
for (int i = 0; i < xp.size() + 1; i++)
{
int idx = xm.size() - i - 1;
sum += xm[idx].second;
}
}
else
{
for (int i = 0; i < xm.size(); i++)
{
sum += xm[i].second;
}
for (int i = 0; i < xp.size(); i++)
{
sum += xp[i].second;
}
}
cout << sum;
return 0;
}
*/
/*
int n;
int b[100001];
int a[1000001];
int visited[1000001];
int visited2[1000001];
vector<pair<int, int>> vp;
int main()
{
cin >> n;
memset(a, 0, sizeof(a));
memset(visited, -1, sizeof(visited));
memset(visited2, -1, sizeof(visited2));
for (int i = 0; i < n; i++)
{
int t; cin >> t;
b[i] = t;
if (visited[t] == -1)
{
visited[t] = i+1;
}
a[t]++;
}
for (int i = n - 1; i >= 0; i--)
{
if (visited2[b[i]] == -1)
{
visited2[b[i]] = i + 1;
}
}
for (int i = 0; i < 1000001; i++)
{
vp.push_back(make_pair(a[i], i));
}
sort(vp.begin(), vp.end());
reverse(vp.begin(), vp.end());
vector<int> va;
int maxv = vp[0].first;
for (int i = 0; i < vp.size(); i++)
{
if (vp[i].first != maxv)
break;
va.push_back(vp[i].second);
}
vector<pair<int, int>> vpp;
for (int i = 0; i < va.size(); i++)
{
vpp.push_back(make_pair(visited2[va[i]] - visited[va[i]], va[i]));
}
sort(vpp.begin(), vpp.end());
int te = vpp[0].second;
cout << visited[te] << " " << visited2[te];
return 0;
}
*/
//312_Div2_C.Amr and Chemistry
//놀랍게도, memset을 n번 반복하게 했던 코드가 시간 초과 문제를 일으켰다.
//memset구문을 삭제하는 대신 visited의 값을 여러개 가질 수 있게 했더니 해결되었다.
/*
int n;
int cnt[100001];
int steps[100001];
int v[100001];
void bfs(int k)
{
queue<pair<int,int>> q;
q.push(make_pair(k,0));
while (!q.empty())
{
int f=q.front().first;
int level = q.front().second;
cnt[f] ++;
steps[f] += level;
v[f] = 1;
q.pop();
int p = f / 2;
if (p >= 1 && v[p] != 1)
q.push(make_pair(p, level + 1));
int c = f * 2;
if (c <= 100000 && v[c] != 1)
q.push(make_pair(c, level + 1));
}
}
int main()
{
int n; cin >> n;
memset(steps, 0, sizeof(steps));
memset(cnt, 0, sizeof(cnt));
for (int i = 1; i <= n; i++)
{
int t; cin >> t;
queue<pair<int, int>> q;
q.push(make_pair(t, 0));
while (!q.empty())
{
int f = q.front().first;
int level = q.front().second;
cnt[f] ++;
steps[f] += level;
v[f] = i;
q.pop();
int p = f / 2;
if (p >= 1 && v[p] != i)
q.push(make_pair(p, level + 1));
int c = f * 2;
if (c <= 100000 && v[c] != i)
q.push(make_pair(c, level + 1));
}
}
int ans = INF;
for (int i = 0; i <= 100000; i++)
{
if (cnt[i] == n)
{
ans = min(ans, steps[i]);
}
}
cout << ans;
}
*/
//311_Div2_C. Authur and Table
/*
int n, l[100001], d[100001];
vector<pair<int, int>> dl;
int cnt[100001]; int sumd[100001];
int minEnergy(int k, int total)
{
int toRemove = total - (2 * cnt[k] - 1);
int sum = 0;
for (int i = 0; i < n; i++)
{
if (toRemove > 0)
{
if (dl[i].second < k)
{
sum += dl[i].first;
toRemove--;
}
}
else
break;
}
for (int i = k-1; i >= 1; i--)
{
if (cnt[i])
return min(sum, minEnergy(i, total - cnt[k]) + sumd[k]);
}
return sum;
}
int main()
{
cin >> n;
for (int i = 0; i < n; i++)
{
int t1;
cin >> t1;
l[i] = t1;
cnt[t1] ++;
}
for (int i = 0; i < n; i++)
{
int t2;
cin >> t2;
d[i] = t2;
}
for (int i = 0; i < n; i++)
{
dl.push_back(make_pair(d[i], l[i]));
sumd[l[i]] += d[i];
}
sort(dl.begin(), dl.end());
for (int i = 100000; i >= 1; i--)
{
if (cnt[i])
{
cout << minEnergy(i, n);
break;
}
}
return 0;
}
*/
/*
int n;
ll a[100003];
ll cache[100003];
ll f(int k)
{
if (k > 100000)
return 0;
ll& ret = cache[k];
if (ret != -1)
return ret;
return ret= max(f(k + 1), f(k + 2) + a[k]*k);
}
int main()
{
cin >> n;
memset(cache, -1, sizeof(cache));
for (int i = 0; i < n; i++)
{
int t; scanf("%d", &t);
a[t] ++;
}
cout << f(1);
return 0;
}
*/
//#FF_Div1_A.DZY Loves Sequences
/*
int n; int a[100002];
int cache[100002];
int lis(int k)
{
int& ret = cache[k];
if (k == n - 1) return ret=1;
if (ret != -1) return ret;
for (int i = k + 1; i < n; i++)
{
if (a[i]>a[k])
ret = max(ret, lis(i) + 1);
}
return ret;
}
int main()
{
cin >> n;
memset(cache, -1, sizeof(cache));
for (int i = 0; i < n; i++)
{
scanf("%d", &a[i]);
}
int ans = -1;
for (int i = 0; i < n; i++)
ans=max(ans,lis(i));
for (int i = 1; i < n; i++)
{
if (cache[i] == ans && a[i] >= 2)
{
cout << ans + 1;
return 0;
}
}
cout<<ans;
return 0;
}
*/
//CF_247_Div2_C.k-Tree
/*
int n, k, d;
ll cache[101];
ll f(int t , int r)
{
if (t == 0) return 1;
if (t < 0) return 0;
ll& ret = cache[t];
if (ret!= -1)
return ret;
ret = 0;
for (int i = 1; i <= r; i++)
{
ret += f(t - i,r);
ret = ret % 1000000007;
}
return ret;
}
int main()
{
memset(cache, -1, sizeof(cache));
cin >> n >> k >> d;
ll total = f(n, k);
memset(cache, -1, sizeof(cache));
ll remained = f(n, d-1);
cout << (total+1000000007 - remained)%1000000007<< endl;
return 0;
}
*/
//RCC 2014 Warm up_Div2_C.Football
int n, k;
int main()
{
cin >> n >> k;
if (n < 2 * k + 1)
{
cout << "-1";
return 0;
}
int m = n*k;
cout << m << endl;
for (int i = 1; i <= n; i++)
{
for (int j = i+1; j <= i+k; j++)
{
int loseteam = j;
if (loseteam>n)
loseteam = loseteam%n;
printf("%d %d\n", i, loseteam);
}
}
return 0;
} | [
"amr.abdelraouf93@gmail.com"
] | amr.abdelraouf93@gmail.com |
b43aaa3a7b57e28928122109a7008dfe9ad25ce3 | 483de0c089559fb5b16259795b3420693507c14b | /Game/debug-overlay.cpp | 30493c854ab0f7d6b37b066101167a6d0fcaa5ec | [] | no_license | eplawless/pong | 8dd54879b99d172170951e081d49b3ef46335249 | 75bcfc6fc046fa042d809791ebd8edd5056cf9b3 | refs/heads/master | 2020-04-08T18:56:21.073962 | 2019-01-15T18:44:29 | 2019-01-15T18:44:29 | 159,631,285 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,382 | cpp | #include "debug-overlay.h"
#include "../Engine/Libraries/DearIMGUI/imgui.h"
#include "../Engine/Libraries/DearIMGUI/imgui_impl_win32.h"
#include "../Engine/Libraries/DearIMGUI/imgui_impl_dx11.h"
extern LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
DebugOverlay::DebugOverlay()
: m_isVisible(false)
{
}
bool DebugOverlay::Initialize(
HWND hwnd,
Direct3D11Renderer &d3d)
{
IMGUI_CHECKVERSION();
ImGui::CreateContext();
ImGuiIO &io = ImGui::GetIO();
ImGui_ImplWin32_Init(hwnd);
ImGui_ImplDX11_Init(d3d.GetDevice(), d3d.GetDeviceContext());
ImGui::StyleColorsClassic();
return true;
}
void DebugOverlay::Shutdown()
{
ImGui_ImplDX11_Shutdown();
ImGui_ImplWin32_Shutdown();
ImGui::DestroyContext();
}
void DebugOverlay::SetVisible(bool isVisible)
{
m_isVisible = isVisible;
}
void DebugOverlay::Render()
{
if (!m_isVisible) { return; }
ImGui_ImplDX11_NewFrame();
ImGui_ImplWin32_NewFrame();
ImGui::NewFrame();
ImGui::Begin("Debug Menu");
if (ImGui::Button(m_options.isPaused ? "Unpause" : "Pause"))
{
m_options.isPaused = !m_options.isPaused;
}
ImGui::End();
ImGui::Render();
ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData());
}
LRESULT DebugOverlay::HandleMessage(
HWND hwnd,
UINT message,
WPARAM wparam,
LPARAM lparam)
{
return ImGui_ImplWin32_WndProcHandler(hwnd, message, wparam, lparam);
}
| [
"eplawless@gmail.com"
] | eplawless@gmail.com |
6ee05cd005d8c041292d40d84577e70a4f364d8a | 24b8aef808a1722b29ee22dc26b2dec0447db427 | /PAT-Advanced/最短路径/1018 Public Bike Management (30 分)/1018.cpp | 0a19f8ce5e159c6614e9d85dcbb53d7a6cb0dcce | [] | no_license | drincs/100-day-plan | 63f080a5328a58cb6f1fe1e97677a13f05d50c45 | ff06270f5d8d53fea3d34d990bb3ff336bb77557 | refs/heads/main | 2023-07-25T10:10:52.797163 | 2021-09-09T10:25:31 | 2021-09-09T10:25:31 | 359,845,885 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,405 | cpp | #include <iostream>
#include <vector>
#include <string.h>
#include <stack>
using namespace std;
int Cmax, N, Sp, M, half;
const int MAXN = 501;
const int INF = 0x3fffffff;
struct Station
{
int v, time;
Station(int _v, int _time) : v(_v), time(_time) {}
};
vector<Station> Adj[MAXN];
int num[MAXN];
bool vis[MAXN] = {false};
int t[MAXN], out[MAXN], back[MAXN];
vector<int> pre[MAXN];
void Dijkstra(int s)
{
fill(t, t + MAXN, INF);
fill(out, out + MAXN, 0);
fill(back, back + MAXN, 0);
t[s] = 0;
for (int i = 0; i < N; i++)
{
int u = -1, MIN = INF;
for (int j = 0; j < N; j++)
{
if (vis[j] == false && t[j] < MIN)
{
u = j;
MIN = t[j];
}
}
if (u == -1)
return;
vis[u] = true;
for (int j = 0; j < Adj[u].size(); j++)
{
int v = Adj[u][j].v;
int time = Adj[u][j].time;
if (time + t[u] < t[v])
{
t[v] = time + t[u];
pre[v].clear();
pre[v].push_back(u);
}
else if (time + t[u] == t[v])
{
pre[v].push_back(u);
}
}
}
}
vector<vector<int>> paths;
vector<int> path;
void getPath(int s)
{
if (s == 0)
{
path.push_back(s);
paths.push_back(path);
path.pop_back();
return;
}
path.push_back(s);
for (int i = 0; i < pre[s].size(); i++)
{
getPath(pre[s][i]);
}
path.pop_back();
}
int main()
{
scanf("%d%d%d%d", &Cmax, &N, &Sp, &M);
half = Cmax / 2;
fill(num, num + MAXN, 0);
for (int i = 0; i < N; i++)
{
scanf("%d", &num[i + 1]);
}
for (int i = 0; i < M; i++)
{
int a, b, time;
scanf("%d%d%d", &a, &b, &time);
Adj[a].push_back(Station(b, time));
Adj[b].push_back(Station(a, time));
}
Dijkstra(0);
getPath(Sp);
int MINOUT = INF, MINBACK = INF, index = -1;
for (int i = 0; i < paths.size(); i++)
{
int takeout = 0, tabkeback = 0;
for (int j = paths[i].size() - 1; j >= 0; j--)
{
int v = paths[i][j];
if (v != 0)
{
if (num[v] <= half)
{
if (tabkeback >= half - num[v])
{
tabkeback -= half - num[v];
}
else
{
takeout += (half - num[v] - tabkeback);
tabkeback = 0;
}
}
else
{
tabkeback += num[v] - half;
}
}
}
if (takeout < MINOUT)
{
MINOUT = takeout;
MINBACK = tabkeback;
index = i;
}
else if (takeout == MINOUT)
{
if (tabkeback < MINBACK)
{
MINBACK = tabkeback;
index = i;
}
}
}
printf("%d", MINOUT);
for (int i = paths[index].size() - 1; i >= 0; i--)
{
int v = paths[index][i];
if (v == 0)
printf(" %d", v);
else
printf("->%d", v);
}
printf(" %d\n", MINBACK);
system("pause");
return 0;
} | [
"drincs@github"
] | drincs@github |
b76a840d688a125661c76ad1ca371bf294c20035 | 56c11c2c4e0ef9752ccf9118825dec1a58787491 | /1_LineStructures/2_ ConsoleRectDraw_CircleCalcs.cpp | fdf0f4e4ca1d91fa40ab3aa6d8059ed4bf6f8be0 | [] | no_license | Ocvcorp/PR60Cplusplus | 79a1e2029756975f2ec81e01924609a6b2657aaf | 33aaf6dbe148a12d6d0beb5500a9707096a089f5 | refs/heads/master | 2021-02-07T03:08:23.119140 | 2020-08-14T21:40:34 | 2020-08-14T21:40:34 | 243,975,688 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,030 | cpp | /*
Семинар 1-3
задача 5
Пользователь вводит количество секунд, прошедшее с некоторого момента. Вывести на экран это количество времени в формате: дни часы минуты секунды.
*/
#include <iostream>
#include <math.h>
#include <locale>
#define PRINT(X) cout<<#X<<"="<<X<<endl;
using namespace std;
int main()
{
int M, S, D, H, Min, Sec,
mD, mH;
setlocale(LC_ALL, "Russian");
//сумма...частное
cout << "введите кол-во сек с 31ой сек 40ой минуты 6ого часа среды"<<endl;
cin>>S;
//перевод момента в секунды
M=31+40*60+6*3600+3*24*3600;
D=(M+S)/24/3600;
mD=(M+S)%(24*3600);
H=mD/3600;
mH=mD%3600;
Min=mH/60;
Sec=mH%60;
printf("Через %d сек настал %d-й день %d-ой час %d-ая минута %d-ая секунда", S, D, H, Min, Sec);
system("pause");
return 0;
} | [
"ocvcorp123@outlook.com"
] | ocvcorp123@outlook.com |
24b7d761937109937df4dcde1bfbb6d63d8f29d1 | 50c1593f3183e7fe578926ccabe1021105b88e90 | /やさしいC++/lesson7/sample6.cpp | 020a7f24676b042ddf7a8b1b14752472935e29eb | [] | no_license | birune/learning-cpp | a30a8887c6fbcabeb2cb176ba22dd0119114ade1 | 6670bd15597d3d46c744f764c4814aa11cc84f84 | refs/heads/master | 2020-05-20T02:15:27.192662 | 2019-05-07T13:49:39 | 2019-05-07T13:49:39 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 904 | cpp | #include <iostream>
using namespace std;
int buy(int x, int y);
//関数の定義の先頭に戻り値の型を指定する
int buy(int x, int y){
int z;
cout << x << "円と" << y << "円の車を買いました\n";
z = x+y;
//"return 戻り値"で一つだけ戻り値を返せる
//return文が来た時点で関数内の処理は終了する
return z;
}
int main(){
int num1, num2, sum;
cout << "いくらの車を買いますか\n";
cin >> num1;
cout << "いくらの車を買いますか\n";
cin >> num2;
//関数を呼び出して戻り値を"sum"に代入している
sum = buy(num1, num2);
cout << "合計で" << sum << "円です\n";
//戻り値は必ずしも利用しなくていい
buy(num1, num2);
return 0;
}
//g++ ファイル名 --input-charset=utf-8 --exec-charset=cp932
//日本語出力するときのやつ | [
"1221birune@gmail.com"
] | 1221birune@gmail.com |
27826210064f526193fc45a45860135ad4673c53 | 025414d26a2661a3479a6842ce8716877fd2e9da | /BWin/BWin/Event/EventCollection.h | a9a5b668bac72928d77229a270191b1e9bb12c24 | [
"MIT"
] | permissive | benbraide/BWin | d5ed92d2cf133d090387463fad0e20b9a6aaa3e9 | 465df64e889321283236e405212a37c528dc9f2d | refs/heads/master | 2022-12-07T17:17:44.169467 | 2020-09-03T06:48:55 | 2020-09-03T06:48:55 | 290,417,944 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,113 | h | #pragma once
#include <unordered_map>
#include "../Thread/ThreadContext.h"
#include "EventState.h"
namespace Win::Event{
namespace Exception{
class InvalidId : public Core::Exception::Base{
public:
InvalidId()
: Base("Invalid ID: Cannot access event handler with specified ID."){}
};
class UnsupportedType : public Core::Exception::Base{
public:
UnsupportedType()
: Base("Specified event type is not supported."){}
};
}
class Target;
class DefaultObject;
class Handler{
public:
virtual ~Handler() = default;
};
template <class ObjectT>
class ParameterTypedHandler : public Handler{
public:
using ObjectType = ObjectT;
virtual ~ParameterTypedHandler() = default;
virtual void Call(ObjectT &object) = 0;
};
template <class ReturnT, class ObjectT>
class TypedHandler : public ParameterTypedHandler<ObjectT>{
public:
using ReturnType = ReturnT;
using ObjectType = typename ParameterTypedHandler<ObjectT>::ObjectType;
using CallbackType = std::function<ReturnT(ObjectT &)>;
template <typename T>
struct Caller{
static void Call(ObjectT &object, const CallbackType &value){
object.Result = value(object);
}
};
template <>
struct Caller<void>{
static void Call(ObjectT &object, const CallbackType &value){
value(object);
}
};
explicit TypedHandler(const CallbackType &value)
: value_(value){}
virtual void Call(ObjectT &object) override{
Caller<ReturnT>::template Call(object, value_);
}
protected:
CallbackType value_;
};
class Bucket{
public:
using IdType = unsigned __int64;
explicit Bucket(bool isDefault)
: isDefault_(isDefault){}
virtual ~Bucket() = default;
virtual bool IsDefault() const{
return isDefault_;
}
virtual void Remove(IdType id, bool isDefault) = 0;
protected:
bool isDefault_;
};
template <class ObjectT>
class TypedBucket : public Bucket{
public:
using ObjectType = ObjectT;
using HandlerType = std::shared_ptr<ParameterTypedHandler<ObjectT>>;
using HandlerListType = std::list<std::pair<IdType, HandlerType>>;
using Bucket::Bucket;
virtual void Remove(IdType id, bool isDefault) override{
auto &handlers = (isDefault ? defaultHandlers_ : handlers_);
if (handlers.empty())
throw Exception::InvalidId();
for (auto it = handlers.begin(); it != handlers.end(); ++it){
if (it->first == id){
handlers.erase(it);
return;
}
}
throw Exception::InvalidId();
}
template <typename ReturnT>
IdType Add(const std::function<ReturnT(ObjectT &)> &callback, bool isDefault){
auto &handlers = (isDefault ? defaultHandlers_ : handlers_);
handlers.push_back(std::make_pair<IdType, HandlerType>(IdType(), std::make_shared<TypedHandler<ReturnT, ObjectT>>(callback)));
return (handlers.rbegin()->first = reinterpret_cast<IdType>(&*handlers.rbegin()));
}
template <typename ReturnT>
IdType Add(const std::function<ReturnT(const ObjectT &)> &callback, bool isDefault){
return Add<ReturnT>([=](ObjectT &e){
callback(e);
});
}
virtual void Call(ObjectT &object, bool isDefault){
auto handlers = (isDefault ? defaultHandlers_ : handlers_);
for (auto &hnadler : handlers){
hnadler.second->Call(object);
if (object.States | State::StopListening)
Remove(hnadler.first, isDefault);
if (object.States | State::StopPropagation)
break;//Propagation stopped
}
}
protected:
HandlerListType handlers_;
HandlerListType defaultHandlers_;
};
struct DefaultDispatcher{
static std::pair<LRESULT, StateValueType> Trigger(Target &owner);
};
template <class TargetT>
class Collection : public Thread::Context{
public:
using TargetType = TargetT;
using IdType = Bucket::IdType;
using BucketType = std::shared_ptr<Bucket>;
explicit Collection(TargetT &owner)
: owner_(owner){}
template <typename CallbackT>
IdType operator +=(const CallbackT &callback){
return Add_(callback, false);
}
void operator -=(IdType id){
Remove_(id, false);
}
template <typename ObjectT>
void Dispatch(ObjectT &object) const{
Use([&]{
auto bucket = GetBucket_<ObjectT>();
bucket->Call(object, false);
if (bucket.get() == defaultBucket_.get() && !(object.States | State::StopPropagation)){
auto resultInfo = DefaultDispatcher::Trigger(owner_);//Dispatch default event object
if ((resultInfo.second & State::ValueSet) != 0)
object.Result = resultInfo.first;//Override result
if ((resultInfo.second & State::PreventDefault) != 0)
object.States += State::PreventDefault;//Forward default prevention
}
object.DoDefault();
});
}
template <typename ObjectT>
void DispatchDefault(ObjectT &object) const{
Use([&]{
GetBucket_<ObjectT>()->Call(object, true);
});
}
template <typename ObjectT, typename... ArgsTypes>
std::pair<LRESULT, StateValueType> Trigger(ArgsTypes &&... args) const{
return TriggerAs<LRESULT, ObjectT>(args...);
}
template <typename ReturnT, typename ObjectT, typename... ArgsTypes>
std::pair<ReturnT, StateValueType> TriggerAs(ArgsTypes &&... args) const{
ObjectT object(owner_, std::forward<ArgsTypes>(args)...);
Dispatch(object);
return std::make_pair<ReturnT, StateValueType>(object.Result, object.States);
}
template <typename ObjectT, typename... ArgsTypes>
bool TriggerAndReportPreventDefault(ArgsTypes &&... args) const{
return ((TriggerAs<LRESULT, ObjectT>(args...).second & State::PreventDefault) != 0u);
}
template <typename ObjectT, typename ResultT, typename... ArgsTypes>
bool TriggerAndCompareResult(ResultT result, ArgsTypes &&... args) const{
return (TriggerAs<ResultT, ObjectT>(args...).first == result);
}
protected:
template <typename T>
std::shared_ptr<TypedBucket<std::remove_reference_t<T>>> GetBucket_() const{
for (auto bucket : buckets_){
auto compatible = std::dynamic_pointer_cast<TypedBucket<std::remove_reference_t<T>>>(bucket);
if (compatible)
return compatible;
}
throw Exception::UnsupportedType();
}
template <typename CallbackT>
IdType Add_(const CallbackT &callback, bool isDefault){
using ReturnType = typename Core::Traits::Functor<CallbackT>::ReturnType;
using ObjectType = typename Core::Traits::Functor<CallbackT>::Args::template At<0>::Type;
using BaseObjectType = std::remove_cv_t<std::conditional_t<std::is_same_v<ObjectType, Core::Traits::NotAType>, DefaultObject, ObjectType>>;
return Use([&]{
auto bucket = GetBucket_<BaseObjectType>();
auto id = dynamic_cast<TypedBucket<std::remove_reference_t<BaseObjectType>> *>(bucket.get())->Add<ReturnType>(callback, isDefault);
refs_[id] = bucket;
return id;
});
}
void Remove_(IdType id, bool isDefault){
Use([&]{
if (refs_.empty())
throw Exception::InvalidId();
auto it = refs_.find(id);
if (it == refs_.end())
throw Exception::InvalidId();
it->second->Remove(id, isDefault);
refs_.erase(it);
});
}
TargetT &owner_;
BucketType defaultBucket_;
std::list<BucketType> buckets_;
std::unordered_map<IdType, BucketType> refs_;
};
template <class OwnerT>
class OwnedCollection : public Collection<OwnerT>{
public:
using OwnerType = OwnerT;
using BaseType = Collection<OwnerT>;
using IdType = typename BaseType::IdType;
using BucketType = typename BaseType::BucketType;
using BaseType::BaseType;
protected:
friend OwnerT;
template <typename ObjectT>
void AddBucket_(bool isDefault){
AddBucket_(std::make_shared<TypedBucket<ObjectT>>(isDefault));
}
void AddBucket_(BucketType bucket){
BaseType::buckets_.push_back(bucket);
if (bucket->IsDefault()){
BaseType::defaultBucket_ = bucket;
try{
BaseType::template GetBucket_<DefaultObject>();
}
catch (const Exception::UnsupportedType &){
AddBucket_<DefaultObject>(false);
}
}
}
template <typename CallbackT>
IdType AddDefault_(const CallbackT &callback){
return BaseType::Add_(callback, true);
}
void RemoveDefault_(IdType id){
BaseType::Remove_(id, true);
}
};
}
| [
"benbraide@yahoo.com"
] | benbraide@yahoo.com |
d535e3f0695af24509e428881a95508db04017c6 | 4f344dd6034de9d0fcb23928baaf2e6f0db7d842 | /Critical Mass/Source Files/OptionsMenu.cpp | 256cb8146328e127d76c080685a5b093e8e0d888 | [] | no_license | ianalcid08/FinalProject2 | 9e5d20bd489b5a5edf9cbc140f8f4ceef764a696 | 1666302e3e426b49c95fabfd63d1d0e1dad2d0ac | refs/heads/master | 2016-09-06T03:02:47.264788 | 2014-02-25T00:44:36 | 2014-02-25T00:44:36 | 17,156,022 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 77,074 | cpp | #include "../Header Files/stdafx.h"
#include "../Header Files/OptionsMenu.h"
/*****************************************************************
File name: OptionsMenu.cpp
Date: 7/17/13
Modify Date: 08/13/13
Modify Initials: CM
Author: Ian Alcid
Purpose: Class for Options state.
******************************************************************/
#include "../Header Files/Input.h"
#include "../Header Files/Game.h"
#include "../Header Files/Renderer.h"
#include "../Header Files/AssetManager.h"
#include "../../Includes/Sound/Source/AudioSystemWwise.h"
#include "../../Includes/Sound/Source/Wwise_IDs.h"
#include "../Header Files/PauseState.h"
#include <fstream>
#include <string>
using namespace std;
COptionsState* COptionsState::GetInstance( void )
{
static COptionsState s_Instance;
return &s_Instance;
}
COptionsState::COptionsState( void )
{
this->SetClosing(false);
m_Switch = false;
}
COptionsState::~COptionsState( void )
{
Shutdown();
}
// IState Functions
void COptionsState::Init( CGame* _game )
{
//LoadOptions( "volume.txt" );
this->m_Game = _game;
this->m_Renderer = m_Game->GetRenderer();
this->m_Choice = 0;
this->m_AM = CAssetManager::GetInstance();
m_MusicVolume = 3;
AudioSystemWwise::GetInstance()->SetRTCPValue(AK::GAME_PARAMETERS::MX_VOLUME, (float)m_MusicVolume * 10.0f);
m_SFXVolume = 3;
AudioSystemWwise::GetInstance()->SetRTCPValue(AK::GAME_PARAMETERS::SFX_VOLUME, (float)m_SFXVolume * 10.0f);
AudioSystemWwise::GetInstance()->SetRTCPValue(AK::GAME_PARAMETERS::DX_VOLUME, (float)m_SFXVolume * 10.0f);
m_bMouseActive = false;
m_PrevMousePosX= 0;
m_PrevMousePosY= 0;
//m_bExit = true;
m_bGamma = true;
m_bMusic = false;
m_bSFX = true;
m_bMouse = true;
m_bDefault = true;
m_bResolution = true;
m_bLeftArrow = true;
m_bRightArrow = true;
m_bCancel = true;
m_bAccept = true;
m_bGamepad = true;
//m_bEnable = false;
m_Timer = 0.0f;
m_FadeTimer = 0.0f;
m_bFadeOut = false;
m_HDC = m_Game->GetHDC();
SetID( OPTIONS_STATE );
}
bool COptionsState::Input( CInput& _input )
{
_input.ReadMouse();
_input.ReadKeyboard();
float _max, _min, _length, _unit;
_min = m_OMElements[OM_BAR_ELEMENT1].GetPosX();
static bool ifPressedD_Options = false;
static bool ifPressedU_Options = false;
static bool ifPressedEnter_Options = false;
static bool ifLeftClickBack_Options = false;
static bool ifLeftClickDefault_Options = false;
static bool ifLeftClickGamma_Options = false;
static bool ifLeftClickMusic_Options = false;
static bool ifLeftClickSFX_Options = false;
static bool ifLeftClickMouse_Options = false;
static bool ifLeftClickAccept_Options = false;
static bool ifLeftClickGamePad_Options = false;
static bool ifLeftClickEnable_Options = false;
// Updates the reticle location based on the mouse pos.
m_reticle.SetPosX(_input.GetMousePosX() - m_reticle.GetRect().GetWidth() * 0.5f);
m_reticle.SetPosY(_input.GetMousePosY() - m_reticle.GetRect().GetHeight() * 0.5f);
m_reticle.BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
//Mouse Active over keybard
if(_input.GetMousePosX() == m_PrevMousePosX && _input.GetMousePosY() == m_PrevMousePosY)
{
m_bMouseActive = false;
}
if(_input.GetMousePosX() != m_PrevMousePosX)
{
m_bMouseActive = true;
m_PrevMousePosX = _input.GetMousePosX();
}
if(_input.GetMousePosY() != m_PrevMousePosY)
{
m_bMouseActive = true;
m_PrevMousePosY = _input.GetMousePosY();
}
//Esc (EXIT THE PROGRAM)
static bool ifPressedEsc_Cred = false;
if(!ifPressedEsc_Cred)
{
ifPressedEsc_Cred = true;
if(_input.KeyDown(DIK_ESCAPE))
{
m_bFadeOut = true;
return true;
}
}
else
ifPressedEsc_Cred = false;
//TODO: where you do the shit to move the bar around, just turn the bool back off for the buffering so as long as you are holding it down and are in the box or w.e. it will work
//MOUSE INPUT FOR SELECTING BUTTONS----------------------------------------------------------------------
#pragma region Mouse Input for Selecting Buttons
int _mouseX = _input.GetMousePosX();
int _mouseY = _input.GetMousePosY();
//ENABLE BUTTON
float _enableWidth1 = m_OMElements[OM_GAMEPAD_ELEMENT].GetRect().GetWidth(); //256
float _enableHeight1 = m_OMElements[OM_GAMEPAD_ELEMENT].GetRect().GetHeight(); //64
float _enablePosX1 = m_OMElements[OM_GAMEPAD_ELEMENT].GetPosX(); //280
float _enablePosY1 = m_OMElements[OM_GAMEPAD_ELEMENT].GetPosY(); //612
float _enableCombinedX1 = _enablePosX1 + _enableWidth1; //536
float _enableCombinedY1 = _enablePosY1 + _enableHeight1; //676
if (_input.IsLeftClicked())
{
if (!ifLeftClickEnable_Options)
{
ifLeftClickEnable_Options = true;
if (_mouseX >= _enablePosX1 && _mouseX <= _enableCombinedX1 && _mouseY <= _enableCombinedY1 && _mouseY >= _enablePosY1)
{
if (m_Timer > 0.5f)
{
m_bEnable = !m_bEnable;
m_Game->SetUsingController(m_bEnable);
AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_SFX_MENU_ACCEPT);
}
}
}
}
else
ifLeftClickEnable_Options = false;
//CANCEL BUTTON
float _backWidth1 = m_OMElements[OM_CANCEL_ELEMENT].GetRect().GetWidth(); //256
float _backHeight1 = m_OMElements[OM_CANCEL_ELEMENT].GetRect().GetHeight(); //64
float _backPosX1 = m_OMElements[OM_CANCEL_ELEMENT].GetPosX(); //280
float _backPosY1 = m_OMElements[OM_CANCEL_ELEMENT].GetPosY(); //612
float _backCombinedX1 = _backPosX1 + _backWidth1; //536
float _bacKCombinedY1 = _backPosY1 + _backHeight1; //676
if (_input.IsLeftClicked())
{
if (!ifLeftClickBack_Options)
{
ifLeftClickBack_Options = true;
if (_mouseX >= _backPosX1 && _mouseX <= _backCombinedX1 && _mouseY <= _bacKCombinedY1 && _mouseY >= _backPosY1)
{
if (m_Timer > 0.5f)
{
m_bFadeOut = true;
AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_SFX_MENU_ACCEPT);
}
}
}
}
else
ifLeftClickBack_Options = false;
if (_mouseX >= _backPosX1 && _mouseX <= _backCombinedX1 && _mouseY <= _bacKCombinedY1 && _mouseY >= _backPosY1)
{
if (m_FadeTimer <= 1.0f && !m_bFadeOut) //Fadded in, set to 0, and not FadeOut.
{
if (m_bMouseActive)
{
m_Choice = OM_CANCEL;
if (m_bSoundCancel)
{
AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_SFX_MENU_HOVER);
}
}
}
}
//GAMEPAD BUTTON
float _gamepadWidth1 = m_OMElements[OM_GAMEPAD_ELEMENT].GetRect().GetWidth(); //256
float _gamepadHeight1 = m_OMElements[OM_GAMEPAD_ELEMENT].GetRect().GetHeight(); //64
float _gamepadPosX1 = m_OMElements[OM_GAMEPAD_ELEMENT].GetPosX(); //280
float _gamepadPosY1 = m_OMElements[OM_GAMEPAD_ELEMENT].GetPosY() - 5.0f; //612
float _gamepadCombinedX1 = _gamepadPosX1 + _gamepadWidth1; //536
float _gamepadCombinedY1 = _gamepadPosY1 + _gamepadHeight1; //676
if (_input.IsLeftClicked())
{
if (!ifLeftClickGamePad_Options)
{
ifLeftClickGamePad_Options = true;
if (_mouseX >= _gamepadPosX1 && _mouseX <= _gamepadCombinedX1 && _mouseY <= _gamepadCombinedY1 && _mouseY >= _gamepadPosY1)
{
if (m_Timer > 0.5f)
{
AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_SFX_MENU_ACCEPT);
}
}
}
}
else
ifLeftClickGamePad_Options = false;
if (_mouseX >= _gamepadPosX1 && _mouseX <= _gamepadCombinedX1 && _mouseY <= _gamepadCombinedY1 && _mouseY >= _gamepadPosY1)
{
if (m_FadeTimer <= 1.0f && !m_bFadeOut) //Fadded in, set to 0, and not FadeOut.
{
if (m_bMouseActive)
{
m_Choice = OM_GAMEPAD;
if (m_bSoundGamePad)
{
AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_SFX_MENU_HOVER);
}
}
}
}
//ACCEPT BUTTON
float _acceptWidth1 = m_OMElements[OM_ACCEPT_ELEMENT].GetRect().GetWidth(); //256
float _acceptHeight1 = m_OMElements[OM_ACCEPT_ELEMENT].GetRect().GetHeight(); //64
float _acceptPosX1 = m_OMElements[OM_ACCEPT_ELEMENT].GetPosX(); //280
float _acceptPosY1 = m_OMElements[OM_ACCEPT_ELEMENT].GetPosY(); //612
float _acceptCombinedX1 = _acceptPosX1 + _acceptWidth1; //536
float _acceptCombinedY1 = _acceptPosY1 + _acceptHeight1; //676
if (_input.IsLeftClicked())
{
if (!ifLeftClickAccept_Options)
{
ifLeftClickAccept_Options = true;
if (_mouseX >= _acceptPosX1 && _mouseX <= _acceptCombinedX1 && _mouseY <= _acceptCombinedY1 && _mouseY >= _acceptPosY1)
{
if ( m_Timer > 0.5f )
{
m_bFadeOut = true;
AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_SFX_MENU_ACCEPT);
if( m_Renderer->GetFullScreen() )
{
POINT xy = m_Renderer->GetAvailableResolutions()[m_nResolutionIndex];
m_Game->ChangeResolution( xy.x, xy.y );
}
}
}
}
}
else
ifLeftClickAccept_Options = false;
if (_mouseX >= _acceptPosX1 && _mouseX <= _acceptCombinedX1 && _mouseY <= _acceptCombinedY1 && _mouseY >= _acceptPosY1)
{
if (m_FadeTimer <= 1.0f && !m_bFadeOut) //Fadded in, set to 0, and not FadeOut.
{
if (m_bMouseActive)
{
m_Choice = OM_ACCEPT;
if (m_bSoundAccept)
{
AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_SFX_MENU_HOVER);
}
}
}
}
//DEFAULT BUTTON
float _defaultWidth1 = m_OMElements[OM_DEFAULT_ELEMENT].GetRect().GetWidth();
float _defaultHeight1 = m_OMElements[OM_DEFAULT_ELEMENT].GetRect().GetHeight();
float _defaultPosX1 = m_OMElements[OM_DEFAULT_ELEMENT].GetPosX();
float _defaultPosY1 = m_OMElements[OM_DEFAULT_ELEMENT].GetPosY();
float _defaultCombinedX1 = _defaultPosX1 + _defaultWidth1;
float _defaultCombinedY1 = _defaultPosY1 + _defaultHeight1;
if (_input.IsLeftClicked())
{
if (!ifLeftClickDefault_Options)
{
ifLeftClickDefault_Options = true;
if (_mouseX >= _defaultPosX1 && _mouseX <= _defaultCombinedX1 && _mouseY <= _defaultCombinedY1 && _mouseY >= _defaultPosY1)
{
if (m_Timer > 0.5f)
{
if (m_bSoundClick)
{
AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_SFX_MENU_ACCEPT);
m_bSoundClick = false;
}
m_bEnable = false;
ResetDefault(m_Game);
}
}
}
}
else
ifLeftClickDefault_Options = false;
if (_mouseX >= _defaultPosX1 && _mouseX <= _defaultCombinedX1 && _mouseY <= _defaultCombinedY1 && _mouseY >= _defaultPosY1)
{
if (m_FadeTimer <= 1.0f && !m_bFadeOut) //Fadded in, set to 0, and not FadeOut.
{
if (m_bMouseActive)
{
m_bDefault = false;
m_Choice = OM_DEFAULT;
}
}
}
//GAMMA BUTTON
float _gammaWidth1 = m_OMElements[OM_GAMMA_HIGHLIGHTED_ELEMENT].GetRect().GetWidth(); //256
float _gammaHeight1 = m_OMElements[OM_GAMMA_HIGHLIGHTED_ELEMENT].GetRect().GetHeight(); //64
float _gammaPosX1 = m_OMElements[OM_GAMMA_HIGHLIGHTED_ELEMENT].GetPosX(); //280
float _gammaPosY1 = m_OMElements[OM_GAMMA_HIGHLIGHTED_ELEMENT].GetPosY(); //612
float _gammaCombinedX1 = _gammaPosX1 + _gammaWidth1 + m_OMElements[OM_BAR_ELEMENT3].GetRect().GetWidth(); //536
float _gammaCombinedY1 = _gammaPosY1 + _gammaHeight1; //676
if (_mouseX >= _gammaPosX1 && _mouseX <= _gammaCombinedX1 && _mouseY <= _gammaCombinedY1 && _mouseY >= _gammaPosY1)
{
if (m_FadeTimer <= 1.0f && !m_bFadeOut)
{
if (m_bMouseActive)
{
ifLeftClickGamma_Options = true;
m_Choice = OM_GAMMA;
}
}
}
//MUSIC BUTTON
float _musicWidth1 = m_OMElements[OM_MUSIC_HIGHLIGHTED_ELEMENT].GetRect().GetWidth(); //256
float _musicHeight1 = m_OMElements[OM_MUSIC_HIGHLIGHTED_ELEMENT].GetRect().GetHeight(); //64
float _musicPosX1 = m_OMElements[OM_MUSIC_HIGHLIGHTED_ELEMENT].GetPosX(); //280
float _musicPosY1 = m_OMElements[OM_MUSIC_HIGHLIGHTED_ELEMENT].GetPosY(); //612
float _musicCombinedX1 = _musicPosX1 + _musicWidth1 + m_OMElements[OM_BAR_ELEMENT1].GetRect().GetWidth(); //the whole bar area
float _musicCombinedY1 = _musicPosY1 + _musicHeight1; //676
if (_mouseX >= _musicPosX1 && _mouseX <= _musicCombinedX1 && _mouseY <= _musicCombinedY1 && _mouseY >= _musicPosY1)
{
if (m_FadeTimer <= 1.0f && !m_bFadeOut)
{
if (m_bMouseActive)
{
m_bMusic = false;
m_Choice = OM_MUSIC;
}
}
}
//SFX BUTTON
float _SFXWidth1 = m_OMElements[OM_SFX_HIGHLIGHTED_ELEMENT].GetRect().GetWidth(); //256
float _SFXHeight1 = m_OMElements[OM_SFX_HIGHLIGHTED_ELEMENT].GetRect().GetHeight(); //64
float _SFXPosX1 = m_OMElements[OM_SFX_HIGHLIGHTED_ELEMENT].GetPosX(); //280
float _SFXPosY1 = m_OMElements[OM_SFX_HIGHLIGHTED_ELEMENT].GetPosY(); //612
float _SFXCombinedX1 = _SFXPosX1 + _SFXWidth1 + m_OMElements[OM_BAR_ELEMENT2].GetRect().GetWidth(); //alot
float _SFXCombinedY1 = _SFXPosY1 + _SFXHeight1; //676
if (_mouseX >= _SFXPosX1 && _mouseX <= _SFXCombinedX1 && _mouseY <= _SFXCombinedY1 && _mouseY >= _SFXPosY1)
{
if (m_FadeTimer <= 1.0f && !m_bFadeOut)
{
if (m_bMouseActive)
{
m_bSFX = false;
m_Choice = OM_SFX;
}
}
}
//RESOLUTION BUTTON
float _ResolutionWidth1 = m_OMElements[OM_RESOLUTION_HIGHLIGHT_ELEMENT].GetRect().GetWidth(); //256
float _ResolutionHeight1 = m_OMElements[OM_RESOLUTION_HIGHLIGHT_ELEMENT].GetRect().GetHeight(); //64
float _ResolutionPosX1 = m_OMElements[OM_RESOLUTION_HIGHLIGHT_ELEMENT].GetPosX(); //280
float _ResolutionPosY1 = m_OMElements[OM_RESOLUTION_HIGHLIGHT_ELEMENT].GetPosY(); //612
float _ResolutionCombinedX1 = _ResolutionPosX1 + _ResolutionWidth1;// + m_OMElements[OM_BAR_ELEMENT2].GetRect().GetWidth(); //alot
float _ResolutionCombinedY1 = _ResolutionPosY1 + _ResolutionHeight1; //676
if (_mouseX >= _ResolutionPosX1 && _mouseX <= _ResolutionCombinedX1 && _mouseY <= _ResolutionCombinedY1 && _mouseY >= _ResolutionPosY1)
{
if (m_FadeTimer <= 1.0f && !m_bFadeOut)
{
if (m_bMouseActive)
{
m_bResolution = false;
m_Choice = OM_RESOLUTION;
}
}
}
if( m_Renderer->GetFullScreen() )
{
//RESOLUTION LEFT ARROW
float _LeftArrowWidth1 = m_OMElements[OM_LEFTARROW_ELEMENT].GetRect().GetWidth();
float _LeftArrowHeight1 = m_OMElements[OM_LEFTARROW_ELEMENT].GetRect().GetHeight();
float _LeftArrowPosX1 = m_OMElements[OM_LEFTARROW_ELEMENT].GetPosX();
float _LeftArrowPosY1 = m_OMElements[OM_LEFTARROW_ELEMENT].GetPosY();
float _LeftArrowCombinedX1 = _LeftArrowPosX1 + _LeftArrowWidth1;
float _LeftArrowCombinedY1 = _LeftArrowPosY1 + _LeftArrowHeight1;
if (_mouseX >= _LeftArrowPosX1 && _mouseX <= _LeftArrowCombinedX1 && _mouseY <= _LeftArrowCombinedY1 && _mouseY >= _LeftArrowPosY1)
{
if (m_FadeTimer <= 1.0f && !m_bFadeOut)
{
if (m_bMouseActive)
{
m_bLeftArrow = false;
m_Choice = OM_LEFTARROW;
}
}
if (_input.IsLeftClicked())
{
if (m_Timer > 0.5f && m_ResolutionChangeTimer < 0.0f)
{
AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_SFX_MENU_ACCEPT);
--m_nResolutionIndex;
if( m_nResolutionIndex < 0 )
m_nResolutionIndex = m_Renderer->GetAvailableResolutions().size() - 1;
m_ResolutionChangeTimer = 0.25f;
}
}
}
//RESOLUTION RIGHT ARROW
float _RightArrowWidth1 = m_OMElements[OM_RIGHTARROW_ELEMENT].GetRect().GetWidth();
float _RightArrowHeight1 = m_OMElements[OM_RIGHTARROW_ELEMENT].GetRect().GetHeight();
float _RightArrowPosX1 = m_OMElements[OM_RIGHTARROW_ELEMENT].GetPosX();
float _RightArrowPosY1 = m_OMElements[OM_RIGHTARROW_ELEMENT].GetPosY();
float _RightArrowCombinedX1 = _RightArrowPosX1 + _RightArrowWidth1;
float _RightArrowCombinedY1 = _RightArrowPosY1 + _RightArrowHeight1;
if (_mouseX >= _RightArrowPosX1 && _mouseX <= _RightArrowCombinedX1 && _mouseY <= _RightArrowCombinedY1 && _mouseY >= _RightArrowPosY1)
{
if (m_FadeTimer <= 1.0f && !m_bFadeOut)
{
if (m_bMouseActive)
{
m_bRightArrow = false;
m_Choice = OM_RIGHTARROW;
}
}
if (_input.IsLeftClicked())
{
if (m_Timer > 0.5f && m_ResolutionChangeTimer < 0.0f)
{
AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_SFX_MENU_ACCEPT);
++m_nResolutionIndex;
if( m_nResolutionIndex >= (int)m_Renderer->GetAvailableResolutions().size() )
m_nResolutionIndex = 0;
m_ResolutionChangeTimer = 0.25f;
}
}
}
}
//MOUSE SE BUTTON
//float _MouseWidth1 = m_OMElements[OM_MOUSE_HIGHLIGHTED_ELEMENT].GetRect().GetWidth(); //256
//float _MouseHeight1 = m_OMElements[OM_MOUSE_HIGHLIGHTED_ELEMENT].GetRect().GetHeight(); //64
//float _MousePosX1 = m_OMElements[OM_MOUSE_HIGHLIGHTED_ELEMENT].GetPosX(); //280
//float _MousePosY1 = m_OMElements[OM_MOUSE_HIGHLIGHTED_ELEMENT].GetPosY(); //612
//float _MouseCombinedX1 = _MousePosX1 + _MouseWidth1 + m_OMElements[OM_BAR_ELEMENT4].GetRect().GetWidth();
//float _MouseCombinedY1 = _MousePosY1 + _MouseHeight1; //676
//if (_mouseX >= _MousePosX1 && _mouseX <= _MouseCombinedX1 && _mouseY <= _MouseCombinedY1 && _mouseY >= _MousePosY1)
//{
// if (m_FadeTimer <= 1.0f && !m_bFadeOut)
// {
// if (m_bMouseActive)
// {
// m_bMouse = false;
// m_Choice = OM_MOUSE;
// }
// }
//}
int CheckChoice = m_Choice;
if (m_Choice == OM_CANCEL)
{
if (m_bSoundCancel)
{
AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_SFX_MENU_HOVER);
m_bSoundCancel = false;
m_bSoundMusic = true;
m_bSoundSFX = true;
m_bSoundMouse = true;
m_bSoundGamma = true;
m_bSoundDefault = true;
m_bSoundClick = true;
m_bSoundResolution = true;
m_bSoundAccept = true;
m_bSoundGamePad = true;
}
}
if (m_Choice == OM_GAMEPAD)
{
if (m_bSoundGamePad)
{
AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_SFX_MENU_HOVER);
m_bSoundGamePad = false;
m_bSoundCancel = true;
m_bSoundMusic = true;
m_bSoundSFX = true;
m_bSoundMouse = true;
m_bSoundGamma = true;
m_bSoundDefault = true;
m_bSoundClick = true;
m_bSoundResolution = true;
m_bSoundAccept = true;
}
}
if (m_Choice == OM_ACCEPT)
{
if (m_bSoundAccept)
{
AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_SFX_MENU_HOVER);
m_bSoundCancel = true;
m_bSoundMusic = true;
m_bSoundSFX = true;
m_bSoundMouse = true;
m_bSoundGamma = true;
m_bSoundDefault = true;
m_bSoundClick = true;
m_bSoundResolution = true;
m_bSoundAccept = false;
m_bSoundGamePad = true;
}
}
if (m_Choice == OM_MUSIC)
{
if (m_bSoundMusic)
{
AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_SFX_MENU_HOVER);
m_bSoundCancel = true;
m_bSoundMusic = false;
m_bSoundSFX = true;
m_bSoundMouse = true;
m_bSoundGamma = true;
m_bSoundDefault = true;
m_bSoundClick = true;
m_bSoundResolution = true;
m_bSoundAccept = true;
m_bSoundGamePad = true;
}
}
if (m_Choice == OM_GAMMA)
{
if (m_bSoundGamma)
{
AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_SFX_MENU_HOVER);
m_bSoundCancel = true;
m_bSoundMusic = true;
m_bSoundSFX = true;
m_bSoundMouse = true;
m_bSoundGamma = false;
m_bSoundDefault = true;
m_bSoundClick = true;
m_bSoundResolution = true;
m_bSoundAccept = true;
m_bSoundGamePad = true;
}
}
if (m_Choice == OM_SFX)
{
if (m_bSoundSFX)
{
AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_SFX_MENU_HOVER);
m_bSoundCancel = true;
m_bSoundMusic = true;
m_bSoundSFX = false;
m_bSoundMouse = true;
m_bSoundGamma = true;
m_bSoundDefault = true;
m_bSoundClick = true;
m_bSoundResolution = true;
m_bSoundAccept = true;
m_bSoundGamePad = true;
}
}
if (m_Choice == OM_DEFAULT)
{
if (m_bSoundDefault)
{
AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_SFX_MENU_HOVER);
m_bSoundCancel = true;
m_bSoundMusic = true;
m_bSoundSFX = true;
m_bSoundMouse = true;
m_bSoundGamma = true;
m_bSoundDefault = false;
m_bSoundClick = true;
m_bSoundResolution = true;
m_bSoundAccept = true;
m_bSoundGamePad = true;
}
}
/*if (m_Choice == OM_MOUSE)
{
if (m_bSoundMouse)
{
AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_SFX_MENU_HOVER);
m_bSoundCancel = true;
m_bSoundMusic = true;
m_bSoundSFX = true;
m_bSoundMouse = false;
m_bSoundGamma = true;
m_bSoundDefault = true;
m_bSoundClick = true;
m_bSoundResolution = true;
m_bSoundAccept = true;
m_bSoundGamePad = true;
}
}*/
if (m_Choice == OM_RESOLUTION)
{
if (m_bSoundResolution)
{
AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_SFX_MENU_HOVER);
m_bSoundCancel = true;
m_bSoundMusic = true;
m_bSoundSFX = true;
m_bSoundMouse = true;
m_bSoundGamma = true;
m_bSoundDefault = true;
m_bSoundClick = true;
m_bSoundResolution = false;
m_bSoundAccept = true;
m_bSoundGamePad = true;
}
}
if (m_Choice == OM_LEFTARROW)
{
if (m_bSoundResolution)
{
AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_SFX_MENU_HOVER);
m_bSoundCancel = true;
m_bSoundMusic = true;
m_bSoundSFX = true;
m_bSoundMouse = true;
m_bSoundGamma = true;
m_bSoundDefault = true;
m_bSoundClick = true;
m_bSoundResolution = false;
m_bSoundAccept = true;
m_bSoundGamePad = true;
}
}
if (m_Choice == OM_RIGHTARROW)
{
if (m_bSoundResolution)
{
AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_SFX_MENU_HOVER);
m_bSoundCancel = true;
m_bSoundMusic = true;
m_bSoundSFX = true;
m_bSoundMouse = true;
m_bSoundGamma = true;
m_bSoundDefault = true;
m_bSoundClick = true;
m_bSoundResolution = false;
m_bSoundAccept = true;
m_bSoundGamePad = true;
}
}
#pragma endregion
//KEYBOARD INPUT ----------------------------------------------------------------------------------------
#pragma region Keyboard Input for Selecting Buttons
if(_input.KeyDown(DIK_S) || _input.KeyDown(DIK_DOWNARROW) || _input.GetController().GetControllerState().Gamepad.sThumbLY < - 8000 || _input.GetController().GetControllerState().Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_DOWN )
{
if (m_FadeTimer <= 1.0f && !m_bFadeOut)
{
if(!ifPressedD_Options)
{
m_Choice++;
if(!m_Game->GetRenderer()->GetFullScreen())
{
if( m_Choice == OM_RESOLUTION )
m_Choice = OM_ACCEPT;
}
if(m_Choice == OM_NUM_CHOICES)
{
m_Choice = OM_MUSIC;
}
ifPressedD_Options = true;
}
}
}
else
ifPressedD_Options = false;
if(_input.KeyDown(DIK_W) || _input.KeyDown(DIK_UPARROW) ||_input.GetController().GetControllerState().Gamepad.sThumbLY > 8000 || _input.GetController().GetControllerState().Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_UP)
{
if (m_FadeTimer <= 1.0f && !m_bFadeOut)
{
if(!ifPressedU_Options)
{
m_Choice--;
if(!m_Game->GetRenderer()->GetFullScreen())
{
if( m_Choice == OM_RIGHTARROW )
m_Choice = OM_GAMEPAD;
}
if(m_Choice < 0)
{
m_Choice = OM_CANCEL;
}
ifPressedU_Options = true;
}
}
}
else
ifPressedU_Options = false;
//SELECTED (ENTER PRESSED)
if (m_Timer > 0.5f)
{
if(_input.KeyDown(DIK_RETURN) || (_input.GetController().GetControllerState().Gamepad.wButtons & XINPUT_GAMEPAD_A) )
{
if (m_FadeTimer <= 1.0f && !m_bFadeOut)
{
if(!ifPressedEnter_Options)
{
AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_SFX_MENU_ACCEPT);
if (m_Choice == OM_CANCEL)
{
ResetDefault(m_Game);
m_bFadeOut = true;
}
if (m_Choice == OM_DEFAULT)
ResetDefault(m_Game);
if (m_Choice == OM_ACCEPT)
{
m_bFadeOut = true;
if( m_Renderer->GetFullScreen() )
{
POINT xy = m_Renderer->GetAvailableResolutions()[m_nResolutionIndex];
m_Game->ChangeResolution( xy.x, xy.y );
}
}
if (m_Choice == OM_GAMEPAD)
{
m_Game->SetUsingController(m_bEnable);
m_bEnable = !m_bEnable;
}
if( m_Choice == OM_LEFTARROW )
{
--m_nResolutionIndex;
if( m_nResolutionIndex < 0 )
m_nResolutionIndex = m_Renderer->GetAvailableResolutions().size() - 1;
}
if( m_Choice == OM_RIGHTARROW )
{
++m_nResolutionIndex;
if( m_nResolutionIndex >= (int)m_Renderer->GetAvailableResolutions().size() )
m_nResolutionIndex = 0;
}
ifPressedEnter_Options = true;
}
}
}
else
ifPressedEnter_Options = false;
}
#pragma endregion
//KEYBOARD INPUT LEFT / RIGHT ---------------------------------------------------------------------------
#pragma region Keyboard Input for Control Slider
static bool pressed = false;
if(_input.KeyDown(DIK_D) || _input.KeyDown(DIK_RIGHTARROW) ||_input.GetController().GetControllerState().Gamepad.sThumbLY > 8000 || _input.GetController().GetControllerState().Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_RIGHT)
{
if( !pressed )
{
if (m_Choice == OM_MUSIC)
{
pressed = true;
m_MusicVolume++;
//set sound
AudioSystemWwise::GetInstance()->SetRTCPValue(AK::GAME_PARAMETERS::MX_VOLUME, (float)m_MusicVolume * 10.0f);
//CSoundManager::GetInstance()->SetVolume(AK::GAME_PARAMETERS::MX_VOLUME, (float)m_MusicVolume * 10.0f);
if (this->m_MusicVolume <= 0)
{
m_OMElements[OM_SLIDER_ELEMENT1].SetPosX(_min - 15 * (m_Renderer->GetScreenHeight() / 720.0f));
m_OMElements[OM_SLIDER_ELEMENT1].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
}
if (this->m_MusicVolume > 9)
{
this->m_MusicVolume = 9;
m_OMElements[OM_SLIDER_ELEMENT1].SetPosX(550* (m_Renderer->GetScreenHeight() / 720.0f));
m_OMElements[OM_SLIDER_ELEMENT1].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
AudioSystemWwise::GetInstance()->SetRTCPValue(AK::GAME_PARAMETERS::MX_VOLUME, (float)m_MusicVolume * 10.0f);
//CSoundManager::GetInstance()->SetVolume(AK::GAME_PARAMETERS::MX_VOLUME, (float)m_MusicVolume * 10.0f);
}
}
if (m_Choice == OM_SFX)
{
m_SFXVolume++;
pressed = true;
//set sound
AudioSystemWwise::GetInstance()->SetRTCPValue(AK::GAME_PARAMETERS::SFX_VOLUME, (float)m_SFXVolume * 10.0f);
AudioSystemWwise::GetInstance()->SetRTCPValue(AK::GAME_PARAMETERS::DX_VOLUME, (float)m_SFXVolume * 10.0f);
if (this->m_SFXVolume <= 0)
{
m_OMElements[OM_SLIDER_ELEMENT2].SetPosX(_min - 15* (m_Renderer->GetScreenHeight() / 720.0f));
m_OMElements[OM_SLIDER_ELEMENT2].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
}
if (this->m_SFXVolume > 9)
{
this->m_SFXVolume = 9;
m_OMElements[OM_SLIDER_ELEMENT2].SetPosX(550* (m_Renderer->GetScreenHeight() / 720.0f));
m_OMElements[OM_SLIDER_ELEMENT2].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
}
}
if (m_Choice == OM_GAMMA)
{
m_Gamma++;
pressed = true;
//set sound
// AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_FX_2D_MENUBACKUP);
if (this->m_Gamma <= 0)
{
m_OMElements[OM_SLIDER_ELEMENT3].SetPosX(_min - 15* (m_Renderer->GetScreenHeight() / 720.0f));
m_OMElements[OM_SLIDER_ELEMENT3].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
}
if (this->m_Gamma > 9)
{
this->m_Gamma = 9;
m_OMElements[OM_SLIDER_ELEMENT3].SetPosX(550* (m_Renderer->GetScreenHeight() / 720.0f));
m_OMElements[OM_SLIDER_ELEMENT3].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
}
}
//if (m_Choice == OM_MOUSE)
//{
// m_MouseSen++;
// pressed = true;
// // AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_FX_2D_MENUBACKUP);
// if (this->m_MouseSen <= 0)
// {
// m_OMElements[OM_SLIDER_ELEMENT4].SetPosX(_min - 15* (m_Renderer->GetScreenHeight() / 720.0f));
// m_OMElements[OM_SLIDER_ELEMENT4].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
// }
// if (this->m_MouseSen > 9)
// {
// this->m_MouseSen = 9;
// m_OMElements[OM_SLIDER_ELEMENT4].SetPosX(550* (m_Renderer->GetScreenHeight() / 720.0f));
// m_OMElements[OM_SLIDER_ELEMENT4].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
// }
//}
}
}
else
pressed = false;
static bool pressed1 = false;
if(_input.KeyDown(DIK_A) || _input.KeyDown(DIK_LEFTARROW) ||_input.GetController().GetControllerState().Gamepad.sThumbLY > 8000 || _input.GetController().GetControllerState().Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_LEFT)
{
if( !pressed1 )
{
if (m_Choice == OM_MUSIC)
{
pressed1 = true;
m_MusicVolume--;
//set sound
AudioSystemWwise::GetInstance()->SetRTCPValue(AK::GAME_PARAMETERS::MX_VOLUME, (float)m_MusicVolume * 10.0f);
if (this->m_MusicVolume <= 0)
{
this->m_MusicVolume = 0;
m_OMElements[OM_SLIDER_ELEMENT1].SetPosX(_min - 15* (m_Renderer->GetScreenHeight() / 720.0f));
m_OMElements[OM_SLIDER_ELEMENT1].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
}
if (this->m_MusicVolume > 9)
{
this->m_MusicVolume = 9;
m_OMElements[OM_SLIDER_ELEMENT1].SetPosX(550* (m_Renderer->GetScreenHeight() / 720.0f));
m_OMElements[OM_SLIDER_ELEMENT1].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
AudioSystemWwise::GetInstance()->SetRTCPValue(AK::GAME_PARAMETERS::MX_VOLUME, (float)m_MusicVolume * 10.0f);
}
}
if (m_Choice == OM_SFX)
{
pressed1 = true;
m_SFXVolume--;
//set sound
AudioSystemWwise::GetInstance()->SetRTCPValue(AK::GAME_PARAMETERS::SFX_VOLUME, (float)m_SFXVolume * 10.0f);
AudioSystemWwise::GetInstance()->SetRTCPValue(AK::GAME_PARAMETERS::DX_VOLUME, (float)m_SFXVolume * 10.0f);
// AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_FX_2D_MENUBACKUP);
if (this->m_SFXVolume <= 0)
{
this->m_SFXVolume = 0;
m_OMElements[OM_SLIDER_ELEMENT2].SetPosX(_min - 15* (m_Renderer->GetScreenHeight() / 720.0f));
m_OMElements[OM_SLIDER_ELEMENT2].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
}
if (this->m_SFXVolume > 9)
{
this->m_SFXVolume = 9;
m_OMElements[OM_SLIDER_ELEMENT2].SetPosX(550* (m_Renderer->GetScreenHeight() / 720.0f));
m_OMElements[OM_SLIDER_ELEMENT2].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
}
}
if (m_Choice == OM_GAMMA)
{
pressed1 = true;
m_Gamma--;
//set sound
// AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_FX_2D_MENUBACKUP);
if (this->m_Gamma <= 0)
{
this->m_Gamma = 0;
m_OMElements[OM_SLIDER_ELEMENT3].SetPosX(_min - 15* (m_Renderer->GetScreenHeight() / 720.0f));
m_OMElements[OM_SLIDER_ELEMENT3].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
}
if (this->m_Gamma > 9)
{
this->m_Gamma = 9;
m_OMElements[OM_SLIDER_ELEMENT3].SetPosX(550* (m_Renderer->GetScreenHeight() / 720.0f));
m_OMElements[OM_SLIDER_ELEMENT3].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
}
}
//if (m_Choice == OM_MOUSE)
//{
// pressed1 = true;
// m_MouseSen--;
// //set sound
// /// AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_FX_2D_MENUBACKUP);
// if (this->m_MouseSen <= 0)
// {
// this->m_MouseSen = 0;
// m_OMElements[OM_SLIDER_ELEMENT4].SetPosX(_min - 15* (m_Renderer->GetScreenHeight() / 720.0f));
// m_OMElements[OM_SLIDER_ELEMENT4].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
// }
// if (this->m_MouseSen > 9)
// {
// this->m_MouseSen = 9;
// m_OMElements[OM_SLIDER_ELEMENT4].SetPosX(550* (m_Renderer->GetScreenHeight() / 720.0f));
// m_OMElements[OM_SLIDER_ELEMENT4].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
// }
//}
}
}
else
pressed1 = false;
#pragma endregion
if (m_Choice == OM_SFX)
{
m_bSFX = false;
m_bMusic = true;
m_bGamma = true;
m_bMouse = true;
m_bCancel = true;
m_bDefault = true;
m_bResolution = true;
m_bAccept = true;
m_bGamepad = true;
m_bLeftArrow = true;
m_bRightArrow = true;
}
if (m_Choice == OM_GAMEPAD)
{
m_bSFX = true;
m_bMusic = true;
m_bGamma = true;
m_bMouse = true;
m_bCancel = true;
m_bDefault = true;
m_bResolution = true;
m_bAccept = true;
m_bGamepad = false;
m_bLeftArrow = true;
m_bRightArrow = true;
}
if (m_Choice == OM_ACCEPT)
{
m_bSFX = true;
m_bMusic = true;
m_bGamma = true;
m_bMouse = true;
m_bCancel = true;
m_bDefault = true;
m_bResolution = true;
m_bAccept = false;
m_bGamepad = true;
m_bLeftArrow = true;
m_bRightArrow = true;
}
if (m_Choice == OM_MUSIC)
{
m_bSFX = true;
m_bMusic = false;
m_bGamma = true;
m_bMouse = true;
m_bCancel = true;
m_bDefault = true;
m_bResolution = true;
m_bAccept = true;
m_bGamepad = true;
m_bLeftArrow = true;
m_bRightArrow = true;
}
if (m_Choice == OM_GAMMA)
{
m_bSFX = true;
m_bMusic = true;
m_bGamma = false;
m_bMouse = true;
m_bCancel = true;
m_bDefault = true;
m_bResolution = true;
m_bAccept = true;
m_bGamepad = true;
m_bLeftArrow = true;
m_bRightArrow = true;
}
/*if (m_Choice == OM_MOUSE)
{
m_bSFX = true;
m_bMusic = true;
m_bGamma = true;
m_bMouse = false;
m_bCancel = true;
m_bDefault = true;
m_bResolution = true;
m_bAccept = true;
m_bGamepad = true;
m_bLeftArrow = true;
m_bRightArrow = true;
}*/
if (m_Choice == OM_CANCEL)
{
m_bSFX = true;
m_bMusic = true;
m_bGamma = true;
m_bMouse = true;
m_bCancel = false;
m_bDefault = true;
m_bResolution = true;
m_bAccept = true;
m_bGamepad = true;
m_bLeftArrow = true;
m_bRightArrow = true;
}
if (m_Choice == OM_DEFAULT)
{
m_bSFX = true;
m_bMusic = true;
m_bGamma = true;
m_bMouse = true;
m_bCancel = true;
m_bDefault = false;
m_bResolution = true;
m_bAccept = true;
m_bGamepad = true;
m_bLeftArrow = true;
m_bRightArrow = true;
}
if (m_Choice == OM_RESOLUTION)
{
m_bSFX = true;
m_bMusic = true;
m_bGamma = true;
m_bMouse = true;
m_bCancel = true;
m_bDefault = true;
m_bResolution = false;
m_bAccept = true;
m_bGamepad = true;
m_bLeftArrow = true;
m_bRightArrow = true;
}
if (m_Choice == OM_LEFTARROW)
{
m_bSFX = true;
m_bMusic = true;
m_bGamma = true;
m_bMouse = true;
m_bCancel = true;
m_bDefault = true;
m_bResolution = true;
m_bAccept = true;
m_bGamepad = true;
m_bLeftArrow = false;
m_bRightArrow = true;
}
if (m_Choice == OM_RIGHTARROW)
{
m_bSFX = true;
m_bMusic = true;
m_bGamma = true;
m_bMouse = true;
m_bCancel = true;
m_bDefault = true;
m_bResolution = true;
m_bAccept = true;
m_bGamepad = true;
m_bLeftArrow = true;
m_bRightArrow = false;
}
//BUTTONS ----------------------------------------------------------------------------------------------
#pragma region Mouse Input Sliders
//MOUSE INPUT SLIDER MUSIC-------------------------------------------------------------------------------------------------------------------------------------------------------
float _sliderWidth1 = m_OMElements[OM_SLIDER_ELEMENT1].GetRect().GetWidth(); //44
float _sliderHeight1 = m_OMElements[OM_SLIDER_ELEMENT1].GetRect().GetHeight(); //44
float _barWidth1 = m_OMElements[OM_BAR_ELEMENT1].GetRect().GetWidth(); //408
float _barHeight1 = m_OMElements[OM_BAR_ELEMENT1].GetRect().GetHeight(); //44
float _barPosX1 = m_OMElements[OM_BAR_ELEMENT1].GetPosX(); //550
float _barPosY1 = m_OMElements[OM_BAR_ELEMENT1].GetPosY(); //108
float _units1 = _barWidth1 / 10.0f; //40.799999
float _barCombinedX1 = _barPosX1 + _barWidth1; //958
float _barCombinedY1 = _barPosY1 + _barHeight1; //152
if (_input.IsLeftClicked() && _mouseX > _barPosX1 && _mouseX < _barCombinedX1 && _mouseY > _barPosY1 && _mouseY < _barCombinedY1 && !ifLeftClickSFX_Options && !ifLeftClickGamma_Options )// && !ifLeftClickSFX_Options && !ifLeftClickGamma_Options)
{
//if (!ifLeftClickMusic_Options)
//{
ifLeftClickMusic_Options = true;
if (m_FadeTimer <= 1.0f && !m_bFadeOut) //BUFFER TO MAKE SURE IT DOESNT JUMP INTO THIS FROM ANOTHER MENU
{
//if (_mouseX >= _barPosX1 && _mouseX <= _barCombinedX1 && _mouseY <= _barCombinedY1 && _mouseY >= _barPosY1) //INSIDE THE BUTTON LOCATION
//{
for (int i = 0; i < 10; i++) //THE 10 SLOTS
{
if (_mouseX >= _barPosX1 + _units1 * i) //Pos Mouse + the Unit (length on the bar) * the number (1 - 10)
{
testCounter++;
m_OMElements[OM_SLIDER_ELEMENT1].SetPosX((float)_input.GetMousePosX()); //Draw the slider on screen
m_OMElements[OM_SLIDER_ELEMENT1].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
this->m_MusicVolume = i; //MusicVol = the number (1-10)
AudioSystemWwise::GetInstance()->SetRTCPValue(AK::GAME_PARAMETERS::MX_VOLUME, (float)m_MusicVolume * 10.0f);
if(!playThisFrickinSoundOnce)
{
// AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_FX_2D_MENUBACKUP);
playThisFrickinSoundOnce = true;
}
}
}
//}
}
//}
}
else if (!_input.IsLeftClicked())
{
ifLeftClickMusic_Options = false;
playThisFrickinSoundOnce = false;
}
//MOUSE INPUT SLIDER 2-------------------------------------------------------------------------------------------------------------------------------------------------------
float _sliderWidth2 = m_OMElements[OM_SLIDER_ELEMENT2].GetRect().GetWidth(); //44
float _sliderHeight2 = m_OMElements[OM_SLIDER_ELEMENT2].GetRect().GetHeight(); //44
float _barWidth2 = m_OMElements[OM_BAR_ELEMENT2].GetRect().GetWidth(); //408
float _barHeight2 = m_OMElements[OM_BAR_ELEMENT2].GetRect().GetHeight(); //44
float _barPosX2 = m_OMElements[OM_BAR_ELEMENT2].GetPosX(); //550
float _barPosY2 = m_OMElements[OM_BAR_ELEMENT2].GetPosY(); //108
float _units2 = _barWidth2 / 10.0f; //40.799999
float _barCombinedX2 = _barPosX2 + _barWidth1; //958
float _barCombinedY2 = _barPosY2 + _barHeight1; //152
if (_input.IsLeftClicked() && _mouseX > _barPosX2 && _mouseX < _barCombinedX2 && _mouseY > _barPosY2 && _mouseY < _barCombinedY2 && !ifLeftClickMusic_Options && !ifLeftClickGamma_Options)
{
//if (!ifLeftClickSFX_Options ) //&& !ifLeftClickMusic_Options && !ifLeftClickGamma_Options)
//{
ifLeftClickSFX_Options = true;
if (m_FadeTimer <= 1.0f && !m_bFadeOut)
{
if (_mouseX >= _barPosX2 && _mouseX <= _barCombinedX2 && _mouseY <= _barCombinedY2 && _mouseY >= _barPosY2)
{
for (int i = 0; i < 10; i++)
{
if (_mouseX >= _barPosX2 + _units2 * i)
{
m_OMElements[OM_SLIDER_ELEMENT2].SetPosX((float)_input.GetMousePosX());
m_OMElements[OM_SLIDER_ELEMENT2].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
this->m_SFXVolume = i;
AudioSystemWwise::GetInstance()->SetRTCPValue(AK::GAME_PARAMETERS::SFX_VOLUME, (float)m_SFXVolume * 10.0f);
AudioSystemWwise::GetInstance()->SetRTCPValue(AK::GAME_PARAMETERS::DX_VOLUME, (float)m_SFXVolume * 10.0f);
if(!playThisFrickinSoundOnce)
{
// AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_FX_2D_KLAXON_LOOP);
playThisFrickinSoundOnce = true;
}
}
}
}
}
//}
}
else if(!_input.IsLeftClicked())
{
ifLeftClickSFX_Options = false;
playThisFrickinSoundOnce = false;
// AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::STOP_FX_2D_KLAXON_LOOP);
}
//MOUSE INPUT SLIDER 3-------------------------------------------------------------------------------------------------------------------------------------------------------
float _sliderWidth3 = m_OMElements[OM_SLIDER_ELEMENT3].GetRect().GetWidth(); //44
float _sliderHeight3 = m_OMElements[OM_SLIDER_ELEMENT3].GetRect().GetHeight(); //44
float _barWidth3 = m_OMElements[OM_BAR_ELEMENT3].GetRect().GetWidth(); //408
float _barHeight3 = m_OMElements[OM_BAR_ELEMENT3].GetRect().GetHeight(); //44
float _barPosX3 = m_OMElements[OM_BAR_ELEMENT3].GetPosX(); //550
float _barPosY3 = m_OMElements[OM_BAR_ELEMENT3].GetPosY(); //108
float _units3 = _barWidth3 / 10.0f; //40.799999
float _barCombinedX3 = _barPosX3 + _barWidth3; //958
float _barCombinedY3 = _barPosY3 + _barHeight3; //152
if (_input.IsLeftClicked() && _mouseX >= _barPosX3 && _mouseX <= _barCombinedX3 && _mouseY <= _barCombinedY3 && _mouseY >= _barPosY3 && !ifLeftClickMusic_Options && !ifLeftClickSFX_Options )
{
//if (!ifLeftClickGamma_Options)
//{
ifLeftClickGamma_Options = true;
if (m_FadeTimer <= 1.0f && !m_bFadeOut)
{
if (_mouseX >= _barPosX3 && _mouseX <= _barCombinedX3 && _mouseY <= _barCombinedY3 && _mouseY >= _barPosY3)
{
for (int i = 0; i < 10; i++)
{
if (_mouseX >= _barPosX3 + _units3 * i)
{
m_OMElements[OM_SLIDER_ELEMENT3].SetPosX((float)_input.GetMousePosX());
m_OMElements[OM_SLIDER_ELEMENT3].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
this->m_Gamma = i;
if(!playThisFrickinSoundOnce)
{
/// AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_FX_2D_MENUBACKUP);
playThisFrickinSoundOnce = true;
}
}
}
}
}
//}
}
else if (!_input.IsLeftClicked())
{
ifLeftClickGamma_Options = false;
playThisFrickinSoundOnce = false;
}
//MOUSE INPUT SLIDER 4-------------------------------------------------------------------------------------------------------------------------------------------------------
//float _sliderWidth4 = m_OMElements[OM_SLIDER_ELEMENT4].GetRect().GetWidth(); //44
//float _sliderHeight4 = m_OMElements[OM_SLIDER_ELEMENT4].GetRect().GetHeight(); //44
//float _barWidth4 = m_OMElements[OM_BAR_ELEMENT4].GetRect().GetWidth(); //408
//float _barHeight4 = m_OMElements[OM_BAR_ELEMENT4].GetRect().GetHeight(); //44
//float _barPosX4 = m_OMElements[OM_BAR_ELEMENT4].GetPosX(); //550
//float _barPosY4 = m_OMElements[OM_BAR_ELEMENT4].GetPosY(); //108
//float _units4 = _barWidth4 / 10.0f; //40.799999
//float _barCombinedX4 = _barPosX4 + _barWidth4; //958
//float _barCombinedY4 = _barPosY4 + _barHeight4; //152
//if (_input.IsLeftClicked() && _mouseX >= _barPosX4 && _mouseX <= _barCombinedX4 && _mouseY <= _barCombinedY4 && _mouseY >= _barPosY4)
//{
// //if (!ifLeftClickMouse_Options)
// //{
// ifLeftClickMouse_Options = true;
// if (m_FadeTimer <= 1.0f && !m_bFadeOut)
// {
// if (_mouseX >= _barPosX4 && _mouseX <= _barCombinedX4 && _mouseY <= _barCombinedY4 && _mouseY >= _barPosY4)
// {
// for (int i = 0; i < 10; i++)
// {
// if (_mouseX >= _barPosX4 + _units4 * i)
// {
// m_OMElements[OM_SLIDER_ELEMENT4].SetPosX((float)_input.GetMousePosX());
// m_OMElements[OM_SLIDER_ELEMENT4].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
// this->m_MouseSen = i;
// if(!playThisFrickinSoundOnce)
// {
// // AudioSystemWwise::GetInstance()->PostEvent(AK::EVENTS::PLAY_FX_2D_MENUBACKUP);
// playThisFrickinSoundOnce = true;
// }
// }
// }
// }
// }
// //}
//}
else if (!_input.IsLeftClicked())
{
ifLeftClickMouse_Options = false;
playThisFrickinSoundOnce = false;
}
#pragma endregion
//SETTING SLIDER ON X -----------------------------------------------------------------------------------
#pragma region Setting Slider on X
//start:
_min = m_OMElements[OM_BAR_ELEMENT1].GetPosX();
_max = m_OMElements[OM_BAR_ELEMENT1].GetPosX() + 408;
_length = _max - _min;
_unit = _length / 10.0f; //40.7999999
if (this->m_MusicVolume > 9)
this->m_MusicVolume = 9;
else
this->m_SliderX1 = _min;
this->m_SliderY1 = m_OMElements[OM_SLIDER_ELEMENT1].GetPosY();
m_OMElements[OM_SLIDER_ELEMENT1].SetPosX(this->m_SliderX1 + _unit * m_MusicVolume * (m_Renderer->GetScreenHeight() / 720.0f));
m_OMElements[OM_SLIDER_ELEMENT1].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
this->m_SliderX2 = _min;
this->m_SliderY2 = m_OMElements[OM_SLIDER_ELEMENT2].GetPosY();
m_OMElements[OM_SLIDER_ELEMENT2].SetPosX(this->m_SliderX2 + _unit * m_SFXVolume * (m_Renderer->GetScreenHeight() / 720.0f));
m_OMElements[OM_SLIDER_ELEMENT2].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
this->m_SliderX3 = _min;
this->m_SliderY3 = m_OMElements[OM_SLIDER_ELEMENT3].GetPosY();
m_OMElements[OM_SLIDER_ELEMENT3].SetPosX(this->m_SliderX3 + _unit * m_Gamma * (m_Renderer->GetScreenHeight() / 720.0f));
m_OMElements[OM_SLIDER_ELEMENT3].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
//this->m_SliderX4 = _min;
//this->m_SliderY4 = m_OMElements[OM_SLIDER_ELEMENT4].GetPosY();
//m_OMElements[OM_SLIDER_ELEMENT4].SetPosX(this->m_SliderX4 + _unit * m_MouseSen);
//m_OMElements[OM_SLIDER_ELEMENT4].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
#pragma endregion
return true;
}
void COptionsState::FadeIn (float _fTime)
{
m_FadeTimer -= _fTime;//count up to 1
for(int i = 0; i < OM_NUM_ELEMENTS; ++i)
m_OMElements[i].SetOpacity(1.0f - m_FadeTimer); // set the Opacity to that timer
for( unsigned int i = 0, n = m_UIResolution.size(); i < n; ++i )
m_UIResolution[i]->SetOpacity( 1.0f - m_FadeTimer );
if (m_FadeTimer <= 0.0f)
m_FadeTimer = 0.0f;
}
void COptionsState::FadeOut (float _fTime)
{
m_FadeTimer += _fTime; //count down to 0
for(int i = 0; i < OM_NUM_ELEMENTS; ++i)
m_OMElements[i].SetOpacity(1.0f - m_FadeTimer); // set the Opacity to that timer
for( unsigned int i = 0, n = m_UIResolution.size(); i < n; ++i )
m_UIResolution[i]->SetOpacity( 1.0f - m_FadeTimer );
}
void COptionsState::ResetDefault ( CGame* _game )
{
m_Game = _game;
m_MusicVolume = 3;
AudioSystemWwise::GetInstance()->SetRTCPValue(AK::GAME_PARAMETERS::MX_VOLUME, (float)m_MusicVolume * 10.0f);
m_SFXVolume = 3;
AudioSystemWwise::GetInstance()->SetRTCPValue(AK::GAME_PARAMETERS::SFX_VOLUME, (float)m_SFXVolume * 10.0f);
AudioSystemWwise::GetInstance()->SetRTCPValue(AK::GAME_PARAMETERS::DX_VOLUME, (float)m_SFXVolume * 10.0f);
m_Gamma = 3;
m_MouseSen = 4;
m_HDC = m_Game->GetHDC();
m_OMElements[OM_SLIDER_ELEMENT4].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
m_OMElements[OM_SLIDER_ELEMENT3].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
m_OMElements[OM_SLIDER_ELEMENT2].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
m_OMElements[OM_SLIDER_ELEMENT1].BuildGeometry(m_Renderer->GetScreenWidth(), m_Renderer->GetScreenHeight());
}
void COptionsState::Update( float _fElapsedTime )
{
this->m_Timer += _fElapsedTime;
m_ResolutionChangeTimer -= _fElapsedTime;
CGame::Gamma( m_Gamma, m_GammaArray, m_HDC);
int tempSens;
tempSens = (m_MouseSen+1)*2;
SystemParametersInfo(SPI_SETMOUSESPEED, 0,(void*)&tempSens, SPIF_SENDCHANGE);
if(!m_bFadeOut && m_FadeTimer <= 1.0f)
{
this->FadeIn(_fElapsedTime);
}
if (m_bFadeOut)
{
this->FadeOut(_fElapsedTime);
}
//Time to leave options IF you are fading out and it has faded all the way to 0.0f
if(m_bFadeOut && m_FadeTimer >= 1.0f)
{
this->SetClosing(true);
return;
}
// Yay all hacky resolution stuff
if( m_Renderer->GetFullScreen() )
{
if( m_bCheckResolution )
{
for( unsigned int i = 0, n = m_Renderer->GetAvailableResolutions().size(); i < n; ++i )
{
if( m_Renderer->GetAvailableResolutions()[i].x == m_Renderer->GetScreenWidth() &&
m_Renderer->GetAvailableResolutions()[i].y == m_Renderer->GetScreenHeight() )
{
m_nResolutionIndex = i;
m_bCheckResolution = false;
break;
}
}
}
for( unsigned int i = 0, n = m_UIResolution.size(); i < n; ++i )
{
m_UIResolution[i]->ReleaseGLBatch();
delete m_UIResolution[i];
}
m_UIResolution.clear();
int screenWidth = (int)m_Renderer->GetAvailableResolutions()[m_nResolutionIndex].x;
int screenHeight = (int)m_Renderer->GetAvailableResolutions()[m_nResolutionIndex].y;
Vec4f white = { 1.0f, 1.0f, 1.0f, 1.0f };
CUIElement* temp = nullptr;
float x = m_OMElements[OM_BAR_ELEMENT1].GetPosX();
float y = m_OMElements[OM_RESOLUTION_HIGHLIGHT_ELEMENT].GetPosY();
float offset = 24.0f * (m_Renderer->GetScreenHeight() / 720.0f);
float scale = 0.5f;
unsigned int texture = OM_NUMBER_0;
x += 64.0f * (m_Renderer->GetScreenHeight() / 720.0f);
if( screenWidth / 1000 )
{
temp = new CUIElement();
texture = OM_NUMBER_0 + screenWidth / 1000;
if( texture > OM_NUMBER_0 + 9 ) // only 0 - 9
texture = OM_NUMBER_0 + 9;
// Chop off the leftmost number
screenWidth -= (screenWidth / 1000) * 1000;
temp->Setup( m_Renderer, m_AM->GetTexture( texture ), RECTANGLE( 0.0f, 48.0f, 0.0f, 64.0f ),
x,
y,
0.0f, scale, white );
temp->SetOpacity( 1.0f - m_FadeTimer );
m_UIResolution.push_back( temp );
x += offset;
}
// 100s place - width
temp = new CUIElement();
texture = OM_NUMBER_0 + screenWidth / 100;
if( texture > OM_NUMBER_0 + 9 ) // only 0 - 9
texture = OM_NUMBER_0 + 9;
// Chop off the leftmost number
screenWidth -= (screenWidth / 100) * 100;
temp->Setup( m_Renderer, m_AM->GetTexture( texture ), RECTANGLE( 0.0f, 48.0f, 0.0f, 64.0f ),
x,
y,
0.0f, scale, white );
temp->SetOpacity( 1.0f - m_FadeTimer );
m_UIResolution.push_back( temp );
x += offset;
// 10s place - width
temp = new CUIElement();
texture = OM_NUMBER_0 + screenWidth / 10;
if( texture > OM_NUMBER_0 + 9 ) // only 0 - 9
texture = OM_NUMBER_0 + 9;
// Chop off the leftmost number
screenWidth -= (screenWidth / 10) * 10;
temp->Setup( m_Renderer, m_AM->GetTexture( texture ), RECTANGLE( 0.0f, 48.0f, 0.0f, 64.0f ),
x,
y,
0.0f, scale, white );
temp->SetOpacity( 1.0f - m_FadeTimer );
m_UIResolution.push_back( temp );
x += offset;
// 1s place - width
temp = new CUIElement();
texture = OM_NUMBER_0 + screenWidth;
if( texture > OM_NUMBER_0 + 9 ) // only 0 - 9
texture = OM_NUMBER_0 + 9;
temp->Setup( m_Renderer, m_AM->GetTexture( texture ), RECTANGLE( 0.0f, 48.0f, 0.0f, 64.0f ),
x,
y,
0.0f, scale, white );
temp->SetOpacity( 1.0f - m_FadeTimer );
m_UIResolution.push_back( temp );
x += offset;
// SPACE
x += offset;
// The 'X' in the middle
temp = new CUIElement();
temp->Setup( m_Renderer, m_AM->GetTexture( OM_NUMBER_X ), RECTANGLE( 0.0f, 48.0f, 0.0f, 64.0f ),
x,
y,
0.0f, scale, white );
temp->SetOpacity( 1.0f - m_FadeTimer );
m_UIResolution.push_back( temp );
x += offset;
// SPACE
x += offset;
if( screenHeight / 1000 )
{
temp = new CUIElement();
texture = OM_NUMBER_0 + screenHeight / 1000;
if( texture > OM_NUMBER_0 + 9 ) // only 0 - 9
texture = OM_NUMBER_0 + 9;
// Chop off the leftmost number
screenHeight -= (screenHeight / 1000) * 1000;
temp->Setup( m_Renderer, m_AM->GetTexture( texture ), RECTANGLE( 0.0f, 48.0f, 0.0f, 64.0f ),
x,
y,
0.0f, scale, white );
temp->SetOpacity( 1.0f - m_FadeTimer );
m_UIResolution.push_back( temp );
x += offset;
}
// 100s place - height
temp = new CUIElement();
texture = OM_NUMBER_0 + screenHeight / 100;
if( texture > OM_NUMBER_0 + 9 ) // only 0 - 9
texture = OM_NUMBER_0 + 9;
// Chop off the leftmost number
screenHeight -= (screenHeight / 100) * 100;
temp->Setup( m_Renderer, m_AM->GetTexture( texture ), RECTANGLE( 0.0f, 48.0f, 0.0f, 64.0f ),
x,
y,
0.0f, scale, white );
temp->SetOpacity( 1.0f - m_FadeTimer );
m_UIResolution.push_back( temp );
x += offset;
// 10s place - height
temp = new CUIElement();
texture = OM_NUMBER_0 + screenHeight / 10;
if( texture > OM_NUMBER_0 + 9 ) // only 0 - 9
texture = OM_NUMBER_0 + 9;
// Chop off the leftmost number
screenHeight -= (screenHeight / 10) * 10;
temp->Setup( m_Renderer, m_AM->GetTexture( texture ), RECTANGLE( 0.0f, 48.0f, 0.0f, 64.0f ),
x,
y,
0.0f, scale, white );
temp->SetOpacity( 1.0f - m_FadeTimer );
m_UIResolution.push_back( temp );
x += offset;
// 1s place - height
temp = new CUIElement();
texture = OM_NUMBER_0 + screenHeight;
if( texture > OM_NUMBER_0 + 9 ) // only 0 - 9
texture = OM_NUMBER_0 + 9;
temp->Setup( m_Renderer, m_AM->GetTexture( texture ), RECTANGLE( 0.0f, 48.0f, 0.0f, 64.0f ),
x,
y,
0.0f, scale, white );
temp->SetOpacity( 1.0f - m_FadeTimer );
m_UIResolution.push_back( temp );
}
}
void COptionsState::Enter()
{
m_nResolutionIndex = m_Renderer->GetAvailableResolutions().size() - 1;
m_bCheckResolution = true;
m_ResolutionChangeTimer = 0.0f;
testCounter = 0;
playThisFrickinSoundOnce = false;
//ShowCursor(TRUE);
SetClosing(false);
m_bMouseActive = false;
m_PrevMousePosX= 0;
m_PrevMousePosY= 0;
this->m_Renderer = m_Game->GetRenderer();
this->m_Choice = 0;
this->m_AM = CAssetManager::GetInstance();
m_FadeTimer = 1.0f;
m_Timer = 0.0f;
m_bFadeOut = false;
m_Choice = 0;
//m_bSoundExit = true;
m_bSoundMusic = true;
m_bSoundSFX = true;
m_bSoundMouse = true;
m_bSoundDefault = true;
m_bSoundGamma = true;
m_bSoundClick = true;
m_bSoundResolution = true;
m_bSoundCancel = true;
m_bSoundAccept = true;
m_bSoundGamePad = true;
m_bSoundEnable = true;
ResetDefault( m_Game );
LoadOptions( L"\\volume.bin" );
AudioSystemWwise::GetInstance()->SetRTCPValue(AK::GAME_PARAMETERS::SFX_VOLUME, (float)m_SFXVolume * 10.0f);
AudioSystemWwise::GetInstance()->SetRTCPValue(AK::GAME_PARAMETERS::MX_VOLUME, (float)m_MusicVolume * 10.0f);
AudioSystemWwise::GetInstance()->SetRTCPValue(AK::GAME_PARAMETERS::DX_VOLUME, (float)m_SFXVolume * 10.0f);
if(m_Enable == 0)
m_bEnable = false;
else
m_bEnable = true;
m_Game->SetUsingController(m_bEnable);
//BLACK BACKGROUND
Vec4f white = { 1.0f, 1.0f, 1.0f, 1.0f };
m_OMElements[OM_BLACK_BACKGROUND_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(M_BLACK_BACKGROUND),
RECTANGLE(0.0f, (float)m_Game->GetScreenWidth(), 0.0f, float(m_Game->GetScreenHeight())), 0.0f, 0.0f, 0.0f, 720.0f / m_Renderer->GetScreenHeight(), white);
//BACKGROUND
#if defined(_DEBUG) || defined(_BETA)
m_OMElements[OM_BACKGROUND_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(M_OPTIONS_BACKGROUND_1024x768),
RECTANGLE(0.0f, (float)m_Game->GetScreenWidth(), 0.0f, float(m_Game->GetScreenHeight())), 0.0f, 0.0f, 0.0f, 720.0f / m_Renderer->GetScreenHeight(), white);
#else
m_OMElements[OM_BACKGROUND_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(M_OPTIONS_BACKGROUND_1280x720),
RECTANGLE(0.0f, (float)m_Game->GetScreenWidth(), 0.0f, float(m_Game->GetScreenHeight())), 0.0f, 0.0f, 0.0f, 720.0f / m_Renderer->GetScreenHeight(), white);
#endif
//BUTTONS ----------------------------------------------------------------------------------------------------
#pragma region Non-Highlighted Buttons
//--------------------------------------------------------------------------------------
m_OMElements[OM_ALL3_ELEMENT].Setup( m_Renderer, CAssetManager::GetInstance()->GetTexture(MENU_ALL3),
RECTANGLE(0.0f, 384.0f, 0.0f, 256.0f),
float((m_Game->GetScreenWidth() / 2) - 440 * (m_Game->GetScreenHeight() / 720.0f)),
((float)m_Game->GetScreenHeight()) - 230 * (m_Game->GetScreenHeight() / 720.0f),
0.0f, 0.5f, white );
m_OMElements[OM_ALL3_CONTROLLER_ELEMENT].Setup( m_Renderer, CAssetManager::GetInstance()->GetTexture(MENU_ALL3_CONTROLLER),
RECTANGLE(0.0f, 384.0f, 0.0f, 256.0f),
float((m_Game->GetScreenWidth() / 2) - 440 * (m_Game->GetScreenHeight() / 720.0f)),
((float)m_Game->GetScreenHeight()) - 240 * (m_Game->GetScreenHeight() / 720.0f),
0.0f, 0.5f, white );
//m_OMElements[OM_MOVE_ELEMENT].Setup( m_Renderer, CAssetManager::GetInstance()->GetTexture(MENU_MOVEMENT),
// RECTANGLE(0.0f, 256.0f, 0.0f, 128.0f),
// float((m_Game->GetScreenWidth() / 2) - 400 * (m_Game->GetScreenHeight() / 720.0f)),
// ((float)m_Game->GetScreenHeight()) - 96 * (m_Game->GetScreenHeight() / 720.0f),
// 0.0f, 0.75f, white );
//m_OMElements[OM_OK_ELEMENT].Setup( m_Renderer, CAssetManager::GetInstance()->GetTexture(MENU_OK),
// RECTANGLE(0.0f, 256.0f, 0.0f, 128.0f),
// float((m_Game->GetScreenWidth() / 2) -96 * (m_Game->GetScreenHeight() / 720.0f)),
// ((float)m_Game->GetScreenHeight()) - 96 * (m_Game->GetScreenHeight() / 720.0f),
// 0.0f, 0.75f, white );
//m_OMElements[OM_BACK_ELEMENT].Setup( m_Renderer, CAssetManager::GetInstance()->GetTexture(MENU_BACK),
// RECTANGLE(0.0f, 256.0f, 0.0f, 128.0f),
// float((m_Game->GetScreenWidth() /2) + 224 * (m_Game->GetScreenHeight() / 720.0f)),
// ((float)m_Game->GetScreenHeight()) -96 * (m_Game->GetScreenHeight() / 720.0f),
// 0.0f, 0.75f, white );
//m_OMElements[OM_MOVE_CONTROLLER_ELEMENT].Setup( m_Renderer, CAssetManager::GetInstance()->GetTexture(MENU_MOVEMENT_CONTROLLER),
// RECTANGLE(0.0f, 256.0f, 0.0f, 128.0f),
// float((m_Game->GetScreenWidth() / 2) -400 * (m_Game->GetScreenHeight() / 720.0f)),
// ((float)m_Game->GetScreenHeight()) - 96 * (m_Game->GetScreenHeight() / 720.0f),
// 0.0f, 0.75f, white );
//m_OMElements[OM_OK_CONTROLLER_ELEMENT].Setup( m_Renderer, CAssetManager::GetInstance()->GetTexture(MENU_OK_CONTROLLER),
// RECTANGLE(0.0f, 256.0f, 0.0f, 128.0f),
// float((m_Game->GetScreenWidth() /2) -96 * (m_Game->GetScreenHeight() / 720.0f)),
// ((float)m_Game->GetScreenHeight()) -96 * (m_Game->GetScreenHeight() / 720.0f),
// 0.0f, 0.75f, white );
//m_OMElements[OM_BACK_CONTROLLER_ELEMENT].Setup( m_Renderer, CAssetManager::GetInstance()->GetTexture(MENU_BACK_CONTROLLER),
// RECTANGLE(0.0f, 256.0f, 0.0f, 128.0f),
// float((m_Game->GetScreenWidth() /2) + 224 * (m_Game->GetScreenHeight() / 720.0f)),
// ((float)m_Game->GetScreenHeight() / 2) -96 * (m_Game->GetScreenHeight() / 720.0f),
// 0.0f, 0.75f, white );
//--------------------------------------------------------------------------------------
m_OMElements[OM_MUSIC_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(BUTTON_MUSIC),
RECTANGLE(0.0f, 256.0f, 0.0f, 64.0f),
float((m_Game->GetScreenWidth() / 2.0f) - 384* (m_Renderer->GetScreenHeight() / 720.0f)), float((m_Game->GetScreenHeight() / 2.0f) - 320* (m_Renderer->GetScreenHeight() / 720.0f)),
0.0f, 1.0f, white);
m_OMElements[OM_SFX_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(BUTTON_SFX),
RECTANGLE(0.0f, 256.0f, 0.0f, 64.0f),
float((m_Game->GetScreenWidth() / 2.0f) - 384* (m_Renderer->GetScreenHeight() / 720.0f)), float((m_Game->GetScreenHeight() / 2.0f) - 256* (m_Renderer->GetScreenHeight() / 720.0f)),
0.0f, 1.0f, white);
m_OMElements[OM_GAMMA_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(BUTTON_GAMMA),
RECTANGLE(0.0f, 256.0f, 0.0f, 64.0f),
float((m_Game->GetScreenWidth() / 2.0f) - 384* (m_Renderer->GetScreenHeight() / 720.0f)), float((m_Game->GetScreenHeight() / 2.0f) - 192* (m_Renderer->GetScreenHeight() / 720.0f)),
0.0f, 1.0f, white);
m_OMElements[OM_MOUSE_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(BUTTON_MOUSE),
RECTANGLE(0.0f, 256.0f, 0.0f, 64.0f),
float((m_Game->GetScreenWidth() / 2.0f) - 384* (m_Renderer->GetScreenHeight() / 720.0f)), float((m_Game->GetScreenHeight() / 2.0f) - 128* (m_Renderer->GetScreenHeight() / 720.0f)),
0.0f, 1.0f, white);
m_OMElements[OM_RESOLUTION_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(BUTTON_RESOLUTION),
RECTANGLE(0.0f, 256.0f, 0.0f, 64.0f),
float((m_Game->GetScreenWidth() / 2.0f) - 384 * (m_Renderer->GetScreenHeight() / 720.0f)), float((m_Game->GetScreenHeight() / 2.0f)),
0.0f, 1.0f, white);
m_OMElements[OM_ACCEPT_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(BUTTON_ACCEPT),
RECTANGLE(0.0f, 256.0f, 0.0f, 64.0f),
float(m_Game->GetScreenWidth() / 2.0f) - 416.0f * (m_Renderer->GetScreenHeight() / 720.0f), float((m_Game->GetScreenHeight() / 2.0f) + 256 * (m_Renderer->GetScreenHeight() / 720.0f)),
0.0f, 1.0f, white);
m_OMElements[OM_DEFAULT_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(BUTTON_DEFAULT),
RECTANGLE(0.0f, 256.0f, 0.0f, 64.0f),
float(m_Game->GetScreenWidth() / 2.0f) - 128.0f * (m_Renderer->GetScreenHeight() / 720.0f), float((m_Game->GetScreenHeight() / 2.0f) + 256 * (m_Renderer->GetScreenHeight() / 720.0f)),
0.0f, 1.0f, white);
m_OMElements[OM_CANCEL_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(BUTTON_CANCEL),
RECTANGLE(0.0f, 256.0f, 0.0f, 64.0f),
float(m_Game->GetScreenWidth() / 2.0f) + 160.0f * (m_Renderer->GetScreenHeight() / 720.0f), float((m_Game->GetScreenHeight() / 2.0f) + 256 * (m_Renderer->GetScreenHeight() / 720.0f)),
0.0f, 1.0f, white);
m_OMElements[OM_GAMEPAD_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(BUTTON_GAMEPAD),
RECTANGLE(0.0f, 256.0f, 0.0f, 64.0f),
float((m_Game->GetScreenWidth() / 2.0f) - 384* (m_Renderer->GetScreenHeight() / 720.0f)), float((m_Game->GetScreenHeight() / 2.0f) - 100 * (m_Renderer->GetScreenHeight() / 720.0f)),
0.0f, 1.0f, white);
m_OMElements[OM_ENABLE_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(BUTTON_ENABLED),
RECTANGLE(0.0f, 256.0f, 0.0f, 64.0f),
float((m_Game->GetScreenWidth() / 2.0f) + 64 * (m_Renderer->GetScreenHeight() / 720.0f)), m_OMElements[OM_GAMEPAD_ELEMENT].GetPosY(),
0.0f, 1.0f, white);
#pragma endregion
//HIGHLIGHTED BUTTONS----------------------------------------------------------------------------------------------------
#pragma region Highlighted buttons
//m_OMElements[OM_BACK_HIGHLIGHTED_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(BUTTON_BACK_HIGHLIGHTED),
// RECTANGLE(0.0f, 256.0f, 0.0f, 64.0f),
// 280.0f * (m_Game->GetScreenHeight() / 720.0f),
// 632.0f * (m_Game->GetScreenHeight() / 720.0f),
// 0.0f, 1.0f, white);
m_OMElements[OM_MUSIC_HIGHLIGHTED_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(BUTTON_MUSIC_HIGHLIGHTED),
RECTANGLE(0.0f, 256.0f, 0.0f, 64.0f),
float((m_Game->GetScreenWidth() / 2.0f) - 384* (m_Renderer->GetScreenHeight() / 720.0f)), float((m_Game->GetScreenHeight() / 2.0f) - 320* (m_Renderer->GetScreenHeight() / 720.0f)),
0.0f, 1.0f, white);
m_OMElements[OM_SFX_HIGHLIGHTED_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(BUTTON_SFX_HIGHLIGHTED),
RECTANGLE(0.0f, 256.0f, 0.0f, 64.0f),
float((m_Game->GetScreenWidth() / 2.0f) - 384* (m_Renderer->GetScreenHeight() / 720.0f)), float((m_Game->GetScreenHeight() / 2.0f) - 256* (m_Renderer->GetScreenHeight() / 720.0f)),
0.0f, 1.0f, white);
m_OMElements[OM_GAMMA_HIGHLIGHTED_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(BUTTON_GAMMA_HIGHLIGHTED),
RECTANGLE(0.0f, 256.0f, 0.0f, 64.0f),
float((m_Game->GetScreenWidth() / 2.0f) - 384* (m_Renderer->GetScreenHeight() / 720.0f)), float((m_Game->GetScreenHeight() / 2.0f) - 192* (m_Renderer->GetScreenHeight() / 720.0f)),
0.0f, 1.0f, white);
m_OMElements[OM_MOUSE_HIGHLIGHTED_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(BUTTON_MOUSE_HIGHLIGHTED),
RECTANGLE(0.0f, 256.0f, 0.0f, 64.0f),
float((m_Game->GetScreenWidth() / 2.0f) - 384* (m_Renderer->GetScreenHeight() / 720.0f)), float((m_Game->GetScreenHeight() / 2.0f) - 128* (m_Renderer->GetScreenHeight() / 720.0f)),
0.0f, 1.0f, white);
m_OMElements[OM_RESOLUTION_HIGHLIGHT_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(BUTTON_RESOLUTION_HIGHLIGHTED),
RECTANGLE(0.0f, 256.0f, 0.0f, 64.0f),
float((m_Game->GetScreenWidth() / 2.0f) - 384* (m_Renderer->GetScreenHeight() / 720.0f)), float((m_Game->GetScreenHeight() / 2.0f)),
0.0f, 1.0f, white);
m_OMElements[OM_ACCEPT_HIGHLIGHTED_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(BUTTON_ACCEPT_HIGHLIGHTED),
RECTANGLE(0.0f, 256.0f, 0.0f, 64.0f),
float(m_Game->GetScreenWidth() / 2.0f) - 416.0f * (m_Renderer->GetScreenHeight() / 720.0f), float((m_Game->GetScreenHeight() / 2.0f) + 256 * (m_Renderer->GetScreenHeight() / 720.0f)),
0.0f, 1.0f, white);
m_OMElements[OM_DEFAULT_HIGHLIGHTED_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(BUTTON_DEFAULT_HIGHLIGHTED),
RECTANGLE(0.0f, 256.0f, 0.0f, 64.0f),
float(m_Game->GetScreenWidth() / 2.0f) - 128.0f * (m_Renderer->GetScreenHeight() / 720.0f), float((m_Game->GetScreenHeight() / 2.0f) + 256 * (m_Renderer->GetScreenHeight() / 720.0f)),
0.0f, 1.0f, white);
m_OMElements[OM_CANCEL_HIGHLIGHTED_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(BUTTON_CANCEL_HIGHLIGHTED),
RECTANGLE(0.0f, 256.0f, 0.0f, 64.0f),
float(m_Game->GetScreenWidth() / 2.0f) + 160.0f * (m_Renderer->GetScreenHeight() / 720.0f), float((m_Game->GetScreenHeight() / 2.0f) + 256 * (m_Renderer->GetScreenHeight() / 720.0f)),
0.0f, 1.0f, white);
m_OMElements[OM_GAMEPAD_HIGHLIGHTED_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(BUTTON_GAMEPAD_HIGHLIGHTED),
RECTANGLE(0.0f, 256.0f, 0.0f, 64.0f),
m_OMElements[OM_GAMEPAD_ELEMENT].GetPosX(), m_OMElements[OM_GAMEPAD_ELEMENT].GetPosY(),
0.0f, 1.0f, white);
m_OMElements[OM_DISABLE_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(BUTTON_DISABLED),
RECTANGLE(0.0f, 256.0f, 0.0f, 64.0f),
float((m_Game->GetScreenWidth() / 2.0f) + 64 * (m_Renderer->GetScreenHeight() / 720.0f)), m_OMElements[OM_GAMEPAD_ELEMENT].GetPosY(),
0.0f, 1.0f, white);
#pragma endregion
//SLIDERS & BARS----------------------------------------------------------------------------------------------------
#pragma region Sliders and Bars
m_OMElements[OM_BAR_ELEMENT1].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(M_SLIDE_BAR),
RECTANGLE(0.0f, 408.0f, 0.0f, 44.0f),
float((m_Game->GetScreenWidth() / 2.0f) + 32* (m_Renderer->GetScreenHeight() / 720.0f)), float((m_Game->GetScreenHeight() / 2.0f) - 304* (m_Renderer->GetScreenHeight() / 720.0f)),
0.0f, 1.0f, white); //RECTANGLE(0.0f, 408.0f, 0.0f, 44.0f), 550.0f, 133.0f, 0.0f, 1.0f, white);
m_OMElements[OM_BAR_ELEMENT2].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(M_SLIDE_BAR),
RECTANGLE(0.0f, 408.0f, 0.0f, 44.0f),
float((m_Game->GetScreenWidth() / 2.0f) + 32* (m_Renderer->GetScreenHeight() / 720.0f)), float((m_Game->GetScreenHeight() / 2.0f) - 240* (m_Renderer->GetScreenHeight() / 720.0f)),
0.0f, 1.0f, white);
m_OMElements[OM_BAR_ELEMENT3].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(M_SLIDE_BAR),
RECTANGLE(0.0f, 408.0f, 0.0f, 44.0f),
float((m_Game->GetScreenWidth() / 2.0f) + 32* (m_Renderer->GetScreenHeight() / 720.0f)), float((m_Game->GetScreenHeight() / 2.0f) - 176* (m_Renderer->GetScreenHeight() / 720.0f)),
0.0f, 1.0f, white);
m_OMElements[OM_BAR_ELEMENT4].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(M_SLIDE_BAR),
RECTANGLE(0.0f, 408.0f, 0.0f, 44.0f),
float((m_Game->GetScreenWidth() / 2.0f) - 425.0f * (m_Renderer->GetScreenHeight() / 720.0f)), float((m_Game->GetScreenHeight() / 2.0f) - 72.0f* (m_Renderer->GetScreenHeight() / 720.0f)),
0.0f, 1.0f, white);
m_OMElements[OM_SLIDER_ELEMENT1].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(M_SLIDE_POINTER),
RECTANGLE(0.0f, 44.0f, 0.0f, 44.0f),
float((m_Game->GetScreenWidth() / 2.0f) + 32* (m_Renderer->GetScreenHeight() / 720.0f)), m_OMElements[OM_BAR_ELEMENT1].GetPosY() - 12.0f* (m_Renderer->GetScreenHeight() / 720.0f),
0.0f, 1.0f, white);
m_OMElements[OM_SLIDER_ELEMENT2].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(M_SLIDE_POINTER),
RECTANGLE(0.0f, 44.0f, 0.0f, 44.0f),
float((m_Game->GetScreenWidth() / 2.0f) + 32* (m_Renderer->GetScreenHeight() / 720.0f)), m_OMElements[OM_BAR_ELEMENT2].GetPosY() - 12.0f* (m_Renderer->GetScreenHeight() / 720.0f),
0.0f, 1.0f, white);
m_OMElements[OM_SLIDER_ELEMENT3].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(M_SLIDE_POINTER),
RECTANGLE(0.0f, 44.0f, 0.0f, 44.0f),
float((m_Game->GetScreenWidth() / 2.0f) + 32* (m_Renderer->GetScreenHeight() / 720.0f)), m_OMElements[OM_BAR_ELEMENT3].GetPosY() - 12.0f* (m_Renderer->GetScreenHeight() / 720.0f),
0.0f, 1.0f, white);
m_OMElements[OM_SLIDER_ELEMENT4].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(M_SLIDE_BAR),
RECTANGLE(0.0f, 408.0f, 0.0f, 44.0f),
float((m_Game->GetScreenWidth() / 2.0f)) + 15.0f, float((m_Game->GetScreenHeight() / 2.0f) - 72.0f * (m_Renderer->GetScreenHeight() / 720.0f)),
0.0f, 1.0f, white);
for(int i = 0; i < OM_NUM_ELEMENTS; ++i)
m_OMElements[i].SetOpacity(0.0f);
#pragma endregion
// For reticle
Vec3f retPos = { m_Game->GetScreenWidth() / 2.0f - 50.0f, m_Game->GetScreenHeight() / 2.0f - 50.0f, 0.0f };
m_reticle.Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(G_RETICULE), RECTANGLE(0.0f, 32, 0.0f, 32), 0.0f, 0.0f, 0.0f, 1.0f, white);
// Left Arrow
m_OMElements[OM_LEFTARROW_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(BUTTON_LEFTARROW),
RECTANGLE(0.0f, 64.0f, 0.0f, 64.0f),
m_OMElements[OM_BAR_ELEMENT1].GetPosX(),
m_OMElements[OM_RESOLUTION_HIGHLIGHT_ELEMENT].GetPosY(),
0.0f, 0.5f, white);
// Right Arrow
m_OMElements[OM_RIGHTARROW_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(BUTTON_RIGHTARROW),
RECTANGLE(0.0f, 64.0f, 0.0f, 64.0f),
m_OMElements[OM_BAR_ELEMENT1].GetPosX() + (m_OMElements[OM_BAR_ELEMENT1].GetRect().right - 32.0f) * (m_Renderer->GetScreenHeight() / 720.0f),
m_OMElements[OM_RESOLUTION_HIGHLIGHT_ELEMENT].GetPosY(),
0.0f, 0.5f, white); // the 32.0f in X takes into account the 0.5f scale.
// Left Arrow Highlighted
m_OMElements[OM_LEFTARROW_HIGHLIGHTED_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(BUTTON_LEFTARROW_HIGHLIGHTED),
RECTANGLE(0.0f, 64.0f, 0.0f, 64.0f),
m_OMElements[OM_BAR_ELEMENT1].GetPosX(),
m_OMElements[OM_RESOLUTION_HIGHLIGHT_ELEMENT].GetPosY(),
0.0f, 0.5f, white);
// Right Arrow Highlighted
m_OMElements[OM_RIGHTARROW_HIGHLIGHTED_ELEMENT].Setup(m_Renderer, CAssetManager::GetInstance()->GetTexture(BUTTON_RIGHTARROW_HIGHLIGHTED),
RECTANGLE(0.0f, 64.0f, 0.0f, 64.0f),
m_OMElements[OM_BAR_ELEMENT1].GetPosX() + (m_OMElements[OM_BAR_ELEMENT1].GetRect().right - 32.0f) * (m_Renderer->GetScreenHeight() / 720.0f),
m_OMElements[OM_RESOLUTION_HIGHLIGHT_ELEMENT].GetPosY(),
0.0f, 0.5f, white); // the 32.0f in X takes into account the 0.5f scale.
}
void COptionsState::Render( void )
{
m_Renderer->EnableDraw();
//m_Renderer->DrawTexture(&m_OMElements[OM_BACKGROUND_ELEMENT]);
m_OMElements[OM_BLACK_BACKGROUND_ELEMENT].SetOpacity(0.4f);
m_Renderer->DrawTexture(&m_OMElements[OM_BLACK_BACKGROUND_ELEMENT]);
if( m_Renderer->GetFullScreen() )
{
if (m_bResolution)
m_Renderer->DrawTexture(&m_OMElements[OM_RESOLUTION_ELEMENT]);
if (!m_bResolution)
m_Renderer->DrawTexture(&m_OMElements[OM_RESOLUTION_HIGHLIGHT_ELEMENT]);
if( m_bLeftArrow )
m_Renderer->DrawTexture(&m_OMElements[OM_LEFTARROW_ELEMENT]);
else
m_Renderer->DrawTexture(&m_OMElements[OM_LEFTARROW_HIGHLIGHTED_ELEMENT]);
if( m_bRightArrow )
m_Renderer->DrawTexture(&m_OMElements[OM_RIGHTARROW_ELEMENT]);
else
m_Renderer->DrawTexture(&m_OMElements[OM_RIGHTARROW_HIGHLIGHTED_ELEMENT]);
}
if (m_bMusic)
m_Renderer->DrawTexture(&m_OMElements[OM_MUSIC_ELEMENT]);
if (!m_bMusic)
m_Renderer->DrawTexture(&m_OMElements[OM_MUSIC_HIGHLIGHTED_ELEMENT]);
if (m_bSFX)
m_Renderer->DrawTexture(&m_OMElements[OM_SFX_ELEMENT]);
if (!m_bSFX)
m_Renderer->DrawTexture(&m_OMElements[OM_SFX_HIGHLIGHTED_ELEMENT]);
if (m_bGamma)
m_Renderer->DrawTexture(&m_OMElements[OM_GAMMA_ELEMENT]);
if (!m_bGamma)
m_Renderer->DrawTexture(&m_OMElements[OM_GAMMA_HIGHLIGHTED_ELEMENT]);
/*if (m_bMouse)
m_Renderer->DrawTexture(&m_OMElements[OM_MOUSE_ELEMENT]);
if (!m_bMouse)
m_Renderer->DrawTexture(&m_OMElements[OM_MOUSE_HIGHLIGHTED_ELEMENT]);*/
if (m_bAccept)
m_Renderer->DrawTexture(&m_OMElements[OM_ACCEPT_ELEMENT]);
if (!m_bAccept)
m_Renderer->DrawTexture(&m_OMElements[OM_ACCEPT_HIGHLIGHTED_ELEMENT]);
if (m_bDefault)
m_Renderer->DrawTexture(&m_OMElements[OM_DEFAULT_ELEMENT]);
if (!m_bDefault)
m_Renderer->DrawTexture(&m_OMElements[OM_DEFAULT_HIGHLIGHTED_ELEMENT]);
if (m_bCancel)
m_Renderer->DrawTexture(&m_OMElements[OM_CANCEL_ELEMENT]);
if (!m_bCancel)
m_Renderer->DrawTexture(&m_OMElements[OM_CANCEL_HIGHLIGHTED_ELEMENT]);
if (m_bGamepad)
m_Renderer->DrawTexture(&m_OMElements[OM_GAMEPAD_ELEMENT]);
if (!m_bGamepad)
m_Renderer->DrawTexture(&m_OMElements[OM_GAMEPAD_HIGHLIGHTED_ELEMENT]);
if (m_bEnable)
{
m_Renderer->DrawTexture(&m_OMElements[OM_ENABLE_ELEMENT]);
m_Renderer->DrawTexture(&m_OMElements[OM_ALL3_CONTROLLER_ELEMENT]);
}
if (!m_bEnable)
{
m_Renderer->DrawTexture(&m_OMElements[OM_DISABLE_ELEMENT]);
m_Renderer->DrawTexture(&m_OMElements[OM_ALL3_ELEMENT]);
}
m_Renderer->DrawTexture(&m_OMElements[OM_BAR_ELEMENT1]); //BG_BAR
m_Renderer->DrawTexture(&m_OMElements[OM_SLIDER_ELEMENT1]); //SLIDER
m_Renderer->DrawTexture(&m_OMElements[OM_BAR_ELEMENT2]); //BG_BAR
m_Renderer->DrawTexture(&m_OMElements[OM_SLIDER_ELEMENT2]); //SLIDER
m_Renderer->DrawTexture(&m_OMElements[OM_BAR_ELEMENT3]); //BG_BAR
m_Renderer->DrawTexture(&m_OMElements[OM_SLIDER_ELEMENT3]); //SLIDER
//m_Renderer->DrawTexture(&m_OMElements[OM_BAR_ELEMENT4]); //BG_BAR
//m_Renderer->DrawTexture(&m_OMElements[OM_SLIDER_ELEMENT4]); //SLIDER
//if(!m_bFadeOut && m_FadeTimer <= 1.0f && m_FadeTimer > 0.0f)
//
//if (m_bFadeOut)
// //FadeOut();
// m_Renderer->DrawTexture(&m_OMElements[OM_BLACK_BACKGROUND_ELEMENT]);
// Selected Resolution
for( unsigned int i = 0, n = m_UIResolution.size(); i < n; ++i )
{
m_Renderer->DrawTexture( m_UIResolution[i] );
}
//DRAW Reticle
m_Renderer->DrawTexture( &m_reticle );
m_Renderer->DisableDraw();
}
void COptionsState::Exit()
{
while( ShowCursor( FALSE ) >= 0 );
if (!m_bCancel) //might need to swap these.
{
LoadOptions( L"\\volume.bin" );
AudioSystemWwise::GetInstance()->SetRTCPValue(AK::GAME_PARAMETERS::SFX_VOLUME, (float)m_SFXVolume * 10.0f);
AudioSystemWwise::GetInstance()->SetRTCPValue(AK::GAME_PARAMETERS::MX_VOLUME, (float)m_MusicVolume * 10.0f);
AudioSystemWwise::GetInstance()->SetRTCPValue(AK::GAME_PARAMETERS::DX_VOLUME, (float)m_SFXVolume * 10.0f);
if(m_Enable == 0)
m_bEnable = false;
else
m_bEnable = true;
m_Game->SetUsingController(m_bEnable);
}
if (!m_bAccept)
SaveOptions( L"\\volume.bin" );
m_Timer = 0.0f;
for( unsigned int i = 0; i < OM_NUM_ELEMENTS; ++i )
{
m_OMElements[i].ReleaseGLBatch();
}
m_reticle.ReleaseGLBatch();
for( unsigned int i = 0, n = m_UIResolution.size(); i < n; ++i )
{
m_UIResolution[i]->ReleaseGLBatch();
delete m_UIResolution[i];
}
m_UIResolution.clear();
}
void COptionsState::Shutdown( void )
{
for( unsigned int i = 0; i < OM_NUM_ELEMENTS; ++i )
{
m_OMElements[i].ReleaseGLBatch();
}
m_reticle.ReleaseGLBatch();
for( unsigned int i = 0, n = m_UIResolution.size(); i < n; ++i )
{
m_UIResolution[i]->ReleaseGLBatch();
delete m_UIResolution[i];
}
m_UIResolution.clear();
}
void COptionsState::ProcessStates( eOMChoices _choice )
{
}
bool COptionsState::LoadOptions( const WCHAR* szFilename)
{
WCHAR _szFilePath [4096];
LPWSTR _returnFilePath = nullptr;
SHGetKnownFolderPath(FOLDERID_LocalAppData, 0, 0, &_returnFilePath );
wcscpy_s(_szFilePath, _returnFilePath);
CoTaskMemFree(_returnFilePath);
wcsncat_s(_szFilePath, szFilename, wcslen(szFilename));
std::fstream volFile;
volFile.open(_szFilePath, ios_base::in | ios_base::binary);
volFile.seekg(0, ios_base::beg);
if (volFile.is_open())
{
volFile.read((char*)&m_MusicVolume, sizeof(int));
volFile.read((char*)&m_SFXVolume, sizeof(int));
volFile.read((char*)&m_Gamma, sizeof(int));
volFile.read((char*)&m_MouseSen, sizeof(int));
volFile.read((char*)&m_Enable, sizeof(int));
}
volFile.close();
return true;
}
void COptionsState::SaveOptions(const WCHAR* szFilename)
{
WCHAR _szFilePath [4096];
LPWSTR _returnFilePath = nullptr;
SHGetKnownFolderPath(FOLDERID_LocalAppData, 0, 0, &_returnFilePath );
wcscpy_s(_szFilePath, _returnFilePath);
CoTaskMemFree(_returnFilePath);
wcsncat_s(_szFilePath, szFilename, wcslen(szFilename));
std::fstream volFile;
volFile.open(_szFilePath, ios_base::out | ios_base::binary | ios_base::trunc);
volFile.seekg(0, ios_base::beg);
if(!volFile.is_open())
{
// Sends error message if broken
MessageBoxA(0, "Volume File not found.", 0, 0);
return;
}
if (volFile.is_open())
{
volFile.write((char*)&m_MusicVolume, sizeof(int));
volFile.write((char*)&m_SFXVolume, sizeof(int));
volFile.write((char*)&m_Gamma, sizeof(int));
volFile.write((char*)&m_MouseSen, sizeof(int));
volFile.write((char*)&m_Enable, sizeof(int));
}
volFile.close();
}
| [
"ian.alcid08@gmail.com"
] | ian.alcid08@gmail.com |
1a2e55397bd43bb9ac9731d8b2fdfe05d30cf640 | ed7f0eaeacf71da995ab3e5c2df1c9fe6738d1e1 | /Source/VitaCoreEditor/Public/CustomDetails/VCCharacterDetails.h | 6ec6d74077f0728dcbb91ce84e5c5b3123079fc8 | [] | no_license | ekokturk/VitaCoreSource | d5c6e91d2e6b208dcca860173b894f628bc987c0 | b5ac9d627daeef125c19c7f49f157f3ce62c19de | refs/heads/master | 2022-12-14T16:20:30.567047 | 2020-09-12T00:08:57 | 2020-09-12T00:08:57 | 285,476,849 | 4 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 446 | h | // VitaCore - Copyright (C) Eser Kokturk, 2020. All Rights Reserved.
#pragma once
#if WITH_EDITOR
#include "Editor/DetailCustomizations/Public/DetailCustomizations.h"
#include "Editor/PropertyEditor/Public/IDetailCustomization.h"
class FVCCharacterDetails : public IDetailCustomization
{
public:
static TSharedRef<IDetailCustomization> MakeInstance();
virtual void CustomizeDetails(IDetailLayoutBuilder& DetailBuilder) override;
};
#endif | [
"eserkokturk@yahoo.com"
] | eserkokturk@yahoo.com |
e1106b453e52fda27e118cc10a8fef03c6fe550f | 51c1c5e9b8489ef8afa029b162aaf4c8f8bda7fc | /easymodeling/src/libmodeling/WeldJoint.h | 703b867cef20cc725e8e12409f6e7667cad02c7f | [
"MIT"
] | permissive | aimoonchen/easyeditor | 3e5c77f0173a40a802fd73d7b741c064095d83e6 | 9dabdbfb8ad7b00c992d997d6662752130d5a02d | refs/heads/master | 2021-04-26T23:06:27.016240 | 2018-02-12T02:28:50 | 2018-02-12T02:28:50 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 798 | h | #ifndef _EASYMODELING_WELD_JOINT_H_
#define _EASYMODELING_WELD_JOINT_H_
#include "Joint.h"
namespace emodeling
{
class WeldJoint : public Joint
{
public:
WeldJoint(Body* b0, Body* b1);
virtual bool IsContain(const sm::vec2& pos) const override;
virtual bool IsIntersect(const sm::rect& rect) const override;
virtual void Draw(DrawType type) const override;
sm::vec2 GetWorldAnchorA() const;
sm::vec2 GetWorldAnchorB() const;
void SetLocalAnchorA(const sm::vec2& world);
void SetLocalAnchorB(const sm::vec2& world);
private:
void DrawAnchor(const sm::vec2& pos, DrawType type) const;
public:
sm::vec2 m_local_anchor_a;
sm::vec2 m_local_anchor_b;
float m_reference_angle;
float m_frequency_hz;
float m_damping_ratio;
}; // WeldJoint
}
#endif // _EASYMODELING_WELD_JOINT_H_ | [
"zhuguang@ejoy.com"
] | zhuguang@ejoy.com |
c8da683ea15558c50edd13000568257400316558 | 88f11922f8ffb0f9a01c2fdd012d948472e373f5 | /main.cpp | b4e4f7387ab4bf590b6a28ab7afc19b9fbfaf57a | [] | no_license | Rikitaru/Queue | ad0c230d8498573ea4e77e687177a27874c38c4e | 6425417375d43b4c93683cdb8351a6f6b28fdc6c | refs/heads/master | 2023-07-30T22:24:20.465153 | 2021-09-16T02:21:25 | 2021-09-16T02:21:25 | 406,526,357 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 16,303 | cpp | #include <iostream>
#include <cstdlib>
using namespace std;
struct Point {
int x;
int y;
int z;
Point() {
this->x = 1;
this->y = 2;
this->z = 3;
}
Point& operator= (const Point& point) //перегрузка оператора присваивания, создание нового объекта структуры
{
this->x = point.x;
this->y = point.y;
this->z = point.z;
return *this;
}
Point& operator= (const int a) //перегрузка оператора присваивания, создание нового объекта структуры (обнуление)
{
this->x = a;
this->y = a;
this->z = a;
return *this;
}
friend std::ostream& operator<< (std::ostream& out, const Point& point);
friend std::istream& operator>> (std::istream& in, Point& point);
};
std::ostream& operator<< (std::ostream& out, const Point& point) {
// Поскольку operator<< является другом класса Point, то мы имеем прямой доступ к членам Point
out << "Point(" << point.x << ", " << point.y << ", " << point.z << ")";
return out;
}
std::istream& operator>> (std::istream& in, Point& point)
{
// Поскольку operator>> является другом класса Point, то мы имеем прямой доступ к членам Point.
// Обратите внимание, параметр point (объект класса Point) должен быть неконстантным, чтобы мы имели возможность изменить члены класса
in >> point.x;
cout << "Введите Y = ";
in >> point.y;
cout << "Введите Z = ";
in >> point.z;
return in;
}
template <typename T>
struct el {//структура каждого элемента очереди состоит из
el();
T x; //значение элемента очереди
el* previous; //указатель на предыдущий элемент очереди
};
template<typename T>
el<T>::el() {
x = 0;
previous = nullptr;
}
template <class T>
class Queue //класс очередь
{
private:
int count; //размер очереди
el <T>* head; //голова очереди
public:
Queue() { head = nullptr; count = 0; }; //конструктор
// Конструктор копирования
Queue(const Queue& queue) { //конструктор копирования this - это очередь в которую нужно скопировать (новая), queue - очередь, из которой мы делаем копию (берем данные)
this->head = new el <T>;//у новой очереди создаем пустую голову
this->head->x = queue.head->x;//в новой голове копируем элемент Х(либо число, либо Pointer, для этого оператор присваивания перегрузили у Pointer)
this->count = queue.count;//копируем количество элементов в очереди
el <T>* current_this = this->head; //указатель новой очереди на голову
el <T>* current_queue = queue.head;//указатель старой queue очереди на голову
//здесь мы уже скопировали голову очереди
while (current_queue->previous != nullptr) //условие: пока указатель на элемент старой очереди не указывает в пустоту (не последний)
{
current_this->previous = new el <T>; //создаем новый элемент по указателю на следующий элемент в новой очереди, далее перейдем на этот элемент
current_this = current_this->previous; //переход указателя на элемент новой очереди на "следующий" элемент oчереди (переходим на элемент ближе к первому), далее перейдем на старой очереди на следующий элемент
current_queue = current_queue->previous; //переход указателя на элемент старой очереди на "следующий" элемент oчереди (переходим на элемент ближе к первому)
current_this->x = current_queue->x; //в новом элементе новой очереди копируем элемент Х(либо число, либо Pointer, для этого оператор присваивания перегрузили у Pointer)
}
//здесь мы дошли до последнего элемента очереди скопировали уже все элементы старой очереди в новую, но последний указатель не обнулили
current_this->previous = nullptr;
//очередь скоирована. голова есть и ее не меняли, потом прошли указателями двумя по обеим очередям, создавали новые элементы через new и туда копировали значения!
cout << "Copy constructor worked here!\n";
}
int size(); //метод -> возвращает count
void show(); //метод вывода очереди
void enqueue(); //добавление нового элемента в очередь
void cut();//метод удаления элемента из очереди
void clear();//метод удаления всей очереди
void deque();
};
template <class T>
int Queue <T>::size() { //функция получения размера очереди
return count;//возвращаем значение счетчика количества элементов в очереди
}
template <class T>
void Queue<T>::enqueue() {//функция вставки нового элемента
if (!count) {//Так как очередь пуста, то создаем головной элемент
head = new el <T>;//создаем по указателю новый элемент
head->previous = nullptr;//пускай он указывает в пустоту
cout << "Х = ";//ввод значения нового элемента (головы)
cin >> head->x;//сохранение результата
count++;//увеличение счетчика длины очереди
cout << "Элемент успешно добавлен" << endl;
system("pause");
}
else
{//если голова есть в очереди -> добавляем новый элемент
auto* current = new el <T>;//el <T> *current = new el <T>;//создаем по указателю новый элемент
cout << "x = ";//ввод значения нового элемента
cin >> current->x;//сохранение результата
current->previous = head;//пускай новый элемент указывает на головной элемент
head = current;//пускай голова теперь указывает на новый элемент
count++;//увеличение счетчика длины очереди
cout << "Элемент успешно добавлен" << endl;
system("pause");
}
}
template <class T>
void Queue<T>::cut() {//удаление элемента в очереди
//если голова пустая, то ничего делать не нужно
if (!count) {//Так как очередь пуста, ничего не делаем
cout << "Очередь пуста" << endl;
system("pause");
return;
}
el <T>* current = head; //указатель на голову
el <T>* buf = head; //временный указатель на голову (для удаления)
if (count > 1) {//Так как очередь пуста, ничего не делаем
//удаляем элемент очереди
while (current->previous->previous != nullptr) //условие: пока не найдем второй элемент с начала очереди (второй пришедший)
{
current = current->previous; //переход на предыдущий элемент oчереди (переходим на элемент ближе к первому)
}
buf = current->previous; //переход на первый элемент очереди, который будем удалять
current->previous = nullptr;//обнуление связи со второго элемента очереди на первый
}
count--;//уменьшение длины очереди
delete(buf);//удаление первого элемента
cout << "Элемент успешно извлечен из очереди" << endl;
system("pause");
}
template <class T>
void Queue<T>::clear() {//удаление элемента в очереди
//если голова пустая, то ничего делать не нужно
if (!count) {//Так как очередь пуста, ничего не делаем
cout << "Очередь пуста" << endl;
system("pause");
return;
}
while (count > 1) {
el <T>* current = head; //указатель на голову
el <T>* buf = head; //временный указатель на голову (для удаления)
//удаляем элемент очереди
while (current->previous->previous != nullptr) //условие: пока не найдем второй элемент с начала очереди (второй пришедший)
{
current = current->previous; //переход на предыдущий элемент oчереди (переходим на элемент ближе к первому)
}
buf = current->previous; //переход на первый элемент очереди, который будем удалять
current->previous = nullptr;//обнуление связи со второго элемента очреди на первый
count--;//уменьшение длины очереди
delete(buf);
cout << "Элемент успешно извлечен из очереди" << endl;
}
el <T>* buf = head; //временный указатель на голову (для удаления)
count--;//уменьшение длины очереди
delete(buf);
system("pause");
}
template <class T>
void Queue<T>::show() {
int i = size(); //получаем значение длины очереди
el <T>* current = head;//указаетль на голову
if (!count)//Так как очередь пуста, ничего не делаем
{
cout << "Очередь пуста" << endl;
system("pause");
return;
}
cout << "Старший элемент по очереди - головной элемент (последний пришедший)." << endl;
//если есть очередь, то выводим циклично, пока не закончится очередь
cout << "[" << --i << "] " << current->x << endl;//вывод значение элемента очереди
while (current->previous != nullptr) {//цикл прохода от головы до первопрешедшего элемента
current = current->previous;//переход на предыдущий элемент oчереди (переходим на элемент ближе к первому)
cout << "[" << --i << "] " << current->x << endl;//вывод значение элемента очереди
}
system("pause");
}
template<class T>
void Queue<T>::deque() {
if (count < 1) {
cout << "Очередь пуста, будет выкинуто исключение" << endl;
throw "Ошибка. Очередь пуста.";
}
}
int main()
{
//system("chcp 65001");
setlocale(LC_ALL, "Russian");
Queue<Point> a;
Queue <int> b;
int answer;
cout << "Выберите тип очереди: 0-int, 1-Point" << endl;
cin >> answer;
int menu;
try {
while (true) {
system("CLS");
cout << "1 – Добавление элемента в конец очереди" << endl
<< "2 – Извлечение с начала очереди" << endl
<< "3 – Вывод очереди на экран" << endl
<< "4 – Удаление всей очереди" << endl
<< "5 – Проверка на пустоту с выбрасывание исключения!" << endl
<< "6 – Конструктор копирования шаблонной очереди" << endl
<< "7 – Выход из программы" << endl;
cin >> menu;
switch (menu)
{
case 7: {
return 0;
}
case 1: { //переход в функцию вставки
(answer == 1) ? a.enqueue() : b.enqueue();//вызов метода вставки
break;
}
case 2: { //переход в функцию вырезки
(answer == 1) ? a.cut() : b.cut();//вызов метода удаления
break;
}
case 3: { //переход в функцию вывода на экран очереди
(answer == 1) ? a.show() : b.show();//вызов метода вывода
break;
}
case 4: { //переход в функцию очистки всей очереди
(answer == 1) ? a.clear() : b.clear();//вызов метода вывода
break;
}
case 5: { //переход в функцию очистки всей очереди
(answer == 1) ? a.deque() : b.deque();//вызов метода вывода
break;
}
case 6: { //переход в функцию очистки всей очереди
if (answer == 1) {
Queue<Point> c = a; //сработает конструктор копирования, так как у нас инициализация
cout << "новая очередь через Конструктор копирования"<< endl;
c.show();
cout << "a.clear();" << endl;
a.clear();
cout << "c.show();" << endl;
c.show();
}
else {
Queue<int> d = b; //сработает конструктор копирования, так как у нас инициализация
cout << "новая очередь через Конструктор копирования" << endl;
d.show();
cout << "b.clear();" << endl;
b.clear();
cout << "d.show();" << endl;
d.show();
}
break;
}
default:
break;
}
}
}
catch (char* a) {
cout << "Мы поймали исключение. " << a << endl;
}
} | [
"danila.korobkov@yandex.ru"
] | danila.korobkov@yandex.ru |
33b1e115dbe2ad32438c0cbf3f3a5076faedcd15 | 6dcdc3f3403729af872f0ab0884f9f5ad7a6e122 | /src/CRSpline.cc | c978bf64063d1c879c6338047d9af1248bbe2b21 | [] | no_license | bagnalla/puddi | 520cc048e1cb0c94bc7dd6cb9bef37f4fb706e06 | 6c51b1602d72097295cfc8e1a04c038083c81f15 | refs/heads/master | 2021-01-10T14:05:15.067722 | 2019-02-26T04:11:09 | 2019-02-26T04:11:09 | 51,229,043 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,830 | cc | // FROM http://www.codeproject.com/Articles/30838/Overhauser-Catmull-Rom-Splines-for-Camera-Animatio
#include "CRSpline.h"
namespace puddi
{
CRSpline::CRSpline()
: vp(), delta_t(0)
{
}
CRSpline::CRSpline(const CRSpline& s)
{
for (int i = 0; i < (int)s.vp.size(); i++)
vp.push_back(s.vp[i]);
delta_t = s.delta_t;
}
CRSpline::~CRSpline()
{}
// Solve the Catmull-Rom parametric equation for a given time(t) and vector quadruple (p1,p2,p3,p4)
vec4 CRSpline::Eq(float t, const vec4& p1, const vec4& p2, const vec4& p3, const vec4& p4)
{
float t2 = t * t;
float t3 = t2 * t;
float b1 = .5f * (-t3 + 2 * t2 - t);
float b2 = .5f * (3 * t3 - 5 * t2 + 2);
float b3 = .5f * (-3 * t3 + 4 * t2 + t);
float b4 = .5f * (t3 - t2);
return (p1*b1 + p2*b2 + p3*b3 + p4*b4);
}
void CRSpline::AddSplinePoint(const vec4& v)
{
vp.push_back(v);
delta_t = (float)1 / (float)vp.size();
}
vec4 CRSpline::GetInterpolatedSplinePoint(float t)
{
// Find out in which interval we are on the spline
int p = (int)(t / delta_t);
// Compute local control point indices
#define BOUNDS(pp) { if (pp < 0) pp = 0; else if (pp >= (int)vp.size()-1) pp = vp.size() - 1; }
int p0 = p - 1; BOUNDS(p0);
int p1 = p; BOUNDS(p1);
int p2 = p + 1; BOUNDS(p2);
int p3 = p + 2; BOUNDS(p3);
// Relative (local) time
float lt = (t - delta_t*(float)p) / delta_t;
// Interpolate
return CRSpline::Eq(lt, vp[p0], vp[p1], vp[p2], vp[p3]);
}
int CRSpline::GetNumPoints()
{
return vp.size();
}
vec4& CRSpline::GetNthPoint(int n)
{
return vp[n];
}
}
| [
"ab667712@ohio.edu"
] | ab667712@ohio.edu |
6e4b97da115f1e333ad87be9e2cb0ab9f4d741b5 | 2e10a55bcc27421c2ce00bac67d62ca3ae7a43be | /gcommon/source/gphysicscomponentspring.h | f687e39678bb3a14dc145ccca613d1b02535f18f | [
"Unlicense"
] | permissive | DavidCoenFish/ancient-code-0 | 2f72b8e20406b9877daa032f9e9fb8343da62340 | 243fb47b9302a77f9b9392b6e3f90bba2ef3c228 | refs/heads/master | 2020-03-21T10:18:30.613722 | 2018-06-24T01:18:30 | 2018-06-24T01:18:30 | 138,444,313 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,559 | h | //
// GPhysicsComponentSpring.h
//
// Created by David Coen on 2010 10 30
// Copyright 2010 Pleasure seeking morons. All rights reserved.
//
#ifndef _GPhysicsComponentSpring_h_
#define _GPhysicsComponentSpring_h_
class GVector3Float;
/**/
class GPhysicsComponentSpring
{
//constructors
public:
GPhysicsComponentSpring(
const float in_springConstant = 0.0F,
const float in_springInnerFriction = 0.0F
);
GPhysicsComponentSpring(const GPhysicsComponentSpring& in_src);
~GPhysicsComponentSpring();
//operators
public:
const GPhysicsComponentSpring& operator=(const GPhysicsComponentSpring& in_rhs);
//public methods
public:
const float CalculateSpringForce(
const float in_target, //the distance we want to be from the spring origin
const float in_currentValue
)const;
const float CalculateSpringFriction(
const float in_velocityLhs,
const float in_velocityRhs
)const;
const GVector3Float CalculateSpringForce(
const GVector3Float& in_origin,
const float in_targetDistance, //the distance we want to be from the spring origin
const GVector3Float& in_currentValue
)const;
const GVector3Float CalculateSpringFriction(
const GVector3Float& in_velocityLhs,
const GVector3Float& in_velocityRhs
)const;
//public accessor
public:
//const float GetSpringDampen()const{ return mSpringDampen; }
//private members
private:
float mSpringConstant;
//inner friction of the spring, kind of like dampening, a force to resist spring movement
float mSpringInnerFriction;
};
/**/
#endif //_GPhysicsComponentSpring_h_
| [
"35204591+DavidCoenFish@users.noreply.github.com"
] | 35204591+DavidCoenFish@users.noreply.github.com |
b59a18ce62a2a5f8278e803ca38baf564abb9920 | 9eaa3db05f1537266bd42646e3dafc12aa4c7941 | /src/ReadRecord.h | 5cf1295b7791fbd82c49838aa139be0044940b63 | [] | no_license | JLUprojects/taq-cprogram2018-group_11 | 0709df7780914e07ad2b82a6bbe729e3e765d924 | dd6e328e87dc39321338fdf6e5384d0f1ce8b0b3 | refs/heads/master | 2020-03-18T19:38:30.684779 | 2018-06-24T15:11:44 | 2018-06-24T15:11:44 | 135,166,666 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 329 | h | #pragma once
#include <stdio.h>
class CReadRecord
{
public:
CReadRecord(void);
CReadRecord(CReadRecord& src);
~CReadRecord(void);
CReadRecord& operator =(const CReadRecord& src);
public:
int Save(IN FILE* fp);
int Load(IN FILE* fp);
public:
CString m_strDate;
int m_iStartPage;
int m_iEndPage;
};
| [
"wu_bingrui@outlook.com"
] | wu_bingrui@outlook.com |
55d0b3c39b54184f3486e09662c36f8088e85799 | a8895974e5aac4b6746733ba97cdf6e0846d044d | /libs/cocos2dx/script_support/CCScriptSupport.cpp | 638d648d6f0301716ee72c829a58df928a70e239 | [] | no_license | 51anygo/mybird | b9260cb3b7e5cb14302d5115196be9f0b19de3af | 71e9375e81ecce4fa8b8ae69195ae416f1da5dc4 | refs/heads/master | 2020-05-16T11:16:19.561900 | 2014-04-10T12:53:51 | 2014-04-10T12:53:51 | 17,505,897 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 5,034 | cpp | /****************************************************************************
Copyright (c) 2010-2012 cocos2d-x.org
http://www.cocos2d-x.org
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
****************************************************************************/
#include "CCScriptSupport.h"
#include "CCScheduler.h"
bool CC_DLL cc_assert_script_compatible(const char *msg)
{
cocos2d::CCScriptEngineProtocol* pEngine = cocos2d::CCScriptEngineManager::sharedManager()->getScriptEngine();
if (pEngine && pEngine->handleAssert(msg))
{
return true;
}
return false;
}
NS_CC_BEGIN
// #pragma mark -
// #pragma mark CCScriptHandlerEntry
CCScriptHandlerEntry* CCScriptHandlerEntry::create(int nHandler)
{
CCScriptHandlerEntry* entry = new CCScriptHandlerEntry(nHandler);
entry->autorelease();
return entry;
}
CCScriptHandlerEntry::~CCScriptHandlerEntry(void)
{
CCScriptEngineManager::sharedManager()->getScriptEngine()->removeScriptHandler(m_nHandler);
}
// #pragma mark -
// #pragma mark CCSchedulerScriptHandlerEntry
CCSchedulerScriptHandlerEntry* CCSchedulerScriptHandlerEntry::create(int nHandler, float fInterval, bool bPaused)
{
CCSchedulerScriptHandlerEntry* pEntry = new CCSchedulerScriptHandlerEntry(nHandler);
pEntry->init(fInterval, bPaused);
pEntry->autorelease();
return pEntry;
}
bool CCSchedulerScriptHandlerEntry::init(float fInterval, bool bPaused)
{
m_pTimer = new CCTimer();
m_pTimer->initWithScriptHandler(m_nHandler, fInterval);
m_pTimer->autorelease();
m_pTimer->retain();
m_bPaused = bPaused;
LUALOG("[LUA] ADD script schedule: %d, entryID: %d", m_nHandler, m_nEntryId);
return true;
}
CCSchedulerScriptHandlerEntry::~CCSchedulerScriptHandlerEntry(void)
{
m_pTimer->release();
LUALOG("[LUA] DEL script schedule %d, entryID: %d", m_nHandler, m_nEntryId);
}
// #pragma mark -
// #pragma mark CCTouchScriptHandlerEntry
CCTouchScriptHandlerEntry* CCTouchScriptHandlerEntry::create(int nHandler,
bool bIsMultiTouches,
int nPriority,
bool bSwallowsTouches)
{
CCTouchScriptHandlerEntry* pEntry = new CCTouchScriptHandlerEntry(nHandler);
pEntry->init(bIsMultiTouches, nPriority, bSwallowsTouches);
pEntry->autorelease();
return pEntry;
}
CCTouchScriptHandlerEntry::~CCTouchScriptHandlerEntry(void)
{
CCScriptEngineManager::sharedManager()->getScriptEngine()->removeScriptHandler(m_nHandler);
LUALOG("[LUA] Remove touch event handler: %d", m_nHandler);
}
bool CCTouchScriptHandlerEntry::init(bool bIsMultiTouches, int nPriority, bool bSwallowsTouches)
{
m_bIsMultiTouches = bIsMultiTouches;
m_nPriority = nPriority;
m_bSwallowsTouches = bSwallowsTouches;
return true;
}
// #pragma mark -
// #pragma mark CCScriptEngineManager
static CCScriptEngineManager* s_pSharedScriptEngineManager = NULL;
CCScriptEngineManager::~CCScriptEngineManager(void)
{
removeScriptEngine();
}
void CCScriptEngineManager::setScriptEngine(CCScriptEngineProtocol *pScriptEngine)
{
removeScriptEngine();
m_pScriptEngine = pScriptEngine;
}
void CCScriptEngineManager::removeScriptEngine(void)
{
if (m_pScriptEngine)
{
delete m_pScriptEngine;
m_pScriptEngine = NULL;
}
}
CCScriptEngineManager* CCScriptEngineManager::sharedManager(void)
{
if (!s_pSharedScriptEngineManager)
{
s_pSharedScriptEngineManager = new CCScriptEngineManager();
}
return s_pSharedScriptEngineManager;
}
void CCScriptEngineManager::purgeSharedManager(void)
{
if (s_pSharedScriptEngineManager)
{
delete s_pSharedScriptEngineManager;
s_pSharedScriptEngineManager = NULL;
}
}
NS_CC_END
| [
"51anygo@gmail.com"
] | 51anygo@gmail.com |
dbd55603c78276dfbf527994bf5b3b16eca2befd | 07b79ec27132b2632fc0273efad4647f56b70068 | /oj_old/进程创建实验.cpp | d58632c5917e4293c8be54bb6bfc73920e17d74e | [] | no_license | oliverhust/cpp_lianxi | 549797eefb4742c87dc10155cedd31b4c6081518 | 6a162068a374af0ded7237af7eb9d4dc11112034 | refs/heads/master | 2020-07-22T22:41:58.162958 | 2016-12-09T01:15:23 | 2016-12-09T01:15:23 | 67,104,685 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,390 | cpp | #include <windows.h>
#include <stdio.h>
#include <string.h>
#define MAX_LINE_LEN 128
int main()
{
//local variables
char cmdLine[MAX_LINE_LEN];
//CreateProcess parameters
LPSECURITY_ATTRIBUTES processA = NULL;//Default
LPSECURITY_ATTRIBUTES threadA = NULL;//Default
BOOL shareRights = TRUE;//Default
DWORD creationMask = CREATE_NEW_CONSOLE;//Window per process.
LPVOID enviroment = NULL;//Default
LPCWSTR curDir = NULL;//Default
STARTUPINFO startInfo;//Result
PROCESS_INFORMATION procInfo;//Result
while (fgets(cmdLine, MAX_LINE_LEN, stdin) != NULL)
{
// Read a command from the file
if (cmdLine[strlen(cmdLine) - 1] == '\n')
cmdLine[strlen(cmdLine) - 1] = '\0';//Remove NEWLINE
//Create a new process to execute the command
ZeroMemory(&startInfo, sizeof(startInfo));
startInfo.cb = sizeof(startInfo);
if (!CreateProcess(
(LPWSTR)cmdLine,//File name of executable
NULL,//command line
processA,//Process inherited security
threadA, //Thread inherited security
shareRights,//Rights propagation
creationMask,//various creation flags
enviroment,//Enviroment variable
curDir, //Child's current directory
&startInfo,
&procInfo
)
)
{
fprintf(stderr, "CreatProcess failed on error %d\n", GetLastError());
}
}
//Terminate after all commands have finished.
printf("Father Process Finish\r\n");
(void)getchar();
return 0;
}
| [
"liangjinchao@d3p.com"
] | liangjinchao@d3p.com |
8db37baf4b6fb3a2fd9467db47c44751e5e7ba18 | 3b9b4049a8e7d38b49e07bb752780b2f1d792851 | /src/third_party/webrtc/common_audio/resampler/push_sinc_resampler_unittest.cc | aca73b2d4bc2aba1203e06f6a6d7d6f426053cbc | [
"LGPL-2.0-or-later",
"GPL-1.0-or-later",
"MIT",
"Apache-2.0",
"BSD-3-Clause",
"LicenseRef-scancode-google-patent-license-webrtc",
"LicenseRef-scancode-unknown-license-reference",
"BSL-1.0",
"LicenseRef-scancode-public-domain",
"LicenseRef-scancode-unknown",
"MS-LPL",
"LicenseRef-scancode-takuy... | permissive | webosce/chromium53 | f8e745e91363586aee9620c609aacf15b3261540 | 9171447efcf0bb393d41d1dc877c7c13c46d8e38 | refs/heads/webosce | 2020-03-26T23:08:14.416858 | 2018-08-23T08:35:17 | 2018-09-20T14:25:18 | 145,513,343 | 0 | 2 | Apache-2.0 | 2019-08-21T22:44:55 | 2018-08-21T05:52:31 | null | UTF-8 | C++ | false | false | 14,498 | cc | /*
* Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include <cmath>
#include <cstring>
#include <memory>
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/common_audio/include/audio_util.h"
#include "webrtc/common_audio/resampler/push_sinc_resampler.h"
#include "webrtc/common_audio/resampler/sinusoidal_linear_chirp_source.h"
#include "webrtc/typedefs.h"
namespace webrtc {
namespace {
// Almost all conversions have an RMS error of around -14 dbFS.
const double kResamplingRMSError = -14.42;
// Used to convert errors to dbFS.
template <typename T>
T DBFS(T x) {
return 20 * std::log10(x);
}
} // namespace
class PushSincResamplerTest : public ::testing::TestWithParam<
::testing::tuple<int, int, double, double>> {
public:
PushSincResamplerTest()
: input_rate_(::testing::get<0>(GetParam())),
output_rate_(::testing::get<1>(GetParam())),
rms_error_(::testing::get<2>(GetParam())),
low_freq_error_(::testing::get<3>(GetParam())) {
}
~PushSincResamplerTest() override {}
protected:
void ResampleBenchmarkTest(bool int_format);
void ResampleTest(bool int_format);
int input_rate_;
int output_rate_;
double rms_error_;
double low_freq_error_;
};
class ZeroSource : public SincResamplerCallback {
public:
void Run(size_t frames, float* destination) {
std::memset(destination, 0, sizeof(float) * frames);
}
};
void PushSincResamplerTest::ResampleBenchmarkTest(bool int_format) {
const size_t input_samples = static_cast<size_t>(input_rate_ / 100);
const size_t output_samples = static_cast<size_t>(output_rate_ / 100);
const int kResampleIterations = 500000;
// Source for data to be resampled.
ZeroSource resampler_source;
std::unique_ptr<float[]> resampled_destination(new float[output_samples]);
std::unique_ptr<float[]> source(new float[input_samples]);
std::unique_ptr<int16_t[]> source_int(new int16_t[input_samples]);
std::unique_ptr<int16_t[]> destination_int(new int16_t[output_samples]);
resampler_source.Run(input_samples, source.get());
for (size_t i = 0; i < input_samples; ++i) {
source_int[i] = static_cast<int16_t>(floor(32767 * source[i] + 0.5));
}
printf("Benchmarking %d iterations of %d Hz -> %d Hz:\n",
kResampleIterations, input_rate_, output_rate_);
const double io_ratio = input_rate_ / static_cast<double>(output_rate_);
SincResampler sinc_resampler(io_ratio, SincResampler::kDefaultRequestSize,
&resampler_source);
int64_t start = rtc::TimeNanos();
for (int i = 0; i < kResampleIterations; ++i) {
sinc_resampler.Resample(output_samples, resampled_destination.get());
}
double total_time_sinc_us =
(rtc::TimeNanos() - start) / rtc::kNumNanosecsPerMicrosec;
printf("SincResampler took %.2f us per frame.\n",
total_time_sinc_us / kResampleIterations);
PushSincResampler resampler(input_samples, output_samples);
start = rtc::TimeNanos();
if (int_format) {
for (int i = 0; i < kResampleIterations; ++i) {
EXPECT_EQ(output_samples,
resampler.Resample(source_int.get(),
input_samples,
destination_int.get(),
output_samples));
}
} else {
for (int i = 0; i < kResampleIterations; ++i) {
EXPECT_EQ(output_samples,
resampler.Resample(source.get(),
input_samples,
resampled_destination.get(),
output_samples));
}
}
double total_time_us =
(rtc::TimeNanos() - start) / rtc::kNumNanosecsPerMicrosec;
printf("PushSincResampler took %.2f us per frame; which is a %.1f%% overhead "
"on SincResampler.\n\n", total_time_us / kResampleIterations,
(total_time_us - total_time_sinc_us) / total_time_sinc_us * 100);
}
// Disabled because it takes too long to run routinely. Use for performance
// benchmarking when needed.
TEST_P(PushSincResamplerTest, DISABLED_BenchmarkInt) {
ResampleBenchmarkTest(true);
}
TEST_P(PushSincResamplerTest, DISABLED_BenchmarkFloat) {
ResampleBenchmarkTest(false);
}
// Tests resampling using a given input and output sample rate.
void PushSincResamplerTest::ResampleTest(bool int_format) {
// Make comparisons using one second of data.
static const double kTestDurationSecs = 1;
// 10 ms blocks.
const size_t kNumBlocks = static_cast<size_t>(kTestDurationSecs * 100);
const size_t input_block_size = static_cast<size_t>(input_rate_ / 100);
const size_t output_block_size = static_cast<size_t>(output_rate_ / 100);
const size_t input_samples =
static_cast<size_t>(kTestDurationSecs * input_rate_);
const size_t output_samples =
static_cast<size_t>(kTestDurationSecs * output_rate_);
// Nyquist frequency for the input sampling rate.
const double input_nyquist_freq = 0.5 * input_rate_;
// Source for data to be resampled.
SinusoidalLinearChirpSource resampler_source(
input_rate_, input_samples, input_nyquist_freq, 0);
PushSincResampler resampler(input_block_size, output_block_size);
// TODO(dalecurtis): If we switch to AVX/SSE optimization, we'll need to
// allocate these on 32-byte boundaries and ensure they're sized % 32 bytes.
std::unique_ptr<float[]> resampled_destination(new float[output_samples]);
std::unique_ptr<float[]> pure_destination(new float[output_samples]);
std::unique_ptr<float[]> source(new float[input_samples]);
std::unique_ptr<int16_t[]> source_int(new int16_t[input_block_size]);
std::unique_ptr<int16_t[]> destination_int(new int16_t[output_block_size]);
// The sinc resampler has an implicit delay of approximately half the kernel
// size at the input sample rate. By moving to a push model, this delay
// becomes explicit and is managed by zero-stuffing in PushSincResampler. We
// deal with it in the test by delaying the "pure" source to match. It must be
// checked before the first call to Resample(), because ChunkSize() will
// change afterwards.
const size_t output_delay_samples = output_block_size -
resampler.get_resampler_for_testing()->ChunkSize();
// Generate resampled signal.
// With the PushSincResampler, we produce the signal block-by-10ms-block
// rather than in a single pass, to exercise how it will be used in WebRTC.
resampler_source.Run(input_samples, source.get());
if (int_format) {
for (size_t i = 0; i < kNumBlocks; ++i) {
FloatToS16(&source[i * input_block_size], input_block_size,
source_int.get());
EXPECT_EQ(output_block_size,
resampler.Resample(source_int.get(),
input_block_size,
destination_int.get(),
output_block_size));
S16ToFloat(destination_int.get(), output_block_size,
&resampled_destination[i * output_block_size]);
}
} else {
for (size_t i = 0; i < kNumBlocks; ++i) {
EXPECT_EQ(
output_block_size,
resampler.Resample(&source[i * input_block_size],
input_block_size,
&resampled_destination[i * output_block_size],
output_block_size));
}
}
// Generate pure signal.
SinusoidalLinearChirpSource pure_source(
output_rate_, output_samples, input_nyquist_freq, output_delay_samples);
pure_source.Run(output_samples, pure_destination.get());
// Range of the Nyquist frequency (0.5 * min(input rate, output_rate)) which
// we refer to as low and high.
static const double kLowFrequencyNyquistRange = 0.7;
static const double kHighFrequencyNyquistRange = 0.9;
// Calculate Root-Mean-Square-Error and maximum error for the resampling.
double sum_of_squares = 0;
double low_freq_max_error = 0;
double high_freq_max_error = 0;
int minimum_rate = std::min(input_rate_, output_rate_);
double low_frequency_range = kLowFrequencyNyquistRange * 0.5 * minimum_rate;
double high_frequency_range = kHighFrequencyNyquistRange * 0.5 * minimum_rate;
for (size_t i = 0; i < output_samples; ++i) {
double error = fabs(resampled_destination[i] - pure_destination[i]);
if (pure_source.Frequency(i) < low_frequency_range) {
if (error > low_freq_max_error)
low_freq_max_error = error;
} else if (pure_source.Frequency(i) < high_frequency_range) {
if (error > high_freq_max_error)
high_freq_max_error = error;
}
// TODO(dalecurtis): Sanity check frequencies > kHighFrequencyNyquistRange.
sum_of_squares += error * error;
}
double rms_error = sqrt(sum_of_squares / output_samples);
rms_error = DBFS(rms_error);
// In order to keep the thresholds in this test identical to SincResamplerTest
// we must account for the quantization error introduced by truncating from
// float to int. This happens twice (once at input and once at output) and we
// allow for the maximum possible error (1 / 32767) for each step.
//
// The quantization error is insignificant in the RMS calculation so does not
// need to be accounted for there.
low_freq_max_error = DBFS(low_freq_max_error - 2.0 / 32767);
high_freq_max_error = DBFS(high_freq_max_error - 2.0 / 32767);
EXPECT_LE(rms_error, rms_error_);
EXPECT_LE(low_freq_max_error, low_freq_error_);
// All conversions currently have a high frequency error around -6 dbFS.
static const double kHighFrequencyMaxError = -6.02;
EXPECT_LE(high_freq_max_error, kHighFrequencyMaxError);
}
TEST_P(PushSincResamplerTest, ResampleInt) { ResampleTest(true); }
TEST_P(PushSincResamplerTest, ResampleFloat) { ResampleTest(false); }
// Thresholds chosen arbitrarily based on what each resampling reported during
// testing. All thresholds are in dbFS, http://en.wikipedia.org/wiki/DBFS.
INSTANTIATE_TEST_CASE_P(
PushSincResamplerTest,
PushSincResamplerTest,
::testing::Values(
// First run through the rates tested in SincResamplerTest. The
// thresholds are identical.
//
// We don't test rates which fail to provide an integer number of
// samples in a 10 ms block (22050 and 11025 Hz). WebRTC doesn't support
// these rates in any case (for the same reason).
// To 44.1kHz
::testing::make_tuple(8000, 44100, kResamplingRMSError, -62.73),
::testing::make_tuple(16000, 44100, kResamplingRMSError, -62.54),
::testing::make_tuple(32000, 44100, kResamplingRMSError, -63.32),
::testing::make_tuple(44100, 44100, kResamplingRMSError, -73.53),
::testing::make_tuple(48000, 44100, -15.01, -64.04),
::testing::make_tuple(96000, 44100, -18.49, -25.51),
::testing::make_tuple(192000, 44100, -20.50, -13.31),
// To 48kHz
::testing::make_tuple(8000, 48000, kResamplingRMSError, -63.43),
::testing::make_tuple(16000, 48000, kResamplingRMSError, -63.96),
::testing::make_tuple(32000, 48000, kResamplingRMSError, -64.04),
::testing::make_tuple(44100, 48000, kResamplingRMSError, -62.63),
::testing::make_tuple(48000, 48000, kResamplingRMSError, -73.52),
::testing::make_tuple(96000, 48000, -18.40, -28.44),
::testing::make_tuple(192000, 48000, -20.43, -14.11),
// To 96kHz
::testing::make_tuple(8000, 96000, kResamplingRMSError, -63.19),
::testing::make_tuple(16000, 96000, kResamplingRMSError, -63.39),
::testing::make_tuple(32000, 96000, kResamplingRMSError, -63.95),
::testing::make_tuple(44100, 96000, kResamplingRMSError, -62.63),
::testing::make_tuple(48000, 96000, kResamplingRMSError, -73.52),
::testing::make_tuple(96000, 96000, kResamplingRMSError, -73.52),
::testing::make_tuple(192000, 96000, kResamplingRMSError, -28.41),
// To 192kHz
::testing::make_tuple(8000, 192000, kResamplingRMSError, -63.10),
::testing::make_tuple(16000, 192000, kResamplingRMSError, -63.14),
::testing::make_tuple(32000, 192000, kResamplingRMSError, -63.38),
::testing::make_tuple(44100, 192000, kResamplingRMSError, -62.63),
::testing::make_tuple(48000, 192000, kResamplingRMSError, -73.44),
::testing::make_tuple(96000, 192000, kResamplingRMSError, -73.52),
::testing::make_tuple(192000, 192000, kResamplingRMSError, -73.52),
// Next run through some additional cases interesting for WebRTC.
// We skip some extreme downsampled cases (192 -> {8, 16}, 96 -> 8)
// because they violate |kHighFrequencyMaxError|, which is not
// unexpected. It's very unlikely that we'll see these conversions in
// practice anyway.
// To 8 kHz
::testing::make_tuple(8000, 8000, kResamplingRMSError, -75.50),
::testing::make_tuple(16000, 8000, -18.56, -28.79),
::testing::make_tuple(32000, 8000, -20.36, -14.13),
::testing::make_tuple(44100, 8000, -21.00, -11.39),
::testing::make_tuple(48000, 8000, -20.96, -11.04),
// To 16 kHz
::testing::make_tuple(8000, 16000, kResamplingRMSError, -70.30),
::testing::make_tuple(16000, 16000, kResamplingRMSError, -75.51),
::testing::make_tuple(32000, 16000, -18.48, -28.59),
::testing::make_tuple(44100, 16000, -19.30, -19.67),
::testing::make_tuple(48000, 16000, -19.81, -18.11),
::testing::make_tuple(96000, 16000, -20.95, -10.96),
// To 32 kHz
::testing::make_tuple(8000, 32000, kResamplingRMSError, -70.30),
::testing::make_tuple(16000, 32000, kResamplingRMSError, -75.51),
::testing::make_tuple(32000, 32000, kResamplingRMSError, -75.51),
::testing::make_tuple(44100, 32000, -16.44, -51.10),
::testing::make_tuple(48000, 32000, -16.90, -44.03),
::testing::make_tuple(96000, 32000, -19.61, -18.04),
::testing::make_tuple(192000, 32000, -21.02, -10.94)));
} // namespace webrtc
| [
"changhyeok.bae@lge.com"
] | changhyeok.bae@lge.com |
ccc8094901f7884326363b5901f33ee475ca37ed | 8304dce0451d1c6929c4a038d59d1a322859f09e | /src/libzerocoin/Denominations.cpp | 44d102a7bcfb03d2a15c2710ca6592481944be8f | [
"MIT"
] | permissive | AnkerPay/Anker | 07c04eb0f4bdd21406dfaa65fc1779292d47e24e | a20a6e911c35c480da222e0ed95b673922d8de5d | refs/heads/master | 2021-06-26T06:00:45.053462 | 2020-10-29T09:18:55 | 2020-10-29T09:18:55 | 167,381,545 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 4,022 | cpp | /**
* @file Denominations.cpp
*
* @brief Functions for converting to/from Zerocoin Denominations to other values library.
*
* @copyright Copyright 2017 PIVX Developers
* @license This project is released under the MIT license.
**/
#include "Denominations.h"
#include "amount.h"
namespace libzerocoin {
// All denomination values should only exist in these routines for consistency.
// For serialization/unserialization enums are converted to int (denoted enumvalue in function name)
CoinDenomination IntToZerocoinDenomination(int64_t amount)
{
CoinDenomination denomination;
switch (amount) {
case 1: denomination = CoinDenomination::ZQ_ONE; break;
case 5: denomination = CoinDenomination::ZQ_FIVE; break;
case 10: denomination = CoinDenomination::ZQ_TEN; break;
case 50: denomination = CoinDenomination::ZQ_FIFTY; break;
case 100: denomination = CoinDenomination::ZQ_ONE_HUNDRED; break;
case 500: denomination = CoinDenomination::ZQ_FIVE_HUNDRED; break;
case 1000: denomination = CoinDenomination::ZQ_ONE_THOUSAND; break;
case 5000: denomination = CoinDenomination::ZQ_FIVE_THOUSAND; break;
default:
//not a valid denomination
denomination = CoinDenomination::ZQ_ERROR; break;
}
return denomination;
}
int64_t ZerocoinDenominationToInt(const CoinDenomination& denomination)
{
int64_t Value = 0;
switch (denomination) {
case CoinDenomination::ZQ_ONE: Value = 1; break;
case CoinDenomination::ZQ_FIVE: Value = 5; break;
case CoinDenomination::ZQ_TEN: Value = 10; break;
case CoinDenomination::ZQ_FIFTY : Value = 50; break;
case CoinDenomination::ZQ_ONE_HUNDRED: Value = 100; break;
case CoinDenomination::ZQ_FIVE_HUNDRED: Value = 500; break;
case CoinDenomination::ZQ_ONE_THOUSAND: Value = 1000; break;
case CoinDenomination::ZQ_FIVE_THOUSAND: Value = 5000; break;
default:
// Error Case
Value = 0; break;
}
return Value;
}
CoinDenomination AmountToZerocoinDenomination(CAmount amount)
{
// Check to make sure amount is an exact integer number of COINS
CAmount residual_amount = amount - COIN * (amount / COIN);
if (residual_amount == 0) {
return IntToZerocoinDenomination(amount/COIN);
} else {
return CoinDenomination::ZQ_ERROR;
}
}
// return the highest denomination that is less than or equal to the amount given
// use case: converting Ank to zAnk without user worrying about denomination math themselves
CoinDenomination AmountToClosestDenomination(CAmount nAmount, CAmount& nRemaining)
{
if (nAmount < 1 * COIN)
return ZQ_ERROR;
CAmount nConvert = nAmount / COIN;
CoinDenomination denomination = ZQ_ERROR;
for (unsigned int i = 0; i < zerocoinDenomList.size(); i++) {
denomination = zerocoinDenomList[i];
//exact match
if (nConvert == denomination) {
nRemaining = 0;
return denomination;
}
//we are beyond the value, use previous denomination
if (denomination > nConvert && i) {
CoinDenomination d = zerocoinDenomList[i - 1];
nRemaining = nConvert - d;
return d;
}
}
//last denomination, the highest value possible
nRemaining = nConvert - denomination;
return denomination;
}
CAmount ZerocoinDenominationToAmount(const CoinDenomination& denomination)
{
CAmount nValue = COIN * ZerocoinDenominationToInt(denomination);
return nValue;
}
CoinDenomination get_denomination(std::string denomAmount) {
int64_t val = std::stoi(denomAmount);
return IntToZerocoinDenomination(val);
}
int64_t get_amount(std::string denomAmount) {
int64_t nAmount = 0;
CoinDenomination denom = get_denomination(denomAmount);
if (denom == ZQ_ERROR) {
// SHOULD WE THROW EXCEPTION or Something?
nAmount = 0;
} else {
nAmount = ZerocoinDenominationToAmount(denom);
}
return nAmount;
}
} /* namespace libzerocoin */
| [
"vtitch@gmail.com"
] | vtitch@gmail.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.