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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
6b25f4409dde5b5a18900631a0a601128e65a2bb | e8454774543913375c6f8620941efcc6ee17fd0d | /codeforces/Connected.cpp | 5004b7b38384f0a4629ce72385923d6635021435 | [] | no_license | priyamraj/Competitive-Programming | 9930fafa677010706fb01ca249c214dd87d41a34 | 813710f839d54f6539dce51f2541e1f557548f8a | refs/heads/master | 2021-05-11T19:58:02.100421 | 2018-02-13T14:43:28 | 2018-02-13T14:43:28 | 117,427,460 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,191 | cpp | #include<unordered_set>
#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <set>
#include <vector>
#include <cstring>
#include <string>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <complex>
#include <map>
#include <queue>
#include <limits.h>
#include<iostream>
using namespace std;
static const int mx=200007;
static int n,m,ans;
static int done[mx];
static map<int, unordered_set<int> > hs;
void dfs(int v){
if(done[v]) return;
done[v]=1;
ans++;
for(int i=1;i<=n;i++){
if(v==i || done[i]==1) continue;
if(hs[v].find(i) == hs[v].end())
dfs(i);
}
}
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);cout.tie(0);
cin>>n>>m;
memset(done,0,mx);
for(int i=1;i<=n;i++) hs[i].insert(-1);
for(int i=0;i<m;i++){
int v1,v2;
cin>>v1>>v2;
hs[v1].insert(v2);
hs[v2].insert(v1);
}
int cons=0;
vector<int> res;
for(int i=1;i<=n;i++){
if(done[i]) continue;
ans=0;
dfs(i);
cons++;
res.push_back(ans);
}
sort(res.begin(),res.end());
cout << cons << endl;
for(int i=0;i<res.size();i++)
cout << res[i] << " ";
return 0;
}
| [
"priyamraj97@gmail.com"
] | priyamraj97@gmail.com |
71196d105ffb5b1600625d5bf81870b84de68fd8 | 50c3f4b74e883b672ef31ca9171ffd90cd8cf230 | /src/jvm/thread/Mutex.cpp | 81dc42f5f7ee298bbbe71dea6105524b05abdf1c | [] | no_license | morgenthum/coldspot | bf34b47d149dac321feffef082680fff2911dd6e | c93744779a6be1c31f00ddd1f1ae14cc6a05f0f3 | refs/heads/master | 2020-06-30T01:24:53.529542 | 2019-08-05T15:26:23 | 2019-08-05T15:26:23 | 200,678,822 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,079 | cpp | ////////////////////////////////////////////////////////////////////////////////
// //
// ColdSpot, a Java virtual machine implementation. //
// Copyright (C) 2014, Mario Morgenthum //
// //
// //
// This program is free software: you can redistribute it and/or modify //
// it under the terms of the GNU General Public License as published by //
// the Free Software Foundation, either version 3 of the License, or //
// (at your option) any later version. //
// //
// This program is distributed in the hope that it will be useful, //
// but WITHOUT ANY WARRANTY; without even the implied warranty of //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
// GNU General Public License for more details. //
// //
// You should have received a copy of the GNU General Public License //
// along with this program. If not, see <http://www.gnu.org/licenses/>. //
// //
////////////////////////////////////////////////////////////////////////////////
#include <jvm/Global.hpp>
namespace coldspot
{
class Mutex::MutexImpl
{
public:
pthread_mutexattr_t attributes;
pthread_mutex_t mutex;
};
Mutex::Mutex()
{
_impl = new MutexImpl;
// TODO error handling
pthread_mutexattr_init(&_impl->attributes);
pthread_mutexattr_settype(&_impl->attributes, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&_impl->mutex, &_impl->attributes);
}
Mutex::~Mutex()
{
pthread_mutexattr_destroy(&_impl->attributes);
pthread_mutex_destroy(&_impl->mutex);
DELETE_OBJECT(_impl)
}
bool Mutex::try_lock()
{
return pthread_mutex_trylock(&_impl->mutex) == 0;
}
void Mutex::lock()
{
if (_current_thread != 0)
{
_current_thread->set_state(THREADSTATE_BLOCKED);
}
int error;
if ((error = pthread_mutex_lock(&_impl->mutex)) != 0)
{
EXIT_FATAL("pthread_mutex_lock failed: " << error)
}
if (_current_thread != 0)
{
_current_thread->set_state(THREADSTATE_RUNNABLE);
}
}
void Mutex::unlock()
{
int error;
if ((error = pthread_mutex_unlock(&_impl->mutex)) != 0)
{
EXIT_FATAL("pthread_mutex_unlock failed: " << error)
}
}
void *Mutex::native_handle_ptr() const
{
return &_impl->mutex;
}
}
| [
"dcast.xyz@mail.ru"
] | dcast.xyz@mail.ru |
4f8f343b9529c5e25c3af3d89ab06911ea2ee7ee | dbd87d28e0854bf47682a39d93b472a5cfeab17e | /src/qt/askpassphrasedialog.cpp | c580ad8c7971a0dc1f9eac9c88b504f78c0020f7 | [
"MIT"
] | permissive | C00KI8/eclipse | 8bc2d7dda40a3808c8264d5e2fb80dfb15da48ab | 2b422294b7954cd547ba3df348ef786a9ac6b2e6 | refs/heads/master | 2022-10-08T19:56:31.790806 | 2020-06-15T03:17:28 | 2020-06-15T03:17:28 | 272,317,997 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,911 | cpp | // Copyright (c) 2011-2013 The Bitcoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "askpassphrasedialog.h"
#include "ui_askpassphrasedialog.h"
#include "guiconstants.h"
#include "walletmodel.h"
#include <QMessageBox>
#include <QPushButton>
#include <QKeyEvent>
AskPassphraseDialog::AskPassphraseDialog(Mode mode, QWidget *parent) :
QDialog(parent),
ui(new Ui::AskPassphraseDialog),
mode(mode),
model(0),
fCapsLock(false)
{
ui->setupUi(this);
ui->passEdit1->setMaxLength(MAX_PASSPHRASE_SIZE);
ui->passEdit2->setMaxLength(MAX_PASSPHRASE_SIZE);
ui->passEdit3->setMaxLength(MAX_PASSPHRASE_SIZE);
// Setup Caps Lock detection.
ui->passEdit1->installEventFilter(this);
ui->passEdit2->installEventFilter(this);
ui->passEdit3->installEventFilter(this);
switch(mode)
{
case Encrypt: // Ask passphrase x2
ui->passLabel1->hide();
ui->passEdit1->hide();
ui->warningLabel->setText(tr("Enter the new passphrase to the wallet.<br/>Please use a passphrase of <b>10 or more random characters</b>, or <b>eight or more words</b>."));
setWindowTitle(tr("Encrypt wallet"));
break;
case Unlock: // Ask passphrase
ui->warningLabel->setText(tr("This operation needs your wallet passphrase to unlock the wallet."));
ui->passLabel2->hide();
ui->passEdit2->hide();
ui->passLabel3->hide();
ui->passEdit3->hide();
setWindowTitle(tr("Unlock wallet"));
break;
case Decrypt: // Ask passphrase
ui->warningLabel->setText(tr("This operation needs your wallet passphrase to decrypt the wallet."));
ui->passLabel2->hide();
ui->passEdit2->hide();
ui->passLabel3->hide();
ui->passEdit3->hide();
setWindowTitle(tr("Decrypt wallet"));
break;
case ChangePass: // Ask old passphrase + new passphrase x2
setWindowTitle(tr("Change passphrase"));
ui->warningLabel->setText(tr("Enter the old and new passphrase to the wallet."));
break;
}
textChanged();
connect(ui->passEdit1, SIGNAL(textChanged(QString)), this, SLOT(textChanged()));
connect(ui->passEdit2, SIGNAL(textChanged(QString)), this, SLOT(textChanged()));
connect(ui->passEdit3, SIGNAL(textChanged(QString)), this, SLOT(textChanged()));
}
AskPassphraseDialog::~AskPassphraseDialog()
{
// Attempt to overwrite text so that they do not linger around in memory
ui->passEdit1->setText(QString(" ").repeated(ui->passEdit1->text().size()));
ui->passEdit2->setText(QString(" ").repeated(ui->passEdit2->text().size()));
ui->passEdit3->setText(QString(" ").repeated(ui->passEdit3->text().size()));
delete ui;
}
void AskPassphraseDialog::setModel(WalletModel *model)
{
this->model = model;
}
void AskPassphraseDialog::accept()
{
SecureString oldpass, newpass1, newpass2;
if(!model)
return;
oldpass.reserve(MAX_PASSPHRASE_SIZE);
newpass1.reserve(MAX_PASSPHRASE_SIZE);
newpass2.reserve(MAX_PASSPHRASE_SIZE);
// TODO: get rid of this .c_str() by implementing SecureString::operator=(std::string)
// Alternately, find a way to make this input mlock()'d to begin with.
oldpass.assign(ui->passEdit1->text().toStdString().c_str());
newpass1.assign(ui->passEdit2->text().toStdString().c_str());
newpass2.assign(ui->passEdit3->text().toStdString().c_str());
switch(mode)
{
case Encrypt: {
if(newpass1.empty() || newpass2.empty())
{
// Cannot encrypt with empty passphrase
break;
}
QMessageBox::StandardButton retval = QMessageBox::question(this, tr("Confirm wallet encryption"),
tr("Warning: If you encrypt your wallet and lose your passphrase, you will <b>LOSE ALL OF YOUR ECLIPSES</b>!") + "<br><br>" + tr("Are you sure you wish to encrypt your wallet?"),
QMessageBox::Yes|QMessageBox::Cancel,
QMessageBox::Cancel);
if(retval == QMessageBox::Yes)
{
if(newpass1 == newpass2)
{
if(model->setWalletEncrypted(true, newpass1))
{
QMessageBox::warning(this, tr("Wallet encrypted"),
"<qt>" +
tr("Eclipse will close now to finish the encryption process. "
"Remember that encrypting your wallet cannot fully protect "
"your eclipses from being stolen by malware infecting your computer.") +
"<br><br><b>" +
tr("IMPORTANT: Any previous backups you have made of your wallet file "
"should be replaced with the newly generated, encrypted wallet file. "
"For security reasons, previous backups of the unencrypted wallet file "
"will become useless as soon as you start using the new, encrypted wallet.") +
"</b></qt>");
QApplication::quit();
}
else
{
QMessageBox::critical(this, tr("Wallet encryption failed"),
tr("Wallet encryption failed due to an internal error. Your wallet was not encrypted."));
}
QDialog::accept(); // Success
}
else
{
QMessageBox::critical(this, tr("Wallet encryption failed"),
tr("The supplied passphrases do not match."));
}
}
else
{
QDialog::reject(); // Cancelled
}
} break;
case Unlock:
if(!model->setWalletLocked(false, oldpass))
{
QMessageBox::critical(this, tr("Wallet unlock failed"),
tr("The passphrase entered for the wallet decryption was incorrect."));
}
else
{
QDialog::accept(); // Success
}
break;
case Decrypt:
if(!model->setWalletEncrypted(false, oldpass))
{
QMessageBox::critical(this, tr("Wallet decryption failed"),
tr("The passphrase entered for the wallet decryption was incorrect."));
}
else
{
QDialog::accept(); // Success
}
break;
case ChangePass:
if(newpass1 == newpass2)
{
if(model->changePassphrase(oldpass, newpass1))
{
QMessageBox::information(this, tr("Wallet encrypted"),
tr("Wallet passphrase was successfully changed."));
QDialog::accept(); // Success
}
else
{
QMessageBox::critical(this, tr("Wallet encryption failed"),
tr("The passphrase entered for the wallet decryption was incorrect."));
}
}
else
{
QMessageBox::critical(this, tr("Wallet encryption failed"),
tr("The supplied passphrases do not match."));
}
break;
}
}
void AskPassphraseDialog::textChanged()
{
// Validate input, set Ok button to enabled when acceptable
bool acceptable = false;
switch(mode)
{
case Encrypt: // New passphrase x2
acceptable = !ui->passEdit2->text().isEmpty() && !ui->passEdit3->text().isEmpty();
break;
case Unlock: // Old passphrase x1
case Decrypt:
acceptable = !ui->passEdit1->text().isEmpty();
break;
case ChangePass: // Old passphrase x1, new passphrase x2
acceptable = !ui->passEdit1->text().isEmpty() && !ui->passEdit2->text().isEmpty() && !ui->passEdit3->text().isEmpty();
break;
}
ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(acceptable);
}
bool AskPassphraseDialog::event(QEvent *event)
{
// Detect Caps Lock key press.
if (event->type() == QEvent::KeyPress) {
QKeyEvent *ke = static_cast<QKeyEvent *>(event);
if (ke->key() == Qt::Key_CapsLock) {
fCapsLock = !fCapsLock;
}
if (fCapsLock) {
ui->capsLabel->setText(tr("Warning: The Caps Lock key is on!"));
} else {
ui->capsLabel->clear();
}
}
return QWidget::event(event);
}
bool AskPassphraseDialog::eventFilter(QObject *object, QEvent *event)
{
/* Detect Caps Lock.
* There is no good OS-independent way to check a key state in Qt, but we
* can detect Caps Lock by checking for the following condition:
* Shift key is down and the result is a lower case character, or
* Shift key is not down and the result is an upper case character.
*/
if (event->type() == QEvent::KeyPress) {
QKeyEvent *ke = static_cast<QKeyEvent *>(event);
QString str = ke->text();
if (str.length() != 0) {
const QChar *psz = str.unicode();
bool fShift = (ke->modifiers() & Qt::ShiftModifier) != 0;
if ((fShift && *psz >= 'a' && *psz <= 'z') || (!fShift && *psz >= 'A' && *psz <= 'Z')) {
fCapsLock = true;
ui->capsLabel->setText(tr("Warning: The Caps Lock key is on!"));
} else if (psz->isLetter()) {
fCapsLock = false;
ui->capsLabel->clear();
}
}
}
return QDialog::eventFilter(object, event);
}
| [
"binaryc8de@gmail.com"
] | binaryc8de@gmail.com |
f5545f0ea93a0c3e2671f8ec4c1caf06e977eabb | 5e3b7fb65ecc60d684cd47133e91d8440cff3fc4 | /devices/include/device.hpp | b52d30d96ace9d9d324b50c16ca84041cc2972f1 | [
"MIT"
] | permissive | cqzhanghy/opencvr | 951ba867f5bc8725b9f1b4ab299aa709d5ddee87 | b735863d377c8f933287607aaecce0b89f433bc2 | refs/heads/master | 2021-01-14T14:01:56.016585 | 2015-05-04T14:03:33 | 2015-05-04T14:03:33 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,148 | hpp | //------------------------------------------------------------------------------
// File: device.hpp
//
// Desc: Device factory - Manage IP Camera.
//
// Copyright (c) 2014-2018 opencvr.com All rights reserved.
//------------------------------------------------------------------------------
#ifndef __VSC_DEVICE_H_
#define __VSC_DEVICE_H_
#define NOMINMAX
#ifdef WIN32
#include <Windows.h>
#include <Winbase.h>
#endif
#include "utility.hpp"
#include "conf.hpp"
#include "devicemanagement.h"
#include "ptzmanagement.h"
#include "media_management/profiles.h"
#include "media_management/streamuri.h"
#include "device_management/capabilities.h"
#include "mediamanagement.h"
#include "vdb.hpp"
#include "vhdfsdb.hpp"
#include "hdfsrecsession.hpp"
#include "vplay.hpp"
#include "debug.hpp"
using namespace UtilityLib;
using namespace std;
using namespace ONVIF;
typedef enum
{
F_PTZ_UP = 1,
F_PTZ_DOWN,
F_PTZ_LEFT,
F_PTZ_RIGHT,
F_PTZ_ZOOM_IN,
F_PTZ_ZOOM_OUT,
F_PTZ_STOP,
F_PTZ_LAST
} FPtzAction;
typedef enum
{
DEV_OFF2ON = 1,
DEV_ON2OFF,
DEV_NO_CHANGE,
DEV_LAST
} DeviceStatus;
/* Device video data callback */
#ifdef WIN32
/* Compressed data callback */
typedef void (__cdecl * DeviceDataCallbackFunctionPtr)(VideoFrame& frame, void * pParam);
/* Raw data callback */
typedef void (__cdecl * DeviceRawCallbackFunctionPtr)(RawFrame& frame, void * pParam);
/* Video Seq callback */
typedef void (__cdecl * DeviceSeqCallbackFunctionPtr)(VideoSeqFrame& frame, void * pParam);
/* Device Delete function */
typedef void (__cdecl * DeviceDelCallbackFunctionPtr)(void * pParam);
#else
/* Compressed data callback */
typedef void ( * DeviceDataCallbackFunctionPtr)(VideoFrame& frame, void * pParam);
/* Raw data callback */
typedef void ( * DeviceRawCallbackFunctionPtr)(RawFrame& frame, void * pParam);
/* Video Seq callback */
typedef void ( * DeviceSeqCallbackFunctionPtr)(VideoSeqFrame& frame, void * pParam);
/* Device Delete function */
typedef void ( * DeviceDelCallbackFunctionPtr)(void * pParam);
#endif
typedef std::map<void *, DeviceDataCallbackFunctionPtr> DeviceDataCallbackMap;
typedef std::map<void *, DeviceRawCallbackFunctionPtr> DeviceRawCallbackMap;
typedef std::map<void *, DeviceSeqCallbackFunctionPtr> DeviceSeqCallbackMap;
typedef std::map<void *, DeviceDelCallbackFunctionPtr> DeviceDelCallbackMap;
class DeviceParam
{
public:
inline DeviceParam();
inline DeviceParam(const DeviceParam &pParam);
inline DeviceParam(VSCDeviceData &pData);
inline ~DeviceParam();
DeviceParam & operator=(const DeviceParam &pParam)
{
memset(&m_Conf, 0, sizeof(m_Conf));
memcpy(&m_Conf, &(pParam.m_Conf), sizeof(m_Conf));
m_strUrl = pParam.m_strUrl;
m_strUrlSubStream = pParam.m_strUrlSubStream;
m_bHasSubStream = pParam.m_bHasSubStream;
m_bOnvifUrlGetted = pParam.m_bOnvifUrlGetted;
m_Online = pParam.m_Online;
return *this;
}
public:
inline BOOL UpdateUrl();
inline BOOL UpdateUrlOnvif();
inline BOOL CheckOnline();
public:
VSCDeviceData m_Conf;
BOOL m_bOnvifUrlGetted;
astring m_strUrl;
astring m_strUrlSubStream;
BOOL m_bHasSubStream;
BOOL m_Online;
BOOL m_OnlineUrl;
/* backend status */
BOOL m_wipOnline;
BOOL m_wipOnlineUrl;
};
class VIPCDeviceParam
{
public:
inline VIPCDeviceParam()
{
memset(&m_Conf, 0, sizeof(m_Conf));
VSCVIPCDataItemDefault(m_Conf.data.conf);
}
inline VIPCDeviceParam(const VIPCDeviceParam &pParam)
{
memset(&m_Conf, 0, sizeof(m_Conf));
memcpy(&m_Conf, &(pParam.m_Conf), sizeof(m_Conf));
}
inline VIPCDeviceParam(VSCVIPCData &pData)
{
memset(&m_Conf, 0, sizeof(m_Conf));
memcpy(&m_Conf, &(pData), sizeof(m_Conf));
}
inline ~VIPCDeviceParam(){}
VIPCDeviceParam & operator=(const VIPCDeviceParam &pParam)
{
memset(&m_Conf, 0, sizeof(m_Conf));
memcpy(&m_Conf, &(pParam.m_Conf), sizeof(m_Conf));
return *this;
}
public:
VSCVIPCData m_Conf;
};
class Device
{
public:
inline Device(VDB &pVdb, VHdfsDB &pVHdfsdb, const DeviceParam &pParam);
inline ~Device();
public:
/* Below api is for a new thread to do some network task whitch may be blocked */
inline BOOL GetDeviceParam(DeviceParam &pParam);
public:
inline BOOL StartData();
inline BOOL StopData();
inline BOOL StartSubData();
inline BOOL StopSubData();
inline BOOL StartRaw();
inline BOOL StopRaw();
inline BOOL StartSubRaw();
inline BOOL StopSubRaw();
inline BOOL StartRecord();
inline BOOL StopRecord();
inline BOOL StartHdfsRecord();
inline BOOL StopHdfsRecord();
inline BOOL SetRecord(BOOL bRecording);
inline BOOL SetHdfsRecord(BOOL bRecording);
inline DeviceStatus CheckDevice(astring strUrl, astring strUrlSubStream,
BOOL bHasSubStream, BOOL bOnline, BOOL bOnlineUrl);
public:
/* Data */
inline static BOOL DataHandler(void* pData, VideoFrame& frame);
inline BOOL DataHandler1(VideoFrame& frame);
inline static BOOL SubDataHandler(void* pData, VideoFrame& frame);
inline BOOL SubDataHandler1(VideoFrame& frame);
/* Raw Data */
inline static BOOL RawHandler(void* pData, RawFrame& frame);
inline BOOL RawHandler1(RawFrame& frame);
inline static BOOL SubRawHandler(void* pData, RawFrame& frame);
inline BOOL SubRawHandler1(RawFrame& frame);
/* Seq data */
inline static BOOL SeqHandler(void* pData, VideoSeqFrame& frame);
inline BOOL SeqHandler1(VideoSeqFrame& frame);
public:
inline void Lock(){m_Lock.lock();}
inline void UnLock(){m_Lock.unlock();}
inline void SubLock(){m_SubLock.lock();}
inline void SubUnLock(){m_SubLock.unlock();}
inline void SeqLock(){m_SeqLock.lock();}
inline void SeqUnLock(){m_SeqLock.unlock();}
public:
/* Data callback*/
inline BOOL RegDataCallback(DeviceDataCallbackFunctionPtr pCallback, void * pParam);
inline BOOL UnRegDataCallback(void * pParam);
inline BOOL RegSubDataCallback(DeviceDataCallbackFunctionPtr pCallback, void * pParam);
inline BOOL UnRegSubDataCallback(void * pParam);
/*Raw Data callback*/
inline BOOL RegRawCallback(DeviceRawCallbackFunctionPtr pCallback, void * pParam);
inline BOOL UnRegRawCallback(void * pParam);
inline BOOL RegSubRawCallback(DeviceRawCallbackFunctionPtr pCallback, void * pParam);
inline BOOL UnRegSubRawCallback(void * pParam);
/* Video Seq data callback */
inline BOOL RegSeqCallback(DeviceSeqCallbackFunctionPtr pCallback, void * pParam);
inline BOOL UnRegSeqCallback(void * pParam);
inline BOOL RegDelCallback(DeviceDelCallbackFunctionPtr pCallback, void * pParam);
inline BOOL UnRegDelCallback(void * pParam);
inline BOOL GetInfoFrame(InfoFrame &pFrame);
inline BOOL GetSubInfoFrame(InfoFrame &pFrame);
inline BOOL Cleanup();
inline BOOL GetDeviceOnline();
inline BOOL GetUrl(std::string &url);
inline BOOL GetDeviceRtspUrl(astring & strUrl);
inline BOOL AttachPlayer(HWND hWnd, int w, int h);
inline BOOL UpdateWidget(HWND hWnd, int w, int h);
inline BOOL DetachPlayer(HWND hWnd);
inline BOOL EnablePtz(HWND hWnd, bool enable);
inline BOOL DrawPtzDirection(HWND hWnd, int x1, int y1, int x2, int y2);
inline BOOL ClearPtzDirection(HWND hWnd);
inline BOOL ShowAlarm(HWND hWnd);
inline BOOL PtzAction(FPtzAction action, float speed);
inline BOOL UpdatePTZConf();
private:
VPlay *m_pvPlay;
VPlay *m_pvPlaySubStream;
VPlay &m_vPlay;
VPlay &m_vPlaySubStream;
BOOL m_bStarted;
BOOL m_bSubStarted;
DeviceDataCallbackMap m_DataMap;
DeviceDataCallbackMap m_SubDataMap;
DeviceRawCallbackMap m_RawMap;
DeviceRawCallbackMap m_SubRawMap;
DeviceSeqCallbackMap m_SeqMap;
DeviceDelCallbackMap m_DelMap;
private:
s32 m_nDeviceType;
s32 m_nDeviceSubType;
DeviceParam m_param;
tthread::thread *m_pThread;
fast_mutex m_Lock;
fast_mutex m_SubLock;
fast_mutex m_SeqLock;
private:
VDB &m_pVdb;
VHdfsDB &m_pVHdfsdb;
RecordSession *m_pRecord;
HdfsRecSession *m_pHdfsRecord;
private:
ContinuousMove m_continuousMove;
ONVIF::Stop m_stop;
PtzManagement *m_ptz;
BOOL m_ptzInited;
InfoFrame m_infoData;
BOOL m_bGotInfoData;
s32 m_nDataRef;
private:
InfoFrame m_infoSubData;
BOOL m_bGotInfoSubData;
s32 m_nSubDataRef;
s32 m_nRawRef;
s32 m_nSubRawRef;
};
typedef DeviceParam* LPDeviceParam;
typedef Device* LPDevice;
#include "deviceimpl.hpp"
#endif // __VSC_DEVICE_H_
| [
"xsmart@163.com"
] | xsmart@163.com |
1e456079bfeabc6fc7c8067835ed496652e645f3 | fc4ec8267bc50bbc38da9894542fddfbf08a3ae4 | /freecad-0.14.3702/src/Gui/DlgCommandsImp.cpp | 26f1c51a7a713d2c6a84be98c5e79998c5c3bf77 | [] | no_license | AlexandreRivet/HomeMaker | c6252aa864780732dd675ab26e5474d84aa7e5f4 | f483afea21c915e9208cb360046942a0fb26011c | refs/heads/master | 2020-12-24T15:58:53.228813 | 2015-02-01T22:21:11 | 2015-02-01T22:21:11 | 29,052,719 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 10,573 | cpp | /***************************************************************************
* Copyright (c) 2004 Werner Mayer <wmayer[at]users.sourceforge.net> *
* *
* This file is part of the FreeCAD CAx development system. *
* *
* This library is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Library General Public *
* License as published by the Free Software Foundation; either *
* version 2 of the License, or (at your option) any later version. *
* *
* This library is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Library General Public License for more details. *
* *
* You should have received a copy of the GNU Library General Public *
* License along with this library; see the file COPYING.LIB. If not, *
* write to the Free Software Foundation, Inc., 59 Temple Place, *
* Suite 330, Boston, MA 02111-1307, USA *
* *
***************************************************************************/
#include "PreCompiled.h"
#ifndef _PreComp_
# include <QHeaderView>
# include <QTreeWidgetItemIterator>
# include <algorithm>
# include <vector>
#endif
#include "DlgCommandsImp.h"
#include "Application.h"
#include "Command.h"
#include "BitmapFactory.h"
#include "Widgets.h"
using namespace Gui::Dialog;
namespace Gui { namespace Dialog {
typedef std::vector< std::pair<QLatin1String, QString> > GroupMap;
struct GroupMap_find {
const QLatin1String& item;
GroupMap_find(const QLatin1String& item) : item(item) {}
bool operator () (const std::pair<QLatin1String, QString>& elem) const
{
return elem.first == item;
}
};
}
}
/* TRANSLATOR Gui::Dialog::DlgCustomCommandsImp */
/**
* Constructs a DlgCustomCommandsImp which is a child of 'parent', with the
* name 'name' and widget flags set to 'f'
*
* The dialog will by default be modeless, unless you set 'modal' to
* TRUE to construct a modal dialog.
*/
DlgCustomCommandsImp::DlgCustomCommandsImp( QWidget* parent )
: CustomizeActionPage(parent)
{
this->setupUi(this);
// paints for active and inactive the same color
QPalette pal = categoryTreeWidget->palette();
pal.setColor(QPalette::Inactive, QPalette::Highlight, pal.color(QPalette::Active, QPalette::Highlight));
pal.setColor(QPalette::Inactive, QPalette::HighlightedText, pal.color(QPalette::Active, QPalette::HighlightedText));
categoryTreeWidget->setPalette( pal );
connect(commandTreeWidget, SIGNAL(currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)),
this, SLOT(onDescription(QTreeWidgetItem*)));
connect(categoryTreeWidget, SIGNAL(currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)),
this, SLOT(onGroupActivated(QTreeWidgetItem*)));
CommandManager & cCmdMgr = Application::Instance->commandManager();
std::map<std::string,Command*> sCommands = cCmdMgr.getCommands();
GroupMap groupMap;
groupMap.push_back(std::make_pair(QLatin1String("File"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("Edit"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("View"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("Standard-View"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("Tools"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("Window"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("Help"), QString()));
groupMap.push_back(std::make_pair(QLatin1String("Macros"), qApp->translate("Gui::MacroCommand", "Macros")));
for (std::map<std::string,Command*>::iterator it = sCommands.begin(); it != sCommands.end(); ++it) {
QLatin1String group(it->second->getGroupName());
QString text = qApp->translate(it->second->className(), it->second->getGroupName());
GroupMap::iterator jt;
jt = std::find_if(groupMap.begin(), groupMap.end(), GroupMap_find(group));
if (jt != groupMap.end())
jt->second = text;
else
groupMap.push_back(std::make_pair(group, text));
}
QStringList labels; labels << tr("Category");
categoryTreeWidget->setHeaderLabels(labels);
for (GroupMap::iterator it = groupMap.begin(); it != groupMap.end(); ++it) {
QTreeWidgetItem* item = new QTreeWidgetItem(categoryTreeWidget);
item->setText(0, it->second);
item->setData(0, Qt::UserRole, QVariant(it->first));
}
labels.clear();
labels << tr("Icon") << tr("Command");
commandTreeWidget->setHeaderLabels(labels);
commandTreeWidget->header()->hide();
commandTreeWidget->setIconSize(QSize(32, 32));
commandTreeWidget->header()->setResizeMode(0, QHeaderView::ResizeToContents);
categoryTreeWidget->setCurrentItem(categoryTreeWidget->topLevelItem(0));
}
/** Destroys the object and frees any allocated resources */
DlgCustomCommandsImp::~DlgCustomCommandsImp()
{
}
/** Shows the description for the corresponding command */
void DlgCustomCommandsImp::onDescription(QTreeWidgetItem *item)
{
if (item)
textLabel->setText(item->toolTip(1));
else
textLabel->setText(QString());
}
/** Shows all commands of this category */
void DlgCustomCommandsImp::onGroupActivated(QTreeWidgetItem* item)
{
if (!item)
return;
QVariant data = item->data(0, Qt::UserRole);
QString group = data.toString();
commandTreeWidget->clear();
CommandManager & cCmdMgr = Application::Instance->commandManager();
std::vector<Command*> aCmds = cCmdMgr.getGroupCommands(group.toAscii());
for (std::vector<Command*>::iterator it = aCmds.begin(); it != aCmds.end(); ++it) {
QTreeWidgetItem* item = new QTreeWidgetItem(commandTreeWidget);
item->setText(1, qApp->translate((*it)->className(), (*it)->getMenuText()));
item->setToolTip(1, qApp->translate((*it)->className(), (*it)->getToolTipText()));
item->setData(1, Qt::UserRole, QByteArray((*it)->getName()));
item->setSizeHint(0, QSize(32, 32));
if ((*it)->getPixmap())
item->setIcon(0, BitmapFactory().pixmap((*it)->getPixmap()));
}
textLabel->setText(QString());
}
void DlgCustomCommandsImp::onAddMacroAction(const QByteArray& macro)
{
QTreeWidgetItem* item = categoryTreeWidget->currentItem();
if (!item)
return;
QVariant data = item->data(0, Qt::UserRole);
QString group = data.toString();
if (group == QLatin1String("Macros"))
{
CommandManager & cCmdMgr = Application::Instance->commandManager();
Command* pCmd = cCmdMgr.getCommandByName(macro);
QTreeWidgetItem* item = new QTreeWidgetItem(commandTreeWidget);
item->setText(1, QString::fromUtf8(pCmd->getMenuText()));
item->setToolTip(1, QString::fromUtf8(pCmd->getToolTipText()));
item->setData(1, Qt::UserRole, macro);
item->setSizeHint(0, QSize(32, 32));
item->setBackgroundColor(0, Qt::lightGray);
if (pCmd->getPixmap())
item->setIcon(0, BitmapFactory().pixmap(pCmd->getPixmap()));
}
}
void DlgCustomCommandsImp::onRemoveMacroAction(const QByteArray& macro)
{
QTreeWidgetItem* item = categoryTreeWidget->currentItem();
if (!item)
return;
QVariant data = item->data(0, Qt::UserRole);
QString group = data.toString();
if (group == QLatin1String("Macros"))
{
for (int i=0; i<commandTreeWidget->topLevelItemCount(); i++) {
QTreeWidgetItem* item = commandTreeWidget->topLevelItem(i);
QByteArray command = item->data(1, Qt::UserRole).toByteArray();
if (command == macro) {
commandTreeWidget->takeTopLevelItem(i);
delete item;
break;
}
}
}
}
void DlgCustomCommandsImp::onModifyMacroAction(const QByteArray& macro)
{
QTreeWidgetItem* item = categoryTreeWidget->currentItem();
if (!item)
return;
QVariant data = item->data(0, Qt::UserRole);
QString group = data.toString();
if (group == QLatin1String("Macros"))
{
CommandManager & cCmdMgr = Application::Instance->commandManager();
Command* pCmd = cCmdMgr.getCommandByName(macro);
for (int i=0; i<commandTreeWidget->topLevelItemCount(); i++) {
QTreeWidgetItem* item = commandTreeWidget->topLevelItem(i);
QByteArray command = item->data(1, Qt::UserRole).toByteArray();
if (command == macro) {
item->setText(1, QString::fromUtf8(pCmd->getMenuText()));
item->setToolTip(1, QString::fromUtf8(pCmd->getToolTipText()));
item->setData(1, Qt::UserRole, macro);
item->setSizeHint(0, QSize(32, 32));
item->setBackgroundColor(0, Qt::lightGray);
if (pCmd->getPixmap())
item->setIcon(0, BitmapFactory().pixmap(pCmd->getPixmap()));
if (commandTreeWidget->isItemSelected(item))
onDescription(item);
break;
}
}
}
}
void DlgCustomCommandsImp::changeEvent(QEvent *e)
{
if (e->type() == QEvent::LanguageChange) {
this->retranslateUi(this);
QStringList labels; labels << tr("Category");
categoryTreeWidget->setHeaderLabels(labels);
CommandManager & cCmdMgr = Application::Instance->commandManager();
QTreeWidgetItemIterator it(categoryTreeWidget);
while (*it) {
QVariant data = (*it)->data(0, Qt::UserRole);
std::vector<Command*> aCmds = cCmdMgr.getGroupCommands(data.toByteArray());
if (!aCmds.empty()) {
QString text = qApp->translate(aCmds[0]->className(), aCmds[0]->getGroupName());
(*it)->setText(0, text);
}
++it;
}
onGroupActivated(categoryTreeWidget->topLevelItem(0));
}
QWidget::changeEvent(e);
}
#include "moc_DlgCommandsImp.cpp"
| [
"alex-rivet94@hotmail.fr"
] | alex-rivet94@hotmail.fr |
2114e00815a48eaf5b503c221da515b12d0fff5d | c50622c69eddabc44aa761bdf15134b8126abe79 | /PBRBox/Model.h | 8d299b45426ddda364027adecd13d003cfeb1c37 | [] | no_license | galapaegos/PBRBox | 82b095656f57a842a6137eaab01300ee741c049a | 79a2bbfd5d73e8b24ab32b58ca9cacd8d05f58e4 | refs/heads/master | 2020-07-03T14:23:42.032704 | 2016-11-29T14:55:23 | 2016-11-29T14:55:23 | 74,162,910 | 0 | 0 | null | 2016-11-18T20:10:05 | 2016-11-18T20:10:04 | null | UTF-8 | C++ | false | false | 926 | h | #pragma once
#include <memory>
#include <vector>
#include <map>
#include <string>
#include "ModelNode.h"
#include "Mesh.h"
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
class Model : public SceneObject
{
friend class ModelLoader;
public:
Model();
Model(const std::string &filename);
virtual ~Model();
//load and save the resource object
virtual void load(const std::string &file);
virtual void save(const std::string &file);
void render();
void renderNode(const ModelNode* node, glm::mat4 transform);
const std::vector<Geometry*>& getMeshes() const { return m_meshes; }
const ModelNode* getHierarchy() const { return m_hierarchy; }
ModelNode* copyHierarchy() const { return m_hierarchy->copyNode(nullptr); }
//gb::AABox3f getAABB() const { return m_AABB; }
//protected:
//gb::AABox3f m_AABB;
std::string m_fileName;
std::vector<Geometry*> m_meshes;
ModelNode* m_hierarchy;
}; | [
"medina-fetterman.1@osu.edu"
] | medina-fetterman.1@osu.edu |
e90b0cf0090d7351b6412e3818bd2f02ca79f57f | 99e494d9ca83ebafdbe6fbebc554ab229edcbacc | /.history/Day 3/Practice/Answers/Caesar Cipher_20210307144208.cpp | cc7a0159034d5a318f2b157c8cc5e8b53f246587 | [] | no_license | Datta2901/CCC | c0364caa1e4937bc7bce68e4847c8d599aef0f59 | 4debb2c1c70df693d0e5f68b5798bd9c7a7ef3dc | refs/heads/master | 2023-04-19T10:05:12.372578 | 2021-04-23T12:50:08 | 2021-04-23T12:50:08 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,246 | cpp | // #include <cmath>
// #include <cstdio>
// #include <vector>
// #include <iostream>
// #include <algorithm>
// using namespace std;
// int main(){
// int n,k;
// string s;
// cin >> n >> s >> k;
// for (int i = 0; i <= n; i++) {
// if (s[i] >= 'ma' && s[i] <= 'z'){
// s[i] = ((s[i] - 'ma' + k) % 26) + 'ma';
// }
// else if (s[i] >= 'A' && s[i] <= 'Z'){
// s[i] = ((s[i] - 'A' + k) % 26) + 'A';
// }
// }
// cout << s << endl;
// return 0;
// }
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <limits.h>
#include <stdbool.h>
int main()
{
int **ma, row,col,i,j,k,s1=0,s2=0;
scanf("%d",&row);
col = row;
ma=(int *)malloc(row*sizeof(int));
for(i=0;i<row;i++)
{
ma[i]=(int *)malloc(col*sizeof(int));
}
for(i=0;i<row;i++)
{
for(j=0;j<col;j++)
{
scanf("%d",&ma[i][j]);
}
}
for(k=0;k<col;k++)
{
s1=s1+ma[k][k];
}
for(i=0,j=col-1;i<row&&j>=0;i++,j--)
{
s2=s2+ma[i][j];
}
printf("%d",s1+s2);
}
| [
"manikanta2901@gmail.com"
] | manikanta2901@gmail.com |
5ca62e9d8b6dfd7532d59fc660ef0fa64ebe143d | a535f95a8906194c2b2eb09e353778a95d76d624 | /DataStructure/Array/6.OrderStatistics/4.min_distance_between_2_nums.cpp | 73d21b21c52ce7fb7642786e51074291ff28b112 | [] | no_license | pakd/cppCodes | bbdd6cb036122fc09cd3716cf8a3c16df13fbede | 9e36652a1e5bb2dec45fb7024da8dee1317fe930 | refs/heads/master | 2021-01-19T19:52:00.603385 | 2019-12-21T10:35:47 | 2019-12-21T10:35:47 | 81,935,229 | 1 | 2 | null | 2019-03-22T14:56:57 | 2017-02-14T10:45:22 | C++ | UTF-8 | C++ | false | false | 888 | cpp | #include <iostream>
int minDist(int *arr, int n, int x, int y)
{
int i = 0;
int min_dist = INT_MAX;
int prev;
for (i = 0; i < n; i++)
{
if (arr[i] == x || arr[i] == y)
{
prev = i;
break;
}
}
for ( ; i < n; i++)
{
if (arr[i] == x || arr[i] == y)
{
// if current element is not same as previous element
if ( arr[prev] != arr[i] && (i - prev) < min_dist )
{
min_dist = i - prev;
}
prev = i;
}
}
return min_dist;
}
int main()
{
int arr[] = {3, 5, 4, 2, 6, 3, 0, 0, 5, 4, 8, 3};
int n = sizeof(arr) / sizeof(arr[0]);
int x = 3;
int y = 6;
std::cout << "Minimum distance between " << x <<
" and " << y << " is "<<
minDist(arr, n, x, y);
return 0;
}
| [
"deepak.kumar.cse12@gmail.com"
] | deepak.kumar.cse12@gmail.com |
b271222d1ce4ce32a1c08368299f0763ca4d1f92 | e37a4775935435eda9f176c44005912253a720d8 | /datadriven/src/sgpp/datadriven/algorithm/DBMatOnlineDEFactory.hpp | 49f91281019800aa38a00ad604a3b49b2383397a | [] | no_license | JihoYang/SGpp | b1d90d2d9e8f8be0092e1a9fa0f37a5f49213c29 | 7e547110584891beed194d496e23194dd90ccd20 | refs/heads/master | 2020-04-25T10:27:58.081281 | 2018-09-29T19:33:13 | 2018-09-29T19:33:13 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 879 | hpp | /* Copyright (C) 2008-today The SG++ project
* This file is part of the SG++ project. For conditions of distribution and
* use, please see the copyright notice provided with SG++ or at
* sgpp.sparsegrids.org
*
* DBMatOnlineDEFactory.hpp
*
* Created on: Apr 8, 2017
* Author: Michael Lettrich
*/
#pragma once
#include <sgpp/datadriven/algorithm/DBMatOnlineDE.hpp>
namespace sgpp {
namespace datadriven {
namespace DBMatOnlineDEFactory {
/**
* Factory to build a DBMatOnlineDE object to manipulate the decomposition in offline object
* @param offline offline object that holds the decomposed system matrix
* @param beta plasticity weighting factor. If set to 0, no plasticity takes place.
*/
DBMatOnlineDE* buildDBMatOnlineDE(DBMatOffline& offline, double beta = 0);
} /* namespace DBMatOnlineDEFactory */
} /* namespace datadriven */
} /* namespace sgpp */
| [
"dirk.pflueger@ipvs.uni-stuttgart.de"
] | dirk.pflueger@ipvs.uni-stuttgart.de |
9adc36fd751cb040af6d291569546f9e956ecbad | 59998693cd7ff4b7dea7cfcc2555c7cfa8036043 | /TOLKIEN/src/bitsum2.cc | 6fedd67e523b3a15eca982db9858a1937cf011ee | [] | no_license | csu-anzai/GeneticLOGIC | 2bc43ff2c68ed2b5e9ee58af170fc910c264a0b9 | a3ce3278cfaf5bf54647271eadf4d17fb1629136 | refs/heads/master | 2020-07-18T20:16:59.007293 | 2019-09-03T11:36:19 | 2019-09-03T11:36:19 | 206,305,824 | 0 | 1 | null | 2019-09-04T11:42:35 | 2019-09-04T11:42:34 | null | UTF-8 | C++ | false | false | 952 | cc | //
// TOLKIEN: Tool Kit for Genetics-based Applications
//
// Anthony Yiu-Cheung Tang, 1992-93.
// Department of Computer Science
// The Chinese University of Hong Kong.
//
#include "bitsum2.h"
#include "errhndl.h"
// this version of Bitsum is a trade off of time for space
// please refer the file 'bitsum.cpp' for another version
// which uses the table lookup approach
//
const short BitSum::masks[4] = { 0x5555, // 0101010101010101,
0x3333, // 0011001100110011,
0x0f0f, // 0000111100001111,
0x00ff // 0000000011111111
};
const char BitSum::powerOfTwo[4] = { 2, 4, 8, 16 };
unsigned BitSum::add(unsigned short val) const
{
unsigned int i;
unsigned short wEven, wOdd;
for (i = 0; i < 4; i++) {
wEven = val & masks[i];
val >>= powerOfTwo[i]; // shift val right pow(2,i) bits
wOdd = val & masks[i];
val = wEven + wOdd;
}
return val;
}
BitSum bitSum;
| [
"the.new.horizon@outlook.com"
] | the.new.horizon@outlook.com |
fa9e6fdb4c2ca1510dfcc9c618deb3b87a53e2da | 58d65c8b0c7a9be38af1490cfddee5269f44cd84 | /Unreal/andtest2/Source/andtest2/andtest2Character.cpp | 19bb004f922081fb8b56b46cf8d9e369e58b7cc8 | [] | no_license | KCalender/Engine | b47eaf3ba1f3c18e24e984ae660714e1e9e7dc51 | e41b90d50cc71db1963fcca18b01aa615dffee5f | refs/heads/main | 2023-06-16T08:24:01.448660 | 2021-07-11T11:46:58 | 2021-07-11T11:46:58 | 350,994,849 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,764 | cpp | // Copyright Epic Games, Inc. All Rights Reserved.
#include "andtest2Character.h"
#include "HeadMountedDisplayFunctionLibrary.h"
#include "Camera/CameraComponent.h"
#include "Components/CapsuleComponent.h"
#include "Components/InputComponent.h"
#include "GameFramework/CharacterMovementComponent.h"
#include "GameFramework/Controller.h"
#include "GameFramework/SpringArmComponent.h"
//////////////////////////////////////////////////////////////////////////
// Aandtest2Character
Aandtest2Character::Aandtest2Character()
{
// Set size for collision capsule
GetCapsuleComponent()->InitCapsuleSize(42.f, 96.0f);
// set our turn rates for input
BaseTurnRate = 45.f;
BaseLookUpRate = 45.f;
// Don't rotate when the controller rotates. Let that just affect the camera.
bUseControllerRotationPitch = false;
bUseControllerRotationYaw = false;
bUseControllerRotationRoll = false;
// Configure character movement
GetCharacterMovement()->bOrientRotationToMovement = true; // Character moves in the direction of input...
GetCharacterMovement()->RotationRate = FRotator(0.0f, 540.0f, 0.0f); // ...at this rotation rate
GetCharacterMovement()->JumpZVelocity = 600.f;
GetCharacterMovement()->AirControl = 0.2f;
// Create a camera boom (pulls in towards the player if there is a collision)
CameraBoom = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraBoom"));
CameraBoom->SetupAttachment(RootComponent);
CameraBoom->TargetArmLength = 300.0f; // The camera follows at this distance behind the character
CameraBoom->bUsePawnControlRotation = true; // Rotate the arm based on the controller
// Create a follow camera
FollowCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("FollowCamera"));
FollowCamera->SetupAttachment(CameraBoom, USpringArmComponent::SocketName); // Attach the camera to the end of the boom and let the boom adjust to match the controller orientation
FollowCamera->bUsePawnControlRotation = false; // Camera does not rotate relative to arm
// Note: The skeletal mesh and anim blueprint references on the Mesh component (inherited from Character)
// are set in the derived blueprint asset named MyCharacter (to avoid direct content references in C++)
}
//////////////////////////////////////////////////////////////////////////
// Input
void Aandtest2Character::SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent)
{
// Set up gameplay key bindings
check(PlayerInputComponent);
PlayerInputComponent->BindAction("Jump", IE_Pressed, this, &ACharacter::Jump);
PlayerInputComponent->BindAction("Jump", IE_Released, this, &ACharacter::StopJumping);
PlayerInputComponent->BindAxis("MoveForward", this, &Aandtest2Character::MoveForward);
PlayerInputComponent->BindAxis("MoveRight", this, &Aandtest2Character::MoveRight);
// We have 2 versions of the rotation bindings to handle different kinds of devices differently
// "turn" handles devices that provide an absolute delta, such as a mouse.
// "turnrate" is for devices that we choose to treat as a rate of change, such as an analog joystick
PlayerInputComponent->BindAxis("Turn", this, &APawn::AddControllerYawInput);
PlayerInputComponent->BindAxis("TurnRate", this, &Aandtest2Character::TurnAtRate);
PlayerInputComponent->BindAxis("LookUp", this, &APawn::AddControllerPitchInput);
PlayerInputComponent->BindAxis("LookUpRate", this, &Aandtest2Character::LookUpAtRate);
// handle touch devices
PlayerInputComponent->BindTouch(IE_Pressed, this, &Aandtest2Character::TouchStarted);
PlayerInputComponent->BindTouch(IE_Released, this, &Aandtest2Character::TouchStopped);
// VR headset functionality
PlayerInputComponent->BindAction("ResetVR", IE_Pressed, this, &Aandtest2Character::OnResetVR);
}
void Aandtest2Character::OnResetVR()
{
// If andtest2 is added to a project via 'Add Feature' in the Unreal Editor the dependency on HeadMountedDisplay in andtest2.Build.cs is not automatically propagated
// and a linker error will result.
// You will need to either:
// Add "HeadMountedDisplay" to [YourProject].Build.cs PublicDependencyModuleNames in order to build successfully (appropriate if supporting VR).
// or:
// Comment or delete the call to ResetOrientationAndPosition below (appropriate if not supporting VR)
UHeadMountedDisplayFunctionLibrary::ResetOrientationAndPosition();
}
void Aandtest2Character::TouchStarted(ETouchIndex::Type FingerIndex, FVector Location)
{
Jump();
}
void Aandtest2Character::TouchStopped(ETouchIndex::Type FingerIndex, FVector Location)
{
StopJumping();
}
void Aandtest2Character::TurnAtRate(float Rate)
{
// calculate delta for this frame from the rate information
AddControllerYawInput(Rate * BaseTurnRate * GetWorld()->GetDeltaSeconds());
}
void Aandtest2Character::LookUpAtRate(float Rate)
{
// calculate delta for this frame from the rate information
AddControllerPitchInput(Rate * BaseLookUpRate * GetWorld()->GetDeltaSeconds());
}
void Aandtest2Character::MoveForward(float Value)
{
if ((Controller != nullptr) && (Value != 0.0f))
{
// find out which way is forward
const FRotator Rotation = Controller->GetControlRotation();
const FRotator YawRotation(0, Rotation.Yaw, 0);
// get forward vector
const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
AddMovementInput(Direction, Value);
}
}
void Aandtest2Character::MoveRight(float Value)
{
if ( (Controller != nullptr) && (Value != 0.0f) )
{
// find out which way is right
const FRotator Rotation = Controller->GetControlRotation();
const FRotator YawRotation(0, Rotation.Yaw, 0);
// get right vector
const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);
// add movement in that direction
AddMovementInput(Direction, Value);
}
}
| [
"pdt0616@gmail.com"
] | pdt0616@gmail.com |
89315a965a9f2ea0b51a039af6216b6f840c2dbc | d65cb1aef8d8842ffaff1aac09c9be1fa4bcf4fa | /src/Geo/bspline_fiting.hh | 3e555c7b3522ff5deb2a4c6de4db85f338d6aa33 | [] | no_license | marcomanno/ml_4_mesh | 6dccae8472e47f2c43612b22f110bc7c65366c1b | 5c47633b898c0bb86f33c5c62934d5d800aeb8db | refs/heads/master | 2020-03-23T03:28:59.128417 | 2019-04-14T09:37:53 | 2019-04-14T09:37:53 | 141,033,031 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 988 | hh | #include <Geo/vector.hh>
#include <memory>
#include <vector>
namespace Geo {
template <size_t dimT>
struct IBsplineFitting
{
struct IFunction
{
virtual Geo::VectorD<dimT> evaluate(const double _t) const = 0;
virtual Geo::VectorD<dimT> closest_point(
const Geo::VectorD<dimT>& _pt, const double _par) const = 0;
};
// Setup
virtual bool init(const size_t _deg,
const std::vector<double>& _knots, const IFunction& _f) = 0;
virtual void set_parameter_correction_iterations(size_t _itr_nmbr) = 0;
virtual void set_favour_boundaries(const bool _fvr_bndr = true) = 0;
virtual void set_samples_per_interval(const size_t _smpl_per_intrvl = 4) = 0;
// Compute
virtual void compute() = 0;
// Get results
virtual const std::vector<VectorD<dimT>>& X() const = 0;
//virtual Vector<dimT> eval(const double _t) const = 0;
/*! Factory */
static std::shared_ptr<IBsplineFitting<dimT>> make();
};
}//namespace Geo
| [
"marco.amagl@outlook.com"
] | marco.amagl@outlook.com |
0a456d8f6622b2e39044f690f7e63209bbd12bdd | 1b0d4d2b05351cd6b062c64af8168f567f561a40 | /Custom/QueueWithMinimum.cpp | 773feda6a21a0a856e03ad878a8bab573ee55bfc | [
"MIT"
] | permissive | 636F57/Algos | 842f6a721b161447aca5ab31b263f465a0e33781 | 92f0f637391652dfc8baa5c394322b849e590748 | refs/heads/master | 2020-05-20T23:32:20.447252 | 2017-09-29T09:01:37 | 2017-09-29T09:01:37 | 84,545,363 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,443 | cpp | /* QueueWithMinimum.cpp
**
** Custom class of queue which can return the minimum value of the queue anytime.
** Run very fast at armitised O(1) for query minimum
**
** compiled and tested with g++ 6.2.0 MinGW-W64
**
** MIT License
** Copyright (c) 2017 636F57@GitHub
** See more detail at https://github.com/636F57/Algos/blob/master/LICENSE
*/
#include <cstdlib>
#include <deque>
#include <cmath>
#include <iostream>
class QueueMin
{
struct mypair
{
int value;
int min;
};
private:
std::deque<mypair> vQueue;
int nCheckedIndex = 0; // index < nCheckedIndex: min = min_of_mypairs[0,nCheckedIndex). index >= nCheckedIndex: min = min_of_mypairs[nCheckedIndex,end of queue]
public:
QueueMin(){}
~QueueMin(){}
int back()
{
return vQueue.back().value;
}
int front()
{
return vQueue.front().value;
}
int operator[] (int i)
{
return vQueue[i].value;
}
int size()
{
return vQueue.size();
}
void clear()
{
vQueue.clear();
}
void resize(int size)
{
vQueue.resize(size);
}
void push_back(int nNum)
{
if ((vQueue.size() == 0) || (vQueue.size() == nCheckedIndex+1))
vQueue.push_back({nNum,nNum});
else
vQueue.push_back({nNum, std::min(nNum, vQueue.back().min)});
}
// return the popped value
int pop_front()
{
if (nCheckedIndex == 0) // renew the mins of newly added pairs with the min found by comparing backward
{
vQueue.back().min = vQueue.back().value;
for (int j=vQueue.size()-2; j>=0; j--)
{
vQueue[j].min = std::min(vQueue[j].value, vQueue[j+1].min);
}
nCheckedIndex = vQueue.size() - 1;
}
mypair pairFront = vQueue.front();
vQueue.pop_front();
if(nCheckedIndex > 0)
nCheckedIndex--;
return pairFront.value;
}
// return the minimum value of current queue
int queryMin()
{
int nMin = vQueue.front().min;
if (vQueue.size() > nCheckedIndex + 1)
nMin = std::min(nMin, vQueue.back().min);
return nMin;
}
};
int main() // sample program
{
std::string strN;
QueueMin qmQueue;
std::cout<< "Demonstration of QueueMin class.\n";
for (int i=0; i<5; i++)
{
std::cout << "Enter integer : ";
std::cin >> strN;
qmQueue.push_back(std::stoi(strN));
std::cout << "Current Queue : \n";
for (int j=0; j<qmQueue.size(); j++)
std::cout << qmQueue[j] << " ";
std::cout << "\nThe minimum value in the queue is : " << qmQueue.queryMin() << "\n";
}
std::cout << "End\n";
return 0;
}
| [
"636f57@outlook.com"
] | 636f57@outlook.com |
12dff6af19f105f6ee61a7992ef9e668dc108c38 | 5999474eb6a5d12efe7ca7bafc7e6e4048c65fc0 | /src/motion.h | 29b4c2d9afde57bc80e2deb00933da60ba6d3681 | [
"MIT"
] | permissive | PetoiCamp/OpenCat | dd1c4bf857f7831f902aef812763581aeedb5d8e | 335e0fe529f1acb405f879c5b6012398c835d953 | refs/heads/main | 2023-09-05T10:27:06.631580 | 2023-09-03T17:21:02 | 2023-09-03T17:21:02 | 326,441,188 | 2,374 | 315 | MIT | 2023-09-14T12:26:31 | 2021-01-03T15:42:00 | C++ | UTF-8 | C++ | false | false | 5,533 | h |
// balancing parameters
#define ROLL_LEVEL_TOLERANCE 5 //the body is still considered as level, no angle adjustment
#define PITCH_LEVEL_TOLERANCE 3
int8_t levelTolerance[2] = { ROLL_LEVEL_TOLERANCE, PITCH_LEVEL_TOLERANCE }; //the body is still considered as level, no angle adjustment
//the following coefficients will be divided by radPerDeg in the adjust() function. so (float) 0.1 can be saved as (int8_t) 1
//this trick allows using int8_t array insead of float array, saving 96 bytes and allows storage on EEPROM
#define panF 60
#define tiltF 60
#define sRF 50 //shoulder roll factor
#define sPF 12 //shoulder pitch factor
#define uRF 60 //upper leg roll factor
#define uPF 30 //upper leg pitch factor
#define lRF (-1.5 * uRF) //lower leg roll factor
#define lPF (-1.5 * uPF) //lower leg pitch factor
#define LEFT_RIGHT_FACTOR 1.2
#define FRONT_BACK_FACTOR 1.2
#define POSTURE_WALKING_FACTOR 0.5
#define ADJUSTMENT_DAMPER 5
#ifdef POSTURE_WALKING_FACTOR
float postureOrWalkingFactor;
#endif
#ifdef X_LEG // >< leg
float adaptiveParameterArray[16][2] = { // they will be saved as int8_t in EEPROM
{ -panF, 0 },
{ -panF, -tiltF },
{ -2 * panF, 0 },
{ 0, 0 },
{ sRF, -sPF },
{ -sRF, -sPF },
{ -sRF, sPF },
{ sRF, sPF },
{ uRF, uPF },
{ uRF, uPF },
{ -uRF, uPF },
{ -uRF, uPF },
{ lRF, lPF },
{ lRF, lPF },
{ -lRF, lPF },
{ -lRF, lPF }
};
#else // >> leg
float adaptiveParameterArray[16][2] = { // they will be saved as int8_t in EEPROM
{ -panF, 0 },
{ -panF / 2, -tiltF },
{ -2 * panF, 0 },
{ 0, 0 },
{ sRF, -sPF },
{ -sRF, -sPF },
{ -sRF, sPF },
{ sRF, sPF },
{ uRF, uPF },
{ uRF, uPF },
{ uRF, uPF },
{ uRF, uPF },
{ lRF, -0.5 * lPF },
{ lRF, -0.5 * lPF },
{ lRF, 0.5 * lPF },
{ lRF, 0.5 * lPF }
};
#endif
float RollPitchDeviation[2];
int8_t slope = 1;
float adjust(byte i) {
float rollAdj, pitchAdj, adj;
if (i == 1 || i > 3) { //check idx = 1
bool leftQ = (i - 1) % 4 > 1 ? true : false;
//bool frontQ = i % 4 < 2 ? true : false;
//bool upperQ = i / 4 < 3 ? true : false;
float leftRightFactor = 1;
if ((leftQ && slope * RollPitchDeviation[0] > 0) // operator * is higher than &&
|| (!leftQ && slope * RollPitchDeviation[0] < 0))
leftRightFactor = LEFT_RIGHT_FACTOR * abs(slope);
rollAdj = fabs(RollPitchDeviation[0]) * eeprom(ADAPT_PARAM, i, 0, 2) * leftRightFactor;
} else
rollAdj = RollPitchDeviation[0] * eeprom(ADAPT_PARAM, i, 0, 2);
float idealAdjust = radPerDeg * (
#ifdef POSTURE_WALKING_FACTOR
(i > 3 ? postureOrWalkingFactor : 1) *
#endif
rollAdj
- /*slope * */ eeprom(ADAPT_PARAM, i, 1, 2) * ((i % 4 < 2) ? (RollPitchDeviation[1]) : RollPitchDeviation[1]));
#ifdef ADJUSTMENT_DAMPER
currentAdjust[i] += max(min(idealAdjust - currentAdjust[i], float(ADJUSTMENT_DAMPER)), -float(ADJUSTMENT_DAMPER));
#else
currentAdjust[i] = idealAdjust;
#endif
return currentAdjust[i];
}
void calibratedPWM(byte i, float angle, float speedRatio = 0) {
/*float angle = max(-SERVO_ANG_RANGE/2, min(SERVO_ANG_RANGE/2, angle));
if (i > 3 && i < 8)
angle = max(-5, angle);*/
angle = max(float(loadAngleLimit(i, 0)), min(float(loadAngleLimit(i, 1)), angle));
int duty0 = EEPROMReadInt(CALIBRATED_ZERO_POSITIONS + i * 2) + currentAng[i] * eeprom(ROTATION_DIRECTION, i);
currentAng[i] = angle;
int duty = EEPROMReadInt(CALIBRATED_ZERO_POSITIONS + i * 2) + angle * eeprom(ROTATION_DIRECTION, i);
int steps = speedRatio > 0 ? int(round(abs(duty - duty0) / 1.0 /*degreeStep*/ / speedRatio)) : 0;
//if default speed is 0, no interpolation will be used
//otherwise the speed ratio is compared to 1 degree per second.
for (int s = 0; s <= steps; s++) {
pwm.writeAngle(i, duty + (steps == 0 ? 0 : (1 + cos(M_PI * s / steps)) / 2 * (duty0 - duty)));
}
}
template<typename T> void allCalibratedPWM(T *dutyAng, byte offset = 0) {
for (int8_t i = DOF - 1; i >= offset; i--) {
calibratedPWM(i, dutyAng[i]);
}
}
template<typename T> void transform(T *target, byte angleDataRatio = 1, float speedRatio = 2, byte offset = 0) {
if (speedRatio <= 0
#ifdef SERVO_SLOW_BOOT
|| servoOff
#endif
) { // the speed ratio should be >0, if the user enters some large numbers, it will become negative
allCalibratedPWM(target, offset);
#ifdef SERVO_SLOW_BOOT
if (servoOff) { //slow boot up for servos
delay(500);
servoOff = false;
}
#endif
} else {
int *diff = new int[DOF - offset], maxDiff = 0;
for (byte i = offset; i < DOF; i++) {
if (manualHeadQ && i < HEAD_GROUP_LEN && token == T_SKILL) // the head motion will be handled by skill.perform()
continue;
diff[i - offset] = currentAng[i] - target[i - offset] * angleDataRatio;
maxDiff = max(maxDiff, abs(diff[i - offset]));
}
// if (maxDiff == 0) {
// delete[] diff;
// return;
// }
int steps = speedRatio > 0 ? int(round(maxDiff / 1.0 /*degreeStep*/ / speedRatio)) : 0; //default speed is 1 degree per step
for (int s = 0; s <= steps; s++) {
for (byte i = offset; i < DOF; i++) {
if (manualHeadQ && i < HEAD_GROUP_LEN && token == T_SKILL)
continue;
float dutyAng = (target[i - offset] * angleDataRatio + (steps == 0 ? 0 : (1 + cos(M_PI * s / steps)) / 2 * diff[i - offset]));
calibratedPWM(i, dutyAng);
}
}
delete[] diff;
}
}
| [
"rzlib2l@gmail.com"
] | rzlib2l@gmail.com |
689329f07b16e79fb576ddcf916da1f3031bbb8b | c8484021b3fc430bb4020cd44917191b9b57a0c0 | /src/interplot/surfacevisual.cpp | e42708a3be23597d638d7a8ed8ffedb09bada7b2 | [] | no_license | stesim/interplot | 85ff85c87c02ce9924b99cc71c102a0963fb6b1d | 714ccc9d9892d4efd2b4f55e9a3b49d5b49dc69f | refs/heads/master | 2021-01-10T03:28:49.264023 | 2015-07-02T21:16:38 | 2015-07-02T21:16:38 | 36,193,086 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,075 | cpp | #include "surfacevisual.h"
#include "engine.h"
#include "shaderprogram.h"
#include <string>
namespace interplot
{
constexpr size_t SurfaceVisual::MAX_POINTS_PER_INSTANCE_DIM;
SurfaceVisual::SurfaceVisual() :
m_pVertexShader( nullptr ),
m_pTessControlShader( nullptr ),
m_pTessEvalShader( nullptr ),
m_pFragmentShader( nullptr ),
m_pShaderProgram( nullptr ),
m_uniInstances( -1 ),
m_uniParamStart( -1 ),
m_uniParamEnd( -1 ),
m_vecParamStart( 0.0f, 0.0f ),
m_vecParamEnd( 1.0f, 1.0f ),
m_vecNumPoints( MAX_POINTS_PER_INSTANCE_DIM, MAX_POINTS_PER_INSTANCE_DIM ),
m_vecNumInstances( 1, 1 ),
m_vecPointsPerInstance( m_vecNumPoints )
{
}
SurfaceVisual::~SurfaceVisual()
{
}
void SurfaceVisual::initialize()
{
m_VertexBuffer.resize( 4 );
m_VertexBuffer.allocHostMemory();
m_VertexBuffer[ 0 ] = LineVertex( 0.0f, 0.0f );
m_VertexBuffer[ 1 ] = LineVertex( 0.0f, 1.0f );
m_VertexBuffer[ 2 ] = LineVertex( 1.0f, 1.0f );
m_VertexBuffer[ 3 ] = LineVertex( 1.0f, 0.0f );
m_VertexBuffer.copyToDevice();
ShaderManager& shaders = engine.shaders;
m_pVertexShader =
shaders.getShader<Shader::Type::Vertex>( "line" );
m_pTessControlShader =
shaders.getShader<Shader::Type::TessellationControl>( "surface" );
m_pTessEvalShader =
Shader::fromName( Shader::Type::TessellationEvaluation, "surface" );
m_pFragmentShader =
shaders.getShader<Shader::Type::Fragment>( "line" );
// setFunction( GpuFunctionSource( 2, 3,
// "return vec3( v, 0.0 );" ) );
setFunction( GpuFunctionSource( 2, 3,
"float R = 2.0;\n"
"float rmin = 1.0;\n"
"float rmax = R;\n"
"float s = R - v.y * ( ( rmax - rmin ) * 0.5 * ( sin( t ) + 1.0 ) + rmin );\n"
"return vec3( 10.0 * v.x - sin( 0.5 * t ) * 2.0 * ( ( s / R - 1.0 ) * ( s / R - 1.0 ) ), s * 2.0 * sin( 1.0 * f_time + PERIODS * v.x * TWO_PI ), s * 2.0 * cos( 1.0 * f_time + PERIODS * v.x * TWO_PI ) );" ) );
}
void SurfaceVisual::finalize()
{
}
void SurfaceVisual::update()
{
}
void SurfaceVisual::render()
{
m_pShaderProgram->setUniform(
ShaderProgram::Uniform::ModelMatrix,
glm::mat4( 1.0f ) );
m_pShaderProgram->setUniform(
ShaderProgram::Uniform::ModelNormalMatrix,
glm::mat3( 1.0f ) );
engine.renderer.render(
m_VertexBuffer,
0,
m_VertexBuffer.numVertices(),
m_vecNumInstances.x * m_vecNumInstances.y );
}
void SurfaceVisual::setNumPoints( const uvec2& points )
{
m_vecNumInstances = ( points + uvec2( MAX_POINTS_PER_INSTANCE_DIM - 1 ) ) /
MAX_POINTS_PER_INSTANCE_DIM;
m_vecPointsPerInstance = ( points + m_vecNumInstances - uvec2( 1 ) ) /
m_vecNumInstances;
m_vecNumPoints = m_vecNumInstances * m_vecPointsPerInstance;
if( m_pShaderProgram != nullptr )
{
dbg_printf( "setNumPoints:\n%f, %f\n%f, %f\n%lu, %lu\n%lu, %lu\n",
m_vecParamStart.x, m_vecParamStart.y,
m_vecParamEnd.x, m_vecParamEnd.y,
m_vecPointsPerInstance.x, m_vecPointsPerInstance.y,
m_vecNumPoints.x, m_vecNumPoints.y );
m_pShaderProgram->setCustomUniform( m_uniPointsPerInstance,
m_vecPointsPerInstance );
m_pShaderProgram->setCustomUniform( m_uniInstances, m_vecNumInstances );
}
}
void SurfaceVisual::setFunction( const GpuFunctionSource& func )
{
if( ( func.getDomainDim() != 2 && func.getDomainDim() != 3 ) ||
func.getImageDim() != 3 )
{
return;
}
m_Function = func;
std::string source =
"vec3 fun( vec2 v )\n"
"{\n";
source += m_Function.getFunctionSource();
source += "\n"
"}\n";
const char* sources[] = { m_pTessEvalShader->getSource(), source.c_str() };
Shader* tesShader = Shader::fromSources(
Shader::Type::TessellationEvaluation,
sources,
2 );
tesShader->compile();
if( m_pShaderProgram != nullptr )
{
ShaderProgram::destroy( m_pShaderProgram );
}
m_pShaderProgram = ShaderProgram::assemble(
m_pVertexShader,
m_pTessControlShader,
tesShader,
m_pFragmentShader );
m_pShaderProgram->link();
m_uniPointsPerInstance =
m_pShaderProgram->getCustomUniform( "vec_pointsPerInstance" );
m_uniInstances =
m_pShaderProgram->getCustomUniform( "vec_instances" );
m_uniParamStart =
m_pShaderProgram->getCustomUniform( "vec_paramStart" );
m_uniParamEnd =
m_pShaderProgram->getCustomUniform( "vec_paramEnd" );
m_pShaderProgram->setCustomUniform( m_uniPointsPerInstance,
m_vecPointsPerInstance );
m_pShaderProgram->setCustomUniform( m_uniInstances, m_vecNumInstances );
dbg_printf( "setFunction:\n%f, %f\n%f, %f\n%lu, %lu\n",
m_vecParamStart.x, m_vecParamStart.y,
m_vecParamEnd.x, m_vecParamEnd.y,
m_vecPointsPerInstance.x, m_vecPointsPerInstance.y );
m_pShaderProgram->setCustomUniform( m_uniParamStart, m_vecParamStart );
m_pShaderProgram->setCustomUniform( m_uniParamEnd, m_vecParamEnd );
}
void SurfaceVisual::setParamStart( const vec2& value )
{
m_vecParamStart = value;
m_pShaderProgram->setCustomUniform( m_uniParamStart, m_vecParamStart );
}
void SurfaceVisual::setParamEnd( const vec2& value )
{
m_vecParamStart = value;
m_pShaderProgram->setCustomUniform( m_uniParamEnd, m_vecParamEnd );
}
}
| [
"simeonov.stefan@gmail.com"
] | simeonov.stefan@gmail.com |
d2ae709c35e12bb601c2c23dfef31564d6fb84c0 | 70d16e6a3adcd592ca04e7a6f4c549a2fee7d332 | /SeveSegBasic/SeveSegBasic.ino | cd879e9b6340c669061853669773a427f6d94678 | [] | no_license | dimplejuno/koreacontentslab | 601beea88f04ff30b01955cdae7aab56e1e42e55 | 8d0c3d1e03c0bbd5030a23b06f0785a7f2c0de79 | refs/heads/master | 2020-05-18T09:51:39.494654 | 2015-11-16T08:44:04 | 2015-11-16T08:44:04 | 39,365,193 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,223 | ino | // Define the LED digit patters, from 0 - 9
// Note that these patterns are for common cathode displays
// For common anode displays, change the 1's to 0's and 0's to 1's
// 1 = LED on, 0 = LED off, in this order:
// Arduino pin: 2,3,4,5,6,7,8
byte seven_seg_digits[10][7] = {
{ 1,1,1,1,1,1,0 }, // = 0
{ 0,1,1,0,0,0,0 }, // = 1
{ 1,1,0,1,1,0,1 }, // = 2
{ 1,1,1,1,0,0,1 }, // = 3
{ 0,1,1,0,0,1,1 }, // = 4
{ 1,0,1,1,0,1,1 }, // = 5
{ 1,0,1,1,1,1,1 }, // = 6
{ 1,1,1,0,0,0,0 }, // = 7
{ 1,1,1,1,1,1,1 }, // = 8
{ 1,1,1,0,0,1,1 } // = 9
};
void setup() {
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
writeDot(0); // start with the "dot" off
}
void writeDot(byte dot) {
digitalWrite(9, dot);
}
void sevenSegWrite(byte digit) {
byte pin = 2;
for (byte segCount = 0; segCount < 7; ++segCount) {
digitalWrite(pin, seven_seg_digits[digit][segCount]);
++pin;
}
}
void loop() {
byte count;
for (count = 0; count<10 ; count++) {
delay(1000);
sevenSegWrite(count);
}
delay(5000);
}
| [
"dimplejuno@decsers.com"
] | dimplejuno@decsers.com |
ae08e3379b45c2d19ecc312495d404fa3fe89bb9 | e4ca3051a10ffea9f926027b205e443395efbcd4 | /src/main.cpp | eae76ca5b7eaf988611208a48904e4d9d7923d73 | [] | no_license | swarth100/baobui | f1ff62369d893391bc6bc0cb2fab6597736dd647 | 90d764fa7214825c1a12a038af8ca775efa25210 | refs/heads/master | 2021-08-07T04:59:25.104580 | 2017-11-07T15:28:11 | 2017-11-07T15:28:11 | 103,238,523 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,889 | cpp | /* Main.cpp */
#include "Util/Util.hpp"
#include "Util/program_utils.hpp"
#include "Util/arduino_utils.hpp"
#include "Util/camera_utils.hpp"
#include "Math/maths_funcs.h"
#include "Component/Component.hpp"
#include "Component/Line.hpp"
#include "Component/Prism.hpp"
#include "Component/Texture.hpp"
#include "Geometry/Point.hpp"
#include "Geometry/ArduinoPoint.hpp"
#include "Geometry/ReferencePoint.hpp"
#include "Program/Program.hpp"
/* Logfile */
#define GL_LOG_FILE "gl.log"
using namespace std;
/* Keeps track of window size for things like the viewport and the mouse cursor */
int g_gl_width = 1280;
int g_gl_height = 960;
/* Window instance */
GLFWwindow *g_window = NULL;
int main() {
restart_gl_log();
/* Start GL context */
start_gl();
/* Setup arduino */
setupArduino();
/* Setup Serial port communication */
setupSerial("/dev/ttyACM0");
/* Set up the models in the virtual layout */
generateModels();
/* Initialise all sound buffers and elements */
initSound();
/* Initialise the camera instance.
Holds an instance of the view matrix. */
init_camera(0.0f, 0.0f, 15.0f, 2.0f);
/* Retrieve the translation matrix from the initialised camera */
mat4 view_mat = getTranslationMatrix();
/* Initialise and retrieve the projection matrix */
mat4 proj_mat = getProjectionMatrix();
/* Attach the newly created uniforms to all programs */
attachUniforms("view", view_mat.m);
attachUniforms("proj", proj_mat.m);
//glEnable( GL_CULL_FACE ); // cull face
//glCullFace( GL_BACK ); // cull back face
//glFrontFace( GL_CW ); // GL_CCW for counter clock-wise
/* Enable depth test */
glEnable(GL_DEPTH_TEST);
/* Accept fragment if it closer to the camera than the former one */
glDepthFunc(GL_LESS);
/* Rendering loop: while window isn't closed */
while (!glfwWindowShouldClose(g_window)) {
/* Update time fields */
static double previous_seconds = glfwGetTime();
double current_seconds = glfwGetTime();
double elapsed_seconds = current_seconds - previous_seconds;
previous_seconds = current_seconds;
_update_fps_counter(g_window);
/* Wipe the drawing surface clear */
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glViewport(0, 0, g_gl_width, g_gl_height);
/* Iterate through all programs calling draw() on their components */
drawAllPrograms();
// update other events like input handling
glfwPollEvents();
/* Update the camera based on Key Press events */
bool cam_moved = update_camera(g_window, elapsed_seconds);
updateCompanionCube(elapsed_seconds);
/* Update view matrix */
if (cam_moved) {
/* Retrieve the new translation Matrix given the new Camera position */
mat4 view_mat = getTranslationMatrix();
/* Update the uniforms attached to the various programs */
attachUniforms("view", view_mat.m);
/* Retrieve the CameraPosition's Point */
shared_ptr<Point> cameraPosition = getCamera();
cameraPosition->print();
/* Use the Camera position to compute the servo motor deltas */
shared_ptr<ReferencePoint> refPos = determineArduinoDeltas(cameraPosition);
shared_ptr<ArduinoPoint> refArduino = refPos->getInnerArduinoData();
/* Set the extension angle (i.e. servo motor 0).
Must be set separately as it's independent from the camera position */
refArduino->setExtensionAngle(getExtensionAngle());
/* Send the current buffer data information to arduino */
sendByteData(refArduino->createBuffer(), current_seconds);
}
/* Trap ESC Key press */
if ( GLFW_PRESS == glfwGetKey(g_window, GLFW_KEY_ESCAPE)) {
glfwSetWindowShouldClose(g_window, 1);
}
/* Show the drawn Components onto the Display */
glfwSwapBuffers(g_window);
/* Read the data sent over by arduino */
uint8_t* readData = readByteData();
updateButtonData(readData);
}
/* Close GL context and any other GLFW resources */
glfwTerminate();
return 0;
}
| [
"as12015@ic.ac.uk"
] | as12015@ic.ac.uk |
c0e27eb516e9e20ce823b5126659bc8b6dce908b | a568d13304fad8f44b1a869837b99ca29687b7d8 | /Code_15/POSN camp 2/Divide and conquer/AP_3Rotate.cpp | c80c73bdc3815547855b58e2ac46d7fc3205977c | [] | no_license | MasterIceZ/Code_CPP | ded570ace902c57e2f5fc84e4b1055d191fc4e3d | bc2561484e58b3a326a5f79282f1e6e359ba63ba | refs/heads/master | 2023-02-20T14:13:47.722180 | 2021-01-21T06:15:03 | 2021-01-21T06:15:03 | 331,527,248 | 0 | 0 | null | 2021-01-21T05:51:49 | 2021-01-21T05:43:59 | null | UTF-8 | C++ | false | false | 896 | cpp | /*
TASK:AP_3Rotate
LANG: CPP
AUTHOR: KersaWC
SCHOOL: REPS
*/
#include<bits/stdc++.h>
using namespace std;
long long a[100100],b[100100],ans,n;
void mergesort(long long l,long long r){
if(l==r)return ;
long long i,j,k,mid;
mid=(l+r)/2;
mergesort(l,mid);
mergesort(mid+1,r);
i=l,k=l,j=mid+1;
while(i<=mid && j<=r){
if(a[i]<=a[j])
b[k++]=a[i++];
else if(a[i]>a[j])
b[k++]=a[j++],ans+=(mid-i+1);
}
while(i<=mid){
b[k++]=a[i++];
}
while(j<=r){
b[k++]=a[j++];
}
for(i=l;i<=r;i++){
a[i]=b[i];
}
}
int main(){
long long q,i;
scanf("%lld",&q);
while(q--){
scanf("%lld",&n);
for(i=0;i<n;i++){
scanf("%lld",&a[i]);
}
ans=0;
mergesort(0,n-1);
printf((ans%2==0)?"yes\n":"no\n");
}
return 0;
}
| [
"w.wichada26@gmail.com"
] | w.wichada26@gmail.com |
f860733f01e60fe3430e985e8ec70b3f6912667a | bcc2102c299bd992b6709bddc8b9ec0bbf1f949d | /spoj/buildafenc.cpp | 6792fbbfaac8f64c6813239bc510a7ecaed4f90b | [] | no_license | sravi4701/competitive-programming | 4982a5beacd4674d43dda121509c5c7b653ed4f1 | 565e55a3b2ed67efd5a08a12ef556f5866e31064 | refs/heads/master | 2020-04-11T16:47:14.742667 | 2016-09-19T22:45:12 | 2016-09-19T22:45:12 | 68,240,502 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 244 | cpp | #include<iostream>
#include<iomanip>
#define pi 3.14159265358979323846
using namespace std;
int main()
{
double f;
while(6)
{
cin>>f;
if(f==0)
{
break;
}
else
{
double x=f/pi;
double a=pi*x*x/2.0;
cout<<fixed<<setprecision(2)<<a<<endl;
}
}
}
| [
"sravi4701@gmail.com"
] | sravi4701@gmail.com |
a8a083f3eadc3502bc8f55b014113e98a3cfb063 | 8dc84558f0058d90dfc4955e905dab1b22d12c08 | /third_party/blink/renderer/modules/imagecapture/image_capture.cc | 110e7964e61a658cab3825b3718690ab96790f2a | [
"LGPL-2.0-or-later",
"GPL-1.0-or-later",
"MIT",
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference",
"BSD-3-Clause"
] | permissive | meniossin/src | 42a95cc6c4a9c71d43d62bc4311224ca1fd61e03 | 44f73f7e76119e5ab415d4593ac66485e65d700a | refs/heads/master | 2022-12-16T20:17:03.747113 | 2020-09-03T10:43:12 | 2020-09-03T10:43:12 | 263,710,168 | 1 | 0 | BSD-3-Clause | 2020-05-13T18:20:09 | 2020-05-13T18:20:08 | null | UTF-8 | C++ | false | false | 32,772 | cc | // Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "third_party/blink/renderer/modules/imagecapture/image_capture.h"
#include <utility>
#include "services/service_manager/public/cpp/interface_provider.h"
#include "third_party/blink/public/platform/interface_provider.h"
#include "third_party/blink/public/platform/platform.h"
#include "third_party/blink/public/platform/web_image_capture_frame_grabber.h"
#include "third_party/blink/public/platform/web_media_stream_track.h"
#include "third_party/blink/renderer/bindings/core/v8/callback_promise_adapter.h"
#include "third_party/blink/renderer/bindings/core/v8/script_promise_resolver.h"
#include "third_party/blink/renderer/core/dom/dom_exception.h"
#include "third_party/blink/renderer/core/dom/exception_code.h"
#include "third_party/blink/renderer/core/fileapi/blob.h"
#include "third_party/blink/renderer/core/frame/local_frame.h"
#include "third_party/blink/renderer/core/imagebitmap/image_bitmap.h"
#include "third_party/blink/renderer/modules/event_target_modules.h"
#include "third_party/blink/renderer/modules/imagecapture/media_settings_range.h"
#include "third_party/blink/renderer/modules/imagecapture/photo_capabilities.h"
#include "third_party/blink/renderer/modules/mediastream/media_stream_track.h"
#include "third_party/blink/renderer/modules/mediastream/media_track_capabilities.h"
#include "third_party/blink/renderer/modules/mediastream/media_track_constraints.h"
#include "third_party/blink/renderer/platform/mojo/mojo_helper.h"
#include "third_party/blink/renderer/platform/waitable_event.h"
namespace blink {
using FillLightMode = media::mojom::blink::FillLightMode;
using MeteringMode = media::mojom::blink::MeteringMode;
namespace {
const char kNoServiceError[] = "ImageCapture service unavailable.";
bool TrackIsInactive(const MediaStreamTrack& track) {
// Spec instructs to return an exception if the Track's readyState() is not
// "live". Also reject if the track is disabled or muted.
return track.readyState() != "live" || !track.enabled() || track.muted();
}
MeteringMode ParseMeteringMode(const String& blink_mode) {
if (blink_mode == "manual")
return MeteringMode::MANUAL;
if (blink_mode == "single-shot")
return MeteringMode::SINGLE_SHOT;
if (blink_mode == "continuous")
return MeteringMode::CONTINUOUS;
if (blink_mode == "none")
return MeteringMode::NONE;
NOTREACHED();
return MeteringMode::NONE;
}
FillLightMode ParseFillLightMode(const String& blink_mode) {
if (blink_mode == "off")
return FillLightMode::OFF;
if (blink_mode == "auto")
return FillLightMode::AUTO;
if (blink_mode == "flash")
return FillLightMode::FLASH;
NOTREACHED();
return FillLightMode::OFF;
}
WebString ToString(MeteringMode value) {
switch (value) {
case MeteringMode::NONE:
return WebString::FromUTF8("none");
case MeteringMode::MANUAL:
return WebString::FromUTF8("manual");
case MeteringMode::SINGLE_SHOT:
return WebString::FromUTF8("single-shot");
case MeteringMode::CONTINUOUS:
return WebString::FromUTF8("continuous");
default:
NOTREACHED() << "Unknown MeteringMode";
}
return WebString();
}
} // anonymous namespace
ImageCapture* ImageCapture::Create(ExecutionContext* context,
MediaStreamTrack* track,
ExceptionState& exception_state) {
if (track->kind() != "video") {
exception_state.ThrowDOMException(
kNotSupportedError,
"Cannot create an ImageCapturer from a non-video Track.");
return nullptr;
}
return new ImageCapture(context, track);
}
ImageCapture::~ImageCapture() {
DCHECK(!HasEventListeners());
// There should be no more outstanding |m_serviceRequests| at this point
// since each of them holds a persistent handle to this object.
DCHECK(service_requests_.IsEmpty());
}
const AtomicString& ImageCapture::InterfaceName() const {
return EventTargetNames::ImageCapture;
}
ExecutionContext* ImageCapture::GetExecutionContext() const {
return ContextLifecycleObserver::GetExecutionContext();
}
bool ImageCapture::HasPendingActivity() const {
return GetExecutionContext() && HasEventListeners();
}
void ImageCapture::ContextDestroyed(ExecutionContext*) {
RemoveAllEventListeners();
service_requests_.clear();
DCHECK(!HasEventListeners());
}
ScriptPromise ImageCapture::getPhotoCapabilities(ScriptState* script_state) {
ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
ScriptPromise promise = resolver->Promise();
if (!service_) {
resolver->Reject(DOMException::Create(kNotFoundError, kNoServiceError));
return promise;
}
service_requests_.insert(resolver);
auto resolver_cb = WTF::Bind(&ImageCapture::ResolveWithPhotoCapabilities,
WrapPersistent(this));
// m_streamTrack->component()->source()->id() is the renderer "name" of the
// camera;
// TODO(mcasas) consider sending the security origin as well:
// scriptState->getExecutionContext()->getSecurityOrigin()->toString()
service_->GetPhotoState(
stream_track_->Component()->Source()->Id(),
WTF::Bind(&ImageCapture::OnMojoGetPhotoState, WrapPersistent(this),
WrapPersistent(resolver), WTF::Passed(std::move(resolver_cb)),
false /* trigger_take_photo */));
return promise;
}
ScriptPromise ImageCapture::getPhotoSettings(ScriptState* script_state) {
ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
ScriptPromise promise = resolver->Promise();
if (!service_) {
resolver->Reject(DOMException::Create(kNotFoundError, kNoServiceError));
return promise;
}
service_requests_.insert(resolver);
auto resolver_cb =
WTF::Bind(&ImageCapture::ResolveWithPhotoSettings, WrapPersistent(this));
// m_streamTrack->component()->source()->id() is the renderer "name" of the
// camera;
// TODO(mcasas) consider sending the security origin as well:
// scriptState->getExecutionContext()->getSecurityOrigin()->toString()
service_->GetPhotoState(
stream_track_->Component()->Source()->Id(),
WTF::Bind(&ImageCapture::OnMojoGetPhotoState, WrapPersistent(this),
WrapPersistent(resolver), WTF::Passed(std::move(resolver_cb)),
false /* trigger_take_photo */));
return promise;
}
ScriptPromise ImageCapture::setOptions(ScriptState* script_state,
const PhotoSettings& photo_settings,
bool trigger_take_photo /* = false */) {
ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
ScriptPromise promise = resolver->Promise();
if (TrackIsInactive(*stream_track_)) {
resolver->Reject(DOMException::Create(
kInvalidStateError, "The associated Track is in an invalid state."));
return promise;
}
if (!service_) {
resolver->Reject(DOMException::Create(kNotFoundError, kNoServiceError));
return promise;
}
service_requests_.insert(resolver);
// TODO(mcasas): should be using a mojo::StructTraits instead.
auto settings = media::mojom::blink::PhotoSettings::New();
settings->has_height = photo_settings.hasImageHeight();
if (settings->has_height) {
const double height = photo_settings.imageHeight();
if (photo_capabilities_ &&
(height < photo_capabilities_->imageHeight()->min() ||
height > photo_capabilities_->imageHeight()->max())) {
resolver->Reject(DOMException::Create(
kNotSupportedError, "imageHeight setting out of range"));
return promise;
}
settings->height = height;
}
settings->has_width = photo_settings.hasImageWidth();
if (settings->has_width) {
const double width = photo_settings.imageWidth();
if (photo_capabilities_ &&
(width < photo_capabilities_->imageWidth()->min() ||
width > photo_capabilities_->imageWidth()->max())) {
resolver->Reject(DOMException::Create(kNotSupportedError,
"imageWidth setting out of range"));
return promise;
}
settings->width = width;
}
settings->has_red_eye_reduction = photo_settings.hasRedEyeReduction();
if (settings->has_red_eye_reduction) {
if (photo_capabilities_ &&
!photo_capabilities_->IsRedEyeReductionControllable()) {
resolver->Reject(DOMException::Create(
kNotSupportedError, "redEyeReduction is not controllable."));
return promise;
}
settings->red_eye_reduction = photo_settings.redEyeReduction();
}
settings->has_fill_light_mode = photo_settings.hasFillLightMode();
if (settings->has_fill_light_mode) {
const String fill_light_mode = photo_settings.fillLightMode();
if (photo_capabilities_ && photo_capabilities_->fillLightMode().Find(
fill_light_mode) == kNotFound) {
resolver->Reject(DOMException::Create(kNotSupportedError,
"Unsupported fillLightMode"));
return promise;
}
settings->fill_light_mode = ParseFillLightMode(fill_light_mode);
}
service_->SetOptions(
stream_track_->Component()->Source()->Id(), std::move(settings),
WTF::Bind(&ImageCapture::OnMojoSetOptions, WrapPersistent(this),
WrapPersistent(resolver), trigger_take_photo));
return promise;
}
ScriptPromise ImageCapture::takePhoto(ScriptState* script_state) {
ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
ScriptPromise promise = resolver->Promise();
if (TrackIsInactive(*stream_track_)) {
resolver->Reject(DOMException::Create(
kInvalidStateError, "The associated Track is in an invalid state."));
return promise;
}
if (!service_) {
resolver->Reject(DOMException::Create(kNotFoundError, kNoServiceError));
return promise;
}
service_requests_.insert(resolver);
// m_streamTrack->component()->source()->id() is the renderer "name" of the
// camera;
// TODO(mcasas) consider sending the security origin as well:
// scriptState->getExecutionContext()->getSecurityOrigin()->toString()
service_->TakePhoto(
stream_track_->Component()->Source()->Id(),
WTF::Bind(&ImageCapture::OnMojoTakePhoto, WrapPersistent(this),
WrapPersistent(resolver)));
return promise;
}
ScriptPromise ImageCapture::takePhoto(ScriptState* script_state,
const PhotoSettings& photo_settings) {
return setOptions(script_state, photo_settings,
true /* trigger_take_photo */);
}
ScriptPromise ImageCapture::grabFrame(ScriptState* script_state) {
ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
ScriptPromise promise = resolver->Promise();
if (TrackIsInactive(*stream_track_)) {
resolver->Reject(DOMException::Create(
kInvalidStateError, "The associated Track is in an invalid state."));
return promise;
}
// Create |m_frameGrabber| the first time.
if (!frame_grabber_) {
frame_grabber_ = Platform::Current()->CreateImageCaptureFrameGrabber();
}
if (!frame_grabber_) {
resolver->Reject(DOMException::Create(
kUnknownError, "Couldn't create platform resources"));
return promise;
}
// The platform does not know about MediaStreamTrack, so we wrap it up.
WebMediaStreamTrack track(stream_track_->Component());
frame_grabber_->GrabFrame(
&track, new CallbackPromiseAdapter<ImageBitmap, void>(resolver));
return promise;
}
MediaTrackCapabilities& ImageCapture::GetMediaTrackCapabilities() {
return capabilities_;
}
// TODO(mcasas): make the implementation fully Spec compliant, see the TODOs
// inside the method, https://crbug.com/708723.
void ImageCapture::SetMediaTrackConstraints(
ScriptPromiseResolver* resolver,
const HeapVector<MediaTrackConstraintSet>& constraints_vector) {
DCHECK_GT(constraints_vector.size(), 0u);
if (!service_) {
resolver->Reject(DOMException::Create(kNotFoundError, kNoServiceError));
return;
}
// TODO(mcasas): add support more than one single advanced constraint.
auto constraints = constraints_vector[0];
if ((constraints.hasWhiteBalanceMode() &&
!capabilities_.hasWhiteBalanceMode()) ||
(constraints.hasExposureMode() && !capabilities_.hasExposureMode()) ||
(constraints.hasFocusMode() && !capabilities_.hasFocusMode()) ||
(constraints.hasExposureCompensation() &&
!capabilities_.hasExposureCompensation()) ||
(constraints.hasColorTemperature() &&
!capabilities_.hasColorTemperature()) ||
(constraints.hasIso() && !capabilities_.hasIso()) ||
(constraints.hasBrightness() && !capabilities_.hasBrightness()) ||
(constraints.hasContrast() && !capabilities_.hasContrast()) ||
(constraints.hasSaturation() && !capabilities_.hasSaturation()) ||
(constraints.hasSharpness() && !capabilities_.hasSharpness()) ||
(constraints.hasZoom() && !capabilities_.hasZoom()) ||
(constraints.hasTorch() && !capabilities_.hasTorch())) {
resolver->Reject(
DOMException::Create(kNotSupportedError, "Unsupported constraint(s)"));
return;
}
auto settings = media::mojom::blink::PhotoSettings::New();
MediaTrackConstraintSet temp_constraints = current_constraints_;
// TODO(mcasas): support other Mode types beyond simple string i.e. the
// equivalents of "sequence<DOMString>"" or "ConstrainDOMStringParameters".
settings->has_white_balance_mode = constraints.hasWhiteBalanceMode() &&
constraints.whiteBalanceMode().IsString();
if (settings->has_white_balance_mode) {
const auto white_balance_mode =
constraints.whiteBalanceMode().GetAsString();
if (capabilities_.whiteBalanceMode().Find(white_balance_mode) ==
kNotFound) {
resolver->Reject(DOMException::Create(kNotSupportedError,
"Unsupported whiteBalanceMode."));
return;
}
temp_constraints.setWhiteBalanceMode(constraints.whiteBalanceMode());
settings->white_balance_mode = ParseMeteringMode(white_balance_mode);
}
settings->has_exposure_mode =
constraints.hasExposureMode() && constraints.exposureMode().IsString();
if (settings->has_exposure_mode) {
const auto exposure_mode = constraints.exposureMode().GetAsString();
if (capabilities_.exposureMode().Find(exposure_mode) == kNotFound) {
resolver->Reject(DOMException::Create(kNotSupportedError,
"Unsupported exposureMode."));
return;
}
temp_constraints.setExposureMode(constraints.exposureMode());
settings->exposure_mode = ParseMeteringMode(exposure_mode);
}
settings->has_focus_mode =
constraints.hasFocusMode() && constraints.focusMode().IsString();
if (settings->has_focus_mode) {
const auto focus_mode = constraints.focusMode().GetAsString();
if (capabilities_.focusMode().Find(focus_mode) == kNotFound) {
resolver->Reject(
DOMException::Create(kNotSupportedError, "Unsupported focusMode."));
return;
}
temp_constraints.setFocusMode(constraints.focusMode());
settings->focus_mode = ParseMeteringMode(focus_mode);
}
// TODO(mcasas): support ConstrainPoint2DParameters.
if (constraints.hasPointsOfInterest() &&
constraints.pointsOfInterest().IsPoint2DSequence()) {
for (const auto& point :
constraints.pointsOfInterest().GetAsPoint2DSequence()) {
auto mojo_point = media::mojom::blink::Point2D::New();
mojo_point->x = point.x();
mojo_point->y = point.y();
settings->points_of_interest.push_back(std::move(mojo_point));
}
temp_constraints.setPointsOfInterest(constraints.pointsOfInterest());
}
// TODO(mcasas): support ConstrainDoubleRange where applicable.
settings->has_exposure_compensation =
constraints.hasExposureCompensation() &&
constraints.exposureCompensation().IsDouble();
if (settings->has_exposure_compensation) {
const auto exposure_compensation =
constraints.exposureCompensation().GetAsDouble();
if (exposure_compensation < capabilities_.exposureCompensation()->min() ||
exposure_compensation > capabilities_.exposureCompensation()->max()) {
resolver->Reject(DOMException::Create(
kNotSupportedError, "exposureCompensation setting out of range"));
return;
}
temp_constraints.setExposureCompensation(
constraints.exposureCompensation());
settings->exposure_compensation = exposure_compensation;
}
settings->has_color_temperature = constraints.hasColorTemperature() &&
constraints.colorTemperature().IsDouble();
if (settings->has_color_temperature) {
const auto color_temperature = constraints.colorTemperature().GetAsDouble();
if (color_temperature < capabilities_.colorTemperature()->min() ||
color_temperature > capabilities_.colorTemperature()->max()) {
resolver->Reject(DOMException::Create(
kNotSupportedError, "colorTemperature setting out of range"));
return;
}
temp_constraints.setColorTemperature(constraints.colorTemperature());
settings->color_temperature = color_temperature;
}
settings->has_iso = constraints.hasIso() && constraints.iso().IsDouble();
if (settings->has_iso) {
const auto iso = constraints.iso().GetAsDouble();
if (iso < capabilities_.iso()->min() || iso > capabilities_.iso()->max()) {
resolver->Reject(
DOMException::Create(kNotSupportedError, "iso setting out of range"));
return;
}
temp_constraints.setIso(constraints.iso());
settings->iso = iso;
}
settings->has_brightness =
constraints.hasBrightness() && constraints.brightness().IsDouble();
if (settings->has_brightness) {
const auto brightness = constraints.brightness().GetAsDouble();
if (brightness < capabilities_.brightness()->min() ||
brightness > capabilities_.brightness()->max()) {
resolver->Reject(DOMException::Create(kNotSupportedError,
"brightness setting out of range"));
return;
}
temp_constraints.setBrightness(constraints.brightness());
settings->brightness = brightness;
}
settings->has_contrast =
constraints.hasContrast() && constraints.contrast().IsDouble();
if (settings->has_contrast) {
const auto contrast = constraints.contrast().GetAsDouble();
if (contrast < capabilities_.contrast()->min() ||
contrast > capabilities_.contrast()->max()) {
resolver->Reject(DOMException::Create(kNotSupportedError,
"contrast setting out of range"));
return;
}
temp_constraints.setContrast(constraints.contrast());
settings->contrast = contrast;
}
settings->has_saturation =
constraints.hasSaturation() && constraints.saturation().IsDouble();
if (settings->has_saturation) {
const auto saturation = constraints.saturation().GetAsDouble();
if (saturation < capabilities_.saturation()->min() ||
saturation > capabilities_.saturation()->max()) {
resolver->Reject(DOMException::Create(kNotSupportedError,
"saturation setting out of range"));
return;
}
temp_constraints.setSaturation(constraints.saturation());
settings->saturation = saturation;
}
settings->has_sharpness =
constraints.hasSharpness() && constraints.sharpness().IsDouble();
if (settings->has_sharpness) {
const auto sharpness = constraints.sharpness().GetAsDouble();
if (sharpness < capabilities_.sharpness()->min() ||
sharpness > capabilities_.sharpness()->max()) {
resolver->Reject(DOMException::Create(kNotSupportedError,
"sharpness setting out of range"));
return;
}
temp_constraints.setSharpness(constraints.sharpness());
settings->sharpness = sharpness;
}
settings->has_zoom = constraints.hasZoom() && constraints.zoom().IsDouble();
if (settings->has_zoom) {
const auto zoom = constraints.zoom().GetAsDouble();
if (zoom < capabilities_.zoom()->min() ||
zoom > capabilities_.zoom()->max()) {
resolver->Reject(DOMException::Create(kNotSupportedError,
"zoom setting out of range"));
return;
}
temp_constraints.setZoom(constraints.zoom());
settings->zoom = zoom;
}
// TODO(mcasas): support ConstrainBooleanParameters where applicable.
settings->has_torch =
constraints.hasTorch() && constraints.torch().IsBoolean();
if (settings->has_torch) {
const auto torch = constraints.torch().GetAsBoolean();
if (torch && !capabilities_.torch()) {
resolver->Reject(
DOMException::Create(kNotSupportedError, "torch not supported"));
return;
}
temp_constraints.setTorch(constraints.torch());
settings->torch = torch;
}
current_constraints_ = temp_constraints;
service_requests_.insert(resolver);
service_->SetOptions(
stream_track_->Component()->Source()->Id(), std::move(settings),
WTF::Bind(&ImageCapture::OnMojoSetOptions, WrapPersistent(this),
WrapPersistent(resolver), false /* trigger_take_photo */));
}
const MediaTrackConstraintSet& ImageCapture::GetMediaTrackConstraints() const {
return current_constraints_;
}
void ImageCapture::ClearMediaTrackConstraints() {
current_constraints_ = MediaTrackConstraintSet();
// TODO(mcasas): Clear also any PhotoSettings that the device might have got
// configured, for that we need to know a "default" state of the device; take
// a snapshot upon first opening. https://crbug.com/700607.
}
void ImageCapture::GetMediaTrackSettings(MediaTrackSettings& settings) const {
// Merge any present |settings_| members into |settings|.
if (settings_.hasWhiteBalanceMode())
settings.setWhiteBalanceMode(settings_.whiteBalanceMode());
if (settings_.hasExposureMode())
settings.setExposureMode(settings_.exposureMode());
if (settings_.hasFocusMode())
settings.setFocusMode(settings_.focusMode());
if (settings_.hasPointsOfInterest() &&
!settings_.pointsOfInterest().IsEmpty()) {
settings.setPointsOfInterest(settings_.pointsOfInterest());
}
if (settings_.hasExposureCompensation())
settings.setExposureCompensation(settings_.exposureCompensation());
if (settings_.hasColorTemperature())
settings.setColorTemperature(settings_.colorTemperature());
if (settings_.hasIso())
settings.setIso(settings_.iso());
if (settings_.hasBrightness())
settings.setBrightness(settings_.brightness());
if (settings_.hasContrast())
settings.setContrast(settings_.contrast());
if (settings_.hasSaturation())
settings.setSaturation(settings_.saturation());
if (settings_.hasSharpness())
settings.setSharpness(settings_.sharpness());
if (settings_.hasZoom())
settings.setZoom(settings_.zoom());
if (settings_.hasTorch())
settings.setTorch(settings_.torch());
}
ImageCapture::ImageCapture(ExecutionContext* context, MediaStreamTrack* track)
: ContextLifecycleObserver(context), stream_track_(track) {
DCHECK(stream_track_);
DCHECK(!service_.is_bound());
// This object may be constructed over an ExecutionContext that has already
// been detached. In this case the ImageCapture service will not be available.
if (!GetFrame())
return;
GetFrame()->GetInterfaceProvider().GetInterface(mojo::MakeRequest(&service_));
service_.set_connection_error_handler(WTF::Bind(
&ImageCapture::OnServiceConnectionError, WrapWeakPersistent(this)));
// Launch a retrieval of the current photo state, which arrive asynchronously
// to avoid blocking the main UI thread.
service_->GetPhotoState(stream_track_->Component()->Source()->Id(),
WTF::Bind(&ImageCapture::UpdateMediaTrackCapabilities,
WrapPersistent(this)));
}
void ImageCapture::OnMojoGetPhotoState(
ScriptPromiseResolver* resolver,
PromiseResolverFunction resolve_function,
bool trigger_take_photo,
media::mojom::blink::PhotoStatePtr photo_state) {
DCHECK(service_requests_.Contains(resolver));
if (photo_state.is_null()) {
resolver->Reject(DOMException::Create(kUnknownError, "platform error"));
service_requests_.erase(resolver);
return;
}
photo_settings_ = PhotoSettings();
photo_settings_.setImageHeight(photo_state->height->current);
photo_settings_.setImageWidth(photo_state->width->current);
// TODO(mcasas): collect the remaining two entries https://crbug.com/732521.
photo_capabilities_ = PhotoCapabilities::Create();
photo_capabilities_->SetRedEyeReduction(photo_state->red_eye_reduction);
// TODO(mcasas): Remove the explicit MediaSettingsRange::create() when
// mojo::StructTraits supports garbage-collected mappings,
// https://crbug.com/700180.
if (photo_state->height->min != 0 || photo_state->height->max != 0) {
photo_capabilities_->SetImageHeight(
MediaSettingsRange::Create(std::move(photo_state->height)));
}
if (photo_state->width->min != 0 || photo_state->width->max != 0) {
photo_capabilities_->SetImageWidth(
MediaSettingsRange::Create(std::move(photo_state->width)));
}
if (!photo_state->fill_light_mode.IsEmpty())
photo_capabilities_->SetFillLightMode(photo_state->fill_light_mode);
// Update the local track photo_state cache.
UpdateMediaTrackCapabilities(std::move(photo_state));
if (trigger_take_photo) {
service_->TakePhoto(
stream_track_->Component()->Source()->Id(),
WTF::Bind(&ImageCapture::OnMojoTakePhoto, WrapPersistent(this),
WrapPersistent(resolver)));
return;
}
std::move(resolve_function).Run(resolver);
service_requests_.erase(resolver);
}
void ImageCapture::OnMojoSetOptions(ScriptPromiseResolver* resolver,
bool trigger_take_photo,
bool result) {
DCHECK(service_requests_.Contains(resolver));
if (!result) {
resolver->Reject(DOMException::Create(kUnknownError, "setOptions failed"));
service_requests_.erase(resolver);
return;
}
auto resolver_cb =
WTF::Bind(&ImageCapture::ResolveWithNothing, WrapPersistent(this));
// Retrieve the current device status after setting the options.
service_->GetPhotoState(
stream_track_->Component()->Source()->Id(),
WTF::Bind(&ImageCapture::OnMojoGetPhotoState, WrapPersistent(this),
WrapPersistent(resolver), WTF::Passed(std::move(resolver_cb)),
trigger_take_photo));
}
void ImageCapture::OnMojoTakePhoto(ScriptPromiseResolver* resolver,
media::mojom::blink::BlobPtr blob) {
DCHECK(service_requests_.Contains(resolver));
// TODO(mcasas): Should be using a mojo::StructTraits.
if (blob->data.IsEmpty()) {
resolver->Reject(DOMException::Create(kUnknownError, "platform error"));
} else {
resolver->Resolve(
Blob::Create(blob->data.data(), blob->data.size(), blob->mime_type));
}
service_requests_.erase(resolver);
}
void ImageCapture::UpdateMediaTrackCapabilities(
media::mojom::blink::PhotoStatePtr photo_state) {
if (!photo_state)
return;
WTF::Vector<WTF::String> supported_white_balance_modes;
supported_white_balance_modes.ReserveInitialCapacity(
photo_state->supported_white_balance_modes.size());
for (const auto& supported_mode : photo_state->supported_white_balance_modes)
supported_white_balance_modes.push_back(ToString(supported_mode));
if (!supported_white_balance_modes.IsEmpty()) {
capabilities_.setWhiteBalanceMode(std::move(supported_white_balance_modes));
settings_.setWhiteBalanceMode(
ToString(photo_state->current_white_balance_mode));
}
WTF::Vector<WTF::String> supported_exposure_modes;
supported_exposure_modes.ReserveInitialCapacity(
photo_state->supported_exposure_modes.size());
for (const auto& supported_mode : photo_state->supported_exposure_modes)
supported_exposure_modes.push_back(ToString(supported_mode));
if (!supported_exposure_modes.IsEmpty()) {
capabilities_.setExposureMode(std::move(supported_exposure_modes));
settings_.setExposureMode(ToString(photo_state->current_exposure_mode));
}
WTF::Vector<WTF::String> supported_focus_modes;
supported_focus_modes.ReserveInitialCapacity(
photo_state->supported_focus_modes.size());
for (const auto& supported_mode : photo_state->supported_focus_modes)
supported_focus_modes.push_back(ToString(supported_mode));
if (!supported_focus_modes.IsEmpty()) {
capabilities_.setFocusMode(std::move(supported_focus_modes));
settings_.setFocusMode(ToString(photo_state->current_focus_mode));
}
HeapVector<Point2D> current_points_of_interest;
if (!photo_state->points_of_interest.IsEmpty()) {
for (const auto& point : photo_state->points_of_interest) {
Point2D web_point;
web_point.setX(point->x);
web_point.setY(point->y);
current_points_of_interest.push_back(mojo::Clone(web_point));
}
}
settings_.setPointsOfInterest(std::move(current_points_of_interest));
// TODO(mcasas): Remove the explicit MediaSettingsRange::create() when
// mojo::StructTraits supports garbage-collected mappings,
// https://crbug.com/700180.
if (photo_state->exposure_compensation->max !=
photo_state->exposure_compensation->min) {
capabilities_.setExposureCompensation(
MediaSettingsRange::Create(*photo_state->exposure_compensation));
settings_.setExposureCompensation(
photo_state->exposure_compensation->current);
}
if (photo_state->color_temperature->max !=
photo_state->color_temperature->min) {
capabilities_.setColorTemperature(
MediaSettingsRange::Create(*photo_state->color_temperature));
settings_.setColorTemperature(photo_state->color_temperature->current);
}
if (photo_state->iso->max != photo_state->iso->min) {
capabilities_.setIso(MediaSettingsRange::Create(*photo_state->iso));
settings_.setIso(photo_state->iso->current);
}
if (photo_state->brightness->max != photo_state->brightness->min) {
capabilities_.setBrightness(
MediaSettingsRange::Create(*photo_state->brightness));
settings_.setBrightness(photo_state->brightness->current);
}
if (photo_state->contrast->max != photo_state->contrast->min) {
capabilities_.setContrast(
MediaSettingsRange::Create(*photo_state->contrast));
settings_.setContrast(photo_state->contrast->current);
}
if (photo_state->saturation->max != photo_state->saturation->min) {
capabilities_.setSaturation(
MediaSettingsRange::Create(*photo_state->saturation));
settings_.setSaturation(photo_state->saturation->current);
}
if (photo_state->sharpness->max != photo_state->sharpness->min) {
capabilities_.setSharpness(
MediaSettingsRange::Create(*photo_state->sharpness));
settings_.setSharpness(photo_state->sharpness->current);
}
if (photo_state->zoom->max != photo_state->zoom->min) {
capabilities_.setZoom(MediaSettingsRange::Create(*photo_state->zoom));
settings_.setZoom(photo_state->zoom->current);
}
if (photo_state->supports_torch)
capabilities_.setTorch(photo_state->supports_torch);
if (photo_state->supports_torch)
settings_.setTorch(photo_state->torch);
}
void ImageCapture::OnServiceConnectionError() {
service_.reset();
for (ScriptPromiseResolver* resolver : service_requests_)
resolver->Reject(DOMException::Create(kNotFoundError, kNoServiceError));
service_requests_.clear();
}
void ImageCapture::ResolveWithNothing(ScriptPromiseResolver* resolver) {
DCHECK(resolver);
resolver->Resolve();
}
void ImageCapture::ResolveWithPhotoSettings(ScriptPromiseResolver* resolver) {
DCHECK(resolver);
resolver->Resolve(photo_settings_);
}
void ImageCapture::ResolveWithPhotoCapabilities(
ScriptPromiseResolver* resolver) {
DCHECK(resolver);
resolver->Resolve(photo_capabilities_);
}
void ImageCapture::Trace(blink::Visitor* visitor) {
visitor->Trace(stream_track_);
visitor->Trace(capabilities_);
visitor->Trace(settings_);
visitor->Trace(current_constraints_);
visitor->Trace(photo_capabilities_);
visitor->Trace(service_requests_);
EventTargetWithInlineData::Trace(visitor);
ContextLifecycleObserver::Trace(visitor);
}
} // namespace blink
| [
"arnaud@geometry.ee"
] | arnaud@geometry.ee |
97361912dbb6e3b1b924ff301292747d67eb1886 | 0f23651b08fd5a8ce21b9e78e39e61618996073b | /lib/Target/AMDGPU/SIFrameLowering.cpp | 37f5665be5074eac1e4ef459f02aa47ca4e157c5 | [
"NCSA"
] | permissive | arcosuc3m/clang-contracts | 3983773f15872514f7b6ae72d7fea232864d7e3d | 99446829e2cd96116e4dce9496f88cc7df1dbe80 | refs/heads/master | 2021-07-04T03:24:03.156444 | 2018-12-12T11:41:18 | 2018-12-12T12:56:08 | 118,155,058 | 31 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 28,857 | cpp | //===----------------------- SIFrameLowering.cpp --------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//==-----------------------------------------------------------------------===//
#include "SIFrameLowering.h"
#include "AMDGPUSubtarget.h"
#include "SIInstrInfo.h"
#include "SIMachineFunctionInfo.h"
#include "SIRegisterInfo.h"
#include "llvm/CodeGen/MachineFrameInfo.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
#include "llvm/CodeGen/RegisterScavenging.h"
using namespace llvm;
static ArrayRef<MCPhysReg> getAllSGPR128(const SISubtarget &ST,
const MachineFunction &MF) {
return makeArrayRef(AMDGPU::SGPR_128RegClass.begin(),
ST.getMaxNumSGPRs(MF) / 4);
}
static ArrayRef<MCPhysReg> getAllSGPRs(const SISubtarget &ST,
const MachineFunction &MF) {
return makeArrayRef(AMDGPU::SGPR_32RegClass.begin(),
ST.getMaxNumSGPRs(MF));
}
void SIFrameLowering::emitFlatScratchInit(const SISubtarget &ST,
MachineFunction &MF,
MachineBasicBlock &MBB) const {
const SIInstrInfo *TII = ST.getInstrInfo();
const SIRegisterInfo* TRI = &TII->getRegisterInfo();
const SIMachineFunctionInfo *MFI = MF.getInfo<SIMachineFunctionInfo>();
// We don't need this if we only have spills since there is no user facing
// scratch.
// TODO: If we know we don't have flat instructions earlier, we can omit
// this from the input registers.
//
// TODO: We only need to know if we access scratch space through a flat
// pointer. Because we only detect if flat instructions are used at all,
// this will be used more often than necessary on VI.
// Debug location must be unknown since the first debug location is used to
// determine the end of the prologue.
DebugLoc DL;
MachineBasicBlock::iterator I = MBB.begin();
unsigned FlatScratchInitReg
= MFI->getPreloadedReg(AMDGPUFunctionArgInfo::FLAT_SCRATCH_INIT);
MachineRegisterInfo &MRI = MF.getRegInfo();
MRI.addLiveIn(FlatScratchInitReg);
MBB.addLiveIn(FlatScratchInitReg);
unsigned FlatScrInitLo = TRI->getSubReg(FlatScratchInitReg, AMDGPU::sub0);
unsigned FlatScrInitHi = TRI->getSubReg(FlatScratchInitReg, AMDGPU::sub1);
unsigned ScratchWaveOffsetReg = MFI->getScratchWaveOffsetReg();
// Do a 64-bit pointer add.
if (ST.flatScratchIsPointer()) {
BuildMI(MBB, I, DL, TII->get(AMDGPU::S_ADD_U32), AMDGPU::FLAT_SCR_LO)
.addReg(FlatScrInitLo)
.addReg(ScratchWaveOffsetReg);
BuildMI(MBB, I, DL, TII->get(AMDGPU::S_ADDC_U32), AMDGPU::FLAT_SCR_HI)
.addReg(FlatScrInitHi)
.addImm(0);
return;
}
// Copy the size in bytes.
BuildMI(MBB, I, DL, TII->get(AMDGPU::COPY), AMDGPU::FLAT_SCR_LO)
.addReg(FlatScrInitHi, RegState::Kill);
// Add wave offset in bytes to private base offset.
// See comment in AMDKernelCodeT.h for enable_sgpr_flat_scratch_init.
BuildMI(MBB, I, DL, TII->get(AMDGPU::S_ADD_U32), FlatScrInitLo)
.addReg(FlatScrInitLo)
.addReg(ScratchWaveOffsetReg);
// Convert offset to 256-byte units.
BuildMI(MBB, I, DL, TII->get(AMDGPU::S_LSHR_B32), AMDGPU::FLAT_SCR_HI)
.addReg(FlatScrInitLo, RegState::Kill)
.addImm(8);
}
unsigned SIFrameLowering::getReservedPrivateSegmentBufferReg(
const SISubtarget &ST,
const SIInstrInfo *TII,
const SIRegisterInfo *TRI,
SIMachineFunctionInfo *MFI,
MachineFunction &MF) const {
MachineRegisterInfo &MRI = MF.getRegInfo();
// We need to insert initialization of the scratch resource descriptor.
unsigned ScratchRsrcReg = MFI->getScratchRSrcReg();
if (ScratchRsrcReg == AMDGPU::NoRegister ||
!MRI.isPhysRegUsed(ScratchRsrcReg))
return AMDGPU::NoRegister;
if (ST.hasSGPRInitBug() ||
ScratchRsrcReg != TRI->reservedPrivateSegmentBufferReg(MF))
return ScratchRsrcReg;
// We reserved the last registers for this. Shift it down to the end of those
// which were actually used.
//
// FIXME: It might be safer to use a pseudoregister before replacement.
// FIXME: We should be able to eliminate unused input registers. We only
// cannot do this for the resources required for scratch access. For now we
// skip over user SGPRs and may leave unused holes.
// We find the resource first because it has an alignment requirement.
unsigned NumPreloaded = (MFI->getNumPreloadedSGPRs() + 3) / 4;
ArrayRef<MCPhysReg> AllSGPR128s = getAllSGPR128(ST, MF);
AllSGPR128s = AllSGPR128s.slice(std::min(static_cast<unsigned>(AllSGPR128s.size()), NumPreloaded));
// Skip the last N reserved elements because they should have already been
// reserved for VCC etc.
for (MCPhysReg Reg : AllSGPR128s) {
// Pick the first unallocated one. Make sure we don't clobber the other
// reserved input we needed.
if (!MRI.isPhysRegUsed(Reg) && MRI.isAllocatable(Reg)) {
MRI.replaceRegWith(ScratchRsrcReg, Reg);
MFI->setScratchRSrcReg(Reg);
return Reg;
}
}
return ScratchRsrcReg;
}
// Shift down registers reserved for the scratch wave offset and stack pointer
// SGPRs.
std::pair<unsigned, unsigned>
SIFrameLowering::getReservedPrivateSegmentWaveByteOffsetReg(
const SISubtarget &ST,
const SIInstrInfo *TII,
const SIRegisterInfo *TRI,
SIMachineFunctionInfo *MFI,
MachineFunction &MF) const {
MachineRegisterInfo &MRI = MF.getRegInfo();
unsigned ScratchWaveOffsetReg = MFI->getScratchWaveOffsetReg();
// No replacement necessary.
if (ScratchWaveOffsetReg == AMDGPU::NoRegister ||
!MRI.isPhysRegUsed(ScratchWaveOffsetReg)) {
assert(MFI->getStackPtrOffsetReg() == AMDGPU::SP_REG);
return std::make_pair(AMDGPU::NoRegister, AMDGPU::NoRegister);
}
unsigned SPReg = MFI->getStackPtrOffsetReg();
if (ST.hasSGPRInitBug())
return std::make_pair(ScratchWaveOffsetReg, SPReg);
unsigned NumPreloaded = MFI->getNumPreloadedSGPRs();
ArrayRef<MCPhysReg> AllSGPRs = getAllSGPRs(ST, MF);
if (NumPreloaded > AllSGPRs.size())
return std::make_pair(ScratchWaveOffsetReg, SPReg);
AllSGPRs = AllSGPRs.slice(NumPreloaded);
// We need to drop register from the end of the list that we cannot use
// for the scratch wave offset.
// + 2 s102 and s103 do not exist on VI.
// + 2 for vcc
// + 2 for xnack_mask
// + 2 for flat_scratch
// + 4 for registers reserved for scratch resource register
// + 1 for register reserved for scratch wave offset. (By exluding this
// register from the list to consider, it means that when this
// register is being used for the scratch wave offset and there
// are no other free SGPRs, then the value will stay in this register.
// + 1 if stack pointer is used.
// ----
// 13 (+1)
unsigned ReservedRegCount = 13;
if (AllSGPRs.size() < ReservedRegCount)
return std::make_pair(ScratchWaveOffsetReg, SPReg);
bool HandledScratchWaveOffsetReg =
ScratchWaveOffsetReg != TRI->reservedPrivateSegmentWaveByteOffsetReg(MF);
for (MCPhysReg Reg : AllSGPRs.drop_back(ReservedRegCount)) {
// Pick the first unallocated SGPR. Be careful not to pick an alias of the
// scratch descriptor, since we haven’t added its uses yet.
if (!MRI.isPhysRegUsed(Reg) && MRI.isAllocatable(Reg)) {
if (!HandledScratchWaveOffsetReg) {
HandledScratchWaveOffsetReg = true;
MRI.replaceRegWith(ScratchWaveOffsetReg, Reg);
MFI->setScratchWaveOffsetReg(Reg);
ScratchWaveOffsetReg = Reg;
break;
}
}
}
return std::make_pair(ScratchWaveOffsetReg, SPReg);
}
void SIFrameLowering::emitEntryFunctionPrologue(MachineFunction &MF,
MachineBasicBlock &MBB) const {
// Emit debugger prologue if "amdgpu-debugger-emit-prologue" attribute was
// specified.
const SISubtarget &ST = MF.getSubtarget<SISubtarget>();
if (ST.debuggerEmitPrologue())
emitDebuggerPrologue(MF, MBB);
assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
SIMachineFunctionInfo *MFI = MF.getInfo<SIMachineFunctionInfo>();
// If we only have SGPR spills, we won't actually be using scratch memory
// since these spill to VGPRs.
//
// FIXME: We should be cleaning up these unused SGPR spill frame indices
// somewhere.
const SIInstrInfo *TII = ST.getInstrInfo();
const SIRegisterInfo *TRI = &TII->getRegisterInfo();
MachineRegisterInfo &MRI = MF.getRegInfo();
// We need to do the replacement of the private segment buffer and wave offset
// register even if there are no stack objects. There could be stores to undef
// or a constant without an associated object.
// FIXME: We still have implicit uses on SGPR spill instructions in case they
// need to spill to vector memory. It's likely that will not happen, but at
// this point it appears we need the setup. This part of the prolog should be
// emitted after frame indices are eliminated.
if (MFI->hasFlatScratchInit())
emitFlatScratchInit(ST, MF, MBB);
unsigned SPReg = MFI->getStackPtrOffsetReg();
if (SPReg != AMDGPU::SP_REG) {
assert(MRI.isReserved(SPReg) && "SPReg used but not reserved");
DebugLoc DL;
const MachineFrameInfo &FrameInfo = MF.getFrameInfo();
int64_t StackSize = FrameInfo.getStackSize();
if (StackSize == 0) {
BuildMI(MBB, MBB.begin(), DL, TII->get(AMDGPU::COPY), SPReg)
.addReg(MFI->getScratchWaveOffsetReg());
} else {
BuildMI(MBB, MBB.begin(), DL, TII->get(AMDGPU::S_ADD_U32), SPReg)
.addReg(MFI->getScratchWaveOffsetReg())
.addImm(StackSize * ST.getWavefrontSize());
}
}
unsigned ScratchRsrcReg
= getReservedPrivateSegmentBufferReg(ST, TII, TRI, MFI, MF);
unsigned ScratchWaveOffsetReg;
std::tie(ScratchWaveOffsetReg, SPReg)
= getReservedPrivateSegmentWaveByteOffsetReg(ST, TII, TRI, MFI, MF);
// It's possible to have uses of only ScratchWaveOffsetReg without
// ScratchRsrcReg if it's only used for the initialization of flat_scratch,
// but the inverse is not true.
if (ScratchWaveOffsetReg == AMDGPU::NoRegister) {
assert(ScratchRsrcReg == AMDGPU::NoRegister);
return;
}
// We need to insert initialization of the scratch resource descriptor.
unsigned PreloadedScratchWaveOffsetReg = MFI->getPreloadedReg(
AMDGPUFunctionArgInfo::PRIVATE_SEGMENT_WAVE_BYTE_OFFSET);
unsigned PreloadedPrivateBufferReg = AMDGPU::NoRegister;
if (ST.isAmdCodeObjectV2(MF)) {
PreloadedPrivateBufferReg = MFI->getPreloadedReg(
AMDGPUFunctionArgInfo::PRIVATE_SEGMENT_BUFFER);
}
bool OffsetRegUsed = MRI.isPhysRegUsed(ScratchWaveOffsetReg);
bool ResourceRegUsed = ScratchRsrcReg != AMDGPU::NoRegister &&
MRI.isPhysRegUsed(ScratchRsrcReg);
// We added live-ins during argument lowering, but since they were not used
// they were deleted. We're adding the uses now, so add them back.
if (OffsetRegUsed) {
assert(PreloadedScratchWaveOffsetReg != AMDGPU::NoRegister &&
"scratch wave offset input is required");
MRI.addLiveIn(PreloadedScratchWaveOffsetReg);
MBB.addLiveIn(PreloadedScratchWaveOffsetReg);
}
if (ResourceRegUsed && PreloadedPrivateBufferReg != AMDGPU::NoRegister) {
assert(ST.isAmdCodeObjectV2(MF) || ST.isMesaGfxShader(MF));
MRI.addLiveIn(PreloadedPrivateBufferReg);
MBB.addLiveIn(PreloadedPrivateBufferReg);
}
// Make the register selected live throughout the function.
for (MachineBasicBlock &OtherBB : MF) {
if (&OtherBB == &MBB)
continue;
if (OffsetRegUsed)
OtherBB.addLiveIn(ScratchWaveOffsetReg);
if (ResourceRegUsed)
OtherBB.addLiveIn(ScratchRsrcReg);
}
DebugLoc DL;
MachineBasicBlock::iterator I = MBB.begin();
// If we reserved the original input registers, we don't need to copy to the
// reserved registers.
bool CopyBuffer = ResourceRegUsed &&
PreloadedPrivateBufferReg != AMDGPU::NoRegister &&
ST.isAmdCodeObjectV2(MF) &&
ScratchRsrcReg != PreloadedPrivateBufferReg;
// This needs to be careful of the copying order to avoid overwriting one of
// the input registers before it's been copied to it's final
// destination. Usually the offset should be copied first.
bool CopyBufferFirst = TRI->isSubRegisterEq(PreloadedPrivateBufferReg,
ScratchWaveOffsetReg);
if (CopyBuffer && CopyBufferFirst) {
BuildMI(MBB, I, DL, TII->get(AMDGPU::COPY), ScratchRsrcReg)
.addReg(PreloadedPrivateBufferReg, RegState::Kill);
}
if (OffsetRegUsed &&
PreloadedScratchWaveOffsetReg != ScratchWaveOffsetReg) {
BuildMI(MBB, I, DL, TII->get(AMDGPU::COPY), ScratchWaveOffsetReg)
.addReg(PreloadedScratchWaveOffsetReg,
MRI.isPhysRegUsed(ScratchWaveOffsetReg) ? 0 : RegState::Kill);
}
if (CopyBuffer && !CopyBufferFirst) {
BuildMI(MBB, I, DL, TII->get(AMDGPU::COPY), ScratchRsrcReg)
.addReg(PreloadedPrivateBufferReg, RegState::Kill);
}
if (ResourceRegUsed)
emitEntryFunctionScratchSetup(ST, MF, MBB, MFI, I,
PreloadedPrivateBufferReg, ScratchRsrcReg);
}
// Emit scratch setup code for AMDPAL or Mesa, assuming ResourceRegUsed is set.
void SIFrameLowering::emitEntryFunctionScratchSetup(const SISubtarget &ST,
MachineFunction &MF, MachineBasicBlock &MBB, SIMachineFunctionInfo *MFI,
MachineBasicBlock::iterator I, unsigned PreloadedPrivateBufferReg,
unsigned ScratchRsrcReg) const {
const SIInstrInfo *TII = ST.getInstrInfo();
const SIRegisterInfo *TRI = &TII->getRegisterInfo();
DebugLoc DL;
auto AMDGPUASI = ST.getAMDGPUAS();
if (ST.isAmdPalOS()) {
// The pointer to the GIT is formed from the offset passed in and either
// the amdgpu-git-ptr-high function attribute or the top part of the PC
unsigned RsrcLo = TRI->getSubReg(ScratchRsrcReg, AMDGPU::sub0);
unsigned RsrcHi = TRI->getSubReg(ScratchRsrcReg, AMDGPU::sub1);
unsigned Rsrc01 = TRI->getSubReg(ScratchRsrcReg, AMDGPU::sub0_sub1);
const MCInstrDesc &SMovB32 = TII->get(AMDGPU::S_MOV_B32);
if (MFI->getGITPtrHigh() != 0xffffffff) {
BuildMI(MBB, I, DL, SMovB32, RsrcHi)
.addImm(MFI->getGITPtrHigh())
.addReg(ScratchRsrcReg, RegState::ImplicitDefine);
} else {
const MCInstrDesc &GetPC64 = TII->get(AMDGPU::S_GETPC_B64);
BuildMI(MBB, I, DL, GetPC64, Rsrc01);
}
BuildMI(MBB, I, DL, SMovB32, RsrcLo)
.addReg(AMDGPU::SGPR0) // Low address passed in
.addReg(ScratchRsrcReg, RegState::ImplicitDefine);
// We now have the GIT ptr - now get the scratch descriptor from the entry
// at offset 0.
PointerType *PtrTy =
PointerType::get(Type::getInt64Ty(MF.getFunction()->getContext()),
AMDGPUAS::CONSTANT_ADDRESS);
MachinePointerInfo PtrInfo(UndefValue::get(PtrTy));
const MCInstrDesc &LoadDwordX4 = TII->get(AMDGPU::S_LOAD_DWORDX4_IMM);
auto MMO = MF.getMachineMemOperand(PtrInfo,
MachineMemOperand::MOLoad |
MachineMemOperand::MOInvariant |
MachineMemOperand::MODereferenceable,
0, 0);
BuildMI(MBB, I, DL, LoadDwordX4, ScratchRsrcReg)
.addReg(Rsrc01)
.addImm(0) // offset
.addImm(0) // glc
.addReg(ScratchRsrcReg, RegState::ImplicitDefine)
.addMemOperand(MMO);
return;
}
if (ST.isMesaGfxShader(MF)
|| (PreloadedPrivateBufferReg == AMDGPU::NoRegister)) {
assert(!ST.isAmdCodeObjectV2(MF));
const MCInstrDesc &SMovB32 = TII->get(AMDGPU::S_MOV_B32);
unsigned Rsrc2 = TRI->getSubReg(ScratchRsrcReg, AMDGPU::sub2);
unsigned Rsrc3 = TRI->getSubReg(ScratchRsrcReg, AMDGPU::sub3);
// Use relocations to get the pointer, and setup the other bits manually.
uint64_t Rsrc23 = TII->getScratchRsrcWords23();
if (MFI->hasImplicitBufferPtr()) {
unsigned Rsrc01 = TRI->getSubReg(ScratchRsrcReg, AMDGPU::sub0_sub1);
if (AMDGPU::isCompute(MF.getFunction()->getCallingConv())) {
const MCInstrDesc &Mov64 = TII->get(AMDGPU::S_MOV_B64);
BuildMI(MBB, I, DL, Mov64, Rsrc01)
.addReg(MFI->getImplicitBufferPtrUserSGPR())
.addReg(ScratchRsrcReg, RegState::ImplicitDefine);
} else {
const MCInstrDesc &LoadDwordX2 = TII->get(AMDGPU::S_LOAD_DWORDX2_IMM);
PointerType *PtrTy =
PointerType::get(Type::getInt64Ty(MF.getFunction()->getContext()),
AMDGPUASI.CONSTANT_ADDRESS);
MachinePointerInfo PtrInfo(UndefValue::get(PtrTy));
auto MMO = MF.getMachineMemOperand(PtrInfo,
MachineMemOperand::MOLoad |
MachineMemOperand::MOInvariant |
MachineMemOperand::MODereferenceable,
0, 0);
BuildMI(MBB, I, DL, LoadDwordX2, Rsrc01)
.addReg(MFI->getImplicitBufferPtrUserSGPR())
.addImm(0) // offset
.addImm(0) // glc
.addMemOperand(MMO)
.addReg(ScratchRsrcReg, RegState::ImplicitDefine);
}
} else {
unsigned Rsrc0 = TRI->getSubReg(ScratchRsrcReg, AMDGPU::sub0);
unsigned Rsrc1 = TRI->getSubReg(ScratchRsrcReg, AMDGPU::sub1);
BuildMI(MBB, I, DL, SMovB32, Rsrc0)
.addExternalSymbol("SCRATCH_RSRC_DWORD0")
.addReg(ScratchRsrcReg, RegState::ImplicitDefine);
BuildMI(MBB, I, DL, SMovB32, Rsrc1)
.addExternalSymbol("SCRATCH_RSRC_DWORD1")
.addReg(ScratchRsrcReg, RegState::ImplicitDefine);
}
BuildMI(MBB, I, DL, SMovB32, Rsrc2)
.addImm(Rsrc23 & 0xffffffff)
.addReg(ScratchRsrcReg, RegState::ImplicitDefine);
BuildMI(MBB, I, DL, SMovB32, Rsrc3)
.addImm(Rsrc23 >> 32)
.addReg(ScratchRsrcReg, RegState::ImplicitDefine);
}
}
void SIFrameLowering::emitPrologue(MachineFunction &MF,
MachineBasicBlock &MBB) const {
const SIMachineFunctionInfo *FuncInfo = MF.getInfo<SIMachineFunctionInfo>();
if (FuncInfo->isEntryFunction()) {
emitEntryFunctionPrologue(MF, MBB);
return;
}
const MachineFrameInfo &MFI = MF.getFrameInfo();
const SISubtarget &ST = MF.getSubtarget<SISubtarget>();
const SIInstrInfo *TII = ST.getInstrInfo();
unsigned StackPtrReg = FuncInfo->getStackPtrOffsetReg();
unsigned FramePtrReg = FuncInfo->getFrameOffsetReg();
MachineBasicBlock::iterator MBBI = MBB.begin();
DebugLoc DL;
bool NeedFP = hasFP(MF);
if (NeedFP) {
// If we need a base pointer, set it up here. It's whatever the value of
// the stack pointer is at this point. Any variable size objects will be
// allocated after this, so we can still use the base pointer to reference
// locals.
BuildMI(MBB, MBBI, DL, TII->get(AMDGPU::COPY), FramePtrReg)
.addReg(StackPtrReg)
.setMIFlag(MachineInstr::FrameSetup);
}
uint32_t NumBytes = MFI.getStackSize();
if (NumBytes != 0 && hasSP(MF)) {
BuildMI(MBB, MBBI, DL, TII->get(AMDGPU::S_ADD_U32), StackPtrReg)
.addReg(StackPtrReg)
.addImm(NumBytes * ST.getWavefrontSize())
.setMIFlag(MachineInstr::FrameSetup);
}
for (const SIMachineFunctionInfo::SGPRSpillVGPRCSR &Reg
: FuncInfo->getSGPRSpillVGPRs()) {
if (!Reg.FI.hasValue())
continue;
TII->storeRegToStackSlot(MBB, MBBI, Reg.VGPR, true,
Reg.FI.getValue(), &AMDGPU::VGPR_32RegClass,
&TII->getRegisterInfo());
}
}
void SIFrameLowering::emitEpilogue(MachineFunction &MF,
MachineBasicBlock &MBB) const {
const SIMachineFunctionInfo *FuncInfo = MF.getInfo<SIMachineFunctionInfo>();
if (FuncInfo->isEntryFunction())
return;
const SISubtarget &ST = MF.getSubtarget<SISubtarget>();
const SIInstrInfo *TII = ST.getInstrInfo();
MachineBasicBlock::iterator MBBI = MBB.getFirstTerminator();
for (const SIMachineFunctionInfo::SGPRSpillVGPRCSR &Reg
: FuncInfo->getSGPRSpillVGPRs()) {
if (!Reg.FI.hasValue())
continue;
TII->loadRegFromStackSlot(MBB, MBBI, Reg.VGPR,
Reg.FI.getValue(), &AMDGPU::VGPR_32RegClass,
&TII->getRegisterInfo());
}
unsigned StackPtrReg = FuncInfo->getStackPtrOffsetReg();
if (StackPtrReg == AMDGPU::NoRegister)
return;
const MachineFrameInfo &MFI = MF.getFrameInfo();
uint32_t NumBytes = MFI.getStackSize();
DebugLoc DL;
// FIXME: Clarify distinction between no set SP and SP. For callee functions,
// it's really whether we need SP to be accurate or not.
if (NumBytes != 0 && hasSP(MF)) {
BuildMI(MBB, MBBI, DL, TII->get(AMDGPU::S_SUB_U32), StackPtrReg)
.addReg(StackPtrReg)
.addImm(NumBytes * ST.getWavefrontSize())
.setMIFlag(MachineInstr::FrameDestroy);
}
}
static bool allStackObjectsAreDead(const MachineFrameInfo &MFI) {
for (int I = MFI.getObjectIndexBegin(), E = MFI.getObjectIndexEnd();
I != E; ++I) {
if (!MFI.isDeadObjectIndex(I))
return false;
}
return true;
}
int SIFrameLowering::getFrameIndexReference(const MachineFunction &MF, int FI,
unsigned &FrameReg) const {
const SIRegisterInfo *RI = MF.getSubtarget<SISubtarget>().getRegisterInfo();
FrameReg = RI->getFrameRegister(MF);
return MF.getFrameInfo().getObjectOffset(FI);
}
void SIFrameLowering::processFunctionBeforeFrameFinalized(
MachineFunction &MF,
RegScavenger *RS) const {
MachineFrameInfo &MFI = MF.getFrameInfo();
if (!MFI.hasStackObjects())
return;
const SISubtarget &ST = MF.getSubtarget<SISubtarget>();
const SIInstrInfo *TII = ST.getInstrInfo();
const SIRegisterInfo &TRI = TII->getRegisterInfo();
SIMachineFunctionInfo *FuncInfo = MF.getInfo<SIMachineFunctionInfo>();
bool AllSGPRSpilledToVGPRs = false;
if (TRI.spillSGPRToVGPR() && FuncInfo->hasSpilledSGPRs()) {
AllSGPRSpilledToVGPRs = true;
// Process all SGPR spills before frame offsets are finalized. Ideally SGPRs
// are spilled to VGPRs, in which case we can eliminate the stack usage.
//
// XXX - This operates under the assumption that only other SGPR spills are
// users of the frame index. I'm not 100% sure this is correct. The
// StackColoring pass has a comment saying a future improvement would be to
// merging of allocas with spill slots, but for now according to
// MachineFrameInfo isSpillSlot can't alias any other object.
for (MachineBasicBlock &MBB : MF) {
MachineBasicBlock::iterator Next;
for (auto I = MBB.begin(), E = MBB.end(); I != E; I = Next) {
MachineInstr &MI = *I;
Next = std::next(I);
if (TII->isSGPRSpill(MI)) {
int FI = TII->getNamedOperand(MI, AMDGPU::OpName::addr)->getIndex();
if (FuncInfo->allocateSGPRSpillToVGPR(MF, FI)) {
bool Spilled = TRI.eliminateSGPRToVGPRSpillFrameIndex(MI, FI, RS);
(void)Spilled;
assert(Spilled && "failed to spill SGPR to VGPR when allocated");
} else
AllSGPRSpilledToVGPRs = false;
}
}
}
FuncInfo->removeSGPRToVGPRFrameIndices(MFI);
}
// FIXME: The other checks should be redundant with allStackObjectsAreDead,
// but currently hasNonSpillStackObjects is set only from source
// allocas. Stack temps produced from legalization are not counted currently.
if (FuncInfo->hasNonSpillStackObjects() || FuncInfo->hasSpilledVGPRs() ||
!AllSGPRSpilledToVGPRs || !allStackObjectsAreDead(MFI)) {
assert(RS && "RegScavenger required if spilling");
// We force this to be at offset 0 so no user object ever has 0 as an
// address, so we may use 0 as an invalid pointer value. This is because
// LLVM assumes 0 is an invalid pointer in address space 0. Because alloca
// is required to be address space 0, we are forced to accept this for
// now. Ideally we could have the stack in another address space with 0 as a
// valid pointer, and -1 as the null value.
//
// This will also waste additional space when user stack objects require > 4
// byte alignment.
//
// The main cost here is losing the offset for addressing modes. However
// this also ensures we shouldn't need a register for the offset when
// emergency scavenging.
int ScavengeFI = MFI.CreateFixedObject(
TRI.getSpillSize(AMDGPU::SGPR_32RegClass), 0, false);
RS->addScavengingFrameIndex(ScavengeFI);
}
}
void SIFrameLowering::determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs,
RegScavenger *RS) const {
TargetFrameLowering::determineCalleeSaves(MF, SavedRegs, RS);
const SIMachineFunctionInfo *MFI = MF.getInfo<SIMachineFunctionInfo>();
// The SP is specifically managed and we don't want extra spills of it.
SavedRegs.reset(MFI->getStackPtrOffsetReg());
}
MachineBasicBlock::iterator SIFrameLowering::eliminateCallFramePseudoInstr(
MachineFunction &MF,
MachineBasicBlock &MBB,
MachineBasicBlock::iterator I) const {
int64_t Amount = I->getOperand(0).getImm();
if (Amount == 0)
return MBB.erase(I);
const SISubtarget &ST = MF.getSubtarget<SISubtarget>();
const SIInstrInfo *TII = ST.getInstrInfo();
const DebugLoc &DL = I->getDebugLoc();
unsigned Opc = I->getOpcode();
bool IsDestroy = Opc == TII->getCallFrameDestroyOpcode();
uint64_t CalleePopAmount = IsDestroy ? I->getOperand(1).getImm() : 0;
const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering();
if (!TFI->hasReservedCallFrame(MF)) {
unsigned Align = getStackAlignment();
Amount = alignTo(Amount, Align);
assert(isUInt<32>(Amount) && "exceeded stack address space size");
const SIMachineFunctionInfo *MFI = MF.getInfo<SIMachineFunctionInfo>();
unsigned SPReg = MFI->getStackPtrOffsetReg();
unsigned Op = IsDestroy ? AMDGPU::S_SUB_U32 : AMDGPU::S_ADD_U32;
BuildMI(MBB, I, DL, TII->get(Op), SPReg)
.addReg(SPReg)
.addImm(Amount * ST.getWavefrontSize());
} else if (CalleePopAmount != 0) {
llvm_unreachable("is this used?");
}
return MBB.erase(I);
}
void SIFrameLowering::emitDebuggerPrologue(MachineFunction &MF,
MachineBasicBlock &MBB) const {
const SISubtarget &ST = MF.getSubtarget<SISubtarget>();
const SIInstrInfo *TII = ST.getInstrInfo();
const SIRegisterInfo *TRI = &TII->getRegisterInfo();
const SIMachineFunctionInfo *MFI = MF.getInfo<SIMachineFunctionInfo>();
MachineBasicBlock::iterator I = MBB.begin();
DebugLoc DL;
// For each dimension:
for (unsigned i = 0; i < 3; ++i) {
// Get work group ID SGPR, and make it live-in again.
unsigned WorkGroupIDSGPR = MFI->getWorkGroupIDSGPR(i);
MF.getRegInfo().addLiveIn(WorkGroupIDSGPR);
MBB.addLiveIn(WorkGroupIDSGPR);
// Since SGPRs are spilled into VGPRs, copy work group ID SGPR to VGPR in
// order to spill it to scratch.
unsigned WorkGroupIDVGPR =
MF.getRegInfo().createVirtualRegister(&AMDGPU::VGPR_32RegClass);
BuildMI(MBB, I, DL, TII->get(AMDGPU::V_MOV_B32_e32), WorkGroupIDVGPR)
.addReg(WorkGroupIDSGPR);
// Spill work group ID.
int WorkGroupIDObjectIdx = MFI->getDebuggerWorkGroupIDStackObjectIndex(i);
TII->storeRegToStackSlot(MBB, I, WorkGroupIDVGPR, false,
WorkGroupIDObjectIdx, &AMDGPU::VGPR_32RegClass, TRI);
// Get work item ID VGPR, and make it live-in again.
unsigned WorkItemIDVGPR = MFI->getWorkItemIDVGPR(i);
MF.getRegInfo().addLiveIn(WorkItemIDVGPR);
MBB.addLiveIn(WorkItemIDVGPR);
// Spill work item ID.
int WorkItemIDObjectIdx = MFI->getDebuggerWorkItemIDStackObjectIndex(i);
TII->storeRegToStackSlot(MBB, I, WorkItemIDVGPR, false,
WorkItemIDObjectIdx, &AMDGPU::VGPR_32RegClass, TRI);
}
}
bool SIFrameLowering::hasFP(const MachineFunction &MF) const {
// All stack operations are relative to the frame offset SGPR.
// TODO: Still want to eliminate sometimes.
const MachineFrameInfo &MFI = MF.getFrameInfo();
// XXX - Is this only called after frame is finalized? Should be able to check
// frame size.
return MFI.hasStackObjects() && !allStackObjectsAreDead(MFI);
}
bool SIFrameLowering::hasSP(const MachineFunction &MF) const {
// All stack operations are relative to the frame offset SGPR.
const MachineFrameInfo &MFI = MF.getFrameInfo();
return MFI.hasCalls() || MFI.hasVarSizedObjects();
}
| [
"courbet@91177308-0d34-0410-b5e6-96231b3b80d8"
] | courbet@91177308-0d34-0410-b5e6-96231b3b80d8 |
1b81ba1c03618161ffee524510bcc5056565c1b7 | 48e9625fcc35e6bf790aa5d881151906280a3554 | /Sources/Elastos/LibCore/src/elastos/io/Int16ArrayBuffer.cpp | c7a7048dc512e482aff91aa3a6f9bf137b4cbb44 | [
"Apache-2.0"
] | permissive | suchto/ElastosRT | f3d7e163d61fe25517846add777690891aa5da2f | 8a542a1d70aebee3dbc31341b7e36d8526258849 | refs/heads/master | 2021-01-22T20:07:56.627811 | 2017-03-17T02:37:51 | 2017-03-17T02:37:51 | 85,281,630 | 4 | 2 | null | 2017-03-17T07:08:49 | 2017-03-17T07:08:49 | null | UTF-8 | C++ | false | false | 8,022 | cpp | //=========================================================================
// Copyright (C) 2012 The Elastos 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.
//=========================================================================
#include "Int16ArrayBuffer.h"
#include "CByteOrderHelper.h"
namespace Elastos {
namespace IO {
Int16ArrayBuffer::Int16ArrayBuffer()
: mArrayOffset(0)
, mIsReadOnly(FALSE)
{
}
ECode Int16ArrayBuffer::constructor(
/* [in] */ ArrayOf<Int16>* array)
{
FAIL_RETURN(Int16Buffer::constructor(array->GetLength(), 0))
mBackingArray = array;
return NOERROR;
}
ECode Int16ArrayBuffer::constructor(
/* [in] */ Int32 capacity,
/* [in] */ ArrayOf<Int16>* backingArray,
/* [in] */ Int32 offset,
/* [in] */ Boolean isReadOnly)
{
FAIL_RETURN(Int16Buffer::constructor(capacity, 0))
mBackingArray = backingArray;
mArrayOffset = offset;
mIsReadOnly = isReadOnly;
return NOERROR;
}
ECode Int16ArrayBuffer::GetPrimitiveArray(
/* [out] */ Handle64* arrayHandle)
{
AutoPtr<ArrayOf<Int16> > arrayTmp;
GetArray((ArrayOf<Int16>**)&arrayTmp);
if (arrayTmp == NULL)
{
*arrayHandle = 0;
return NOERROR;
}
Int16* primitiveArray = arrayTmp->GetPayload();
*arrayHandle = reinterpret_cast<Handle64>(primitiveArray);
return NOERROR;
}
ECode Int16ArrayBuffer::Get(
/* [out] */ Int16* value)
{
VALIDATE_NOT_NULL(value);
*value = 0;
if (mPosition == mLimit) {
// throw new BufferUnderflowException();
return E_BUFFER_UNDER_FLOW_EXCEPTION;
}
*value = (*mBackingArray)[mArrayOffset + mPosition++];
return NOERROR;
}
ECode Int16ArrayBuffer::Get(
/* [in] */ Int32 index,
/* [out] */ Int16* value)
{
VALIDATE_NOT_NULL(value);
*value = 0;
FAIL_RETURN(CheckIndex(index))
*value = (*mBackingArray)[mArrayOffset + index];
return NOERROR;
}
ECode Int16ArrayBuffer::Get(
/* [out] */ ArrayOf<Int16>* dst,
/* [in] */ Int32 dstOffset,
/* [in] */ Int32 int16Count)
{
VALIDATE_NOT_NULL(dst);
Int32 remaining = 0;
GetRemaining(&remaining);
if (int16Count > remaining) {
// throw new BufferUnderflowException();
return E_BUFFER_UNDER_FLOW_EXCEPTION;
}
dst->Copy(dstOffset, mBackingArray, mArrayOffset + mPosition, int16Count);
mPosition += int16Count;
return NOERROR;
}
ECode Int16ArrayBuffer::IsDirect(
/* [out] */ Boolean* isDirect)
{
VALIDATE_NOT_NULL(isDirect);
*isDirect = FALSE;
return NOERROR;
}
ECode Int16ArrayBuffer::GetOrder(
/* [out] */ ByteOrder* byteOrder)
{
VALIDATE_NOT_NULL(byteOrder)
AutoPtr<IByteOrderHelper> helper;
ASSERT_SUCCEEDED(CByteOrderHelper::AcquireSingleton((IByteOrderHelper**)&helper))
return helper->GetNativeOrder(byteOrder);
}
ECode Int16ArrayBuffer::AsReadOnlyBuffer(
/* [out] */ IInt16Buffer** buffer)
{
VALIDATE_NOT_NULL(buffer)
*buffer = NULL;
AutoPtr<Int16ArrayBuffer> iab;
FAIL_RETURN(Copy(this, mMark, TRUE, (Int16ArrayBuffer**)&iab))
*buffer = IInt16Buffer::Probe(iab);
REFCOUNT_ADD(*buffer)
return NOERROR;
}
ECode Int16ArrayBuffer::Compact()
{
if (mIsReadOnly) {
// throw new ReadOnlyBufferException();
return E_READ_ONLY_BUFFER_EXCEPTION;
}
// System.arraycopy(backingArray, mPosition + mArrayOffset, backingArray, mArrayOffset, remaining());
Int32 reaminvalue = 0;
GetRemaining(&reaminvalue);
mBackingArray->Copy(mArrayOffset, mBackingArray, mPosition + mArrayOffset, reaminvalue);
mPosition = mLimit - mPosition;
mLimit = mCapacity;
mMark = UNSET_MARK;
return NOERROR;
}
ECode Int16ArrayBuffer::Duplicate(
/* [out] */ IInt16Buffer** buffer)
{
VALIDATE_NOT_NULL(buffer)
*buffer = NULL;
AutoPtr<Int16ArrayBuffer> iab;
FAIL_RETURN(Copy(this, mMark, mIsReadOnly, (Int16ArrayBuffer**)&iab))
*buffer = IInt16Buffer::Probe(iab);
REFCOUNT_ADD(*buffer)
return NOERROR;
}
ECode Int16ArrayBuffer::ProtectedArray(
/* [out, callee] */ ArrayOf<Int16>** array)
{
VALIDATE_NOT_NULL(array)
*array = NULL;
if (mIsReadOnly) {
// throw new ReadOnlyBufferException();
return E_READ_ONLY_BUFFER_EXCEPTION;
}
*array = mBackingArray;
REFCOUNT_ADD(*array)
return NOERROR;
}
ECode Int16ArrayBuffer::ProtectedArrayOffset(
/* [out] */ Int32* offset)
{
VALIDATE_NOT_NULL(offset)
*offset = 0;
if (mIsReadOnly) {
// throw new ReadOnlyBufferException();
return E_READ_ONLY_BUFFER_EXCEPTION;
}
*offset = mArrayOffset;
return NOERROR;
}
ECode Int16ArrayBuffer::ProtectedHasArray(
/* [out] */ Boolean* hasArray)
{
VALIDATE_NOT_NULL(hasArray)
*hasArray = TRUE;
if (mIsReadOnly) {
*hasArray = FALSE;
}
return NOERROR;
}
ECode Int16ArrayBuffer::Put(
/* [in] */ Int16 d)
{
if (mIsReadOnly) {
// throw new ReadOnlyBufferException();
return E_READ_ONLY_BUFFER_EXCEPTION;
}
if (mPosition == mLimit) {
// throw new BufferOverflowException();
return E_BUFFER_UNDER_FLOW_EXCEPTION;
}
(*mBackingArray)[mArrayOffset + mPosition++] = d;
return NOERROR;
}
ECode Int16ArrayBuffer::Put(
/* [in] */ Int32 index,
/* [in] */ Int16 d)
{
if (mIsReadOnly) {
// throw new ReadOnlyBufferException();
return E_READ_ONLY_BUFFER_EXCEPTION;
}
FAIL_RETURN(CheckIndex(index));
(*mBackingArray)[mArrayOffset + index] = d;
return NOERROR;
}
ECode Int16ArrayBuffer::Put(
/* [in] */ const ArrayOf<Int16>& src,
/* [in] */ Int32 srcOffset,
/* [in] */ Int32 doubleCount)
{
if (mIsReadOnly) {
// throw new ReadOnlyBufferException();
return E_READ_ONLY_BUFFER_EXCEPTION;
}
Int32 remainvalue = 0;
GetRemaining(&remainvalue);
if (doubleCount > remainvalue) {
// throw new BufferOverflowException();
return E_BUFFER_OVERFLOW_EXCEPTION;
}
// System.arraycopy(src, srcOffset, backingArray, mArrayOffset + mPosition, doubleCount);
mBackingArray->Copy(mArrayOffset + mPosition, &src, srcOffset, doubleCount);
mPosition += doubleCount;
return NOERROR;
}
ECode Int16ArrayBuffer::Slice(
/* [out] */ IInt16Buffer** buffer)
{
VALIDATE_NOT_NULL(buffer)
*buffer = NULL;
Int32 remainvalue = 0;
GetRemaining(&remainvalue);
AutoPtr<Int16ArrayBuffer> iab = new Int16ArrayBuffer();
FAIL_RETURN(iab->constructor(remainvalue, mBackingArray, mArrayOffset + mPosition, mIsReadOnly))
*buffer = IInt16Buffer::Probe(iab);
REFCOUNT_ADD(*buffer)
return NOERROR;
}
ECode Int16ArrayBuffer::IsReadOnly(
/* [out] */ Boolean* value)
{
VALIDATE_NOT_NULL(value)
*value = mIsReadOnly;
return NOERROR;
}
ECode Int16ArrayBuffer::Copy(
/* [in] */ Int16ArrayBuffer* other,
/* [in] */ Int32 mMarkOfOther,
/* [in] */ Boolean mIsReadOnly,
/* [out] */ Int16ArrayBuffer** buffer)
{
VALIDATE_NOT_NULL(buffer)
*buffer = NULL;
Int32 capvalue = 0;
other->GetCapacity(&capvalue);
AutoPtr<Int16ArrayBuffer> iab = new Int16ArrayBuffer();
FAIL_RETURN(iab->constructor(capvalue, other->mBackingArray, other->mArrayOffset, mIsReadOnly))
iab->mLimit = other->mLimit;
other->GetPosition(&iab->mPosition);
iab->mMark = mMarkOfOther;
*buffer = iab;
REFCOUNT_ADD(*buffer)
return NOERROR;
}
} // namespace IO
} // namespace Elastos
| [
"cao.jing@kortide.com"
] | cao.jing@kortide.com |
be188d4b3f95d575d39ff959edede88b6e93aeb5 | 4f40a304c125308bec55c7f1a611adfb26d20091 | /VC/DLL劫持学习/逆向的lpk病毒/lpk病毒分析及查杀工具源码/lpk病毒分析笔记/Exe/HookApi/detours.h | 1c568dc365107b4ea2ea70fa27a843fcbb6d1632 | [] | no_license | tlsloves/windows_note | b696bae0332af4f6b68ad3d04e1e4d12b215c6dd | 9125f4ea8af2f685c8b198ad785b951fb6eb8886 | refs/heads/master | 2021-05-29T12:07:49.680854 | 2015-06-29T12:58:33 | 2015-06-29T12:58:33 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 18,719 | h | //////////////////////////////////////////////////////////////////////////////
//
// Core Detours Functionality (detours.h of detours.lib)
//
// Microsoft Research Detours Package, Version 2.1.
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
#pragma once
#ifndef _DETOURS_H_
#define _DETOURS_H_
#define DETOURS_X86
#define DETOURS_VERSION 20100 // 2.1.0
//////////////////////////////////////////////////////////////////////////////
//
#if (_MSC_VER < 1299)
typedef LONG LONG_PTR;
typedef ULONG ULONG_PTR;
#endif
#ifndef __in_z
#define __in_z
#endif
//////////////////////////////////////////////////////////////////////////////
//
#ifndef GUID_DEFINED
#define GUID_DEFINED
typedef struct _GUID
{
DWORD Data1;
WORD Data2;
WORD Data3;
BYTE Data4[ 8 ];
} GUID;
#ifdef INITGUID
#define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
const GUID name \
= { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }
#else
#define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
const GUID name
#endif // INITGUID
#endif // !GUID_DEFINED
#if defined(__cplusplus)
#ifndef _REFGUID_DEFINED
#define _REFGUID_DEFINED
#define REFGUID const GUID &
#endif // !_REFGUID_DEFINED
#else // !__cplusplus
#ifndef _REFGUID_DEFINED
#define _REFGUID_DEFINED
#define REFGUID const GUID * const
#endif // !_REFGUID_DEFINED
#endif // !__cplusplus
//
//////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
/////////////////////////////////////////////////// Instruction Target Macros.
//
#define DETOUR_INSTRUCTION_TARGET_NONE ((PVOID)0)
#define DETOUR_INSTRUCTION_TARGET_DYNAMIC ((PVOID)(LONG_PTR)-1)
#define DETOUR_SECTION_HEADER_SIGNATURE 0x00727444 // "Dtr\0"
extern const GUID DETOUR_EXE_RESTORE_GUID;
#define DETOUR_TRAMPOLINE_SIGNATURE 0x21727444 // Dtr!
typedef struct _DETOUR_TRAMPOLINE DETOUR_TRAMPOLINE, *PDETOUR_TRAMPOLINE;
/////////////////////////////////////////////////////////// Binary Structures.
//
#pragma pack(push, 8)
typedef struct _DETOUR_SECTION_HEADER
{
DWORD cbHeaderSize;
DWORD nSignature;
DWORD nDataOffset;
DWORD cbDataSize;
DWORD nOriginalImportVirtualAddress;
DWORD nOriginalImportSize;
DWORD nOriginalBoundImportVirtualAddress;
DWORD nOriginalBoundImportSize;
DWORD nOriginalIatVirtualAddress;
DWORD nOriginalIatSize;
DWORD nOriginalSizeOfImage;
DWORD cbPrePE;
DWORD nOriginalClrFlags;
DWORD reserved1;
DWORD reserved2;
DWORD reserved3;
// Followed by cbPrePE bytes of data.
} DETOUR_SECTION_HEADER, *PDETOUR_SECTION_HEADER;
typedef struct _DETOUR_SECTION_RECORD
{
DWORD cbBytes;
DWORD nReserved;
GUID guid;
} DETOUR_SECTION_RECORD, *PDETOUR_SECTION_RECORD;
typedef struct _DETOUR_CLR_HEADER
{
// Header versioning
ULONG cb;
USHORT MajorRuntimeVersion;
USHORT MinorRuntimeVersion;
// Symbol table and startup information
IMAGE_DATA_DIRECTORY MetaData;
ULONG Flags;
// Followed by the rest of the header.
} DETOUR_CLR_HEADER, *PDETOUR_CLR_HEADER;
typedef struct _DETOUR_EXE_RESTORE
{
ULONG cb;
PIMAGE_DOS_HEADER pidh;
PIMAGE_NT_HEADERS pinh;
PULONG pclrFlags;
DWORD impDirProt;
IMAGE_DOS_HEADER idh;
IMAGE_NT_HEADERS inh;
ULONG clrFlags;
} DETOUR_EXE_RESTORE, *PDETOUR_EXE_RESTORE;
#pragma pack(pop)
#define DETOUR_SECTION_HEADER_DECLARE(cbSectionSize) \
{ \
sizeof(DETOUR_SECTION_HEADER),\
DETOUR_SECTION_HEADER_SIGNATURE,\
sizeof(DETOUR_SECTION_HEADER),\
(cbSectionSize),\
\
0,\
0,\
0,\
0,\
\
0,\
0,\
0,\
0,\
}
///////////////////////////////////////////////////////////// Binary Typedefs.
//
typedef BOOL (CALLBACK *PF_DETOUR_BINARY_BYWAY_CALLBACK)(PVOID pContext,
PCHAR pszFile,
PCHAR *ppszOutFile);
typedef BOOL (CALLBACK *PF_DETOUR_BINARY_FILE_CALLBACK)(PVOID pContext,
PCHAR pszOrigFile,
PCHAR pszFile,
PCHAR *ppszOutFile);
typedef BOOL (CALLBACK *PF_DETOUR_BINARY_SYMBOL_CALLBACK)(PVOID pContext,
ULONG nOrigOrdinal,
ULONG nOrdinal,
ULONG *pnOutOrdinal,
PCHAR pszOrigSymbol,
PCHAR pszSymbol,
PCHAR *ppszOutSymbol);
typedef BOOL (CALLBACK *PF_DETOUR_BINARY_COMMIT_CALLBACK)(PVOID pContext);
typedef BOOL (CALLBACK *PF_DETOUR_ENUMERATE_EXPORT_CALLBACK)(PVOID pContext,
ULONG nOrdinal,
PCHAR pszName,
PVOID pCode);
typedef VOID * PDETOUR_BINARY;
typedef VOID * PDETOUR_LOADED_BINARY;
//////////////////////////////////////////////////////////// Detours 2.1 APIs.
//
LONG WINAPI DetourTransactionBegin();
LONG WINAPI DetourTransactionAbort();
LONG WINAPI DetourTransactionCommit();
LONG WINAPI DetourTransactionCommitEx(PVOID **pppFailedPointer);
LONG WINAPI DetourUpdateThread(HANDLE hThread);
LONG WINAPI DetourAttach(PVOID *ppPointer,
PVOID pDetour);
LONG WINAPI DetourAttachEx(PVOID *ppPointer,
PVOID pDetour,
PDETOUR_TRAMPOLINE *ppRealTrampoline,
PVOID *ppRealTarget,
PVOID *ppRealDetour);
LONG WINAPI DetourDetach(PVOID *ppPointer,
PVOID pDetour);
VOID WINAPI DetourSetIgnoreTooSmall(BOOL fIgnore);
////////////////////////////////////////////////////////////// Code Functions.
//
PVOID WINAPI DetourFindFunction(PCSTR pszModule, PCSTR pszFunction);
PVOID WINAPI DetourCodeFromPointer(PVOID pPointer, PVOID *ppGlobals);
PVOID WINAPI DetourCopyInstruction(PVOID pDst, PVOID pSrc, PVOID *ppTarget);
PVOID WINAPI DetourCopyInstructionEx(PVOID pDst,
PVOID pSrc,
PVOID *ppTarget,
LONG *plExtra);
///////////////////////////////////////////////////// Loaded Binary Functions.
//
HMODULE WINAPI DetourEnumerateModules(HMODULE hModuleLast);
PVOID WINAPI DetourGetEntryPoint(HMODULE hModule);
ULONG WINAPI DetourGetModuleSize(HMODULE hModule);
BOOL WINAPI DetourEnumerateExports(HMODULE hModule,
PVOID pContext,
PF_DETOUR_ENUMERATE_EXPORT_CALLBACK pfExport);
PVOID WINAPI DetourFindPayload(HMODULE hModule, REFGUID rguid, DWORD *pcbData);
DWORD WINAPI DetourGetSizeOfPayloads(HMODULE hModule);
///////////////////////////////////////////////// Persistent Binary Functions.
//
PDETOUR_BINARY WINAPI DetourBinaryOpen(HANDLE hFile);
PVOID WINAPI DetourBinaryEnumeratePayloads(PDETOUR_BINARY pBinary,
GUID *pGuid,
DWORD *pcbData,
DWORD *pnIterator);
PVOID WINAPI DetourBinaryFindPayload(PDETOUR_BINARY pBinary,
REFGUID rguid,
DWORD *pcbData);
PVOID WINAPI DetourBinarySetPayload(PDETOUR_BINARY pBinary,
REFGUID rguid,
PVOID pData,
DWORD cbData);
BOOL WINAPI DetourBinaryDeletePayload(PDETOUR_BINARY pBinary, REFGUID rguid);
BOOL WINAPI DetourBinaryPurgePayloads(PDETOUR_BINARY pBinary);
BOOL WINAPI DetourBinaryResetImports(PDETOUR_BINARY pBinary);
BOOL WINAPI DetourBinaryEditImports(PDETOUR_BINARY pBinary,
PVOID pContext,
PF_DETOUR_BINARY_BYWAY_CALLBACK pfByway,
PF_DETOUR_BINARY_FILE_CALLBACK pfFile,
PF_DETOUR_BINARY_SYMBOL_CALLBACK pfSymbol,
PF_DETOUR_BINARY_COMMIT_CALLBACK pfCommit);
BOOL WINAPI DetourBinaryWrite(PDETOUR_BINARY pBinary, HANDLE hFile);
BOOL WINAPI DetourBinaryClose(PDETOUR_BINARY pBinary);
/////////////////////////////////////////////////// Create Process & Load Dll.
//
typedef BOOL (WINAPI *PDETOUR_CREATE_PROCESS_ROUTINEA)
(LPCSTR lpApplicationName,
LPSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCSTR lpCurrentDirectory,
LPSTARTUPINFOA lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation);
typedef BOOL (WINAPI *PDETOUR_CREATE_PROCESS_ROUTINEW)
(LPCWSTR lpApplicationName,
LPWSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCWSTR lpCurrentDirectory,
LPSTARTUPINFOW lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation);
BOOL WINAPI DetourCreateProcessWithDllA(LPCSTR lpApplicationName,
__in_z LPSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCSTR lpCurrentDirectory,
LPSTARTUPINFOA lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation,
LPCSTR lpDetouredDllFullName,
LPCSTR lpDllName,
PDETOUR_CREATE_PROCESS_ROUTINEA
pfCreateProcessA);
BOOL WINAPI DetourCreateProcessWithDllW(LPCWSTR lpApplicationName,
__in_z LPWSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCWSTR lpCurrentDirectory,
LPSTARTUPINFOW lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation,
LPCSTR lpDetouredDllFullName,
LPCSTR lpDllName,
PDETOUR_CREATE_PROCESS_ROUTINEW
pfCreateProcessW);
#ifdef UNICODE
#define DetourCreateProcessWithDll DetourCreateProcessWithDllW
#define PDETOUR_CREATE_PROCESS_ROUTINE PDETOUR_CREATE_PROCESS_ROUTINEW
#else
#define DetourCreateProcessWithDll DetourCreateProcessWithDllA
#define PDETOUR_CREATE_PROCESS_ROUTINE PDETOUR_CREATE_PROCESS_ROUTINEA
#endif // !UNICODE
BOOL WINAPI DetourCopyPayloadToProcess(HANDLE hProcess,
REFGUID rguid,
PVOID pvData,
DWORD cbData);
BOOL WINAPI DetourRestoreAfterWith();
BOOL WINAPI DetourRestoreAfterWithEx(PVOID pvData, DWORD cbData);
HMODULE WINAPI DetourGetDetouredMarker();
//
//////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif // __cplusplus
//////////////////////////////////////////////// Detours Internal Definitions.
//
#ifdef __cplusplus
#ifdef DETOURS_INTERNAL
#ifndef __deref_out
#define __deref_out
#endif
#ifndef __deref
#define __deref
#endif
//////////////////////////////////////////////////////////////////////////////
//
#if (_MSC_VER < 1299)
#include <imagehlp.h>
// typedef IMAGEHLP_MODULE IMAGEHLP_MODULE64;
// typedef PIMAGEHLP_MODULE PIMAGEHLP_MODULE64;
// typedef IMAGEHLP_SYMBOL SYMBOL_INFO;
// typedef PIMAGEHLP_SYMBOL PSYMBOL_INFO;
// static inline
// LONG InterlockedCompareExchange(LONG *ptr, LONG nval, LONG oval)
// {
// return (LONG)::InterlockedCompareExchange((PVOID*)ptr, (PVOID)nval, (PVOID)oval);
// }
#else
#include <dbghelp.h>
#endif
#ifdef IMAGEAPI // defined by DBGHELP.H
typedef LPAPI_VERSION (NTAPI *PF_ImagehlpApiVersionEx)(LPAPI_VERSION AppVersion);
typedef BOOL (NTAPI *PF_SymInitialize)(IN HANDLE hProcess,
IN LPCSTR UserSearchPath,
IN BOOL fInvadeProcess);
typedef DWORD (NTAPI *PF_SymSetOptions)(IN DWORD SymOptions);
typedef DWORD (NTAPI *PF_SymGetOptions)(VOID);
typedef DWORD64 (NTAPI *PF_SymLoadModule64)(IN HANDLE hProcess,
IN HANDLE hFile,
IN PSTR ImageName,
IN PSTR ModuleName,
IN DWORD64 BaseOfDll,
IN DWORD SizeOfDll);
typedef BOOL (NTAPI *PF_SymGetModuleInfo64)(IN HANDLE hProcess,
IN DWORD64 qwAddr,
OUT PIMAGEHLP_MODULE64 ModuleInfo);
typedef BOOL (NTAPI *PF_SymFromName)(IN HANDLE hProcess,
IN LPSTR Name,
OUT PSYMBOL_INFO Symbol);
typedef struct _DETOUR_SYM_INFO
{
HANDLE hProcess;
HMODULE hDbgHelp;
PF_ImagehlpApiVersionEx pfImagehlpApiVersionEx;
PF_SymInitialize pfSymInitialize;
PF_SymSetOptions pfSymSetOptions;
PF_SymGetOptions pfSymGetOptions;
PF_SymLoadModule64 pfSymLoadModule64;
PF_SymGetModuleInfo64 pfSymGetModuleInfo64;
PF_SymFromName pfSymFromName;
} DETOUR_SYM_INFO, *PDETOUR_SYM_INFO;
PDETOUR_SYM_INFO DetourLoadDbgHelp(VOID);
#endif // IMAGEAPI
#ifndef DETOUR_TRACE
#if DETOUR_DEBUG
#define DETOUR_TRACE(x) printf x
#define DETOUR_BREAK() DebugBreak()
#include <stdio.h>
#include <limits.h>
#else
#define DETOUR_TRACE(x)
#define DETOUR_BREAK()
#endif
#endif
#ifdef DETOURS_IA64
__declspec(align(16)) struct DETOUR_IA64_BUNDLE
{
public:
union
{
BYTE data[16];
UINT64 wide[2];
};
public:
struct DETOUR_IA64_METADATA;
typedef BOOL (DETOUR_IA64_BUNDLE::* DETOUR_IA64_METACOPY)
(const DETOUR_IA64_METADATA *pMeta, DETOUR_IA64_BUNDLE *pDst) const;
enum {
A_UNIT = 1u,
I_UNIT = 2u,
M_UNIT = 3u,
B_UNIT = 4u,
F_UNIT = 5u,
L_UNIT = 6u,
X_UNIT = 7u,
UNIT_MASK = 7u,
STOP = 8u
};
struct DETOUR_IA64_METADATA
{
ULONG nTemplate : 8; // Instruction template.
ULONG nUnit0 : 4; // Unit for slot 0
ULONG nUnit1 : 4; // Unit for slot 1
ULONG nUnit2 : 4; // Unit for slot 2
DETOUR_IA64_METACOPY pfCopy; // Function pointer.
};
protected:
BOOL CopyBytes(const DETOUR_IA64_METADATA *pMeta, DETOUR_IA64_BUNDLE *pDst) const;
BOOL CopyBytesMMB(const DETOUR_IA64_METADATA *pMeta, DETOUR_IA64_BUNDLE *pDst) const;
BOOL CopyBytesMBB(const DETOUR_IA64_METADATA *pMeta, DETOUR_IA64_BUNDLE *pDst) const;
BOOL CopyBytesBBB(const DETOUR_IA64_METADATA *pMeta, DETOUR_IA64_BUNDLE *pDst) const;
BOOL CopyBytesMLX(const DETOUR_IA64_METADATA *pMeta, DETOUR_IA64_BUNDLE *pDst) const;
static const DETOUR_IA64_METADATA s_rceCopyTable[33];
public:
// 120 112 104 96 88 80 72 64 56 48 40 32 24 16 8 0
// f. e. d. c. b. a. 9. 8. 7. 6. 5. 4. 3. 2. 1. 0.
// 00
// f.e. d.c. b.a. 9.8. 7.6. 5.4. 3.2. 1.0.
// 0000 0000 0000 0000 0000 0000 0000 001f : Template [4..0]
// 0000 0000 0000 0000 0000 03ff ffff ffe0 : Zero [ 41.. 5]
// 0000 0000 0000 0000 0000 3c00 0000 0000 : Zero [ 45.. 42]
// 0000 0000 0007 ffff ffff c000 0000 0000 : One [ 82.. 46]
// 0000 0000 0078 0000 0000 0000 0000 0000 : One [ 86.. 83]
// 0fff ffff ff80 0000 0000 0000 0000 0000 : Two [123.. 87]
// f000 0000 0000 0000 0000 0000 0000 0000 : Two [127..124]
BYTE GetTemplate() const;
BYTE GetInst0() const;
BYTE GetInst1() const;
BYTE GetInst2() const;
BYTE GetUnit0() const;
BYTE GetUnit1() const;
BYTE GetUnit2() const;
UINT64 GetData0() const;
UINT64 GetData1() const;
UINT64 GetData2() const;
public:
BOOL IsBrl() const;
VOID SetBrl();
VOID SetBrl(UINT64 target);
UINT64 GetBrlTarget() const;
VOID SetBrlTarget(UINT64 target);
VOID SetBrlImm(UINT64 imm);
UINT64 GetBrlImm() const;
BOOL IsMovlGp() const;
UINT64 GetMovlGp() const;
VOID SetMovlGp(UINT64 gp);
VOID SetInst0(BYTE nInst);
VOID SetInst1(BYTE nInst);
VOID SetInst2(BYTE nInst);
VOID SetData0(UINT64 nData);
VOID SetData1(UINT64 nData);
VOID SetData2(UINT64 nData);
BOOL SetNop0();
BOOL SetNop1();
BOOL SetNop2();
BOOL SetStop();
BOOL Copy(DETOUR_IA64_BUNDLE *pDst) const;
};
#endif // DETOURS_IA64
//////////////////////////////////////////////////////////////////////////////
#endif // DETOURS_INTERNAL
#endif // __cplusplus
#endif // _DETOURS_H_
//
//////////////////////////////////////////////////////////////// End of File.
| [
"pandashellcode@163.com"
] | pandashellcode@163.com |
f16486829de1c6bbfb2a2245a0797184aa035686 | 8f6d9010a0752bfd9b313c9abba298794eb009f9 | /counter.h | 8db6d22b133e3f9c082c40ae849c8f7621cb7043 | [] | no_license | RaymiiOrg/qml_cpp_signal_example | 47c822fe0f7f9e706eb99633833078fb57e2f6c6 | a2efbf8c3c41e3cf658b0411f429294e0d6d87d1 | refs/heads/master | 2023-03-08T20:27:55.811366 | 2021-02-25T15:31:31 | 2021-02-25T15:31:31 | 342,276,949 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 447 | h | #ifndef COUNTER_H
#define COUNTER_H
#include <QObject>
class Counter : public QObject
{
Q_OBJECT
Q_PROPERTY(long long value READ value WRITE setValue NOTIFY valueChanged)
public:
explicit Counter(QObject *parent = nullptr);
long long value() { return m_Value; };
public slots:
void setValue(long long value);
signals:
void valueChanged(long long newValue);
private:
long long m_Value {0} ;
};
#endif // COUNTER_H
| [
"vanelst@dejongduke.nl"
] | vanelst@dejongduke.nl |
4242bfac3feda7b22b7a828d46e6b535352b7d2d | 98a81ccec5c523c1a6d4d23af2cc3d25d03961e5 | /common_types/src/frac.h | 60e6c8b2a3cc65e87c5ddf0b88f6222ae6178f82 | [] | no_license | bs-eagle/bs-eagle | 1af7b4c788f6f6aa9ffe094ac1a7d72a6efe4bdc | b1017a4f6ac2dcafba2deafec84052ddde792671 | refs/heads/master | 2021-01-18T21:48:44.426068 | 2016-06-06T13:13:09 | 2016-06-06T13:13:09 | 1,061,323 | 9 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 1,442 | h | /**
* @file frac.h
* @brief implementation of frac storage
* @author Oleg Borschuk
* @version
* @date 2011-07-29
*/
#ifndef FRAC_YSG17OI0
#define FRAC_YSG17OI0
#include <string>
#include <sstream>
#include <vector>
#include <fstream>
#include "frac_iface.h"
namespace blue_sky
{
class BS_API_PLUGIN frac : public frac_iface
{
public:
typedef BS_SP (prop_iface) sp_prop_t;
// ------------------------------------
// METHODS
// ------------------------------------
public:
// destructor
virtual ~frac ()
{}
// ------------------------------------
// INTERFACE METHODS
// ------------------------------------
/**
* @brief return SP to the property
*/
virtual sp_prop_t get_prop ()
{
return sp_prop;
}
public:
#ifdef BSPY_EXPORTING_PLUGIN
/**
* @brief python print wrapper
*
* @return return table description
*/
virtual std::string py_str () const;
#endif //BSPY_EXPORTING_PLUGIN
protected:
void init_prop ();
// ------------------------------
// VARIABLES
// ------------------------------
protected:
sp_prop_t sp_prop; //!< ptoperties pointer
BLUE_SKY_TYPE_DECL (frac);
};
}; //end of blue_sky namespace
#endif /* end of include guard: FRAC_YSG17OI0 */
| [
"oleg.borschuk@gmail.com"
] | oleg.borschuk@gmail.com |
ae5534627733759679387836744712e505e6cb31 | d63e34900e26f3c1ff79292d6dce8ebec067e370 | /src/Boid3d.cpp | 94478434752db6a20a5b410621e435e1cf100769 | [] | no_license | Marshmallow-Laser-Feast/tmt | df9f6f189be20995bea27a72e0dea8912f3bc221 | 7e3083b8548cfa964b8b2c12f6defbeb8438cbcf | refs/heads/master | 2016-09-03T06:33:26.460227 | 2013-06-13T17:19:26 | 2013-06-13T21:39:04 | 10,461,125 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,923 | cpp | /*
* Boid3d.cpp
* flockHelloBoidsAttr
*
* Created by andré sier on 20130225.
* Copyright 2013 __MyCompanyName__. All rights reserved.
*
*/
#include "Boid3d.h"
#include "Flock3d.h"
Boid3d::Boid3d(Flock3d * flock) {
Boid3d();
this->flockPtr = flock;
}
Boid3d * Boid3d::setFlock(Flock3d * flock) {
this->flockPtr = flock;
return this;
}
void Boid3d::bounds() {
switch (flockPtr->boundmode) {
case 0: // CLAMP
if (x < flockPtr->minX) {
x = flockPtr->minX;
vx = -vx;
}
if (x > flockPtr->maxX) {
x = flockPtr->maxX;
vx = -vx;
}
if (y < flockPtr->minY) {
y = flockPtr->minY;
vy = -vy;
}
if (y > flockPtr->maxY) {
y = flockPtr->maxY;
vy = -vy;
}
if (z < flockPtr->minZ) {
z = flockPtr->minZ;
vz = -vz;
}
if (z > flockPtr->maxZ) {
z = flockPtr->maxZ;
vz = -vz;
}
break;
case 1: // WRAP
if (x < flockPtr->minX) {
x += flockPtr->boundsWidth;
}
if (x > flockPtr->maxX) {
x -= flockPtr->boundsWidth;
}
if (y < flockPtr->minY) {
y += flockPtr->boundsHeight;
}
if (y > flockPtr->maxY) {
y -= flockPtr->boundsHeight;
}
if (z < flockPtr->minZ) {
z += flockPtr->boundsDepth;
}
if (z > flockPtr->maxZ) {
z -= flockPtr->boundsDepth;
}
break;
}
}
void Boid3d:: update(const float amount) {
// float vec[] = flock(amount);// flockfull(amount);
//float * vec = flockfull(amount);
// reset acc on begin 2 draw
ax = 0;
ay = 0;
az = 0;
float *vec = new float[3];
vec[0] = 0.0f;
vec[1] = 0.0f;
vec[2] = 0.0f;
// flock(amount, vec);
flockfull(amount, vec);
ax += vec[0];// *amount;
ay += vec[1];// *amount;
az += vec[2];
delete [] vec;
// change this to allow flock flock interaction
// accX = vec[0];
// accY = vec[1];
// limit force
float distMaxForce = ABS(ax) + ABS(ay) + ABS(az);
if (distMaxForce > flockPtr->maxForce) {
distMaxForce = flockPtr->maxForce / distMaxForce;
ax *= distMaxForce;
ay *= distMaxForce;
az *= distMaxForce;
}
vx += ax;
vy += ay;
vz += az;
// limit speed
float distMaxSpeed = ABS(vx) + ABS(vy) + ABS(vz);
if (distMaxSpeed > flockPtr->maxSpeed) {
distMaxSpeed = flockPtr->maxSpeed / distMaxSpeed;
vx *= distMaxSpeed;
vy *= distMaxSpeed;
vz *= distMaxSpeed;
}
x += vx * amount;
y += vy * amount;
z += vz * amount;
bounds();
// // reset acc on end
// ax = 0;
// ay = 0;
// az = 0;
}
float* Boid3d::steer(float* target, float amount){ //, float *steervec) {
// float steer[] = {0.f, 0.f}; //new float[2];
//float *dir =new float[2];
float dir[3] = {0.f,0.f,0.f};
// dir[0] = 0.0f;
// dir[1] = 0.0f;
dir[0] = target[0] - x;
dir[1] = target[1] - y;
dir[2] = target[1] - z;
float d = ABS(dir[0]) + ABS(dir[1]) + ABS(dir[2]);
if (d > 2) {
float invDist = 1.f / d;
dir[0] *= invDist;
dir[1] *= invDist;
dir[2] *= invDist;
// steer, desired - vel
target[0] = dir[0] - vx;
target[1] = dir[1] - vy;
target[2] = dir[2] - vz;
float steerLen = ABS(target[0]) + ABS(target[1]) + ABS(target[2]);
if (steerLen > 0) {
float invSteerLen = amount / steerLen;// 1f / steerLen;
target[0] *= invSteerLen;
target[1] *= invSteerLen;
target[2] *= invSteerLen;
}
}
// delete [] dir;
return target;
}
//float* Boid3d::cohesion(vector<Boid3d*>* b, float *vec) {
float* Boid3d::cohesion( float *vec) {
float cohesiondist = flockPtr->distCohesion;
// float vec[] = {0.f, 0.f};//new float[2];
int count = 0;
for (int i = 0; i < flockPtr->boids.size(); i++) {
Boid3d * other = flockPtr->boids.at(i);
float dx = other->x - x;
float dy = other->y - y;
float dz = other->z - z;
float d = ABS(dx) + ABS(dy)+ ABS(dz);
if (d > 0 && d < cohesiondist) {
count++;
vec[0] += other->x;// dx;
vec[1] += other->y;// dy;
vec[2] += other->z;// dy;
}
}
if (count > 0) {
float invCount = 1.f / count;
vec[0] *= invCount;
vec[1] *= invCount;
vec[2] *= invCount;
steer(vec, 1);
}
return vec;
}
float* Boid3d::align( float *vec) {
float aligndist = flockPtr->distAlign;
// float vec[] = {0.f, 0.f};//new float[2];
int count = 0;
for (int i = 0; i < flockPtr->boids.size(); i++) {
Boid3d * other = flockPtr->boids.at(i);
float dx = other->x - x;
float dy = other->y - y;
float dz = other->z - z;
float d = ABS(dx) + ABS(dy)+ ABS(dz);
if (d > 0 && d < aligndist) {
count++;
vec[0] += other->vx;// dx;
vec[1] += other->vy;// dy;
vec[2] += other->vz;// dy;
}
}
if (count > 0) {
float invCount = 1.f / count;
vec[0] *= invCount;
vec[1] *= invCount;
vec[2] *= invCount;
}
return vec;
}
float* Boid3d::separate(float *vec) {
float separatedist = flockPtr->distSeparation;
// float vec[] = {0.f, 0.f}; //new float[2];
int count = 0;
for (int i = 0; i < flockPtr->boids.size(); i++) {
Boid3d * other = flockPtr->boids.at(i);
float dx = other->x - x;
float dy = other->y - y;
float dz = other->z - z;
float d = ABS(dx) + ABS(dy)+ ABS(dz);
if (d > 0 && d < flockPtr->distAlign) {
count++;
// / mais longe influenciam mais?
// vec[0] += -dx;
// vec[1] += -dy;
float invD = 1.f / d;
vec[0] += -dx * invD;
vec[1] += -dy * invD;
vec[2] += -dz * invD;
}
}
if (count > 0) {
float invCount = 1.f / count;
vec[0] *= invCount;
vec[1] *= invCount;
vec[2] *= invCount;
}
return vec;
}
float* Boid3d::flock(const float amount, float *vec) {
// float * vec = new float[2];
float *sep = new float[3];
float *ali = new float[3];
float *coh = new float[3];
sep[0] = 0.0f;
sep[1] = 0.0f;
sep[2] = 0.0f;
ali[0] = 0.0f;
ali[1] = 0.0f;
ali[2] = 0.0f;
coh[0] = 0.0f;
coh[1] = 0.0f;
coh[2] = 0.0f;
separate(sep);
align( ali);
cohesion( coh);
// System.out.print("boid flock sep " + sep[0] + " " + sep[1] + " "
// + flock.forceSeparate + "\n");
sep[0] *= flockPtr->separate;
sep[1] *= flockPtr->separate;
sep[2] *= flockPtr->separate;
ali[0] *= flockPtr->align;
ali[1] *= flockPtr->align;
ali[2] *= flockPtr->align;
coh[0] *= flockPtr->cohesion;
coh[1] *= flockPtr->cohesion;
coh[2] *= flockPtr->cohesion;
vec[0] = sep[0] + ali[0] + coh[0];
vec[1] = sep[1] + ali[1] + coh[1];
vec[2] = sep[2] + ali[2] + coh[2];
float d =ABS(vec[0]) + ABS(vec[1]) + ABS(vec[2]);
float invDist = 1.f;
if (d > 0)
invDist = amount / d;// 1f / d;
vec[0] *= invDist;
vec[1] *= invDist;
vec[2] *= invDist;
delete[] sep;
delete[] ali;
delete[] coh;
return vec;
}
float* Boid3d::flockfull(const float amount, float *vec) {
// float * vec = new float[2];
float *sep = new float[3];
float *ali = new float[3];
float *coh = new float[3];
float *attrForce = new float[3];
sep[0] = 0.0f;
sep[1] = 0.0f;
sep[2] = 0.0f;
ali[0] = 0.0f;
ali[1] = 0.0f;
ali[2] = 0.0f;
coh[0] = 0.0f;
coh[1] = 0.0f;
coh[2] = 0.0f;
attrForce[0] = 0.0f;
attrForce[1] = 0.0f;
attrForce[2] = 0.0f;
// float attrForce[] = {0.f, 0.f}; //new float[2];
int countsep = 0, countali = 0, countcoh = 0;
float separatedist = flockPtr->distSeparation;
float aligndist = flockPtr->distAlign;
float cohesiondist = flockPtr->distCohesion;
float invD = 0;
// boolean hasAttractionPoints = flock.hasAttractionPoints();
// main full loop track all forces boid other boids
for (int i = 0; i < flockPtr->boids.size(); i++) {
Boid3d * other = flockPtr->boids.at(i);
float dx = other->x - x;
float dy = other->y - y;
float dz = other->z - z;
float d = ABS(dx) + ABS(dy)+ ABS(dz);
if (d <= 1e-7)
continue;
// sep
if (d < separatedist) {
countsep++;
invD = 1.f / d;
sep[0] -= dx * invD;
sep[1] -= dy * invD;
sep[2] -= dz * invD;
}
// coh
if (d < cohesiondist) {
countcoh++;
coh[0] += other->x;
coh[1] += other->y;
coh[2] += other->z;
}
// ali
if (d < aligndist) {
countali++;
ali[0] += other->vx;
ali[1] += other->vy;
ali[2] += other->vz;
}
}
if (countsep > 0) {
const float invForSep = flockPtr->separate / (float) countsep;
sep[0] *= invForSep;
sep[1] *= invForSep;
sep[2] *= invForSep;
}
if (countali > 0) {
// final float invForAli = 1f / (float) countali;
const float invForAli = flockPtr->align / (float) countali;
ali[0] *= invForAli;
ali[1] *= invForAli;
ali[2] *= invForAli;
}
if (countcoh > 0) {
const float invForCoh = flockPtr->cohesion / (float) countcoh;
coh[0] *= invForCoh;
coh[1] *= invForCoh;
coh[2] *= invForCoh;
coh = steer(coh, 1);
}
// if using extra forces, place here
// sep[0] *= flock.separate;
// sep[1] *= flock.separate;
//
// ali[0] *= flock.align;
// ali[1] *= flock.align;
//
// coh[0] *= flock.cohesion;
// coh[1] *= flock.cohesion;
// other forces
if (flockPtr->hasAttractionPoints()) {
for (int i = 0; i < flockPtr->attractionPoints.size(); i++) {
AttractionPoint3d * point = flockPtr->attractionPoints.at(i);
float dx = point->x - x;
float dy = point->y - y;
float dz = point->z - z;
float d = ABS(dx) + ABS(dy)+ ABS(dz);
if (d <= 1e-7)
continue;
if (d > point->sensorDist)
continue;
// inbounds, calc
float invForce = point->force / d * attr;// newww ////flockPtr->attraction ; // neww
dx *= invForce;
dy *= invForce;
dz *= invForce;
attrForce[0] += dx;
attrForce[1] += dy;
attrForce[2] += dz;
}
}
vec[0] = sep[0] + ali[0] + coh[0] + attrForce[0];
vec[1] = sep[1] + ali[1] + coh[1] + attrForce[1];
vec[2] = sep[2] + ali[2] + coh[2] + attrForce[2];
const float d = ABS(vec[0]) + ABS(vec[1]) + ABS(vec[2]);
if (d > 0) {
float invDist = amount / d;
vec[0] *= invDist;
vec[1] *= invDist;
vec[2] *= invDist;
}
vec[0] *= amount;
vec[1] *= amount;
vec[2] *= amount;
delete[] sep;
delete[] ali;
delete[] coh;
delete[] attrForce;
return vec;
}
| [
"ali.nakipoglu@fiction.io"
] | ali.nakipoglu@fiction.io |
d1a5a6a3983bda8b07fd29c0878eeef472defd78 | cc5390e0e818f2a8e8e3d9d733757f53f17b359a | /src/model/parser/parser.hpp | 8aea9ff8f31dc42dd95231f4910f33bf7e76d25c | [] | no_license | AaronZLT/CL-EDEN-kernel | 53319cc470fe232e8366cc6773eca141f7d4618b | 2cacf94046cb8920a677ceb3bc30eb1eb6f86bdf | refs/heads/main | 2023-07-14T06:25:18.727255 | 2021-08-27T05:14:01 | 2021-08-27T05:14:01 | 400,395,663 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 953 | hpp | #ifndef SRC_MODEL_PARSER_PARSER_HPP_
#define SRC_MODEL_PARSER_PARSER_HPP_
#include "model/raw/model.hpp"
namespace enn {
namespace model {
class Parser {
public:
// Convert given input model to RawModel and then store in Impl
explicit Parser();
virtual ~Parser();
Parser(Parser&&) = delete;
Parser& operator=(Parser&&) = delete;
Parser(const Parser&) = delete;
Parser& operator=(const Parser&) = delete;
// ModelManager using Parser should let it know ModelType.
// Because ModelManager should know type of each model opened for caching.
void Set(const ModelType& model_type, const std::shared_ptr<ModelMemInfo> model,
const std::shared_ptr<std::vector<std::shared_ptr<enn::model::ModelMemInfo>>> params);
std::shared_ptr<raw::Model> Parse();
private:
class Impl;
std::unique_ptr<Impl> impl_;
};
}; // namespace model
}; // namespace enn
#endif // SRC_MODEL_PARSER_PARSER_HPP_
| [
"35474496+AaronZLT@users.noreply.github.com"
] | 35474496+AaronZLT@users.noreply.github.com |
4cb10ac2a4257bb23b3a1862bc1912e4c132ed9b | 14196d7fcc3784a9172caffdc2309eb03940ae83 | /ProjetSession/ProjetSession/CJoueur.cpp | 6e9fb2cd171d00fd5817892a6d6bd29fe08c1a38 | [] | no_license | marinemezin/LabyrintheAleatoire | 7811d3ce981fa2ff3b180a125a1955d635e69b3b | 49852368a3f05b2ce649df220c397b3aa67ab659 | refs/heads/master | 2021-08-28T09:37:38.873605 | 2017-12-11T21:39:17 | 2017-12-11T21:39:17 | 111,619,070 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 554 | cpp | #include "CJoueur.h"
CJoueur::CJoueur(int ligdep, int coldep) {
ligne = ligdep;
colonne = coldep;
score = 0;
}
CJoueur::~CJoueur() {
}
int CJoueur::GetLigne() {
return ligne;
}
int CJoueur::GetColonne() {
return colonne;
}
int CJoueur::GetScore() {
return score;
}
void CJoueur::SetScore(int value) {
if (value > 0) {
score += value;
}
}
void CJoueur::SetLigne(int value) {
ligne = value;
}
void CJoueur::SetColonne(int value) {
colonne = value;
}
void CJoueur::Deplacement(int lig, int col) {
ligne = lig;
colonne = col;
} | [
"mezin.marine@gmail.com"
] | mezin.marine@gmail.com |
d00d54a830dfcc27d5051230f99b3f07532a9bb6 | 7bb4f7daa8466c257101b2222e260556c8d6874a | /List/数值的整数次方2.cpp | 0598e77f4544f7a3fca8790428ef2dfda261f03d | [] | no_license | sirlancer/Algorithm | 794e8914398717962f403bbcb8df88e75ce16a84 | 987137252e718367f991830d8cd2121947c1c9a3 | refs/heads/master | 2020-03-17T04:51:21.871287 | 2018-06-29T07:17:15 | 2018-06-29T07:17:15 | 133,291,402 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 845 | cpp | class Solution {
public:
double Power(double base, int exponent) {
if(base==0.0 && exponent < 0){
return 0.0;
}
unsigned int absExponent = (unsigned int)exponent;
if(exponent < 0){
absExponent = (unsigned int)(-exponent);
}
int res = PowerWithUnsignedExponent(base, absExponent);
if(exponent < 0){
return 1.0/res;
}
return res;
}
double PowerWithUnsignedExponent(double base, unsigned int exponent){
if(exponent == 0){
return 1.0;
}
if(exponent == 1){
return base;
}
double res = PowerWithUnsignedExponent(base, exponent >> 1);
res *= res;
if(exponent & 0x1 ==1){
res *= base;
}
return res;
}
}; | [
"920365914@qq.com"
] | 920365914@qq.com |
c514963da5d1729eba9f75b030a032b6d4fafe3a | a80f3148cbfa2ab722a395aec4313d3cfe960d35 | /lidar_test/lidar_test.ino | dc260ad51797df5f1817d615d8e66dd884ae695d | [] | no_license | HrushikeshBudhale/Robocon2018 | eccc95804b99e0eabb93a4c816e61694f0324720 | 0b17d91dd1d9185c9ab9b0d0d72caec8283893c2 | refs/heads/master | 2023-07-16T23:40:13.927921 | 2018-03-14T18:55:03 | 2018-03-14T18:55:03 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,334 | ino | /*
Button
Turns on and off a light emitting diode(LED) connected to digital pin 13,
when pressing a pushbutton attached to pin 2.
The circuit:
- LED attached from pin 13 to ground
- pushbutton attached to pin 2 from +5V
- 10K resistor attached to pin 2 from ground
- Note: on most Arduinos there is already an LED on the board
attached to pin 13.
created 2005
by DojoDave <http://www.0j0.org>
modified 30 Aug 2011
by Tom Igoe
This example code is in the public domain.
http://www.arduino.cc/en/Tutorial/Button
*/
// constants won't change. They're used here to set pin numbers:
const int buttonPin = 53; // the number of the pushbutton pin
const int ledPin = 13; // the number of the LED pin
// variables will change:
int buttonState = 0; // variable for reading the pushbutton status
void setup() {
// initialize the LED pin as an output:
pinMode(ledPin, OUTPUT);
// initialize the pushbutton pin as an input:
pinMode(buttonPin, INPUT);
}
void loop() {
// read the state of the pushbutton value:
buttonState = digitalRead(buttonPin);
// check if the pushbutton is pressed. If it is, the buttonState is HIGH:
if (buttonState == HIGH) {
// turn LED on:
digitalWrite(ledPin, HIGH);
} else {
// turn LED off:
digitalWrite(ledPin, LOW);
}
}
| [
"hruhnb@gmail.com"
] | hruhnb@gmail.com |
cfa2e055c7f65d24f9989a47a4752f9f91c2091f | d24eae32bb90915c8ef3d07e74e22144581eb589 | /TextRain/src/Particle.cpp | 0567690ef075817d32c0a7a92b13bb593cf2c83d | [
"MIT"
] | permissive | fishkingsin/DanceViva | 37f240ef89f43ae46a50102593d72b5ef0fafb6b | 5596ad112b663d17231825b145b6588ad9695c90 | refs/heads/master | 2016-09-05T09:39:44.014276 | 2014-07-04T04:38:07 | 2014-07-04T04:38:07 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,405 | cpp | //
// Particle.cpp
// TextRain
//
// Created by Kong king sin on 19/6/14.
//
//
#include "Particle.h"
void Particle:: setup(ofxTrueTypeFontUC *_type , string _theCharacter) {
angle = ofRandomf()*TWO_PI;
age = 0;
// alpha = 0;
mass = ofRandom(1,2.5);
type = _type;
theCharacter = _theCharacter;
damp = 0.98;
acc.set(ofRandom(0,1),0,0);
}
void Particle::draw() {
ofPushMatrix();
ofPushStyle();
ofSetColor(255,255,255,255*((100.0f-age)/100.0f));
ofTranslate(pos.x,pos.y);
float scale = ofMap(age, 0, 50, 0, 1);
ofScale(scale, scale);
if(type)type->drawString(theCharacter, 0, 0);
ofPopStyle();
ofPopMatrix();
}
//void Particle::update() {
// float t = (ofGetElapsedTimef()) * 0.9;
// float div = 250.0;
// float cur = ofGetElapsedTimef();
// float noiseStrength = 0.7;
//
// ofVec3f vec(
// ofSignedNoise(t, pos.y/div,pos.z/div)*noiseStrength,
// ofSignedNoise(pos.x/div, t, pos.z/div)*noiseStrength,
// ofSignedNoise(pos.x/div, t, pos.y/div)*noiseStrength);
//// angle += ofSignedNoise(vel.x, vel.y)*TWO_PI;
// if(vel.x>10)
// {
// vec *= vel ;
// }
// else
// {
//
// vec *= 5;
// }
//// vel.rotate(angle,ofVec3f(0,0,1));
// oldpos = pos;
// vel*=damp;
// pos += vel+vec;
// if(age<MAX_AGE)age++;
//}
| [
"fishkingsin@gmail.com"
] | fishkingsin@gmail.com |
b4c4631e33ef6c589a560248efc85c18f18311f3 | 919de4fd0acce359057e98a1c79f2dca71cbdb55 | /snowman.cpp | 2f53f1045cb861e2f53902190d67679554edd717 | [
"MIT"
] | permissive | GiladMoalem/snowman | b4a5dda053474fc330d423caa4e7a29a90f4483d | e85c1a8b3cd800bed47314d6fc8c36d2c665d464 | refs/heads/master | 2023-05-24T06:21:48.708346 | 2021-06-14T12:35:24 | 2021-06-14T12:35:24 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,444 | cpp | #include <iostream>
#include <string>
using namespace std;
namespace ariel{
string hat(int H){
switch(H){
case 1:
return " _===_";
case 2:
return " ___ \n.....";
case 3:
return " _ \n /_\\ ";
case 4:
return " ___ \n(_*_)";
default:
return "error";
}
}
string highBody(int X, int L, int N, int R, int Y){
string result="";
switch(X){
case 1:
result += " ";
break;
case 2:
result += "\\";
break;
case 3:
result += " ";
break;
case 4:
result += " ";
break;
default:
return "error!";
}
result+="(";
switch(L){
case 1:
result += ".";
break;
case 2:
result += "o";
break;
case 3:
result += "O";
break;
case 4:
result += "-";
break;
default:
return "error!";
}
switch(N){
case 1:
result +=",";
break;
case 2:
result += ".";
break;
case 3:
result += "_";
break;
case 4:
break;
default:
return "error!";
}
switch(R){
case 1:
result += ".";
break;
case 2:
result += "o";
break;
case 3:
result += "O";
break;
case 4:
result +="-";
break;
default:
return "error";
}
result+=")";
switch(Y){
case 1:
result += " ";
break;
case 2:
result +="/";
break;
case 3:
result += " ";
break;
case 4:
result +=" ";
break;
default:
return "error!";
}
return result;
}
string lowBody(int X,int T, int Y){
string result="";
switch(X){
case 1:
result+="<";
break;
case 2:
result +=" ";
break;
case 3:
result +="/";
break;
case 4:
result +=" ";
break;
default:
return "error";
}
result +="(";
switch(T){
case 1:
result +=" : ";
break;
case 2:
result +="] [";
break;
case 3:
result += "> <";
break;
case 4:
result +=" ";
break;
default:
return "error";
}
result +=")";
switch(Y){
case 1:
result +=">";
break;
case 2:
result += " ";
break;
case 3:
result +="\\";
break;
case 4:
result += " ";
break;
default:
return "error";
}
return result;
}
string base(int B){
switch(B){
case 1:
return " ( : ) ";
case 2:
return {' ', '(', '"', ' ', '"', ')', ' ', '\0'};
case 3:
return " (___) ";
case 4:
return " ( ) ";
default:
throw "error";
}
}
string snowman(int num){
if(num <11111111 || num > 44444444) throw "error";
int arr[8];
int i;
for(i=0;i<8;i++){
arr[i] = num%10;
num /= 10;
if(arr[i]<1 || arr[i]>4) throw "error";
}
string result ="";
result += hat(arr[7]);
result += "\n";
result += highBody(arr[3],arr[5],arr[6],arr[4],arr[2]);
result += "\n";
result += lowBody(arr[3],arr[1],arr[2]);
result += "\n";
result += base(arr[0]);
result += "\n";
return result;
}
} | [
"giladmoa@gmail.com"
] | giladmoa@gmail.com |
3de72e290463729bc624cdd6c74a694280f89c25 | d53a7501ff6c972f03d4f248d21e3242a24a9156 | /test/bug2102138c.ei.re | fbab5542178bf91d6951341b12d2bc5bfb997cb8 | [
"LicenseRef-scancode-warranty-disclaimer",
"LicenseRef-scancode-public-domain"
] | permissive | olabini/re2j | 5648fb965efdbd35b5da6ba3addec1405a7e644d | 7f96f559b2a9ba20fd9c23e03ec84f2d9d550feb | refs/heads/master | 2021-01-22T13:42:15.535650 | 2009-07-23T13:28:23 | 2009-07-23T13:28:23 | 256,962 | 4 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,625 | re | #include <stdio.h>
int scan(const unsigned char *cr)
{
unsigned char ch;
/*!re2j
re2j:define:YYCTYPE = "unsigned char";
re2j:define:YYCURSOR = cr;
re2j:define:YYFILL = fill;
re2j:variable:yych = ch;
re2j:yyfill:enable = 0;
"\x00" := return 0x00;
"\x01" := return 0x01;
"\x02" := return 0x02;
"\x03" := return 0x03;
"\x04" := return 0x04;
"\x05" := return 0x05;
"\x06" := return 0x06;
"\a" := return 0x07;
"\b" := return 0x08;
"\t" := return 0x09;
"\n" := return 0x0A;
"\v" := return 0x0B;
"\f" := return 0x0C;
"\r" := return 0x0D;
"\x0E" := return 0x0E;
"\x0F" := return 0x0F;
"\x10" := return 0x10;
"\x11" := return 0x11;
"\x12" := return 0x12;
"\x13" := return 0x13;
"\x14" := return 0x14;
"\x15" := return 0x15;
"\x16" := return 0x16;
"\x17" := return 0x17;
"\x18" := return 0x18;
"\x19" := return 0x19;
"\x1A" := return 0x1A;
"\x1B" := return 0x1B;
"\x1C" := return 0x1C;
"\x1D" := return 0x1D;
"\x1E" := return 0x1E;
"\x1F" := return 0x1F;
"\x20" := return 0x20;
"\x21" := return 0x21;
"\x22" := return 0x22;
"\x23" := return 0x23;
"\x24" := return 0x24;
"\x25" := return 0x25;
"\x26" := return 0x26;
"\x27" := return 0x27;
"\x28" := return 0x28;
"\x29" := return 0x29;
"\x2A" := return 0x2A;
"\x2B" := return 0x2B;
"\x2C" := return 0x2C;
"\x2D" := return 0x2D;
"\x2E" := return 0x2E;
"\x2F" := return 0x2F;
"\x30" := return 0x30;
"\x31" := return 0x31;
"\x32" := return 0x32;
"\x33" := return 0x33;
"\x34" := return 0x34;
"\x35" := return 0x35;
"\x36" := return 0x36;
"\x37" := return 0x37;
"\x38" := return 0x38;
"\x39" := return 0x39;
"\x3A" := return 0x3A;
"\x3B" := return 0x3B;
"\x3C" := return 0x3C;
"\x3D" := return 0x3D;
"\x3E" := return 0x3E;
"\x3F" := return 0x3F;
"\x40" := return 0x40;
"\x41" := return 0x41;
"\x42" := return 0x42;
"\x43" := return 0x43;
"\x44" := return 0x44;
"\x45" := return 0x45;
"\x46" := return 0x46;
"\x47" := return 0x47;
"\x48" := return 0x48;
"\x49" := return 0x49;
"\x4A" := return 0x4A;
"\x4B" := return 0x4B;
"\x4C" := return 0x4C;
"\x4D" := return 0x4D;
"\x4E" := return 0x4E;
"\x4F" := return 0x4F;
"\x50" := return 0x50;
"\x51" := return 0x51;
"\x52" := return 0x52;
"\x53" := return 0x53;
"\x54" := return 0x54;
"\x55" := return 0x55;
"\x56" := return 0x56;
"\x57" := return 0x57;
"\x58" := return 0x58;
"\x59" := return 0x59;
"\x5A" := return 0x5A;
"\x5B" := return 0x5B;
"\x5C" := return 0x5C;
"\x5D" := return 0x5D;
"\x5E" := return 0x5E;
"\x5F" := return 0x5F;
"\x60" := return 0x60;
"\x61" := return 0x61;
"\x62" := return 0x62;
"\x63" := return 0x63;
"\x64" := return 0x64;
"\x65" := return 0x65;
"\x66" := return 0x66;
"\x67" := return 0x67;
"\x68" := return 0x68;
"\x69" := return 0x69;
"\x6A" := return 0x6A;
"\x6B" := return 0x6B;
"\x6C" := return 0x6C;
"\x6D" := return 0x6D;
"\x6E" := return 0x6E;
"\x6F" := return 0x6F;
"\x70" := return 0x70;
"\x71" := return 0x71;
"\x72" := return 0x72;
"\x73" := return 0x73;
"\x74" := return 0x74;
"\x75" := return 0x75;
"\x76" := return 0x76;
"\x77" := return 0x77;
"\x78" := return 0x78;
"\x79" := return 0x79;
"\x7A" := return 0x7A;
"\x7B" := return 0x7B;
"\x7C" := return 0x7C;
"\x7D" := return 0x7D;
"\x7E" := return 0x7E;
"\x7F" := return 0x7F;
"\x80" := return 0x80;
"\x81" := return 0x81;
"\x82" := return 0x82;
"\x83" := return 0x83;
"\x84" := return 0x84;
"\x85" := return 0x85;
"\x86" := return 0x86;
"\x87" := return 0x87;
"\x88" := return 0x88;
"\x89" := return 0x89;
"\x8A" := return 0x8A;
"\x8B" := return 0x8B;
"\x8C" := return 0x8C;
"\x8D" := return 0x8D;
"\x8E" := return 0x8E;
"\x8F" := return 0x8F;
"\x90" := return 0x90;
"\x91" := return 0x91;
"\x92" := return 0x92;
"\x93" := return 0x93;
"\x94" := return 0x94;
"\x95" := return 0x95;
"\x96" := return 0x96;
"\x97" := return 0x97;
"\x98" := return 0x98;
"\x99" := return 0x99;
"\x9A" := return 0x9A;
"\x9B" := return 0x9B;
"\x9C" := return 0x9C;
"\x9D" := return 0x9D;
"\x9E" := return 0x9E;
"\x9F" := return 0x9F;
"\xA0" := return 0xA0;
"\xA1" := return 0xA1;
"\xA2" := return 0xA2;
"\xA3" := return 0xA3;
"\xA4" := return 0xA4;
"\xA5" := return 0xA5;
"\xA6" := return 0xA6;
"\xA7" := return 0xA7;
"\xA8" := return 0xA8;
"\xA9" := return 0xA9;
"\xAA" := return 0xAA;
"\xAB" := return 0xAB;
"\xAC" := return 0xAC;
"\xAD" := return 0xAD;
"\xAE" := return 0xAE;
"\xAF" := return 0xAF;
"\xB0" := return 0xB0;
"\xB1" := return 0xB1;
"\xB2" := return 0xB2;
"\xB3" := return 0xB3;
"\xB4" := return 0xB4;
"\xB5" := return 0xB5;
"\xB6" := return 0xB6;
"\xB7" := return 0xB7;
"\xB8" := return 0xB8;
"\xB9" := return 0xB9;
"\xBA" := return 0xBA;
"\xBB" := return 0xBB;
"\xBC" := return 0xBC;
"\xBD" := return 0xBD;
"\xBE" := return 0xBE;
"\xBF" := return 0xBF;
"\xC0" := return 0xC0;
"\xC1" := return 0xC1;
"\xC2" := return 0xC2;
"\xC3" := return 0xC3;
"\xC4" := return 0xC4;
"\xC5" := return 0xC5;
"\xC6" := return 0xC6;
"\xC7" := return 0xC7;
"\xC8" := return 0xC8;
"\xC9" := return 0xC9;
"\xCA" := return 0xCA;
"\xCB" := return 0xCB;
"\xCC" := return 0xCC;
"\xCD" := return 0xCD;
"\xCE" := return 0xCE;
"\xCF" := return 0xCF;
"\xD0" := return 0xD0;
"\xD1" := return 0xD1;
"\xD2" := return 0xD2;
"\xD3" := return 0xD3;
"\xD4" := return 0xD4;
"\xD5" := return 0xD5;
"\xD6" := return 0xD6;
"\xD7" := return 0xD7;
"\xD8" := return 0xD8;
"\xD9" := return 0xD9;
"\xDA" := return 0xDA;
"\xDB" := return 0xDB;
"\xDC" := return 0xDC;
"\xDD" := return 0xDD;
"\xDE" := return 0xDE;
"\xDF" := return 0xDF;
"\xE0" := return 0xE0;
"\xE1" := return 0xE1;
"\xE2" := return 0xE2;
"\xE3" := return 0xE3;
"\xE4" := return 0xE4;
"\xE5" := return 0xE5;
"\xE6" := return 0xE6;
"\xE7" := return 0xE7;
"\xE8" := return 0xE8;
"\xE9" := return 0xE9;
"\xEA" := return 0xEA;
"\xEB" := return 0xEB;
"\xEC" := return 0xEC;
"\xED" := return 0xED;
"\xEE" := return 0xEE;
"\xEF" := return 0xEF;
"\xF0" := return 0xF0;
"\xF1" := return 0xF1;
"\xF2" := return 0xF2;
"\xF3" := return 0xF3;
"\xF4" := return 0xF4;
"\xF5" := return 0xF5;
"\xF6" := return 0xF6;
"\xF7" := return 0xF7;
"\xF8" := return 0xF8;
"\xF9" := return 0xF9;
"\xFA" := return 0xFA;
"\xFB" := return 0xFB;
"\xFC" := return 0xFC;
"\xFD" := return 0xFD;
"\xFE" := return 0xFE;
"\xFF" := return 0xFF;
*/
}
int main(int argc, char** argv) {
unsigned char buf[2];
unsigned int ch = 0;
buf[1] = 0u;
printf("const uint ebc2asc[256] =\n");
printf(" { /* Based on ISO 8859/1 and Code Page 37 */\n");
for (;;) {
if (ch % 16 == 0) {
printf(" ");
}
buf[0] = ch++;
printf("0x%02x", scan(buf));
if (ch == 256) {
printf("\n");
break;
}
if (ch % 16 == 0) {
printf(",\n");
} else {
printf(", ");
}
}
printf(" };\n");
return 0;
}
| [
"ola.bini@gmail.com"
] | ola.bini@gmail.com |
3a4b6d333a3ff0c1d0965fb12b275acf83c776b8 | f7c8c5bcb73b3d11cf84fba30e6835dae56328e8 | /uva10199_tourist_guide.cpp | 0b155077dad8707760a6634396db3a2ae76f1442 | [] | no_license | pedropaulovc/Desafios | 2ec28452e12c78070664b794c72536163e4c44e5 | 26c4554cd608b2c4cdeddf3fe50a708529491580 | refs/heads/master | 2020-05-20T13:14:14.543950 | 2012-08-06T17:11:08 | 2012-08-06T17:11:08 | 3,632,716 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,929 | cpp | #include<iostream>
#include<stack>
#include<queue>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<set>
#include<list>
#include<string>
#include<cstring>
#include<map>
#include<numeric>
#include<sstream>
#include<cmath>
using namespace std;
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define pb push_back
#define f(i,x,y) for(int i = x; i<y; i++ )
#define FORV(it,A) for(vector<int>::iterator it = A.begin(); it!= A.end(); it++)
#define FORS(it,A) for(set<int>::iterator it = A.begin(); it!= A.end(); it++)
#define quad(x) (x) * (x)
#define mp make_pair
#define clr(x, y) memset(x, y, sizeof x)
#define fst first
#define snd second
#define round(x) x <= 0.5 ? floor(x) : ceil(x)
#ifdef DEBUG
#define debug(x) x
#else
#define debug(x)
#endif
typedef pair<int, int> pii;
typedef long long ll;
typedef long double ld;
int instancia = 1, V, A, qtd_arestas;
map<int, string> nomes;
map<string, int> vertices;
vector<vector<int> > G;
vector<int> articulacoes;
int conta_pre;
vector<string> resposta;
vector<int> pre, low, parnt;
void articulacoes_recursivo(int v){
bool articulacao = false;
int conta_filhos = 0;
pre[v] = conta_pre++;
low[v] = pre[v];
f(i, 0, G[v].size()){
int w = G[v][i];
if(pre[w] == -1){
parnt[w] = v;
conta_filhos++;
articulacoes_recursivo(w);
if(low[w] < low[v])
low[v] = low[w];
if(parnt[v] != v && low[w] >= pre[v])
articulacao = true;
} else if(w != parnt[v] && pre[w] < low[v])
low[v] = pre[w];
}
debug(cout << nomes[v] << " " << pre[v] << " " << low[v] << endl;)
if(articulacao || parnt[v] == v && conta_filhos > 1)
articulacoes.pb(v);
}
void calcular_articulacoes(){
pre.clear();
low.clear();
parnt.clear();
pre.insert(pre.begin(), V, -1);
low.insert(low.begin(), V, -1);
parnt.insert(parnt.begin(), V, -1);
conta_pre = 0;
f(v, 0, V){
if(pre[v] == -1){
parnt[v] = v;
articulacoes_recursivo(v);
}
}
}
int main(){
bool primeiro = true;
int qtd_instancias = 0;
while(cin >> V && V != 0){
if(!primeiro)
cout << endl;
primeiro = false;
qtd_instancias++;
G.clear();
nomes.clear();
vertices.clear();
articulacoes.clear();
G.insert(G.begin(), V, vector<int>());
string nome;
f(i, 0, V){
cin >> nome;
nomes[i] = nome;
vertices[nome] = i;
}
cin >> A;
getchar();
string origem, destino;
f(i, 0, A){
getline(cin, origem, ' ');
getline(cin, destino);
G[vertices[origem]].pb(vertices[destino]);
G[vertices[destino]].pb(vertices[origem]);
}
calcular_articulacoes();
resposta.clear();
f(i, 0, articulacoes.size()){
resposta.pb(nomes[articulacoes[i]]);
}
sort(resposta.begin(), resposta.end());
cout << "City map #" << qtd_instancias << ": "<< articulacoes.size() << " camera(s) found" << endl;
f(i, 0, articulacoes.size()){
cout << resposta[i] << endl;
}
}
return 0;
}
| [
"pedropaulovc@gmail.com"
] | pedropaulovc@gmail.com |
ff39964a7f1b7ff91488442f3d0c06839b377219 | 0f764a7dd57533e0685e2d907ceff67e2bd65af3 | /cl_dll/haj/haj_concussion_effect.cpp | 5f5be005c7b96dcf20076708d9344378756864df | [
"MIT"
] | permissive | sswires/ham-and-jam | 86754d5a48a9745f86763e7150a2091e2d71f556 | 25121bf6302d81e68207706ae5c313c0c84ffc78 | refs/heads/master | 2020-05-17T16:21:23.920987 | 2015-01-06T13:01:09 | 2015-01-06T13:01:09 | 28,862,333 | 3 | 2 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 7,278 | cpp | //========= Copyright © 2007, Ham and Jam. ==============================//
// Purpose: The Ham and Jam concussion effect.
// Note: This can be called via C_HaJScreenEffects or env_screenoverlay
// $NoKeywords: $
//=======================================================================//
#include "cbase.h"
#include "screenspaceeffects.h"
#include "rendertexture.h"
#include "materialsystem/imaterialsystemhardwareconfig.h"
#include "materialsystem/imaterialsystem.h"
#include "materialsystem/imaterialvar.h"
#include "cdll_client_int.h"
#include "materialsystem/itexture.h"
#include "keyvalues.h"
#include "ClientEffectPrecacheSystem.h"
#include "haj_concussion_effect.h"
const float MAX_CONCUSS_DURATION = 8.0f; // duration of concussion for 100 damage (seconds)
CLIENTEFFECT_REGISTER_BEGIN( PrecacheEffectHaJConcussion )
//CLIENTEFFECT_MATERIAL( "effects/stun" )
//CLIENTEFFECT_MATERIAL( "dev/downsample" )
CLIENTEFFECT_MATERIAL( "fx/out" )
CLIENTEFFECT_MATERIAL( "dev/downsample_non_hdr" )
CLIENTEFFECT_MATERIAL( "dev/blurfilterx" )
//CLIENTEFFECT_MATERIAL( "dev/blurfilterx_nohdr" )
CLIENTEFFECT_MATERIAL( "dev/blurfiltery" )
CLIENTEFFECT_REGISTER_END()
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CConcussionEffect::Init( void )
{
m_pStunTexture = NULL;
m_flDuration = 0.0f;
m_flFinishTime = 0.0f;
m_bUpdated = false;
screen_mat = NULL;
downsample_mat = NULL;
blurx_mat = NULL;
blury_mat = NULL;
dest_rt0 = NULL;
dest_rt1 = NULL;
mv = NULL;
}
//------------------------------------------------------------------------------
// Purpose: Pick up changes in our parameters
//------------------------------------------------------------------------------
void CConcussionEffect::SetParameters( KeyValues *params )
{
if( params->FindKey( "duration" ) )
{
m_flDuration = ( MAX_CONCUSS_DURATION / 100.0f ) * params->GetFloat( "duration" );
m_flFinishTime = gpGlobals->curtime + m_flDuration;
m_bUpdated = true;
}
}
//-----------------------------------------------------------------------------
// Purpose: Render the effect
//-----------------------------------------------------------------------------
void CConcussionEffect::Render( int x, int y, int w, int h )
{
// Make sure we're ready to play this effect
if ( m_flFinishTime < gpGlobals->curtime )
return;
screen_mat = materials->FindMaterial( "fx/out", TEXTURE_GROUP_OTHER, true );
if( IsErrorMaterial( screen_mat ) )
return;
downsample_mat = materials->FindMaterial( "dev/downsample_non_hdr", TEXTURE_GROUP_OTHER, true);
if( IsErrorMaterial( downsample_mat ) )
return;
blurx_mat = materials->FindMaterial( "dev/blurfilterx", TEXTURE_GROUP_OTHER, true );
if( IsErrorMaterial( blurx_mat ) )
return;
blury_mat = materials->FindMaterial( "dev/blurfiltery", TEXTURE_GROUP_OTHER, true );
if( IsErrorMaterial( blury_mat ) )
return;
bool bResetBaseFrame = m_bUpdated;
int w1, h1;
bool found;
// Set ourselves to the proper rendermode
materials->MatrixMode( MATERIAL_VIEW );
materials->PushMatrix();
materials->LoadIdentity();
materials->MatrixMode( MATERIAL_PROJECTION );
materials->PushMatrix();
materials->LoadIdentity();
// Save off this pass
Rect_t srcRect;
srcRect.x = x;
srcRect.y = y;
srcRect.width = w;
srcRect.height = h;
ITexture *pSaveRenderTarget = materials->GetRenderTarget();
ITexture *pFBTexture = GetFullFrameFrameBufferTexture( 0 );
ITexture *dest_rt0 = materials->FindTexture( "_rt_SmallFB0", TEXTURE_GROUP_RENDER_TARGET );
ITexture *dest_rt1 = materials->FindTexture( "_rt_SmallFB1", TEXTURE_GROUP_RENDER_TARGET );
// First copy the FB off to the offscreen texture
materials->CopyRenderTargetToTexture( pFBTexture );
// get height of downsample buffers
w1 = dest_rt1->GetActualWidth();
h1 = dest_rt1->GetActualHeight();
// set out initial alpha to 1.0 (opaque)
mv = screen_mat->FindVar( "$alpha", &found, false );
if ( found ) { mv->SetFloatValue( 1.0f ); }
// Downsample image
materials->SetRenderTarget( dest_rt0 );
materials->Viewport( 0, 0, w1, h1 );
materials->DrawScreenSpaceQuad( downsample_mat );
// figure out how long is left and round it down to an int
float timeleft = m_flFinishTime - gpGlobals->curtime;
int t = (int)timeleft;
if (t > 3) t = 3; // set cap at max 3.
// blur the downsample buffer 3 times
// max is 3, down to 1 pass at the end.
for (; t >= 1; t-- )
{
// Blur filter pass 1
materials->SetRenderTarget( dest_rt1 );
materials->Viewport( 0, 0, w, h );
materials->DrawScreenSpaceQuad( blurx_mat );
// Blur filter pass 2
materials->SetRenderTarget( dest_rt0 );
materials->Viewport( 0, 0, w, h );
materials->DrawScreenSpaceQuad( blury_mat );
}
// set the alpha to fade out over the last 3 seconds.
mv = screen_mat->FindVar( "$alpha", &found, false );
if ( found )
mv->SetFloatValue( timeleft > 3.0f ? 1.0f : timeleft * 0.333333 );
materials->SetRenderTarget( pSaveRenderTarget );
materials->Viewport( srcRect.x,srcRect.y, srcRect.width, srcRect.height );
materials->DrawScreenSpaceQuad( screen_mat );
/*
// Get our current view
if ( m_pStunTexture == NULL )
{
m_pStunTexture = GetPowerOfTwoFrameBufferTexture();
}
// Draw the texture if we're using it
if ( m_pStunTexture != NULL )
{
bool foundVar;
IMaterialVar* pBaseTextureVar = pMaterial->FindVar( "$basetexture", &foundVar, false );
if ( bResetBaseFrame )
{
// Save off this pass
Rect_t srcRect;
srcRect.x = x;
srcRect.y = y;
srcRect.width = w;
srcRect.height = h;
pBaseTextureVar->SetTextureValue( m_pStunTexture );
materials->CopyRenderTargetToTextureEx( m_pStunTexture, 0, &srcRect, NULL );
materials->SetFrameBufferCopyTexture( m_pStunTexture );
m_bUpdated = false;
}
byte overlaycolor[4] = { 255, 255, 255, 0 };
float flEffectPerc = ( m_flFinishTime - gpGlobals->curtime ) / m_flDuration;
overlaycolor[3] = (byte) (150.0f * flEffectPerc);
render->ViewDrawFade( overlaycolor, pMaterial );
float viewOffs = ( flEffectPerc * 32.0f ) * cos( gpGlobals->curtime * 10.0f * cos( gpGlobals->curtime * 2.0f ) );
float vX = x + viewOffs;
float vY = y;
// just do one pass for dxlevel < 80.
if (g_pMaterialSystemHardwareConfig->GetDXSupportLevel() >= 80)
{
materials->DrawScreenSpaceRectangle( pMaterial, vX, vY, w, h,
0, 0, m_pStunTexture->GetActualWidth()-1, m_pStunTexture->GetActualHeight()-1,
m_pStunTexture->GetActualWidth(), m_pStunTexture->GetActualHeight() );
render->ViewDrawFade( overlaycolor, pMaterial );
materials->DrawScreenSpaceRectangle( pMaterial, x, y, w, h,
0, 0, m_pStunTexture->GetActualWidth()-1, m_pStunTexture->GetActualHeight()-1,
m_pStunTexture->GetActualWidth(), m_pStunTexture->GetActualHeight() );
}
// Save off this pass
Rect_t srcRect;
srcRect.x = x;
srcRect.y = y;
srcRect.width = w;
srcRect.height = h;
pBaseTextureVar->SetTextureValue( m_pStunTexture );
materials->CopyRenderTargetToTextureEx( m_pStunTexture, 0, &srcRect, NULL );
}
*/
// Restore our state
materials->MatrixMode( MATERIAL_VIEW );
materials->PopMatrix();
materials->MatrixMode( MATERIAL_PROJECTION );
materials->PopMatrix();
} | [
"steve@swires.me"
] | steve@swires.me |
86d521fd94cfad127aec4c6ad23a5b17a86eb2e5 | da55615c7a2290249c7bc38cec0c8b5f40610d0f | /DecisionTree/DecisionTreeLib/MepPruner.cpp | 30294675bc83510237836c1caa4c08ad28799144 | [] | no_license | adr-wisniewski/med-decision-trees | 46fcc1d4f4d4ea2d34df269d5023573234a3ac53 | d9083cb0f8bb461b954c5dd7542ebcf75c59a301 | refs/heads/master | 2021-01-17T09:35:20.853400 | 2012-06-05T20:44:28 | 2012-06-05T20:44:28 | 32,132,131 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,274 | cpp | #include "stdafx.h"
#include "MepPruner.h"
#include "Utils.h"
#include "DataSet.h"
#include "Node.h"
namespace Tree {
MepPruner::MepPruner(const char* name) : Pruner(name)
{
}
void MepPruner::prune(Node& tree, const Data::DataSet &pruningSet, const Data::DataSet &trainingSet) const {
// pruningSet and trainingSet is unused here
pruneRecursive(&tree);
}
float MepPruner::pruneRecursive(Node* subTree) const {
float n = (float)subTree->getTrainingObjects().size();
float nc = (float)subTree->getClassesCount()[subTree->GetMajorityClass()];
float k = (float)subTree->getClassesCount().size();
float errorEstimate = (n - nc + k - 1) / (n + k);
if(!subTree->IsLeaf()) {
float leftEstimate = pruneRecursive(subTree->getLeftChild());
float rightEstimate = pruneRecursive(subTree->getRightChild());
float leftn = (float)subTree->getLeftChild()->getTrainingObjects().size();
float rightn = (float)subTree->getRightChild()->getTrainingObjects().size();
float childrenEstimate = (leftn/n) * leftEstimate + (rightn/n) * rightEstimate;
if( childrenEstimate >= errorEstimate) {
pruneSubtree(subTree);
} else {
errorEstimate = childrenEstimate;
}
}
subTree->updateNodesCount();
return errorEstimate;
}
}
| [
"SirIzaak@gmail.com@decfb877-ba30-6845-4e93-c652665180cf"
] | SirIzaak@gmail.com@decfb877-ba30-6845-4e93-c652665180cf |
ad3f9e16f477ea96bbb6999ef17a15b178ea95df | cfeac52f970e8901871bd02d9acb7de66b9fb6b4 | /generated/src/aws-cpp-sdk-compute-optimizer/include/aws/compute-optimizer/model/EBSFilterName.h | 853f7cc4d042d74aa6553d130b3c88017a441d0a | [
"Apache-2.0",
"MIT",
"JSON"
] | permissive | aws/aws-sdk-cpp | aff116ddf9ca2b41e45c47dba1c2b7754935c585 | 9a7606a6c98e13c759032c2e920c7c64a6a35264 | refs/heads/main | 2023-08-25T11:16:55.982089 | 2023-08-24T18:14:53 | 2023-08-24T18:14:53 | 35,440,404 | 1,681 | 1,133 | Apache-2.0 | 2023-09-12T15:59:33 | 2015-05-11T17:57:32 | null | UTF-8 | C++ | false | false | 682 | h | /**
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
* SPDX-License-Identifier: Apache-2.0.
*/
#pragma once
#include <aws/compute-optimizer/ComputeOptimizer_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
namespace Aws
{
namespace ComputeOptimizer
{
namespace Model
{
enum class EBSFilterName
{
NOT_SET,
Finding
};
namespace EBSFilterNameMapper
{
AWS_COMPUTEOPTIMIZER_API EBSFilterName GetEBSFilterNameForName(const Aws::String& name);
AWS_COMPUTEOPTIMIZER_API Aws::String GetNameForEBSFilterName(EBSFilterName value);
} // namespace EBSFilterNameMapper
} // namespace Model
} // namespace ComputeOptimizer
} // namespace Aws
| [
"sdavtaker@users.noreply.github.com"
] | sdavtaker@users.noreply.github.com |
3cc0f392552c252e6a858ef663934fe9f01076b6 | febd6381e6951b6f3b018ede862c9b331f26dc26 | /Balkard-Project/deckShop.h | 93e0469a3b9b6cd27327622dfa7c51f8f8fa5b23 | [] | no_license | TimDel44/Balkard-Project | c680bf434d2468660716b08b7b618850c51e0c77 | 3541a2e7be67f8eebd4b76ff37d039087a34b406 | refs/heads/master | 2021-04-21T00:13:32.717195 | 2020-04-27T21:26:34 | 2020-04-27T21:26:34 | 249,728,908 | 1 | 0 | null | 2020-04-27T21:26:36 | 2020-03-24T14:23:45 | C++ | UTF-8 | C++ | false | false | 339 | h | #pragma once
#include <iostream>
#include <string>
#include <vector>
#include "carte.h"
using namespace std;
class deckShop
{
private:
vector<carte*> cartes;
public:
deckShop();
vector<carte*> getCarte() { return this->cartes; }
void melangerDeck();
void afficherDeck(sf::RenderWindow*);
void checkTaille();
void suppCarte();
}; | [
"56686964+TheophileFarvacque@users.noreply.github.com"
] | 56686964+TheophileFarvacque@users.noreply.github.com |
5829bd1ee4cc772ca8ff5ceba5f54c59fc56fc22 | 8b2aa09dca4c37e4cbf42a5dd83940ef7403e1e3 | /src/namespace1/test/Test_Class1.cpp | 3f309fa0c34a6f817065cd26c1df473b07e8ec6e | [] | no_license | CWegmann/GTestWithCMake | a300ab58101826ee97c066efcba7e804c86aa179 | 8d33a2dbdd3766840023b3794e1dc233317531d3 | refs/heads/master | 2020-08-08T17:42:28.719335 | 2019-10-09T09:46:52 | 2019-10-09T09:46:52 | 213,880,620 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 215 | cpp | #include <gtest/gtest.h>
#include "Class1.hpp"
TEST(Class1, Get){
EXPECT_EQ(ns1::Class1::get(), 1);
}
TEST(Class1, PassingTest){
EXPECT_TRUE(4 < 5);
}
TEST(Class1, FailingTest){
EXPECT_TRUE(5 < 4);
}
| [
"rh4370@partner.kit.edu"
] | rh4370@partner.kit.edu |
99fa7a0ca2f197447427b8e11ade14331a3817e8 | 6d842b054030c18d780717f5eecfe4720788ff01 | /homework1/homework1a/homework1a.ino | e16b36ff9f62c25ca30faa7ce2c17a6dcbfee873 | [] | no_license | irealva/gadgets-and-sensors | 0fd3241c1e4b1f002816b74e0c64153ff04504a3 | 565e531541974b7aad553d6904390d4a1ef7d7fa | refs/heads/master | 2021-03-27T14:00:35.341196 | 2017-03-03T01:22:08 | 2017-03-03T01:22:08 | 80,567,454 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,371 | ino | /*========================================================
Irene Alvarado
Gadgets and Sensors
Homework 1
Build a simple device with your Arduino which flashes four LEDs. Turn the first LED on for
2 seconds, then the second for 1 second, the third for a ½ second, and then the fourth for
a ¼ second. Then flash the four in some pattern of your choosing. Wait ½ second, and
then repeat.
// Instructions: https://www.arduino.cc/en/Tutorial/RowColumnScanning
========================================================*/
// 2-dimensional array of row pin numbers:
const int row[8] = {
7, 4, 9, 3, 14, 10, 16, 11
};
// 2-dimensional array of column pin numbers:
const int col[8] = {
18, 17, 13, 8, 12, 6, 5, 15
};
int H[8][8] = {
{0, 1, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0}
};
// 2-dimensional array of pixels:
int pixels[8][8] = {
{1, 1, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 1, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 1, 0, 0},
{0, 0, 1, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0}
};
// cursor position:
//int x = 5;
//int y = 5;
void setup() {
Serial.begin(9600);
// initialize the I/O pins as outputs
// iterate over the pins:
for (int thisPin = 0; thisPin < 8; thisPin++) {
// initialize the output pins:
pinMode(col[thisPin], OUTPUT);
pinMode(row[thisPin], OUTPUT);
// take the col pins (i.e. the cathodes) high to ensure that
// the LEDS are off:
digitalWrite(col[thisPin], HIGH);
}
}
// digitalWrite(3, LOW); // ROW4
// digitalWrite(4, LOW); // ROW 2
// digitalWrite(5, LOW); // COL 7
// digitalWrite(6, LOW); // COL 6
// digitalWrite(7, LOW); // ROW1
// digitalWrite(8, LOW); // COL 4
// digitalWrite(9, LOW); // ROW3
// digitalWrite(10, LOW); // ROW6
// digitalWrite(11, LOW); // ROW8
// digitalWrite(12, LOW); // COL 5
// digitalWrite(13, LOW); // COL 3
// digitalWrite(A0, LOW); // ROW5 // 14
// digitalWrite(A1, LOW); // COL 8 // 15
// digitalWrite(A2, HIGH); // ROW7 // 16
// digitalWrite(A3, LOW); // COL 2 //17
// digitalWrite(A4, HIGH); // COL 1 // 18
void loop() {
// iterate over the rows (anodes):
for (int thisRow = 0; thisRow < 8; thisRow++) {
// take the row pin (anode) high:
digitalWrite(row[thisRow], HIGH);
// iterate over the cols (cathodes):
for (int thisCol = 0; thisCol < 8; thisCol++) {
// get the state of the current pixel;
int thisPixel = pixels[thisRow][thisCol];
thisPixel = !thisPixel; // EXTRA DELETE
// when the row is HIGH and the col is LOW,
// the LED where they meet turns on:
digitalWrite(col[thisCol], thisPixel);
// turn the pixel off:
if (thisPixel == LOW) {
// Serial.println(LOW);
digitalWrite(col[thisCol], HIGH);
}
}
// take the row pin low to turn off the whole row:
digitalWrite(row[thisRow], LOW);
}
}
/*
// iterate over the rows (anodes):
for (int thisRow = 0; thisRow < 8; thisRow++) {
// take the row pin (anode) high:
digitalWrite(row[thisRow], HIGH);
for (int thisCol = 0; thisCol < 8; thisCol++) {
digitalWrite(col[thisCol], HIGH);
// Serial.print( "Col: ");
// Serial.println(thisCol);
if (H[thisRow][thisCol] == 1) {
// Serial.print( "Row: ");
// Serial.print(thisRow);
//
// Serial.print( "Col: ");
// Serial.println(thisCol);
digitalWrite(col[thisCol], LOW);
digitalWrite(row[thisRow], LOW);
}
}
}
*/
// digitalWrite(3, LOW); // ROW4
// digitalWrite(4, LOW); // ROW 2
// digitalWrite(5, HIGH); // COL 7
// digitalWrite(6, HIGH); // COL 6
// digitalWrite(7, LOW); // ROW1
// digitalWrite(8, HIGH); // COL 4
// digitalWrite(9, HIGH); // ROW3 // this is on HIGH
// digitalWrite(10, LOW); // ROW6
// digitalWrite(11, LOW); // ROW8
// digitalWrite(12, HIGH); // COL 5
// digitalWrite(13, HIGH); // COL 3
// digitalWrite(A0, LOW); // ROW5 // 14
// digitalWrite(A1, LOW); // COL 8 // 15
// digitalWrite(A2, HIGH); // ROW7 // 16 // this is on high
// digitalWrite(A3, LOW); // COL 2 //17
// digitalWrite(A4, LOW); // COL 1 // 18
| [
"ire.alvarado@gmail.com"
] | ire.alvarado@gmail.com |
08d1ad8b8b2c7baa0eb96f10285d6043e54e99c1 | 28d25f81c33fe772a6d5f740a1b36b8c8ba854b8 | /Codeforces/96B/main.cpp | 8fb856641fc73f9c167d5f9a85deb0a2d9601823 | [] | no_license | ahmedibrahim404/CompetitiveProgramming | b59dcfef250818fb9f34797e432a75ef1507578e | 7473064433f92ac8cf821b3b1d5cd2810f81c4ad | refs/heads/master | 2021-12-26T01:18:35.882467 | 2021-11-11T20:43:08 | 2021-11-11T20:43:08 | 148,578,163 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 540 | cpp | #include <iostream>
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll arr[10000000+9];
int idx=0;
ll n;
void build(ll num, int fours, int sevens){
if(num > 1e10) return;
if(num != 0 && fours==sevens)
arr[idx++]=num;
build(num*10+4, fours+1, sevens);
build(num*10+7, fours, sevens+1);
}
int main(){
build(0, 0, 0);
sort(arr, arr+idx);
scanf("%lld", &n);
int id=lower_bound(arr, arr+idx, n)-arr;
printf("%lld", arr[id]);
return 0;
}
| [
"ahmedie20022011@gmail.com"
] | ahmedie20022011@gmail.com |
b8581b3659bee6104042bd34df6e650b67f1c4f0 | 0fe27e6c63a755fe7df003f36acc079490a338f3 | /src/cpp/Longest-Word-in-Dictionary.cpp | 5f640d2815fab255cdce55235103e153292386be | [] | no_license | Finalcheat/leetcode | 83f9ceb7bd10783554133434347803a41260a713 | 985deb6142c6841aa7025c9b582010b33f694e6c | refs/heads/master | 2022-11-11T22:51:42.666150 | 2022-11-05T03:07:31 | 2022-11-05T03:07:31 | 53,241,690 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,770 | cpp | /**
* @file Longest-Word-in-Dictionary.cpp
* @brief 字典的最长词(https://leetcode.com/problems/longest-word-in-dictionary/description/)
* @author Finalcheat
* @date 2018-01-11
*/
/**
* Given a list of strings words representing an English Dictionary, find the longest word in words that can be built one character at a time by other words in words. If there is more than one possible answer, return the longest word with the smallest lexicographical order.
* If there is no answer, return the empty string.
* Example 1:
* Input:
* words = ["w","wo","wor","worl", "world"]
* Output: "world"
* Explanation:
* The word "world" can be built one character at a time by "w", "wo", "wor", and "worl".
* Example 2:
* Input:
* words = ["a", "banana", "app", "appl", "ap", "apply", "apple"]
* Output: "apple"
* Explanation:
* Both "apply" and "apple" can be built from other words in the dictionary. However, "apple" is lexicographically smaller than "apply".
*/
/**
* 先排序使得前缀的词聚在一起，然后遍历过程中使用hash table作为辅助判断前缀。
*/
class Solution {
public:
string longestWord(vector<string>& words) {
std::sort(words.begin(), words.end());
std::unordered_set<string> u;
string result;
for (size_t i = 0; i < words.size(); ++i) {
const string& word = words[i];
const string preWord = word.substr(0, word.size() - 1);
if (preWord.empty() || u.find(preWord) != u.end()) {
u.insert(word);
if (word.size() > result.size()) {
result = word;
}
}
}
return result;
}
};
| [
"finalcheat@qq.com"
] | finalcheat@qq.com |
5d9c2e17fcf0fc60ddaaf728fcc2bcf4fbf80e59 | 869d474399fe79a0095a163f64f4ee87ddd97510 | /src/version.h | a4f1715d4d4a3066cd11858749a69003b402baa5 | [
"MIT"
] | permissive | HYPERcrypto/Hyper | dbee80d901afd24037fd563c4cc3ce441bf0ef85 | f83a89f95d1196f9b03dfaac9f3f6327efc2fbb1 | refs/heads/master | 2021-01-15T12:26:08.924412 | 2015-07-09T11:51:20 | 2015-07-09T11:51:20 | 20,156,296 | 3 | 5 | null | 2015-07-09T11:51:21 | 2014-05-25T14:21:42 | C++ | UTF-8 | C++ | false | false | 1,471 | h | // Copyright (c) 2012 The Bitcoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef BITCOIN_VERSION_H
#define BITCOIN_VERSION_H
#include "clientversion.h"
#include <string>
//
// client versioning
//
static const int CLIENT_VERSION =
1000000 * CLIENT_VERSION_MAJOR
+ 10000 * CLIENT_VERSION_MINOR
+ 100 * CLIENT_VERSION_REVISION
+ 1 * CLIENT_VERSION_BUILD;
extern const std::string CLIENT_NAME;
extern const std::string CLIENT_BUILD;
extern const std::string CLIENT_DATE;
//
// network protocol versioning
//
static const int PROTOCOL_VERSION = 60007;
// earlier versions not supported as of Feb 2012, and are disconnected
static const int MIN_PROTO_VERSION = 209;
// nTime field added to CAddress, starting with this version;
// if possible, avoid requesting addresses nodes older than this
static const int CADDR_TIME_VERSION = 31402;
// only request blocks from nodes outside this range of versions
static const int NOBLKS_VERSION_START = 60002;
static const int NOBLKS_VERSION_END = 60004;
// BIP 0031, pong message, is enabled for all versions AFTER this one
static const int BIP0031_VERSION = 60000;
// "mempool" command, enhanced "getdata" behavior starts with this version:
static const int MEMPOOL_GD_VERSION = 60002;
#endif
| [
"Hyper"
] | Hyper |
098780fd7f6e567c2a0a4c00f4bf99904644f3c4 | 8f6b8cf0d4a5e66c5252709cfb955ee8a4c7beca | /STMGeom/inc/STMBasorber.hh | 3549e33adde232912fc7634967c5051e5a20698a | [
"Apache-2.0"
] | permissive | jrquirk/Offline | 74ae5626a0655f29f60e481abab7e3035e2075c6 | cd6398c77893390b4288000f2ddb5edc601060ad | refs/heads/master | 2023-02-04T07:03:28.428904 | 2020-12-23T04:11:33 | 2020-12-23T04:11:33 | 276,197,693 | 0 | 0 | Apache-2.0 | 2020-08-28T23:52:52 | 2020-06-30T20:06:49 | C++ | UTF-8 | C++ | false | false | 1,730 | hh | #ifndef STMGeom_STMBasorber_hh
#define STMGeom_STMBasorber_hh
// STM Basorber Object
//
// Author: Anthony Palladino
//
#include <string>
#include "CLHEP/Vector/Rotation.h"
#include "CLHEP/Vector/ThreeVector.h"
namespace mu2e {
class STMBasorber {
public:
STMBasorber(bool build,
double halfWidth, double halfHeight, double halfLength,
CLHEP::Hep3Vector const & originInMu2e = CLHEP::Hep3Vector(),
CLHEP::HepRotation const & rotation = CLHEP::HepRotation(),
std::string const & material = ""
) :
_build( build ),
_halfWidth( halfWidth ),
_halfHeight( halfHeight ),
_halfLength( halfLength ),
_originInMu2e( originInMu2e ),
_rotation( rotation ),
_material( material )
{}
bool build() const { return _build; }
double halfWidth() const { return _halfWidth; }
double halfHeight() const { return _halfHeight; }
double halfLength() const { return _halfLength; }
CLHEP::Hep3Vector const & originInMu2e() const { return _originInMu2e; }
CLHEP::HepRotation const & rotation() const { return _rotation; }
std::string const & material() const { return _material; }
// Genreflex can't do persistency of vector<STMBasorber> without a default constructor
STMBasorber() {}
private:
bool _build;
double _halfWidth;
double _halfHeight;
double _halfLength;
CLHEP::Hep3Vector _originInMu2e;
CLHEP::HepRotation _rotation; // wrt to parent volume
std::string _material;
};
}
#endif/*STMGeom_STMBasorber_hh*/
| [
"whyaqm@gmail.com"
] | whyaqm@gmail.com |
ae089cc412c90ef0e2b9d0dddbdca4d5a420f58f | 35c723f0b4753ef6d566a8837a78475a5a762875 | /Chapter 19 More about Strings/19.03/main.cpp | d0deb2b889de43efc26041c84c65fec0076be520 | [] | no_license | cory-brown/Jumping-into-CPP | fbf8bb0b2d82266a7b82641b2116ea0f8d0e50a8 | 82a1ce2d759e572c089ba32ce9c3a28fea5ad9ac | refs/heads/master | 2021-09-25T10:44:00.370819 | 2017-08-06T16:50:37 | 2017-08-06T16:50:37 | 54,891,396 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,035 | cpp | /*
Write a program that reads in HTML text that the user types in (don’t worry, we’ll cover how to
read from a file later). It should support the following HTML tags: <html>, <head>, <body>, <b>,
<i>, and <a>. Each HTML tag has an open tag, e.g. <html>, and a closing tag which has a forwardslash
at the start: </html>. Inside the tag is text that is controlled by that tag: <b>text to be
bolded</b> or <i>text to be italicized</i>. The <head> </head> tags control text that is
metadata, and the <body></body> tags surround text that is to be displayed. <a> tags are used
for hyperlinks, and have an URL in the following format: <a href=URL>text</a>.
Once your program has read in some HTML, it should simply ignore <html>. It should remove
any text from the <head> section so that it doesn't show up when you output it. It should then
display all text in the body, modifying it so that any text between a <b> and a </b> will show up
with asterisks (*) around it, any text inside <i> and </i> will show up with underscores (_)
around it, and any text with a <a href=linkurl>link text</a> tag shows up as link text (linkurl).
*/
//Supported <html>, <head>, <body>, <b>, <i>, and <a>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
void readHTML(vector<string>&, const string&);
void formatHTML(vector<string>&);
void printHTML(const vector<string>&);
int main() {
vector<string> tags;
string input_tag = "<html><head></head><body><i>Hello</i><b>World</b><a href=google.com>Visit Google!</a></body></html>";
readHTML(tags, input_tag);
formatHTML(tags);
printHTML(tags);
}
// READ THIS LATER
// http://stackoverflow.com/questions/9221980/how-would-i-store-an-empty-string-into-a-vector
//
void readHTML(vector<string>& tags, const string& html) {
for (int i = 0; i < html.length(); ++i) {
if (html[i] == '<' || html[i] == '/') {
if (html[i] == '/') {
--i;
}
string temp_tag = "";
while (html[i] != '>') {
temp_tag += html[i++];
}
tags.push_back(temp_tag);
} else {
string temp_text;
while (html[i] != '<') {
temp_text += html[i++];
}
tags.push_back(temp_text);
}
}
}
// Could spilt this up into two different functions, but it's fine for now.
void formatHTML(vector<string>& tags) {
for (int i = 0; i < tags.size(); i++) {
if ((tags[i]) == "<b") {
++i;
string &textContent = tags[i];
textContent.insert(textContent.begin(), '*');
textContent.push_back('*');
} else if ((tags[i]) == "<i") {
++i;
string &textContent = tags[i];
textContent.insert(textContent.begin(), '_');
textContent.push_back('_');
} else if (((tags[i])[1]) == 'a') {
string url = (tags[i]).substr(8);
url.insert(url.begin(), '(');
url.push_back(')');
string &textContent = tags[++i];
textContent += " " + url;
}
}
}
void printHTML(const vector<string>& tags) {
for (int i = 0; i < tags.size(); i++) {
if (((tags[i])[0]) != '<') {
cout << tags[i] << endl;
}
}
}
| [
"cbrown8100@gmail.com"
] | cbrown8100@gmail.com |
53ee494c0cb6e2fa86f2ee2d792d55ad8fced392 | 241a7f0c8eb546081c188d7ecc1c5247eda8d892 | /Multibot/Extras/ConfigReader/ConfigFile.hpp | a65f6108ce0269906d43287861a029d9e03616a5 | [
"MIT"
] | permissive | Sophie-Williams/TeamSpeak3-Multibot-cpp | 80d9ba1bcc89f9396963dc354c07b19905aee776 | 5ed9cac4eb14121afab030547d8d5f24fc75c454 | refs/heads/master | 2020-09-07T04:52:25.384646 | 2016-05-08T11:22:10 | 2016-05-08T11:22:10 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,362 | hpp | #pragma once
#include <string>
#include <map>
#include <fstream>
#include <iostream>
#include <vector>
#include "Loger/Loger.hpp"
using namespace std;
class ConfigFile {
private:
/// Przechowuje ścieżkę do pliku
string fileName;
/**
* @brief Pobiera zawartość pliku w odpowiednim formacie i zapisuje ją do mapy fileContent.
*/
void getContent();
/**
* @brief Usuwa białe znaki z początku i końca ciągu
* @param source - Ciąg do usunięcia buałych znaków
* @param delims - Znaki które powinny być usunięte
* @return Ciąg bez białych znaków na początku i końcu
*/
string trim(string const& source, char const* delims = " \t\r\n");
public:
/// Przechowuje wczytany plik konfiguracyjny
map<string, map<string, string>> fileContent;
/**
* @breif Konstruktor obiektu ConfigFile
*/
ConfigFile(string const file);
/**
* @brief Zapisuje zmienioną konfiguracje do pliku
*/
void save();
/**
* Pozwala na używanie obiektu tak jak zwykłej mapy
*
* @brief Przeładowanie operatora []
* @param name - Nazwa sekcji w pliku konfiguracyjnym
* @return map<string, string> - Zawartość sekcji pliku konfiguracyjnego
*/
map<string, string>& operator[](string name);
vector<string> explode(string const& str, string key);
map<string, string> explodeToMap(string const& str, string key);
}; | [
"karo2krupa@gmail.com"
] | karo2krupa@gmail.com |
b9f712be515e2f55f54dd5ac2e3cd47246ebb5b5 | fba3f3ae4fcbe5da8b8cec89b10bc5c209ba91eb | /kinect_slam/Kinect_SLAM.cpp | 4502a6e8cb603ef390c568c2733366fe7331d21c | [] | no_license | xin-xiner/ORBSLAM_project | 30912517229509970db677c5a91a1bb935d3e8d2 | bcd1e26ce83c79bb2afbdf215ad5f7aca46d5402 | refs/heads/master | 2021-01-19T02:09:34.377948 | 2016-11-10T10:43:14 | 2016-11-10T10:43:14 | 73,372,691 | 3 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,877 | cpp |
#include "KinectReader.h"
#include<System.h>
#include<iostream>
#include<algorithm>
#include<fstream>
#include<chrono>
#include<opencv2/core/core.hpp>
#include "frameWriter.h"
#include <boost\thread\thread.hpp>
using namespace std;
int main(int argc, char **argv)
{
if (argc != 3)
{
cerr << endl << "Usage: ./rgbd_tum path_to_vocabulary path_to_settings path_to_sequence path_to_association" << endl;
return 1;
}
// Retrieve paths to images
// Create SLAM system. It initializes all system threads and gets ready to process frames.
//ORB_SLAM2::System SLAM(argv[1], argv[2], ORB_SLAM2::System::RGBD, true);
ORB_SLAM2::System SLAM(argv[1], argv[2], ORB_SLAM2::System::MONOCULAR, true);
FrameQueue frame_queue("frames\\");
system("DEL/q frames\\rgb\\*.*");
system("DEL/q frames\\depth\\*.*");
std::thread visThread(&FrameQueue::writeThread, &frame_queue);
KinectReader capture;
capture.sizeType = 1;
cout << "Start processing sequence ..." << endl;
// Main loop
cv::Mat imRGB, imD, depth8U,cameraPose;
double frameID = 0;
cv::namedWindow("rgb", 0);
while (cv::waitKey(10) != 'c')
{
while (!capture.getNextFrame(imD, imRGB)){ Sleep(1); };
// Read image and depthmap from file
cv::imshow("rgb", imRGB);
/*
imD.convertTo(depth8U, CV_8U);
cv::imshow("depth", depth8U);
cv::waitKey(10);*/
if (imRGB.empty())
{
cerr << endl << "Failed to load image at: "
<< endl;
return 1;
}
#ifdef COMPILEDWITHC11
std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
#else
std::chrono::monotonic_clock::time_point t1 = std::chrono::monotonic_clock::now();
#endif
// Pass the image to the SLAM system
//cameraPose = SLAM.TrackRGBD(imRGB, imD, frameID);
cameraPose = SLAM.TrackMonocular(imRGB, frameID);
if (!cameraPose.empty())
{
frame_queue.pushBack(imRGB, imD, frameID);
frameID++;
}
#ifdef COMPILEDWITHC11
std::chrono::steady_clock::time_point t2 = std::chrono::steady_clock::now();
#else
std::chrono::monotonic_clock::time_point t2 = std::chrono::monotonic_clock::now();
#endif
double ttrack = std::chrono::duration_cast<std::chrono::duration<double> >(t2 - t1).count();
// Wait to load the next frame
}
// Stop all threads
SLAM.Shutdown();
frame_queue.close();
// Save camera trajectory
SLAM.SaveTrajectoryTUM("CameraTrajectory_all.txt");
SLAM.SaveKeyFrameTrajectoryTUM("CameraTrajectory_keyframe.txt");
SLAM.SaveMapClouds("MapPoints.vtx");
return 0;
}
//int main()
//{
//
//}
//int main()
//{
// KinectReader capture;
// cv::Mat rgb, depth,depthu8;
// while (capture.getNextFrame(depth, rgb))
// {
// normalizeDepthImage(depth,depthu8);
// cv::imshow("rgb", rgb);
// cv::imshow("depth", depthu8);
// cv::waitKey(10);
// }
//}
| [
"1036980707@qq.com"
] | 1036980707@qq.com |
37636215f78a75b13826e220a77e928779c36cc4 | 806440459d331cfa5a2194ce60d4c7d6745bf23e | /sharp/cmftsharp/cmftclr/CmftImage.h | dbfd40aceb47fb67ef67539287d3dd6071e76011 | [] | no_license | lucasassislar/cmftsharp | 7019221cd37068a5c3afc4d82f23d5dbb74c5206 | af6162a62b51e8554cee16f469edefacd0e154cf | refs/heads/master | 2021-01-19T10:21:30.368738 | 2017-04-11T01:18:49 | 2017-04-11T01:18:49 | 87,856,121 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,539 | h | #pragma once
#include <cmft\image.h>
#include <cmft/cubemapfilter.h>
#include "ClrAllocator.h"
using namespace System;
using namespace System::IO;
using namespace System::Runtime::InteropServices;
using namespace cmft;
using CImage = cmft::Image;
using CTextureFormat = cmft::TextureFormat;
using CImageFileType = cmft::ImageFileType;
using COutputType = cmft::OutputType;
using CLightingModel = cmft::LightingModel;
using CEdgeFixup = cmft::EdgeFixup;
namespace cmftclr
{
public enum class FilterType
{
None,
Radiance,
Irradiance,
ShCoeffs,
};
public enum class LightingModel
{
Phong,
PhongBrdf,
Blinn,
BlinnBrdf,
Count
};
public enum class EdgeFixup
{
None,
Warp,
};
public enum class ImageFileType
{
DDS,
KTX,
TGA,
HDR,
Count
};
public enum class OutputType
{
LatLong,
Cubemap,
HCross,
VCross,
HStrip,
VStrip,
FaceList,
Octant,
Count,
Null = -1,
};
public enum class TextureFormat
{
BGR8,
RGB8,
RGB16,
RGB16F,
RGB32F,
RGBE,
BGRA8,
RGBA8,
RGBA16,
RGBA16F,
RGBA32F,
RGBM,
Count,
Null = -1,
};
public ref class CmftImage
{
private:
CImage* image;
bool imageLoaded;
public:
CmftImage(String^ filePath, TextureFormat format);
CmftImage(String^ filePath);
CmftImage(Stream^ stream);
~CmftImage();
bool IsCubemap();
bool IsLatLong();
bool IsHorizontalStrip();
bool IsVerticalStrip();
bool IsOctant();
bool ToCubemapFromStrip();
void DoRadianceFilter(Int32 faceSize, LightingModel lightModel, bool excludeBase, Byte mipCount, Byte glossScale, Byte glossBias, EdgeFixup edgeFixup, Byte numCPUThreads);
void DoIrradianceFilterSh(Int32 faceSize);
void GenerateMipMapChain();
void ApplyGamma(float gamma);
void EncodeRGBM();
bool Save(String^ filePath, ImageFileType fileType, OutputType outType, TextureFormat format);
static TextureFormat GetTextureFormat(CTextureFormat::Enum format)
{
return (TextureFormat)(Int32)(format);
}
static CTextureFormat::Enum GetCmftTextureFormat(TextureFormat format)
{
return (CTextureFormat::Enum)(Int32)(format);
}
Int32 Width()
{
return image->m_width;
}
Int32 Height()
{
return image->m_height;
}
Int32 DataSize()
{
return image->m_dataSize;
}
TextureFormat Format()
{
return static_cast<TextureFormat>(image->m_format);
}
Int32 NumFaces()
{
return image->m_numFaces;
}
Int32 NumMips()
{
return image->m_numMips;
}
IntPtr Data()
{
return IntPtr(image->m_data);
}
};
}
| [
"lucasassis@outlook.com"
] | lucasassis@outlook.com |
7141c94465e8f61c6eba323ec425bad5123e90d2 | 60691e2e3cd27f25183d8d3ff6bf6a50628d2e21 | /World/RangeImplementation/XRange.h | ff6718c1c67963f67591871d10b29e7d9c61fb28 | [] | no_license | Binyamin-Brion/3DWorld | fa9619afaf4caa8615a6a45e942810a9a6433cc1 | 2acdd7812c2614b7ab6811b624f48b0db52ad13c | refs/heads/master | 2020-12-10T05:05:25.580670 | 2020-07-03T12:21:32 | 2020-07-03T12:21:32 | 233,508,514 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 461 | h | //
// Created by BinyBrion on 2019-10-29.
//
#ifndef MINECRAFTQT_XRANGE_H
#define MINECRAFTQT_XRANGE_H
#include "Range.h"
namespace World
{
/*
* Specialized range for the X dimension in the world.
*/
class XRange : public Range
{
public:
XRange(float min, float max);
bool operator==(const XRange &otherRange) const;
bool overlapRange(XRange xRange) const;
};
}
#endif //MINECRAFTQT_XRANGE_H
| [
"binybrion@gmail.com"
] | binybrion@gmail.com |
14eb22b0c4f7a6a230cad2562fe6c01f4352f857 | c336cefe67b2510ed68a5fd58897fe54ba7a67ce | /clion/protobuf/concept.h | f0d31a0d1dbfe406ac7c2365845ecedc174ee150 | [] | no_license | david-pp/david | 08ec42564ba468487458a09c6455338174098ca8 | a943dac2e78403dcb7f90e45c3dab95aaa9723a4 | refs/heads/master | 2021-06-28T17:58:06.387031 | 2020-11-19T11:43:33 | 2020-11-19T11:43:33 | 7,815,588 | 7 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 1,122 | h |
template<typename T>
struct Serializer {
std::string serialize(const T &object) const;
bool deserialize(T &object, const std::string &bin) const;
};
template<template <typename T> class SerializerT = ProtoSerializer, typename T>
std::string serialize(const T &object, const SerializerT &serializer = SerializerT()) {
return serializer.serialize(object);
};
template<template <typename T> class SerializerT = ProtoSerializer, typename T>
bool deserialize(T &object, const std::string &bin, const SerializerT &serializer = SerializerT()) const {
return serializer.deserialize(object, bin);
}
Player p;
void usage_1() {
std::string data = serialize(p);
deserialize(p, data);
}
void usage_2() {
std::string data = serialize<DynProtoSerializer>(p);
deserialize<DynProtoSerializer>(p, data);
}
void usage_3() {
DynProtoSerializer serializer(&GeneratedProtoMappingFactory::intance());
std::string data = serialize(p, serializer);
deserialize(p, serializer);
}
void usage_4() {
std::string data = serialize<JsonSerializer>(p);
deserialize<JsonSerializer>(p, data);
}
| [
"heaven.hell.or@gmail.com"
] | heaven.hell.or@gmail.com |
c41b852926a83deb181e5b8ee9fe8e29ae9409b7 | 688cd6b75839ba98141d0aa089d1dee28f2a0c77 | /C/codelite/1.cpp | 4ceb486f7e856ab609ee1bc088c4c8c4128d41ec | [] | no_license | chenwei182729/code | c3e1208264e96c3146c8b6e4044eaed12fd269b3 | ac9c81da6c010bd134d61127d72ea5a8e651f17d | refs/heads/master | 2020-06-30T20:36:35.557266 | 2016-12-02T12:40:52 | 2016-12-02T12:40:52 | 74,349,006 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 77 | cpp | #include<stdio.h>
int main()
{
cout<<"hello world"<<endl;
return 0;
} | [
"chenwei182729@163.com"
] | chenwei182729@163.com |
cc7d7a50dd519c86120c7fe4c2413fd01e8e7fc5 | c87095bd13b9080224324b3a6dd4fd538912d97e | /OpenGL/OBJ File Loader/Init.cpp | 8621c348ed59d1a1139d1283723e8c3c00073abf | [
"MIT"
] | permissive | Agrelimos/tutorials | 6a0a8ef6652a44bd5a35b59bf192326c831367ff | 7d2953b8fbb5c56a921a17e7e3cac3d1f4fbb41b | refs/heads/master | 2020-04-01T05:26:56.560609 | 2018-10-13T18:45:56 | 2018-10-13T18:45:56 | 152,903,588 | 0 | 0 | MIT | 2018-10-13T18:44:42 | 2018-10-13T18:44:42 | null | WINDOWS-1252 | C++ | false | false | 12,772 | cpp | //***********************************************************************//
// //
// - "Talk to me like I'm a 3 year old!" Programming Lessons - //
// //
// $Author: DigiBen digiben@gametutorials.com //
// //
// $Program: Obj Loader //
// //
// $Description: Demonstrates how to load a .Obj file format //
// //
//***********************************************************************//
#include "main.h"
///////////////////////////////// CREATE TEXTURE \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
/////
///// This creates a texture in OpenGL that we can texture map
/////
///////////////////////////////// CREATE TEXTURE \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
bool CreateTexture(GLuint &textureID, LPTSTR szFileName) // Creates Texture From A Bitmap File
{
HBITMAP hBMP; // Handle Of The Bitmap
BITMAP bitmap; // Bitmap Structure
glGenTextures(1, &textureID); // Create The Texture
hBMP=(HBITMAP)LoadImage(GetModuleHandle(NULL), szFileName, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION | LR_LOADFROMFILE );
if (!hBMP) // Does The Bitmap Exist?
return FALSE; // If Not Return False
GetObject(hBMP, sizeof(bitmap), &bitmap); // Get The Object
// hBMP: Handle To Graphics Object
// sizeof(bitmap): Size Of Buffer For Object Information
// &bitmap: Buffer For Object Information
glPixelStorei(GL_UNPACK_ALIGNMENT, 4); // Pixel Storage Mode (Word Alignment / 4 Bytes)
// Typical Texture Generation Using Data From The Bitmap
glBindTexture(GL_TEXTURE_2D, textureID); // Bind To The Texture ID
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // Linear Min Filter
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Linear Mag Filter
glTexImage2D(GL_TEXTURE_2D, 0, 3, bitmap.bmWidth, bitmap.bmHeight, 0, GL_BGR_EXT, GL_UNSIGNED_BYTE, bitmap.bmBits);
// MUST NOT BE INDEX BMP, BUT RGB
DeleteObject(hBMP); // Delete The Object
return TRUE; // Loading Was Successful
}
///////////////////////////////// CHANGE TO FULL SCREEN \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
/////
///// This changes the screen to FULL SCREEN
/////
///////////////////////////////// CHANGE TO FULL SCREEN \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
void ChangeToFullScreen()
{
DEVMODE dmSettings; // Device Mode variable
memset(&dmSettings,0,sizeof(dmSettings)); // Makes Sure Memory's Cleared
// Get current settings -- This function fills in our settings.
// This makes sure NT and Win98 machines change correctly.
if(!EnumDisplaySettings(NULL,ENUM_CURRENT_SETTINGS,&dmSettings))
{
// Display error message if we couldn't get display settings
MessageBox(NULL, "Could Not Enum Display Settings", "Error", MB_OK);
return;
}
dmSettings.dmPelsWidth = SCREEN_WIDTH; // Selected Screen Width
dmSettings.dmPelsHeight = SCREEN_HEIGHT; // Selected Screen Height
// This function actually changes the screen to full screen.
// CDS_FULLSCREEN gets rid of the start Bar.
// We always want to get a result from this function to check if we failed.
int result = ChangeDisplaySettings(&dmSettings,CDS_FULLSCREEN);
// Check if we didn't receive a good return message From the function
if(result != DISP_CHANGE_SUCCESSFUL)
{
// Display the error message and quit the program
MessageBox(NULL, "Display Mode Not Compatible", "Error", MB_OK);
PostQuitMessage(0);
}
}
///////////////////////////////// CREATE MY WINDOW \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
/////
///// This function creates a window, but doesn't have a message loop
/////
///////////////////////////////// CREATE MY WINDOW \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
HWND CreateMyWindow(LPSTR strWindowName, int width, int height, DWORD dwStyle, bool bFullScreen, HINSTANCE hInstance)
{
HWND hWnd;
WNDCLASS wndclass;
memset(&wndclass, 0, sizeof(WNDCLASS)); // Init the size of the class
wndclass.style = CS_HREDRAW | CS_VREDRAW; // Regular drawing capabilities
wndclass.lpfnWndProc = WinProc; // Pass our function pointer as the window procedure
wndclass.hInstance = hInstance; // Assign our hInstance
wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION); // General icon
wndclass.hCursor = LoadCursor(NULL, IDC_ARROW); // An arrow for the cursor
wndclass.hbrBackground = (HBRUSH) (COLOR_WINDOW+1); // A white window
wndclass.lpszClassName = "GameTutorials"; // Assign the class name
RegisterClass(&wndclass); // Register the class
if(bFullScreen && !dwStyle) // Check if we wanted full screen mode
{ // Set the window properties for full screen mode
dwStyle = WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
ChangeToFullScreen(); // Go to full screen
ShowCursor(FALSE); // Hide the cursor
}
else if(!dwStyle) // Assign styles to the window depending on the choice
dwStyle = WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
g_hInstance = hInstance; // Assign our global hInstance to the window's hInstance
RECT rWindow;
rWindow.left = 0; // Set Left Value To 0
rWindow.right = width; // Set Right Value To Requested Width
rWindow.top = 0; // Set Top Value To 0
rWindow.bottom = height; // Set Bottom Value To Requested Height
AdjustWindowRect( &rWindow, dwStyle, false); // Adjust Window To True Requested Size
// Create the window
hWnd = CreateWindow("GameTutorials", strWindowName, dwStyle, 0, 0,
rWindow.right - rWindow.left, rWindow.bottom - rWindow.top,
NULL, NULL, hInstance, NULL);
if(!hWnd) return NULL; // If we could get a handle, return NULL
ShowWindow(hWnd, SW_SHOWNORMAL); // Show the window
UpdateWindow(hWnd); // Draw the window
SetFocus(hWnd); // Sets Keyboard Focus To The Window
return hWnd;
}
///////////////////////////////// SET UP PIXEL FORMAT \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
/////
///// This function sets the pixel format for OpenGL.
/////
///////////////////////////////// SET UP PIXEL FORMAT \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
bool bSetupPixelFormat(HDC hdc)
{
PIXELFORMATDESCRIPTOR pfd;
int pixelformat;
pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR); // Set the size of the structure
pfd.nVersion = 1; // Always set this to 1
// Pass in the appropriate OpenGL flags
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
pfd.dwLayerMask = PFD_MAIN_PLANE; // We want the standard mask (this is ignored anyway)
pfd.iPixelType = PFD_TYPE_RGBA; // We want RGB and Alpha pixel type
pfd.cColorBits = SCREEN_DEPTH; // Here we use our #define for the color bits
pfd.cDepthBits = SCREEN_DEPTH; // Depthbits is ignored for RGBA, but we do it anyway
pfd.cAccumBits = 0; // No special bitplanes needed
pfd.cStencilBits = 0; // We desire no stencil bits
// This gets us a pixel format that best matches the one passed in from the device
if ( (pixelformat = ChoosePixelFormat(hdc, &pfd)) == FALSE )
{
MessageBox(NULL, "ChoosePixelFormat failed", "Error", MB_OK);
return FALSE;
}
// This sets the pixel format that we extracted from above
if (SetPixelFormat(hdc, pixelformat, &pfd) == FALSE)
{
MessageBox(NULL, "SetPixelFormat failed", "Error", MB_OK);
return FALSE;
}
return TRUE; // Return a success!
}
//////////////////////////// RESIZE OPENGL SCREEN \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
/////
///// This function resizes the viewport for OpenGL.
/////
//////////////////////////// RESIZE OPENGL SCREEN \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
void SizeOpenGLScreen(int width, int height) // Initialize The GL Window
{
if (height==0) // Prevent A Divide By Zero error
{
height=1; // Make the Height Equal One
}
glViewport(0,0,width,height); // Make our viewport the whole window
// We could make the view smaller inside
// Our window if we wanted too.
// The glViewport takes (x, y, width, height)
// This basically means, what are our drawing boundaries
glMatrixMode(GL_PROJECTION); // Select The Projection Matrix
glLoadIdentity(); // Reset The Projection Matrix
// Calculate The Aspect Ratio Of The Window
// The parameters are:
// (view angle, aspect ration of the width to the height,
// the closest distance to the camera before it clips,
// FOV // Ratio // the farthest distance before it stops drawing).
gluPerspective(45.0f,(GLfloat)width/(GLfloat)height, .5f ,150.0f);
glMatrixMode(GL_MODELVIEW); // Select The Modelview Matrix
glLoadIdentity(); // Reset The Modelview Matrix
}
///////////////////////////////// INITIALIZE GL \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
/////
///// This function handles all the initialization for OpenGL.
/////
///////////////////////////////// INITIALIZE GL \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
void InitializeOpenGL(int width, int height)
{
g_hDC = GetDC(g_hWnd); // This sets our global HDC
// We don't free this hdc until the end of our program
if (!bSetupPixelFormat(g_hDC)) // This sets our pixel format/information
PostQuitMessage (0); // If there's an error, quit
g_hRC = wglCreateContext(g_hDC); // This creates a rendering context from our hdc
wglMakeCurrent(g_hDC, g_hRC); // This makes the rendering context we just created the one we want to use
glEnable(GL_TEXTURE_2D); // Enables Texture Mapping
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
SizeOpenGLScreen(width, height); // Setup the screen translations and viewport
}
///////////////////////////////// DE INIT \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
/////
///// This function cleans up and then posts a quit message to the window
/////
///////////////////////////////// DE INIT \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
void DeInit()
{
if (g_hRC)
{
wglMakeCurrent(NULL, NULL); // This frees our rendering memory and sets everything back to normal
wglDeleteContext(g_hRC); // Delete our OpenGL Rendering Context
}
if (g_hDC)
ReleaseDC(g_hWnd, g_hDC); // Release our HDC from memory
if(g_bFullScreen) // If we were in full screen
{
ChangeDisplaySettings(NULL,0); // If So Switch Back To The Desktop
ShowCursor(TRUE); // Show Mouse Pointer
}
UnregisterClass("GameTutorials", g_hInstance); // Free the window class
PostQuitMessage (0); // Post a QUIT message to the window
}
///////////////////////////////// WIN MAIN \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
/////
///// This function handles registering and creating the window.
/////
///////////////////////////////// WIN MAIN \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hprev, PSTR cmdline, int ishow)
{
HWND hWnd;
// Check if we want full screen or not
if(MessageBox(NULL, "Click Yes to go to full screen (Recommended)", "Options", MB_YESNO | MB_ICONQUESTION) == IDNO)
g_bFullScreen = false;
// Create our window with our function we create that passes in the:
// name, width, height, any flags for the window, if we want fullscreen of not, and the hInstance.
hWnd = CreateMyWindow("www.GameTutorials.com - OBJ Loader", SCREEN_WIDTH, SCREEN_HEIGHT, 0, g_bFullScreen, hInstance);
// If we never got a valid window handle, quit the program
if(hWnd == NULL) return true;
// INIT OpenGL
Init(hWnd);
// Run our message loop and after it's done, return the result
return (int)MainLoop();
}
/////////////////////////////////////////////////////////////////////////////////
//
// * QUICK NOTES *
//
// This tutorial shows how to load a .obj file. Nothing regarding this tutorial
// was added to this file. It is the standard file for initialization and texture maps.
//
//
//
// Ben Humphrey (DigiBen)
// Game Programmer
// DigiBen@GameTutorials.com
// ©2000-2005 GameTutorials
//
//
| [
"staff@gametutorials.com"
] | staff@gametutorials.com |
3029ab8c4f739d6d75db122af9ac1debdcad793b | 67110b6ee81e0958ae7150687d78a279ddc9a133 | /dlls/hl2_dll/npc_mortarsynth.cpp | 1da8c8d0a79a2f824478dab05000a9f262b510f9 | [] | no_license | ataceyhun/LeakNet-SDK | c383fb8fa555d33c5d3a9e9283590a3a28244745 | aeedaf894a3f5e749e59e80c39600c5fd3e89779 | refs/heads/master | 2020-06-13T19:38:15.198904 | 2016-11-18T11:25:56 | 2016-11-18T11:25:56 | null | 0 | 0 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 31,411 | cpp | //========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================
#include "cbase.h"
#include "beam_shared.h"
#include "npc_mortarsynth.h"
#include "AI_Default.h"
#include "AI_Node.h"
#include "AI_Hull.h"
#include "AI_Hint.h"
#include "AI_Navigator.h"
#include "ai_moveprobe.h"
#include "AI_Memory.h"
#include "Sprite.h"
#include "explode.h"
#include "grenade_energy.h"
#include "ndebugoverlay.h"
#include "game.h"
#include "gib.h"
#include "AI_Interactions.h"
#include "IEffects.h"
#include "vstdlib/random.h"
#include "engine/IEngineSound.h"
#include "movevars_shared.h"
#define MSYNTH_GIB_COUNT 5
#define MSYNTH_ATTACK_NEAR_DIST 600
#define MSYNTH_ATTACK_FAR_DIST 800
#define MSYNTH_COVER_NEAR_DIST 60
#define MSYNTH_COVER_FAR_DIST 250
#define MSYNTH_MAX_SHEILD_DIST 400
#define MSYNTH_BANK_RATE 5
#define MSYNTH_ENERGY_WARMUP_TIME 0.5
#define MSYNTH_MIN_GROUND_DIST 40
#define MSYNTH_MAX_GROUND_DIST 50
#define MSYNTH_GIB_COUNT 5
ConVar sk_mortarsynth_health( "sk_mortarsynth_health","0");
extern float GetFloorZ(const Vector &origin, float fMaxDrop);
//-----------------------------------------------------------------------------
// Private activities.
//-----------------------------------------------------------------------------
int ACT_MSYNTH_FLINCH_BACK;
int ACT_MSYNTH_FLINCH_FRONT;
int ACT_MSYNTH_FLINCH_LEFT;
int ACT_MSYNTH_FLINCH_RIGHT;
//-----------------------------------------------------------------------------
// MSynth schedules.
//-----------------------------------------------------------------------------
enum MSynthSchedules
{
SCHED_MSYNTH_HOVER = LAST_SHARED_SCHEDULE,
SCHED_MSYNTH_PATROL,
SCHED_MSYNTH_CHASE_ENEMY,
SCHED_MSYNTH_CHASE_TARGET,
SCHED_MSYNTH_SHOOT_ENERGY,
};
//-----------------------------------------------------------------------------
// MSynth tasks.
//-----------------------------------------------------------------------------
enum MSynthTasks
{
TASK_ENERGY_WARMUP = LAST_SHARED_TASK,
TASK_ENERGY_SHOOT,
};
//-----------------------------------------------------------------------------
// Custom Conditions
//-----------------------------------------------------------------------------
enum MSynth_Conds
{
COND_MSYNTH_FLY_BLOCKED = LAST_SHARED_CONDITION,
COND_MSYNTH_FLY_CLEAR,
COND_MSYNTH_PISSED_OFF,
};
BEGIN_DATADESC( CNPC_MSynth )
DEFINE_FIELD( CNPC_MSynth, m_lastHurtTime, FIELD_FLOAT ),
DEFINE_FIELD( CNPC_MSynth, m_pEnergyBeam, FIELD_CLASSPTR ),
DEFINE_ARRAY( CNPC_MSynth, m_pEnergyGlow, FIELD_CLASSPTR, MSYNTH_NUM_GLOWS ),
DEFINE_FIELD( CNPC_MSynth, m_fNextEnergyAttackTime, FIELD_TIME),
DEFINE_FIELD( CNPC_MSynth, m_fNextFlySoundTime, FIELD_TIME),
DEFINE_FIELD( CNPC_MSynth, m_vCoverPosition, FIELD_POSITION_VECTOR),
END_DATADESC()
LINK_ENTITY_TO_CLASS( npc_mortarsynth, CNPC_MSynth );
IMPLEMENT_CUSTOM_AI( npc_mortarsynth, CNPC_MSynth );
//-----------------------------------------------------------------------------
// Purpose: Initialize the custom schedules
// Input :
// Output :
//-----------------------------------------------------------------------------
void CNPC_MSynth::InitCustomSchedules(void)
{
INIT_CUSTOM_AI(CNPC_MSynth);
ADD_CUSTOM_TASK(CNPC_MSynth, TASK_ENERGY_WARMUP);
ADD_CUSTOM_TASK(CNPC_MSynth, TASK_ENERGY_SHOOT);
ADD_CUSTOM_SCHEDULE(CNPC_MSynth, SCHED_MSYNTH_HOVER);
ADD_CUSTOM_SCHEDULE(CNPC_MSynth, SCHED_MSYNTH_PATROL);
ADD_CUSTOM_SCHEDULE(CNPC_MSynth, SCHED_MSYNTH_CHASE_ENEMY);
ADD_CUSTOM_SCHEDULE(CNPC_MSynth, SCHED_MSYNTH_CHASE_TARGET);
ADD_CUSTOM_SCHEDULE(CNPC_MSynth, SCHED_MSYNTH_SHOOT_ENERGY);
ADD_CUSTOM_CONDITION(CNPC_MSynth, COND_MSYNTH_FLY_BLOCKED);
ADD_CUSTOM_CONDITION(CNPC_MSynth, COND_MSYNTH_FLY_CLEAR);
ADD_CUSTOM_CONDITION(CNPC_MSynth, COND_MSYNTH_PISSED_OFF);
ADD_CUSTOM_ACTIVITY(CNPC_MSynth, ACT_MSYNTH_FLINCH_BACK);
ADD_CUSTOM_ACTIVITY(CNPC_MSynth, ACT_MSYNTH_FLINCH_FRONT);
ADD_CUSTOM_ACTIVITY(CNPC_MSynth, ACT_MSYNTH_FLINCH_LEFT);
ADD_CUSTOM_ACTIVITY(CNPC_MSynth, ACT_MSYNTH_FLINCH_RIGHT);
AI_LOAD_SCHEDULE(CNPC_MSynth, SCHED_MSYNTH_HOVER);
AI_LOAD_SCHEDULE(CNPC_MSynth, SCHED_MSYNTH_PATROL);
AI_LOAD_SCHEDULE(CNPC_MSynth, SCHED_MSYNTH_CHASE_ENEMY);
AI_LOAD_SCHEDULE(CNPC_MSynth, SCHED_MSYNTH_CHASE_TARGET);
AI_LOAD_SCHEDULE(CNPC_MSynth, SCHED_MSYNTH_SHOOT_ENERGY);
}
CNPC_MSynth::CNPC_MSynth()
{
#ifdef _DEBUG
m_vCurrentBanking.Init();
m_vCoverPosition.Init();
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Indicates this NPC's place in the relationship table.
//-----------------------------------------------------------------------------
Class_T CNPC_MSynth::Classify(void)
{
// return(CLASS_MORTAR_SYNTH);
return CLASS_MORTAR_SYNTH;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_MSynth::StopLoopingSounds(void)
{
StopSound( "NPC_MSynth.Hover" );
StopSound( "NPC_MSynth.WarmUp" );
StopSound( "NPC_MSynth.Shoot" );
BaseClass::StopLoopingSounds();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : Type -
//-----------------------------------------------------------------------------
int CNPC_MSynth::TranslateSchedule( int scheduleType )
{
return BaseClass::TranslateSchedule(scheduleType);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_MSynth::Event_Killed( const CTakeDamageInfo &info )
{
BaseClass::Event_Killed( info );
EnergyKill();
Gib();
}
//------------------------------------------------------------------------------
// Purpose : Override to split in two when attacked
//------------------------------------------------------------------------------
int CNPC_MSynth::OnTakeDamage_Alive( const CTakeDamageInfo &inputInfo )
{
CTakeDamageInfo info = inputInfo;
// Don't take friendly fire from combine
if (info.GetAttacker()->Classify() == CLASS_COMBINE)
{
info.SetDamage( 0 );
}
else
{
// Flinch in the direction of the attack
float vAttackYaw = VecToYaw(g_vecAttackDir);
float vAngleDiff = UTIL_AngleDiff( vAttackYaw, m_fHeadYaw );
if (vAngleDiff > -45 && vAngleDiff < 45)
{
SetActivity((Activity)ACT_MSYNTH_FLINCH_BACK);
}
else if (vAngleDiff < -45 && vAngleDiff > -135)
{
SetActivity((Activity)ACT_MSYNTH_FLINCH_LEFT);
}
else if (vAngleDiff > 45 && vAngleDiff < 135)
{
SetActivity((Activity)ACT_MSYNTH_FLINCH_RIGHT);
}
else
{
SetActivity((Activity)ACT_MSYNTH_FLINCH_FRONT);
}
m_lastHurtTime = gpGlobals->curtime;
}
return (BaseClass::OnTakeDamage_Alive( info ));
}
//-----------------------------------------------------------------------------
// Purpose: Handles movement towards the last move target.
// Input : flInterval -
//-----------------------------------------------------------------------------
bool CNPC_MSynth::OverrideMove(float flInterval)
{
if (IsActivityFinished())
{
SetActivity(ACT_IDLE);
}
// ----------------------------------------------
// Select move target
// ----------------------------------------------
CBaseEntity* pMoveTarget = NULL;
float fNearDist = 0;
float fFarDist = 0;
if (GetTarget() != NULL )
{
pMoveTarget = GetTarget();
fNearDist = MSYNTH_COVER_NEAR_DIST;
fFarDist = MSYNTH_COVER_FAR_DIST;
}
else if (GetEnemy() != NULL )
{
pMoveTarget = GetEnemy();
fNearDist = MSYNTH_ATTACK_NEAR_DIST;
fFarDist = MSYNTH_ATTACK_FAR_DIST;
}
// -----------------------------------------
// See if we can fly there directly
// -----------------------------------------
if (pMoveTarget)
{
trace_t tr;
Vector endPos = GetAbsOrigin() + GetCurrentVelocity()*flInterval;
AI_TraceHull(GetAbsOrigin(), pMoveTarget->GetAbsOrigin() + Vector(0,0,150),
GetHullMins(), GetHullMaxs(), MASK_NPCSOLID_BRUSHONLY,
this, COLLISION_GROUP_NONE, &tr);
if (tr.fraction != 1.0)
{
/*
NDebugOverlay::Cross3D(GetLocalOrigin()+Vector(0,0,-60),Vector(-15,-15,-15),Vector(5,5,5),0,255,255,true,0.1);
*/
SetCondition( COND_MSYNTH_FLY_BLOCKED );
}
else
{
SetCondition( COND_MSYNTH_FLY_CLEAR );
}
}
// -----------------------------------------------------------------
// If I have a route, keep it updated and move toward target
// ------------------------------------------------------------------
if (GetNavigator()->IsGoalActive())
{
// -----------------------------------------------------------------
// Check route is blocked
// ------------------------------------------------------------------
AIMoveTrace_t moveTrace;
GetMoveProbe()->MoveLimit( NAV_FLY, GetLocalOrigin(), GetNavigator()->GetCurWaypointPos(),
MASK_NPCSOLID, GetEnemy(), &moveTrace);
if (IsMoveBlocked( moveTrace ))
{
TaskFail(FAIL_NO_ROUTE);
GetNavigator()->ClearGoal();
return true;
}
// --------------------------------------------------
Vector lastPatrolDir = GetNavigator()->GetCurWaypointPos() - GetLocalOrigin();
if ( ProgressFlyPath( flInterval, GetEnemy(), MASK_NPCSOLID,
!IsCurSchedule( SCHED_MSYNTH_PATROL ) ) == AINPP_COMPLETE )
{
if (IsCurSchedule( SCHED_MSYNTH_PATROL ))
{
m_vLastPatrolDir = lastPatrolDir;
VectorNormalize(m_vLastPatrolDir);
}
return true;
}
}
// ----------------------------------------------
// Move to target directly if path is clear
// ----------------------------------------------
else if ( pMoveTarget && HasCondition( COND_MSYNTH_FLY_CLEAR ) )
{
MoveToEntity(flInterval, pMoveTarget, fNearDist, fFarDist);
}
// -----------------------------------------------------------------
// Otherwise just decelerate
// -----------------------------------------------------------------
else
{
float myDecay = 9.5;
Decelerate( flInterval, myDecay );
// -------------------------------------
// If I have an enemy turn to face him
// -------------------------------------
if (GetEnemy())
{
TurnHeadToTarget(flInterval, GetEnemy()->GetLocalOrigin() );
}
}
MoveExecute_Alive(flInterval);
return true;
}
//------------------------------------------------------------------------------
// Purpose : Override to set pissed level of msynth
// Input :
// Output :
//------------------------------------------------------------------------------
void CNPC_MSynth::NPCThink(void)
{
// --------------------------------------------------
// COND_MSYNTH_PISSED_OFF
// --------------------------------------------------
float fHurtAge = gpGlobals->curtime - m_lastHurtTime;
if (fHurtAge > 5.0)
{
ClearCondition(COND_MSYNTH_PISSED_OFF);
}
else
{
SetCondition(COND_MSYNTH_PISSED_OFF);
}
Vector pos = GetAbsOrigin()+Vector(0,0,-30);
CBroadcastRecipientFilter filter;
te->DynamicLight( filter, 0.0, &pos, 0, 0, 255, 0, 45, 0.1, 50 );
BaseClass::NPCThink();
}
//------------------------------------------------------------------------------
// Purpose : Is head facing the given position
// Input :
// Output :
//------------------------------------------------------------------------------
bool CNPC_MSynth::IsHeadFacing( const Vector &vFaceTarget )
{
float fDesYaw = UTIL_AngleDiff(VecToYaw(vFaceTarget - GetLocalOrigin()), GetLocalAngles().y);
// If I've flipped completely around, reverse angles
float fYawDiff = m_fHeadYaw - fDesYaw;
if (fYawDiff > 180)
{
m_fHeadYaw -= 360;
}
else if (fYawDiff < -180)
{
m_fHeadYaw += 360;
}
if (fabs(m_fHeadYaw - fDesYaw) > 20)
{
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
void CNPC_MSynth::MoveToTarget(float flInterval, const Vector &MoveTarget)
{
const float myAccel = 300.0;
const float myDecay = 9.0;
TurnHeadToTarget( flInterval, MoveTarget );
MoveToLocation( flInterval, MoveTarget, myAccel, (2 * myAccel), myDecay );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
void CNPC_MSynth::MoveToEntity(float flInterval, CBaseEntity* pMoveTarget, float fMinRange, float fMaxRange)
{
// -----------------------------------------
// Make sure we have a move target
// -----------------------------------------
if (!pMoveTarget)
{
return;
}
// -----------------------------------------
// Keep within range of enemy
// -----------------------------------------
Vector vFlyDirection = vec3_origin;
Vector vEnemyDir = pMoveTarget->EyePosition() - GetAbsOrigin();
float fEnemyDist = VectorNormalize(vEnemyDir);
if (fEnemyDist < fMinRange)
{
vFlyDirection = -vEnemyDir;
}
else if (fEnemyDist > fMaxRange)
{
vFlyDirection = vEnemyDir;
}
TurnHeadToTarget( flInterval, pMoveTarget->GetAbsOrigin() );
// -------------------------------------
// Set net velocity
// -------------------------------------
float myAccel = 500.0;
float myDecay = 0.35; // decay to 35% in 1 second
MoveInDirection( flInterval, vFlyDirection, myAccel, 2 * myAccel, myDecay);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
void CNPC_MSynth::PlayFlySound(void)
{
if (gpGlobals->curtime > m_fNextFlySoundTime)
{
EmitSound( "NPC_MSynth.Hover" );
m_fNextFlySoundTime = gpGlobals->curtime + 1.0;
}
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
float CNPC_MSynth::MinGroundDist(void)
{
return MSYNTH_MIN_GROUND_DIST;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
void CNPC_MSynth::SetBanking(float flInterval)
{
// Make frame rate independent
float iRate = 0.5;
float timeToUse = flInterval;
while (timeToUse > 0)
{
Vector vFlyDirection = GetCurrentVelocity();
VectorNormalize(vFlyDirection);
vFlyDirection *= MSYNTH_BANK_RATE;
Vector vBankDir;
// Bank based on fly direction
vBankDir = vFlyDirection;
m_vCurrentBanking.x = (iRate * m_vCurrentBanking.x) + (1 - iRate)*(vBankDir.x);
m_vCurrentBanking.z = (iRate * m_vCurrentBanking.z) + (1 - iRate)*(vBankDir.z);
timeToUse =- 0.1;
}
SetLocalAngles( QAngle( m_vCurrentBanking.x, 0, m_vCurrentBanking.z ) );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
void CNPC_MSynth::MoveExecute_Alive(float flInterval)
{
// ----------------------------------------------------------------------------------------
// Add time-coherent noise to the current velocity so that it never looks bolted in place.
// ----------------------------------------------------------------------------------------
AddNoiseToVelocity();
// -------------------------------------------
// Avoid obstacles
// -------------------------------------------
SetCurrentVelocity( GetCurrentVelocity() + VelocityToAvoidObstacles(flInterval) );
// ---------------------
// Limit overall speed
// ---------------------
LimitSpeed( 200, MSYNTH_MAX_SPEED);
SetBanking(flInterval);
// If I'm right over the ground limit my banking so my blades
// don't sink into the floor
float floorZ = GetFloorZ(GetLocalOrigin());
if (abs(GetLocalOrigin().z - floorZ) < 36)
{
QAngle angles = GetLocalAngles();
if (angles.x < -20) angles.x = -20;
if (angles.x > 20) angles.x = 20;
if (angles.z < -20) angles.z = -20;
if (angles.z > 20) angles.z = 20;
SetLocalAngles( angles );
}
PlayFlySound();
WalkMove( GetCurrentVelocity() * flInterval, MASK_NPCSOLID );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_MSynth::Precache(void)
{
//
// Model.
//
engine->PrecacheModel("models/mortarsynth.mdl");
engine->PrecacheModel("models/gibs/mortarsynth_gibs.mdl");
engine->PrecacheModel("sprites/physbeam.vmt");
engine->PrecacheModel("sprites/glow01.vmt");
engine->PrecacheModel("sprites/physring1.vmt");
UTIL_PrecacheOther("grenade_energy");
BaseClass::Precache();
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CNPC_MSynth::Gib(void)
{
// Sparks
for (int i = 0; i < 4; i++)
{
Vector sparkPos = GetAbsOrigin();
sparkPos.x += random->RandomFloat(-12,12);
sparkPos.y += random->RandomFloat(-12,12);
sparkPos.z += random->RandomFloat(-12,12);
g_pEffects->Sparks(sparkPos);
}
// Smoke
UTIL_Smoke(GetAbsOrigin(), random->RandomInt(10, 15), 10);
// Light
CBroadcastRecipientFilter filter;
te->DynamicLight( filter, 0.0,
&GetAbsOrigin(), 255, 180, 100, 0, 100, 0.1, 0 );
// Throw mortar synth gibs
// CGib::SpawnSpecificGibs( this, MSYNTH_GIB_COUNT, 800, 1000, "models/gibs/mortarsynth_gibs.mdl"); // VXP: Empty gibs model for mortarsynth
ExplosionCreate(GetAbsOrigin(), GetAbsAngles(), NULL, random->RandomInt(30, 40), 0, true);
UTIL_Remove(this);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pTask -
//-----------------------------------------------------------------------------
void CNPC_MSynth::RunTask( const Task_t *pTask )
{
switch ( pTask->iTask )
{
case TASK_ENERGY_WARMUP:
{
// ---------------------------
// Make sure I have an enemy
// -----------------------------
if (GetEnemy() == NULL)
{
EnergyKill();
TaskFail(FAIL_NO_ENEMY);
}
if (gpGlobals->curtime < m_flWaitFinished)
{
// -------------------
// Adjust beam
// -------------------
float fScale = (1-(m_flWaitFinished - gpGlobals->curtime)/MSYNTH_ENERGY_WARMUP_TIME);
if (m_pEnergyBeam)
{
m_pEnergyBeam->SetBrightness(255*fScale);
m_pEnergyBeam->SetColor( 255, 255*fScale, 255*fScale );
}
// -------------------
// Adjust glow
// -------------------
for (int i=0;i<MSYNTH_NUM_GLOWS-1;i++)
{
if (m_pEnergyGlow[i])
{
m_pEnergyGlow[i]->SetColor( 255, 255*fScale, 255*fScale );
m_pEnergyGlow[i]->SetBrightness( 100 + (155*fScale) );
}
}
}
// --------------------
// Face Enemy
// --------------------
if ( gpGlobals->curtime >= m_flWaitFinished &&
IsHeadFacing(GetEnemy()->GetLocalOrigin()) )
{
TaskComplete();
}
break;
}
// If my enemy has moved significantly, update my path
case TASK_WAIT_FOR_MOVEMENT:
{
CBaseEntity *pEnemy = GetEnemy();
if (pEnemy &&
IsCurSchedule(SCHED_MSYNTH_CHASE_ENEMY) &&
GetNavigator()->IsGoalActive() )
{
Vector flEnemyLKP = GetEnemyLKP();
if ((GetNavigator()->GetGoalPos() - pEnemy->EyePosition()).Length() > 40 )
{
GetNavigator()->UpdateGoalPos(pEnemy->EyePosition());
}
// If final position is enemy, exit my schedule (will go to attack hover)
if (GetNavigator()->IsGoalActive() &&
GetNavigator()->GetCurWaypointPos() == pEnemy->EyePosition())
{
TaskComplete();
GetNavigator()->ClearGoal(); // Stop moving
break;
}
}
CAI_BaseNPC::RunTask(pTask);
break;
}
default:
{
CAI_BaseNPC::RunTask(pTask);
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_MSynth::Spawn(void)
{
Precache();
SetModel( "models/mortarsynth.mdl" );
SetHullType(HULL_LARGE_CENTERED);
SetHullSizeNormal();
SetSolid( SOLID_BBOX );
AddSolidFlags( FSOLID_NOT_STANDABLE );
// Make bounce so I bounce off the surfaces I hit, but turn gravity off
SetMoveType( MOVETYPE_STEP );
SetGravity(0.001);
m_iHealth = sk_mortarsynth_health.GetFloat();
SetViewOffset( Vector(0, 0, 10) ); // Position of the eyes relative to NPC's origin.
m_flFieldOfView = 0.2;
m_NPCState = NPC_STATE_NONE;
SetNavType( NAV_FLY );
SetBloodColor( DONT_BLEED );
SetCurrentVelocity( Vector(0, 0, 0) );
m_vCurrentBanking = Vector(0, 0, 0);
AddFlag( FL_FLY );
// This is a flying creature, but it uses grond nodes as it hovers right over the ground
CapabilitiesAdd( bits_CAP_MOVE_GROUND );
CapabilitiesAdd( bits_CAP_SQUAD);
m_vLastPatrolDir = vec3_origin;
m_fNextEnergyAttackTime = 0;
m_fNextFlySoundTime = 0;
m_pEnergyBeam = NULL;
for (int i=0;i<MSYNTH_NUM_GLOWS;i++)
{
m_pEnergyGlow[i] = NULL;
}
SetNoiseMod( 2, 2, 2 );
m_fHeadYaw = 0;
NPCInit();
// Let this guy look far
m_flDistTooFar = 99999999.0;
SetDistLook( 4000.0 );
}
//-----------------------------------------------------------------------------
// Purpose: Gets the appropriate next schedule based on current condition
// bits.
//-----------------------------------------------------------------------------
int CNPC_MSynth::SelectSchedule(void)
{
// Kill laser if its still on
EnergyKill();
switch ( m_NPCState )
{
// -------------------------------------------------
// In idle attemp to pair up with a squad
// member that could use shielding
// -------------------------------------------------
case NPC_STATE_IDLE:
{
// --------------------------------------------------
// If I'm blocked find a path to my goal entity
// --------------------------------------------------
if (HasCondition( COND_MSYNTH_FLY_BLOCKED ) && (GetTarget() != NULL))
{
return SCHED_MSYNTH_CHASE_TARGET;
}
return SCHED_MSYNTH_HOVER;
break;
}
case NPC_STATE_DEAD:
case NPC_STATE_SCRIPT:
{
return BaseClass::SelectSchedule();
break;
}
default:
{
// --------------------------------------------------
// If I'm blocked find a path to my goal entity
// --------------------------------------------------
if (HasCondition( COND_MSYNTH_FLY_BLOCKED ))
{
if ((GetTarget() != NULL) && !HasCondition( COND_MSYNTH_PISSED_OFF))
{
return SCHED_MSYNTH_CHASE_TARGET;
}
else if (GetEnemy() != NULL)
{
return SCHED_MSYNTH_CHASE_ENEMY;
}
}
// --------------------------------------------------
// If I have a live enemy
// --------------------------------------------------
if (GetEnemy() != NULL && GetEnemy()->IsAlive())
{
// --------------------------------------------------
// If I'm not shielding someone or I'm pissed off
// attack my enemy
// --------------------------------------------------
if (GetTarget() == NULL ||
HasCondition( COND_MSYNTH_PISSED_OFF) )
{
// ------------------------------------------------
// If I don't have a line of sight, establish one
// ------------------------------------------------
if (!HasCondition(COND_HAVE_ENEMY_LOS))
{
return SCHED_MSYNTH_CHASE_ENEMY;
}
// ------------------------------------------------
// If I can't attack go for fover
// ------------------------------------------------
else if (gpGlobals->curtime < m_fNextEnergyAttackTime)
{
return SCHED_MSYNTH_HOVER;
}
// ------------------------------------------------
// Otherwise shoot at my enemy
// ------------------------------------------------
else
{
return SCHED_MSYNTH_SHOOT_ENERGY;
}
}
// --------------------------------------------------
// Otherwise hover in place
// --------------------------------------------------
else
{
return SCHED_MSYNTH_HOVER;
}
}
// --------------------------------------------------
// I have no enemy so patrol
// --------------------------------------------------
else if (GetEnemy() == NULL)
{
return SCHED_MSYNTH_HOVER;
}
// --------------------------------------------------
// I have no enemy so patrol
// --------------------------------------------------
else
{
return SCHED_MSYNTH_PATROL;
}
break;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pTask -
//-----------------------------------------------------------------------------
void CNPC_MSynth::StartTask( const Task_t *pTask )
{
switch (pTask->iTask)
{
// Create
case TASK_ENERGY_WARMUP:
{
if (GetEnemy() == NULL)
{
TaskFail(FAIL_NO_ENEMY);
}
else
{
GetMotor()->SetIdealYawToTarget( GetEnemy()->GetLocalOrigin() );
SetTurnActivity();
EnergyWarmup();
// set a future time that tells us when the warmup is over.
m_flWaitFinished = gpGlobals->curtime + MSYNTH_ENERGY_WARMUP_TIME;
}
break;
}
case TASK_ENERGY_SHOOT:
{
EnergyShoot();
TaskComplete();
break;
}
// Override so can find hint nodes that are much further away
case TASK_FIND_HINTNODE:
{
if (!m_pHintNode )
{
m_pHintNode = CAI_Hint::FindHint( this, HINT_NONE, pTask->flTaskData, 5000 );
}
if ( m_pHintNode)
{
TaskComplete();
}
else
{
// No hint node run from enemy
SetSchedule( SCHED_RUN_FROM_ENEMY );
}
break;
}
default:
{
BaseClass::StartTask(pTask);
}
}
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CNPC_MSynth::EnergyWarmup(void)
{
// -------------------
// Beam beams
// -------------------
m_pEnergyBeam = CBeam::BeamCreate( "sprites/physbeam.vmt", 2.0 );
m_pEnergyBeam->SetColor( 255, 0, 0 );
m_pEnergyBeam->SetBrightness( 100 );
m_pEnergyBeam->SetNoise( 8 );
m_pEnergyBeam->EntsInit( this, this );
m_pEnergyBeam->SetStartAttachment( 1 );
m_pEnergyBeam->SetEndAttachment( 2 );
// -------------
// Glow
// -------------
m_pEnergyGlow[0] = CSprite::SpriteCreate( "sprites/glow01.vmt", GetLocalOrigin(), FALSE );
m_pEnergyGlow[0]->SetAttachment( this, 1 );
m_pEnergyGlow[0]->SetTransparency( kRenderGlow, 255, 255, 255, 0, kRenderFxNoDissipation );
m_pEnergyGlow[0]->SetBrightness( 100 );
m_pEnergyGlow[0]->SetScale( 0.3 );
m_pEnergyGlow[1] = CSprite::SpriteCreate( "sprites/glow01.vmt", GetLocalOrigin(), FALSE );
m_pEnergyGlow[1]->SetAttachment( this, 2 );
m_pEnergyGlow[1]->SetTransparency( kRenderGlow, 255, 255, 255, 0, kRenderFxNoDissipation );
m_pEnergyGlow[1]->SetBrightness( 100 );
m_pEnergyGlow[1]->SetScale( 0.3 );
EmitSound( "NPC_MSynth.WarmUp" );
// After firing sit still for a second to make easier to hit
SetCurrentVelocity( vec3_origin );
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CNPC_MSynth::EnergyShoot(void)
{
CBaseEntity* pEnemy = GetEnemy();
if (pEnemy)
{
//<<TEMP>> need new sound
EmitSound( "NPC_MSynth.EnergyShoot" );
for (int i=1;i<3;i++)
{
Vector vShootStart;
QAngle vShootAng;
GetAttachment( i, vShootStart, vShootAng );
Vector vShootDir = ( pEnemy->EyePosition() ) - vShootStart;
VectorNormalize(vShootDir);
CGrenadeEnergy::Shoot( this, vShootStart, vShootDir * 800 );
}
}
EmitSound( "NPC_MSynth.Shoot" );
if (m_pEnergyBeam)
{
// Let beam kill itself
m_pEnergyBeam->LiveForTime(0.2);
m_pEnergyBeam = NULL;
}
m_fNextEnergyAttackTime = gpGlobals->curtime + random->RandomFloat(1.8,2.2);
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CNPC_MSynth::EnergyKill(void)
{
// -------------------------------
// Kill beams if not set to die
// ------------------------------
if (m_pEnergyBeam)
{
UTIL_Remove(m_pEnergyBeam);
m_pEnergyBeam = NULL;
}
// ---------------------
// Kill laser
// ---------------------
for (int i=0;i<MSYNTH_NUM_GLOWS;i++)
{
if (m_pEnergyGlow[i])
{
UTIL_Remove( m_pEnergyGlow[i] );
m_pEnergyGlow[i] = NULL;
}
}
// Kill charge sound in case still going
StopSound(entindex(), "NPC_MSynth.WarmUp" );
}
//------------------------------------------------------------------------------
//
// Schedules
//
//------------------------------------------------------------------------------
//=========================================================
// > SCHED_MSYNTH_HOVER
//=========================================================
AI_DEFINE_SCHEDULE
(
SCHED_MSYNTH_HOVER,
" Tasks"
" TASK_WAIT 5"
""
" Interrupts"
" COND_NEW_ENEMY"
" COND_MSYNTH_FLY_BLOCKED"
);
//=========================================================
// > SCHED_MSYNTH_SHOOT_ENERGY
//
// Shoot and go for cover
//=========================================================
AI_DEFINE_SCHEDULE
(
SCHED_MSYNTH_SHOOT_ENERGY,
" Tasks"
" TASK_ENERGY_WARMUP 0"
" TASK_ENERGY_SHOOT 0"
//" TASK_SET_SCHEDULE SCHEDULE:SCHED_TAKE_COVER_FROM_ENEMY"
""
" Interrupts"
" COND_ENEMY_DEAD"
);
//=========================================================
// > SCHED_MSYNTH_PATROL
//=========================================================
AI_DEFINE_SCHEDULE
(
SCHED_MSYNTH_PATROL,
" Tasks"
" TASK_SET_TOLERANCE_DISTANCE 48"
" TASK_SET_ROUTE_SEARCH_TIME 5" // Spend 5 seconds trying to build a path if stuck
" TASK_GET_PATH_TO_RANDOM_NODE 2000"
" TASK_RUN_PATH 0"
" TASK_WAIT_FOR_MOVEMENT 0"
""
" Interrupts"
" COND_GIVE_WAY"
" COND_NEW_ENEMY"
" COND_SEE_ENEMY"
" COND_SEE_FEAR"
" COND_HEAR_COMBAT"
" COND_HEAR_DANGER"
" COND_HEAR_PLAYER"
" COND_LIGHT_DAMAGE"
" COND_HEAVY_DAMAGE"
" COND_PROVOKED"
);
//=========================================================
// > SCHED_MSYNTH_CHASE_ENEMY
//=========================================================
AI_DEFINE_SCHEDULE
(
SCHED_MSYNTH_CHASE_ENEMY,
" Tasks"
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_MSYNTH_PATROL"
" TASK_SET_TOLERANCE_DISTANCE 120"
" TASK_GET_PATH_TO_ENEMY 0"
" TASK_RUN_PATH 0"
" TASK_WAIT_FOR_MOVEMENT 0"
""
" Interrupts"
" COND_ENEMY_DEAD"
" COND_MSYNTH_FLY_CLEAR"
);
//=========================================================
// > SCHED_MSYNTH_CHASE_TARGET
//=========================================================
AI_DEFINE_SCHEDULE
(
SCHED_MSYNTH_CHASE_TARGET,
" Tasks"
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_MSYNTH_HOVER"
" TASK_SET_TOLERANCE_DISTANCE 120"
" TASK_GET_PATH_TO_TARGET 0"
" TASK_RUN_PATH 0"
" TASK_WAIT_FOR_MOVEMENT 0"
""
" Interrupts"
" COND_MSYNTH_FLY_CLEAR"
" COND_MSYNTH_PISSED_OFF"
);
| [
"uavxp29@gmail.com"
] | uavxp29@gmail.com |
e43e01fe7f520bd2de02912b7e59536de0f65a44 | bc897e397bb4b726430f8f188d26aa857f0917d9 | /dipple/qml-box2d-qml-box2d/box2dbody.h | c2c7b85e7e84b410c0e993369eb3ddc56929f719 | [
"Zlib"
] | permissive | jga9000/Dipple | 449356a856e31a9b265ea7bf238a9f420635b570 | 37787a6293f2e825dd2853572fc5541c9fe05ce5 | refs/heads/master | 2016-09-06T16:50:45.588370 | 2013-03-13T08:37:43 | 2013-03-13T08:37:43 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,947 | h | /*
* box2dbody.h
* Copyright (c) 2010-2011 Thorbjørn Lindeijer <thorbjorn@lindeijer.nl>
* Copyright (c) 2011 Daker Fernandes Pinheiro <daker.pinheiro@openbossa.org>
* Copyright (c) 2011 Tan Miaoqing <miaoqing.tan@nokia.com>
* Copyright (c) 2011 Antonio Aloisio <antonio.aloisio@nokia.com>
* Copyright (c) 2011 Joonas Erkinheimo <joonas.erkinheimo@nokia.com>
* Copyright (c) 2011 Antti Krats <antti.krats@digia.com>
*
* This file is part of the Box2D QML plugin.
*
* This software is provided 'as-is', without any express or implied warranty.
* In no event will the authors be held liable for any damages arising from
* the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software in
* a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
*
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
*
* 3. This notice may not be removed or altered from any source distribution.
*/
#ifndef BOX2DBODY_H
#define BOX2DBODY_H
#include <QQuickItem>
class Box2DFixture;
class Box2DWorld;
class b2Body;
class b2World;
/**
* The Box2D body, build up from a list of shapes.
*/
class Box2DBody : public QQuickItem
{
Q_OBJECT
Q_ENUMS(BodyType)
Q_PROPERTY(qreal linearDamping READ linearDamping WRITE setLinearDamping NOTIFY linearDampingChanged)
Q_PROPERTY(qreal angularDamping READ angularDamping WRITE setAngularDamping NOTIFY angularDampingChanged)
Q_PROPERTY(BodyType bodyType READ bodyType WRITE setBodyType NOTIFY bodyTypeChanged)
Q_PROPERTY(bool bullet READ isBullet WRITE setBullet NOTIFY bulletChanged)
Q_PROPERTY(bool sleepingAllowed READ sleepingAllowed WRITE setSleepingAllowed NOTIFY sleepingAllowedChanged)
Q_PROPERTY(bool fixedRotation READ fixedRotation WRITE setFixedRotation NOTIFY fixedRotationChanged)
Q_PROPERTY(bool active READ active WRITE setActive)
Q_PROPERTY(QPointF linearVelocity READ linearVelocity WRITE setLinearVelocity NOTIFY linearVelocityChanged)
Q_PROPERTY(QQmlListProperty<Box2DFixture> fixtures READ fixtures)
public:
enum BodyType {
Static,
Kinematic,
Dynamic
};
explicit Box2DBody(QQuickItem *parent = 0);
~Box2DBody();
qreal linearDamping() const { return mLinearDamping; }
void setLinearDamping(qreal linearDamping);
qreal angularDamping() const { return mAngularDamping; }
void setAngularDamping(qreal angularDamping);
BodyType bodyType() const { return mBodyType; }
void setBodyType(BodyType bodyType);
bool isBullet() const { return mBullet; }
void setBullet(bool bullet);
bool sleepingAllowed() const { return mSleepingAllowed; }
void setSleepingAllowed(bool allowed);
bool fixedRotation() const { return mFixedRotation; }
void setFixedRotation(bool fixedRotation);
bool active() const { return mActive; }
void setActive(bool active);
QPointF linearVelocity() const { return mLinearVelocity; }
void setLinearVelocity(const QPointF &linearVelocity);
QQmlListProperty<Box2DFixture> fixtures();
void initialize(b2World *world);
void synchronize();
void cleanup(b2World *world);
Q_INVOKABLE void applyLinearImpulse(const QPointF &impulse,
const QPointF &point);
Q_INVOKABLE void applyTorque(qreal torque);
Q_INVOKABLE QPointF getWorldCenter() const;
void componentComplete();
b2Body *body() const;
// Added by Jukka
Q_INVOKABLE void changePosition(int xPos, int yPos);
Q_INVOKABLE void stop();
Q_INVOKABLE void activate();
Q_INVOKABLE void move(int x, int y, int x2, int y2);
protected:
void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry);
signals:
void linearDampingChanged();
void angularDampingChanged();
void bodyTypeChanged();
void bulletChanged();
void sleepingAllowedChanged();
void fixedRotationChanged();
void linearVelocityChanged();
void bodyCreated();
void unregisterBody();
private slots:
void onRotationChanged();
private:
static void append_fixture(QQmlListProperty<Box2DFixture> *list,
Box2DFixture *fixture);
b2Body *mBody;
b2World *mWorld;
qreal mLinearDamping;
qreal mAngularDamping;
BodyType mBodyType;
bool mBullet;
bool mSleepingAllowed;
bool mFixedRotation;
bool mActive;
QPointF mLinearVelocity;
bool mSynchronizing;
bool mInitializePending;
QList<Box2DFixture*> mFixtures;
};
#endif // BOX2DBODY_H
| [
"jukkhama@gmail.com"
] | jukkhama@gmail.com |
bdd1d53d478a930b2e14d67516a28b91f158a44a | 9884a5a7fbbdde2d26ba728fa595358a4a785229 | /chrome/browser/search/background/ntp_background_service_factory.cc | f136176e9bb52184fc6afc2b061e8f325b47bee4 | [
"BSD-3-Clause"
] | permissive | darius-iko/chromium | 3d560da5f0bf75a463d58f9a9827355e81a86090 | 2aa9fa878859e42e15cacf755b6fc41b85e0fa35 | refs/heads/master | 2022-12-31T00:07:06.483046 | 2020-10-29T12:48:26 | 2020-10-29T12:48:26 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,840 | cc | // Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/search/background/ntp_background_service_factory.h"
#include <string>
#include "base/feature_list.h"
#include "base/metrics/field_trial_params.h"
#include "base/optional.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/search/background/ntp_background_service.h"
#include "chrome/browser/search/ntp_features.h"
#include "components/keyed_service/content/browser_context_dependency_manager.h"
#include "content/public/browser/browser_context.h"
#include "content/public/browser/storage_partition.h"
// static
NtpBackgroundService* NtpBackgroundServiceFactory::GetForProfile(
Profile* profile) {
return static_cast<NtpBackgroundService*>(
GetInstance()->GetServiceForBrowserContext(profile, true));
}
// static
NtpBackgroundServiceFactory* NtpBackgroundServiceFactory::GetInstance() {
return base::Singleton<NtpBackgroundServiceFactory>::get();
}
NtpBackgroundServiceFactory::NtpBackgroundServiceFactory()
: BrowserContextKeyedServiceFactory(
"NtpBackgroundService",
BrowserContextDependencyManager::GetInstance()) {}
NtpBackgroundServiceFactory::~NtpBackgroundServiceFactory() = default;
KeyedService* NtpBackgroundServiceFactory::BuildServiceInstanceFor(
content::BrowserContext* context) const {
// TODO(crbug.com/914898): Background service URLs should be
// configurable server-side, so they can be changed mid-release.
auto url_loader_factory =
content::BrowserContext::GetDefaultStoragePartition(context)
->GetURLLoaderFactoryForBrowserProcess();
return new NtpBackgroundService(url_loader_factory);
}
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
74a2a4ec133ccdaf3e46805705176569a66d28e9 | 0da1f47a5cf52d0665571b997e1b27c9d19d0b41 | /QExamineMach/QExamineMach/Logic/QWeightMeasureDelegate.cpp | 90b50c765f35e42c9cc2ff0de1a1717609bfbfc2 | [] | no_license | lxw1775/ExamineMach_2020.09.06_Qt | 485c370bea2df0d72029cdf9d3f87e51b65b48bd | 03254de15577d86bf638f63da8d1bb072e83f1f0 | refs/heads/master | 2022-12-25T00:57:09.430776 | 2020-10-07T10:09:31 | 2020-10-07T10:09:31 | 293,187,318 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,375 | cpp | #include "QWeightMeasureDelegate.h"
#include "QWeightMeasure_Youjian.h"
#include "common.h"
#include <QSettings>
#include <QDebug>
QWeightMeasureDelegate* QWeightMeasureDelegate::m_instance_ptr = nullptr;
QWeightMeasureDelegate* QWeightMeasureDelegate::GetInstance()
{
if (m_instance_ptr == nullptr) {
m_instance_ptr = new QWeightMeasureDelegate();
}
return m_instance_ptr;
}
QWeightMeasureDelegate::QWeightMeasureDelegate(QObject* parent)
: QObject(parent)
{
m_pQWeightMeasure_Youjian = new QWeightMeasure_Youjian;
// 根据ini文件路径新建QSettings类
QSettings m_IniFile(getLocalCfgPath(), QSettings::IniFormat);
m_port = m_IniFile.value("SerialPort/Weight").toString();
}
QWeightMeasureDelegate::~QWeightMeasureDelegate()
{
if (m_pQWeightMeasure_Youjian)
{
delete m_pQWeightMeasure_Youjian;
m_pQWeightMeasure_Youjian = NULL;
}
}
int QWeightMeasureDelegate::start()
{
if (!m_pQWeightMeasure_Youjian)
return -1;
if (m_port == "")
{
qCritical() << "Weight Meausre start error, port=null";//日志
return -1;
}
int iRet = m_pQWeightMeasure_Youjian->weightMeasureStart(m_port);
if (iRet != 0)
{
qCritical() << "QWeightMeasure_Youjian start error, ret=" << iRet;//日志
return iRet;
}
return iRet;
}
void QWeightMeasureDelegate::stop()
{
if (!m_pQWeightMeasure_Youjian)
return;
return m_pQWeightMeasure_Youjian->stop();
} | [
"875121629@qq.com"
] | 875121629@qq.com |
9596511ffa57d1c6212de3807de0c2b698455d15 | a76fc4b155b155bb59a14a82b5939a30a9f74eca | /ATPrintPDF/Composite/JFCDrawBeginPath.h | bb2f9265f24d39f81ef1e08dc9cb35f7b87f6a6d | [] | no_license | isliulin/JFC-Tools | aade33337153d7cc1b5cfcd33744d89fe2d56b79 | 98b715b78ae5c01472ef595b1faa5531f356e794 | refs/heads/master | 2023-06-01T12:10:51.383944 | 2021-06-17T14:41:07 | 2021-06-17T14:41:07 | null | 0 | 0 | null | null | null | null | ISO-8859-1 | C++ | false | false | 849 | h | //================================
// fichier: JFCDrawBeginPath.h
//
// date: 02/09/2001
// auteur: JB
//================================
// on teste si la macro qui identifie le fichier est déjà définie
#ifndef _JFCDRAWBEGINPATH_H_
// on définit une macro pour identifier le fichier
#define _JFCDRAWBEGINPATH_H_
// on inclut les fichiers nécessaires
#include "JFCDrawComponent.h"
class DrawBeginPath : public DrawComponent
{
public:
// le constructeur
DrawBeginPath();
// le constructeur de recopie
DrawBeginPath(const DrawBeginPath & source);
// la fonction pour dessiner le composant
void Draw(JFCDraw * pDraw, long firstpage, long lastpage);
// la fonction de clonage
DrawComponent * Clone() const;
// le destructeur
~DrawBeginPath();
protected:
// pas d'argument pour cette commande
};
// fin du test sur la macro
#endif | [
"damien.bodenes@kantarmedia.com"
] | damien.bodenes@kantarmedia.com |
df8773c12b5c7a18af820ed0054da9a77d3878a7 | 7f1344dee215117b0e48dd2d05089447c191bcaa | /src/conversions/keplerian.cpp | c3c2578d543a36a70c197756dbc4bebba7ebf83f | [
"MIT"
] | permissive | maxhlc/thames | b9302eab7f558df9920d51b35aa9c6f96844d788 | 987b63107d28c21599ca1c68e5679976f8c3edeb | refs/heads/main | 2023-04-07T11:18:20.152799 | 2022-11-15T10:30:01 | 2022-11-15T10:30:01 | 435,660,220 | 2 | 0 | null | 2022-11-15T10:30:03 | 2021-12-06T21:58:10 | C++ | UTF-8 | C++ | false | false | 6,254 | cpp | /*
MIT License
Copyright (c) 2021-2022 Max Hallgarten La Casta
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 <array>
#include <cmath>
#include <vector>
#include "../../include/conversions/keplerian.h"
#include "../../include/vector/arithmeticoverloads.h"
#include "../../include/vector/geometry.h"
namespace thames::conversions::keplerian {
using namespace thames::vector::arithmeticoverloads;
///////////
// Reals //
///////////
template<class T>
std::vector<T> cartesian_to_keplerian(const std::vector<T>& RV, const T& mu){
// Extract position and velocity vectors
std::vector<T> R = {RV[0], RV[1], RV[2]};
std::vector<T> V = {RV[3], RV[4], RV[5]};
// Declare units vectors
const std::vector<T> K = {0.0, 0.0, 1.0};
// Set constants
const double atol = 1e-12;
// Calculate state magnitudes
T r = thames::vector::geometry::norm3(R);
T v = thames::vector::geometry::norm3(V);
// Calculate semi-major axis
T sma = 1.0/(2.0/r - pow(v, 2.0)/mu);
// Calculate angular momentum vector and magnitude
std::vector<T> H = thames::vector::geometry::cross3(R, V);
T h = thames::vector::geometry::norm3(H);
// Calculate eccentricity vector and magnitude
std::vector<T> E = thames::vector::geometry::cross3(V, H)/mu - R/r;
T e = thames::vector::geometry::norm3(E);
// Calculate inclination
T inc = acos(H[2]/h);
// Check for circular and equatorial orbits
bool e_near = fabs(e) < atol;
bool inc_near = fabs(inc) < atol;
// Calculate right ascension of the ascending node
std::vector<T> N = thames::vector::geometry::cross3(K, H);
T n = thames::vector::geometry::norm3(N);
T raan;
if (inc_near) {
raan = 0.0;
} else {
raan = acos(N[0]/n);
if(N[1] < 0.0){
raan = 2.0*M_PI - raan;
}
}
// Calculate argument of periapsis
T aop;
if (inc_near & e_near) {
aop = 0.0;
} else if (inc_near) {
aop = atan2(E[1], E[0]);
if(H[2] < 0.0){
aop = 2.0*M_PI - aop;
}
} else {
aop = acos(thames::vector::geometry::dot3(N, E)/(n*e));
if(E[2] < 0.0){
aop = 2.0*M_PI - aop;
}
}
// Calculate true anomaly
T ta;
if (inc_near & e_near) {
ta = acos(R[0]/r);
if (V[0] > 0.0) {
ta = 2.0*M_PI - ta;
}
} else if (e_near) {
ta = acos(thames::vector::geometry::dot3(N, R)/(n*r));
if (R[2] < 0.0) {
ta = 2.0*M_PI - ta;
}
} else {
ta = acos(thames::vector::geometry::dot3(E, R)/(e*r));
if (thames::vector::geometry::dot3(R, V) < 0.0) {
ta = 2.0*M_PI - ta;
}
}
// Store elements in the Keplerian elements vector
std::vector<T> keplerian = {
sma,
e,
inc,
raan,
aop,
ta
};
// Return Keplerian elements vector
return keplerian;
}
template std::vector<double> cartesian_to_keplerian<double>(const std::vector<double>&, const double&);
template<class T>
std::vector<T> keplerian_to_cartesian(const std::vector<T>& keplerian, const T& mu){
// Extract Keplerian elements
T sma = keplerian[0];
T e = keplerian[1];
T inc = keplerian[2];
T raan = keplerian[3];
T aop = keplerian[4];
T ta = keplerian[5];
// Calculate angle trigs
T cinc = cos(inc), sinc = sin(inc);
T craan = cos(raan), sraan = sin(raan);
T caop = cos(aop), saop = sin(aop);
T cta = cos(ta), sta = sin(ta);
// Calculate eccentric anomaly
T E = 2.0*atan(sqrt((1.0 - e)/(1.0 + e))*tan(ta/2.0));
// Calculate radial distance
T r = sma*(1.0 - pow(e, 2.0))/(1.0 + e*cta);
// Calculate position and velocity vectors in the orbital frame
std::vector<T> o = {
r*cta,
r*sta,
0.0
};
T fac = sqrt(mu*sma)/r;
std::vector<T> dodt = {
-fac*sin(E),
fac*sqrt(1.0 - pow(e, 2.0))*cos(E),
0.0
};
// Calculate rotation angles
T ang[3][2];
ang[0][0] = caop*craan - saop*cinc*sraan;
ang[0][1] = -saop*craan - caop*cinc*sraan;
ang[1][0] = caop*sraan + saop*cinc*craan;
ang[1][1] = caop*cinc*craan - saop*sraan;
ang[2][0] = saop*sinc;
ang[2][1] = caop*sinc;
// Transform the position and velocity vectors to the inertial frame
std::vector<T> RV(6);
for(unsigned int ii=0; ii<3; ii++){
RV[ii] = o[0]*ang[ii][0] + o[1]*ang[ii][1];
RV[ii+3] = dodt[0]*ang[ii][0] + dodt[1]*ang[ii][1];
}
// Return Cartesian state
return RV;
}
template std::vector<double> keplerian_to_cartesian<double>(const std::vector<double>&, const double&);
} | [
"34109153+maxhlc@users.noreply.github.com"
] | 34109153+maxhlc@users.noreply.github.com |
6ca8ea6098f7add52b7420e1d60f2f5f6ec3ed63 | 95585203a62d03bea6cc6e91d653f2c980f4fee5 | /textdisplay.cc | 244e3e60a94a5255553de3d8b10a2afb6e436666 | [] | no_license | wzn997859196/a5-watopoly | 0336c68e8e65cd09b118a2536b5df8bed730f611 | ca6d434ac502cb4787f6994ba3a592fe7dbc89f4 | refs/heads/master | 2020-12-30T15:29:10.897660 | 2017-05-13T01:59:09 | 2017-05-13T01:59:09 | 91,142,486 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,868 | cc | #include "textdisplay.h"
#include <iostream>
#include <iomanip>
#include <string>
using namespace std;
textDisplay::textDisplay(){
squares[0] = " ";
squares[1] = "AL";
squares[2] = " ";
squares[3] = "ML";
squares[4] = " ";
squares[5] = " ";
squares[6] = "ECH";
squares[7] = " ";
squares[8] = "PAS";
squares[9] = "HH";
squares[10] = " ";
squares[11] = "RCH";
squares[12] = " ";
squares[13] = "DWE";
squares[14] = "CPH";
squares[15] = " ";
squares[16] = "LHI";
squares[17] = " ";
squares[18] = "BMH";
squares[19] = "OPT";
squares[20] = " ";
squares[21] = "EV1";
squares[22] = " ";
squares[23] = "EV2";
squares[24] = "EV3";
squares[25] = " ";
squares[26] = "PHYS";
squares[27] = "B1";
squares[28] = " ";
squares[29] = "B2";
squares[30] = " ";
squares[31] = "EIT";
squares[32] = "ESC";
squares[33] = " ";
squares[34] = "C2";
squares[35] = " ";
squares[36] = " ";
squares[37] = "MC";
squares[38] = " ";
squares[39] = "DC";
for (int i = 0; i < 40; i++){
for(int j = 0; j < 8; j++){
playerPos[i][j] = ' ';
}
}
for (int i = 0; i < 40; i++){
improv[i] = 0;
}
}
textDisplay::~textDisplay(){}
void textDisplay::notifyJoin(char newplayer){
if(newplayer == 'G') { playerPos[0][0] = newplayer; }
else if (newplayer == 'B') { playerPos[0][1] = newplayer; }
else if (newplayer == 'D') { playerPos[0][2] = newplayer; }
else if (newplayer == 'P') { playerPos[0][3] = newplayer; }
else if (newplayer == 'S') { playerPos[0][4] = newplayer; }
else if (newplayer == '$') { playerPos[0][5] = newplayer; }
else if (newplayer == 'L') { playerPos[0][6] = newplayer; }
else if (newplayer == 'T') { playerPos[0][7] = newplayer; }
}
void textDisplay::notifyMove(char player, const int curPos, const int newPos){
int player_ind;
if(player == 'G') { player_ind = 0; }
else if (player == 'B') { player_ind = 1; }
else if (player == 'D') { player_ind = 2; }
else if (player == 'P') { player_ind = 3; }
else if (player == 'S') { player_ind = 4; }
else if (player == '$') { player_ind = 5; }
else if (player == 'L') { player_ind = 6; }
else if (player == 'T') { player_ind = 7; }
playerPos[curPos][player_ind] = ' ';
playerPos[newPos][player_ind] = player;
}
void textDisplay::notifyImprov(int pos, bool action){ // ture is buy. false is sell
if(action) ++improv[pos];
else --improv[pos];
}
void textDisplay::print() const{
//first line
cout.fill('_');
cout.width(100);
cout << "";
cout << endl;
for(int i = 20; i < 31; i++){
cout << "|";
cout.fill(' ');
cout.width(8);
if(i == 20) { cout << left << "GOOSE"; }
else if(i == 22) { cout << left << "NEEDLES"; }
else if(i == 25) { cout << left << "V1"; }
else if(i == 28) { cout << left << "CIF"; }
else if(i == 30) { cout << left << "GO TO"; }
else {
string improvments = "";
for(int j = 0; j < improv[i]; j++){
improvments.append("I");
}
cout.fill(' ');
cout.width(8);
cout << left << improvments;
}
}
cout << "|" << endl;
for(int i = 20; i < 31; i++){
cout << "|";
cout.fill(' ');
cout.width(8);
if (i == 20) { cout << left << "NESTING"; }
else if(i == 22) { cout << left << "HALL"; }
else if(i == 25) { cout << left << ""; }
else if(i == 28) { cout << left << ""; }
else if(i == 30) { cout << left << "TIMS"; }
else { cout << "--------"; }
}
cout << "|" << endl;
for(int i = 20; i < 31; i++){
cout << "|";
cout.fill(' ');
cout.width(8);
cout << left << squares[i];
}
cout << "|" << endl;
// player position in first line
for(int i = 20; i < 31; i++){
cout << "|";
//cout.fill(' ');//add
//cout.width(7);//add
for(int j = 0; j < 8; j++){
cout << playerPos[i][j];
}
}
cout << "|" << endl;
for(int i = 20; i < 31; i++){
cout << "|________";
}
cout << "|" << endl;
//second part
int leftside,rightside;
for(int line = 1; line < 10; line++){
leftside = 20 - line;
rightside = 30 + line;
for(int i = 0; i < 11; i++){
if(i == 0){
if(squares[leftside] == " "){
if(leftside == 17){
cout << left << "|SLC ";
} else if(leftside == 15){
cout << left << "|UWP ";
} else if(leftside == 12){
cout << left << "|SLC ";
}
} else{
cout << "|";
string improvments = "";
for(int j = 0; j < improv[leftside]; i++){
improvments.append("I");
}
cout.fill(' ');
cout.width(8);
cout << left << improvments;
}
} else if(i == 1) {
cout << "| ";
} else if(i == 9) {
cout << " |";
} else if(i == 10) {
if(squares[rightside] == " "){
if(rightside == 33) {
cout << left << "SLC ";
} else if(rightside == 35){
cout << left << "REV ";
} else if(rightside == 36){
cout << left << "NEEDLES ";
} else if(rightside == 38){
cout << left << "COOP ";
}
cout << "|";
} else{
string improvments = "";
for(int j = 0; j < improv[rightside]; j++){
improvments.append("I");
}
cout.fill(' ');
cout.width(8);
cout << left << improvments;
cout << "|";
}
} else{
cout << " ";
}
}
cout << endl;
for(int i = 0; i < 11; i++){
if(i == 0){
if((leftside == 17) || (leftside == 15) || (leftside == 12)){
cout << "|";
cout.fill(' ');
cout.width(8);
cout << "";
} else{
cout << "|";
cout.fill('-');
cout.width(8);
cout << "";
}
} else if(i == 1){
cout << "| ";
} else if(i == 9){
cout << " |";
} else if(i == 10){
if(squares[rightside] == " "){
if(rightside == 36){
cout.fill(' ');
cout.width(8);
cout << left << "HALL";
cout << "|";
} else if(rightside == 38){
cout.fill(' ');
cout.width(8);
cout << left << "FEE";
cout << "|";
} else{
cout.fill(' ');
cout.width(9);
cout << right << "|";
}
} else{
cout.fill('-');
cout.width(9);
cout << right << "|";
}
} else{
cout << " ";
}
}
cout << endl;
for(int i = 0; i < 11; i++){
if(i == 0){
cout << "|";
cout.fill(' ');
cout.width(8);
cout << left << squares[leftside];
} else if(i == 1){
cout << "| ";
} else if(i == 9){
cout << " |";
} else if(i == 10){
cout.fill(' ');
cout.width(8);
cout << left << squares[rightside];
cout << "|";
} else {
cout << " ";
}
}
cout << endl;
for(int i = 0; i < 11; i++){
if(i == 0){
cout << "|";
//cout.fill(' ');//add
//cout.width(7);//add
for(int j = 0; j < 8; j++){
cout << playerPos[leftside][j];
}
//cout << " ";
} else if(i == 1){
cout << "| ";
} else if(i == 9){
cout << " |";
} else if(i == 10){
//cout << " ";
//cout.fill(' ');//add
//cout.width(7);//add
for(int j = 0; j < 8; j++){
cout << playerPos[rightside][j];
}
cout << "|";
} else{
cout << " ";
}
}
cout << endl;
for(int i = 0; i < 11; i++){
if(i == 0){
cout << "|________";
} else if(i == 1){
if (line == 9){
cout << "|________";
} else {
cout << "| ";
}
} else if(i == 9){
if (line == 9){
cout << "_________|";
} else {
cout << " |";
}
} else if(i == 10){
cout.fill('_');
cout.width(8);
cout << "";
cout << "|";
} else{
if (line == 9){
cout << "_________";
} else {
cout << " ";
}
}
}
cout << endl;
}
//last line
for (int i = 10; i > -1; i--){
cout << "|";
cout.fill(' ');
cout.width(8);
if(i == 10){ cout << left << "DC TIMS"; }
else if(i == 7) { cout << left << "NEEDLES"; }
else if(i == 5) { cout << left << "MKV"; }
else if(i == 4) { cout << left << "TUITION"; }
else if(i == 2) { cout << left << "SLC"; }
else if(i == 0) { cout << left << "COLLECT"; }
else {
string improvments = "";
for(int j = 0; j < improv[i]; j++){
improvments.append("I");
}
cout.fill(' ');
cout.width(8);
cout << left << improvments;
}
}
cout << "|" << endl;
for(int i = 10; i > -1; i--){
cout << "|";
cout.fill(' ');
cout.width(8);
if (i == 10) { cout << left << "LINE"; }
else if(i == 7) { cout << left << "HALL"; }
else if(i == 5) { cout << left << ""; }
else if(i == 4) { cout << left << ""; }
else if(i == 2) { cout << left << ""; }
else if(i == 0) { cout << left << "OSAP"; }
else { cout << "--------"; }
}
cout << "|" << endl;
for(int i = 10; i > -1; i--){
cout << "|";
cout.fill(' ');
cout.width(8);
cout << left << squares[i];
}
cout << "|" << endl;
// player position in last line
for(int i = 10; i > -1; i--){
cout << "|";
//cout.fill(' ');//add
//cout.width(7);//add
for(int j = 0; j < 8; j++){
cout << playerPos[i][j];
}
}
cout << "|" << endl;
for(int i = 10; i > -1; i--){
cout << "|________";
}
cout << "|" << endl;
}
| [
"ziniuwu@ziniudeMacBook.local"
] | ziniuwu@ziniudeMacBook.local |
f1335011560b685bd419dc394dba80c4741e7f43 | 556ff74668d1d93f91407c815dc7581291815aa8 | /cuneiform_src/Addfiles/API_PUMA/api_puma/SAMPLE_DIB/Events.cpp | 04af334987e125f2357d4de13bcbe6c48f929771 | [] | no_license | jwilk-mirrors/cuneiform-multilang | c4f747659f67818398736ed4234452a842ba3b42 | e4ba7053544d5e20d7f45339591e01671115d751 | refs/heads/master | 2020-03-18T15:15:50.024245 | 2009-06-01T07:22:55 | 2009-06-01T07:22:55 | 134,896,628 | 1 | 2 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 2,659 | cpp | // Events.cpp : implementation file
//
// CT: ÊËÀÑÑ ÄËß ÎÐÃÀÍÈÇÀÖÈÈ ÏÐÎÃÐÅÑÑ-ÌÎÍÈÒÎÐÀ
#include "stdafx.h"
#include "sample.h"
#include "Events.h"
#include "sampleDlg.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// Events
IMPLEMENT_DYNCREATE(Events, CCmdTarget)
Events::Events(CSampleDlg *dlg)
{
EnableAutomation();
if( dlg )
m_dlg=dlg;
}
Events::~Events()
{
}
void Events::OnFinalRelease()
{
// When the last reference for an automation object is released
// OnFinalRelease is called. The base class will automatically
// deletes the object. Add additional cleanup required for your
// object before calling the base class.
CCmdTarget::OnFinalRelease();
}
BEGIN_MESSAGE_MAP(Events, CCmdTarget)
//{{AFX_MSG_MAP(Events)
// NOTE - the ClassWizard will add and remove mapping macros here.
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
BEGIN_DISPATCH_MAP(Events, CCmdTarget)
//{{AFX_DISPATCH_MAP(Events)
DISP_FUNCTION(Events, "Start", Start, VT_BOOL, VTS_NONE)
DISP_FUNCTION(Events, "Stop", Stop, VT_BOOL, VTS_NONE)
DISP_FUNCTION(Events, "Step", Step, VT_BOOL, VTS_I4 VTS_BSTR VTS_I4)
DISP_FUNCTION(Events, "EndThread", EndThread, VT_I4, VTS_BOOL VTS_I4)
//}}AFX_DISPATCH_MAP
END_DISPATCH_MAP()
// Note: we add support for IID_IEvents to support typesafe binding
// from VBA. This IID must match the GUID that is attached to the
// dispinterface in the .ODL file.
// {367DEC5D-2EED-447F-8290-41FAED27F28C}
const IID DIID__IRecognitionEvents = {0x229C1071,0x829F,0x11D2,{0xBA,0x6E,0x00,0x00,0xE8,0xD9,0xFD,0xF6}};
static const IID IID_IEvents = DIID__IRecognitionEvents;
//{ 0x367dec5d, 0x2eed, 0x447f, { 0x82, 0x90, 0x41, 0xfa, 0xed, 0x27, 0xf2, 0x8c } };
BEGIN_INTERFACE_MAP(Events, CCmdTarget)
INTERFACE_PART(Events, IID_IEvents, Dispatch)
END_INTERFACE_MAP()
/////////////////////////////////////////////////////////////////////////////
// Events message handlers
BOOL Events::Start()
{
m_dlg->m_progress="";
m_dlg->UpdateData(false);
m_dlg->UpdateWindow();
return TRUE;
}
BOOL Events::Stop()
{
m_dlg->m_progress="Ðàñïîçíàâàíèå çàêîí÷åíî.";
m_dlg->UpdateData(false);
m_dlg->UpdateWindow();
return TRUE;
}
BOOL Events::Step(long lStep, LPCTSTR strName, long lPerc)
{
m_dlg->m_progress.Format("%s %d%%",strName,lPerc);
m_dlg->UpdateData(false);
m_dlg->UpdateWindow();
return TRUE;
}
long Events::EndThread(BOOL rc, long lContext)
{
// TODO: Add your dispatch handler code here
return 0;
}
| [
"jpakkane@kosto"
] | jpakkane@kosto |
4538d8be2fe3253b59ed36309257be9f6d2d6993 | 550c688adfe7d7e8f700e51be6718359d92d9d1e | /HackerRank/substring.cpp | e7d3af9e490c99d4aa4de2a4ccd146f0e2993d7f | [] | no_license | shribadiger/interviewpreparation | 1d8326bd4e1c11218affde66072ae65453577cb8 | d29a477cca8fd6f750b7a365c9b591f28108ba00 | refs/heads/master | 2023-03-20T20:41:15.405574 | 2021-03-24T15:44:52 | 2021-03-24T15:44:52 | 296,693,578 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 178 | cpp | #include<iostream>
#include<string>
using namespace std;
int main() {
std::string s1="shrikant";
std::string s2 = s1.substr(0,1);
std::cout<<"\n Result: "<<s2;
return 0;
}
| [
"shrikant.badiger@siemens.com"
] | shrikant.badiger@siemens.com |
f900c97a2ea5565bbef6dbcca3ecb769f91fcfcd | 348591c20d78a66f18a57945946bd3533b8f7758 | /MultiplicityGenerator.h | 79b96256c1c54a3aa1473a38c29264aae5a00983 | [] | no_license | TansTB/ppSimulation | 5c5eafde486b9f3c4edc4ae8aef8b03812d994e1 | ad28e424ed3934e7d58c87e5886d058f865bf1bd | refs/heads/master | 2020-07-12T17:14:45.959947 | 2017-09-27T21:10:55 | 2017-09-27T21:10:55 | 73,902,586 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,458 | h | #ifndef MULTIPLICITYGENERATOR_H
#define MULTIPLICITYGENERATOR_H
#if !defined(__CINT__) || defined(__MAKECINT__)
#include "TFile.h"
#include "TH1D.h"
#include "TMath.h"
#include "TRandom3.h"
#include <iostream>
#endif
class MultiplicityGenerator{
public:
MultiplicityGenerator(){}
MultiplicityGenerator(const char *input_file_name, const char* input_hist_name);
~MultiplicityGenerator();
const char* GetInputFileName(){return input_file_name;}
const char* GetInputHistName(){return input_hist_name;}
Int_t GetConstMultiplicity();//Returns a constant value. If multiplicity is <0, 0 is returned
void SetConstMultiplicity(Int_t multiplicity);
Int_t GetGausMultiplicity();//Returns a gaussian distributed integer value. If the random number is <0, 0 is returned
void SetGausMultiplicity(Double_t mean, Double_t sigma);
Int_t GetUniformMultiplicity();//Returns a uniform distributed integer value between min and max. Min must be >0 and <max
void SetUniformMultiplicity(Int_t min, Int_t max);
Int_t GetCustomMultiplicity();
void SetCustomMultiplicity(const char* input_file_name, const char* input_hist_name);
private:
MultiplicityGenerator(const MultiplicityGenerator &other);
MultiplicityGenerator& operator=(const MultiplicityGenerator& other);
const char *input_file_name;
const char *input_hist_name;
TFile *input_file;
TH1D *input_hist;
Bool_t used_hist=0;
Double_t multiplicity,max,sigma;
};
#endif | [
"andrea.bellora@gmail.com"
] | andrea.bellora@gmail.com |
6d2709198555e340952bf3b25e168037c5799c32 | d0c44dd3da2ef8c0ff835982a437946cbf4d2940 | /cmake-build-debug/programs_tiling/function13811/function13811_schedule_44/function13811_schedule_44.cpp | 390ffb606c5fae5eb45fdae5edc77788bb28c6af | [] | no_license | IsraMekki/tiramisu_code_generator | 8b3f1d63cff62ba9f5242c019058d5a3119184a3 | 5a259d8e244af452e5301126683fa4320c2047a3 | refs/heads/master | 2020-04-29T17:27:57.987172 | 2019-04-23T16:50:32 | 2019-04-23T16:50:32 | 176,297,755 | 1 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 1,035 | cpp | #include <tiramisu/tiramisu.h>
using namespace tiramisu;
int main(int argc, char **argv){
tiramisu::init("function13811_schedule_44");
constant c0("c0", 128), c1("c1", 1024), c2("c2", 256);
var i0("i0", 0, c0), i1("i1", 0, c1), i2("i2", 0, c2), i01("i01"), i02("i02"), i03("i03"), i04("i04"), i05("i05"), i06("i06");
input input00("input00", {i0, i1}, p_int32);
input input01("input01", {i2}, p_int32);
computation comp0("comp0", {i0, i1, i2}, input00(i0, i1) - input01(i2));
comp0.tile(i0, i1, i2, 128, 128, 128, i01, i02, i03, i04, i05, i06);
comp0.parallelize(i01);
buffer buf00("buf00", {128, 1024}, p_int32, a_input);
buffer buf01("buf01", {256}, p_int32, a_input);
buffer buf0("buf0", {128, 1024, 256}, p_int32, a_output);
input00.store_in(&buf00);
input01.store_in(&buf01);
comp0.store_in(&buf0);
tiramisu::codegen({&buf00, &buf01, &buf0}, "../data/programs/function13811/function13811_schedule_44/function13811_schedule_44.o");
return 0;
} | [
"ei_mekki@esi.dz"
] | ei_mekki@esi.dz |
577d51a5d8427b1390d7641b577cc97d3fc398a3 | e5dad8e72f6c89011ae030f8076ac25c365f0b5f | /caret_gui/GuiTransformationMatrixDialog.h | 31c252423986932b35fca81f389f724787db4e25 | [] | no_license | djsperka/caret | f9a99dc5b88c4ab25edf8b1aa557fe51588c2652 | 153f8e334e0cbe37d14f78c52c935c074b796370 | refs/heads/master | 2023-07-15T19:34:16.565767 | 2020-03-07T00:29:29 | 2020-03-07T00:29:29 | 122,994,146 | 0 | 1 | null | 2018-02-26T16:06:03 | 2018-02-26T16:06:03 | null | UTF-8 | C++ | false | false | 8,674 | h | /*LICENSE_START*/
/*
* Copyright 1995-2002 Washington University School of Medicine
*
* http://brainmap.wustl.edu
*
* This file is part of CARET.
*
* CARET 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.
*
* CARET is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with CARET; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
/*LICENSE_END*/
#ifndef __VE_GUI_TRANSFORMATION_MATRIX_DIALOG_H__
#define __VE_GUI_TRANSFORMATION_MATRIX_DIALOG_H__
#include <stack>
#include <vector>
#include "WuQDialog.h"
class GuiTransformationMatrixSelectionControl;
class QCheckBox;
class QComboBox;
class QGridLayout;
class QLabel;
class QLineEdit;
class QPushButton;
class QTabWidget;
class QDoubleSpinBox;
class TransformationMatrix;
class vtkTransform;
/// Dialog for editing transformation matrices.
class GuiTransformationMatrixDialog : public WuQDialog {
Q_OBJECT
public:
/// Constructor
GuiTransformationMatrixDialog(QWidget* parent);
/// Destructor
~GuiTransformationMatrixDialog();
/// called when the mouse is pressed to make matrix available for undo
void axesEventInMainWindow();
/// update the dialog
void updateDialog();
/// update the display if the matrix is linked to main window or axis
void updateMatrixDisplay(const TransformationMatrix* tm);
/// set the translation values
void setTranslation(const float tx, const float ty, const float tz);
private slots:
/// called to close the dialog
void slotCloseDialog();
/// called when a matrix is selected
void slotMatrixSelectionComboBox(int item);
/// called when a matrix component is changed
void slotMatrixComponentChanged();
/// called to set the matrix to the identity matrix
void slotOperationIdentity();
/// called to set the matrix to its inverse
void slotOperationInverse();
/// called to transpose the matrix
void slotOperationTranspose();
/// called to multiply the matrix by another matrix
void slotOperationMultiply();
/// called to translate in screen axes
void slotTranslateScreenAxes();
/// called to translate in object axes
void slotTranslateObjectAxes();
/// called to rotate in screen axes
void slotRotateScreenAxes();
/// called to rotate in object axes
void slotRotateObjectAxes();
/// called to scale object
void slotScale();
/// called to set translation with mouse
void slotSetTranslationWithMouse();
/// called when new matrix button pressed
void slotMatrixNew();
/// called when delete matrix button pressed
void slotMatrixDelete();
/// called when matrix attributes button pressed
void slotMatrixAttributes();
/// called when copy matrix button pressed
void slotMatrixCopy();
/// called when paste matrix button pressed
void slotMatrixPaste();
/// called when apply matrix to main window button pressed
void slotMatrixApplyMainWindow();
/// called when apply matrix to transform data file button pressed
void slotMatrixApplyTransformDataFile();
/// called when load matrix button pressed
void slotMatrixLoad();
/// called when the show axes check box is toggled
void slotShowAxesCheckBox(bool val);
/// called to pop a matrix off the undo stack
void slotUndoPushButton();
/// called when a matrix is selected for a data file
void slotTransformMatrixSelection();
private:
/// class for storing a matrix for "undoing" an operation
class UndoMatrix {
public:
/// Constructor
UndoMatrix(const TransformationMatrix* tm);
/// Destructor
UndoMatrix();
/// get the matrix
void getMatrix(TransformationMatrix* tm) const;
protected:
/// the matrix
double mm[16];
};
/// matrix view type
enum MATRIX_VIEW_TYPE {
MATRIX_VIEW_MATRIX,
MATRIX_VIEW_TRANSFORMATIONS
};
/// create the matrix section
QWidget* createMatrixSection();
/// create the operations section
QWidget* createOperationsSection();
/// create the operation section.
QWidget* createMatrixButtonsSection();
/// add current matrix values to the undo stack
void addMatrixToUndoStack();
/// enable/disable the undo button
void enableDisableUndoPushButton();
/// clear the undo stack
void clearUndoStack();
/// transfer the matrix into the matrix element part of dialog
void transferMatrixIntoMatrixElementLineEdits();
/// transfer the matrix into the matrix transformation spin boxes
void transferMatrixIntoMatrixTransformSpinBoxes();
/// transfer the matrix into the dialog
void transferMatrixIntoDialog();
/// transfer dialog values into matrix
void transferDialogValuesIntoMatrix();
/// get the matrix view type
MATRIX_VIEW_TYPE getMatrixViewType() const;
/// get main window transform matrix
vtkTransform* getMainWindowRotationTransform();
/// create the matrix editor page
QWidget* createMatrixEditorPage();
/// create the transform data file page
QWidget* createTransformDataFilePage();
/// update the main window viewing matrix
void updateMainWindowViewingMatrix();
/// tab widget for matrices and data files
QTabWidget* matricesDataFilesTabWidget;
/// matrix editor page
QWidget* matrixEditorPage;
/// transform data file page
QWidget* transformDataFilePage;
/// transform data file grid layout
QGridLayout* transformDataFileGridLayout;
/// transform data file labels
std::vector<QLabel*> transformFileLabels;
/// transform data file matrix control
std::vector<GuiTransformationMatrixSelectionControl*> transformFileMatrixControls;
/// tab widget for matrix or trans/rotate
QTabWidget* matrixViewTabWidget;
/// widget for matrix elements
QWidget* matrixElementWidget;
/// line edits for matrix elements
QLineEdit* matrixElementLineEdits[4][4];
/// comment label
QLabel* commentLabel;
/// matrix selection combo box
QComboBox* matrixSelectionComboBox;
/// matrix transformations widget
QWidget* matrixTransformationsWidget;
/// matrix view translation X
QDoubleSpinBox* matrixTranslateXDoubleSpinBox;
/// matrix view translation Y
QDoubleSpinBox* matrixTranslateYDoubleSpinBox;
/// matrix view translation Z
QDoubleSpinBox* matrixTranslateZDoubleSpinBox;
/// matrix view rotate X
QDoubleSpinBox* matrixRotateXDoubleSpinBox;
/// matrix view rotate Y
QDoubleSpinBox* matrixRotateYDoubleSpinBox;
/// matrix view rotate Z
QDoubleSpinBox* matrixRotateZDoubleSpinBox;
/// matrix view scale X
QDoubleSpinBox* matrixScaleXDoubleSpinBox;
/// matrix view scale Y
QDoubleSpinBox* matrixScaleYDoubleSpinBox;
/// matrix view scale Z
QDoubleSpinBox* matrixScaleZDoubleSpinBox;
/// the show axes check box
QCheckBox* showAxesCheckBox;
/// yoke to main window
QCheckBox* yokeToMainWindowCheckBox;
/// current matrix in dialog
TransformationMatrix* currentMatrix;
/// the undo matrix stack
std::stack<UndoMatrix> undoMatrixStack;
/// the undo push button
QPushButton* undoPushButton;
};
#endif // __VE_GUI_TRANSFORMATION_MATRIX_DIALOG_H__
| [
"michael.hanke@gmail.com"
] | michael.hanke@gmail.com |
c18ab097b7c2821022e5d552a584d829a0cc0794 | 391c3971ff196e3c1ae862d50dee460a3faf00f4 | /common/storage/compress/integer.hpp | 490f400353b8a3e331d3fcfa8b1ec43a4a1be122 | [] | no_license | OpenTrader9000/quik | 257c954fc219338d9f25ccae9cff52b4ec7b7520 | 117e9f3439b9e05bfd5a73c837d6921de66bf239 | refs/heads/master | 2021-09-01T04:30:41.349079 | 2017-12-24T20:14:52 | 2017-12-24T20:14:52 | 110,351,902 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 121 | hpp | #pragma once
#include "signed.hpp"
#include "unsigned.hpp"
#include "signed_history.hpp"
#include "unsigned_history.hpp" | [
"likhachevae@1488a.ru"
] | likhachevae@1488a.ru |
3fe3ea8df776b6c686c8b80c9268072bbf669f58 | d390a36a08e0b2bd3b6235749b81b95e36128784 | /Dxproj/EnemyMgr.h | e59464469ec15070f45a0dc4c55dc5bc2d8cd567 | [] | no_license | hasepon/XAudio2Test | 4214f7c8ca78aa5add5343468d49b52e9113e6df | f0d9be75dc48edbc2f761e3aed5d03d2f1e77039 | refs/heads/master | 2021-08-23T09:08:48.912090 | 2017-12-04T12:29:10 | 2017-12-04T12:29:10 | 81,212,809 | 0 | 0 | null | null | null | null | SHIFT_JIS | C++ | false | false | 414 | h | #pragma once
#include "includeheader.h"
#include"Enemy.h"
class CEnemyMgr : public ObjBase
{
public:
CEnemyMgr();
~CEnemyMgr();
void Init();
void Update();
private:
void CreateEnemyCall();
int m_NowLiveCnt = 0; // 現在の敵の数
int m_MAX_ENEMY;
int m_SpwnTimeCnt = 0; // 次の生成までの時間
int m_Spwntimelimit;
int m_GameTime;
float m_EnemySpd = 0.5f;
int m_SpwnEnemyTotal = 0;
};
| [
"kamikirihien@gmail.com"
] | kamikirihien@gmail.com |
ffea678f367f6208501fb96fb425ff25f310957a | dd2bcd6e829347eef6ab8020bd8e31a18c335acc | /ThisIsASoftRenderer/Editor/XTP/Source/CommandBars/XTPControls.h | 36e5de60030b5c8d68ad72e6ca19895d56861913 | [] | no_license | lai3d/ThisIsASoftRenderer | 4dab4cac0e0ee82ac4f7f796aeafae40a4cb478a | a8d65af36f11a079e754c739a37803484df05311 | refs/heads/master | 2021-01-22T17:14:03.064181 | 2014-03-24T16:02:16 | 2014-03-24T16:02:16 | 56,359,042 | 1 | 0 | null | 2016-04-16T01:19:22 | 2016-04-16T01:19:20 | null | UTF-8 | C++ | false | false | 22,135 | h | // XTPControls.h : interface for the CXTPControls class.
//
// This file is a part of the XTREME COMMANDBARS MFC class library.
// (c)1998-2011 Codejock Software, All Rights Reserved.
//
// THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
// RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
// CONSENT OF CODEJOCK SOFTWARE.
//
// THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
// IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
// YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
// SINGLE COMPUTER.
//
// CONTACT INFORMATION:
// support@codejock.com
// http://www.codejock.com
//
/////////////////////////////////////////////////////////////////////////////
//{{AFX_CODEJOCK_PRIVATE
#if !defined(__XTPCONTROLS_H__)
#define __XTPCONTROLS_H__
//}}AFX_CODEJOCK_PRIVATE
#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000
class CXTPCommandBar;
class CXTPControl;
class CXTPCommandBars;
class CXTPCommandBarList;
class CXTPPropExchange;
struct XTP_COMMANDBARS_PROPEXCHANGE_PARAM;
class CXTPOriginalControls;
//===========================================================================
// Summary:
// CXTPControls is a CCmdTarget derived class. It represents a collection
// of the controls.
//===========================================================================
class _XTP_EXT_CLASS CXTPControls : public CXTPCmdTarget
{
DECLARE_DYNCREATE(CXTPControls)
private:
struct XTPBUTTONINFO; // Internal helper structure.
public:
//-----------------------------------------------------------------------
// Summary:
// Protected constructor used by dynamic creation
//-----------------------------------------------------------------------
CXTPControls();
//-----------------------------------------------------------------------
// Summary:
// Destroys a CXTPControls object, handles cleanup and deallocation
//-----------------------------------------------------------------------
virtual ~CXTPControls();
public:
//-----------------------------------------------------------------------
// Summary:
// Call this member to return the control at the specified index.
// Parameters:
// nIndex - An integer index.
// Returns:
// The CXTPControl pointer currently at this index.
//-----------------------------------------------------------------------
CXTPControl* GetAt(int nIndex) const;
//-----------------------------------------------------------------------
// Summary:
// This member function returns the index of the first control, starting
// at position 0, whose command ID matches nIDFind.
// Parameters:
// nIDFind - Command ID of the control to find.
// Returns:
// The index of the control, or -1 if no control has the given command ID.
//-----------------------------------------------------------------------
int CommandToIndex(int nIDFind) const;
//-----------------------------------------------------------------------
// Summary:
// Call this member to add a new control.
// Parameters:
// pControl - A pointer to the control to be added.
// controlType - The type of the control to be added.
// nId - Identifier of the control to be added.
// lpszParameter - Parameter of the control to be added.
// nBefore - Index of the control to be inserted.
// bTemporary - TRUE if this control is temporary.
// Returns:
// A pointer to the added control.
//-----------------------------------------------------------------------
CXTPControl* Add(CXTPControl* pControl, int nId, LPCTSTR lpszParameter = NULL, int nBefore = -1, BOOL bTemporary = FALSE);
CXTPControl* Add(XTPControlType controlType, int nId, LPCTSTR lpszParameter = NULL, int nBefore = -1, BOOL bTemporary = FALSE); //<combine CXTPControls::Add@CXTPControl*@int@LPCTSTR@int@BOOL>
CXTPControl* Add(CXTPControl* pControl);//<combine CXTPControls::Add@CXTPControl*@int@LPCTSTR@int@BOOL>
//-----------------------------------------------------------------------
// Summary:
// Call this member to insert a new control.
// Parameters:
// pControl - A pointer to the control to be added.
// nBefore - Index of the control to be inserted.
// Returns:
// A pointer to the added control.
// See Also: Add
//-----------------------------------------------------------------------
CXTPControl* InsertAt(CXTPControl* pControl, int nBefore);
//-----------------------------------------------------------------------
// Summary:
// Call this member to add a new control.
// Parameters:
// pMenu - Menu that contains the control.
// nIndex - Index of the control to be added.
// Returns:
// Pointer to the added control.
//-----------------------------------------------------------------------
CXTPControl* AddMenuItem(CMenu* pMenu, int nIndex);
//-----------------------------------------------------------------------
// Summary:
// Call this member to remove a control.
// Parameters:
// nIndex - Index of the control to be removed.
// pControl - Control to be removed.
//-----------------------------------------------------------------------
virtual void Remove(CXTPControl* pControl);
void Remove(int nIndex); // <combine CXTPControls::Remove@CXTPControl*>
//-----------------------------------------------------------------------
// Summary:
// Call this member to remove all controls.
//-----------------------------------------------------------------------
void RemoveAll();
//-----------------------------------------------------------------------
// Summary:
// Call this member to get the count of the controls
// Returns:
// The count of the controls.
//-----------------------------------------------------------------------
int GetCount() const;
//-----------------------------------------------------------------------
// Summary:
// Call this member to find the specified control.
// Parameters:
// type - The type of the control to find.
// nId - The control's identifier.
// bVisible - TRUE if the control is visible.
// bRecursive - TRUE to find in the nested command bars.
// Returns:
// Pointer to the CXTPControl object if successful; otherwise returns NULL.
//-----------------------------------------------------------------------
CXTPControl* FindControl(int nId) const;
CXTPControl* FindControl(XTPControlType type, int nId, BOOL bVisible, BOOL bRecursive) const; //<combine CXTPControls::FindControl@int@const>
//-----------------------------------------------------------------------
// Summary:
// Call this member to convert menu items to command bar controls.
// Parameters:
// pMenu - Menu to be converted.
// Returns:
// TRUE if the method was successful; otherwise FALSE.
//-----------------------------------------------------------------------
BOOL LoadMenu(CMenu* pMenu);
public:
//-----------------------------------------------------------------------
// Summary:
// Call this member to retrieve the first control.
// Returns:
// A pointer to a CXTPControl object
//-----------------------------------------------------------------------
CXTPControl* GetFirst() const;
//-----------------------------------------------------------------------
// Summary:
// Finds the next control in the given direction.
// Parameters:
// nIndex - Current control index.
// nDirection - Direction to find.
// bKeyboard - TRUE to skip controls with xtpFlagSkipFocus flag.
// bSkipTemporary - TRUE to skip all controls with Temporary flag
// bSkipCollapsed - TRUE to skip all controls with xtpHideExpand hide flag.
// pControl - Receives a pointer to the next control.
// Returns:
// Index of the next control.
//-----------------------------------------------------------------------
void GetNext(CXTPControl*& pControl) const;
long GetNext(long nIndex, int nDirection = +1, BOOL bKeyboard = TRUE, BOOL bSkipTemporary = FALSE, BOOL bSkipCollapsed = TRUE) const; //<combine CXTPControls::GetNext@CXTPControl*&@const>
//-----------------------------------------------------------------------
// Summary:
// This method determines where a point lies in a specified control.
// Parameters:
// point - Specifies the point to be tested.
// Returns:
// A pointer to a CXTPControl control that occupies the specified
// point or NULL if no control occupies the point.
//-----------------------------------------------------------------------
CXTPControl* HitTest(CPoint point) const;
//-----------------------------------------------------------------------
// Summary:
// Call this member to change the type of the control.
// Parameters:
// pControl - Points to a CXTPControl object
// nIndex - Index of the control
// type - Type needed to be changed.
// Returns:
// A pointer to a CXTPControl object
//-----------------------------------------------------------------------
CXTPControl* SetControlType(CXTPControl* pControl, XTPControlType type);
CXTPControl* SetControlType(int nIndex, XTPControlType type); // <combine CXTPControls::SetControlType@CXTPControl*@XTPControlType>
//-----------------------------------------------------------------------
// Summary:
// Call this member to add the copy of the control.
// Parameters:
// pClone - Points to a CXTPControl object needed to copy.
// nBefore - Index of the control to be inserted.
// bRecursive - TRUE to copy recursively.
// Returns:
// A pointer to an added CXTPControl object
//-----------------------------------------------------------------------
CXTPControl* AddClone(CXTPControl* pClone, int nBefore = -1, BOOL bRecursive = FALSE);
//-----------------------------------------------------------------------
// Summary:
// This method is called internally to reposition controls and
// determine their size.
// Parameters:
// pDC - Pointer to a valid device context
// nLength - Length of the parent bar.
// dwMode - Mode of the parent bar.
// rcBorder - Borders of commandbar.
// nWidth - Width of the parent bar.
// Returns:
// Total size of the controls.
//-----------------------------------------------------------------------
CSize CalcDynamicSize(CDC* pDC, int nLength, DWORD dwMode, const CRect& rcBorder, int nWidth = 0);
//-----------------------------------------------------------------------
// Summary:
// This method is called internally to reposition controls and
// determine their size for popup bar.
// Parameters:
// pDC - Pointer to a valid device context
// nLength - Length of the parent bar.
// nWidth - Width of the parent bar.
// rcBorder - Borders of popup bar.
// Returns:
// Total size of the controls.
// See Also: CalcDynamicSize
//-----------------------------------------------------------------------
CSize CalcPopupSize(CDC* pDC, int nLength, int nWidth, const CRect& rcBorder);
//-----------------------------------------------------------------------
// Summary:
// Call this member to get the number of visible controls.
// Parameters:
// bIgnoreWrap - TRUE to ignore controls that are wrapped.
// Returns:
// Number of visible controls.
//-----------------------------------------------------------------------
int GetVisibleCount(BOOL bIgnoreWrap = FALSE) const;
//-----------------------------------------------------------------------
// Input: nIndex - Control's identifier
// bIgnoreWraps - TRUE to ignore controls that are wrapped
// Summary: Finds the specified control by Id
// Returns: Pointer to the CXTPControl object if successful; otherwise returns NULL
//-----------------------------------------------------------------------
CXTPControl* GetVisibleAt(int nIndex, BOOL bIgnoreWraps = FALSE) const;
//-----------------------------------------------------------------------
// Summary:
// Call this member to attach the specified command bars object.
// Parameters:
// pCommandBars - Command bars object need to attach.
// Remarks:
// You can call this member if you create plain toolbar and want to set CommandBars for it.
//-----------------------------------------------------------------------
void SetCommandBars(CXTPCommandBars* pCommandBars);
//-----------------------------------------------------------------------
// Summary:
// Makes a copy of all controls.
// Parameters:
// bRecursive - TRUE to copy recursively.
// Returns:
// A pointer to a CXTPControls object.
//-----------------------------------------------------------------------
CXTPControls* Duplicate(BOOL bRecursive = FALSE);
//-----------------------------------------------------------------------
// Summary: This method is called to copy the control.
// Input: pControls - Controls needed to be copied.
// bRecursive - TRUE to copy recursively.
//-----------------------------------------------------------------------
virtual void Copy(CXTPControls* pControls, BOOL bRecursive = FALSE);
//-----------------------------------------------------------------------
// Summary:
// Retrieves the parent command bars object.
// Returns:
// A pointer to a CXTPCommandBars object
//-----------------------------------------------------------------------
CXTPCommandBars* GetCommandBars() const;
//-----------------------------------------------------------------------
// Summary:
// Move the control to a specified position.
// Parameters:
// pControl - Points to a CXTPControl object
// nBefore - Index to be moved.
//-----------------------------------------------------------------------
void MoveBefore(CXTPControl* pControl, int nBefore);
//-----------------------------------------------------------------------
// Summary:
// Attaches the parent command bar.
// Parameters:
// pParent - Points to a CXTPCommandBar object
//-----------------------------------------------------------------------
void SetParent(CXTPCommandBar* pParent);
//-----------------------------------------------------------------------
// Summary:
// Creates original controls set.
//-----------------------------------------------------------------------
void CreateOriginalControls();
//-----------------------------------------------------------------------
// Summary:
// Removes the original controls set.
//-----------------------------------------------------------------------
void ClearOriginalControls();
//-----------------------------------------------------------------------
// Summary:
// Retrieves original controls set.
// Returns:
// A pointer to a CXTPControls object
//-----------------------------------------------------------------------
CXTPOriginalControls* GetOriginalControls() const;
//-----------------------------------------------------------------------
// Summary:
// Call this method to assign original controls
// Parameters:
// pControls - A pointer to a CXTPControls object to assign
//-----------------------------------------------------------------------
void SetOriginalControls(CXTPOriginalControls* pControls);
//-----------------------------------------------------------------------
// Summary:
// Call this member to compare the controls.
// Parameters:
// pControls - Points to a CXTPControls object
// Returns:
// TRUE if the controls are identical.
//-----------------------------------------------------------------------
BOOL Compare(const CXTPControls* pControls);
//-----------------------------------------------------------------------
// Summary:
// Returns the changed status flag of the control.
// Returns:
// TRUE if the internal control state was changed since last drawing,
// FALSE otherwise.
//-----------------------------------------------------------------------
BOOL IsChanged() const;
//-----------------------------------------------------------------------
// Summary:
// Reads or writes this object from or to an archive.
// Parameters:
// pPX - A CXTPPropExchange object to serialize to or from.
//----------------------------------------------------------------------
virtual void DoPropExchange(CXTPPropExchange* pPX);
//-----------------------------------------------------------------------
// Input: pControl - Control to check to see if it need to be saved
// Summary: This method is called to check if the control was changed and has to be saved
// Returns: TRUE if control has to be saved
//-----------------------------------------------------------------------
virtual BOOL ShouldSerializeControl(CXTPControl* pControl);
//-----------------------------------------------------------------------
// Summary:
// Call this member to get the parent command bar.
// Returns:
// The parent command bar object.
//-----------------------------------------------------------------------
CXTPCommandBar* GetParent() const;
//-----------------------------------------------------------------------
// Summary: Determines if all controls are original and not added or modified
// by the user.
// Returns: Returns TRUE if all Controls in the collection were added at
// the time of creation or from the last time
// CreateOriginalControls was called.
//-----------------------------------------------------------------------
BOOL IsOriginalControls() const;
//-----------------------------------------------------------------------
// Summary:
// Sorts the commands list.
//-----------------------------------------------------------------------
void Sort();
protected:
//-----------------------------------------------------------------------
// Summary:
// This method is called when control is added to collection
// Parameters:
// pControl - control that added to collection
virtual void OnControlAdded(CXTPControl* pControl);
//-----------------------------------------------------------------------
// Summary:
// This method is called when control is removed from collection
// Parameters:
// pControl - control that removed from collection
//-----------------------------------------------------------------------
virtual void OnControlRemoved(CXTPControl* pControl);
//-----------------------------------------------------------------------
// Summary:
// This method is called when control is about to be removed from collection
// Parameters:
// pControl - control that removed from collection
// Returns: TRUE to cancel removing controls
//-----------------------------------------------------------------------
virtual BOOL OnControlRemoving(CXTPControl* pControl);
//{{AFX_CODEJOCK_PRIVATE
protected:
virtual void RefreshIndexes();
static int _cdecl CompareByCaption(const CXTPControl** ppItem1, const CXTPControl** ppItem2);
protected:
void GenerateCommandBarList(DWORD& nID, CXTPCommandBarList* pCommandBarList, XTP_COMMANDBARS_PROPEXCHANGE_PARAM* pParam);
void RestoreCommandBarList(CXTPCommandBarList* pCommandBarList);
CSize _CalcSize(XTPBUTTONINFO* pData, BOOL bVert);
int _WrapToolBar(XTPBUTTONINFO* pData, int nWidth, DWORD& dwMode);
void _SizeFloatableBar(XTPBUTTONINFO* pData, int nLength, DWORD dwMode);
void _AdjustBorders(XTPBUTTONINFO* pData, CSize& sizeResult, DWORD dwMode, CRect rcBorder);
void _CenterControlsInRow(XTPBUTTONINFO* pData, int nFirst, int nLast, int, BOOL, CSize sizeResult, CRect);
void _MoveRightAlligned(XTPBUTTONINFO* pData, CSize sizeResult, CRect rcBorder, DWORD dwMode);
void _SizePopupToolBar(XTPBUTTONINFO* pData, DWORD dwMode);
CSize _CalcSmartLayoutToolBar(CDC* pDC, XTPBUTTONINFO* pData, DWORD& dwMode);
CSize _WrapSmartLayoutToolBar(CDC* pDC, XTPBUTTONINFO* pData, int nWidth, DWORD& dwMode);
CSize _ReduceSmartLayoutToolBar(CDC* pDC, XTPBUTTONINFO* pData, int nWidth, DWORD& dwMode);
void _MakeSameWidth(int nStart, int nLast, int nWidth);
//}}AFX_CODEJOCK_PRIVATE
protected:
CXTPCommandBar* m_pParent; // Parent Command Bar
CArray<CXTPControl*, CXTPControl*> m_arrControls; // Collection of controls
CXTPCommandBars* m_pCommandBars; // Parent Command Bars
CXTPOriginalControls* m_pOriginalControls; // Original controls collection.
BOOL m_bOriginalControls; // TRUE if all controls are original and unmodified
friend class CXTPCommandBar;
friend class CXTPCommandBars;
friend class CXTPToolBar;
friend class CXTPMenuBar;
friend class CXTPRibbonBar;
};
//===========================================================================
// Summary: CXTPOriginalControls object
//===========================================================================
class _XTP_EXT_CLASS CXTPOriginalControls : public CXTPControls
{
DECLARE_DYNCREATE(CXTPOriginalControls)
public:
//-----------------------------------------------------------------------
// Summary:
// Constructs a CXTPOriginalControls object
//-----------------------------------------------------------------------
CXTPOriginalControls();
friend class CXTPControls;
};
//////////////////////////////////////////////////////////////////////////
AFX_INLINE CXTPControl* CXTPControls::GetAt(int nIndex) const {
ASSERT(nIndex < m_arrControls.GetSize());
return (nIndex >= 0 && nIndex < m_arrControls.GetSize()) ? m_arrControls.GetAt(nIndex) : NULL;
}
AFX_INLINE int CXTPControls::GetCount() const {
return (int)m_arrControls.GetSize();
}
AFX_INLINE CXTPOriginalControls* CXTPControls::GetOriginalControls() const {
return m_pOriginalControls;
}
AFX_INLINE CXTPCommandBar* CXTPControls::GetParent() const {
return m_pParent;
}
AFX_INLINE BOOL CXTPControls::IsOriginalControls() const {
return m_bOriginalControls;
}
#endif // #if !defined(__XTPCONTROLS_H__)
| [
"54639976@qq.com"
] | 54639976@qq.com |
b9eb875bb5684608fa36386d2ad9ef1baa295d8d | 6c8efa5554ce17a8f97e4b1d523bf192ff355ccd | /Classes/Core/MTile.h | 88a84f7683ffd04a1931cd376588f5f0e75fa9f1 | [
"MIT"
] | permissive | liuyatao/Alarm-x4 | 082528ec8294b1dd5cc80545f7506cec973c60db | bc4ad1bcf34a7c9ea2ab3fbd2b6cfffe4b7156a8 | refs/heads/master | 2021-01-17T06:11:08.725340 | 2013-10-01T20:03:06 | 2013-10-01T20:03:06 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,950 | h | #ifndef TILE_H
#define TILE_H
#include "cocos2d.h"
#include "MTilePosition.h"
#include "MTileSize.h"
#include "Alignment.h"
#include "Logic/Lang.h"
#include <memory>
class MTile;
typedef void (cocos2d::CCObject::*SEL_TileHandler)(MTile*);
#define tile_selector(_SELECTOR) (SEL_TileHandler)(&_SELECTOR)
class MTile : public cocos2d::CCNode
{
public:
static MTile* create(const char* background,
const MTilePosition&,
const MTileSize&,
cocos2d::CCObject *rec=0, SEL_TileHandler selector=0);
const MTilePosition getTilePosition() const;
void setTilePosition(const MTilePosition& pos);
const MTileSize getTileSize() const;
void setTileSize(const MTileSize& size);
virtual cocos2d::CCSize getContentSize();
cocos2d::CCSize getInnerContentSize();
void onHoverBegin();
void onHoverEnd();
void onClick();
bool isClickable() const;
void addChild(CCNode* child, const Aligment::Horizontal horizontal,
const Aligment::Vertical vertical,
float margin_x=0, float margin_y=0);
const cocos2d::CCRect& rect() const
{
return _rect;
}
void selfDestroy();
~MTile();
protected:
void init(const char* background,
const MTilePosition&,
const MTileSize&,
cocos2d::CCObject *rec,
SEL_TileHandler selector);
MTile();
private:
void updatePosition();
void updateSize();
void updateRect();
MTile(const MTile&);
MTile& operator=(const MTile&);
MTilePosition _my_pos;
MTileSize _my_size;
cocos2d::CCSprite* _main_texture;
cocos2d::CCObject *_callback_obj;
SEL_TileHandler _callback_ptr;
cocos2d::CCRect _rect;
};
void addImageAndLabelToTile(
MTile* tile, const char* label, const char* icon);
void addLabelToTile(MTile* tile, const char* labelt);
#endif // TILE_H
| [
"andriy+en@chaika.in.ua"
] | andriy+en@chaika.in.ua |
41bdc0b4282f2f80ba05f206085eed774218e78d | 6923f79f1eaaba0ab28b25337ba6cb56be97d32d | /NumericalRecipes2/examples/xpoidev.cpp | 7caa89b3fd08bda195b4c90bcae00e1bd4b19c45 | [] | no_license | burakbayramli/books | 9fe7ba0cabf06e113eb125d62fe16d4946f4a4f0 | 5e9a0e03aa7ddf5e5ddf89943ccc68d94b539e95 | refs/heads/master | 2023-08-17T05:31:08.885134 | 2023-08-14T10:05:37 | 2023-08-14T10:05:37 | 72,460,321 | 223 | 174 | null | 2022-10-24T12:15:06 | 2016-10-31T17:24:00 | Jupyter Notebook | UTF-8 | C++ | false | false | 1,330 | cpp | #include <string>
#include <iostream>
#include <iomanip>
#include "nr.h"
using namespace std;
// Driver for routine poidev
int main(void)
{
const int N=20,NPTS=10000,ISCAL=200,LLEN=50;
int i,j,klim,idum=(-13);
Vec_INT dist(N+1);
DP xm,dd;
for (;;) {
for (j=0;j<=N;j++) dist[j]=0;
do {
cout << "Mean of Poisson distribution (0.0<x<" << N << ".0) ";
cout << "- Negative to end: " << endl;
cin >> xm;
} while (xm > N);
if (xm < 0.0) break;
for (i=0;i<NPTS;i++) {
j=int(0.5+NR::poidev(xm,idum));
if ((j >= 0) && (j <= N)) ++dist[j];
}
cout << fixed << setprecision(4);
cout << "Poisson-distributed deviate, mean " << xm;
cout << " of " << NPTS << " points" << endl;
cout << setw(5) << "x" << setw(9) << "p(x)";
cout << setw(11) << "graph:" << endl;
for (j=0;j<=N;j++) {
dd=DP(dist[j])/NPTS;
klim=int(ISCAL*dd);
if (klim > LLEN) klim=LLEN;
string txt(klim,'*');
cout << setw(6) << j << setw(9) << dd;
cout << " " << txt << endl;
}
cout << endl;
}
return 0;
}
| [
"bb@b.om"
] | bb@b.om |
fdb22b10f46f137141a7be989424acd80ef8a12e | 185d1d3afb894d419709d2a80ed9d325d9ab66d4 | /FS/HashedTable.cpp | e4b509a7ba5f472410911d2a0768cf37828fe359 | [] | no_license | mahesh001/Myds-program | 9022f101392cb0dc8f3fc667ae6969d67cc372b6 | fd2d7f5039e777c03ae7e71a3a4c26e2a93f6816 | refs/heads/master | 2021-01-17T07:47:11.717396 | 2017-03-03T17:07:41 | 2017-03-03T17:07:41 | 83,792,053 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,762 | cpp | #include "Bucket.cpp"
#include<math.h>
using namespace std;
class HashedTable
{
public:
void find(int x)
{
int n=findHash(x);
}
private:
int size;
Bucket *buckets;
public:
HashedTable()
{
size=0;
buckets=NULL;
}
//Hash Function...
private:
int findHash(int no)
{
int temp=1;
for(int i=0;i<size;i++)
{
temp*=2;
}
return (no%temp);
}
//Function calling the insert function of the Bucket class...
bool insert(Bucket& bucket,int& no)
{
return (bucket.insert(no));
}
public:
void insert(int no)
{
int n=findHash(no);
bool TorF=insert(buckets[n],no);
if(!TorF)
{
extend(n,buckets);
insert(no);
}
}
private:
void extend(int& n,Bucket* bucket)
{
size++;
//Creating the new Hash table thing and copying the pointers as required....
Bucket *buckets1 =new Bucket[(int)pow(2,size)];
for(int i=0;i<((int)pow(2,size-1));i++)
{
if(i!=n)
{
buckets1[2*i]=this->buckets[i];
buckets1[2*i+1]=this->buckets[i];
}
else
{
buckets1[2*i]=this->buckets[i];
}
}
//Deleting the original hash table and making the new table the orginal one....
delete buckets;
buckets=new Bucket[(int)pow(2,size)];
for(int i=0;i<((int)pow(2,size));i++)
{
buckets[i]=buckets1[i];
}
//Transfer the elements that donot belong to this(2n+1) Bucket to the new Bucket.....
Node *temp=buckets[2*n].root;
while(temp!=NULL)
{
findHash(temp->element);
if(temp->element!=(2*n))
{
insert(temp->element);
if(temp->next!=NULL)
{
Node *temp1=temp->next;
temp->element=temp->next->element;
temp->next=temp->next->next;
delete temp1;
}
else
{
delete temp;
}
temp=temp->next;
}
}
}
};
int main()
{
HashedTable *hsdtbl=new HashedTable();
while(1)
{
cout<<"\n Please specify the operation that you want to do";
cout<<"\n 1-Inserting element..";
cout<<"\n 2-Finding elememt..";
cout<<"\n 3-Exit...";
int k;
cin>>k;
switch(k)
{
case 1:
{
cout<<"\nEnter the number that you want to insert";
int l;
cin>>l;
hsdtbl->insert(l);
cout<<endl;
break;
}
case 2:
{
cout<<"\nEnter the element that you want to find";
int m;
cin>>m;
hsdtbl->find(m);
cout<<endl;
}
default: cout<<"\nPlease specify a valid option\n";
}
}
return 0;
}
| [
"mahesh001"
] | mahesh001 |
4007638e004c4e6aedbf0c580de62de493d354ab | 0e745cd5f569847079bdd1668d92af0293e027c2 | /myLib/Lapackpp1.1a/include/ltgmd.h | dfb80a064509cc4f81b13f27e23f76e5c2062b71 | [] | no_license | konstantinAriel/myTest | b63ad156f7fdd112809b03c969ea7d0072bcf1e4 | 2b2c07a69063b1965fa544a47137d64cb05f168e | refs/heads/master | 2021-01-11T17:37:31.011522 | 2017-01-24T11:06:30 | 2017-01-24T11:06:30 | 79,803,748 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,597 | h | // LAPACK++ (V. 1.1)
// (C) 1992-1996 All Rights Reserved.
#ifndef _LA_LOWER_TRIANG_MAT_DOUBLE_H_
#define _LA_LOWER_TRIANG_MAT_DOUBLE_H_
#ifndef _LA_GEN_MAT_DOUBLE_H_
#include LA_GEN_MAT_DOUBLE_H
#endif
//#define LOWER_INDEX_CHK
class LaLowerTriangMatDouble
{
LaGenMatDouble data_;
static double outofbounds_;
static int debug_; // print debug info.
static int *info_; // print matrix info only, not values
// originally 0, set to 1, and then
// reset to 0 after use.
public:
// constructors
inline LaLowerTriangMatDouble();
inline LaLowerTriangMatDouble(int,int);
inline LaLowerTriangMatDouble(double*,int,int);
inline LaLowerTriangMatDouble(const LaLowerTriangMatDouble &);
// operators
inline LaLowerTriangMatDouble& ref(LaLowerTriangMatDouble &);
inline LaLowerTriangMatDouble& ref(LaGenMatDouble &);
LaLowerTriangMatDouble& copy(const LaLowerTriangMatDouble &);
LaLowerTriangMatDouble& operator=(double);
inline LaLowerTriangMatDouble& operator=(const LaLowerTriangMatDouble &);
inline double& operator()(int,int);
inline double& operator()(int,int) const;
// inline operator LaGenMatDouble();
inline int size(int) const; // submatrix size
inline int inc(int d) const; // explicit increment
inline int gdim(int d) const; // global dimensions
inline double* addr() const { // return address of matrix.
return data_.addr();}
inline int ref_count() const { // return ref_count of matrix.
return data_.ref_count();}
inline LaIndex index(int d) const { // return indices of matrix.
return data_.index(d);}
inline int shallow() const { // return indices of matrix.
return data_.shallow();}
inline int debug() const { // return debug flag.
return debug_;}
inline int debug(int d) { // set debug flag for lagenmat.
return debug_ = d;}
inline LaLowerTriangMatDouble& resize(const LaLowerTriangMatDouble&);
inline const LaLowerTriangMatDouble& info() const {
int *t = info_;
*t = 1;
return *this;};
friend ostream &operator<<(ostream &, const LaLowerTriangMatDouble &);
// destructor
inline ~LaLowerTriangMatDouble();
};
// constructor functions
inline LaLowerTriangMatDouble::LaLowerTriangMatDouble() : data_()
{
*info_ = 0;
}
inline LaLowerTriangMatDouble::LaLowerTriangMatDouble(int i,int j):data_(i,j)
{
*info_ = 0;
}
inline LaLowerTriangMatDouble::LaLowerTriangMatDouble(double *d,int i,int j):
data_(d,i,j)
{
*info_ = 0;
}
inline LaLowerTriangMatDouble::LaLowerTriangMatDouble(const LaLowerTriangMatDouble &A)
{
data_.copy(A.data_);
}
// operator functions
inline LaLowerTriangMatDouble& LaLowerTriangMatDouble::ref(LaLowerTriangMatDouble &ob)
{
data_.ref(ob.data_);
return *this;
}
inline LaLowerTriangMatDouble& LaLowerTriangMatDouble::ref(LaGenMatDouble &ob)
{
data_.ref(ob);
return *this;
}
inline LaLowerTriangMatDouble& LaLowerTriangMatDouble::resize(const LaLowerTriangMatDouble &ob)
{
data_.resize(ob.data_);
return *this;
}
inline LaLowerTriangMatDouble& LaLowerTriangMatDouble::operator=(const LaLowerTriangMatDouble &L)
{
data_ = L.data_;
return *this;
}
inline double& LaLowerTriangMatDouble::operator()(int i, int j)
{
#ifdef LOWER_INDEX_CHK
if (i<j)
{
cout << "Warning, index to Lower Triular matrix out of range!\n";
cout << " i = " << i << " " <<" j = " << j << endl;
}
#endif
if (i<j)
return outofbounds_;
else
return data_(i,j);
}
inline double& LaLowerTriangMatDouble::operator()(int i, int j) const
{
#ifdef LOWER_INDEX_CHK
if (i<j)
{
cout << "Warning, index to Lower Triular matrix out of range!\n";
cout << " i = " << i << " " <<" j = " << j << endl;
}
#endif
if (i<j)
return outofbounds_;
else
return data_(i,j);
}
// destructor function
inline LaLowerTriangMatDouble::~LaLowerTriangMatDouble()
{
}
inline int LaLowerTriangMatDouble::size(int d) const
{
return(data_.size(d));
}
inline int LaLowerTriangMatDouble::inc(int d) const
{
return(data_.inc(d));
}
inline int LaLowerTriangMatDouble::gdim(int d) const
{
return(data_.gdim(d));
}
#if 0
// type conversions between LaGenMat and LaUpTriMat
inline LaLowerTriangMatDouble::operator LaGenMatDouble()
{
LaGenMatDouble G;
G.ref((*this).data_);
return G;
}
#endif
#endif
// _LA_LOWER_TRIANG_MAT_DOUBLE_H_
| [
"konstantinsh@ariel.ac.il"
] | konstantinsh@ariel.ac.il |
217e91168b0ffd9806ca14ed40badd4564c73120 | b43343d2c735ce913fe9d2bde3994d3da5fa4d63 | /yellow/1week/sqrt.cpp | 5e020f62828b455c848fc6b2def219dac35c2add | [] | no_license | AvilovaEM/tasks | 11a9e4409c959d2e106f1feb3fed3b9ba0d10ba8 | f1a29ff2334e967afa959c9baceff069143e1eaa | refs/heads/master | 2020-03-08T10:19:54.670915 | 2019-04-17T04:59:59 | 2019-04-17T04:59:59 | 128,070,482 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,529 | cpp | #include<iostream>
#include<map>
#include<vector>
#include<utility>
using namespace std;
template<typename T> T Sqr(T x);
template<typename T> std::vector<T> Sqr(const std::vector<T>& arg);
template<typename Key, typename Value> std::map<Key, Value> Sqr(const std::map<Key, Value>& arg);
template<typename First, typename Second> std::pair<First, Second> operator*(const std::pair<First, Second>& lhs, const std::pair<First, Second>& rhs);
template<typename First, typename Second> std::pair<First, Second> Sqr(std::pair<First, Second> arg);
template <typename T> T Sqr(T x) {
return x*x;
}
template<typename T> std::vector<T> Sqr(const std::vector<T>& arg){
std::vector<T> result(arg.size());
for(size_t i = 0; i < result.size(); ++i)
result[i] = Sqr(arg[i]);
return result;
}
template<typename Key, typename Value> std::map<Key, Value> Sqr(const std::map<Key, Value>& arg){
std::map<Key, Value> result;
for(auto key : arg)
result[key.first] = Sqr(key.second);
return result;
}
template<typename First, typename Second> std::pair<First, Second> operator*(const std::pair<First, Second>& lhs, const std::pair<First, Second>& rhs){
First first_arg = lhs.first * rhs.first;
Second second_arg = lhs.second * rhs.second;
return {first_arg, second_arg};
}
template<typename First, typename Second> std::pair<First, Second> Sqr(std::pair<First, Second> arg){
return {Sqr(arg.first), Sqr(arg.second)};
}
int main(){
// Пример вызова функции
std::vector<int> v = {1, 2, 3};
std::cout << "vector:";
for (int x : Sqr(v)) {
std::cout << ' ' << x;
}
std::cout << std::endl;
std::map<int, int> sqrt = {{1, 1}, {2, 4}, {3, 9}};
for(auto key : Sqr(sqrt))
std::cout << key.first << " - " << key.second << std::endl;
std::map<int, std::pair<int, int>> map_of_pairs = {
{4, {2, 2}},
{7, {4, 3}}
};
std::cout << "map of pairs:" << std::endl;
for (const auto& x : Sqr(map_of_pairs)) {
std::cout << x.first << ' ' << x.second.first << ' ' << x.second.second << std::endl;
}
return 0;
}
'T Sqr(T) [with T = std::map<int, std::vector<double> >]':
\n/tmp/tmp3oua5va7.cpp:104:20:
required from 'std::vector<T> Sqr(const std::vector<T>&) [with T = std::map<int, std::vector<double> >]'\n/tmp/tmp3oua5va7.cpp:163:27: required from here\n/tmp/tmp3oua5va7.cpp:96:11: error: no match for 'operator*' (operand types are 'std::map<int, std::vector<double> >' and 'std::map<int, std::vector<double> >')\n return x*x;\n ~^~\n/tmp/tmp3oua5va7.cpp:120:68: note: candidate: template<class First, class Second> std::pair<_T1, _T2> operator*(const std::pair<_T1, _T2>&, const std::pair<_T1, _T2>&)\n template<typename First, typename Second> std::pair<First, Second> operator*(const std::pair<First, Second>& lhs, const std::pair<First, Second>& rhs){\n ^~~~~~~~\n/tmp/tmp3oua5va7.cpp:120:68: note: template argument deduction/substitution failed:\n/tmp/tmp3oua5va7.cpp:96:11: note: 'std::map<int, std::vector<double> >' is not derived from 'const std::pair<_T1, _T2>'\n return x*x;\n ~^~\n" (Time used: 0.00/1.00, preprocess time used: 0/None, memory used: 9355264/536870912.)
0/1Оценка: 0 из 1
НетЗадание не пройдено
0/1Оценка: 0 из 1
НетЗадание не пройдено
0/1Оценка: 0 из 1
НетЗадание не пройдено
0/1Оценка: 0 из 1
НетЗадание не пройдено
| [
"katya.avilova@gmail.com"
] | katya.avilova@gmail.com |
5d0e68e56c7f1a5391876371ba53d2e4d15fb284 | 3282ccae547452b96c4409e6b5a447f34b8fdf64 | /SimModel_Python_API/simmodel_swig/SimModel_Dll_lib/framework/SimGeomCurve_Line_Default.cxx | 9b953d012e70cf75b16f1eea5664d20ca84e12ad | [
"MIT"
] | permissive | EnEff-BIM/EnEffBIM-Framework | c8bde8178bb9ed7d5e3e5cdf6d469a009bcb52de | 6328d39b498dc4065a60b5cc9370b8c2a9a1cddf | refs/heads/master | 2021-01-18T00:16:06.546875 | 2017-04-18T08:03:40 | 2017-04-18T08:03:40 | 28,960,534 | 3 | 0 | null | 2017-04-18T08:03:40 | 2015-01-08T10:19:18 | C++ | UTF-8 | C++ | false | false | 3,749 | cxx | // Copyright (c) 2005-2014 Code Synthesis Tools CC
//
// This program was generated by CodeSynthesis XSD, an XML Schema to
// C++ data binding compiler.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
//
// In addition, as a special exception, Code Synthesis Tools CC gives
// permission to link this program with the Xerces-C++ library (or with
// modified versions of Xerces-C++ that use the same license as Xerces-C++),
// and distribute linked combinations including the two. You must obey
// the GNU General Public License version 2 in all respects for all of
// the code used other than Xerces-C++. If you modify this copy of the
// program, you may extend this exception to your version of the program,
// but you are not obligated to do so. If you do not wish to do so, delete
// this exception statement from your version.
//
// Furthermore, Code Synthesis Tools CC makes a special exception for
// the Free/Libre and Open Source Software (FLOSS) which is described
// in the accompanying FLOSSE file.
//
// Begin prologue.
//
//
// End prologue.
#include <xsd/cxx/pre.hxx>
#include "SimGeomCurve_Line_Default.hxx"
namespace schema
{
namespace simxml
{
namespace ResourcesGeometry
{
// SimGeomCurve_Line_Default
//
}
}
}
#include <xsd/cxx/xml/dom/parsing-source.hxx>
#include <xsd/cxx/tree/type-factory-map.hxx>
namespace _xsd
{
static
const ::xsd::cxx::tree::type_factory_plate< 0, char >
type_factory_plate_init;
}
namespace schema
{
namespace simxml
{
namespace ResourcesGeometry
{
// SimGeomCurve_Line_Default
//
SimGeomCurve_Line_Default::
SimGeomCurve_Line_Default ()
: ::schema::simxml::ResourcesGeometry::SimGeomCurve_Line ()
{
}
SimGeomCurve_Line_Default::
SimGeomCurve_Line_Default (const RefId_type& RefId)
: ::schema::simxml::ResourcesGeometry::SimGeomCurve_Line (RefId)
{
}
SimGeomCurve_Line_Default::
SimGeomCurve_Line_Default (const SimGeomCurve_Line_Default& x,
::xml_schema::flags f,
::xml_schema::container* c)
: ::schema::simxml::ResourcesGeometry::SimGeomCurve_Line (x, f, c)
{
}
SimGeomCurve_Line_Default::
SimGeomCurve_Line_Default (const ::xercesc::DOMElement& e,
::xml_schema::flags f,
::xml_schema::container* c)
: ::schema::simxml::ResourcesGeometry::SimGeomCurve_Line (e, f, c)
{
}
SimGeomCurve_Line_Default* SimGeomCurve_Line_Default::
_clone (::xml_schema::flags f,
::xml_schema::container* c) const
{
return new class SimGeomCurve_Line_Default (*this, f, c);
}
SimGeomCurve_Line_Default::
~SimGeomCurve_Line_Default ()
{
}
}
}
}
#include <istream>
#include <xsd/cxx/xml/sax/std-input-source.hxx>
#include <xsd/cxx/tree/error-handler.hxx>
namespace schema
{
namespace simxml
{
namespace ResourcesGeometry
{
}
}
}
#include <xsd/cxx/post.hxx>
// Begin epilogue.
//
//
// End epilogue.
| [
"cao@e3d.rwth-aachen.de"
] | cao@e3d.rwth-aachen.de |
a4bf5e540bf26ef1f8cdad2cce8b07e82c2a5817 | 3c69215669c81c235c493e568f9e4892c119d915 | /C++/Sortowanie.cpp | 4468914178d27bc9a8be35281ba298b6af48cf46 | [] | no_license | DawidIzydor/AiSD | 0ea0dddcfb4e6bee8051fbaccc6b9622e7a33478 | aadddf35025377cfaf6a25fa980c815dbb20a62d | refs/heads/master | 2020-04-01T04:30:07.214105 | 2018-12-17T10:38:04 | 2018-12-17T10:38:04 | 152,866,292 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,832 | cpp | #include "pch.h"
#include "Sortowanie.h"
#include <iostream>
Sortowanie::Sortowanie()
{
}
Sortowanie::~Sortowanie()
{
}
void Sortowanie::PrzezProsteWybieranie(list<int>& KolecjaDoPosortowania)
{
int iloscIteracji = 0;
for (int i = 0; i < KolecjaDoPosortowania.size()- 1; ++i)
{
iloscIteracji++;
int PozycjaNajmniejszego = i;
for (int j = i + 1; j < KolecjaDoPosortowania.size(); ++j)
{
iloscIteracji++;
if (KolecjaDoPosortowania[j] < KolecjaDoPosortowania[PozycjaNajmniejszego])
{
PozycjaNajmniejszego = j;
}
}
int temp = KolecjaDoPosortowania[PozycjaNajmniejszego];
KolecjaDoPosortowania[PozycjaNajmniejszego] = KolecjaDoPosortowania[i];
KolecjaDoPosortowania[i] = temp;
}
std::cout << "Ilosc iteracji: " << iloscIteracji << std::endl;
}
void Sortowanie::PrzezProsteWstawianie(list<int>& KolekcjaDoPosortowania)
{
int iloscIteracji = 0;
for (int i = 1; i < KolekcjaDoPosortowania.size(); ++i)
{
iloscIteracji++;
int Klucz = KolekcjaDoPosortowania[i];
int j = i - 1;
while (j >= 0 && KolekcjaDoPosortowania[j] > Klucz)
{
iloscIteracji++;
KolekcjaDoPosortowania[j + 1] = KolekcjaDoPosortowania[j];
j--;
}
KolekcjaDoPosortowania[j + 1] = Klucz;
}
std::cout << "Ilosc iteracji: " << iloscIteracji << std::endl;
}
void Sortowanie::Babelkowe(list<int>& KolekcjaDoPosortowania)
{
int iloscIteracji = 0;
int n = KolekcjaDoPosortowania.size();
do
{
iloscIteracji++;
for (int i = 0; i < n - 1; ++i)
{
iloscIteracji++;
if (KolekcjaDoPosortowania[i] > KolekcjaDoPosortowania[i + 1])
{
int temp = KolekcjaDoPosortowania[i];
KolekcjaDoPosortowania[i] = KolekcjaDoPosortowania[i + 1];
KolekcjaDoPosortowania[i + 1] = temp;
}
}
n--;
} while (n > 1);
std::cout << "Ilosc iteracji: " << iloscIteracji << std::endl;
}
| [
"admin@dawid-izydor.pl"
] | admin@dawid-izydor.pl |
6888cd0efcf042d08506a737b5ce5a1827f7ecbb | 2bb354ef07f9043ddaad5ffb09a20b34447cd9d5 | /corelib/huffman.h | 987d8bdfad27a49155ddc0c9ed14bf986fc36cf4 | [
"MIT"
] | permissive | niravcodes/huffman_compression | ddfcfbdd8f7357da4852febb72171422988f3a6c | c0ef06429b617a16aa236082423f36fb0516299c | refs/heads/master | 2021-07-02T05:12:07.908344 | 2020-09-23T09:11:48 | 2020-09-23T09:11:48 | 170,150,311 | 15 | 6 | MIT | 2019-02-16T06:49:23 | 2019-02-11T15:15:03 | C | UTF-8 | C++ | false | false | 888 | h | #ifndef _HUFFMAN_H
#define _HUFFMAN_H
#include "../param_parser.h"
#include "tree.h"
const char _MAGIC_BYTES[] = {'n', 'i', 'r', 'a', 'v', '.', 'c', 'o', 'm', '.', 'n', 'p'};
class huffman_code
{
private:
unsigned code;
unsigned size;
public:
huffman_code();
void add_left();
void add_right();
unsigned get_code() const;
unsigned get_size() const;
void set_code(unsigned);
void set_size(unsigned);
};
std::ostream &operator<<(std::ostream &os, const huffman_code &m); //for debug purpose only
unsigned *count_frequency(input_param);
tree *make_huffman_tree(input_param);
huffman_code *generate_code(tree *);
int encode_file(huffman_code *, input_param);
int output_table(input_param);
int output_code(input_param);
huffman_code *reconstruct_code_from_ascii();
void naive_decode(huffman_code *, input_param);
int naive_decode_with_header(input_param options);
#endif | [
"niravnikhil@gmail.com"
] | niravnikhil@gmail.com |
67a2fb3b6d0fbfbad3d016a288f62f2ce25fe200 | ea91bffc446ca53e5942a571c2f7090310376c9d | /src/syntax/SyntaxKindExtra.cpp | 6d8e5d62d819be6c1200b568115c71b52d92c289 | [] | no_license | macro-l/polarphp | f7b1dc4b609f1aae23b4618fc1176b8c26531722 | f6608c4dc26add94e61684ed0edd3d5c7e86e768 | refs/heads/master | 2022-07-21T23:37:02.237733 | 2019-08-15T10:32:06 | 2019-08-15T10:32:06 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,365 | cpp | // This source file is part of the polarphp.org open source project
//
// Copyright (c) 2017 - 2019 polarphp software foundation
// Copyright (c) 2017 - 2019 zzu_softboy <zzu_softboy@163.com>
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://polarphp.org/LICENSE.txt for license information
// See https://polarphp.org/CONTRIBUTORS.txt for the list of polarphp project authors
//
// Created by polarboy on 2019/05/11.
#include "polarphp/syntax/SyntaxKind.h"
#include "polarphp/syntax/SyntaxNodes.h"
#define SYNTAX_TABLE_ENTRY(kind) {#kind , polar::as_integer<SyntaxKind>(SyntaxKind::kind), \
kind##Syntax::CHILDREN_COUNT, kind##Syntax::REQUIRED_CHILDREN_COUNT}
namespace polar::syntax {
using SyntaxKindEntryType = std::tuple<std::string, std::uint32_t, std::uint32_t, std::uint32_t>;
/// name - serialization_code - children_count - required_children_count
static const std::map<SyntaxKind, SyntaxKindEntryType> scg_syntaxKindTable
{
{SyntaxKind::Decl, SYNTAX_TABLE_ENTRY(Decl)},
{SyntaxKind::Expr, SYNTAX_TABLE_ENTRY(Expr)},
{SyntaxKind::Stmt, SYNTAX_TABLE_ENTRY(Stmt)},
{SyntaxKind::Token, SYNTAX_TABLE_ENTRY(Token)},
{SyntaxKind::Unknown, SYNTAX_TABLE_ENTRY(Unknown)},
// {SyntaxKind::CodeBlockItem, SYNTAX_TABLE_ENTRY(CodeBlockItem)},
// {SyntaxKind::CodeBlock, SYNTAX_TABLE_ENTRY(CodeBlock)},
// {SyntaxKind::TokenList, SYNTAX_TABLE_ENTRY(TokenList)},
// {SyntaxKind::NonEmptyTokenList, SYNTAX_TABLE_ENTRY(NonEmptyTokenList)},
// {SyntaxKind::CodeBlockItemList, SYNTAX_TABLE_ENTRY(CodeBlockItemList)}
};
StringRef retrieve_syntax_kind_text(SyntaxKind kind)
{
auto iter = scg_syntaxKindTable.find(kind);
if (iter == scg_syntaxKindTable.end()) {
return StringRef();
}
return std::get<0>(iter->second);
}
int retrieve_syntax_kind_serialization_code(SyntaxKind kind)
{
auto iter = scg_syntaxKindTable.find(kind);
if (iter == scg_syntaxKindTable.end()) {
return -1;
}
return std::get<1>(iter->second);
}
std::pair<std::uint32_t, std::uint32_t> retrieve_syntax_kind_child_count(SyntaxKind kind, bool &exist)
{
auto iter = scg_syntaxKindTable.find(kind);
if (iter == scg_syntaxKindTable.end()) {
exist = false;
return {-1, -1};
}
exist = true;
return {std::get<2>(iter->second), std::get<3>(iter->second)};
}
} // polar::syntax
| [
"zzu_softboy@163.com"
] | zzu_softboy@163.com |
0157ea97c5f90c45b3ee7c91cc796d0d9900e803 | a17cd68b5f119c43f68c7135856f34d0ac91f5fe | /flappy_bird/src/main.cxx | 3b146773ea58fe7d380f1e4b63c6ddd3f111e7ba | [] | no_license | claiirelu/cpp-flappybird | f7ee3a2e013d569651ab7f39e3e8a7a04bd6f013 | f5d8575511162acb63f14d71b8658250e10c8dd6 | refs/heads/master | 2023-07-09T04:17:10.600262 | 2021-08-17T20:52:13 | 2021-08-17T20:52:13 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 136 | cxx | #include "controller.hxx"
#include "model.hxx"
int
main()
{
Model model;
Controller controller(model);
controller.run();
}
| [
"isabelzhong30@gmail.com"
] | isabelzhong30@gmail.com |
def051f305bf9dbf5dd85cf9b1be388d019a74ba | 6b40e9dccf2edc767c44df3acd9b626fcd586b4d | /NT/base/fs/utils/ifsutil/src/autoreg.cxx | a477ce8745ac8a96e0d0a336206211e6a322ef2b | [] | no_license | jjzhang166/WinNT5_src_20201004 | 712894fcf94fb82c49e5cd09d719da00740e0436 | b2db264153b80fbb91ef5fc9f57b387e223dbfc2 | refs/heads/Win2K3 | 2023-08-12T01:31:59.670176 | 2021-10-14T15:14:37 | 2021-10-14T15:14:37 | 586,134,273 | 1 | 0 | null | 2023-01-07T03:47:45 | 2023-01-07T03:47:44 | null | UTF-8 | C++ | false | false | 15,271 | cxx | /*++
Copyright (c) 1992-2000 Microsoft Corporation
Module Name:
autoreg
Abstract:
This module contains the definition of the AUTOREG class.
The AUTOREG class contains methods for the registration and
de-registration of those programs that are to be executed at
boot time.
Author:
Ramon J. San Andres (ramonsa) 11 Mar 1991
Environment:
Ulib, User Mode
--*/
#include <pch.cxx>
#define _NTAPI_ULIB_
#define _IFSUTIL_MEMBER_
#include "ulib.hxx"
#include "ifsutil.hxx"
#include "autoreg.hxx"
#include "autoentr.hxx"
extern "C" {
#include <stdio.h>
#include "bootreg.h"
}
CONST BootExecuteBufferSize = 0x2000;
IFSUTIL_EXPORT
BOOLEAN
AUTOREG::AddEntry (
IN PCWSTRING CommandLine
)
{
BYTE BootExecuteBuffer[BootExecuteBufferSize];
PWCHAR BootExecuteValue = (PWCHAR)BootExecuteBuffer;
ULONG CharsInValue, NewCharCount;
// Fetch the existing autocheck entries.
//
if( !QueryAutocheckEntries( BootExecuteValue,
BootExecuteBufferSize ) ) {
return FALSE;
}
// Determine if the new entry fits in our buffer. The
// new size will be the chars in the existing value
// plus the length of the new string plus a terminating
// null for the new string plus a terminating null for
// the multi-string value.
//
CharsInValue = CharsInMultiString( BootExecuteValue );
NewCharCount = CharsInValue + CommandLine->QueryChCount() + 2;
if( NewCharCount * sizeof( WCHAR ) > BootExecuteBufferSize ) {
// Not enough room.
//
return FALSE;
}
// Add the new entry to the buffer and add a terminating null
// for the multi-string:
//
if( !CommandLine->QueryWSTR( 0,
TO_END,
BootExecuteValue + CharsInValue,
BootExecuteBufferSize/sizeof(WCHAR) -
CharsInValue ) ) {
// Couldn't get the WSTR.
//
return FALSE;
}
BootExecuteValue[ NewCharCount - 1 ] = 0;
// Write the value back into the registry:
//
return( SaveAutocheckEntries( BootExecuteValue ) );
}
IFSUTIL_EXPORT
BOOLEAN
AUTOREG::PushEntry (
IN PCWSTRING CommandLine
)
{
BYTE BootExecuteBuffer[BootExecuteBufferSize];
PWCHAR BootExecuteValue = (PWCHAR)BootExecuteBuffer;
ULONG CharsInValue, NewCharCount;
// Fetch the existing autocheck entries.
//
if( !QueryAutocheckEntries( BootExecuteValue,
BootExecuteBufferSize ) ) {
return FALSE;
}
// Determine if the new entry fits in our buffer. The
// new size will be the chars in the existing value
// plus the length of the new string plus a terminating
// null for the new string plus a terminating null for
// the multi-string value.
//
CharsInValue = CharsInMultiString( BootExecuteValue ) + 1;
NewCharCount = CharsInValue + CommandLine->QueryChCount() + 1;
if( NewCharCount * sizeof( WCHAR ) > BootExecuteBufferSize ) {
// Not enough room.
//
return FALSE;
}
// Add the new entry to the buffer and add a terminating null
// for the multi-string:
//
memmove(BootExecuteValue + CommandLine->QueryChCount() + 1,
BootExecuteValue,
CharsInValue*sizeof(WCHAR));
if( !CommandLine->QueryWSTR( 0,
TO_END,
BootExecuteValue,
NewCharCount
)) {
// Couldn't get the WSTR.
//
return FALSE;
}
// Write the value back into the registry:
//
return( SaveAutocheckEntries( BootExecuteValue ) );
}
IFSUTIL_EXPORT
BOOLEAN
AUTOREG::DeleteEntry (
IN PCWSTRING LineToMatch,
IN BOOLEAN PrefixOnly
)
/*++
Routine Description:
This method removes an Autocheck entry.
Arguments:
LineToMatch -- Supplies a pattern for the entry to delete.
All lines which match this pattern will be
deleted.
PrefixOnly -- LineToMatch specifies a prefix, and all lines
beginning with that prefix are deleted.
Return Value:
TRUE upon successful completion. Note that this function
will return TRUE if no matching entry is found, or if a
matching entry is found and removed.
Notes:
Since the utilities only assume responsibility for removing
entries which we created in the first place, we can place
very tight constraints on the matching pattern. In particular,
we can require an exact match (except for case).
--*/
{
DSTRING CurrentString;
BYTE BootExecuteBuffer[BootExecuteBufferSize];
PWCHAR BootExecuteValue = (PWCHAR)BootExecuteBuffer;
PWCHAR pw;
// Fetch the existing entries:
//
if( !QueryAutocheckEntries( BootExecuteValue,
BootExecuteBufferSize ) ) {
return FALSE;
}
// Spin through the entries looking for matches:
//
pw = BootExecuteValue;
while( *pw ) {
if( !CurrentString.Initialize( pw ) ) {
return FALSE;
}
if( CurrentString.Stricmp( LineToMatch ) == 0 ||
(PrefixOnly && CurrentString.Stricmp( LineToMatch,
0, LineToMatch->QueryChCount(),
0, LineToMatch->QueryChCount()) == 0)) {
// This line is a match--delete it. We simply expunge
// the current string plus its terminating null by
// shifting the data beyond that point down.
//
memmove( pw,
pw + CurrentString.QueryChCount() + 1,
BootExecuteBufferSize - (unsigned int)(pw - BootExecuteValue) * sizeof(WCHAR) );
} else {
// This line is not a match. Advance to the next.
// Note that this will bump over the terminating
// null for this component string, which is what
// we want.
//
while( *pw++ );
}
}
return( SaveAutocheckEntries( BootExecuteValue ) );
}
IFSUTIL_EXPORT
BOOLEAN
AUTOREG::DeleteEntry (
IN PCWSTRING PrefixToMatch,
IN PCWSTRING ContainingString
)
/*++
Routine Description:
This method removes an entry that matches the PrefixToMatch and
also contains the ContainingString.
Arguments:
PrefixToMatch -- Supplies a prefix pattern of interest.
ContainingString -- Supplies a string to look for in each entry.
Return Value:
TRUE upon successful completion. Note that this function
will return TRUE if no matching entry is found, or if a
matching entry is found and removed.
Notes:
Since the utilities only assume responsibility for removing
entries which we created in the first place, we can place
very tight constraints on the matching pattern. In particular,
we can require an exact match (except for case).
--*/
{
DSTRING CurrentString;
DSTRING ContainingStringUpcase;
BYTE BootExecuteBuffer[BootExecuteBufferSize];
PWCHAR BootExecuteValue = (PWCHAR)BootExecuteBuffer;
PWCHAR pw;
// Fetch the existing entries:
//
if( !QueryAutocheckEntries( BootExecuteValue,
BootExecuteBufferSize ) ) {
return FALSE;
}
if (!ContainingStringUpcase.Initialize( ContainingString ) ||
!ContainingStringUpcase.Strupr())
return FALSE;
// Spin through the entries looking for matches:
//
pw = BootExecuteValue;
while( *pw ) {
if( !CurrentString.Initialize( pw ) ||
!CurrentString.Strupr() ) {
return FALSE;
}
if( CurrentString.Stricmp( PrefixToMatch,
0,
PrefixToMatch->QueryChCount(),
0,
TO_END ) == 0 &&
CurrentString.Strstr( &ContainingStringUpcase ) != INVALID_CHNUM ) {
// This line is a match--delete it. We simply expunge
// the current string plus its terminating null by
// shifting the data beyond that point down.
//
memmove( pw,
pw + CurrentString.QueryChCount() + 1,
BootExecuteBufferSize - (unsigned int)(pw - BootExecuteValue) * sizeof(WCHAR) );
} else {
// This line is not a match. Advance to the next.
// Note that this will bump over the terminating
// null for this component string, which is what
// we want.
//
while( *pw++ );
}
}
return( SaveAutocheckEntries( BootExecuteValue ) );
}
IFSUTIL_EXPORT
BOOLEAN
AUTOREG::IsEntryPresent (
IN PCWSTRING LineToMatch
)
/*++
Routine Description:
This method determines whether a proposed entry for the
autocheck list is already in the registry.
Arguments:
LineToMatch -- Supplies a pattern for proposed entry.
Return Value:
TRUE if a matching entry exists.
--*/
{
DSTRING CurrentString;
BYTE BootExecuteBuffer[BootExecuteBufferSize];
PWCHAR BootExecuteValue = (PWCHAR)BootExecuteBuffer;
PWCHAR pw;
// Fetch the existing entries:
//
if( !QueryAutocheckEntries( BootExecuteValue,
BootExecuteBufferSize ) ) {
return FALSE;
}
// Spin through the entries looking for matches:
//
pw = BootExecuteValue;
while( *pw ) {
if( !CurrentString.Initialize( pw ) ) {
return FALSE;
}
if( CurrentString.Stricmp( LineToMatch ) == 0 ) {
// This line is a match.
//
return TRUE;
} else {
// This line is not a match. Advance to the next.
// Note that this will bump over the terminating
// null for this component string, which is what
// we want.
//
while( *pw++ );
}
}
return FALSE;
}
IFSUTIL_EXPORT
BOOLEAN
AUTOREG::IsEntryPresent (
IN PCWSTRING PrefixToMatch,
IN PCWSTRING ContainingString
)
/*++
Routine Description:
This method search for an entry that matches the PrefixToMatch and
also contains the ContainingString.
Arguments:
PrefixToMatch -- Supplies a prefix pattern of interest.
ContainingString -- Supplies a string to look for in each entry.
Return Value:
TRUE if a matching entry exists.
--*/
{
DSTRING CurrentString;
DSTRING ContainingStringUpcase;
BYTE BootExecuteBuffer[BootExecuteBufferSize];
PWCHAR BootExecuteValue = (PWCHAR)BootExecuteBuffer;
PWCHAR pw;
// Fetch the existing entries:
//
if( !QueryAutocheckEntries( BootExecuteValue,
BootExecuteBufferSize ) ) {
return FALSE;
}
if (!ContainingStringUpcase.Initialize( ContainingString ) ||
!ContainingStringUpcase.Strupr())
return FALSE;
// Spin through the entries looking for matches:
//
pw = BootExecuteValue;
while( *pw ) {
if( !CurrentString.Initialize( pw ) ||
!CurrentString.Strupr() ) {
return FALSE;
}
if( CurrentString.Stricmp( PrefixToMatch,
0,
PrefixToMatch->QueryChCount(),
0,
TO_END ) == 0 &&
CurrentString.Strstr( &ContainingStringUpcase ) != INVALID_CHNUM ) {
return TRUE;
} else {
// This line is not a match. Advance to the next.
// Note that this will bump over the terminating
// null for this component string, which is what
// we want.
//
while( *pw++ );
}
}
return FALSE;
}
IFSUTIL_EXPORT
BOOLEAN
AUTOREG::IsFrontEndPresent (
IN PCWSTRING PrefixToMatch,
IN PCWSTRING SuffixToMatch
)
/*++
Routine Description:
This method search for an entry that matches the PrefixToMatch and
the SuffixToMatch.
Arguments:
PrefixToMatch -- Supplies a prefix pattern of interest.
SuffixToMatch -- Supplies a suffix pattern of interest.
Return Value:
TRUE if a matching entry exists.
--*/
{
DSTRING CurrentString;
DSTRING SuffixUpcase;
BYTE BootExecuteBuffer[BootExecuteBufferSize];
PWCHAR BootExecuteValue = (PWCHAR)BootExecuteBuffer;
PWCHAR pw;
// Fetch the existing entries:
//
if( !QueryAutocheckEntries( BootExecuteValue,
BootExecuteBufferSize ) ) {
return FALSE;
}
if (!SuffixUpcase.Initialize( SuffixToMatch ) ||
!SuffixUpcase.Strupr())
return FALSE;
// Spin through the entries looking for matches:
//
pw = BootExecuteValue;
while( *pw ) {
if( !CurrentString.Initialize( pw ) ||
!CurrentString.Strupr() ) {
return FALSE;
}
if( CurrentString.Stricmp( PrefixToMatch,
0,
PrefixToMatch->QueryChCount(),
0,
TO_END ) == 0 ) {
if ((CurrentString.QueryChCount() >=
(PrefixToMatch->QueryChCount() + SuffixUpcase.QueryChCount())) &&
CurrentString.Stricmp( SuffixToMatch,
CurrentString.QueryChCount() - SuffixUpcase.QueryChCount(),
TO_END,
0,
TO_END ) == 0 ) {
return TRUE;
} else {
// This line is not a match. Advance to the next.
// Note that this will bump over the terminating
// null for this component string, which is what
// we want.
//
while( *pw++ );
}
} else {
// This line is not a match. Advance to the next.
// Note that this will bump over the terminating
// null for this component string, which is what
// we want.
//
while( *pw++ );
}
}
return FALSE;
}
| [
"seta7D5@protonmail.com"
] | seta7D5@protonmail.com |
e50d3723d167dfbdf28875a319bc645e136b03b0 | e43d84b05d34eaad67064be4356c6a711fc17a21 | /UI-Qt/QXDocumentWindowManager.cpp | 57f8466bd996683f41e2cf4b064ed3cd52207b96 | [
"MIT"
] | permissive | frinkr/FontViewer | 5bb3593960426db8399679180bb2bbfff879aac8 | 6dbd24ca605605edc01aa172327238c932a14082 | refs/heads/master | 2022-03-12T23:14:06.602826 | 2022-02-24T02:08:17 | 2022-02-24T02:08:17 | 126,189,660 | 2 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 12,552 | cpp | #include <QApplication>
#include <QDockWidget>
#include <QFileDialog>
#include <QFileIconProvider>
#include <QInputDialog>
#include <QMenu>
#include <QMenuBar>
#include <QMessageBox>
#include <QMetaType>
#include <QSplashScreen>
#include <QtDebug>
#include <QtGui>
#include "FontX/FXFace.h"
#include "QXApplication.h"
#include "QXConv.h"
#include "QXDockTitleBarWidget.h"
#include "QXDocumentWindow.h"
#include "QXDocumentWindowManager.h"
#include "QXFontListView.h"
#include "QXFontListWindow.h"
#include "QXFontCollectionDialog.h"
#include "QXMenuBar.h"
namespace {
QString fileTypeFilterToString(QXDocumentWindowManager::FileTypeFilter filter) {
QString string;
switch (filter) {
case QXDocumentWindowManager::FileTypeFilter::Font:
string = QXDocumentWindowManager::tr("Font files (*.ttf *.otf *.ttc *.pfa *.pfb)");
break;
case QXDocumentWindowManager::FileTypeFilter::PDF:
string = QXDocumentWindowManager::tr("PDF files (*.pdf)");
break;
default:
string = QXDocumentWindowManager::tr("All Files (*)");
break;
}
return string;
}
QString fileTypeFiltersFullString() {
QXDocumentWindowManager::FileTypeFilter filters[] = {
QXDocumentWindowManager::FileTypeFilter::Font,
QXDocumentWindowManager::FileTypeFilter::PDF,
QXDocumentWindowManager::FileTypeFilter::All
};
QStringList text;
for (auto filter : filters)
text << fileTypeFilterToString(filter);
return text.join(";;");
}
const char * sKeyFontInstanceID = "FontInstanceID";
}
QXDocumentWindowManager * QXDocumentWindowManager::instance_ = nullptr;
QXDocumentWindowManager::QXDocumentWindowManager() {
#ifdef Q_OS_MAC
// Create default menu bar.
new QXMenuBar();
#endif
recentFonts_ = QXPreferences::recentFonts();
connect(qApp, &QXApplication::aboutToQuit, [this]() {
appIsAboutToQuit_ = true;
QXPreferences::setRecentFonts(recentFonts_);
});
}
QXDocumentWindowManager::~QXDocumentWindowManager() {
delete fontListWindow_;
}
// Singleton
QXDocumentWindowManager *
QXDocumentWindowManager::instance() {
if (instance_ == nullptr)
instance_ = new QXDocumentWindowManager;
return instance_;
}
void
QXDocumentWindowManager::addDocument(QXDocument * document) {
if (documents_.indexOf(document) == -1)
documents_.append(document);
}
void
QXDocumentWindowManager::removeDocument(QXDocument * document) {
for (int i = documents_.count() - 1; i >= 0; --i)
if (documents_.at(i) == document)
documents_.removeAt(i);
}
const QList<QXDocument *> &
QXDocumentWindowManager::documents() const {
return documents_;
}
QXDocument *
QXDocumentWindowManager::getDocument(const QXFontURI & fontURI) const {
foreach (QPointer<QXDocument> document, documents_) {
if (document->uri() == fontURI)
return document;
}
return nullptr;
}
QXDocumentWindow *
QXDocumentWindowManager::getDocumentWindow(const QXDocument * document) const {
for (auto window: documentWindows()) {
if (window->document() == document)
return window;
}
return nullptr;
}
QXDocumentWindow *
QXDocumentWindowManager::createDocumentWindow(QXDocument * document) {
QXDocumentWindow * window = new QXDocumentWindow(document, nullptr);
addManagedWindow(window);
return window;
}
void
QXDocumentWindowManager::addManagedWindow(QWidget * window)
{
connect(window, &QWidget::destroyed, [window, this]() {
removeManagedWindow(window);
if (auto itr = windowToDocumentMap_.find(window); itr != windowToDocumentMap_.end())
removeDocument(itr.value());
#if defined(Q_OS_MACOS)
if (!appIsAboutToQuit_ && documents_.empty())
showFontListWindow();
#endif
});
managedWindows_.append(window);
if (auto documentWindow = qobject_cast<QXDocumentWindow *>(window))
windowToDocumentMap_[window] = documentWindow->document();
}
void
QXDocumentWindowManager::removeManagedWindow(QWidget * window)
{
// remove from window list
for (int i = managedWindows_.count() - 1; i >= 0; --i)
if (managedWindows_.at(i) == window)
managedWindows_.removeAt(i);
}
const QList<QXRecentFontItem> &
QXDocumentWindowManager::recentFonts() const {
return recentFonts_;
}
void
QXDocumentWindowManager::aboutToShowWindowMenu(QMenu * menu) {
QList<QAction *> actionsToRemove;
for (QAction * action: menu->actions()) {
QVariant data = action->data();
if (data.canConvert<bool>())
actionsToRemove.append(action);
}
for (QAction * action: actionsToRemove) {
menu->removeAction(action);
}
foreach(QWidget * window, managedWindows_) {
QAction * action = new QAction(window->windowTitle(), menu);
connect(action, &QAction::triggered, this, [window]() {
qApp->bringWindowToFront(window);
});
action->setData(QVariant(true));
action->setCheckable(true);
action->setChecked(window->isActiveWindow());
menu->addAction(action);
}
}
void
QXDocumentWindowManager::reloadRecentMenu(QMenu * recentMenu, bool includeIcon) {
recentMenu->clear();
foreach(QXRecentFontItem font, recentFonts_) {
QAction * action = recentMenu->addAction(font.fullName);
action->setData(QVariant::fromValue<QXFontURI>(font));
if (includeIcon) {
QFileInfo fi(font.filePath);
action->setIcon(QFileIconProvider().icon(fi));
}
}
}
bool
QXDocumentWindowManager::handleDropEvent(QDropEvent * event) {
bool ok = false;
for (const QUrl & url: event->mimeData()->urls()) {
QString filePath = url.toLocalFile();
ok |= QXDocumentWindowManager::instance()->openFontFile(filePath);
}
return ok;
}
void
QXDocumentWindowManager::showFontListWindow() {
QXFontListWindow * isCreatingFontListWindow = (QXFontListWindow*)(-1);
if (fontListWindow_ == isCreatingFontListWindow)
// there is possible recursive creation of QXFontListWindow. When the splash is dismissed in
// constructor of QXFontListWindow, the MacApplicationDelegate.applicationOpenUntitledFile may
// run again in the event loop (e.g. user keeps clicking the icon in Dock bar)
return;
if (!fontListWindow_) {
fontListWindow_ = isCreatingFontListWindow;
fontListWindow_ = new QXFontListWindow(nullptr);
connect(fontListWindow_, &QXFontListWindow::fontSelected, this, [this]() {
const QXFontURI fontURI = fontListWindow_->selectedFont();
openFontURI(fontURI);
});
}
qApp->bringWindowToFront(fontListWindow_);
fontListWindow_->searchLineEdit()->setFocus();
}
void
QXDocumentWindowManager::autoShowFontListWindow() {
if (appIsAboutToQuit_)
return;
if (documents().empty()) {
bool hasWindow = false;
for (QWidget * widget: qApp->allWidgets()) {
QWidget * window = widget->window();
if (window &&
window->isWindow() &&
window->isVisible()
&& !qobject_cast<QMenuBar*>(window)
&& !qobject_cast<QMenu*>(window)
&& !qobject_cast<QSplashScreen*>(window))
{
hasWindow = true;
break;
}
}
if (!hasWindow)
showFontListWindow();
}
}
void
QXDocumentWindowManager::addToRecents(QXDocument * document) {
QXRecentFontItem item;
item.filePath = document->uri().filePath;
item.faceIndex = document->uri().faceIndex;
item.fullName = QXDocument::faceDisplayName(document->face()->attributes(), FXFaceLanguages::en);
// add or move to front
int index = recentFonts_.indexOf(item);
if (index != -1)
recentFonts_.takeAt(index);
recentFonts_.insert(0, item);
while (recentFonts_.size() > kMaxRecentFiles)
recentFonts_.takeLast();
}
bool
QXDocumentWindowManager::doNativeOpenFileDialog(FileTypeFilter selectedTypeFilter) {
QFileDialog openFileDialog(nullptr);
openFileDialog.setFileMode(QFileDialog::ExistingFile);
openFileDialog.setNameFilter(fileTypeFiltersFullString());
openFileDialog.selectNameFilter(fileTypeFilterToString(selectedTypeFilter));
if (QDialog::Accepted == openFileDialog.exec()) {
return openFontFile(openFileDialog.selectedFiles()[0]);
}
return false;
}
bool
QXDocumentWindowManager::doQuickOpenFontDialog() {
QInputDialog dialog(nullptr);
dialog.setInputMode(QInputDialog::TextInput);
dialog.setWindowTitle(tr("Open Font File"));
dialog.setLabelText(tr("Please input the font path:"));
if (dialog.exec() == QDialog::Accepted) {
if (auto text = dialog.textValue(); !text.isEmpty())
return openFontFile(text);
}
return false;
}
bool
QXDocumentWindowManager::openFontFile(const QString & filePath) {
auto initFace = FXFace::createFace(toStdString(filePath), 0);
size_t faceCount = initFace? initFace->faceCount(): 0;
if (faceCount == 1) {
QXFontURI uri {filePath, 0};
return openFontURI(uri, initFace);
}
else if (faceCount > 1) {
int index = QXFontCollectionDialog::selectFontIndex(filePath, initFace);
if (index != -1) {
QXFontURI uri {filePath, static_cast<size_t>(index)};
return openFontURI(uri, initFace);
}
}
else {
showOpenFontFileError(filePath, nullptr);
}
return false;
}
bool
QXDocumentWindowManager::openFontURI(const QXFontURI & uri, FXPtr<FXFace> initFace, bool forceNewWindowInstance) {
if (fontListWindow_ && fontListWindow_->isVisible())
fontListWindow_->close();
// check already open
QXDocument * openDocument = getDocument(uri);
if (!forceNewWindowInstance && openDocument) {
qApp->bringWindowToFront(getDocumentWindow(openDocument));
return true;
}
else {
// or open new
QXDocument * newDocument = QXDocument::openFromURI(uri, initFace, this);
if (newDocument) {
newDocument->setFontInstanceId(newFontInstanceId(uri));
addDocument(newDocument);
addToRecents(newDocument);
QXDocumentWindow * window = createDocumentWindow(newDocument);
if (auto activeWindow = activeDocumentWindow()) {
window->show();
window->move(activeWindow->pos() + QPoint(50, 50));
}
else {
window->show();
}
return true;
} else {
showOpenFontFileError(uri.filePath, initFace);
return false;
}
}
}
void
QXDocumentWindowManager::showOpenFontFileError(const QString & file, FXPtr<FXFace> initFace) {
QMessageBox::critical(nullptr,
tr("Error to open file"),
tr("The file %1 can't be open. (init font %2)")
.arg(file)
.arg(initFace? toQString(initFace->postscriptName()): "<null>"),
QMessageBox::Ok);
}
QXDocumentWindow *
QXDocumentWindowManager::activeDocumentWindow() const {
for (auto window : documentWindows()) {
if (window->isActiveWindow())
return window;
}
return nullptr;
}
void
QXDocumentWindowManager::closeAllDocuments() {
for (int i = 0; i < managedWindows_.size(); i++)
managedWindows_[i]->close();
}
void
QXDocumentWindowManager::closeAllDocumentsAndQuit() {
closeAllDocuments();
QXPreferences::setRecentFonts(recentFonts_);
delete fontListWindow_;
fontListWindow_ = nullptr;
appIsAboutToQuit_ = true;
QTimer::singleShot(100, qApp, &QXApplication::quit);
}
QList<QXDocumentWindow *>
QXDocumentWindowManager::documentWindows() const {
QList<QXDocumentWindow *> windows;
for (auto widget: managedWindows_) {
if (auto window = qobject_cast<QXDocumentWindow*>(widget))
windows.append(window);
}
return windows;
}
int
QXDocumentWindowManager::newFontInstanceId(const QXFontURI & uri) {
int maxId = -1;
for (auto doc: documents_) {
if (doc->uri() == uri)
maxId = std::max(maxId, doc->fontInstanceId());
}
return maxId + 1;
}
| [
"frinkr@outlook.com"
] | frinkr@outlook.com |
3b977e790df46c909b66cf5b4055d41a009f796f | c4bf478aa387b2459e24a30862f1008621801289 | /HVStab/device.cpp | d1c7c3cd42191734e5aaec5499ed4347bf86ba24 | [] | no_license | Iuve/HVStab | 110d66978e535014637bdeec2763c5971617955c | a248e8e6cd4645cb5d257ce1be34a0909e96f77e | refs/heads/master | 2023-03-17T20:15:20.368853 | 2021-03-10T14:30:20 | 2021-03-10T14:30:20 | 340,438,366 | 0 | 1 | null | 2021-03-10T12:59:33 | 2021-02-19T17:14:40 | C++ | UTF-8 | C++ | false | false | 1,261 | cpp | #include "device.h"
Device::Device()
{
}
Device::Device(int channelNumber,
string deviceName,
string deviceType,
hv initHV,
hv limitHV,
double initLP,
string deviceDRSAdress,
bool status){
SetChannelNumber(channelNumber);
SetDeviceName(deviceName);
SetDeviceType(deviceType);
SetDeviceInitHV(initHV);
SetDeviceLimitHV(limitHV);
SetDeviceStatusON(status);
hv currHV(0.0, 0.0); // to fill zeros in to the table not any random values
SetDeviceCurrHV(currHV);
SetDeviceInitLP(initLP);
SetDeviceCurrLP(600);
// AddHistoryHVData(0.0);
SetDeviceDRSAdress(deviceDRSAdress);
}
void Device::AddHistoryHVData(double value)
{
deviceHistoryHVkey_.push_back(QDateTime::currentDateTime().toTime_t());
deviceHistoryHVvalue_.push_back(value);
// qDebug() << "nowa wartosc HV dodana" << value << deviceHistoryHVvalue_.size();
}
void Device::AddHistoryLPData(double value)
{
deviceHistoryLPkey_.push_back(QDateTime::currentDateTime().toTime_t());
deviceHistoryLPvalue_.push_back(value);
// qDebug() << "nowa wartosc LP dodana" << value << deviceHistoryLPvalue_.size();
}
| [
"michalstepaniuk@op.pl"
] | michalstepaniuk@op.pl |
794fd0357d0d87ead4d83974227a474698a8cae8 | 7d49634e9bd4a4bcf452a8460986bbf73f4e8a96 | /Trees/PostOrderIterative.cpp | 1aa3889f5416dd92f8fd8de7ce6bdff6767a7428 | [] | no_license | manohar2000/DSA_450 | 14921d70b5f59cd65ff5a01e00f823bf68c2419d | 2199debc468d020f5c293692c5c409f81d3fbb1a | refs/heads/main | 2023-05-05T05:37:07.206956 | 2021-05-26T04:52:03 | 2021-05-26T04:52:03 | 320,508,104 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 989 | cpp | #include <bits/stdc++.h>
using namespace std;
class node
{
public:
int data;
node* left;
node* right;
node(int d)
{
data = d;
left = NULL;
right = NULL;
}
};
node* buildTree()
{
int d;
cin>>d;
if(d==-1) return NULL;
else
{
node* root = new node(d);
root->left = buildTree();
root->right = buildTree();
return root;
}
}
void printPostOrder(node* root)
{
stack<node*> s;
s.push(root);
stack<int> out;
while (!s.empty())
{
node *curr = s.top();
s.pop();
out.push(curr->data);
if (curr->left)
s.push(curr->left);
if (curr->right)
s.push(curr->right);
}
while (!out.empty())
{
cout << out.top() << " ";
out.pop();
}
}
int main()
{
node* root = buildTree();
printPostOrder(root);
return 0;
} | [
"maohar502@gmail.com"
] | maohar502@gmail.com |
34cb615a6e9c5ed30eda123f062c7989986df8b1 | 7f1f2d028a0faa297617a4e2070714891df11688 | /ch12/1209placenew2.cpp | ed3c1d125f7212ae16e931a0624fc7ae8b46619a | [] | no_license | mallius/CppPrimerPlus | 3487058a82d74ef0dd0c51b19c9f082b89c0c3f3 | 2a1ca08b4cdda542bb5cda35c8c5cfd903f969eb | refs/heads/master | 2021-01-01T04:12:16.783696 | 2018-03-08T13:49:17 | 2018-03-08T13:49:17 | 58,808,717 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,295 | cpp | #include <iostream>
#include <string>
#include <new>
using namespace std;
const int BUF = 512;
class JustTesting
{
private:
string words;
int number;
public:
JustTesting(const string &s = "Just Testing", int n = 0)
{ words = s; number = n; cout << words << " constructed\n"; }
~JustTesting(){ cout << words << " destroyed\n"; }
void Show() const { cout << words << ", " << number << endl; }
};
int main(void)
{
char *buffer = new char[BUF]; //get a block of memory
JustTesting *pc1, *pc2;
pc1 = new (buffer) JustTesting;
pc2 = new JustTesting("Heap1", 20);
cout << "Memory block address:\n" << "buffer: "
<< (void *)buffer << " heap: " << pc2 << endl;
cout << "Memory contents:\n";
cout << pc1 << ": ";
pc1->Show();
cout << pc2 << ": ";
pc2->Show();
JustTesting *pc3, *pc4;
//fix placement new location
pc3 = new (buffer + sizeof(JustTesting)) JustTesting("Bad Idea", 6);
pc4 = new JustTesting("Heap2", 10);
cout << "Memory contents:\n";
cout << pc3 << ": ";
pc3->Show();
cout << pc4 << ": ";
pc4->Show();
delete pc2;
delete pc4;
//explicitly destroy placement new objects
pc3->~JustTesting(); //destroy object pointed to by pc3
pc1->~JustTesting(); //destroy object pointed to by pc1
delete [] buffer; //free buffer
cout << "Done\n";
return 0;
}
| [
"mallius@qq.com"
] | mallius@qq.com |
a162157eb5de2a0afa55d3d29a804ae594930c02 | d347554c4bc24b7e159551007f5683cac8fa97d0 | /common/protocols/xtproto/src/XtSubscribeMessage.h | a1f1e327508424720c05403c4536390da62f7782 | [] | no_license | ansartnl/ALPHA | 892065b1476ec9c35e834a3158592332cda4c5f5 | 138ddd981ed5bac882c29f28a065171e51d680cf | refs/heads/main | 2022-12-27T16:15:28.721053 | 2020-10-16T08:58:41 | 2020-10-16T08:58:41 | 304,633,537 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,270 | h | #ifndef XT_SUBSCRIBE_MESSAGE_H
#define XT_SUBSCRIBE_MESSAGE_H
#include "xtproto_global.h"
#include "XtDefines.h"
#include "XtTypes.h"
#include "XtMessage.h"
#include <QDataStream>
XT_BEGIN_NAMESPACE
//! Message class for storing subscribe notification
class XTPROTO_EXPORT CSubscribeMessage : public CMessage
{
public:
//! Constructs null data message.
CSubscribeMessage()
: m_SubsType(0)
{}
//! Serialization handler.
/*!
\param out Output data stream
*/
virtual void Serialize(QDataStream& out)
{
CMessage::Serialize(out);
out << m_SubsType;
}
//! Deserialization handler.
/*!
\param in Input data stream
\param isPartial True if only current class types deserialization is required
*/
virtual void Deserialize(QDataStream& in, bool isPartial = false)
{
if ( !isPartial )
CMessage::Deserialize(in, isPartial);
in >> m_SubsType;
}
//! Type of subscription
PROPERTY_DECL(int, SubsType);
XT_MESSAGE_TYPE_DECL
protected:
//! Constructor for specific data message.
CSubscribeMessage(int type)
: CMessage((int)ESubscribe), m_SubsType(type)
{}
};
XT_END_NAMESPACE
#endif // XT_SUBSCRIBE_MESSAGE_H
| [
"50514882+dg-atmsys@users.noreply.github.com"
] | 50514882+dg-atmsys@users.noreply.github.com |
fb62705cca8d18cdb00970cbda42b76ea7947d99 | 157c466d9577b48400bd00bf4f3c4d7a48f71e20 | /Source/ProjectR/UI/ItemManagement/UP_ItemOptionReset.h | 963f89bfee64d8aaed8a92f0ecece0a862a8cc03 | [] | no_license | SeungyulOh/OverlordSource | 55015d357297393c7315c798f6813a9daba28b15 | 2e2339183bf847663d8f1722ed0f932fed6c7516 | refs/heads/master | 2020-04-19T16:00:25.346619 | 2019-01-30T06:41:12 | 2019-01-30T06:41:12 | 168,291,223 | 8 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 4,150 | h | #pragma once
#include "UI/RBaseWidget.h"
#include "UC_GenericPopupContent.h"
#include "Network/PacketDataStructures.h"
#include "Table/ItemTableInfo.h"
#include "UC_HeroItemInfo.h"
#include "UP_ItemInventoryPage.h"
#include "UP_ItemOptionReset.generated.h"
class UUC_GenericItemIcon;
class ULocalizingTextBlock;
class UUC_StatChange;
class UUC_EnchantMaterialButton;
class UUC_ItemEnchant_Button;
class URRichTextBlock;
class UUC_EquipmentIcon;
struct FItemGradeTableInfo;
class UUC_GenericItemIconWithFlare;
class UUC_ItemOptionReset_AdditionalStats;
/**
* 오버로드_장비시스템_승급과옵션재부여.docx
* UI: 아이템 UI_장비 옵션 재부여_김현주.pdf
*
* currently class definition copied from UUP_ItemUpgrade with modifications
*/
UCLASS()
class PROJECTR_API UUP_ItemOptionReset : public UUP_ItemInventoryPage_ContentBase
{
GENERATED_BODY()
public:
void NativeConstruct() override;
void NativeDestruct() override;
//// UUP_ItemInventoryPage_ContentBase interface
void InvalidateData() override;
void SetItemUD(FString InItemUD) override;
bool IsInventoryIncludingEquipmentItem(const FItemTableInfo* ItemInfo, const FITEM* ItemData) override;
void OnInventoryEquipmentItemSelected(FString SelectedItemUD) override;
void UpdateScrollItemData_EquipmentItem(UInventoryScrollDataBase* ScrollItemData) override;
//// BP Widgets
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "UUC_ItemEnchant|Ref")
UUC_GenericItemIcon* ItemIcon;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "UUC_ItemEnchant|Ref")
UTextBlock* Text_ItemName;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "UUC_ItemEnchant|Ref")
UUC_EnchantMaterialButton* OptionResetMaterial;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "UUC_ItemEnchant|Ref")
UUC_GenericItemIcon* Icon_EquipmentMaterial1;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "UUC_ItemEnchant|Ref")
UUC_GenericItemIcon* Icon_EquipmentMaterial2;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "UUC_ItemEnchant|Ref")
UUC_ItemOptionReset_AdditionalStats* AdditionalStats;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "UUC_ItemEnchant|Ref")
UUC_ItemEnchant_Button* Button_Upgrade;
//// Delegates
UFUNCTION()
void OnButtonUpgradeClicked();
UFUNCTION()
void OnInventoryItemUpgradeRp(bool bSuccess, FITEM ItemDataBefore);
/** Please call this from BP. WhichOne is either 0 or 1 */
UFUNCTION(BlueprintCallable, Category = "UUC_ItemEnchant|Ref")
void OnButtonEquipmentMaterialClicked(int32 WhichOne);
private:
//// InvalidateData helpers
void InvalidateOnEquipmentMaterialSelected();
bool CanUpgrade();
// principal state
FString ItemUD;
// equipment material selection state
/** Empty string means the slot is empty */
FString EquipmentMaterial1_ItemUD;
FString EquipmentMaterial2_ItemUD;
// saved on InvalidateData
bool HasSufficientGold = false;
EItemGradeEnum CurrentGrade = EItemGradeEnum::Normal;
};
UCLASS()
class PROJECTR_API UUC_ItemOptionResetResult : public URBaseWidget
{
GENERATED_BODY()
public:
//// Interface
void InvalidateData() override;
FString ItemUD;
FITEM ItemDataBefore; // item id different from what it is now (ItemUD)
//// BP Widgets
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "UUC_ItemEnchant|Ref")
UUC_GenericItemIconWithFlare* ItemIcon;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "UUC_ItemEnchant|Ref")
UTextBlock* Text_ItemName;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "UUC_ItemEnchant|Ref")
UUC_ItemOptionReset_AdditionalStats* AdditionalStatsBefore;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "UUC_ItemEnchant|Ref")
UUC_ItemOptionReset_AdditionalStats* AdditionalStatsAfter;
};
/** a stack of additional options for FITEM */
UCLASS()
class PROJECTR_API UUC_ItemOptionReset_AdditionalStats : public URBaseWidget
{
GENERATED_BODY()
public:
//// Interface
void Refresh(const FITEM* ItemData);
//// BP Widgets
/** 4 of them expected */
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = UC_ItemEnchantResult)
TArray<UUC_ItemInfo_ItemStat*> AdditionalStats;
}; | [
"happycap88@gmail.com"
] | happycap88@gmail.com |
38e3d1d6421cac1651177a2db084b14eb2bde5df | c0c12cb761e5910c994892373bbe694563b2806b | /src/vpp-api/vom/arp_proxy_binding.hpp | 2ee814aa1298b4665da274d9969a0d8ab0b59180 | [
"Apache-2.0"
] | permissive | waytongxue/vpp | af742564f2ca7d4a27a1cd548e79a54fae88d64a | e7fa24e574bd2ee36b21848bb0981eb8b3d2f96f | refs/heads/master | 2021-08-07T09:29:49.143106 | 2017-11-07T18:07:44 | 2017-11-07T23:25:16 | 109,907,704 | 1 | 0 | null | 2017-11-08T00:34:05 | 2017-11-08T00:34:05 | null | UTF-8 | C++ | false | false | 3,714 | hpp | /*
* Copyright (c) 2017 Cisco and/or its affiliates.
* 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 __VOM_ARP_PROXY_BINDING_H__
#define __VOM_ARP_PROXY_BINDING_H__
#include "vom/arp_proxy_config.hpp"
#include "vom/hw.hpp"
#include "vom/inspect.hpp"
#include "vom/interface.hpp"
#include "vom/object_base.hpp"
#include "vom/om.hpp"
#include "vom/singular_db.hpp"
namespace VOM {
/**
* A representation of LLDP client configuration on an interface
*/
class arp_proxy_binding : public object_base
{
public:
/**
* Construct a new object matching the desried state
*/
arp_proxy_binding(const interface& itf, const arp_proxy_config& proxy_cfg);
/**
* Copy Constructor
*/
arp_proxy_binding(const arp_proxy_binding& o);
/**
* Destructor
*/
~arp_proxy_binding();
/**
* Return the 'singular' of the LLDP binding that matches this object
*/
std::shared_ptr<arp_proxy_binding> singular() const;
/**
* convert to string format for debug purposes
*/
std::string to_string() const;
/**
* Dump all LLDP bindings into the stream provided
*/
static void dump(std::ostream& os);
private:
/**
* Class definition for listeners to OM events
*/
class event_handler : public OM::listener, public inspect::command_handler
{
public:
event_handler();
virtual ~event_handler() = default;
/**
* Handle a populate event
*/
void handle_populate(const client_db::key_t& key);
/**
* Handle a replay event
*/
void handle_replay();
/**
* Show the object in the Singular DB
*/
void show(std::ostream& os);
/**
* Get the sortable Id of the listener
*/
dependency_t order() const;
};
/**
* event_handler to register with OM
*/
static event_handler m_evh;
/**
* Enquue commonds to the VPP command Q for the update
*/
void update(const arp_proxy_binding& obj);
/**
* Find or add LLDP binding to the OM
*/
static std::shared_ptr<arp_proxy_binding> find_or_add(
const arp_proxy_binding& temp);
/*
* It's the OM class that calls singular()
*/
friend class OM;
/**
* It's the singular_db class that calls replay()
*/
friend class singular_db<interface::key_type, arp_proxy_binding>;
/**
* Sweep/reap the object if still stale
*/
void sweep(void);
/**
* replay the object to create it in hardware
*/
void replay(void);
/**
* A reference counting pointer to the interface on which LLDP config
* resides. By holding the reference here, we can guarantee that
* this object will outlive the interface
*/
const std::shared_ptr<interface> m_itf;
/**
* A reference counting pointer to the prxy config.
*/
const std::shared_ptr<arp_proxy_config> m_arp_proxy_cfg;
/**
* HW configuration for the binding. The bool representing the
* do/don't bind.
*/
HW::item<bool> m_binding;
/**
* A map of all ArpProxy bindings keyed against the interface.
*/
static singular_db<interface::key_type, arp_proxy_binding> m_db;
};
};
/*
* fd.io coding-style-patch-verification: ON
*
* Local Variables:
* eval: (c-set-style "mozilla")
* End:
*/
#endif
| [
"dmarion.lists@gmail.com"
] | dmarion.lists@gmail.com |
ab18bc97f25b7491ca09118e33e11c4e0cc0d785 | a2111a80faf35749d74a533e123d9da9da108214 | /raw/workshop11/workshop2011-data-20110925/sources/fwmf9kkqo37idut8/67/sandbox/my_sandbox/apps/my_app/my_app.cpp | 3eec2cb2adcb9a8ffdc46b2aad0932844b57203b | [
"MIT"
] | permissive | bkahlert/seqan-research | f2c550d539f511825842a60f6b994c1f0a3934c2 | 21945be863855077eec7cbdb51c3450afcf560a3 | refs/heads/master | 2022-12-24T13:05:48.828734 | 2015-07-01T01:56:22 | 2015-07-01T01:56:22 | 21,610,669 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,090 | cpp | #include <iostream>
#include <vector>
#include <seqan/sequence.h> // CharString, ...
#include <seqan/file.h> // to stream a CharString into cout
#include <seqan/basic.h>
#include <seqan/find_motif.h>
using namespace seqan;
using namespace std;
void tut01();
void tut02();
void ass01();
void task1();
void countOneMers(String<char> str);
int main(int, char **) {
task1();
return 0;
}
template <typename TAlphabet>
void showAllLetterOfMyAlphabet(TAlphabet const &)
{
typedef typename Size<TAlphabet>::Type TSize;
TSize alphSize = ValueSize<TAlphabet>::VALUE;
for (TSize i = 0; i < alphSize; ++i)
std::cout << i << ',' << TAlphabet(i) << " ";
std::cout << std::endl;
}
void tut01(){
showAllLetterOfMyAlphabet(AminoAcid());
showAllLetterOfMyAlphabet(Dna());
showAllLetterOfMyAlphabet(Dna5());
}
void tut02(){
String<char> str = "ACME";
Iterator<String<char> >::Type it1 = begin(str); //a standard iterator
Iterator<String<char>, Standard>::Type it2 = begin(str); //same as above
Iterator<String<char>, Rooted>::Type it3 = begin(str); //a rooted iterator
Iterator<String<char>, Rooted>::Type it4 = begin(str, Rooted()); //same as above
}
void ass01(){
String<AminoAcid> pep = "MQDRVKRPMNAFIVWSRDQRRKMALEN";
Iterator<String<AminoAcid>, Standard>::Type it = begin(pep);
Iterator<String<AminoAcid>, Standard>::Type itEnd = end(pep);
int alphSize = ValueSize<AminoAcid>::VALUE;
cout << alphSize << " " << AminoAcid('Q') << endl;
cout << pep << endl;
while (it != itEnd){
if (*it == 'R'){
*it = 'A';
}
it++;
}
cout << pep << endl;
}
void task1(){
String<char> str1 = "hello world";
String<char> str2 = "banana";
String<char> str3 = "mississippi";
countOneMers(str1);
countOneMers(str2);
countOneMers(str3);
}
void countOneMers(String<char> str){
int alphSize = ValueSize<char>::VALUE;
vector<int> dist (alphSize, 0);
for (int i=0; i<length(str); i++){
dist[ordValue(str[i])]++;
}
cout << str << endl;
for (int i=0; i<dist.size(); i++){
if (dist[i] != 0)
cout << char(i) << ":" << dist[i] << ", ";
}
cout << endl;
} | [
"mail@bkahlert.com"
] | mail@bkahlert.com |
fba7e99aa02f89623de03cdea765a3c15c781eda | 9a8c6a6bc5300f7038c33d9d558f7524e5f33451 | /myex/prob5/practice/rat.cpp | b39e5a92ecb5d09dcc5d642dbb8dff0470050243 | [] | no_license | s1250009/Cpp | 5ee7279290ca0189e5e0dfb15984063638ef860a | a2bd5e9ebf99bb8badbcd94dd687fdca59376334 | refs/heads/master | 2022-04-05T15:13:02.134348 | 2020-03-07T16:17:01 | 2020-03-07T16:17:01 | 212,468,765 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 649 | cpp | #include "rat.h"
#include <iostream>
using namespace std;
// ネズミの数の初期値を0に設定
int CRat::m_count = 0;
// コンストラクタ
CRat::CRat() : m_id(0){
m_id = m_count; // ネズミの数を、IDとする。
m_count++; // ネズミの数を一つ増やす
}
// デストラクタ
CRat::~CRat() {
cout << "Rat:" << m_id << " deleted" << endl;
m_count--; // ネズミの数を一つ減らす
}
// ネズミの数の出力
void CRat::showNum(){
cout << "Now, Rats are " << m_count << endl;
}
// ネズミが鳴く
void CRat::squeak(){
cout << m_id << ":" << "Chu, Chu" << endl;
} | [
"s1250009@u-aizu.ac.jp"
] | s1250009@u-aizu.ac.jp |
f624d6d78c8fe4ecde45ce86206268e1d017a050 | f3ddeaa9804b4c4fffb36e561b5d9e29c642c25b | /version/C++/dependency/lbp/lbp.cpp | df07b6bdabb7a18dca133cf5ed84d869c5a16408 | [
"MIT",
"BSD-3-Clause"
] | permissive | hliangzhao/Face-Liveness-Detection | 3095905374db9cc1c35bdbed37cd2db4f62eb479 | 23854756d890a0c8e50924f94e3c86db838eb910 | refs/heads/master | 2021-06-22T09:59:01.261618 | 2020-11-28T07:50:21 | 2020-11-28T07:50:21 | 131,124,167 | 22 | 7 | null | null | null | null | UTF-8 | C++ | false | false | 6,123 | cpp | #include "lbp.hpp"
#define M_PI 3.14159265358979323846
using namespace cv;
template <typename _Tp>
void lbp::OLBP_(const Mat& src, Mat& dst) {
dst = Mat::zeros(src.rows-2, src.cols-2, CV_8UC1);
for(int i=1;i<src.rows-1;i++) {
for(int j=1;j<src.cols-1;j++) {
_Tp center = src.at<_Tp>(i,j);
unsigned char code = 0;
code |= (src.at<_Tp>(i-1,j-1) > center) << 7;
code |= (src.at<_Tp>(i-1,j) > center) << 6;
code |= (src.at<_Tp>(i-1,j+1) > center) << 5;
code |= (src.at<_Tp>(i,j+1) > center) << 4;
code |= (src.at<_Tp>(i+1,j+1) > center) << 3;
code |= (src.at<_Tp>(i+1,j) > center) << 2;
code |= (src.at<_Tp>(i+1,j-1) > center) << 1;
code |= (src.at<_Tp>(i,j-1) > center) << 0;
dst.at<unsigned char>(i-1,j-1) = code;
}
}
}
template <typename _Tp>
void lbp::ELBP_(const Mat& src, Mat& dst, int radius, int neighbors) {
neighbors = max(min(neighbors,31),1); // set bounds...
// Note: alternatively you can switch to the new OpenCV Mat_
// type system to define an unsigned int matrix... I am probably
// mistaken here, but I didn't see an unsigned int representation
// in OpenCV's classic typesystem...
dst = Mat::zeros(src.rows-2*radius, src.cols-2*radius, CV_32SC1);
for(int n=0; n<neighbors; n++) {
// sample points
float x = static_cast<float>(radius) * cos(2.0*M_PI*n/static_cast<float>(neighbors));
float y = static_cast<float>(radius) * -sin(2.0*M_PI*n/static_cast<float>(neighbors));
// relative indices
int fx = static_cast<int>(floor(x));
int fy = static_cast<int>(floor(y));
int cx = static_cast<int>(ceil(x));
int cy = static_cast<int>(ceil(y));
// fractional part
float ty = y - fy;
float tx = x - fx;
// set interpolation weights
float w1 = (1 - tx) * (1 - ty);
float w2 = tx * (1 - ty);
float w3 = (1 - tx) * ty;
float w4 = tx * ty;
// iterate through your data
for(int i=radius; i < src.rows-radius;i++) {
for(int j=radius;j < src.cols-radius;j++) {
float t = w1*src.at<_Tp>(i+fy,j+fx) + w2*src.at<_Tp>(i+fy,j+cx) + w3*src.at<_Tp>(i+cy,j+fx) + w4*src.at<_Tp>(i+cy,j+cx);
// we are dealing with floating point precision, so add some little tolerance
dst.at<int>(i-radius,j-radius) += ((t > src.at<_Tp>(i,j)) && (abs(t-src.at<_Tp>(i,j)) > std::numeric_limits<float>::epsilon())) << n;
}
}
}
}
template <typename _Tp>
void lbp::VARLBP_(const Mat& src, Mat& dst, int radius, int neighbors) {
max(min(neighbors,31),1); // set bounds
dst = Mat::zeros(src.rows-2*radius, src.cols-2*radius, CV_32FC1); //! result
// allocate some memory for temporary on-line variance calculations
Mat _mean = Mat::zeros(src.rows, src.cols, CV_32FC1);
Mat _delta = Mat::zeros(src.rows, src.cols, CV_32FC1);
Mat _m2 = Mat::zeros(src.rows, src.cols, CV_32FC1);
for(int n=0; n<neighbors; n++) {
// sample points
float x = static_cast<float>(radius) * cos(2.0*M_PI*n/static_cast<float>(neighbors));
float y = static_cast<float>(radius) * -sin(2.0*M_PI*n/static_cast<float>(neighbors));
// relative indices
int fx = static_cast<int>(floor(x));
int fy = static_cast<int>(floor(y));
int cx = static_cast<int>(ceil(x));
int cy = static_cast<int>(ceil(y));
// fractional part
float ty = y - fy;
float tx = x - fx;
// set interpolation weights
float w1 = (1 - tx) * (1 - ty);
float w2 = tx * (1 - ty);
float w3 = (1 - tx) * ty;
float w4 = tx * ty;
// iterate through your data
for(int i=radius; i < src.rows-radius;i++) {
for(int j=radius;j < src.cols-radius;j++) {
float t = w1*src.at<_Tp>(i+fy,j+fx) + w2*src.at<_Tp>(i+fy,j+cx) + w3*src.at<_Tp>(i+cy,j+fx) + w4*src.at<_Tp>(i+cy,j+cx);
_delta.at<float>(i,j) = t - _mean.at<float>(i,j);
_mean.at<float>(i,j) = (_mean.at<float>(i,j) + (_delta.at<float>(i,j) / (1.0*(n+1)))); // i am a bit paranoid
_m2.at<float>(i,j) = _m2.at<float>(i,j) + _delta.at<float>(i,j) * (t - _mean.at<float>(i,j));
}
}
}
// calculate result
for(int i = radius; i < src.rows-radius; i++) {
for(int j = radius; j < src.cols-radius; j++) {
dst.at<float>(i-radius, j-radius) = _m2.at<float>(i,j) / (1.0*(neighbors-1));
}
}
}
// now the wrapper functions
void lbp::OLBP(const Mat& src, Mat& dst) {
switch(src.type()) {
case CV_8SC1: OLBP_<char>(src, dst); break;
case CV_8UC1: OLBP_<unsigned char>(src, dst); break;
case CV_16SC1: OLBP_<short>(src, dst); break;
case CV_16UC1: OLBP_<unsigned short>(src, dst); break;
case CV_32SC1: OLBP_<int>(src, dst); break;
case CV_32FC1: OLBP_<float>(src, dst); break;
case CV_64FC1: OLBP_<double>(src, dst); break;
}
}
void lbp::ELBP(const Mat& src, Mat& dst, int radius, int neighbors) {
switch(src.type()) {
case CV_8SC1: ELBP_<char>(src, dst, radius, neighbors); break;
case CV_8UC1: ELBP_<unsigned char>(src, dst, radius, neighbors); break;
case CV_16SC1: ELBP_<short>(src, dst, radius, neighbors); break;
case CV_16UC1: ELBP_<unsigned short>(src, dst, radius, neighbors); break;
case CV_32SC1: ELBP_<int>(src, dst, radius, neighbors); break;
case CV_32FC1: ELBP_<float>(src, dst, radius, neighbors); break;
case CV_64FC1: ELBP_<double>(src, dst, radius, neighbors); break;
}
}
void lbp::VARLBP(const Mat& src, Mat& dst, int radius, int neighbors) {
switch(src.type()) {
case CV_8SC1: VARLBP_<char>(src, dst, radius, neighbors); break;
case CV_8UC1: VARLBP_<unsigned char>(src, dst, radius, neighbors); break;
case CV_16SC1: VARLBP_<short>(src, dst, radius, neighbors); break;
case CV_16UC1: VARLBP_<unsigned short>(src, dst, radius, neighbors); break;
case CV_32SC1: VARLBP_<int>(src, dst, radius, neighbors); break;
case CV_32FC1: VARLBP_<float>(src, dst, radius, neighbors); break;
case CV_64FC1: VARLBP_<double>(src, dst, radius, neighbors); break;
}
}
// now the Mat return functions
Mat lbp::OLBP(const Mat& src) { Mat dst; OLBP(src, dst); return dst; }
Mat lbp::ELBP(const Mat& src, int radius, int neighbors) { Mat dst; ELBP(src, dst, radius, neighbors); return dst; }
Mat lbp::VARLBP(const Mat& src, int radius, int neighbors) { Mat dst; VARLBP(src, dst, radius, neighbors); return dst; }
| [
"2456217567@whut.edu.cn"
] | 2456217567@whut.edu.cn |
172866b32de0e253ea3f7c8f50fcd20db9d8b6f5 | 6b2a8dd202fdce77c971c412717e305e1caaac51 | /solutions_5662291475300352_0/C++/jevi/C.cpp | cf7b461031b26673778c9c5a79036965c715cac4 | [] | no_license | alexandraback/datacollection | 0bc67a9ace00abbc843f4912562f3a064992e0e9 | 076a7bc7693f3abf07bfdbdac838cb4ef65ccfcf | refs/heads/master | 2021-01-24T18:27:24.417992 | 2017-05-23T09:23:38 | 2017-05-23T09:23:38 | 84,313,442 | 2 | 4 | null | null | null | null | UTF-8 | C++ | false | false | 1,754 | cpp | #include <iostream>
#include <fstream>
#include <cstdio>
#include <iomanip>
#include <sstream>
#include <cstring>
#include <string>
#include <cmath>
#include <stack>
#include <list>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <vector>
#include <algorithm>
#include <numeric>
#include <utility>
#include <functional>
#include <limits>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int ui;
typedef pair<int,int> pii;
typedef vector<vector<int> > graph;
const double pi = acos(-1.0);
#define oned(a, x1, x2) { cout << #a << ":"; for(int _i = (x1); _i < (x2); _i++){ cout << " " << a[_i]; } cout << endl; }
#define twod(a, x1, x2, y1, y2) { cout << #a << ":" << endl; for(int _i = (x1); _i < (x2); _i++){ for(int _j = (y1); _j < (y2); _j++){ cout << (_j > y1 ? " " : "") << a[_i][_j]; } cout << endl; } }
#define mp make_pair
#define pb push_back
#define fst first
#define snd second
const int MAXN = 500005;
int n, d[MAXN], h[MAXN], m[MAXN];
ll N, D[MAXN], M[MAXN];
int small1() {
N = 0;
for(int i = 0; i < n; i++) {
for(int j = 0; j < h[i]; j++) {
D[N] = d[i];
M[N] = m[i]+j;
N++;
}
}
if(N <= 1) {
return 0;
} else {
ll time0 = (360-D[0])*M[0];
ll time1 = (360-D[1])*M[1];
if(time0 == time1) {
return 0;
} else {
if(time0 > time1) {
swap(D[0],D[1]);
swap(M[0],M[1]);
swap(time0,time1);
}
return (720-D[0])*M[0] <= time1;
}
}
}
int main() {
freopen("C-input.in", "r", stdin);
freopen("C-output.out", "w", stdout);
int t; scanf("%d", &t);
for(int c = 1; c <= t; c++) {
scanf("%d", &n);
for(int i = 0; i < n; i++) {
scanf("%d %d %d", d+i, h+i, m+i);
}
printf("Case #%d: %d\n", c, small1());
}
}
| [
"eewestman@gmail.com"
] | eewestman@gmail.com |
ce2924461f079b9251b61828ac245a430f4870c9 | 060c251200cc9bdcf590889a4a74562f5bbe5599 | /cpp/jdddzpk.pb.h | a2032eb099ee795bdda5c05e3592b1fd1617d2bb | [] | no_license | ganshulong/proto | fb03db871e497e6b538dc7706e59fce93af638d8 | aa0c3d866c4b4bc3202284867bb199c643f8ac9f | refs/heads/master | 2021-08-23T01:17:31.954762 | 2017-12-02T03:35:45 | 2017-12-02T03:35:45 | 112,809,713 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | true | 485,911 | h | // Generated by the protocol buffer compiler. DO NOT EDIT!
// source: jdddzpk.proto
#ifndef PROTOBUF_jdddzpk_2eproto__INCLUDED
#define PROTOBUF_jdddzpk_2eproto__INCLUDED
#include <string>
#include <google/protobuf/stubs/common.h>
#if GOOGLE_PROTOBUF_VERSION < 2005000
#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 2005000 < 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>
#include "base.pb.h"
// @@protoc_insertion_point(includes)
// Internal implementation detail -- do not call these.
void protobuf_AddDesc_jdddzpk_2eproto();
void protobuf_AssignDesc_jdddzpk_2eproto();
void protobuf_ShutdownFile_jdddzpk_2eproto();
class ProJDDDZGameStatusResponse;
class ProJDDDZGameDeskInfoResponse;
class ProJDDDZGameReadyNotify;
class ProJDDDZGameReadyRequest;
class ProJDDDZGameReadyResponse;
class ProJDDDZGameStart;
class ProJDDDZGameDiceNotify;
class ProJDDDZGameDiceRequest;
class ProJDDDZGameDiceResult;
class ProJDDDZGameSendMahs;
class ProJDDDZGameKingData;
class ProJDDDZGameOutMahsResponse;
class ProJDDDZGameTimerPower;
class ProJDDDZGameOperateNotify;
class ProJDDDZGameOperateResult;
class ProJDDDZGameOperateRequest;
class ProJDDDZGameTrust;
class ProJDDDZGameOutMahRequest;
class ProJDDDZGameCatchCard;
class JDDDZMahList;
class JDDDZScoreList;
class JDDDZAwardList;
class ProJDDDZGameEnd;
class ProJDDDZGameQuickSoundRequest;
class ProJDDDZGameQuickSoundResponse;
class ProJDDDZGameSendDiscardMahs;
class JDDDZWeaveItem;
class JDDDZWeaveItems;
class ProJDDDZGameSendActionMahs;
class ProJDDDZGameBrokenRequest;
class ProJDDDZGameBrokenOperate;
class ProJDDDZGameBrokenNotify;
class ProJDDDZGameRuleConfig;
class ProJDDDZGameBrokenStatus;
class ProJDDDZGameDataResp;
class ProJDDDZGameRecordRequest;
class ProJDDDZGameRecordResponse;
class ProJDDDZGameUserLocationRequest;
class ProJDDDZGameSyncCardResponse;
class ProJDDDZGameUserPhoneStatusRequest;
class ProJDDDZGameUserGiveUpRequest;
class ProJDDDZGameUserHintRequest;
class ProJDDDZGameUserHintResponse;
class ProJDDDZGameUserCallScoreResponse;
class ProJDDDZGameUserCallScoreRequest;
class ProJDDDZGameCallNotify;
class ProJDDDZGameQiangNotify;
class ProJDDDZGameUserCallLandlordResponse;
class ProJDDDZGameUserCallLandlordRequest;
class ProJDDDZGameUserQinagLandlordResponse;
class ProJDDDZGameUserQiangLandlordRequest;
class ProJDDDZGameSendLastCard;
class ProJDDDZGameUserMingPaiRequest;
class ProJDDDZGameUserMingPaiResponse;
class ProJDDDZGameMingNotify;
class ProJDDDZGameStartAgain;
enum ProJDDDZGameStatusResponse_MSGID {
ProJDDDZGameStatusResponse_MSGID_ID = 2200
};
bool ProJDDDZGameStatusResponse_MSGID_IsValid(int value);
const ProJDDDZGameStatusResponse_MSGID ProJDDDZGameStatusResponse_MSGID_MSGID_MIN = ProJDDDZGameStatusResponse_MSGID_ID;
const ProJDDDZGameStatusResponse_MSGID ProJDDDZGameStatusResponse_MSGID_MSGID_MAX = ProJDDDZGameStatusResponse_MSGID_ID;
const int ProJDDDZGameStatusResponse_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameStatusResponse_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameStatusResponse_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameStatusResponse_MSGID_Name(ProJDDDZGameStatusResponse_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameStatusResponse_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameStatusResponse_MSGID_Parse(
const ::std::string& name, ProJDDDZGameStatusResponse_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameStatusResponse_MSGID>(
ProJDDDZGameStatusResponse_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameDeskInfoResponse_MSGID {
ProJDDDZGameDeskInfoResponse_MSGID_ID = 2201
};
bool ProJDDDZGameDeskInfoResponse_MSGID_IsValid(int value);
const ProJDDDZGameDeskInfoResponse_MSGID ProJDDDZGameDeskInfoResponse_MSGID_MSGID_MIN = ProJDDDZGameDeskInfoResponse_MSGID_ID;
const ProJDDDZGameDeskInfoResponse_MSGID ProJDDDZGameDeskInfoResponse_MSGID_MSGID_MAX = ProJDDDZGameDeskInfoResponse_MSGID_ID;
const int ProJDDDZGameDeskInfoResponse_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameDeskInfoResponse_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameDeskInfoResponse_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameDeskInfoResponse_MSGID_Name(ProJDDDZGameDeskInfoResponse_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameDeskInfoResponse_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameDeskInfoResponse_MSGID_Parse(
const ::std::string& name, ProJDDDZGameDeskInfoResponse_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameDeskInfoResponse_MSGID>(
ProJDDDZGameDeskInfoResponse_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameReadyNotify_MSGID {
ProJDDDZGameReadyNotify_MSGID_ID = 2202
};
bool ProJDDDZGameReadyNotify_MSGID_IsValid(int value);
const ProJDDDZGameReadyNotify_MSGID ProJDDDZGameReadyNotify_MSGID_MSGID_MIN = ProJDDDZGameReadyNotify_MSGID_ID;
const ProJDDDZGameReadyNotify_MSGID ProJDDDZGameReadyNotify_MSGID_MSGID_MAX = ProJDDDZGameReadyNotify_MSGID_ID;
const int ProJDDDZGameReadyNotify_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameReadyNotify_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameReadyNotify_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameReadyNotify_MSGID_Name(ProJDDDZGameReadyNotify_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameReadyNotify_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameReadyNotify_MSGID_Parse(
const ::std::string& name, ProJDDDZGameReadyNotify_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameReadyNotify_MSGID>(
ProJDDDZGameReadyNotify_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameReadyRequest_MSGID {
ProJDDDZGameReadyRequest_MSGID_ID = 2203
};
bool ProJDDDZGameReadyRequest_MSGID_IsValid(int value);
const ProJDDDZGameReadyRequest_MSGID ProJDDDZGameReadyRequest_MSGID_MSGID_MIN = ProJDDDZGameReadyRequest_MSGID_ID;
const ProJDDDZGameReadyRequest_MSGID ProJDDDZGameReadyRequest_MSGID_MSGID_MAX = ProJDDDZGameReadyRequest_MSGID_ID;
const int ProJDDDZGameReadyRequest_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameReadyRequest_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameReadyRequest_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameReadyRequest_MSGID_Name(ProJDDDZGameReadyRequest_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameReadyRequest_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameReadyRequest_MSGID_Parse(
const ::std::string& name, ProJDDDZGameReadyRequest_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameReadyRequest_MSGID>(
ProJDDDZGameReadyRequest_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameReadyResponse_MSGID {
ProJDDDZGameReadyResponse_MSGID_ID = 2204
};
bool ProJDDDZGameReadyResponse_MSGID_IsValid(int value);
const ProJDDDZGameReadyResponse_MSGID ProJDDDZGameReadyResponse_MSGID_MSGID_MIN = ProJDDDZGameReadyResponse_MSGID_ID;
const ProJDDDZGameReadyResponse_MSGID ProJDDDZGameReadyResponse_MSGID_MSGID_MAX = ProJDDDZGameReadyResponse_MSGID_ID;
const int ProJDDDZGameReadyResponse_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameReadyResponse_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameReadyResponse_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameReadyResponse_MSGID_Name(ProJDDDZGameReadyResponse_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameReadyResponse_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameReadyResponse_MSGID_Parse(
const ::std::string& name, ProJDDDZGameReadyResponse_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameReadyResponse_MSGID>(
ProJDDDZGameReadyResponse_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameStart_MSGID {
ProJDDDZGameStart_MSGID_ID = 2205
};
bool ProJDDDZGameStart_MSGID_IsValid(int value);
const ProJDDDZGameStart_MSGID ProJDDDZGameStart_MSGID_MSGID_MIN = ProJDDDZGameStart_MSGID_ID;
const ProJDDDZGameStart_MSGID ProJDDDZGameStart_MSGID_MSGID_MAX = ProJDDDZGameStart_MSGID_ID;
const int ProJDDDZGameStart_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameStart_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameStart_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameStart_MSGID_Name(ProJDDDZGameStart_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameStart_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameStart_MSGID_Parse(
const ::std::string& name, ProJDDDZGameStart_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameStart_MSGID>(
ProJDDDZGameStart_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameDiceNotify_MSGID {
ProJDDDZGameDiceNotify_MSGID_ID = 2206
};
bool ProJDDDZGameDiceNotify_MSGID_IsValid(int value);
const ProJDDDZGameDiceNotify_MSGID ProJDDDZGameDiceNotify_MSGID_MSGID_MIN = ProJDDDZGameDiceNotify_MSGID_ID;
const ProJDDDZGameDiceNotify_MSGID ProJDDDZGameDiceNotify_MSGID_MSGID_MAX = ProJDDDZGameDiceNotify_MSGID_ID;
const int ProJDDDZGameDiceNotify_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameDiceNotify_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameDiceNotify_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameDiceNotify_MSGID_Name(ProJDDDZGameDiceNotify_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameDiceNotify_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameDiceNotify_MSGID_Parse(
const ::std::string& name, ProJDDDZGameDiceNotify_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameDiceNotify_MSGID>(
ProJDDDZGameDiceNotify_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameDiceRequest_MSGID {
ProJDDDZGameDiceRequest_MSGID_ID = 2207
};
bool ProJDDDZGameDiceRequest_MSGID_IsValid(int value);
const ProJDDDZGameDiceRequest_MSGID ProJDDDZGameDiceRequest_MSGID_MSGID_MIN = ProJDDDZGameDiceRequest_MSGID_ID;
const ProJDDDZGameDiceRequest_MSGID ProJDDDZGameDiceRequest_MSGID_MSGID_MAX = ProJDDDZGameDiceRequest_MSGID_ID;
const int ProJDDDZGameDiceRequest_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameDiceRequest_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameDiceRequest_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameDiceRequest_MSGID_Name(ProJDDDZGameDiceRequest_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameDiceRequest_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameDiceRequest_MSGID_Parse(
const ::std::string& name, ProJDDDZGameDiceRequest_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameDiceRequest_MSGID>(
ProJDDDZGameDiceRequest_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameDiceResult_MSGID {
ProJDDDZGameDiceResult_MSGID_ID = 2208
};
bool ProJDDDZGameDiceResult_MSGID_IsValid(int value);
const ProJDDDZGameDiceResult_MSGID ProJDDDZGameDiceResult_MSGID_MSGID_MIN = ProJDDDZGameDiceResult_MSGID_ID;
const ProJDDDZGameDiceResult_MSGID ProJDDDZGameDiceResult_MSGID_MSGID_MAX = ProJDDDZGameDiceResult_MSGID_ID;
const int ProJDDDZGameDiceResult_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameDiceResult_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameDiceResult_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameDiceResult_MSGID_Name(ProJDDDZGameDiceResult_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameDiceResult_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameDiceResult_MSGID_Parse(
const ::std::string& name, ProJDDDZGameDiceResult_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameDiceResult_MSGID>(
ProJDDDZGameDiceResult_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameSendMahs_MSGID {
ProJDDDZGameSendMahs_MSGID_ID = 2209
};
bool ProJDDDZGameSendMahs_MSGID_IsValid(int value);
const ProJDDDZGameSendMahs_MSGID ProJDDDZGameSendMahs_MSGID_MSGID_MIN = ProJDDDZGameSendMahs_MSGID_ID;
const ProJDDDZGameSendMahs_MSGID ProJDDDZGameSendMahs_MSGID_MSGID_MAX = ProJDDDZGameSendMahs_MSGID_ID;
const int ProJDDDZGameSendMahs_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameSendMahs_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameSendMahs_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameSendMahs_MSGID_Name(ProJDDDZGameSendMahs_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameSendMahs_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameSendMahs_MSGID_Parse(
const ::std::string& name, ProJDDDZGameSendMahs_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameSendMahs_MSGID>(
ProJDDDZGameSendMahs_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameKingData_MSGID {
ProJDDDZGameKingData_MSGID_ID = 2210
};
bool ProJDDDZGameKingData_MSGID_IsValid(int value);
const ProJDDDZGameKingData_MSGID ProJDDDZGameKingData_MSGID_MSGID_MIN = ProJDDDZGameKingData_MSGID_ID;
const ProJDDDZGameKingData_MSGID ProJDDDZGameKingData_MSGID_MSGID_MAX = ProJDDDZGameKingData_MSGID_ID;
const int ProJDDDZGameKingData_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameKingData_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameKingData_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameKingData_MSGID_Name(ProJDDDZGameKingData_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameKingData_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameKingData_MSGID_Parse(
const ::std::string& name, ProJDDDZGameKingData_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameKingData_MSGID>(
ProJDDDZGameKingData_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameOutMahsResponse_MSGID {
ProJDDDZGameOutMahsResponse_MSGID_ID = 2211
};
bool ProJDDDZGameOutMahsResponse_MSGID_IsValid(int value);
const ProJDDDZGameOutMahsResponse_MSGID ProJDDDZGameOutMahsResponse_MSGID_MSGID_MIN = ProJDDDZGameOutMahsResponse_MSGID_ID;
const ProJDDDZGameOutMahsResponse_MSGID ProJDDDZGameOutMahsResponse_MSGID_MSGID_MAX = ProJDDDZGameOutMahsResponse_MSGID_ID;
const int ProJDDDZGameOutMahsResponse_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameOutMahsResponse_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameOutMahsResponse_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameOutMahsResponse_MSGID_Name(ProJDDDZGameOutMahsResponse_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameOutMahsResponse_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameOutMahsResponse_MSGID_Parse(
const ::std::string& name, ProJDDDZGameOutMahsResponse_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameOutMahsResponse_MSGID>(
ProJDDDZGameOutMahsResponse_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameTimerPower_MSGID {
ProJDDDZGameTimerPower_MSGID_ID = 2212
};
bool ProJDDDZGameTimerPower_MSGID_IsValid(int value);
const ProJDDDZGameTimerPower_MSGID ProJDDDZGameTimerPower_MSGID_MSGID_MIN = ProJDDDZGameTimerPower_MSGID_ID;
const ProJDDDZGameTimerPower_MSGID ProJDDDZGameTimerPower_MSGID_MSGID_MAX = ProJDDDZGameTimerPower_MSGID_ID;
const int ProJDDDZGameTimerPower_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameTimerPower_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameTimerPower_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameTimerPower_MSGID_Name(ProJDDDZGameTimerPower_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameTimerPower_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameTimerPower_MSGID_Parse(
const ::std::string& name, ProJDDDZGameTimerPower_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameTimerPower_MSGID>(
ProJDDDZGameTimerPower_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameOperateNotify_MSGID {
ProJDDDZGameOperateNotify_MSGID_ID = 2213
};
bool ProJDDDZGameOperateNotify_MSGID_IsValid(int value);
const ProJDDDZGameOperateNotify_MSGID ProJDDDZGameOperateNotify_MSGID_MSGID_MIN = ProJDDDZGameOperateNotify_MSGID_ID;
const ProJDDDZGameOperateNotify_MSGID ProJDDDZGameOperateNotify_MSGID_MSGID_MAX = ProJDDDZGameOperateNotify_MSGID_ID;
const int ProJDDDZGameOperateNotify_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameOperateNotify_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameOperateNotify_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameOperateNotify_MSGID_Name(ProJDDDZGameOperateNotify_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameOperateNotify_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameOperateNotify_MSGID_Parse(
const ::std::string& name, ProJDDDZGameOperateNotify_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameOperateNotify_MSGID>(
ProJDDDZGameOperateNotify_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameOperateResult_MSGID {
ProJDDDZGameOperateResult_MSGID_ID = 2214
};
bool ProJDDDZGameOperateResult_MSGID_IsValid(int value);
const ProJDDDZGameOperateResult_MSGID ProJDDDZGameOperateResult_MSGID_MSGID_MIN = ProJDDDZGameOperateResult_MSGID_ID;
const ProJDDDZGameOperateResult_MSGID ProJDDDZGameOperateResult_MSGID_MSGID_MAX = ProJDDDZGameOperateResult_MSGID_ID;
const int ProJDDDZGameOperateResult_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameOperateResult_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameOperateResult_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameOperateResult_MSGID_Name(ProJDDDZGameOperateResult_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameOperateResult_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameOperateResult_MSGID_Parse(
const ::std::string& name, ProJDDDZGameOperateResult_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameOperateResult_MSGID>(
ProJDDDZGameOperateResult_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameOperateRequest_MSGID {
ProJDDDZGameOperateRequest_MSGID_ID = 2215
};
bool ProJDDDZGameOperateRequest_MSGID_IsValid(int value);
const ProJDDDZGameOperateRequest_MSGID ProJDDDZGameOperateRequest_MSGID_MSGID_MIN = ProJDDDZGameOperateRequest_MSGID_ID;
const ProJDDDZGameOperateRequest_MSGID ProJDDDZGameOperateRequest_MSGID_MSGID_MAX = ProJDDDZGameOperateRequest_MSGID_ID;
const int ProJDDDZGameOperateRequest_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameOperateRequest_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameOperateRequest_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameOperateRequest_MSGID_Name(ProJDDDZGameOperateRequest_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameOperateRequest_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameOperateRequest_MSGID_Parse(
const ::std::string& name, ProJDDDZGameOperateRequest_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameOperateRequest_MSGID>(
ProJDDDZGameOperateRequest_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameTrust_MSGID {
ProJDDDZGameTrust_MSGID_ID = 2216
};
bool ProJDDDZGameTrust_MSGID_IsValid(int value);
const ProJDDDZGameTrust_MSGID ProJDDDZGameTrust_MSGID_MSGID_MIN = ProJDDDZGameTrust_MSGID_ID;
const ProJDDDZGameTrust_MSGID ProJDDDZGameTrust_MSGID_MSGID_MAX = ProJDDDZGameTrust_MSGID_ID;
const int ProJDDDZGameTrust_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameTrust_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameTrust_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameTrust_MSGID_Name(ProJDDDZGameTrust_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameTrust_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameTrust_MSGID_Parse(
const ::std::string& name, ProJDDDZGameTrust_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameTrust_MSGID>(
ProJDDDZGameTrust_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameOutMahRequest_MSGID {
ProJDDDZGameOutMahRequest_MSGID_ID = 2217
};
bool ProJDDDZGameOutMahRequest_MSGID_IsValid(int value);
const ProJDDDZGameOutMahRequest_MSGID ProJDDDZGameOutMahRequest_MSGID_MSGID_MIN = ProJDDDZGameOutMahRequest_MSGID_ID;
const ProJDDDZGameOutMahRequest_MSGID ProJDDDZGameOutMahRequest_MSGID_MSGID_MAX = ProJDDDZGameOutMahRequest_MSGID_ID;
const int ProJDDDZGameOutMahRequest_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameOutMahRequest_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameOutMahRequest_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameOutMahRequest_MSGID_Name(ProJDDDZGameOutMahRequest_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameOutMahRequest_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameOutMahRequest_MSGID_Parse(
const ::std::string& name, ProJDDDZGameOutMahRequest_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameOutMahRequest_MSGID>(
ProJDDDZGameOutMahRequest_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameCatchCard_MSGID {
ProJDDDZGameCatchCard_MSGID_ID = 2218
};
bool ProJDDDZGameCatchCard_MSGID_IsValid(int value);
const ProJDDDZGameCatchCard_MSGID ProJDDDZGameCatchCard_MSGID_MSGID_MIN = ProJDDDZGameCatchCard_MSGID_ID;
const ProJDDDZGameCatchCard_MSGID ProJDDDZGameCatchCard_MSGID_MSGID_MAX = ProJDDDZGameCatchCard_MSGID_ID;
const int ProJDDDZGameCatchCard_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameCatchCard_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameCatchCard_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameCatchCard_MSGID_Name(ProJDDDZGameCatchCard_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameCatchCard_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameCatchCard_MSGID_Parse(
const ::std::string& name, ProJDDDZGameCatchCard_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameCatchCard_MSGID>(
ProJDDDZGameCatchCard_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameEnd_MSGID {
ProJDDDZGameEnd_MSGID_ID = 2219
};
bool ProJDDDZGameEnd_MSGID_IsValid(int value);
const ProJDDDZGameEnd_MSGID ProJDDDZGameEnd_MSGID_MSGID_MIN = ProJDDDZGameEnd_MSGID_ID;
const ProJDDDZGameEnd_MSGID ProJDDDZGameEnd_MSGID_MSGID_MAX = ProJDDDZGameEnd_MSGID_ID;
const int ProJDDDZGameEnd_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameEnd_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameEnd_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameEnd_MSGID_Name(ProJDDDZGameEnd_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameEnd_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameEnd_MSGID_Parse(
const ::std::string& name, ProJDDDZGameEnd_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameEnd_MSGID>(
ProJDDDZGameEnd_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameQuickSoundRequest_MSGID {
ProJDDDZGameQuickSoundRequest_MSGID_ID = 2220
};
bool ProJDDDZGameQuickSoundRequest_MSGID_IsValid(int value);
const ProJDDDZGameQuickSoundRequest_MSGID ProJDDDZGameQuickSoundRequest_MSGID_MSGID_MIN = ProJDDDZGameQuickSoundRequest_MSGID_ID;
const ProJDDDZGameQuickSoundRequest_MSGID ProJDDDZGameQuickSoundRequest_MSGID_MSGID_MAX = ProJDDDZGameQuickSoundRequest_MSGID_ID;
const int ProJDDDZGameQuickSoundRequest_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameQuickSoundRequest_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameQuickSoundRequest_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameQuickSoundRequest_MSGID_Name(ProJDDDZGameQuickSoundRequest_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameQuickSoundRequest_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameQuickSoundRequest_MSGID_Parse(
const ::std::string& name, ProJDDDZGameQuickSoundRequest_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameQuickSoundRequest_MSGID>(
ProJDDDZGameQuickSoundRequest_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameQuickSoundResponse_MSGID {
ProJDDDZGameQuickSoundResponse_MSGID_ID = 2221
};
bool ProJDDDZGameQuickSoundResponse_MSGID_IsValid(int value);
const ProJDDDZGameQuickSoundResponse_MSGID ProJDDDZGameQuickSoundResponse_MSGID_MSGID_MIN = ProJDDDZGameQuickSoundResponse_MSGID_ID;
const ProJDDDZGameQuickSoundResponse_MSGID ProJDDDZGameQuickSoundResponse_MSGID_MSGID_MAX = ProJDDDZGameQuickSoundResponse_MSGID_ID;
const int ProJDDDZGameQuickSoundResponse_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameQuickSoundResponse_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameQuickSoundResponse_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameQuickSoundResponse_MSGID_Name(ProJDDDZGameQuickSoundResponse_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameQuickSoundResponse_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameQuickSoundResponse_MSGID_Parse(
const ::std::string& name, ProJDDDZGameQuickSoundResponse_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameQuickSoundResponse_MSGID>(
ProJDDDZGameQuickSoundResponse_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameSendDiscardMahs_MSGID {
ProJDDDZGameSendDiscardMahs_MSGID_ID = 2222
};
bool ProJDDDZGameSendDiscardMahs_MSGID_IsValid(int value);
const ProJDDDZGameSendDiscardMahs_MSGID ProJDDDZGameSendDiscardMahs_MSGID_MSGID_MIN = ProJDDDZGameSendDiscardMahs_MSGID_ID;
const ProJDDDZGameSendDiscardMahs_MSGID ProJDDDZGameSendDiscardMahs_MSGID_MSGID_MAX = ProJDDDZGameSendDiscardMahs_MSGID_ID;
const int ProJDDDZGameSendDiscardMahs_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameSendDiscardMahs_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameSendDiscardMahs_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameSendDiscardMahs_MSGID_Name(ProJDDDZGameSendDiscardMahs_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameSendDiscardMahs_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameSendDiscardMahs_MSGID_Parse(
const ::std::string& name, ProJDDDZGameSendDiscardMahs_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameSendDiscardMahs_MSGID>(
ProJDDDZGameSendDiscardMahs_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameSendActionMahs_MSGID {
ProJDDDZGameSendActionMahs_MSGID_ID = 2223
};
bool ProJDDDZGameSendActionMahs_MSGID_IsValid(int value);
const ProJDDDZGameSendActionMahs_MSGID ProJDDDZGameSendActionMahs_MSGID_MSGID_MIN = ProJDDDZGameSendActionMahs_MSGID_ID;
const ProJDDDZGameSendActionMahs_MSGID ProJDDDZGameSendActionMahs_MSGID_MSGID_MAX = ProJDDDZGameSendActionMahs_MSGID_ID;
const int ProJDDDZGameSendActionMahs_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameSendActionMahs_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameSendActionMahs_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameSendActionMahs_MSGID_Name(ProJDDDZGameSendActionMahs_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameSendActionMahs_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameSendActionMahs_MSGID_Parse(
const ::std::string& name, ProJDDDZGameSendActionMahs_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameSendActionMahs_MSGID>(
ProJDDDZGameSendActionMahs_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameBrokenRequest_MSGID {
ProJDDDZGameBrokenRequest_MSGID_ID = 2224
};
bool ProJDDDZGameBrokenRequest_MSGID_IsValid(int value);
const ProJDDDZGameBrokenRequest_MSGID ProJDDDZGameBrokenRequest_MSGID_MSGID_MIN = ProJDDDZGameBrokenRequest_MSGID_ID;
const ProJDDDZGameBrokenRequest_MSGID ProJDDDZGameBrokenRequest_MSGID_MSGID_MAX = ProJDDDZGameBrokenRequest_MSGID_ID;
const int ProJDDDZGameBrokenRequest_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameBrokenRequest_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameBrokenRequest_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameBrokenRequest_MSGID_Name(ProJDDDZGameBrokenRequest_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameBrokenRequest_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameBrokenRequest_MSGID_Parse(
const ::std::string& name, ProJDDDZGameBrokenRequest_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameBrokenRequest_MSGID>(
ProJDDDZGameBrokenRequest_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameBrokenOperate_MSGID {
ProJDDDZGameBrokenOperate_MSGID_ID = 2225
};
bool ProJDDDZGameBrokenOperate_MSGID_IsValid(int value);
const ProJDDDZGameBrokenOperate_MSGID ProJDDDZGameBrokenOperate_MSGID_MSGID_MIN = ProJDDDZGameBrokenOperate_MSGID_ID;
const ProJDDDZGameBrokenOperate_MSGID ProJDDDZGameBrokenOperate_MSGID_MSGID_MAX = ProJDDDZGameBrokenOperate_MSGID_ID;
const int ProJDDDZGameBrokenOperate_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameBrokenOperate_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameBrokenOperate_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameBrokenOperate_MSGID_Name(ProJDDDZGameBrokenOperate_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameBrokenOperate_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameBrokenOperate_MSGID_Parse(
const ::std::string& name, ProJDDDZGameBrokenOperate_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameBrokenOperate_MSGID>(
ProJDDDZGameBrokenOperate_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameBrokenNotify_MSGID {
ProJDDDZGameBrokenNotify_MSGID_ID = 2226
};
bool ProJDDDZGameBrokenNotify_MSGID_IsValid(int value);
const ProJDDDZGameBrokenNotify_MSGID ProJDDDZGameBrokenNotify_MSGID_MSGID_MIN = ProJDDDZGameBrokenNotify_MSGID_ID;
const ProJDDDZGameBrokenNotify_MSGID ProJDDDZGameBrokenNotify_MSGID_MSGID_MAX = ProJDDDZGameBrokenNotify_MSGID_ID;
const int ProJDDDZGameBrokenNotify_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameBrokenNotify_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameBrokenNotify_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameBrokenNotify_MSGID_Name(ProJDDDZGameBrokenNotify_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameBrokenNotify_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameBrokenNotify_MSGID_Parse(
const ::std::string& name, ProJDDDZGameBrokenNotify_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameBrokenNotify_MSGID>(
ProJDDDZGameBrokenNotify_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameRuleConfig_MSGID {
ProJDDDZGameRuleConfig_MSGID_ID = 2227
};
bool ProJDDDZGameRuleConfig_MSGID_IsValid(int value);
const ProJDDDZGameRuleConfig_MSGID ProJDDDZGameRuleConfig_MSGID_MSGID_MIN = ProJDDDZGameRuleConfig_MSGID_ID;
const ProJDDDZGameRuleConfig_MSGID ProJDDDZGameRuleConfig_MSGID_MSGID_MAX = ProJDDDZGameRuleConfig_MSGID_ID;
const int ProJDDDZGameRuleConfig_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameRuleConfig_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameRuleConfig_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameRuleConfig_MSGID_Name(ProJDDDZGameRuleConfig_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameRuleConfig_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameRuleConfig_MSGID_Parse(
const ::std::string& name, ProJDDDZGameRuleConfig_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameRuleConfig_MSGID>(
ProJDDDZGameRuleConfig_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameBrokenStatus_MSGID {
ProJDDDZGameBrokenStatus_MSGID_ID = 2228
};
bool ProJDDDZGameBrokenStatus_MSGID_IsValid(int value);
const ProJDDDZGameBrokenStatus_MSGID ProJDDDZGameBrokenStatus_MSGID_MSGID_MIN = ProJDDDZGameBrokenStatus_MSGID_ID;
const ProJDDDZGameBrokenStatus_MSGID ProJDDDZGameBrokenStatus_MSGID_MSGID_MAX = ProJDDDZGameBrokenStatus_MSGID_ID;
const int ProJDDDZGameBrokenStatus_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameBrokenStatus_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameBrokenStatus_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameBrokenStatus_MSGID_Name(ProJDDDZGameBrokenStatus_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameBrokenStatus_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameBrokenStatus_MSGID_Parse(
const ::std::string& name, ProJDDDZGameBrokenStatus_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameBrokenStatus_MSGID>(
ProJDDDZGameBrokenStatus_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameDataResp_MSGID {
ProJDDDZGameDataResp_MSGID_ID = 2229
};
bool ProJDDDZGameDataResp_MSGID_IsValid(int value);
const ProJDDDZGameDataResp_MSGID ProJDDDZGameDataResp_MSGID_MSGID_MIN = ProJDDDZGameDataResp_MSGID_ID;
const ProJDDDZGameDataResp_MSGID ProJDDDZGameDataResp_MSGID_MSGID_MAX = ProJDDDZGameDataResp_MSGID_ID;
const int ProJDDDZGameDataResp_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameDataResp_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameDataResp_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameDataResp_MSGID_Name(ProJDDDZGameDataResp_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameDataResp_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameDataResp_MSGID_Parse(
const ::std::string& name, ProJDDDZGameDataResp_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameDataResp_MSGID>(
ProJDDDZGameDataResp_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameRecordRequest_MSGID {
ProJDDDZGameRecordRequest_MSGID_ID = 2230
};
bool ProJDDDZGameRecordRequest_MSGID_IsValid(int value);
const ProJDDDZGameRecordRequest_MSGID ProJDDDZGameRecordRequest_MSGID_MSGID_MIN = ProJDDDZGameRecordRequest_MSGID_ID;
const ProJDDDZGameRecordRequest_MSGID ProJDDDZGameRecordRequest_MSGID_MSGID_MAX = ProJDDDZGameRecordRequest_MSGID_ID;
const int ProJDDDZGameRecordRequest_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameRecordRequest_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameRecordRequest_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameRecordRequest_MSGID_Name(ProJDDDZGameRecordRequest_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameRecordRequest_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameRecordRequest_MSGID_Parse(
const ::std::string& name, ProJDDDZGameRecordRequest_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameRecordRequest_MSGID>(
ProJDDDZGameRecordRequest_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameRecordResponse_MSGID {
ProJDDDZGameRecordResponse_MSGID_ID = 2231
};
bool ProJDDDZGameRecordResponse_MSGID_IsValid(int value);
const ProJDDDZGameRecordResponse_MSGID ProJDDDZGameRecordResponse_MSGID_MSGID_MIN = ProJDDDZGameRecordResponse_MSGID_ID;
const ProJDDDZGameRecordResponse_MSGID ProJDDDZGameRecordResponse_MSGID_MSGID_MAX = ProJDDDZGameRecordResponse_MSGID_ID;
const int ProJDDDZGameRecordResponse_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameRecordResponse_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameRecordResponse_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameRecordResponse_MSGID_Name(ProJDDDZGameRecordResponse_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameRecordResponse_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameRecordResponse_MSGID_Parse(
const ::std::string& name, ProJDDDZGameRecordResponse_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameRecordResponse_MSGID>(
ProJDDDZGameRecordResponse_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameUserLocationRequest_MSGID {
ProJDDDZGameUserLocationRequest_MSGID_ID = 2232
};
bool ProJDDDZGameUserLocationRequest_MSGID_IsValid(int value);
const ProJDDDZGameUserLocationRequest_MSGID ProJDDDZGameUserLocationRequest_MSGID_MSGID_MIN = ProJDDDZGameUserLocationRequest_MSGID_ID;
const ProJDDDZGameUserLocationRequest_MSGID ProJDDDZGameUserLocationRequest_MSGID_MSGID_MAX = ProJDDDZGameUserLocationRequest_MSGID_ID;
const int ProJDDDZGameUserLocationRequest_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameUserLocationRequest_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameUserLocationRequest_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameUserLocationRequest_MSGID_Name(ProJDDDZGameUserLocationRequest_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameUserLocationRequest_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameUserLocationRequest_MSGID_Parse(
const ::std::string& name, ProJDDDZGameUserLocationRequest_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameUserLocationRequest_MSGID>(
ProJDDDZGameUserLocationRequest_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameSyncCardResponse_MSGID {
ProJDDDZGameSyncCardResponse_MSGID_ID = 2233
};
bool ProJDDDZGameSyncCardResponse_MSGID_IsValid(int value);
const ProJDDDZGameSyncCardResponse_MSGID ProJDDDZGameSyncCardResponse_MSGID_MSGID_MIN = ProJDDDZGameSyncCardResponse_MSGID_ID;
const ProJDDDZGameSyncCardResponse_MSGID ProJDDDZGameSyncCardResponse_MSGID_MSGID_MAX = ProJDDDZGameSyncCardResponse_MSGID_ID;
const int ProJDDDZGameSyncCardResponse_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameSyncCardResponse_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameSyncCardResponse_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameSyncCardResponse_MSGID_Name(ProJDDDZGameSyncCardResponse_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameSyncCardResponse_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameSyncCardResponse_MSGID_Parse(
const ::std::string& name, ProJDDDZGameSyncCardResponse_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameSyncCardResponse_MSGID>(
ProJDDDZGameSyncCardResponse_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameUserPhoneStatusRequest_MSGID {
ProJDDDZGameUserPhoneStatusRequest_MSGID_ID = 2234
};
bool ProJDDDZGameUserPhoneStatusRequest_MSGID_IsValid(int value);
const ProJDDDZGameUserPhoneStatusRequest_MSGID ProJDDDZGameUserPhoneStatusRequest_MSGID_MSGID_MIN = ProJDDDZGameUserPhoneStatusRequest_MSGID_ID;
const ProJDDDZGameUserPhoneStatusRequest_MSGID ProJDDDZGameUserPhoneStatusRequest_MSGID_MSGID_MAX = ProJDDDZGameUserPhoneStatusRequest_MSGID_ID;
const int ProJDDDZGameUserPhoneStatusRequest_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameUserPhoneStatusRequest_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameUserPhoneStatusRequest_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameUserPhoneStatusRequest_MSGID_Name(ProJDDDZGameUserPhoneStatusRequest_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameUserPhoneStatusRequest_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameUserPhoneStatusRequest_MSGID_Parse(
const ::std::string& name, ProJDDDZGameUserPhoneStatusRequest_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameUserPhoneStatusRequest_MSGID>(
ProJDDDZGameUserPhoneStatusRequest_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameUserGiveUpRequest_MSGID {
ProJDDDZGameUserGiveUpRequest_MSGID_ID = 2235
};
bool ProJDDDZGameUserGiveUpRequest_MSGID_IsValid(int value);
const ProJDDDZGameUserGiveUpRequest_MSGID ProJDDDZGameUserGiveUpRequest_MSGID_MSGID_MIN = ProJDDDZGameUserGiveUpRequest_MSGID_ID;
const ProJDDDZGameUserGiveUpRequest_MSGID ProJDDDZGameUserGiveUpRequest_MSGID_MSGID_MAX = ProJDDDZGameUserGiveUpRequest_MSGID_ID;
const int ProJDDDZGameUserGiveUpRequest_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameUserGiveUpRequest_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameUserGiveUpRequest_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameUserGiveUpRequest_MSGID_Name(ProJDDDZGameUserGiveUpRequest_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameUserGiveUpRequest_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameUserGiveUpRequest_MSGID_Parse(
const ::std::string& name, ProJDDDZGameUserGiveUpRequest_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameUserGiveUpRequest_MSGID>(
ProJDDDZGameUserGiveUpRequest_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameUserHintRequest_MSGID {
ProJDDDZGameUserHintRequest_MSGID_ID = 2236
};
bool ProJDDDZGameUserHintRequest_MSGID_IsValid(int value);
const ProJDDDZGameUserHintRequest_MSGID ProJDDDZGameUserHintRequest_MSGID_MSGID_MIN = ProJDDDZGameUserHintRequest_MSGID_ID;
const ProJDDDZGameUserHintRequest_MSGID ProJDDDZGameUserHintRequest_MSGID_MSGID_MAX = ProJDDDZGameUserHintRequest_MSGID_ID;
const int ProJDDDZGameUserHintRequest_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameUserHintRequest_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameUserHintRequest_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameUserHintRequest_MSGID_Name(ProJDDDZGameUserHintRequest_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameUserHintRequest_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameUserHintRequest_MSGID_Parse(
const ::std::string& name, ProJDDDZGameUserHintRequest_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameUserHintRequest_MSGID>(
ProJDDDZGameUserHintRequest_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameUserHintResponse_MSGID {
ProJDDDZGameUserHintResponse_MSGID_ID = 2237
};
bool ProJDDDZGameUserHintResponse_MSGID_IsValid(int value);
const ProJDDDZGameUserHintResponse_MSGID ProJDDDZGameUserHintResponse_MSGID_MSGID_MIN = ProJDDDZGameUserHintResponse_MSGID_ID;
const ProJDDDZGameUserHintResponse_MSGID ProJDDDZGameUserHintResponse_MSGID_MSGID_MAX = ProJDDDZGameUserHintResponse_MSGID_ID;
const int ProJDDDZGameUserHintResponse_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameUserHintResponse_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameUserHintResponse_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameUserHintResponse_MSGID_Name(ProJDDDZGameUserHintResponse_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameUserHintResponse_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameUserHintResponse_MSGID_Parse(
const ::std::string& name, ProJDDDZGameUserHintResponse_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameUserHintResponse_MSGID>(
ProJDDDZGameUserHintResponse_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameUserCallScoreResponse_MSGID {
ProJDDDZGameUserCallScoreResponse_MSGID_ID = 2238
};
bool ProJDDDZGameUserCallScoreResponse_MSGID_IsValid(int value);
const ProJDDDZGameUserCallScoreResponse_MSGID ProJDDDZGameUserCallScoreResponse_MSGID_MSGID_MIN = ProJDDDZGameUserCallScoreResponse_MSGID_ID;
const ProJDDDZGameUserCallScoreResponse_MSGID ProJDDDZGameUserCallScoreResponse_MSGID_MSGID_MAX = ProJDDDZGameUserCallScoreResponse_MSGID_ID;
const int ProJDDDZGameUserCallScoreResponse_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameUserCallScoreResponse_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameUserCallScoreResponse_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameUserCallScoreResponse_MSGID_Name(ProJDDDZGameUserCallScoreResponse_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameUserCallScoreResponse_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameUserCallScoreResponse_MSGID_Parse(
const ::std::string& name, ProJDDDZGameUserCallScoreResponse_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameUserCallScoreResponse_MSGID>(
ProJDDDZGameUserCallScoreResponse_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameUserCallScoreRequest_MSGID {
ProJDDDZGameUserCallScoreRequest_MSGID_ID = 2239
};
bool ProJDDDZGameUserCallScoreRequest_MSGID_IsValid(int value);
const ProJDDDZGameUserCallScoreRequest_MSGID ProJDDDZGameUserCallScoreRequest_MSGID_MSGID_MIN = ProJDDDZGameUserCallScoreRequest_MSGID_ID;
const ProJDDDZGameUserCallScoreRequest_MSGID ProJDDDZGameUserCallScoreRequest_MSGID_MSGID_MAX = ProJDDDZGameUserCallScoreRequest_MSGID_ID;
const int ProJDDDZGameUserCallScoreRequest_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameUserCallScoreRequest_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameUserCallScoreRequest_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameUserCallScoreRequest_MSGID_Name(ProJDDDZGameUserCallScoreRequest_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameUserCallScoreRequest_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameUserCallScoreRequest_MSGID_Parse(
const ::std::string& name, ProJDDDZGameUserCallScoreRequest_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameUserCallScoreRequest_MSGID>(
ProJDDDZGameUserCallScoreRequest_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameCallNotify_MSGID {
ProJDDDZGameCallNotify_MSGID_ID = 2244
};
bool ProJDDDZGameCallNotify_MSGID_IsValid(int value);
const ProJDDDZGameCallNotify_MSGID ProJDDDZGameCallNotify_MSGID_MSGID_MIN = ProJDDDZGameCallNotify_MSGID_ID;
const ProJDDDZGameCallNotify_MSGID ProJDDDZGameCallNotify_MSGID_MSGID_MAX = ProJDDDZGameCallNotify_MSGID_ID;
const int ProJDDDZGameCallNotify_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameCallNotify_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameCallNotify_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameCallNotify_MSGID_Name(ProJDDDZGameCallNotify_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameCallNotify_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameCallNotify_MSGID_Parse(
const ::std::string& name, ProJDDDZGameCallNotify_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameCallNotify_MSGID>(
ProJDDDZGameCallNotify_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameQiangNotify_MSGID {
ProJDDDZGameQiangNotify_MSGID_ID = 2245
};
bool ProJDDDZGameQiangNotify_MSGID_IsValid(int value);
const ProJDDDZGameQiangNotify_MSGID ProJDDDZGameQiangNotify_MSGID_MSGID_MIN = ProJDDDZGameQiangNotify_MSGID_ID;
const ProJDDDZGameQiangNotify_MSGID ProJDDDZGameQiangNotify_MSGID_MSGID_MAX = ProJDDDZGameQiangNotify_MSGID_ID;
const int ProJDDDZGameQiangNotify_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameQiangNotify_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameQiangNotify_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameQiangNotify_MSGID_Name(ProJDDDZGameQiangNotify_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameQiangNotify_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameQiangNotify_MSGID_Parse(
const ::std::string& name, ProJDDDZGameQiangNotify_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameQiangNotify_MSGID>(
ProJDDDZGameQiangNotify_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameUserCallLandlordResponse_MSGID {
ProJDDDZGameUserCallLandlordResponse_MSGID_ID = 2240
};
bool ProJDDDZGameUserCallLandlordResponse_MSGID_IsValid(int value);
const ProJDDDZGameUserCallLandlordResponse_MSGID ProJDDDZGameUserCallLandlordResponse_MSGID_MSGID_MIN = ProJDDDZGameUserCallLandlordResponse_MSGID_ID;
const ProJDDDZGameUserCallLandlordResponse_MSGID ProJDDDZGameUserCallLandlordResponse_MSGID_MSGID_MAX = ProJDDDZGameUserCallLandlordResponse_MSGID_ID;
const int ProJDDDZGameUserCallLandlordResponse_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameUserCallLandlordResponse_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameUserCallLandlordResponse_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameUserCallLandlordResponse_MSGID_Name(ProJDDDZGameUserCallLandlordResponse_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameUserCallLandlordResponse_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameUserCallLandlordResponse_MSGID_Parse(
const ::std::string& name, ProJDDDZGameUserCallLandlordResponse_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameUserCallLandlordResponse_MSGID>(
ProJDDDZGameUserCallLandlordResponse_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameUserCallLandlordRequest_MSGID {
ProJDDDZGameUserCallLandlordRequest_MSGID_ID = 2241
};
bool ProJDDDZGameUserCallLandlordRequest_MSGID_IsValid(int value);
const ProJDDDZGameUserCallLandlordRequest_MSGID ProJDDDZGameUserCallLandlordRequest_MSGID_MSGID_MIN = ProJDDDZGameUserCallLandlordRequest_MSGID_ID;
const ProJDDDZGameUserCallLandlordRequest_MSGID ProJDDDZGameUserCallLandlordRequest_MSGID_MSGID_MAX = ProJDDDZGameUserCallLandlordRequest_MSGID_ID;
const int ProJDDDZGameUserCallLandlordRequest_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameUserCallLandlordRequest_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameUserCallLandlordRequest_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameUserCallLandlordRequest_MSGID_Name(ProJDDDZGameUserCallLandlordRequest_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameUserCallLandlordRequest_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameUserCallLandlordRequest_MSGID_Parse(
const ::std::string& name, ProJDDDZGameUserCallLandlordRequest_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameUserCallLandlordRequest_MSGID>(
ProJDDDZGameUserCallLandlordRequest_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameUserQinagLandlordResponse_MSGID {
ProJDDDZGameUserQinagLandlordResponse_MSGID_ID = 2242
};
bool ProJDDDZGameUserQinagLandlordResponse_MSGID_IsValid(int value);
const ProJDDDZGameUserQinagLandlordResponse_MSGID ProJDDDZGameUserQinagLandlordResponse_MSGID_MSGID_MIN = ProJDDDZGameUserQinagLandlordResponse_MSGID_ID;
const ProJDDDZGameUserQinagLandlordResponse_MSGID ProJDDDZGameUserQinagLandlordResponse_MSGID_MSGID_MAX = ProJDDDZGameUserQinagLandlordResponse_MSGID_ID;
const int ProJDDDZGameUserQinagLandlordResponse_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameUserQinagLandlordResponse_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameUserQinagLandlordResponse_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameUserQinagLandlordResponse_MSGID_Name(ProJDDDZGameUserQinagLandlordResponse_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameUserQinagLandlordResponse_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameUserQinagLandlordResponse_MSGID_Parse(
const ::std::string& name, ProJDDDZGameUserQinagLandlordResponse_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameUserQinagLandlordResponse_MSGID>(
ProJDDDZGameUserQinagLandlordResponse_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameUserQiangLandlordRequest_MSGID {
ProJDDDZGameUserQiangLandlordRequest_MSGID_ID = 2243
};
bool ProJDDDZGameUserQiangLandlordRequest_MSGID_IsValid(int value);
const ProJDDDZGameUserQiangLandlordRequest_MSGID ProJDDDZGameUserQiangLandlordRequest_MSGID_MSGID_MIN = ProJDDDZGameUserQiangLandlordRequest_MSGID_ID;
const ProJDDDZGameUserQiangLandlordRequest_MSGID ProJDDDZGameUserQiangLandlordRequest_MSGID_MSGID_MAX = ProJDDDZGameUserQiangLandlordRequest_MSGID_ID;
const int ProJDDDZGameUserQiangLandlordRequest_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameUserQiangLandlordRequest_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameUserQiangLandlordRequest_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameUserQiangLandlordRequest_MSGID_Name(ProJDDDZGameUserQiangLandlordRequest_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameUserQiangLandlordRequest_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameUserQiangLandlordRequest_MSGID_Parse(
const ::std::string& name, ProJDDDZGameUserQiangLandlordRequest_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameUserQiangLandlordRequest_MSGID>(
ProJDDDZGameUserQiangLandlordRequest_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameSendLastCard_MSGID {
ProJDDDZGameSendLastCard_MSGID_ID = 2246
};
bool ProJDDDZGameSendLastCard_MSGID_IsValid(int value);
const ProJDDDZGameSendLastCard_MSGID ProJDDDZGameSendLastCard_MSGID_MSGID_MIN = ProJDDDZGameSendLastCard_MSGID_ID;
const ProJDDDZGameSendLastCard_MSGID ProJDDDZGameSendLastCard_MSGID_MSGID_MAX = ProJDDDZGameSendLastCard_MSGID_ID;
const int ProJDDDZGameSendLastCard_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameSendLastCard_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameSendLastCard_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameSendLastCard_MSGID_Name(ProJDDDZGameSendLastCard_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameSendLastCard_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameSendLastCard_MSGID_Parse(
const ::std::string& name, ProJDDDZGameSendLastCard_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameSendLastCard_MSGID>(
ProJDDDZGameSendLastCard_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameUserMingPaiRequest_MSGID {
ProJDDDZGameUserMingPaiRequest_MSGID_ID = 2247
};
bool ProJDDDZGameUserMingPaiRequest_MSGID_IsValid(int value);
const ProJDDDZGameUserMingPaiRequest_MSGID ProJDDDZGameUserMingPaiRequest_MSGID_MSGID_MIN = ProJDDDZGameUserMingPaiRequest_MSGID_ID;
const ProJDDDZGameUserMingPaiRequest_MSGID ProJDDDZGameUserMingPaiRequest_MSGID_MSGID_MAX = ProJDDDZGameUserMingPaiRequest_MSGID_ID;
const int ProJDDDZGameUserMingPaiRequest_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameUserMingPaiRequest_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameUserMingPaiRequest_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameUserMingPaiRequest_MSGID_Name(ProJDDDZGameUserMingPaiRequest_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameUserMingPaiRequest_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameUserMingPaiRequest_MSGID_Parse(
const ::std::string& name, ProJDDDZGameUserMingPaiRequest_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameUserMingPaiRequest_MSGID>(
ProJDDDZGameUserMingPaiRequest_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameUserMingPaiResponse_MSGID {
ProJDDDZGameUserMingPaiResponse_MSGID_ID = 2248
};
bool ProJDDDZGameUserMingPaiResponse_MSGID_IsValid(int value);
const ProJDDDZGameUserMingPaiResponse_MSGID ProJDDDZGameUserMingPaiResponse_MSGID_MSGID_MIN = ProJDDDZGameUserMingPaiResponse_MSGID_ID;
const ProJDDDZGameUserMingPaiResponse_MSGID ProJDDDZGameUserMingPaiResponse_MSGID_MSGID_MAX = ProJDDDZGameUserMingPaiResponse_MSGID_ID;
const int ProJDDDZGameUserMingPaiResponse_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameUserMingPaiResponse_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameUserMingPaiResponse_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameUserMingPaiResponse_MSGID_Name(ProJDDDZGameUserMingPaiResponse_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameUserMingPaiResponse_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameUserMingPaiResponse_MSGID_Parse(
const ::std::string& name, ProJDDDZGameUserMingPaiResponse_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameUserMingPaiResponse_MSGID>(
ProJDDDZGameUserMingPaiResponse_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameMingNotify_MSGID {
ProJDDDZGameMingNotify_MSGID_ID = 2249
};
bool ProJDDDZGameMingNotify_MSGID_IsValid(int value);
const ProJDDDZGameMingNotify_MSGID ProJDDDZGameMingNotify_MSGID_MSGID_MIN = ProJDDDZGameMingNotify_MSGID_ID;
const ProJDDDZGameMingNotify_MSGID ProJDDDZGameMingNotify_MSGID_MSGID_MAX = ProJDDDZGameMingNotify_MSGID_ID;
const int ProJDDDZGameMingNotify_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameMingNotify_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameMingNotify_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameMingNotify_MSGID_Name(ProJDDDZGameMingNotify_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameMingNotify_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameMingNotify_MSGID_Parse(
const ::std::string& name, ProJDDDZGameMingNotify_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameMingNotify_MSGID>(
ProJDDDZGameMingNotify_MSGID_descriptor(), name, value);
}
enum ProJDDDZGameStartAgain_MSGID {
ProJDDDZGameStartAgain_MSGID_ID = 2250
};
bool ProJDDDZGameStartAgain_MSGID_IsValid(int value);
const ProJDDDZGameStartAgain_MSGID ProJDDDZGameStartAgain_MSGID_MSGID_MIN = ProJDDDZGameStartAgain_MSGID_ID;
const ProJDDDZGameStartAgain_MSGID ProJDDDZGameStartAgain_MSGID_MSGID_MAX = ProJDDDZGameStartAgain_MSGID_ID;
const int ProJDDDZGameStartAgain_MSGID_MSGID_ARRAYSIZE = ProJDDDZGameStartAgain_MSGID_MSGID_MAX + 1;
const ::google::protobuf::EnumDescriptor* ProJDDDZGameStartAgain_MSGID_descriptor();
inline const ::std::string& ProJDDDZGameStartAgain_MSGID_Name(ProJDDDZGameStartAgain_MSGID value) {
return ::google::protobuf::internal::NameOfEnum(
ProJDDDZGameStartAgain_MSGID_descriptor(), value);
}
inline bool ProJDDDZGameStartAgain_MSGID_Parse(
const ::std::string& name, ProJDDDZGameStartAgain_MSGID* value) {
return ::google::protobuf::internal::ParseNamedEnum<ProJDDDZGameStartAgain_MSGID>(
ProJDDDZGameStartAgain_MSGID_descriptor(), name, value);
}
enum JDDDZGameState {
JDDDZ_GAME_IDLE = 1,
JDDDZ_GAME_DICE_BANK = 2,
JDDDZ_GAME_SEND = 3,
JDDDZ_GAME_DICE_KING = 4,
JDDDZ_GAME_CALL = 5,
JDDDZ_GAME_QIANG = 6,
JDDDZ_GAME_PLAY = 7,
JDDDZ_GAME_END = 8
};
bool JDDDZGameState_IsValid(int value);
const JDDDZGameState JDDDZGameState_MIN = JDDDZ_GAME_IDLE;
const JDDDZGameState JDDDZGameState_MAX = JDDDZ_GAME_END;
const int JDDDZGameState_ARRAYSIZE = JDDDZGameState_MAX + 1;
const ::google::protobuf::EnumDescriptor* JDDDZGameState_descriptor();
inline const ::std::string& JDDDZGameState_Name(JDDDZGameState value) {
return ::google::protobuf::internal::NameOfEnum(
JDDDZGameState_descriptor(), value);
}
inline bool JDDDZGameState_Parse(
const ::std::string& name, JDDDZGameState* value) {
return ::google::protobuf::internal::ParseNamedEnum<JDDDZGameState>(
JDDDZGameState_descriptor(), name, value);
}
enum JDDDZSEND_TYPE {
JDDDZ_NORMAL_SEND = 1,
JDDDZ_RECOME_SEND = 2
};
bool JDDDZSEND_TYPE_IsValid(int value);
const JDDDZSEND_TYPE JDDDZSEND_TYPE_MIN = JDDDZ_NORMAL_SEND;
const JDDDZSEND_TYPE JDDDZSEND_TYPE_MAX = JDDDZ_RECOME_SEND;
const int JDDDZSEND_TYPE_ARRAYSIZE = JDDDZSEND_TYPE_MAX + 1;
const ::google::protobuf::EnumDescriptor* JDDDZSEND_TYPE_descriptor();
inline const ::std::string& JDDDZSEND_TYPE_Name(JDDDZSEND_TYPE value) {
return ::google::protobuf::internal::NameOfEnum(
JDDDZSEND_TYPE_descriptor(), value);
}
inline bool JDDDZSEND_TYPE_Parse(
const ::std::string& name, JDDDZSEND_TYPE* value) {
return ::google::protobuf::internal::ParseNamedEnum<JDDDZSEND_TYPE>(
JDDDZSEND_TYPE_descriptor(), name, value);
}
enum JDDDZKIGN_TYPE {
JDDDZ_KING_UP = 1,
JDDDZ_KING_HUITOU = 2,
JDDDZ_KING_MAILEI = 3
};
bool JDDDZKIGN_TYPE_IsValid(int value);
const JDDDZKIGN_TYPE JDDDZKIGN_TYPE_MIN = JDDDZ_KING_UP;
const JDDDZKIGN_TYPE JDDDZKIGN_TYPE_MAX = JDDDZ_KING_MAILEI;
const int JDDDZKIGN_TYPE_ARRAYSIZE = JDDDZKIGN_TYPE_MAX + 1;
const ::google::protobuf::EnumDescriptor* JDDDZKIGN_TYPE_descriptor();
inline const ::std::string& JDDDZKIGN_TYPE_Name(JDDDZKIGN_TYPE value) {
return ::google::protobuf::internal::NameOfEnum(
JDDDZKIGN_TYPE_descriptor(), value);
}
inline bool JDDDZKIGN_TYPE_Parse(
const ::std::string& name, JDDDZKIGN_TYPE* value) {
return ::google::protobuf::internal::ParseNamedEnum<JDDDZKIGN_TYPE>(
JDDDZKIGN_TYPE_descriptor(), name, value);
}
enum JDDDZBROKEN_TYPE {
JDDDZ_BT_MASTER_QUIT = 0,
JDDDZ_BT_USER_QUIT = 1,
JDDDZ_BT_BROKEN = 2
};
bool JDDDZBROKEN_TYPE_IsValid(int value);
const JDDDZBROKEN_TYPE JDDDZBROKEN_TYPE_MIN = JDDDZ_BT_MASTER_QUIT;
const JDDDZBROKEN_TYPE JDDDZBROKEN_TYPE_MAX = JDDDZ_BT_BROKEN;
const int JDDDZBROKEN_TYPE_ARRAYSIZE = JDDDZBROKEN_TYPE_MAX + 1;
const ::google::protobuf::EnumDescriptor* JDDDZBROKEN_TYPE_descriptor();
inline const ::std::string& JDDDZBROKEN_TYPE_Name(JDDDZBROKEN_TYPE value) {
return ::google::protobuf::internal::NameOfEnum(
JDDDZBROKEN_TYPE_descriptor(), value);
}
inline bool JDDDZBROKEN_TYPE_Parse(
const ::std::string& name, JDDDZBROKEN_TYPE* value) {
return ::google::protobuf::internal::ParseNamedEnum<JDDDZBROKEN_TYPE>(
JDDDZBROKEN_TYPE_descriptor(), name, value);
}
enum JDDDZBROKEN_OPERATE {
JDDDZ_BO_DISAGREE = 0,
JDDDZ_BO_AGREE = 1
};
bool JDDDZBROKEN_OPERATE_IsValid(int value);
const JDDDZBROKEN_OPERATE JDDDZBROKEN_OPERATE_MIN = JDDDZ_BO_DISAGREE;
const JDDDZBROKEN_OPERATE JDDDZBROKEN_OPERATE_MAX = JDDDZ_BO_AGREE;
const int JDDDZBROKEN_OPERATE_ARRAYSIZE = JDDDZBROKEN_OPERATE_MAX + 1;
const ::google::protobuf::EnumDescriptor* JDDDZBROKEN_OPERATE_descriptor();
inline const ::std::string& JDDDZBROKEN_OPERATE_Name(JDDDZBROKEN_OPERATE value) {
return ::google::protobuf::internal::NameOfEnum(
JDDDZBROKEN_OPERATE_descriptor(), value);
}
inline bool JDDDZBROKEN_OPERATE_Parse(
const ::std::string& name, JDDDZBROKEN_OPERATE* value) {
return ::google::protobuf::internal::ParseNamedEnum<JDDDZBROKEN_OPERATE>(
JDDDZBROKEN_OPERATE_descriptor(), name, value);
}
enum JDDDZBROKEN_CODE {
JDDDZ_BC_SUCCESS = 0,
JDDDZ_BC_DISAGREE = 1,
JDDDZ_BC_QUIT_SUCCESS = 2,
JDDDZ_BC_EXCEPTION = 3
};
bool JDDDZBROKEN_CODE_IsValid(int value);
const JDDDZBROKEN_CODE JDDDZBROKEN_CODE_MIN = JDDDZ_BC_SUCCESS;
const JDDDZBROKEN_CODE JDDDZBROKEN_CODE_MAX = JDDDZ_BC_EXCEPTION;
const int JDDDZBROKEN_CODE_ARRAYSIZE = JDDDZBROKEN_CODE_MAX + 1;
const ::google::protobuf::EnumDescriptor* JDDDZBROKEN_CODE_descriptor();
inline const ::std::string& JDDDZBROKEN_CODE_Name(JDDDZBROKEN_CODE value) {
return ::google::protobuf::internal::NameOfEnum(
JDDDZBROKEN_CODE_descriptor(), value);
}
inline bool JDDDZBROKEN_CODE_Parse(
const ::std::string& name, JDDDZBROKEN_CODE* value) {
return ::google::protobuf::internal::ParseNamedEnum<JDDDZBROKEN_CODE>(
JDDDZBROKEN_CODE_descriptor(), name, value);
}
// ===================================================================
class ProJDDDZGameStatusResponse : public ::google::protobuf::Message {
public:
ProJDDDZGameStatusResponse();
virtual ~ProJDDDZGameStatusResponse();
ProJDDDZGameStatusResponse(const ProJDDDZGameStatusResponse& from);
inline ProJDDDZGameStatusResponse& operator=(const ProJDDDZGameStatusResponse& 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 ProJDDDZGameStatusResponse& default_instance();
void Swap(ProJDDDZGameStatusResponse* other);
// implements Message ----------------------------------------------
ProJDDDZGameStatusResponse* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameStatusResponse& from);
void MergeFrom(const ProJDDDZGameStatusResponse& 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 ProJDDDZGameStatusResponse_MSGID MSGID;
static const MSGID ID = ProJDDDZGameStatusResponse_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameStatusResponse_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameStatusResponse_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameStatusResponse_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameStatusResponse_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameStatusResponse_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameStatusResponse_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameStatusResponse_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional .JDDDZGameState status = 2;
inline bool has_status() const;
inline void clear_status();
static const int kStatusFieldNumber = 2;
inline ::JDDDZGameState status() const;
inline void set_status(::JDDDZGameState value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameStatusResponse)
private:
inline void set_has_status();
inline void clear_has_status();
::google::protobuf::UnknownFieldSet _unknown_fields_;
int status_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameStatusResponse* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameDeskInfoResponse : public ::google::protobuf::Message {
public:
ProJDDDZGameDeskInfoResponse();
virtual ~ProJDDDZGameDeskInfoResponse();
ProJDDDZGameDeskInfoResponse(const ProJDDDZGameDeskInfoResponse& from);
inline ProJDDDZGameDeskInfoResponse& operator=(const ProJDDDZGameDeskInfoResponse& 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 ProJDDDZGameDeskInfoResponse& default_instance();
void Swap(ProJDDDZGameDeskInfoResponse* other);
// implements Message ----------------------------------------------
ProJDDDZGameDeskInfoResponse* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameDeskInfoResponse& from);
void MergeFrom(const ProJDDDZGameDeskInfoResponse& 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 ProJDDDZGameDeskInfoResponse_MSGID MSGID;
static const MSGID ID = ProJDDDZGameDeskInfoResponse_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameDeskInfoResponse_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameDeskInfoResponse_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameDeskInfoResponse_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameDeskInfoResponse_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameDeskInfoResponse_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameDeskInfoResponse_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameDeskInfoResponse_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 CellScore = 2;
inline bool has_cellscore() const;
inline void clear_cellscore();
static const int kCellScoreFieldNumber = 2;
inline ::google::protobuf::int32 cellscore() const;
inline void set_cellscore(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameDeskInfoResponse)
private:
inline void set_has_cellscore();
inline void clear_has_cellscore();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 cellscore_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameDeskInfoResponse* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameReadyNotify : public ::google::protobuf::Message {
public:
ProJDDDZGameReadyNotify();
virtual ~ProJDDDZGameReadyNotify();
ProJDDDZGameReadyNotify(const ProJDDDZGameReadyNotify& from);
inline ProJDDDZGameReadyNotify& operator=(const ProJDDDZGameReadyNotify& 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 ProJDDDZGameReadyNotify& default_instance();
void Swap(ProJDDDZGameReadyNotify* other);
// implements Message ----------------------------------------------
ProJDDDZGameReadyNotify* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameReadyNotify& from);
void MergeFrom(const ProJDDDZGameReadyNotify& 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 ProJDDDZGameReadyNotify_MSGID MSGID;
static const MSGID ID = ProJDDDZGameReadyNotify_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameReadyNotify_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameReadyNotify_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameReadyNotify_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameReadyNotify_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameReadyNotify_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameReadyNotify_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameReadyNotify_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat = 2;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 2;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// optional int32 time = 3;
inline bool has_time() const;
inline void clear_time();
static const int kTimeFieldNumber = 3;
inline ::google::protobuf::int32 time() const;
inline void set_time(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameReadyNotify)
private:
inline void set_has_seat();
inline void clear_has_seat();
inline void set_has_time();
inline void clear_has_time();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 seat_;
::google::protobuf::int32 time_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameReadyNotify* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameReadyRequest : public ::google::protobuf::Message {
public:
ProJDDDZGameReadyRequest();
virtual ~ProJDDDZGameReadyRequest();
ProJDDDZGameReadyRequest(const ProJDDDZGameReadyRequest& from);
inline ProJDDDZGameReadyRequest& operator=(const ProJDDDZGameReadyRequest& 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 ProJDDDZGameReadyRequest& default_instance();
void Swap(ProJDDDZGameReadyRequest* other);
// implements Message ----------------------------------------------
ProJDDDZGameReadyRequest* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameReadyRequest& from);
void MergeFrom(const ProJDDDZGameReadyRequest& 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 ProJDDDZGameReadyRequest_MSGID MSGID;
static const MSGID ID = ProJDDDZGameReadyRequest_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameReadyRequest_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameReadyRequest_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameReadyRequest_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameReadyRequest_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameReadyRequest_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameReadyRequest_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameReadyRequest_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat = 2;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 2;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameReadyRequest)
private:
inline void set_has_seat();
inline void clear_has_seat();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 seat_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameReadyRequest* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameReadyResponse : public ::google::protobuf::Message {
public:
ProJDDDZGameReadyResponse();
virtual ~ProJDDDZGameReadyResponse();
ProJDDDZGameReadyResponse(const ProJDDDZGameReadyResponse& from);
inline ProJDDDZGameReadyResponse& operator=(const ProJDDDZGameReadyResponse& 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 ProJDDDZGameReadyResponse& default_instance();
void Swap(ProJDDDZGameReadyResponse* other);
// implements Message ----------------------------------------------
ProJDDDZGameReadyResponse* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameReadyResponse& from);
void MergeFrom(const ProJDDDZGameReadyResponse& 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 ProJDDDZGameReadyResponse_MSGID MSGID;
static const MSGID ID = ProJDDDZGameReadyResponse_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameReadyResponse_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameReadyResponse_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameReadyResponse_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameReadyResponse_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameReadyResponse_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameReadyResponse_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameReadyResponse_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat = 2;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 2;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// optional bool isMingPai = 3;
inline bool has_ismingpai() const;
inline void clear_ismingpai();
static const int kIsMingPaiFieldNumber = 3;
inline bool ismingpai() const;
inline void set_ismingpai(bool value);
// optional int32 MingPaiTag = 4;
inline bool has_mingpaitag() const;
inline void clear_mingpaitag();
static const int kMingPaiTagFieldNumber = 4;
inline ::google::protobuf::int32 mingpaitag() const;
inline void set_mingpaitag(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameReadyResponse)
private:
inline void set_has_seat();
inline void clear_has_seat();
inline void set_has_ismingpai();
inline void clear_has_ismingpai();
inline void set_has_mingpaitag();
inline void clear_has_mingpaitag();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 seat_;
bool ismingpai_;
::google::protobuf::int32 mingpaitag_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameReadyResponse* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameStart : public ::google::protobuf::Message {
public:
ProJDDDZGameStart();
virtual ~ProJDDDZGameStart();
ProJDDDZGameStart(const ProJDDDZGameStart& from);
inline ProJDDDZGameStart& operator=(const ProJDDDZGameStart& 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 ProJDDDZGameStart& default_instance();
void Swap(ProJDDDZGameStart* other);
// implements Message ----------------------------------------------
ProJDDDZGameStart* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameStart& from);
void MergeFrom(const ProJDDDZGameStart& 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 ProJDDDZGameStart_MSGID MSGID;
static const MSGID ID = ProJDDDZGameStart_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameStart_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameStart_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameStart_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameStart_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameStart_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameStart_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameStart_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 bankerseat = 2;
inline bool has_bankerseat() const;
inline void clear_bankerseat();
static const int kBankerseatFieldNumber = 2;
inline ::google::protobuf::int32 bankerseat() const;
inline void set_bankerseat(::google::protobuf::int32 value);
// optional int32 gamecount = 3;
inline bool has_gamecount() const;
inline void clear_gamecount();
static const int kGamecountFieldNumber = 3;
inline ::google::protobuf::int32 gamecount() const;
inline void set_gamecount(::google::protobuf::int32 value);
// optional int32 outCardtimes = 4;
inline bool has_outcardtimes() const;
inline void clear_outcardtimes();
static const int kOutCardtimesFieldNumber = 4;
inline ::google::protobuf::int32 outcardtimes() const;
inline void set_outcardtimes(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameStart)
private:
inline void set_has_bankerseat();
inline void clear_has_bankerseat();
inline void set_has_gamecount();
inline void clear_has_gamecount();
inline void set_has_outcardtimes();
inline void clear_has_outcardtimes();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 bankerseat_;
::google::protobuf::int32 gamecount_;
::google::protobuf::int32 outcardtimes_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameStart* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameDiceNotify : public ::google::protobuf::Message {
public:
ProJDDDZGameDiceNotify();
virtual ~ProJDDDZGameDiceNotify();
ProJDDDZGameDiceNotify(const ProJDDDZGameDiceNotify& from);
inline ProJDDDZGameDiceNotify& operator=(const ProJDDDZGameDiceNotify& 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 ProJDDDZGameDiceNotify& default_instance();
void Swap(ProJDDDZGameDiceNotify* other);
// implements Message ----------------------------------------------
ProJDDDZGameDiceNotify* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameDiceNotify& from);
void MergeFrom(const ProJDDDZGameDiceNotify& 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 ProJDDDZGameDiceNotify_MSGID MSGID;
static const MSGID ID = ProJDDDZGameDiceNotify_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameDiceNotify_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameDiceNotify_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameDiceNotify_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameDiceNotify_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameDiceNotify_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameDiceNotify_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameDiceNotify_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat = 2;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 2;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// optional int32 time = 3;
inline bool has_time() const;
inline void clear_time();
static const int kTimeFieldNumber = 3;
inline ::google::protobuf::int32 time() const;
inline void set_time(::google::protobuf::int32 value);
// optional int32 dicecount = 4;
inline bool has_dicecount() const;
inline void clear_dicecount();
static const int kDicecountFieldNumber = 4;
inline ::google::protobuf::int32 dicecount() const;
inline void set_dicecount(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameDiceNotify)
private:
inline void set_has_seat();
inline void clear_has_seat();
inline void set_has_time();
inline void clear_has_time();
inline void set_has_dicecount();
inline void clear_has_dicecount();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 seat_;
::google::protobuf::int32 time_;
::google::protobuf::int32 dicecount_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameDiceNotify* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameDiceRequest : public ::google::protobuf::Message {
public:
ProJDDDZGameDiceRequest();
virtual ~ProJDDDZGameDiceRequest();
ProJDDDZGameDiceRequest(const ProJDDDZGameDiceRequest& from);
inline ProJDDDZGameDiceRequest& operator=(const ProJDDDZGameDiceRequest& 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 ProJDDDZGameDiceRequest& default_instance();
void Swap(ProJDDDZGameDiceRequest* other);
// implements Message ----------------------------------------------
ProJDDDZGameDiceRequest* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameDiceRequest& from);
void MergeFrom(const ProJDDDZGameDiceRequest& 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 ProJDDDZGameDiceRequest_MSGID MSGID;
static const MSGID ID = ProJDDDZGameDiceRequest_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameDiceRequest_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameDiceRequest_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameDiceRequest_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameDiceRequest_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameDiceRequest_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameDiceRequest_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameDiceRequest_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat = 2;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 2;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// optional int32 dicecount = 3;
inline bool has_dicecount() const;
inline void clear_dicecount();
static const int kDicecountFieldNumber = 3;
inline ::google::protobuf::int32 dicecount() const;
inline void set_dicecount(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameDiceRequest)
private:
inline void set_has_seat();
inline void clear_has_seat();
inline void set_has_dicecount();
inline void clear_has_dicecount();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 seat_;
::google::protobuf::int32 dicecount_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameDiceRequest* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameDiceResult : public ::google::protobuf::Message {
public:
ProJDDDZGameDiceResult();
virtual ~ProJDDDZGameDiceResult();
ProJDDDZGameDiceResult(const ProJDDDZGameDiceResult& from);
inline ProJDDDZGameDiceResult& operator=(const ProJDDDZGameDiceResult& 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 ProJDDDZGameDiceResult& default_instance();
void Swap(ProJDDDZGameDiceResult* other);
// implements Message ----------------------------------------------
ProJDDDZGameDiceResult* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameDiceResult& from);
void MergeFrom(const ProJDDDZGameDiceResult& 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 ProJDDDZGameDiceResult_MSGID MSGID;
static const MSGID ID = ProJDDDZGameDiceResult_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameDiceResult_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameDiceResult_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameDiceResult_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameDiceResult_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameDiceResult_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameDiceResult_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameDiceResult_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat = 2;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 2;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// repeated int32 result = 3;
inline int result_size() const;
inline void clear_result();
static const int kResultFieldNumber = 3;
inline ::google::protobuf::int32 result(int index) const;
inline void set_result(int index, ::google::protobuf::int32 value);
inline void add_result(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
result() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_result();
// optional int32 dicecount = 4;
inline bool has_dicecount() const;
inline void clear_dicecount();
static const int kDicecountFieldNumber = 4;
inline ::google::protobuf::int32 dicecount() const;
inline void set_dicecount(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameDiceResult)
private:
inline void set_has_seat();
inline void clear_has_seat();
inline void set_has_dicecount();
inline void clear_has_dicecount();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > result_;
::google::protobuf::int32 seat_;
::google::protobuf::int32 dicecount_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameDiceResult* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameSendMahs : public ::google::protobuf::Message {
public:
ProJDDDZGameSendMahs();
virtual ~ProJDDDZGameSendMahs();
ProJDDDZGameSendMahs(const ProJDDDZGameSendMahs& from);
inline ProJDDDZGameSendMahs& operator=(const ProJDDDZGameSendMahs& 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 ProJDDDZGameSendMahs& default_instance();
void Swap(ProJDDDZGameSendMahs* other);
// implements Message ----------------------------------------------
ProJDDDZGameSendMahs* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameSendMahs& from);
void MergeFrom(const ProJDDDZGameSendMahs& 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 ProJDDDZGameSendMahs_MSGID MSGID;
static const MSGID ID = ProJDDDZGameSendMahs_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameSendMahs_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameSendMahs_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameSendMahs_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameSendMahs_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameSendMahs_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameSendMahs_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameSendMahs_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat = 2;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 2;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// repeated .JDDDZMahList cbHandCardData = 3;
inline int cbhandcarddata_size() const;
inline void clear_cbhandcarddata();
static const int kCbHandCardDataFieldNumber = 3;
inline const ::JDDDZMahList& cbhandcarddata(int index) const;
inline ::JDDDZMahList* mutable_cbhandcarddata(int index);
inline ::JDDDZMahList* add_cbhandcarddata();
inline const ::google::protobuf::RepeatedPtrField< ::JDDDZMahList >&
cbhandcarddata() const;
inline ::google::protobuf::RepeatedPtrField< ::JDDDZMahList >*
mutable_cbhandcarddata();
// repeated int32 mahscount = 4;
inline int mahscount_size() const;
inline void clear_mahscount();
static const int kMahscountFieldNumber = 4;
inline ::google::protobuf::int32 mahscount(int index) const;
inline void set_mahscount(int index, ::google::protobuf::int32 value);
inline void add_mahscount(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
mahscount() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_mahscount();
// optional int32 cbLeftCount = 5;
inline bool has_cbleftcount() const;
inline void clear_cbleftcount();
static const int kCbLeftCountFieldNumber = 5;
inline ::google::protobuf::int32 cbleftcount() const;
inline void set_cbleftcount(::google::protobuf::int32 value);
// optional int32 offlineTag = 6;
inline bool has_offlinetag() const;
inline void clear_offlinetag();
static const int kOfflineTagFieldNumber = 6;
inline ::google::protobuf::int32 offlinetag() const;
inline void set_offlinetag(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameSendMahs)
private:
inline void set_has_seat();
inline void clear_has_seat();
inline void set_has_cbleftcount();
inline void clear_has_cbleftcount();
inline void set_has_offlinetag();
inline void clear_has_offlinetag();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::RepeatedPtrField< ::JDDDZMahList > cbhandcarddata_;
::google::protobuf::int32 seat_;
::google::protobuf::int32 cbleftcount_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > mahscount_;
::google::protobuf::int32 offlinetag_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameSendMahs* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameKingData : public ::google::protobuf::Message {
public:
ProJDDDZGameKingData();
virtual ~ProJDDDZGameKingData();
ProJDDDZGameKingData(const ProJDDDZGameKingData& from);
inline ProJDDDZGameKingData& operator=(const ProJDDDZGameKingData& 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 ProJDDDZGameKingData& default_instance();
void Swap(ProJDDDZGameKingData* other);
// implements Message ----------------------------------------------
ProJDDDZGameKingData* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameKingData& from);
void MergeFrom(const ProJDDDZGameKingData& 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 ProJDDDZGameKingData_MSGID MSGID;
static const MSGID ID = ProJDDDZGameKingData_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameKingData_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameKingData_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameKingData_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameKingData_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameKingData_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameKingData_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameKingData_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat = 2;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 2;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// repeated int32 mahs = 3;
inline int mahs_size() const;
inline void clear_mahs();
static const int kMahsFieldNumber = 3;
inline ::google::protobuf::int32 mahs(int index) const;
inline void set_mahs(int index, ::google::protobuf::int32 value);
inline void add_mahs(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
mahs() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_mahs();
// repeated int32 downKingScore = 4;
inline int downkingscore_size() const;
inline void clear_downkingscore();
static const int kDownKingScoreFieldNumber = 4;
inline ::google::protobuf::int32 downkingscore(int index) const;
inline void set_downkingscore(int index, ::google::protobuf::int32 value);
inline void add_downkingscore(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
downkingscore() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_downkingscore();
// repeated int32 kingcount = 5;
inline int kingcount_size() const;
inline void clear_kingcount();
static const int kKingcountFieldNumber = 5;
inline ::google::protobuf::int32 kingcount(int index) const;
inline void set_kingcount(int index, ::google::protobuf::int32 value);
inline void add_kingcount(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
kingcount() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_kingcount();
// repeated int32 viceking = 6;
inline int viceking_size() const;
inline void clear_viceking();
static const int kVicekingFieldNumber = 6;
inline ::google::protobuf::int32 viceking(int index) const;
inline void set_viceking(int index, ::google::protobuf::int32 value);
inline void add_viceking(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
viceking() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_viceking();
// optional .JDDDZSEND_TYPE notify_type = 7 [default = JDDDZ_NORMAL_SEND];
inline bool has_notify_type() const;
inline void clear_notify_type();
static const int kNotifyTypeFieldNumber = 7;
inline ::JDDDZSEND_TYPE notify_type() const;
inline void set_notify_type(::JDDDZSEND_TYPE value);
// optional .JDDDZKIGN_TYPE king_type = 8 [default = JDDDZ_KING_UP];
inline bool has_king_type() const;
inline void clear_king_type();
static const int kKingTypeFieldNumber = 8;
inline ::JDDDZKIGN_TYPE king_type() const;
inline void set_king_type(::JDDDZKIGN_TYPE value);
// repeated int32 cbChongGuang = 9;
inline int cbchongguang_size() const;
inline void clear_cbchongguang();
static const int kCbChongGuangFieldNumber = 9;
inline ::google::protobuf::int32 cbchongguang(int index) const;
inline void set_cbchongguang(int index, ::google::protobuf::int32 value);
inline void add_cbchongguang(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
cbchongguang() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_cbchongguang();
// repeated int32 cbBaWangKing = 10;
inline int cbbawangking_size() const;
inline void clear_cbbawangking();
static const int kCbBaWangKingFieldNumber = 10;
inline ::google::protobuf::int32 cbbawangking(int index) const;
inline void set_cbbawangking(int index, ::google::protobuf::int32 value);
inline void add_cbbawangking(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
cbbawangking() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_cbbawangking();
// @@protoc_insertion_point(class_scope:ProJDDDZGameKingData)
private:
inline void set_has_seat();
inline void clear_has_seat();
inline void set_has_notify_type();
inline void clear_has_notify_type();
inline void set_has_king_type();
inline void clear_has_king_type();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > mahs_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > downkingscore_;
::google::protobuf::int32 seat_;
int notify_type_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > kingcount_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > viceking_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > cbchongguang_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > cbbawangking_;
int king_type_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(9 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameKingData* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameOutMahsResponse : public ::google::protobuf::Message {
public:
ProJDDDZGameOutMahsResponse();
virtual ~ProJDDDZGameOutMahsResponse();
ProJDDDZGameOutMahsResponse(const ProJDDDZGameOutMahsResponse& from);
inline ProJDDDZGameOutMahsResponse& operator=(const ProJDDDZGameOutMahsResponse& 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 ProJDDDZGameOutMahsResponse& default_instance();
void Swap(ProJDDDZGameOutMahsResponse* other);
// implements Message ----------------------------------------------
ProJDDDZGameOutMahsResponse* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameOutMahsResponse& from);
void MergeFrom(const ProJDDDZGameOutMahsResponse& 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 ProJDDDZGameOutMahsResponse_MSGID MSGID;
static const MSGID ID = ProJDDDZGameOutMahsResponse_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameOutMahsResponse_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameOutMahsResponse_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameOutMahsResponse_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameOutMahsResponse_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameOutMahsResponse_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameOutMahsResponse_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameOutMahsResponse_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat = 2;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 2;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// repeated int32 outMahs = 3;
inline int outmahs_size() const;
inline void clear_outmahs();
static const int kOutMahsFieldNumber = 3;
inline ::google::protobuf::int32 outmahs(int index) const;
inline void set_outmahs(int index, ::google::protobuf::int32 value);
inline void add_outmahs(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
outmahs() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_outmahs();
// repeated int32 handmahs = 4;
inline int handmahs_size() const;
inline void clear_handmahs();
static const int kHandmahsFieldNumber = 4;
inline ::google::protobuf::int32 handmahs(int index) const;
inline void set_handmahs(int index, ::google::protobuf::int32 value);
inline void add_handmahs(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
handmahs() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_handmahs();
// optional int32 cardCount = 5;
inline bool has_cardcount() const;
inline void clear_cardcount();
static const int kCardCountFieldNumber = 5;
inline ::google::protobuf::int32 cardcount() const;
inline void set_cardcount(::google::protobuf::int32 value);
// optional int32 cardType = 6;
inline bool has_cardtype() const;
inline void clear_cardtype();
static const int kCardTypeFieldNumber = 6;
inline ::google::protobuf::int32 cardtype() const;
inline void set_cardtype(::google::protobuf::int32 value);
// repeated int32 noChangeMahs = 7;
inline int nochangemahs_size() const;
inline void clear_nochangemahs();
static const int kNoChangeMahsFieldNumber = 7;
inline ::google::protobuf::int32 nochangemahs(int index) const;
inline void set_nochangemahs(int index, ::google::protobuf::int32 value);
inline void add_nochangemahs(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
nochangemahs() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_nochangemahs();
// @@protoc_insertion_point(class_scope:ProJDDDZGameOutMahsResponse)
private:
inline void set_has_seat();
inline void clear_has_seat();
inline void set_has_cardcount();
inline void clear_has_cardcount();
inline void set_has_cardtype();
inline void clear_has_cardtype();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > outmahs_;
::google::protobuf::int32 seat_;
::google::protobuf::int32 cardcount_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > handmahs_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > nochangemahs_;
::google::protobuf::int32 cardtype_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameOutMahsResponse* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameTimerPower : public ::google::protobuf::Message {
public:
ProJDDDZGameTimerPower();
virtual ~ProJDDDZGameTimerPower();
ProJDDDZGameTimerPower(const ProJDDDZGameTimerPower& from);
inline ProJDDDZGameTimerPower& operator=(const ProJDDDZGameTimerPower& 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 ProJDDDZGameTimerPower& default_instance();
void Swap(ProJDDDZGameTimerPower* other);
// implements Message ----------------------------------------------
ProJDDDZGameTimerPower* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameTimerPower& from);
void MergeFrom(const ProJDDDZGameTimerPower& 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 ProJDDDZGameTimerPower_MSGID MSGID;
static const MSGID ID = ProJDDDZGameTimerPower_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameTimerPower_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameTimerPower_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameTimerPower_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameTimerPower_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameTimerPower_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameTimerPower_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameTimerPower_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat = 2;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 2;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// optional int32 time = 3;
inline bool has_time() const;
inline void clear_time();
static const int kTimeFieldNumber = 3;
inline ::google::protobuf::int32 time() const;
inline void set_time(::google::protobuf::int32 value);
// optional int32 outcardTime = 4;
inline bool has_outcardtime() const;
inline void clear_outcardtime();
static const int kOutcardTimeFieldNumber = 4;
inline ::google::protobuf::int32 outcardtime() const;
inline void set_outcardtime(::google::protobuf::int32 value);
// optional int32 lastCardType = 5;
inline bool has_lastcardtype() const;
inline void clear_lastcardtype();
static const int kLastCardTypeFieldNumber = 5;
inline ::google::protobuf::int32 lastcardtype() const;
inline void set_lastcardtype(::google::protobuf::int32 value);
// optional int32 lastPoint = 6;
inline bool has_lastpoint() const;
inline void clear_lastpoint();
static const int kLastPointFieldNumber = 6;
inline ::google::protobuf::int32 lastpoint() const;
inline void set_lastpoint(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameTimerPower)
private:
inline void set_has_seat();
inline void clear_has_seat();
inline void set_has_time();
inline void clear_has_time();
inline void set_has_outcardtime();
inline void clear_has_outcardtime();
inline void set_has_lastcardtype();
inline void clear_has_lastcardtype();
inline void set_has_lastpoint();
inline void clear_has_lastpoint();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 seat_;
::google::protobuf::int32 time_;
::google::protobuf::int32 outcardtime_;
::google::protobuf::int32 lastcardtype_;
::google::protobuf::int32 lastpoint_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameTimerPower* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameOperateNotify : public ::google::protobuf::Message {
public:
ProJDDDZGameOperateNotify();
virtual ~ProJDDDZGameOperateNotify();
ProJDDDZGameOperateNotify(const ProJDDDZGameOperateNotify& from);
inline ProJDDDZGameOperateNotify& operator=(const ProJDDDZGameOperateNotify& 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 ProJDDDZGameOperateNotify& default_instance();
void Swap(ProJDDDZGameOperateNotify* other);
// implements Message ----------------------------------------------
ProJDDDZGameOperateNotify* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameOperateNotify& from);
void MergeFrom(const ProJDDDZGameOperateNotify& 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 ProJDDDZGameOperateNotify_MSGID MSGID;
static const MSGID ID = ProJDDDZGameOperateNotify_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameOperateNotify_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameOperateNotify_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameOperateNotify_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameOperateNotify_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameOperateNotify_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameOperateNotify_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameOperateNotify_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 resumeSeat = 2;
inline bool has_resumeseat() const;
inline void clear_resumeseat();
static const int kResumeSeatFieldNumber = 2;
inline ::google::protobuf::int32 resumeseat() const;
inline void set_resumeseat(::google::protobuf::int32 value);
// optional int32 ActionMask = 3;
inline bool has_actionmask() const;
inline void clear_actionmask();
static const int kActionMaskFieldNumber = 3;
inline ::google::protobuf::int32 actionmask() const;
inline void set_actionmask(::google::protobuf::int32 value);
// optional int32 ActionCard = 4;
inline bool has_actioncard() const;
inline void clear_actioncard();
static const int kActionCardFieldNumber = 4;
inline ::google::protobuf::int32 actioncard() const;
inline void set_actioncard(::google::protobuf::int32 value);
// optional int32 time = 5;
inline bool has_time() const;
inline void clear_time();
static const int kTimeFieldNumber = 5;
inline ::google::protobuf::int32 time() const;
inline void set_time(::google::protobuf::int32 value);
// optional int32 operateseat = 6;
inline bool has_operateseat() const;
inline void clear_operateseat();
static const int kOperateseatFieldNumber = 6;
inline ::google::protobuf::int32 operateseat() const;
inline void set_operateseat(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameOperateNotify)
private:
inline void set_has_resumeseat();
inline void clear_has_resumeseat();
inline void set_has_actionmask();
inline void clear_has_actionmask();
inline void set_has_actioncard();
inline void clear_has_actioncard();
inline void set_has_time();
inline void clear_has_time();
inline void set_has_operateseat();
inline void clear_has_operateseat();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 resumeseat_;
::google::protobuf::int32 actionmask_;
::google::protobuf::int32 actioncard_;
::google::protobuf::int32 time_;
::google::protobuf::int32 operateseat_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameOperateNotify* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameOperateResult : public ::google::protobuf::Message {
public:
ProJDDDZGameOperateResult();
virtual ~ProJDDDZGameOperateResult();
ProJDDDZGameOperateResult(const ProJDDDZGameOperateResult& from);
inline ProJDDDZGameOperateResult& operator=(const ProJDDDZGameOperateResult& 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 ProJDDDZGameOperateResult& default_instance();
void Swap(ProJDDDZGameOperateResult* other);
// implements Message ----------------------------------------------
ProJDDDZGameOperateResult* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameOperateResult& from);
void MergeFrom(const ProJDDDZGameOperateResult& 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 ProJDDDZGameOperateResult_MSGID MSGID;
static const MSGID ID = ProJDDDZGameOperateResult_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameOperateResult_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameOperateResult_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameOperateResult_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameOperateResult_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameOperateResult_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameOperateResult_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameOperateResult_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 wOperateUser = 2;
inline bool has_woperateuser() const;
inline void clear_woperateuser();
static const int kWOperateUserFieldNumber = 2;
inline ::google::protobuf::int32 woperateuser() const;
inline void set_woperateuser(::google::protobuf::int32 value);
// optional int32 wProvideUser = 3;
inline bool has_wprovideuser() const;
inline void clear_wprovideuser();
static const int kWProvideUserFieldNumber = 3;
inline ::google::protobuf::int32 wprovideuser() const;
inline void set_wprovideuser(::google::protobuf::int32 value);
// optional int32 wOperateCode = 4;
inline bool has_woperatecode() const;
inline void clear_woperatecode();
static const int kWOperateCodeFieldNumber = 4;
inline ::google::protobuf::int32 woperatecode() const;
inline void set_woperatecode(::google::protobuf::int32 value);
// optional int32 cbOperateCard = 5;
inline bool has_cboperatecard() const;
inline void clear_cboperatecard();
static const int kCbOperateCardFieldNumber = 5;
inline ::google::protobuf::int32 cboperatecard() const;
inline void set_cboperatecard(::google::protobuf::int32 value);
// repeated int32 handmahs = 6;
inline int handmahs_size() const;
inline void clear_handmahs();
static const int kHandmahsFieldNumber = 6;
inline ::google::protobuf::int32 handmahs(int index) const;
inline void set_handmahs(int index, ::google::protobuf::int32 value);
inline void add_handmahs(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
handmahs() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_handmahs();
// optional int32 handcount = 7;
inline bool has_handcount() const;
inline void clear_handcount();
static const int kHandcountFieldNumber = 7;
inline ::google::protobuf::int32 handcount() const;
inline void set_handcount(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameOperateResult)
private:
inline void set_has_woperateuser();
inline void clear_has_woperateuser();
inline void set_has_wprovideuser();
inline void clear_has_wprovideuser();
inline void set_has_woperatecode();
inline void clear_has_woperatecode();
inline void set_has_cboperatecard();
inline void clear_has_cboperatecard();
inline void set_has_handcount();
inline void clear_has_handcount();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 woperateuser_;
::google::protobuf::int32 wprovideuser_;
::google::protobuf::int32 woperatecode_;
::google::protobuf::int32 cboperatecard_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > handmahs_;
::google::protobuf::int32 handcount_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameOperateResult* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameOperateRequest : public ::google::protobuf::Message {
public:
ProJDDDZGameOperateRequest();
virtual ~ProJDDDZGameOperateRequest();
ProJDDDZGameOperateRequest(const ProJDDDZGameOperateRequest& from);
inline ProJDDDZGameOperateRequest& operator=(const ProJDDDZGameOperateRequest& 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 ProJDDDZGameOperateRequest& default_instance();
void Swap(ProJDDDZGameOperateRequest* other);
// implements Message ----------------------------------------------
ProJDDDZGameOperateRequest* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameOperateRequest& from);
void MergeFrom(const ProJDDDZGameOperateRequest& 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 ProJDDDZGameOperateRequest_MSGID MSGID;
static const MSGID ID = ProJDDDZGameOperateRequest_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameOperateRequest_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameOperateRequest_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameOperateRequest_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameOperateRequest_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameOperateRequest_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameOperateRequest_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameOperateRequest_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat = 2;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 2;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// optional int32 wOperateCode = 3;
inline bool has_woperatecode() const;
inline void clear_woperatecode();
static const int kWOperateCodeFieldNumber = 3;
inline ::google::protobuf::int32 woperatecode() const;
inline void set_woperatecode(::google::protobuf::int32 value);
// optional int32 cbOperateCard = 4;
inline bool has_cboperatecard() const;
inline void clear_cboperatecard();
static const int kCbOperateCardFieldNumber = 4;
inline ::google::protobuf::int32 cboperatecard() const;
inline void set_cboperatecard(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameOperateRequest)
private:
inline void set_has_seat();
inline void clear_has_seat();
inline void set_has_woperatecode();
inline void clear_has_woperatecode();
inline void set_has_cboperatecard();
inline void clear_has_cboperatecard();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 seat_;
::google::protobuf::int32 woperatecode_;
::google::protobuf::int32 cboperatecard_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameOperateRequest* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameTrust : public ::google::protobuf::Message {
public:
ProJDDDZGameTrust();
virtual ~ProJDDDZGameTrust();
ProJDDDZGameTrust(const ProJDDDZGameTrust& from);
inline ProJDDDZGameTrust& operator=(const ProJDDDZGameTrust& 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 ProJDDDZGameTrust& default_instance();
void Swap(ProJDDDZGameTrust* other);
// implements Message ----------------------------------------------
ProJDDDZGameTrust* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameTrust& from);
void MergeFrom(const ProJDDDZGameTrust& 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 ProJDDDZGameTrust_MSGID MSGID;
static const MSGID ID = ProJDDDZGameTrust_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameTrust_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameTrust_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameTrust_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameTrust_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameTrust_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameTrust_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameTrust_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat = 2;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 2;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// optional bool isTrust = 3;
inline bool has_istrust() const;
inline void clear_istrust();
static const int kIsTrustFieldNumber = 3;
inline bool istrust() const;
inline void set_istrust(bool value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameTrust)
private:
inline void set_has_seat();
inline void clear_has_seat();
inline void set_has_istrust();
inline void clear_has_istrust();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 seat_;
bool istrust_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameTrust* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameOutMahRequest : public ::google::protobuf::Message {
public:
ProJDDDZGameOutMahRequest();
virtual ~ProJDDDZGameOutMahRequest();
ProJDDDZGameOutMahRequest(const ProJDDDZGameOutMahRequest& from);
inline ProJDDDZGameOutMahRequest& operator=(const ProJDDDZGameOutMahRequest& 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 ProJDDDZGameOutMahRequest& default_instance();
void Swap(ProJDDDZGameOutMahRequest* other);
// implements Message ----------------------------------------------
ProJDDDZGameOutMahRequest* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameOutMahRequest& from);
void MergeFrom(const ProJDDDZGameOutMahRequest& 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 ProJDDDZGameOutMahRequest_MSGID MSGID;
static const MSGID ID = ProJDDDZGameOutMahRequest_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameOutMahRequest_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameOutMahRequest_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameOutMahRequest_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameOutMahRequest_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameOutMahRequest_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameOutMahRequest_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameOutMahRequest_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat = 2;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 2;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// repeated int32 outMahs = 3;
inline int outmahs_size() const;
inline void clear_outmahs();
static const int kOutMahsFieldNumber = 3;
inline ::google::protobuf::int32 outmahs(int index) const;
inline void set_outmahs(int index, ::google::protobuf::int32 value);
inline void add_outmahs(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
outmahs() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_outmahs();
// repeated int32 noChangeMahs = 4;
inline int nochangemahs_size() const;
inline void clear_nochangemahs();
static const int kNoChangeMahsFieldNumber = 4;
inline ::google::protobuf::int32 nochangemahs(int index) const;
inline void set_nochangemahs(int index, ::google::protobuf::int32 value);
inline void add_nochangemahs(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
nochangemahs() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_nochangemahs();
// @@protoc_insertion_point(class_scope:ProJDDDZGameOutMahRequest)
private:
inline void set_has_seat();
inline void clear_has_seat();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > outmahs_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > nochangemahs_;
::google::protobuf::int32 seat_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameOutMahRequest* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameCatchCard : public ::google::protobuf::Message {
public:
ProJDDDZGameCatchCard();
virtual ~ProJDDDZGameCatchCard();
ProJDDDZGameCatchCard(const ProJDDDZGameCatchCard& from);
inline ProJDDDZGameCatchCard& operator=(const ProJDDDZGameCatchCard& 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 ProJDDDZGameCatchCard& default_instance();
void Swap(ProJDDDZGameCatchCard* other);
// implements Message ----------------------------------------------
ProJDDDZGameCatchCard* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameCatchCard& from);
void MergeFrom(const ProJDDDZGameCatchCard& 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 ProJDDDZGameCatchCard_MSGID MSGID;
static const MSGID ID = ProJDDDZGameCatchCard_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameCatchCard_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameCatchCard_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameCatchCard_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameCatchCard_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameCatchCard_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameCatchCard_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameCatchCard_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat = 2;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 2;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// optional int32 cbCardData = 3;
inline bool has_cbcarddata() const;
inline void clear_cbcarddata();
static const int kCbCardDataFieldNumber = 3;
inline ::google::protobuf::int32 cbcarddata() const;
inline void set_cbcarddata(::google::protobuf::int32 value);
// optional int32 wActionMask = 4;
inline bool has_wactionmask() const;
inline void clear_wactionmask();
static const int kWActionMaskFieldNumber = 4;
inline ::google::protobuf::int32 wactionmask() const;
inline void set_wactionmask(::google::protobuf::int32 value);
// optional bool cbIsNotGang = 5;
inline bool has_cbisnotgang() const;
inline void clear_cbisnotgang();
static const int kCbIsNotGangFieldNumber = 5;
inline bool cbisnotgang() const;
inline void set_cbisnotgang(bool value);
// optional int32 cbLeftCount = 6;
inline bool has_cbleftcount() const;
inline void clear_cbleftcount();
static const int kCbLeftCountFieldNumber = 6;
inline ::google::protobuf::int32 cbleftcount() const;
inline void set_cbleftcount(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameCatchCard)
private:
inline void set_has_seat();
inline void clear_has_seat();
inline void set_has_cbcarddata();
inline void clear_has_cbcarddata();
inline void set_has_wactionmask();
inline void clear_has_wactionmask();
inline void set_has_cbisnotgang();
inline void clear_has_cbisnotgang();
inline void set_has_cbleftcount();
inline void clear_has_cbleftcount();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 seat_;
::google::protobuf::int32 cbcarddata_;
::google::protobuf::int32 wactionmask_;
bool cbisnotgang_;
::google::protobuf::int32 cbleftcount_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameCatchCard* default_instance_;
};
// -------------------------------------------------------------------
class JDDDZMahList : public ::google::protobuf::Message {
public:
JDDDZMahList();
virtual ~JDDDZMahList();
JDDDZMahList(const JDDDZMahList& from);
inline JDDDZMahList& operator=(const JDDDZMahList& 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 JDDDZMahList& default_instance();
void Swap(JDDDZMahList* other);
// implements Message ----------------------------------------------
JDDDZMahList* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const JDDDZMahList& from);
void MergeFrom(const JDDDZMahList& 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 ----------------------------------------------------
// accessors -------------------------------------------------------
// repeated int32 Mahs = 1;
inline int mahs_size() const;
inline void clear_mahs();
static const int kMahsFieldNumber = 1;
inline ::google::protobuf::int32 mahs(int index) const;
inline void set_mahs(int index, ::google::protobuf::int32 value);
inline void add_mahs(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
mahs() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_mahs();
// @@protoc_insertion_point(class_scope:JDDDZMahList)
private:
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > mahs_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static JDDDZMahList* default_instance_;
};
// -------------------------------------------------------------------
class JDDDZScoreList : public ::google::protobuf::Message {
public:
JDDDZScoreList();
virtual ~JDDDZScoreList();
JDDDZScoreList(const JDDDZScoreList& from);
inline JDDDZScoreList& operator=(const JDDDZScoreList& 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 JDDDZScoreList& default_instance();
void Swap(JDDDZScoreList* other);
// implements Message ----------------------------------------------
JDDDZScoreList* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const JDDDZScoreList& from);
void MergeFrom(const JDDDZScoreList& 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 ----------------------------------------------------
// accessors -------------------------------------------------------
// repeated int32 roundScore = 1;
inline int roundscore_size() const;
inline void clear_roundscore();
static const int kRoundScoreFieldNumber = 1;
inline ::google::protobuf::int32 roundscore(int index) const;
inline void set_roundscore(int index, ::google::protobuf::int32 value);
inline void add_roundscore(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
roundscore() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_roundscore();
// @@protoc_insertion_point(class_scope:JDDDZScoreList)
private:
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > roundscore_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static JDDDZScoreList* default_instance_;
};
// -------------------------------------------------------------------
class JDDDZAwardList : public ::google::protobuf::Message {
public:
JDDDZAwardList();
virtual ~JDDDZAwardList();
JDDDZAwardList(const JDDDZAwardList& from);
inline JDDDZAwardList& operator=(const JDDDZAwardList& 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 JDDDZAwardList& default_instance();
void Swap(JDDDZAwardList* other);
// implements Message ----------------------------------------------
JDDDZAwardList* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const JDDDZAwardList& from);
void MergeFrom(const JDDDZAwardList& 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 ----------------------------------------------------
// accessors -------------------------------------------------------
// optional int32 seat = 1;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 1;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// repeated int32 CardsData = 2;
inline int cardsdata_size() const;
inline void clear_cardsdata();
static const int kCardsDataFieldNumber = 2;
inline ::google::protobuf::int32 cardsdata(int index) const;
inline void set_cardsdata(int index, ::google::protobuf::int32 value);
inline void add_cardsdata(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
cardsdata() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_cardsdata();
// optional int32 awardScore = 3;
inline bool has_awardscore() const;
inline void clear_awardscore();
static const int kAwardScoreFieldNumber = 3;
inline ::google::protobuf::int32 awardscore() const;
inline void set_awardscore(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:JDDDZAwardList)
private:
inline void set_has_seat();
inline void clear_has_seat();
inline void set_has_awardscore();
inline void clear_has_awardscore();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > cardsdata_;
::google::protobuf::int32 seat_;
::google::protobuf::int32 awardscore_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static JDDDZAwardList* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameEnd : public ::google::protobuf::Message {
public:
ProJDDDZGameEnd();
virtual ~ProJDDDZGameEnd();
ProJDDDZGameEnd(const ProJDDDZGameEnd& from);
inline ProJDDDZGameEnd& operator=(const ProJDDDZGameEnd& 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 ProJDDDZGameEnd& default_instance();
void Swap(ProJDDDZGameEnd* other);
// implements Message ----------------------------------------------
ProJDDDZGameEnd* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameEnd& from);
void MergeFrom(const ProJDDDZGameEnd& 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 ProJDDDZGameEnd_MSGID MSGID;
static const MSGID ID = ProJDDDZGameEnd_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameEnd_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameEnd_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameEnd_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameEnd_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameEnd_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameEnd_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameEnd_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 lGameTax = 2;
inline bool has_lgametax() const;
inline void clear_lgametax();
static const int kLGameTaxFieldNumber = 2;
inline ::google::protobuf::int32 lgametax() const;
inline void set_lgametax(::google::protobuf::int32 value);
// repeated int32 cbChongGuang = 3;
inline int cbchongguang_size() const;
inline void clear_cbchongguang();
static const int kCbChongGuangFieldNumber = 3;
inline ::google::protobuf::int32 cbchongguang(int index) const;
inline void set_cbchongguang(int index, ::google::protobuf::int32 value);
inline void add_cbchongguang(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
cbchongguang() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_cbchongguang();
// repeated int32 cbBaWangKing = 4;
inline int cbbawangking_size() const;
inline void clear_cbbawangking();
static const int kCbBaWangKingFieldNumber = 4;
inline ::google::protobuf::int32 cbbawangking(int index) const;
inline void set_cbbawangking(int index, ::google::protobuf::int32 value);
inline void add_cbbawangking(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
cbbawangking() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_cbbawangking();
// optional int32 wProvideUser = 5;
inline bool has_wprovideuser() const;
inline void clear_wprovideuser();
static const int kWProvideUserFieldNumber = 5;
inline ::google::protobuf::int32 wprovideuser() const;
inline void set_wprovideuser(::google::protobuf::int32 value);
// optional int32 cbChiHuCard = 6;
inline bool has_cbchihucard() const;
inline void clear_cbchihucard();
static const int kCbChiHuCardFieldNumber = 6;
inline ::google::protobuf::int32 cbchihucard() const;
inline void set_cbchihucard(::google::protobuf::int32 value);
// repeated int32 dwChiHuKind = 7;
inline int dwchihukind_size() const;
inline void clear_dwchihukind();
static const int kDwChiHuKindFieldNumber = 7;
inline ::google::protobuf::int32 dwchihukind(int index) const;
inline void set_dwchihukind(int index, ::google::protobuf::int32 value);
inline void add_dwchihukind(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
dwchihukind() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_dwchihukind();
// repeated int32 dwChiHuRight = 8;
inline int dwchihuright_size() const;
inline void clear_dwchihuright();
static const int kDwChiHuRightFieldNumber = 8;
inline ::google::protobuf::int32 dwchihuright(int index) const;
inline void set_dwchihuright(int index, ::google::protobuf::int32 value);
inline void add_dwchihuright(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
dwchihuright() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_dwchihuright();
// repeated int32 lTotaslGameScore = 9;
inline int ltotaslgamescore_size() const;
inline void clear_ltotaslgamescore();
static const int kLTotaslGameScoreFieldNumber = 9;
inline ::google::protobuf::int32 ltotaslgamescore(int index) const;
inline void set_ltotaslgamescore(int index, ::google::protobuf::int32 value);
inline void add_ltotaslgamescore(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ltotaslgamescore() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_ltotaslgamescore();
// repeated int32 lCurrentGameScore = 10;
inline int lcurrentgamescore_size() const;
inline void clear_lcurrentgamescore();
static const int kLCurrentGameScoreFieldNumber = 10;
inline ::google::protobuf::int32 lcurrentgamescore(int index) const;
inline void set_lcurrentgamescore(int index, ::google::protobuf::int32 value);
inline void add_lcurrentgamescore(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
lcurrentgamescore() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_lcurrentgamescore();
// repeated int32 lCurrentPointScore = 11;
inline int lcurrentpointscore_size() const;
inline void clear_lcurrentpointscore();
static const int kLCurrentPointScoreFieldNumber = 11;
inline ::google::protobuf::int32 lcurrentpointscore(int index) const;
inline void set_lcurrentpointscore(int index, ::google::protobuf::int32 value);
inline void add_lcurrentpointscore(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
lcurrentpointscore() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_lcurrentpointscore();
// repeated int32 lAttachScore = 12;
inline int lattachscore_size() const;
inline void clear_lattachscore();
static const int kLAttachScoreFieldNumber = 12;
inline ::google::protobuf::int32 lattachscore(int index) const;
inline void set_lattachscore(int index, ::google::protobuf::int32 value);
inline void add_lattachscore(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
lattachscore() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_lattachscore();
// repeated .JDDDZMahList cbHandCardData = 13;
inline int cbhandcarddata_size() const;
inline void clear_cbhandcarddata();
static const int kCbHandCardDataFieldNumber = 13;
inline const ::JDDDZMahList& cbhandcarddata(int index) const;
inline ::JDDDZMahList* mutable_cbhandcarddata(int index);
inline ::JDDDZMahList* add_cbhandcarddata();
inline const ::google::protobuf::RepeatedPtrField< ::JDDDZMahList >&
cbhandcarddata() const;
inline ::google::protobuf::RepeatedPtrField< ::JDDDZMahList >*
mutable_cbhandcarddata();
// repeated .JDDDZAwardList cbAwardCardData = 14;
inline int cbawardcarddata_size() const;
inline void clear_cbawardcarddata();
static const int kCbAwardCardDataFieldNumber = 14;
inline const ::JDDDZAwardList& cbawardcarddata(int index) const;
inline ::JDDDZAwardList* mutable_cbawardcarddata(int index);
inline ::JDDDZAwardList* add_cbawardcarddata();
inline const ::google::protobuf::RepeatedPtrField< ::JDDDZAwardList >&
cbawardcarddata() const;
inline ::google::protobuf::RepeatedPtrField< ::JDDDZAwardList >*
mutable_cbawardcarddata();
// repeated int32 lOnlyWinScore = 15;
inline int lonlywinscore_size() const;
inline void clear_lonlywinscore();
static const int kLOnlyWinScoreFieldNumber = 15;
inline ::google::protobuf::int32 lonlywinscore(int index) const;
inline void set_lonlywinscore(int index, ::google::protobuf::int32 value);
inline void add_lonlywinscore(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
lonlywinscore() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_lonlywinscore();
// optional bool bRoundEnd = 16;
inline bool has_broundend() const;
inline void clear_broundend();
static const int kBRoundEndFieldNumber = 16;
inline bool broundend() const;
inline void set_broundend(bool value);
// repeated int32 lHuiTouScore = 17;
inline int lhuitouscore_size() const;
inline void clear_lhuitouscore();
static const int kLHuiTouScoreFieldNumber = 17;
inline ::google::protobuf::int32 lhuitouscore(int index) const;
inline void set_lhuitouscore(int index, ::google::protobuf::int32 value);
inline void add_lhuitouscore(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
lhuitouscore() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_lhuitouscore();
// optional bool bZhuangWin = 18;
inline bool has_bzhuangwin() const;
inline void clear_bzhuangwin();
static const int kBZhuangWinFieldNumber = 18;
inline bool bzhuangwin() const;
inline void set_bzhuangwin(bool value);
// repeated int32 cbJiangMaCardData = 19;
inline int cbjiangmacarddata_size() const;
inline void clear_cbjiangmacarddata();
static const int kCbJiangMaCardDataFieldNumber = 19;
inline ::google::protobuf::int32 cbjiangmacarddata(int index) const;
inline void set_cbjiangmacarddata(int index, ::google::protobuf::int32 value);
inline void add_cbjiangmacarddata(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
cbjiangmacarddata() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_cbjiangmacarddata();
// repeated .JDDDZScoreList detailedScores = 20;
inline int detailedscores_size() const;
inline void clear_detailedscores();
static const int kDetailedScoresFieldNumber = 20;
inline const ::JDDDZScoreList& detailedscores(int index) const;
inline ::JDDDZScoreList* mutable_detailedscores(int index);
inline ::JDDDZScoreList* add_detailedscores();
inline const ::google::protobuf::RepeatedPtrField< ::JDDDZScoreList >&
detailedscores() const;
inline ::google::protobuf::RepeatedPtrField< ::JDDDZScoreList >*
mutable_detailedscores();
// @@protoc_insertion_point(class_scope:ProJDDDZGameEnd)
private:
inline void set_has_lgametax();
inline void clear_has_lgametax();
inline void set_has_wprovideuser();
inline void clear_has_wprovideuser();
inline void set_has_cbchihucard();
inline void clear_has_cbchihucard();
inline void set_has_broundend();
inline void clear_has_broundend();
inline void set_has_bzhuangwin();
inline void clear_has_bzhuangwin();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > cbchongguang_;
::google::protobuf::int32 lgametax_;
::google::protobuf::int32 wprovideuser_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > cbbawangking_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > dwchihukind_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > dwchihuright_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > ltotaslgamescore_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > lcurrentgamescore_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > lcurrentpointscore_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > lattachscore_;
::google::protobuf::RepeatedPtrField< ::JDDDZMahList > cbhandcarddata_;
::google::protobuf::int32 cbchihucard_;
bool broundend_;
bool bzhuangwin_;
::google::protobuf::RepeatedPtrField< ::JDDDZAwardList > cbawardcarddata_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > lonlywinscore_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > lhuitouscore_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > cbjiangmacarddata_;
::google::protobuf::RepeatedPtrField< ::JDDDZScoreList > detailedscores_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(19 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameEnd* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameQuickSoundRequest : public ::google::protobuf::Message {
public:
ProJDDDZGameQuickSoundRequest();
virtual ~ProJDDDZGameQuickSoundRequest();
ProJDDDZGameQuickSoundRequest(const ProJDDDZGameQuickSoundRequest& from);
inline ProJDDDZGameQuickSoundRequest& operator=(const ProJDDDZGameQuickSoundRequest& 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 ProJDDDZGameQuickSoundRequest& default_instance();
void Swap(ProJDDDZGameQuickSoundRequest* other);
// implements Message ----------------------------------------------
ProJDDDZGameQuickSoundRequest* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameQuickSoundRequest& from);
void MergeFrom(const ProJDDDZGameQuickSoundRequest& 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 ProJDDDZGameQuickSoundRequest_MSGID MSGID;
static const MSGID ID = ProJDDDZGameQuickSoundRequest_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameQuickSoundRequest_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameQuickSoundRequest_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameQuickSoundRequest_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameQuickSoundRequest_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameQuickSoundRequest_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameQuickSoundRequest_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameQuickSoundRequest_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 desk_id = 2;
inline bool has_desk_id() const;
inline void clear_desk_id();
static const int kDeskIdFieldNumber = 2;
inline ::google::protobuf::int32 desk_id() const;
inline void set_desk_id(::google::protobuf::int32 value);
// optional int32 seat_id = 3;
inline bool has_seat_id() const;
inline void clear_seat_id();
static const int kSeatIdFieldNumber = 3;
inline ::google::protobuf::int32 seat_id() const;
inline void set_seat_id(::google::protobuf::int32 value);
// optional int32 sound_id = 4;
inline bool has_sound_id() const;
inline void clear_sound_id();
static const int kSoundIdFieldNumber = 4;
inline ::google::protobuf::int32 sound_id() const;
inline void set_sound_id(::google::protobuf::int32 value);
// optional bytes text = 5;
inline bool has_text() const;
inline void clear_text();
static const int kTextFieldNumber = 5;
inline const ::std::string& text() const;
inline void set_text(const ::std::string& value);
inline void set_text(const char* value);
inline void set_text(const void* value, size_t size);
inline ::std::string* mutable_text();
inline ::std::string* release_text();
inline void set_allocated_text(::std::string* text);
// @@protoc_insertion_point(class_scope:ProJDDDZGameQuickSoundRequest)
private:
inline void set_has_desk_id();
inline void clear_has_desk_id();
inline void set_has_seat_id();
inline void clear_has_seat_id();
inline void set_has_sound_id();
inline void clear_has_sound_id();
inline void set_has_text();
inline void clear_has_text();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 desk_id_;
::google::protobuf::int32 seat_id_;
::std::string* text_;
::google::protobuf::int32 sound_id_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameQuickSoundRequest* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameQuickSoundResponse : public ::google::protobuf::Message {
public:
ProJDDDZGameQuickSoundResponse();
virtual ~ProJDDDZGameQuickSoundResponse();
ProJDDDZGameQuickSoundResponse(const ProJDDDZGameQuickSoundResponse& from);
inline ProJDDDZGameQuickSoundResponse& operator=(const ProJDDDZGameQuickSoundResponse& 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 ProJDDDZGameQuickSoundResponse& default_instance();
void Swap(ProJDDDZGameQuickSoundResponse* other);
// implements Message ----------------------------------------------
ProJDDDZGameQuickSoundResponse* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameQuickSoundResponse& from);
void MergeFrom(const ProJDDDZGameQuickSoundResponse& 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 ProJDDDZGameQuickSoundResponse_MSGID MSGID;
static const MSGID ID = ProJDDDZGameQuickSoundResponse_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameQuickSoundResponse_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameQuickSoundResponse_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameQuickSoundResponse_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameQuickSoundResponse_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameQuickSoundResponse_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameQuickSoundResponse_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameQuickSoundResponse_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 desk_id = 2;
inline bool has_desk_id() const;
inline void clear_desk_id();
static const int kDeskIdFieldNumber = 2;
inline ::google::protobuf::int32 desk_id() const;
inline void set_desk_id(::google::protobuf::int32 value);
// optional int32 seat_id = 3;
inline bool has_seat_id() const;
inline void clear_seat_id();
static const int kSeatIdFieldNumber = 3;
inline ::google::protobuf::int32 seat_id() const;
inline void set_seat_id(::google::protobuf::int32 value);
// optional int32 sound_id = 4;
inline bool has_sound_id() const;
inline void clear_sound_id();
static const int kSoundIdFieldNumber = 4;
inline ::google::protobuf::int32 sound_id() const;
inline void set_sound_id(::google::protobuf::int32 value);
// optional bytes text = 5;
inline bool has_text() const;
inline void clear_text();
static const int kTextFieldNumber = 5;
inline const ::std::string& text() const;
inline void set_text(const ::std::string& value);
inline void set_text(const char* value);
inline void set_text(const void* value, size_t size);
inline ::std::string* mutable_text();
inline ::std::string* release_text();
inline void set_allocated_text(::std::string* text);
// @@protoc_insertion_point(class_scope:ProJDDDZGameQuickSoundResponse)
private:
inline void set_has_desk_id();
inline void clear_has_desk_id();
inline void set_has_seat_id();
inline void clear_has_seat_id();
inline void set_has_sound_id();
inline void clear_has_sound_id();
inline void set_has_text();
inline void clear_has_text();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 desk_id_;
::google::protobuf::int32 seat_id_;
::std::string* text_;
::google::protobuf::int32 sound_id_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameQuickSoundResponse* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameSendDiscardMahs : public ::google::protobuf::Message {
public:
ProJDDDZGameSendDiscardMahs();
virtual ~ProJDDDZGameSendDiscardMahs();
ProJDDDZGameSendDiscardMahs(const ProJDDDZGameSendDiscardMahs& from);
inline ProJDDDZGameSendDiscardMahs& operator=(const ProJDDDZGameSendDiscardMahs& 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 ProJDDDZGameSendDiscardMahs& default_instance();
void Swap(ProJDDDZGameSendDiscardMahs* other);
// implements Message ----------------------------------------------
ProJDDDZGameSendDiscardMahs* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameSendDiscardMahs& from);
void MergeFrom(const ProJDDDZGameSendDiscardMahs& 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 ProJDDDZGameSendDiscardMahs_MSGID MSGID;
static const MSGID ID = ProJDDDZGameSendDiscardMahs_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameSendDiscardMahs_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameSendDiscardMahs_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameSendDiscardMahs_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameSendDiscardMahs_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameSendDiscardMahs_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameSendDiscardMahs_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameSendDiscardMahs_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat_id = 2;
inline bool has_seat_id() const;
inline void clear_seat_id();
static const int kSeatIdFieldNumber = 2;
inline ::google::protobuf::int32 seat_id() const;
inline void set_seat_id(::google::protobuf::int32 value);
// repeated .JDDDZMahList cbCardData = 3;
inline int cbcarddata_size() const;
inline void clear_cbcarddata();
static const int kCbCardDataFieldNumber = 3;
inline const ::JDDDZMahList& cbcarddata(int index) const;
inline ::JDDDZMahList* mutable_cbcarddata(int index);
inline ::JDDDZMahList* add_cbcarddata();
inline const ::google::protobuf::RepeatedPtrField< ::JDDDZMahList >&
cbcarddata() const;
inline ::google::protobuf::RepeatedPtrField< ::JDDDZMahList >*
mutable_cbcarddata();
// optional int32 deskCount = 4;
inline bool has_deskcount() const;
inline void clear_deskcount();
static const int kDeskCountFieldNumber = 4;
inline ::google::protobuf::int32 deskcount() const;
inline void set_deskcount(::google::protobuf::int32 value);
// repeated int32 outCardCount = 5;
inline int outcardcount_size() const;
inline void clear_outcardcount();
static const int kOutCardCountFieldNumber = 5;
inline ::google::protobuf::int32 outcardcount(int index) const;
inline void set_outcardcount(int index, ::google::protobuf::int32 value);
inline void add_outcardcount(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
outcardcount() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_outcardcount();
// @@protoc_insertion_point(class_scope:ProJDDDZGameSendDiscardMahs)
private:
inline void set_has_seat_id();
inline void clear_has_seat_id();
inline void set_has_deskcount();
inline void clear_has_deskcount();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::RepeatedPtrField< ::JDDDZMahList > cbcarddata_;
::google::protobuf::int32 seat_id_;
::google::protobuf::int32 deskcount_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > outcardcount_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameSendDiscardMahs* default_instance_;
};
// -------------------------------------------------------------------
class JDDDZWeaveItem : public ::google::protobuf::Message {
public:
JDDDZWeaveItem();
virtual ~JDDDZWeaveItem();
JDDDZWeaveItem(const JDDDZWeaveItem& from);
inline JDDDZWeaveItem& operator=(const JDDDZWeaveItem& 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 JDDDZWeaveItem& default_instance();
void Swap(JDDDZWeaveItem* other);
// implements Message ----------------------------------------------
JDDDZWeaveItem* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const JDDDZWeaveItem& from);
void MergeFrom(const JDDDZWeaveItem& 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 ----------------------------------------------------
// accessors -------------------------------------------------------
// optional int32 weaveKind = 1;
inline bool has_weavekind() const;
inline void clear_weavekind();
static const int kWeaveKindFieldNumber = 1;
inline ::google::protobuf::int32 weavekind() const;
inline void set_weavekind(::google::protobuf::int32 value);
// optional int32 centercard = 2;
inline bool has_centercard() const;
inline void clear_centercard();
static const int kCentercardFieldNumber = 2;
inline ::google::protobuf::int32 centercard() const;
inline void set_centercard(::google::protobuf::int32 value);
// optional int32 provideUser = 3;
inline bool has_provideuser() const;
inline void clear_provideuser();
static const int kProvideUserFieldNumber = 3;
inline ::google::protobuf::int32 provideuser() const;
inline void set_provideuser(::google::protobuf::int32 value);
// optional int32 cardsize = 4;
inline bool has_cardsize() const;
inline void clear_cardsize();
static const int kCardsizeFieldNumber = 4;
inline ::google::protobuf::int32 cardsize() const;
inline void set_cardsize(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:JDDDZWeaveItem)
private:
inline void set_has_weavekind();
inline void clear_has_weavekind();
inline void set_has_centercard();
inline void clear_has_centercard();
inline void set_has_provideuser();
inline void clear_has_provideuser();
inline void set_has_cardsize();
inline void clear_has_cardsize();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 weavekind_;
::google::protobuf::int32 centercard_;
::google::protobuf::int32 provideuser_;
::google::protobuf::int32 cardsize_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static JDDDZWeaveItem* default_instance_;
};
// -------------------------------------------------------------------
class JDDDZWeaveItems : public ::google::protobuf::Message {
public:
JDDDZWeaveItems();
virtual ~JDDDZWeaveItems();
JDDDZWeaveItems(const JDDDZWeaveItems& from);
inline JDDDZWeaveItems& operator=(const JDDDZWeaveItems& 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 JDDDZWeaveItems& default_instance();
void Swap(JDDDZWeaveItems* other);
// implements Message ----------------------------------------------
JDDDZWeaveItems* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const JDDDZWeaveItems& from);
void MergeFrom(const JDDDZWeaveItems& 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 ----------------------------------------------------
// accessors -------------------------------------------------------
// repeated .JDDDZWeaveItem items = 1;
inline int items_size() const;
inline void clear_items();
static const int kItemsFieldNumber = 1;
inline const ::JDDDZWeaveItem& items(int index) const;
inline ::JDDDZWeaveItem* mutable_items(int index);
inline ::JDDDZWeaveItem* add_items();
inline const ::google::protobuf::RepeatedPtrField< ::JDDDZWeaveItem >&
items() const;
inline ::google::protobuf::RepeatedPtrField< ::JDDDZWeaveItem >*
mutable_items();
// @@protoc_insertion_point(class_scope:JDDDZWeaveItems)
private:
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::RepeatedPtrField< ::JDDDZWeaveItem > items_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static JDDDZWeaveItems* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameSendActionMahs : public ::google::protobuf::Message {
public:
ProJDDDZGameSendActionMahs();
virtual ~ProJDDDZGameSendActionMahs();
ProJDDDZGameSendActionMahs(const ProJDDDZGameSendActionMahs& from);
inline ProJDDDZGameSendActionMahs& operator=(const ProJDDDZGameSendActionMahs& 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 ProJDDDZGameSendActionMahs& default_instance();
void Swap(ProJDDDZGameSendActionMahs* other);
// implements Message ----------------------------------------------
ProJDDDZGameSendActionMahs* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameSendActionMahs& from);
void MergeFrom(const ProJDDDZGameSendActionMahs& 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 ProJDDDZGameSendActionMahs_MSGID MSGID;
static const MSGID ID = ProJDDDZGameSendActionMahs_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameSendActionMahs_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameSendActionMahs_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameSendActionMahs_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameSendActionMahs_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameSendActionMahs_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameSendActionMahs_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameSendActionMahs_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat_id = 2;
inline bool has_seat_id() const;
inline void clear_seat_id();
static const int kSeatIdFieldNumber = 2;
inline ::google::protobuf::int32 seat_id() const;
inline void set_seat_id(::google::protobuf::int32 value);
// repeated .JDDDZWeaveItems weaves = 3;
inline int weaves_size() const;
inline void clear_weaves();
static const int kWeavesFieldNumber = 3;
inline const ::JDDDZWeaveItems& weaves(int index) const;
inline ::JDDDZWeaveItems* mutable_weaves(int index);
inline ::JDDDZWeaveItems* add_weaves();
inline const ::google::protobuf::RepeatedPtrField< ::JDDDZWeaveItems >&
weaves() const;
inline ::google::protobuf::RepeatedPtrField< ::JDDDZWeaveItems >*
mutable_weaves();
// @@protoc_insertion_point(class_scope:ProJDDDZGameSendActionMahs)
private:
inline void set_has_seat_id();
inline void clear_has_seat_id();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::RepeatedPtrField< ::JDDDZWeaveItems > weaves_;
::google::protobuf::int32 seat_id_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameSendActionMahs* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameBrokenRequest : public ::google::protobuf::Message {
public:
ProJDDDZGameBrokenRequest();
virtual ~ProJDDDZGameBrokenRequest();
ProJDDDZGameBrokenRequest(const ProJDDDZGameBrokenRequest& from);
inline ProJDDDZGameBrokenRequest& operator=(const ProJDDDZGameBrokenRequest& 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 ProJDDDZGameBrokenRequest& default_instance();
void Swap(ProJDDDZGameBrokenRequest* other);
// implements Message ----------------------------------------------
ProJDDDZGameBrokenRequest* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameBrokenRequest& from);
void MergeFrom(const ProJDDDZGameBrokenRequest& 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 ProJDDDZGameBrokenRequest_MSGID MSGID;
static const MSGID ID = ProJDDDZGameBrokenRequest_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameBrokenRequest_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameBrokenRequest_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameBrokenRequest_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameBrokenRequest_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameBrokenRequest_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameBrokenRequest_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameBrokenRequest_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat_id = 2;
inline bool has_seat_id() const;
inline void clear_seat_id();
static const int kSeatIdFieldNumber = 2;
inline ::google::protobuf::int32 seat_id() const;
inline void set_seat_id(::google::protobuf::int32 value);
// optional .JDDDZBROKEN_TYPE type = 3;
inline bool has_type() const;
inline void clear_type();
static const int kTypeFieldNumber = 3;
inline ::JDDDZBROKEN_TYPE type() const;
inline void set_type(::JDDDZBROKEN_TYPE value);
// optional int32 time = 4;
inline bool has_time() const;
inline void clear_time();
static const int kTimeFieldNumber = 4;
inline ::google::protobuf::int32 time() const;
inline void set_time(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameBrokenRequest)
private:
inline void set_has_seat_id();
inline void clear_has_seat_id();
inline void set_has_type();
inline void clear_has_type();
inline void set_has_time();
inline void clear_has_time();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 seat_id_;
int type_;
::google::protobuf::int32 time_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameBrokenRequest* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameBrokenOperate : public ::google::protobuf::Message {
public:
ProJDDDZGameBrokenOperate();
virtual ~ProJDDDZGameBrokenOperate();
ProJDDDZGameBrokenOperate(const ProJDDDZGameBrokenOperate& from);
inline ProJDDDZGameBrokenOperate& operator=(const ProJDDDZGameBrokenOperate& 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 ProJDDDZGameBrokenOperate& default_instance();
void Swap(ProJDDDZGameBrokenOperate* other);
// implements Message ----------------------------------------------
ProJDDDZGameBrokenOperate* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameBrokenOperate& from);
void MergeFrom(const ProJDDDZGameBrokenOperate& 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 ProJDDDZGameBrokenOperate_MSGID MSGID;
static const MSGID ID = ProJDDDZGameBrokenOperate_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameBrokenOperate_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameBrokenOperate_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameBrokenOperate_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameBrokenOperate_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameBrokenOperate_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameBrokenOperate_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameBrokenOperate_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat_id = 2;
inline bool has_seat_id() const;
inline void clear_seat_id();
static const int kSeatIdFieldNumber = 2;
inline ::google::protobuf::int32 seat_id() const;
inline void set_seat_id(::google::protobuf::int32 value);
// optional .JDDDZBROKEN_OPERATE result = 3 [default = JDDDZ_BO_DISAGREE];
inline bool has_result() const;
inline void clear_result();
static const int kResultFieldNumber = 3;
inline ::JDDDZBROKEN_OPERATE result() const;
inline void set_result(::JDDDZBROKEN_OPERATE value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameBrokenOperate)
private:
inline void set_has_seat_id();
inline void clear_has_seat_id();
inline void set_has_result();
inline void clear_has_result();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 seat_id_;
int result_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameBrokenOperate* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameBrokenNotify : public ::google::protobuf::Message {
public:
ProJDDDZGameBrokenNotify();
virtual ~ProJDDDZGameBrokenNotify();
ProJDDDZGameBrokenNotify(const ProJDDDZGameBrokenNotify& from);
inline ProJDDDZGameBrokenNotify& operator=(const ProJDDDZGameBrokenNotify& 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 ProJDDDZGameBrokenNotify& default_instance();
void Swap(ProJDDDZGameBrokenNotify* other);
// implements Message ----------------------------------------------
ProJDDDZGameBrokenNotify* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameBrokenNotify& from);
void MergeFrom(const ProJDDDZGameBrokenNotify& 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 ProJDDDZGameBrokenNotify_MSGID MSGID;
static const MSGID ID = ProJDDDZGameBrokenNotify_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameBrokenNotify_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameBrokenNotify_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameBrokenNotify_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameBrokenNotify_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameBrokenNotify_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameBrokenNotify_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameBrokenNotify_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat_id = 2;
inline bool has_seat_id() const;
inline void clear_seat_id();
static const int kSeatIdFieldNumber = 2;
inline ::google::protobuf::int32 seat_id() const;
inline void set_seat_id(::google::protobuf::int32 value);
// optional .JDDDZBROKEN_CODE operate_code = 3 [default = JDDDZ_BC_SUCCESS];
inline bool has_operate_code() const;
inline void clear_operate_code();
static const int kOperateCodeFieldNumber = 3;
inline ::JDDDZBROKEN_CODE operate_code() const;
inline void set_operate_code(::JDDDZBROKEN_CODE value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameBrokenNotify)
private:
inline void set_has_seat_id();
inline void clear_has_seat_id();
inline void set_has_operate_code();
inline void clear_has_operate_code();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 seat_id_;
int operate_code_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameBrokenNotify* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameRuleConfig : public ::google::protobuf::Message {
public:
ProJDDDZGameRuleConfig();
virtual ~ProJDDDZGameRuleConfig();
ProJDDDZGameRuleConfig(const ProJDDDZGameRuleConfig& from);
inline ProJDDDZGameRuleConfig& operator=(const ProJDDDZGameRuleConfig& 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 ProJDDDZGameRuleConfig& default_instance();
void Swap(ProJDDDZGameRuleConfig* other);
// implements Message ----------------------------------------------
ProJDDDZGameRuleConfig* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameRuleConfig& from);
void MergeFrom(const ProJDDDZGameRuleConfig& 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 ProJDDDZGameRuleConfig_MSGID MSGID;
static const MSGID ID = ProJDDDZGameRuleConfig_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameRuleConfig_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameRuleConfig_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameRuleConfig_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameRuleConfig_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameRuleConfig_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameRuleConfig_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameRuleConfig_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 game_round = 1;
inline bool has_game_round() const;
inline void clear_game_round();
static const int kGameRoundFieldNumber = 1;
inline ::google::protobuf::int32 game_round() const;
inline void set_game_round(::google::protobuf::int32 value);
// optional int32 need_card = 2;
inline bool has_need_card() const;
inline void clear_need_card();
static const int kNeedCardFieldNumber = 2;
inline ::google::protobuf::int32 need_card() const;
inline void set_need_card(::google::protobuf::int32 value);
// optional bool have_bottom_king = 3;
inline bool has_have_bottom_king() const;
inline void clear_have_bottom_king();
static const int kHaveBottomKingFieldNumber = 3;
inline bool have_bottom_king() const;
inline void set_have_bottom_king(bool value);
// optional bool have_mai_lei = 4;
inline bool has_have_mai_lei() const;
inline void clear_have_mai_lei();
static const int kHaveMaiLeiFieldNumber = 4;
inline bool have_mai_lei() const;
inline void set_have_mai_lei(bool value);
// optional bool hava_hui_tou = 5;
inline bool has_hava_hui_tou() const;
inline void clear_hava_hui_tou();
static const int kHavaHuiTouFieldNumber = 5;
inline bool hava_hui_tou() const;
inline void set_hava_hui_tou(bool value);
// optional int32 nMasterSeat = 6;
inline bool has_nmasterseat() const;
inline void clear_nmasterseat();
static const int kNMasterSeatFieldNumber = 6;
inline ::google::protobuf::int32 nmasterseat() const;
inline void set_nmasterseat(::google::protobuf::int32 value);
// optional int32 current_game_count = 7;
inline bool has_current_game_count() const;
inline void clear_current_game_count();
static const int kCurrentGameCountFieldNumber = 7;
inline ::google::protobuf::int32 current_game_count() const;
inline void set_current_game_count(::google::protobuf::int32 value);
// optional bool have_jianma = 8;
inline bool has_have_jianma() const;
inline void clear_have_jianma();
static const int kHaveJianmaFieldNumber = 8;
inline bool have_jianma() const;
inline void set_have_jianma(bool value);
// optional int32 nChongguanNum = 9;
inline bool has_nchongguannum() const;
inline void clear_nchongguannum();
static const int kNChongguanNumFieldNumber = 9;
inline ::google::protobuf::int32 nchongguannum() const;
inline void set_nchongguannum(::google::protobuf::int32 value);
// optional bool bbawangfanbei = 10;
inline bool has_bbawangfanbei() const;
inline void clear_bbawangfanbei();
static const int kBbawangfanbeiFieldNumber = 10;
inline bool bbawangfanbei() const;
inline void set_bbawangfanbei(bool value);
// optional int32 nPlayerNum = 11;
inline bool has_nplayernum() const;
inline void clear_nplayernum();
static const int kNPlayerNumFieldNumber = 11;
inline ::google::protobuf::int32 nplayernum() const;
inline void set_nplayernum(::google::protobuf::int32 value);
// optional bytes sRoomNum = 12;
inline bool has_sroomnum() const;
inline void clear_sroomnum();
static const int kSRoomNumFieldNumber = 12;
inline const ::std::string& sroomnum() const;
inline void set_sroomnum(const ::std::string& value);
inline void set_sroomnum(const char* value);
inline void set_sroomnum(const void* value, size_t size);
inline ::std::string* mutable_sroomnum();
inline ::std::string* release_sroomnum();
inline void set_allocated_sroomnum(::std::string* sroomnum);
// optional bytes sPlayTime = 13;
inline bool has_splaytime() const;
inline void clear_splaytime();
static const int kSPlayTimeFieldNumber = 13;
inline const ::std::string& splaytime() const;
inline void set_splaytime(const ::std::string& value);
inline void set_splaytime(const char* value);
inline void set_splaytime(const void* value, size_t size);
inline ::std::string* mutable_splaytime();
inline ::std::string* release_splaytime();
inline void set_allocated_splaytime(::std::string* splaytime);
// optional int32 nselfSeat = 14;
inline bool has_nselfseat() const;
inline void clear_nselfseat();
static const int kNselfSeatFieldNumber = 14;
inline ::google::protobuf::int32 nselfseat() const;
inline void set_nselfseat(::google::protobuf::int32 value);
// optional bool bJingDian = 15;
inline bool has_bjingdian() const;
inline void clear_bjingdian();
static const int kBJingDianFieldNumber = 15;
inline bool bjingdian() const;
inline void set_bjingdian(bool value);
// optional bool bMagicCard = 16;
inline bool has_bmagiccard() const;
inline void clear_bmagiccard();
static const int kBMagicCardFieldNumber = 16;
inline bool bmagiccard() const;
inline void set_bmagiccard(bool value);
// optional bool bMasterThebe = 17;
inline bool has_bmasterthebe() const;
inline void clear_bmasterthebe();
static const int kBMasterThebeFieldNumber = 17;
inline bool bmasterthebe() const;
inline void set_bmasterthebe(bool value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameRuleConfig)
private:
inline void set_has_game_round();
inline void clear_has_game_round();
inline void set_has_need_card();
inline void clear_has_need_card();
inline void set_has_have_bottom_king();
inline void clear_has_have_bottom_king();
inline void set_has_have_mai_lei();
inline void clear_has_have_mai_lei();
inline void set_has_hava_hui_tou();
inline void clear_has_hava_hui_tou();
inline void set_has_nmasterseat();
inline void clear_has_nmasterseat();
inline void set_has_current_game_count();
inline void clear_has_current_game_count();
inline void set_has_have_jianma();
inline void clear_has_have_jianma();
inline void set_has_nchongguannum();
inline void clear_has_nchongguannum();
inline void set_has_bbawangfanbei();
inline void clear_has_bbawangfanbei();
inline void set_has_nplayernum();
inline void clear_has_nplayernum();
inline void set_has_sroomnum();
inline void clear_has_sroomnum();
inline void set_has_splaytime();
inline void clear_has_splaytime();
inline void set_has_nselfseat();
inline void clear_has_nselfseat();
inline void set_has_bjingdian();
inline void clear_has_bjingdian();
inline void set_has_bmagiccard();
inline void clear_has_bmagiccard();
inline void set_has_bmasterthebe();
inline void clear_has_bmasterthebe();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 game_round_;
::google::protobuf::int32 need_card_;
bool have_bottom_king_;
bool have_mai_lei_;
bool hava_hui_tou_;
bool have_jianma_;
::google::protobuf::int32 nmasterseat_;
::google::protobuf::int32 current_game_count_;
::google::protobuf::int32 nchongguannum_;
::std::string* sroomnum_;
::google::protobuf::int32 nplayernum_;
::google::protobuf::int32 nselfseat_;
::std::string* splaytime_;
bool bbawangfanbei_;
bool bjingdian_;
bool bmagiccard_;
bool bmasterthebe_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(17 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameRuleConfig* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameBrokenStatus : public ::google::protobuf::Message {
public:
ProJDDDZGameBrokenStatus();
virtual ~ProJDDDZGameBrokenStatus();
ProJDDDZGameBrokenStatus(const ProJDDDZGameBrokenStatus& from);
inline ProJDDDZGameBrokenStatus& operator=(const ProJDDDZGameBrokenStatus& 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 ProJDDDZGameBrokenStatus& default_instance();
void Swap(ProJDDDZGameBrokenStatus* other);
// implements Message ----------------------------------------------
ProJDDDZGameBrokenStatus* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameBrokenStatus& from);
void MergeFrom(const ProJDDDZGameBrokenStatus& 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 ProJDDDZGameBrokenStatus_MSGID MSGID;
static const MSGID ID = ProJDDDZGameBrokenStatus_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameBrokenStatus_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameBrokenStatus_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameBrokenStatus_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameBrokenStatus_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameBrokenStatus_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameBrokenStatus_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameBrokenStatus_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 broken_seat = 1;
inline bool has_broken_seat() const;
inline void clear_broken_seat();
static const int kBrokenSeatFieldNumber = 1;
inline ::google::protobuf::int32 broken_seat() const;
inline void set_broken_seat(::google::protobuf::int32 value);
// repeated bool broken_status = 2;
inline int broken_status_size() const;
inline void clear_broken_status();
static const int kBrokenStatusFieldNumber = 2;
inline bool broken_status(int index) const;
inline void set_broken_status(int index, bool value);
inline void add_broken_status(bool value);
inline const ::google::protobuf::RepeatedField< bool >&
broken_status() const;
inline ::google::protobuf::RepeatedField< bool >*
mutable_broken_status();
// optional int32 left_time = 3;
inline bool has_left_time() const;
inline void clear_left_time();
static const int kLeftTimeFieldNumber = 3;
inline ::google::protobuf::int32 left_time() const;
inline void set_left_time(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameBrokenStatus)
private:
inline void set_has_broken_seat();
inline void clear_has_broken_seat();
inline void set_has_left_time();
inline void clear_has_left_time();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::RepeatedField< bool > broken_status_;
::google::protobuf::int32 broken_seat_;
::google::protobuf::int32 left_time_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameBrokenStatus* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameDataResp : public ::google::protobuf::Message {
public:
ProJDDDZGameDataResp();
virtual ~ProJDDDZGameDataResp();
ProJDDDZGameDataResp(const ProJDDDZGameDataResp& from);
inline ProJDDDZGameDataResp& operator=(const ProJDDDZGameDataResp& 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 ProJDDDZGameDataResp& default_instance();
void Swap(ProJDDDZGameDataResp* other);
// implements Message ----------------------------------------------
ProJDDDZGameDataResp* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameDataResp& from);
void MergeFrom(const ProJDDDZGameDataResp& 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 ProJDDDZGameDataResp_MSGID MSGID;
static const MSGID ID = ProJDDDZGameDataResp_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameDataResp_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameDataResp_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameDataResp_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameDataResp_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameDataResp_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameDataResp_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameDataResp_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// repeated int32 total_score = 1;
inline int total_score_size() const;
inline void clear_total_score();
static const int kTotalScoreFieldNumber = 1;
inline ::google::protobuf::int32 total_score(int index) const;
inline void set_total_score(int index, ::google::protobuf::int32 value);
inline void add_total_score(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
total_score() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_total_score();
// optional int32 type = 2;
inline bool has_type() const;
inline void clear_type();
static const int kTypeFieldNumber = 2;
inline ::google::protobuf::int32 type() const;
inline void set_type(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameDataResp)
private:
inline void set_has_type();
inline void clear_has_type();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > total_score_;
::google::protobuf::int32 type_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameDataResp* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameRecordRequest : public ::google::protobuf::Message {
public:
ProJDDDZGameRecordRequest();
virtual ~ProJDDDZGameRecordRequest();
ProJDDDZGameRecordRequest(const ProJDDDZGameRecordRequest& from);
inline ProJDDDZGameRecordRequest& operator=(const ProJDDDZGameRecordRequest& 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 ProJDDDZGameRecordRequest& default_instance();
void Swap(ProJDDDZGameRecordRequest* other);
// implements Message ----------------------------------------------
ProJDDDZGameRecordRequest* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameRecordRequest& from);
void MergeFrom(const ProJDDDZGameRecordRequest& 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 ProJDDDZGameRecordRequest_MSGID MSGID;
static const MSGID ID = ProJDDDZGameRecordRequest_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameRecordRequest_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameRecordRequest_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameRecordRequest_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameRecordRequest_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameRecordRequest_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameRecordRequest_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameRecordRequest_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat_id = 1;
inline bool has_seat_id() const;
inline void clear_seat_id();
static const int kSeatIdFieldNumber = 1;
inline ::google::protobuf::int32 seat_id() const;
inline void set_seat_id(::google::protobuf::int32 value);
// optional bytes url = 2;
inline bool has_url() const;
inline void clear_url();
static const int kUrlFieldNumber = 2;
inline const ::std::string& url() const;
inline void set_url(const ::std::string& value);
inline void set_url(const char* value);
inline void set_url(const void* value, size_t size);
inline ::std::string* mutable_url();
inline ::std::string* release_url();
inline void set_allocated_url(::std::string* url);
// @@protoc_insertion_point(class_scope:ProJDDDZGameRecordRequest)
private:
inline void set_has_seat_id();
inline void clear_has_seat_id();
inline void set_has_url();
inline void clear_has_url();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::std::string* url_;
::google::protobuf::int32 seat_id_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameRecordRequest* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameRecordResponse : public ::google::protobuf::Message {
public:
ProJDDDZGameRecordResponse();
virtual ~ProJDDDZGameRecordResponse();
ProJDDDZGameRecordResponse(const ProJDDDZGameRecordResponse& from);
inline ProJDDDZGameRecordResponse& operator=(const ProJDDDZGameRecordResponse& 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 ProJDDDZGameRecordResponse& default_instance();
void Swap(ProJDDDZGameRecordResponse* other);
// implements Message ----------------------------------------------
ProJDDDZGameRecordResponse* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameRecordResponse& from);
void MergeFrom(const ProJDDDZGameRecordResponse& 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 ProJDDDZGameRecordResponse_MSGID MSGID;
static const MSGID ID = ProJDDDZGameRecordResponse_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameRecordResponse_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameRecordResponse_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameRecordResponse_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameRecordResponse_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameRecordResponse_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameRecordResponse_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameRecordResponse_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat_id = 1;
inline bool has_seat_id() const;
inline void clear_seat_id();
static const int kSeatIdFieldNumber = 1;
inline ::google::protobuf::int32 seat_id() const;
inline void set_seat_id(::google::protobuf::int32 value);
// optional bytes url = 2;
inline bool has_url() const;
inline void clear_url();
static const int kUrlFieldNumber = 2;
inline const ::std::string& url() const;
inline void set_url(const ::std::string& value);
inline void set_url(const char* value);
inline void set_url(const void* value, size_t size);
inline ::std::string* mutable_url();
inline ::std::string* release_url();
inline void set_allocated_url(::std::string* url);
// @@protoc_insertion_point(class_scope:ProJDDDZGameRecordResponse)
private:
inline void set_has_seat_id();
inline void clear_has_seat_id();
inline void set_has_url();
inline void clear_has_url();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::std::string* url_;
::google::protobuf::int32 seat_id_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameRecordResponse* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameUserLocationRequest : public ::google::protobuf::Message {
public:
ProJDDDZGameUserLocationRequest();
virtual ~ProJDDDZGameUserLocationRequest();
ProJDDDZGameUserLocationRequest(const ProJDDDZGameUserLocationRequest& from);
inline ProJDDDZGameUserLocationRequest& operator=(const ProJDDDZGameUserLocationRequest& 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 ProJDDDZGameUserLocationRequest& default_instance();
void Swap(ProJDDDZGameUserLocationRequest* other);
// implements Message ----------------------------------------------
ProJDDDZGameUserLocationRequest* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameUserLocationRequest& from);
void MergeFrom(const ProJDDDZGameUserLocationRequest& 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 ProJDDDZGameUserLocationRequest_MSGID MSGID;
static const MSGID ID = ProJDDDZGameUserLocationRequest_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameUserLocationRequest_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameUserLocationRequest_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameUserLocationRequest_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameUserLocationRequest_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameUserLocationRequest_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameUserLocationRequest_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameUserLocationRequest_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat_id = 1;
inline bool has_seat_id() const;
inline void clear_seat_id();
static const int kSeatIdFieldNumber = 1;
inline ::google::protobuf::int32 seat_id() const;
inline void set_seat_id(::google::protobuf::int32 value);
// optional double dwlongitude = 2;
inline bool has_dwlongitude() const;
inline void clear_dwlongitude();
static const int kDwlongitudeFieldNumber = 2;
inline double dwlongitude() const;
inline void set_dwlongitude(double value);
// optional double dwlatitude = 3;
inline bool has_dwlatitude() const;
inline void clear_dwlatitude();
static const int kDwlatitudeFieldNumber = 3;
inline double dwlatitude() const;
inline void set_dwlatitude(double value);
// optional bytes strDistrict = 4;
inline bool has_strdistrict() const;
inline void clear_strdistrict();
static const int kStrDistrictFieldNumber = 4;
inline const ::std::string& strdistrict() const;
inline void set_strdistrict(const ::std::string& value);
inline void set_strdistrict(const char* value);
inline void set_strdistrict(const void* value, size_t size);
inline ::std::string* mutable_strdistrict();
inline ::std::string* release_strdistrict();
inline void set_allocated_strdistrict(::std::string* strdistrict);
// optional bytes strStreetName = 5;
inline bool has_strstreetname() const;
inline void clear_strstreetname();
static const int kStrStreetNameFieldNumber = 5;
inline const ::std::string& strstreetname() const;
inline void set_strstreetname(const ::std::string& value);
inline void set_strstreetname(const char* value);
inline void set_strstreetname(const void* value, size_t size);
inline ::std::string* mutable_strstreetname();
inline ::std::string* release_strstreetname();
inline void set_allocated_strstreetname(::std::string* strstreetname);
// @@protoc_insertion_point(class_scope:ProJDDDZGameUserLocationRequest)
private:
inline void set_has_seat_id();
inline void clear_has_seat_id();
inline void set_has_dwlongitude();
inline void clear_has_dwlongitude();
inline void set_has_dwlatitude();
inline void clear_has_dwlatitude();
inline void set_has_strdistrict();
inline void clear_has_strdistrict();
inline void set_has_strstreetname();
inline void clear_has_strstreetname();
::google::protobuf::UnknownFieldSet _unknown_fields_;
double dwlongitude_;
double dwlatitude_;
::std::string* strdistrict_;
::std::string* strstreetname_;
::google::protobuf::int32 seat_id_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameUserLocationRequest* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameSyncCardResponse : public ::google::protobuf::Message {
public:
ProJDDDZGameSyncCardResponse();
virtual ~ProJDDDZGameSyncCardResponse();
ProJDDDZGameSyncCardResponse(const ProJDDDZGameSyncCardResponse& from);
inline ProJDDDZGameSyncCardResponse& operator=(const ProJDDDZGameSyncCardResponse& 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 ProJDDDZGameSyncCardResponse& default_instance();
void Swap(ProJDDDZGameSyncCardResponse* other);
// implements Message ----------------------------------------------
ProJDDDZGameSyncCardResponse* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameSyncCardResponse& from);
void MergeFrom(const ProJDDDZGameSyncCardResponse& 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 ProJDDDZGameSyncCardResponse_MSGID MSGID;
static const MSGID ID = ProJDDDZGameSyncCardResponse_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameSyncCardResponse_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameSyncCardResponse_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameSyncCardResponse_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameSyncCardResponse_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameSyncCardResponse_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameSyncCardResponse_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameSyncCardResponse_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat = 2;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 2;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// repeated int32 handmahs = 3;
inline int handmahs_size() const;
inline void clear_handmahs();
static const int kHandmahsFieldNumber = 3;
inline ::google::protobuf::int32 handmahs(int index) const;
inline void set_handmahs(int index, ::google::protobuf::int32 value);
inline void add_handmahs(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
handmahs() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_handmahs();
// @@protoc_insertion_point(class_scope:ProJDDDZGameSyncCardResponse)
private:
inline void set_has_seat();
inline void clear_has_seat();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > handmahs_;
::google::protobuf::int32 seat_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameSyncCardResponse* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameUserPhoneStatusRequest : public ::google::protobuf::Message {
public:
ProJDDDZGameUserPhoneStatusRequest();
virtual ~ProJDDDZGameUserPhoneStatusRequest();
ProJDDDZGameUserPhoneStatusRequest(const ProJDDDZGameUserPhoneStatusRequest& from);
inline ProJDDDZGameUserPhoneStatusRequest& operator=(const ProJDDDZGameUserPhoneStatusRequest& 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 ProJDDDZGameUserPhoneStatusRequest& default_instance();
void Swap(ProJDDDZGameUserPhoneStatusRequest* other);
// implements Message ----------------------------------------------
ProJDDDZGameUserPhoneStatusRequest* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameUserPhoneStatusRequest& from);
void MergeFrom(const ProJDDDZGameUserPhoneStatusRequest& 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 ProJDDDZGameUserPhoneStatusRequest_MSGID MSGID;
static const MSGID ID = ProJDDDZGameUserPhoneStatusRequest_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameUserPhoneStatusRequest_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameUserPhoneStatusRequest_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameUserPhoneStatusRequest_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameUserPhoneStatusRequest_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameUserPhoneStatusRequest_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameUserPhoneStatusRequest_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameUserPhoneStatusRequest_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat_id = 1;
inline bool has_seat_id() const;
inline void clear_seat_id();
static const int kSeatIdFieldNumber = 1;
inline ::google::protobuf::int32 seat_id() const;
inline void set_seat_id(::google::protobuf::int32 value);
// optional int32 userstatus = 2;
inline bool has_userstatus() const;
inline void clear_userstatus();
static const int kUserstatusFieldNumber = 2;
inline ::google::protobuf::int32 userstatus() const;
inline void set_userstatus(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameUserPhoneStatusRequest)
private:
inline void set_has_seat_id();
inline void clear_has_seat_id();
inline void set_has_userstatus();
inline void clear_has_userstatus();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 seat_id_;
::google::protobuf::int32 userstatus_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameUserPhoneStatusRequest* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameUserGiveUpRequest : public ::google::protobuf::Message {
public:
ProJDDDZGameUserGiveUpRequest();
virtual ~ProJDDDZGameUserGiveUpRequest();
ProJDDDZGameUserGiveUpRequest(const ProJDDDZGameUserGiveUpRequest& from);
inline ProJDDDZGameUserGiveUpRequest& operator=(const ProJDDDZGameUserGiveUpRequest& 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 ProJDDDZGameUserGiveUpRequest& default_instance();
void Swap(ProJDDDZGameUserGiveUpRequest* other);
// implements Message ----------------------------------------------
ProJDDDZGameUserGiveUpRequest* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameUserGiveUpRequest& from);
void MergeFrom(const ProJDDDZGameUserGiveUpRequest& 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 ProJDDDZGameUserGiveUpRequest_MSGID MSGID;
static const MSGID ID = ProJDDDZGameUserGiveUpRequest_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameUserGiveUpRequest_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameUserGiveUpRequest_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameUserGiveUpRequest_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameUserGiveUpRequest_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameUserGiveUpRequest_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameUserGiveUpRequest_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameUserGiveUpRequest_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat_id = 1;
inline bool has_seat_id() const;
inline void clear_seat_id();
static const int kSeatIdFieldNumber = 1;
inline ::google::protobuf::int32 seat_id() const;
inline void set_seat_id(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameUserGiveUpRequest)
private:
inline void set_has_seat_id();
inline void clear_has_seat_id();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 seat_id_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameUserGiveUpRequest* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameUserHintRequest : public ::google::protobuf::Message {
public:
ProJDDDZGameUserHintRequest();
virtual ~ProJDDDZGameUserHintRequest();
ProJDDDZGameUserHintRequest(const ProJDDDZGameUserHintRequest& from);
inline ProJDDDZGameUserHintRequest& operator=(const ProJDDDZGameUserHintRequest& 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 ProJDDDZGameUserHintRequest& default_instance();
void Swap(ProJDDDZGameUserHintRequest* other);
// implements Message ----------------------------------------------
ProJDDDZGameUserHintRequest* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameUserHintRequest& from);
void MergeFrom(const ProJDDDZGameUserHintRequest& 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 ProJDDDZGameUserHintRequest_MSGID MSGID;
static const MSGID ID = ProJDDDZGameUserHintRequest_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameUserHintRequest_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameUserHintRequest_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameUserHintRequest_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameUserHintRequest_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameUserHintRequest_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameUserHintRequest_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameUserHintRequest_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// @@protoc_insertion_point(class_scope:ProJDDDZGameUserHintRequest)
private:
::google::protobuf::UnknownFieldSet _unknown_fields_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[1];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameUserHintRequest* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameUserHintResponse : public ::google::protobuf::Message {
public:
ProJDDDZGameUserHintResponse();
virtual ~ProJDDDZGameUserHintResponse();
ProJDDDZGameUserHintResponse(const ProJDDDZGameUserHintResponse& from);
inline ProJDDDZGameUserHintResponse& operator=(const ProJDDDZGameUserHintResponse& 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 ProJDDDZGameUserHintResponse& default_instance();
void Swap(ProJDDDZGameUserHintResponse* other);
// implements Message ----------------------------------------------
ProJDDDZGameUserHintResponse* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameUserHintResponse& from);
void MergeFrom(const ProJDDDZGameUserHintResponse& 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 ProJDDDZGameUserHintResponse_MSGID MSGID;
static const MSGID ID = ProJDDDZGameUserHintResponse_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameUserHintResponse_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameUserHintResponse_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameUserHintResponse_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameUserHintResponse_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameUserHintResponse_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameUserHintResponse_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameUserHintResponse_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 lenth = 1;
inline bool has_lenth() const;
inline void clear_lenth();
static const int kLenthFieldNumber = 1;
inline ::google::protobuf::int32 lenth() const;
inline void set_lenth(::google::protobuf::int32 value);
// repeated int32 outMahs = 2;
inline int outmahs_size() const;
inline void clear_outmahs();
static const int kOutMahsFieldNumber = 2;
inline ::google::protobuf::int32 outmahs(int index) const;
inline void set_outmahs(int index, ::google::protobuf::int32 value);
inline void add_outmahs(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
outmahs() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_outmahs();
// @@protoc_insertion_point(class_scope:ProJDDDZGameUserHintResponse)
private:
inline void set_has_lenth();
inline void clear_has_lenth();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > outmahs_;
::google::protobuf::int32 lenth_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameUserHintResponse* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameUserCallScoreResponse : public ::google::protobuf::Message {
public:
ProJDDDZGameUserCallScoreResponse();
virtual ~ProJDDDZGameUserCallScoreResponse();
ProJDDDZGameUserCallScoreResponse(const ProJDDDZGameUserCallScoreResponse& from);
inline ProJDDDZGameUserCallScoreResponse& operator=(const ProJDDDZGameUserCallScoreResponse& 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 ProJDDDZGameUserCallScoreResponse& default_instance();
void Swap(ProJDDDZGameUserCallScoreResponse* other);
// implements Message ----------------------------------------------
ProJDDDZGameUserCallScoreResponse* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameUserCallScoreResponse& from);
void MergeFrom(const ProJDDDZGameUserCallScoreResponse& 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 ProJDDDZGameUserCallScoreResponse_MSGID MSGID;
static const MSGID ID = ProJDDDZGameUserCallScoreResponse_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameUserCallScoreResponse_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameUserCallScoreResponse_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameUserCallScoreResponse_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameUserCallScoreResponse_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameUserCallScoreResponse_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameUserCallScoreResponse_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameUserCallScoreResponse_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat = 1;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 1;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// optional int32 usercallscore = 2;
inline bool has_usercallscore() const;
inline void clear_usercallscore();
static const int kUsercallscoreFieldNumber = 2;
inline ::google::protobuf::int32 usercallscore() const;
inline void set_usercallscore(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameUserCallScoreResponse)
private:
inline void set_has_seat();
inline void clear_has_seat();
inline void set_has_usercallscore();
inline void clear_has_usercallscore();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 seat_;
::google::protobuf::int32 usercallscore_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameUserCallScoreResponse* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameUserCallScoreRequest : public ::google::protobuf::Message {
public:
ProJDDDZGameUserCallScoreRequest();
virtual ~ProJDDDZGameUserCallScoreRequest();
ProJDDDZGameUserCallScoreRequest(const ProJDDDZGameUserCallScoreRequest& from);
inline ProJDDDZGameUserCallScoreRequest& operator=(const ProJDDDZGameUserCallScoreRequest& 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 ProJDDDZGameUserCallScoreRequest& default_instance();
void Swap(ProJDDDZGameUserCallScoreRequest* other);
// implements Message ----------------------------------------------
ProJDDDZGameUserCallScoreRequest* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameUserCallScoreRequest& from);
void MergeFrom(const ProJDDDZGameUserCallScoreRequest& 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 ProJDDDZGameUserCallScoreRequest_MSGID MSGID;
static const MSGID ID = ProJDDDZGameUserCallScoreRequest_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameUserCallScoreRequest_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameUserCallScoreRequest_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameUserCallScoreRequest_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameUserCallScoreRequest_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameUserCallScoreRequest_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameUserCallScoreRequest_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameUserCallScoreRequest_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat = 1;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 1;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// optional int32 usercallscore = 2;
inline bool has_usercallscore() const;
inline void clear_usercallscore();
static const int kUsercallscoreFieldNumber = 2;
inline ::google::protobuf::int32 usercallscore() const;
inline void set_usercallscore(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameUserCallScoreRequest)
private:
inline void set_has_seat();
inline void clear_has_seat();
inline void set_has_usercallscore();
inline void clear_has_usercallscore();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 seat_;
::google::protobuf::int32 usercallscore_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameUserCallScoreRequest* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameCallNotify : public ::google::protobuf::Message {
public:
ProJDDDZGameCallNotify();
virtual ~ProJDDDZGameCallNotify();
ProJDDDZGameCallNotify(const ProJDDDZGameCallNotify& from);
inline ProJDDDZGameCallNotify& operator=(const ProJDDDZGameCallNotify& 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 ProJDDDZGameCallNotify& default_instance();
void Swap(ProJDDDZGameCallNotify* other);
// implements Message ----------------------------------------------
ProJDDDZGameCallNotify* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameCallNotify& from);
void MergeFrom(const ProJDDDZGameCallNotify& 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 ProJDDDZGameCallNotify_MSGID MSGID;
static const MSGID ID = ProJDDDZGameCallNotify_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameCallNotify_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameCallNotify_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameCallNotify_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameCallNotify_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameCallNotify_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameCallNotify_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameCallNotify_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat = 1;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 1;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// optional int32 maxCallScore = 2;
inline bool has_maxcallscore() const;
inline void clear_maxcallscore();
static const int kMaxCallScoreFieldNumber = 2;
inline ::google::protobuf::int32 maxcallscore() const;
inline void set_maxcallscore(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameCallNotify)
private:
inline void set_has_seat();
inline void clear_has_seat();
inline void set_has_maxcallscore();
inline void clear_has_maxcallscore();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 seat_;
::google::protobuf::int32 maxcallscore_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameCallNotify* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameQiangNotify : public ::google::protobuf::Message {
public:
ProJDDDZGameQiangNotify();
virtual ~ProJDDDZGameQiangNotify();
ProJDDDZGameQiangNotify(const ProJDDDZGameQiangNotify& from);
inline ProJDDDZGameQiangNotify& operator=(const ProJDDDZGameQiangNotify& 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 ProJDDDZGameQiangNotify& default_instance();
void Swap(ProJDDDZGameQiangNotify* other);
// implements Message ----------------------------------------------
ProJDDDZGameQiangNotify* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameQiangNotify& from);
void MergeFrom(const ProJDDDZGameQiangNotify& 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 ProJDDDZGameQiangNotify_MSGID MSGID;
static const MSGID ID = ProJDDDZGameQiangNotify_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameQiangNotify_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameQiangNotify_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameQiangNotify_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameQiangNotify_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameQiangNotify_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameQiangNotify_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameQiangNotify_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat = 1;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 1;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameQiangNotify)
private:
inline void set_has_seat();
inline void clear_has_seat();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 seat_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameQiangNotify* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameUserCallLandlordResponse : public ::google::protobuf::Message {
public:
ProJDDDZGameUserCallLandlordResponse();
virtual ~ProJDDDZGameUserCallLandlordResponse();
ProJDDDZGameUserCallLandlordResponse(const ProJDDDZGameUserCallLandlordResponse& from);
inline ProJDDDZGameUserCallLandlordResponse& operator=(const ProJDDDZGameUserCallLandlordResponse& 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 ProJDDDZGameUserCallLandlordResponse& default_instance();
void Swap(ProJDDDZGameUserCallLandlordResponse* other);
// implements Message ----------------------------------------------
ProJDDDZGameUserCallLandlordResponse* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameUserCallLandlordResponse& from);
void MergeFrom(const ProJDDDZGameUserCallLandlordResponse& 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 ProJDDDZGameUserCallLandlordResponse_MSGID MSGID;
static const MSGID ID = ProJDDDZGameUserCallLandlordResponse_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameUserCallLandlordResponse_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameUserCallLandlordResponse_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameUserCallLandlordResponse_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameUserCallLandlordResponse_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameUserCallLandlordResponse_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameUserCallLandlordResponse_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameUserCallLandlordResponse_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 iscallandlord = 1;
inline bool has_iscallandlord() const;
inline void clear_iscallandlord();
static const int kIscallandlordFieldNumber = 1;
inline ::google::protobuf::int32 iscallandlord() const;
inline void set_iscallandlord(::google::protobuf::int32 value);
// optional int32 score = 2;
inline bool has_score() const;
inline void clear_score();
static const int kScoreFieldNumber = 2;
inline ::google::protobuf::int32 score() const;
inline void set_score(::google::protobuf::int32 value);
// optional int32 landlordSeat = 3;
inline bool has_landlordseat() const;
inline void clear_landlordseat();
static const int kLandlordSeatFieldNumber = 3;
inline ::google::protobuf::int32 landlordseat() const;
inline void set_landlordseat(::google::protobuf::int32 value);
// optional int32 seat = 4;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 4;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// optional bool isSoundCall = 5;
inline bool has_issoundcall() const;
inline void clear_issoundcall();
static const int kIsSoundCallFieldNumber = 5;
inline bool issoundcall() const;
inline void set_issoundcall(bool value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameUserCallLandlordResponse)
private:
inline void set_has_iscallandlord();
inline void clear_has_iscallandlord();
inline void set_has_score();
inline void clear_has_score();
inline void set_has_landlordseat();
inline void clear_has_landlordseat();
inline void set_has_seat();
inline void clear_has_seat();
inline void set_has_issoundcall();
inline void clear_has_issoundcall();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 iscallandlord_;
::google::protobuf::int32 score_;
::google::protobuf::int32 landlordseat_;
::google::protobuf::int32 seat_;
bool issoundcall_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameUserCallLandlordResponse* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameUserCallLandlordRequest : public ::google::protobuf::Message {
public:
ProJDDDZGameUserCallLandlordRequest();
virtual ~ProJDDDZGameUserCallLandlordRequest();
ProJDDDZGameUserCallLandlordRequest(const ProJDDDZGameUserCallLandlordRequest& from);
inline ProJDDDZGameUserCallLandlordRequest& operator=(const ProJDDDZGameUserCallLandlordRequest& 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 ProJDDDZGameUserCallLandlordRequest& default_instance();
void Swap(ProJDDDZGameUserCallLandlordRequest* other);
// implements Message ----------------------------------------------
ProJDDDZGameUserCallLandlordRequest* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameUserCallLandlordRequest& from);
void MergeFrom(const ProJDDDZGameUserCallLandlordRequest& 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 ProJDDDZGameUserCallLandlordRequest_MSGID MSGID;
static const MSGID ID = ProJDDDZGameUserCallLandlordRequest_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameUserCallLandlordRequest_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameUserCallLandlordRequest_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameUserCallLandlordRequest_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameUserCallLandlordRequest_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameUserCallLandlordRequest_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameUserCallLandlordRequest_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameUserCallLandlordRequest_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat = 1;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 1;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// optional int32 iscallandlord = 2;
inline bool has_iscallandlord() const;
inline void clear_iscallandlord();
static const int kIscallandlordFieldNumber = 2;
inline ::google::protobuf::int32 iscallandlord() const;
inline void set_iscallandlord(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameUserCallLandlordRequest)
private:
inline void set_has_seat();
inline void clear_has_seat();
inline void set_has_iscallandlord();
inline void clear_has_iscallandlord();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 seat_;
::google::protobuf::int32 iscallandlord_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameUserCallLandlordRequest* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameUserQinagLandlordResponse : public ::google::protobuf::Message {
public:
ProJDDDZGameUserQinagLandlordResponse();
virtual ~ProJDDDZGameUserQinagLandlordResponse();
ProJDDDZGameUserQinagLandlordResponse(const ProJDDDZGameUserQinagLandlordResponse& from);
inline ProJDDDZGameUserQinagLandlordResponse& operator=(const ProJDDDZGameUserQinagLandlordResponse& 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 ProJDDDZGameUserQinagLandlordResponse& default_instance();
void Swap(ProJDDDZGameUserQinagLandlordResponse* other);
// implements Message ----------------------------------------------
ProJDDDZGameUserQinagLandlordResponse* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameUserQinagLandlordResponse& from);
void MergeFrom(const ProJDDDZGameUserQinagLandlordResponse& 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 ProJDDDZGameUserQinagLandlordResponse_MSGID MSGID;
static const MSGID ID = ProJDDDZGameUserQinagLandlordResponse_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameUserQinagLandlordResponse_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameUserQinagLandlordResponse_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameUserQinagLandlordResponse_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameUserQinagLandlordResponse_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameUserQinagLandlordResponse_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameUserQinagLandlordResponse_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameUserQinagLandlordResponse_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 isQiangLandlord = 1;
inline bool has_isqianglandlord() const;
inline void clear_isqianglandlord();
static const int kIsQiangLandlordFieldNumber = 1;
inline ::google::protobuf::int32 isqianglandlord() const;
inline void set_isqianglandlord(::google::protobuf::int32 value);
// optional int32 score = 2;
inline bool has_score() const;
inline void clear_score();
static const int kScoreFieldNumber = 2;
inline ::google::protobuf::int32 score() const;
inline void set_score(::google::protobuf::int32 value);
// optional int32 landlordSeat = 3;
inline bool has_landlordseat() const;
inline void clear_landlordseat();
static const int kLandlordSeatFieldNumber = 3;
inline ::google::protobuf::int32 landlordseat() const;
inline void set_landlordseat(::google::protobuf::int32 value);
// optional int32 seat = 4;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 4;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameUserQinagLandlordResponse)
private:
inline void set_has_isqianglandlord();
inline void clear_has_isqianglandlord();
inline void set_has_score();
inline void clear_has_score();
inline void set_has_landlordseat();
inline void clear_has_landlordseat();
inline void set_has_seat();
inline void clear_has_seat();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 isqianglandlord_;
::google::protobuf::int32 score_;
::google::protobuf::int32 landlordseat_;
::google::protobuf::int32 seat_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameUserQinagLandlordResponse* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameUserQiangLandlordRequest : public ::google::protobuf::Message {
public:
ProJDDDZGameUserQiangLandlordRequest();
virtual ~ProJDDDZGameUserQiangLandlordRequest();
ProJDDDZGameUserQiangLandlordRequest(const ProJDDDZGameUserQiangLandlordRequest& from);
inline ProJDDDZGameUserQiangLandlordRequest& operator=(const ProJDDDZGameUserQiangLandlordRequest& 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 ProJDDDZGameUserQiangLandlordRequest& default_instance();
void Swap(ProJDDDZGameUserQiangLandlordRequest* other);
// implements Message ----------------------------------------------
ProJDDDZGameUserQiangLandlordRequest* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameUserQiangLandlordRequest& from);
void MergeFrom(const ProJDDDZGameUserQiangLandlordRequest& 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 ProJDDDZGameUserQiangLandlordRequest_MSGID MSGID;
static const MSGID ID = ProJDDDZGameUserQiangLandlordRequest_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameUserQiangLandlordRequest_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameUserQiangLandlordRequest_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameUserQiangLandlordRequest_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameUserQiangLandlordRequest_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameUserQiangLandlordRequest_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameUserQiangLandlordRequest_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameUserQiangLandlordRequest_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat = 1;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 1;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// optional int32 isQiangLandlord = 2;
inline bool has_isqianglandlord() const;
inline void clear_isqianglandlord();
static const int kIsQiangLandlordFieldNumber = 2;
inline ::google::protobuf::int32 isqianglandlord() const;
inline void set_isqianglandlord(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameUserQiangLandlordRequest)
private:
inline void set_has_seat();
inline void clear_has_seat();
inline void set_has_isqianglandlord();
inline void clear_has_isqianglandlord();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 seat_;
::google::protobuf::int32 isqianglandlord_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameUserQiangLandlordRequest* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameSendLastCard : public ::google::protobuf::Message {
public:
ProJDDDZGameSendLastCard();
virtual ~ProJDDDZGameSendLastCard();
ProJDDDZGameSendLastCard(const ProJDDDZGameSendLastCard& from);
inline ProJDDDZGameSendLastCard& operator=(const ProJDDDZGameSendLastCard& 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 ProJDDDZGameSendLastCard& default_instance();
void Swap(ProJDDDZGameSendLastCard* other);
// implements Message ----------------------------------------------
ProJDDDZGameSendLastCard* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameSendLastCard& from);
void MergeFrom(const ProJDDDZGameSendLastCard& 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 ProJDDDZGameSendLastCard_MSGID MSGID;
static const MSGID ID = ProJDDDZGameSendLastCard_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameSendLastCard_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameSendLastCard_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameSendLastCard_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameSendLastCard_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameSendLastCard_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameSendLastCard_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameSendLastCard_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat = 1;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 1;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// repeated .JDDDZMahList cbHandCardData = 2;
inline int cbhandcarddata_size() const;
inline void clear_cbhandcarddata();
static const int kCbHandCardDataFieldNumber = 2;
inline const ::JDDDZMahList& cbhandcarddata(int index) const;
inline ::JDDDZMahList* mutable_cbhandcarddata(int index);
inline ::JDDDZMahList* add_cbhandcarddata();
inline const ::google::protobuf::RepeatedPtrField< ::JDDDZMahList >&
cbhandcarddata() const;
inline ::google::protobuf::RepeatedPtrField< ::JDDDZMahList >*
mutable_cbhandcarddata();
// repeated int32 lastmahs = 3;
inline int lastmahs_size() const;
inline void clear_lastmahs();
static const int kLastmahsFieldNumber = 3;
inline ::google::protobuf::int32 lastmahs(int index) const;
inline void set_lastmahs(int index, ::google::protobuf::int32 value);
inline void add_lastmahs(::google::protobuf::int32 value);
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
lastmahs() const;
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_lastmahs();
// optional int32 laizi = 4;
inline bool has_laizi() const;
inline void clear_laizi();
static const int kLaiziFieldNumber = 4;
inline ::google::protobuf::int32 laizi() const;
inline void set_laizi(::google::protobuf::int32 value);
// optional bool isReCome = 5;
inline bool has_isrecome() const;
inline void clear_isrecome();
static const int kIsReComeFieldNumber = 5;
inline bool isrecome() const;
inline void set_isrecome(bool value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameSendLastCard)
private:
inline void set_has_seat();
inline void clear_has_seat();
inline void set_has_laizi();
inline void clear_has_laizi();
inline void set_has_isrecome();
inline void clear_has_isrecome();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::RepeatedPtrField< ::JDDDZMahList > cbhandcarddata_;
::google::protobuf::int32 seat_;
::google::protobuf::int32 laizi_;
::google::protobuf::RepeatedField< ::google::protobuf::int32 > lastmahs_;
bool isrecome_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameSendLastCard* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameUserMingPaiRequest : public ::google::protobuf::Message {
public:
ProJDDDZGameUserMingPaiRequest();
virtual ~ProJDDDZGameUserMingPaiRequest();
ProJDDDZGameUserMingPaiRequest(const ProJDDDZGameUserMingPaiRequest& from);
inline ProJDDDZGameUserMingPaiRequest& operator=(const ProJDDDZGameUserMingPaiRequest& 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 ProJDDDZGameUserMingPaiRequest& default_instance();
void Swap(ProJDDDZGameUserMingPaiRequest* other);
// implements Message ----------------------------------------------
ProJDDDZGameUserMingPaiRequest* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameUserMingPaiRequest& from);
void MergeFrom(const ProJDDDZGameUserMingPaiRequest& 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 ProJDDDZGameUserMingPaiRequest_MSGID MSGID;
static const MSGID ID = ProJDDDZGameUserMingPaiRequest_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameUserMingPaiRequest_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameUserMingPaiRequest_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameUserMingPaiRequest_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameUserMingPaiRequest_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameUserMingPaiRequest_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameUserMingPaiRequest_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameUserMingPaiRequest_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat = 1;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 1;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// optional bool isMingPai = 2;
inline bool has_ismingpai() const;
inline void clear_ismingpai();
static const int kIsMingPaiFieldNumber = 2;
inline bool ismingpai() const;
inline void set_ismingpai(bool value);
// optional int32 beilv = 3;
inline bool has_beilv() const;
inline void clear_beilv();
static const int kBeilvFieldNumber = 3;
inline ::google::protobuf::int32 beilv() const;
inline void set_beilv(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameUserMingPaiRequest)
private:
inline void set_has_seat();
inline void clear_has_seat();
inline void set_has_ismingpai();
inline void clear_has_ismingpai();
inline void set_has_beilv();
inline void clear_has_beilv();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 seat_;
bool ismingpai_;
::google::protobuf::int32 beilv_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameUserMingPaiRequest* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameUserMingPaiResponse : public ::google::protobuf::Message {
public:
ProJDDDZGameUserMingPaiResponse();
virtual ~ProJDDDZGameUserMingPaiResponse();
ProJDDDZGameUserMingPaiResponse(const ProJDDDZGameUserMingPaiResponse& from);
inline ProJDDDZGameUserMingPaiResponse& operator=(const ProJDDDZGameUserMingPaiResponse& 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 ProJDDDZGameUserMingPaiResponse& default_instance();
void Swap(ProJDDDZGameUserMingPaiResponse* other);
// implements Message ----------------------------------------------
ProJDDDZGameUserMingPaiResponse* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameUserMingPaiResponse& from);
void MergeFrom(const ProJDDDZGameUserMingPaiResponse& 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 ProJDDDZGameUserMingPaiResponse_MSGID MSGID;
static const MSGID ID = ProJDDDZGameUserMingPaiResponse_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameUserMingPaiResponse_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameUserMingPaiResponse_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameUserMingPaiResponse_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameUserMingPaiResponse_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameUserMingPaiResponse_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameUserMingPaiResponse_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameUserMingPaiResponse_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat = 1;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 1;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// optional bool isMingPai = 2;
inline bool has_ismingpai() const;
inline void clear_ismingpai();
static const int kIsMingPaiFieldNumber = 2;
inline bool ismingpai() const;
inline void set_ismingpai(bool value);
// optional int32 score = 3;
inline bool has_score() const;
inline void clear_score();
static const int kScoreFieldNumber = 3;
inline ::google::protobuf::int32 score() const;
inline void set_score(::google::protobuf::int32 value);
// optional int32 mingtag = 4;
inline bool has_mingtag() const;
inline void clear_mingtag();
static const int kMingtagFieldNumber = 4;
inline ::google::protobuf::int32 mingtag() const;
inline void set_mingtag(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameUserMingPaiResponse)
private:
inline void set_has_seat();
inline void clear_has_seat();
inline void set_has_ismingpai();
inline void clear_has_ismingpai();
inline void set_has_score();
inline void clear_has_score();
inline void set_has_mingtag();
inline void clear_has_mingtag();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 seat_;
bool ismingpai_;
::google::protobuf::int32 score_;
::google::protobuf::int32 mingtag_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameUserMingPaiResponse* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameMingNotify : public ::google::protobuf::Message {
public:
ProJDDDZGameMingNotify();
virtual ~ProJDDDZGameMingNotify();
ProJDDDZGameMingNotify(const ProJDDDZGameMingNotify& from);
inline ProJDDDZGameMingNotify& operator=(const ProJDDDZGameMingNotify& 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 ProJDDDZGameMingNotify& default_instance();
void Swap(ProJDDDZGameMingNotify* other);
// implements Message ----------------------------------------------
ProJDDDZGameMingNotify* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameMingNotify& from);
void MergeFrom(const ProJDDDZGameMingNotify& 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 ProJDDDZGameMingNotify_MSGID MSGID;
static const MSGID ID = ProJDDDZGameMingNotify_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameMingNotify_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameMingNotify_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameMingNotify_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameMingNotify_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameMingNotify_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameMingNotify_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameMingNotify_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// optional int32 seat = 1;
inline bool has_seat() const;
inline void clear_seat();
static const int kSeatFieldNumber = 1;
inline ::google::protobuf::int32 seat() const;
inline void set_seat(::google::protobuf::int32 value);
// optional int32 tag = 2;
inline bool has_tag() const;
inline void clear_tag();
static const int kTagFieldNumber = 2;
inline ::google::protobuf::int32 tag() const;
inline void set_tag(::google::protobuf::int32 value);
// optional float time = 3;
inline bool has_time() const;
inline void clear_time();
static const int kTimeFieldNumber = 3;
inline float time() const;
inline void set_time(float value);
// @@protoc_insertion_point(class_scope:ProJDDDZGameMingNotify)
private:
inline void set_has_seat();
inline void clear_has_seat();
inline void set_has_tag();
inline void clear_has_tag();
inline void set_has_time();
inline void clear_has_time();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::int32 seat_;
::google::protobuf::int32 tag_;
float time_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameMingNotify* default_instance_;
};
// -------------------------------------------------------------------
class ProJDDDZGameStartAgain : public ::google::protobuf::Message {
public:
ProJDDDZGameStartAgain();
virtual ~ProJDDDZGameStartAgain();
ProJDDDZGameStartAgain(const ProJDDDZGameStartAgain& from);
inline ProJDDDZGameStartAgain& operator=(const ProJDDDZGameStartAgain& 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 ProJDDDZGameStartAgain& default_instance();
void Swap(ProJDDDZGameStartAgain* other);
// implements Message ----------------------------------------------
ProJDDDZGameStartAgain* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const ProJDDDZGameStartAgain& from);
void MergeFrom(const ProJDDDZGameStartAgain& 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 ProJDDDZGameStartAgain_MSGID MSGID;
static const MSGID ID = ProJDDDZGameStartAgain_MSGID_ID;
static inline bool MSGID_IsValid(int value) {
return ProJDDDZGameStartAgain_MSGID_IsValid(value);
}
static const MSGID MSGID_MIN =
ProJDDDZGameStartAgain_MSGID_MSGID_MIN;
static const MSGID MSGID_MAX =
ProJDDDZGameStartAgain_MSGID_MSGID_MAX;
static const int MSGID_ARRAYSIZE =
ProJDDDZGameStartAgain_MSGID_MSGID_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor*
MSGID_descriptor() {
return ProJDDDZGameStartAgain_MSGID_descriptor();
}
static inline const ::std::string& MSGID_Name(MSGID value) {
return ProJDDDZGameStartAgain_MSGID_Name(value);
}
static inline bool MSGID_Parse(const ::std::string& name,
MSGID* value) {
return ProJDDDZGameStartAgain_MSGID_Parse(name, value);
}
// accessors -------------------------------------------------------
// @@protoc_insertion_point(class_scope:ProJDDDZGameStartAgain)
private:
::google::protobuf::UnknownFieldSet _unknown_fields_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[1];
friend void protobuf_AddDesc_jdddzpk_2eproto();
friend void protobuf_AssignDesc_jdddzpk_2eproto();
friend void protobuf_ShutdownFile_jdddzpk_2eproto();
void InitAsDefaultInstance();
static ProJDDDZGameStartAgain* default_instance_;
};
// ===================================================================
// ===================================================================
// ProJDDDZGameStatusResponse
// optional .JDDDZGameState status = 2;
inline bool ProJDDDZGameStatusResponse::has_status() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameStatusResponse::set_has_status() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameStatusResponse::clear_has_status() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameStatusResponse::clear_status() {
status_ = 1;
clear_has_status();
}
inline ::JDDDZGameState ProJDDDZGameStatusResponse::status() const {
return static_cast< ::JDDDZGameState >(status_);
}
inline void ProJDDDZGameStatusResponse::set_status(::JDDDZGameState value) {
assert(::JDDDZGameState_IsValid(value));
set_has_status();
status_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameDeskInfoResponse
// optional int32 CellScore = 2;
inline bool ProJDDDZGameDeskInfoResponse::has_cellscore() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameDeskInfoResponse::set_has_cellscore() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameDeskInfoResponse::clear_has_cellscore() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameDeskInfoResponse::clear_cellscore() {
cellscore_ = 0;
clear_has_cellscore();
}
inline ::google::protobuf::int32 ProJDDDZGameDeskInfoResponse::cellscore() const {
return cellscore_;
}
inline void ProJDDDZGameDeskInfoResponse::set_cellscore(::google::protobuf::int32 value) {
set_has_cellscore();
cellscore_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameReadyNotify
// optional int32 seat = 2;
inline bool ProJDDDZGameReadyNotify::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameReadyNotify::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameReadyNotify::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameReadyNotify::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameReadyNotify::seat() const {
return seat_;
}
inline void ProJDDDZGameReadyNotify::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// optional int32 time = 3;
inline bool ProJDDDZGameReadyNotify::has_time() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameReadyNotify::set_has_time() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameReadyNotify::clear_has_time() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameReadyNotify::clear_time() {
time_ = 0;
clear_has_time();
}
inline ::google::protobuf::int32 ProJDDDZGameReadyNotify::time() const {
return time_;
}
inline void ProJDDDZGameReadyNotify::set_time(::google::protobuf::int32 value) {
set_has_time();
time_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameReadyRequest
// optional int32 seat = 2;
inline bool ProJDDDZGameReadyRequest::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameReadyRequest::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameReadyRequest::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameReadyRequest::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameReadyRequest::seat() const {
return seat_;
}
inline void ProJDDDZGameReadyRequest::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameReadyResponse
// optional int32 seat = 2;
inline bool ProJDDDZGameReadyResponse::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameReadyResponse::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameReadyResponse::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameReadyResponse::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameReadyResponse::seat() const {
return seat_;
}
inline void ProJDDDZGameReadyResponse::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// optional bool isMingPai = 3;
inline bool ProJDDDZGameReadyResponse::has_ismingpai() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameReadyResponse::set_has_ismingpai() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameReadyResponse::clear_has_ismingpai() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameReadyResponse::clear_ismingpai() {
ismingpai_ = false;
clear_has_ismingpai();
}
inline bool ProJDDDZGameReadyResponse::ismingpai() const {
return ismingpai_;
}
inline void ProJDDDZGameReadyResponse::set_ismingpai(bool value) {
set_has_ismingpai();
ismingpai_ = value;
}
// optional int32 MingPaiTag = 4;
inline bool ProJDDDZGameReadyResponse::has_mingpaitag() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ProJDDDZGameReadyResponse::set_has_mingpaitag() {
_has_bits_[0] |= 0x00000004u;
}
inline void ProJDDDZGameReadyResponse::clear_has_mingpaitag() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ProJDDDZGameReadyResponse::clear_mingpaitag() {
mingpaitag_ = 0;
clear_has_mingpaitag();
}
inline ::google::protobuf::int32 ProJDDDZGameReadyResponse::mingpaitag() const {
return mingpaitag_;
}
inline void ProJDDDZGameReadyResponse::set_mingpaitag(::google::protobuf::int32 value) {
set_has_mingpaitag();
mingpaitag_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameStart
// optional int32 bankerseat = 2;
inline bool ProJDDDZGameStart::has_bankerseat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameStart::set_has_bankerseat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameStart::clear_has_bankerseat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameStart::clear_bankerseat() {
bankerseat_ = 0;
clear_has_bankerseat();
}
inline ::google::protobuf::int32 ProJDDDZGameStart::bankerseat() const {
return bankerseat_;
}
inline void ProJDDDZGameStart::set_bankerseat(::google::protobuf::int32 value) {
set_has_bankerseat();
bankerseat_ = value;
}
// optional int32 gamecount = 3;
inline bool ProJDDDZGameStart::has_gamecount() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameStart::set_has_gamecount() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameStart::clear_has_gamecount() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameStart::clear_gamecount() {
gamecount_ = 0;
clear_has_gamecount();
}
inline ::google::protobuf::int32 ProJDDDZGameStart::gamecount() const {
return gamecount_;
}
inline void ProJDDDZGameStart::set_gamecount(::google::protobuf::int32 value) {
set_has_gamecount();
gamecount_ = value;
}
// optional int32 outCardtimes = 4;
inline bool ProJDDDZGameStart::has_outcardtimes() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ProJDDDZGameStart::set_has_outcardtimes() {
_has_bits_[0] |= 0x00000004u;
}
inline void ProJDDDZGameStart::clear_has_outcardtimes() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ProJDDDZGameStart::clear_outcardtimes() {
outcardtimes_ = 0;
clear_has_outcardtimes();
}
inline ::google::protobuf::int32 ProJDDDZGameStart::outcardtimes() const {
return outcardtimes_;
}
inline void ProJDDDZGameStart::set_outcardtimes(::google::protobuf::int32 value) {
set_has_outcardtimes();
outcardtimes_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameDiceNotify
// optional int32 seat = 2;
inline bool ProJDDDZGameDiceNotify::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameDiceNotify::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameDiceNotify::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameDiceNotify::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameDiceNotify::seat() const {
return seat_;
}
inline void ProJDDDZGameDiceNotify::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// optional int32 time = 3;
inline bool ProJDDDZGameDiceNotify::has_time() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameDiceNotify::set_has_time() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameDiceNotify::clear_has_time() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameDiceNotify::clear_time() {
time_ = 0;
clear_has_time();
}
inline ::google::protobuf::int32 ProJDDDZGameDiceNotify::time() const {
return time_;
}
inline void ProJDDDZGameDiceNotify::set_time(::google::protobuf::int32 value) {
set_has_time();
time_ = value;
}
// optional int32 dicecount = 4;
inline bool ProJDDDZGameDiceNotify::has_dicecount() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ProJDDDZGameDiceNotify::set_has_dicecount() {
_has_bits_[0] |= 0x00000004u;
}
inline void ProJDDDZGameDiceNotify::clear_has_dicecount() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ProJDDDZGameDiceNotify::clear_dicecount() {
dicecount_ = 0;
clear_has_dicecount();
}
inline ::google::protobuf::int32 ProJDDDZGameDiceNotify::dicecount() const {
return dicecount_;
}
inline void ProJDDDZGameDiceNotify::set_dicecount(::google::protobuf::int32 value) {
set_has_dicecount();
dicecount_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameDiceRequest
// optional int32 seat = 2;
inline bool ProJDDDZGameDiceRequest::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameDiceRequest::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameDiceRequest::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameDiceRequest::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameDiceRequest::seat() const {
return seat_;
}
inline void ProJDDDZGameDiceRequest::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// optional int32 dicecount = 3;
inline bool ProJDDDZGameDiceRequest::has_dicecount() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameDiceRequest::set_has_dicecount() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameDiceRequest::clear_has_dicecount() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameDiceRequest::clear_dicecount() {
dicecount_ = 0;
clear_has_dicecount();
}
inline ::google::protobuf::int32 ProJDDDZGameDiceRequest::dicecount() const {
return dicecount_;
}
inline void ProJDDDZGameDiceRequest::set_dicecount(::google::protobuf::int32 value) {
set_has_dicecount();
dicecount_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameDiceResult
// optional int32 seat = 2;
inline bool ProJDDDZGameDiceResult::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameDiceResult::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameDiceResult::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameDiceResult::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameDiceResult::seat() const {
return seat_;
}
inline void ProJDDDZGameDiceResult::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// repeated int32 result = 3;
inline int ProJDDDZGameDiceResult::result_size() const {
return result_.size();
}
inline void ProJDDDZGameDiceResult::clear_result() {
result_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameDiceResult::result(int index) const {
return result_.Get(index);
}
inline void ProJDDDZGameDiceResult::set_result(int index, ::google::protobuf::int32 value) {
result_.Set(index, value);
}
inline void ProJDDDZGameDiceResult::add_result(::google::protobuf::int32 value) {
result_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameDiceResult::result() const {
return result_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameDiceResult::mutable_result() {
return &result_;
}
// optional int32 dicecount = 4;
inline bool ProJDDDZGameDiceResult::has_dicecount() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ProJDDDZGameDiceResult::set_has_dicecount() {
_has_bits_[0] |= 0x00000004u;
}
inline void ProJDDDZGameDiceResult::clear_has_dicecount() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ProJDDDZGameDiceResult::clear_dicecount() {
dicecount_ = 0;
clear_has_dicecount();
}
inline ::google::protobuf::int32 ProJDDDZGameDiceResult::dicecount() const {
return dicecount_;
}
inline void ProJDDDZGameDiceResult::set_dicecount(::google::protobuf::int32 value) {
set_has_dicecount();
dicecount_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameSendMahs
// optional int32 seat = 2;
inline bool ProJDDDZGameSendMahs::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameSendMahs::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameSendMahs::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameSendMahs::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameSendMahs::seat() const {
return seat_;
}
inline void ProJDDDZGameSendMahs::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// repeated .JDDDZMahList cbHandCardData = 3;
inline int ProJDDDZGameSendMahs::cbhandcarddata_size() const {
return cbhandcarddata_.size();
}
inline void ProJDDDZGameSendMahs::clear_cbhandcarddata() {
cbhandcarddata_.Clear();
}
inline const ::JDDDZMahList& ProJDDDZGameSendMahs::cbhandcarddata(int index) const {
return cbhandcarddata_.Get(index);
}
inline ::JDDDZMahList* ProJDDDZGameSendMahs::mutable_cbhandcarddata(int index) {
return cbhandcarddata_.Mutable(index);
}
inline ::JDDDZMahList* ProJDDDZGameSendMahs::add_cbhandcarddata() {
return cbhandcarddata_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::JDDDZMahList >&
ProJDDDZGameSendMahs::cbhandcarddata() const {
return cbhandcarddata_;
}
inline ::google::protobuf::RepeatedPtrField< ::JDDDZMahList >*
ProJDDDZGameSendMahs::mutable_cbhandcarddata() {
return &cbhandcarddata_;
}
// repeated int32 mahscount = 4;
inline int ProJDDDZGameSendMahs::mahscount_size() const {
return mahscount_.size();
}
inline void ProJDDDZGameSendMahs::clear_mahscount() {
mahscount_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameSendMahs::mahscount(int index) const {
return mahscount_.Get(index);
}
inline void ProJDDDZGameSendMahs::set_mahscount(int index, ::google::protobuf::int32 value) {
mahscount_.Set(index, value);
}
inline void ProJDDDZGameSendMahs::add_mahscount(::google::protobuf::int32 value) {
mahscount_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameSendMahs::mahscount() const {
return mahscount_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameSendMahs::mutable_mahscount() {
return &mahscount_;
}
// optional int32 cbLeftCount = 5;
inline bool ProJDDDZGameSendMahs::has_cbleftcount() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ProJDDDZGameSendMahs::set_has_cbleftcount() {
_has_bits_[0] |= 0x00000008u;
}
inline void ProJDDDZGameSendMahs::clear_has_cbleftcount() {
_has_bits_[0] &= ~0x00000008u;
}
inline void ProJDDDZGameSendMahs::clear_cbleftcount() {
cbleftcount_ = 0;
clear_has_cbleftcount();
}
inline ::google::protobuf::int32 ProJDDDZGameSendMahs::cbleftcount() const {
return cbleftcount_;
}
inline void ProJDDDZGameSendMahs::set_cbleftcount(::google::protobuf::int32 value) {
set_has_cbleftcount();
cbleftcount_ = value;
}
// optional int32 offlineTag = 6;
inline bool ProJDDDZGameSendMahs::has_offlinetag() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ProJDDDZGameSendMahs::set_has_offlinetag() {
_has_bits_[0] |= 0x00000010u;
}
inline void ProJDDDZGameSendMahs::clear_has_offlinetag() {
_has_bits_[0] &= ~0x00000010u;
}
inline void ProJDDDZGameSendMahs::clear_offlinetag() {
offlinetag_ = 0;
clear_has_offlinetag();
}
inline ::google::protobuf::int32 ProJDDDZGameSendMahs::offlinetag() const {
return offlinetag_;
}
inline void ProJDDDZGameSendMahs::set_offlinetag(::google::protobuf::int32 value) {
set_has_offlinetag();
offlinetag_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameKingData
// optional int32 seat = 2;
inline bool ProJDDDZGameKingData::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameKingData::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameKingData::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameKingData::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameKingData::seat() const {
return seat_;
}
inline void ProJDDDZGameKingData::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// repeated int32 mahs = 3;
inline int ProJDDDZGameKingData::mahs_size() const {
return mahs_.size();
}
inline void ProJDDDZGameKingData::clear_mahs() {
mahs_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameKingData::mahs(int index) const {
return mahs_.Get(index);
}
inline void ProJDDDZGameKingData::set_mahs(int index, ::google::protobuf::int32 value) {
mahs_.Set(index, value);
}
inline void ProJDDDZGameKingData::add_mahs(::google::protobuf::int32 value) {
mahs_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameKingData::mahs() const {
return mahs_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameKingData::mutable_mahs() {
return &mahs_;
}
// repeated int32 downKingScore = 4;
inline int ProJDDDZGameKingData::downkingscore_size() const {
return downkingscore_.size();
}
inline void ProJDDDZGameKingData::clear_downkingscore() {
downkingscore_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameKingData::downkingscore(int index) const {
return downkingscore_.Get(index);
}
inline void ProJDDDZGameKingData::set_downkingscore(int index, ::google::protobuf::int32 value) {
downkingscore_.Set(index, value);
}
inline void ProJDDDZGameKingData::add_downkingscore(::google::protobuf::int32 value) {
downkingscore_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameKingData::downkingscore() const {
return downkingscore_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameKingData::mutable_downkingscore() {
return &downkingscore_;
}
// repeated int32 kingcount = 5;
inline int ProJDDDZGameKingData::kingcount_size() const {
return kingcount_.size();
}
inline void ProJDDDZGameKingData::clear_kingcount() {
kingcount_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameKingData::kingcount(int index) const {
return kingcount_.Get(index);
}
inline void ProJDDDZGameKingData::set_kingcount(int index, ::google::protobuf::int32 value) {
kingcount_.Set(index, value);
}
inline void ProJDDDZGameKingData::add_kingcount(::google::protobuf::int32 value) {
kingcount_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameKingData::kingcount() const {
return kingcount_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameKingData::mutable_kingcount() {
return &kingcount_;
}
// repeated int32 viceking = 6;
inline int ProJDDDZGameKingData::viceking_size() const {
return viceking_.size();
}
inline void ProJDDDZGameKingData::clear_viceking() {
viceking_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameKingData::viceking(int index) const {
return viceking_.Get(index);
}
inline void ProJDDDZGameKingData::set_viceking(int index, ::google::protobuf::int32 value) {
viceking_.Set(index, value);
}
inline void ProJDDDZGameKingData::add_viceking(::google::protobuf::int32 value) {
viceking_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameKingData::viceking() const {
return viceking_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameKingData::mutable_viceking() {
return &viceking_;
}
// optional .JDDDZSEND_TYPE notify_type = 7 [default = JDDDZ_NORMAL_SEND];
inline bool ProJDDDZGameKingData::has_notify_type() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ProJDDDZGameKingData::set_has_notify_type() {
_has_bits_[0] |= 0x00000020u;
}
inline void ProJDDDZGameKingData::clear_has_notify_type() {
_has_bits_[0] &= ~0x00000020u;
}
inline void ProJDDDZGameKingData::clear_notify_type() {
notify_type_ = 1;
clear_has_notify_type();
}
inline ::JDDDZSEND_TYPE ProJDDDZGameKingData::notify_type() const {
return static_cast< ::JDDDZSEND_TYPE >(notify_type_);
}
inline void ProJDDDZGameKingData::set_notify_type(::JDDDZSEND_TYPE value) {
assert(::JDDDZSEND_TYPE_IsValid(value));
set_has_notify_type();
notify_type_ = value;
}
// optional .JDDDZKIGN_TYPE king_type = 8 [default = JDDDZ_KING_UP];
inline bool ProJDDDZGameKingData::has_king_type() const {
return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ProJDDDZGameKingData::set_has_king_type() {
_has_bits_[0] |= 0x00000040u;
}
inline void ProJDDDZGameKingData::clear_has_king_type() {
_has_bits_[0] &= ~0x00000040u;
}
inline void ProJDDDZGameKingData::clear_king_type() {
king_type_ = 1;
clear_has_king_type();
}
inline ::JDDDZKIGN_TYPE ProJDDDZGameKingData::king_type() const {
return static_cast< ::JDDDZKIGN_TYPE >(king_type_);
}
inline void ProJDDDZGameKingData::set_king_type(::JDDDZKIGN_TYPE value) {
assert(::JDDDZKIGN_TYPE_IsValid(value));
set_has_king_type();
king_type_ = value;
}
// repeated int32 cbChongGuang = 9;
inline int ProJDDDZGameKingData::cbchongguang_size() const {
return cbchongguang_.size();
}
inline void ProJDDDZGameKingData::clear_cbchongguang() {
cbchongguang_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameKingData::cbchongguang(int index) const {
return cbchongguang_.Get(index);
}
inline void ProJDDDZGameKingData::set_cbchongguang(int index, ::google::protobuf::int32 value) {
cbchongguang_.Set(index, value);
}
inline void ProJDDDZGameKingData::add_cbchongguang(::google::protobuf::int32 value) {
cbchongguang_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameKingData::cbchongguang() const {
return cbchongguang_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameKingData::mutable_cbchongguang() {
return &cbchongguang_;
}
// repeated int32 cbBaWangKing = 10;
inline int ProJDDDZGameKingData::cbbawangking_size() const {
return cbbawangking_.size();
}
inline void ProJDDDZGameKingData::clear_cbbawangking() {
cbbawangking_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameKingData::cbbawangking(int index) const {
return cbbawangking_.Get(index);
}
inline void ProJDDDZGameKingData::set_cbbawangking(int index, ::google::protobuf::int32 value) {
cbbawangking_.Set(index, value);
}
inline void ProJDDDZGameKingData::add_cbbawangking(::google::protobuf::int32 value) {
cbbawangking_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameKingData::cbbawangking() const {
return cbbawangking_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameKingData::mutable_cbbawangking() {
return &cbbawangking_;
}
// -------------------------------------------------------------------
// ProJDDDZGameOutMahsResponse
// optional int32 seat = 2;
inline bool ProJDDDZGameOutMahsResponse::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameOutMahsResponse::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameOutMahsResponse::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameOutMahsResponse::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameOutMahsResponse::seat() const {
return seat_;
}
inline void ProJDDDZGameOutMahsResponse::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// repeated int32 outMahs = 3;
inline int ProJDDDZGameOutMahsResponse::outmahs_size() const {
return outmahs_.size();
}
inline void ProJDDDZGameOutMahsResponse::clear_outmahs() {
outmahs_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameOutMahsResponse::outmahs(int index) const {
return outmahs_.Get(index);
}
inline void ProJDDDZGameOutMahsResponse::set_outmahs(int index, ::google::protobuf::int32 value) {
outmahs_.Set(index, value);
}
inline void ProJDDDZGameOutMahsResponse::add_outmahs(::google::protobuf::int32 value) {
outmahs_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameOutMahsResponse::outmahs() const {
return outmahs_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameOutMahsResponse::mutable_outmahs() {
return &outmahs_;
}
// repeated int32 handmahs = 4;
inline int ProJDDDZGameOutMahsResponse::handmahs_size() const {
return handmahs_.size();
}
inline void ProJDDDZGameOutMahsResponse::clear_handmahs() {
handmahs_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameOutMahsResponse::handmahs(int index) const {
return handmahs_.Get(index);
}
inline void ProJDDDZGameOutMahsResponse::set_handmahs(int index, ::google::protobuf::int32 value) {
handmahs_.Set(index, value);
}
inline void ProJDDDZGameOutMahsResponse::add_handmahs(::google::protobuf::int32 value) {
handmahs_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameOutMahsResponse::handmahs() const {
return handmahs_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameOutMahsResponse::mutable_handmahs() {
return &handmahs_;
}
// optional int32 cardCount = 5;
inline bool ProJDDDZGameOutMahsResponse::has_cardcount() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ProJDDDZGameOutMahsResponse::set_has_cardcount() {
_has_bits_[0] |= 0x00000008u;
}
inline void ProJDDDZGameOutMahsResponse::clear_has_cardcount() {
_has_bits_[0] &= ~0x00000008u;
}
inline void ProJDDDZGameOutMahsResponse::clear_cardcount() {
cardcount_ = 0;
clear_has_cardcount();
}
inline ::google::protobuf::int32 ProJDDDZGameOutMahsResponse::cardcount() const {
return cardcount_;
}
inline void ProJDDDZGameOutMahsResponse::set_cardcount(::google::protobuf::int32 value) {
set_has_cardcount();
cardcount_ = value;
}
// optional int32 cardType = 6;
inline bool ProJDDDZGameOutMahsResponse::has_cardtype() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ProJDDDZGameOutMahsResponse::set_has_cardtype() {
_has_bits_[0] |= 0x00000010u;
}
inline void ProJDDDZGameOutMahsResponse::clear_has_cardtype() {
_has_bits_[0] &= ~0x00000010u;
}
inline void ProJDDDZGameOutMahsResponse::clear_cardtype() {
cardtype_ = 0;
clear_has_cardtype();
}
inline ::google::protobuf::int32 ProJDDDZGameOutMahsResponse::cardtype() const {
return cardtype_;
}
inline void ProJDDDZGameOutMahsResponse::set_cardtype(::google::protobuf::int32 value) {
set_has_cardtype();
cardtype_ = value;
}
// repeated int32 noChangeMahs = 7;
inline int ProJDDDZGameOutMahsResponse::nochangemahs_size() const {
return nochangemahs_.size();
}
inline void ProJDDDZGameOutMahsResponse::clear_nochangemahs() {
nochangemahs_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameOutMahsResponse::nochangemahs(int index) const {
return nochangemahs_.Get(index);
}
inline void ProJDDDZGameOutMahsResponse::set_nochangemahs(int index, ::google::protobuf::int32 value) {
nochangemahs_.Set(index, value);
}
inline void ProJDDDZGameOutMahsResponse::add_nochangemahs(::google::protobuf::int32 value) {
nochangemahs_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameOutMahsResponse::nochangemahs() const {
return nochangemahs_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameOutMahsResponse::mutable_nochangemahs() {
return &nochangemahs_;
}
// -------------------------------------------------------------------
// ProJDDDZGameTimerPower
// optional int32 seat = 2;
inline bool ProJDDDZGameTimerPower::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameTimerPower::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameTimerPower::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameTimerPower::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameTimerPower::seat() const {
return seat_;
}
inline void ProJDDDZGameTimerPower::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// optional int32 time = 3;
inline bool ProJDDDZGameTimerPower::has_time() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameTimerPower::set_has_time() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameTimerPower::clear_has_time() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameTimerPower::clear_time() {
time_ = 0;
clear_has_time();
}
inline ::google::protobuf::int32 ProJDDDZGameTimerPower::time() const {
return time_;
}
inline void ProJDDDZGameTimerPower::set_time(::google::protobuf::int32 value) {
set_has_time();
time_ = value;
}
// optional int32 outcardTime = 4;
inline bool ProJDDDZGameTimerPower::has_outcardtime() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ProJDDDZGameTimerPower::set_has_outcardtime() {
_has_bits_[0] |= 0x00000004u;
}
inline void ProJDDDZGameTimerPower::clear_has_outcardtime() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ProJDDDZGameTimerPower::clear_outcardtime() {
outcardtime_ = 0;
clear_has_outcardtime();
}
inline ::google::protobuf::int32 ProJDDDZGameTimerPower::outcardtime() const {
return outcardtime_;
}
inline void ProJDDDZGameTimerPower::set_outcardtime(::google::protobuf::int32 value) {
set_has_outcardtime();
outcardtime_ = value;
}
// optional int32 lastCardType = 5;
inline bool ProJDDDZGameTimerPower::has_lastcardtype() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ProJDDDZGameTimerPower::set_has_lastcardtype() {
_has_bits_[0] |= 0x00000008u;
}
inline void ProJDDDZGameTimerPower::clear_has_lastcardtype() {
_has_bits_[0] &= ~0x00000008u;
}
inline void ProJDDDZGameTimerPower::clear_lastcardtype() {
lastcardtype_ = 0;
clear_has_lastcardtype();
}
inline ::google::protobuf::int32 ProJDDDZGameTimerPower::lastcardtype() const {
return lastcardtype_;
}
inline void ProJDDDZGameTimerPower::set_lastcardtype(::google::protobuf::int32 value) {
set_has_lastcardtype();
lastcardtype_ = value;
}
// optional int32 lastPoint = 6;
inline bool ProJDDDZGameTimerPower::has_lastpoint() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ProJDDDZGameTimerPower::set_has_lastpoint() {
_has_bits_[0] |= 0x00000010u;
}
inline void ProJDDDZGameTimerPower::clear_has_lastpoint() {
_has_bits_[0] &= ~0x00000010u;
}
inline void ProJDDDZGameTimerPower::clear_lastpoint() {
lastpoint_ = 0;
clear_has_lastpoint();
}
inline ::google::protobuf::int32 ProJDDDZGameTimerPower::lastpoint() const {
return lastpoint_;
}
inline void ProJDDDZGameTimerPower::set_lastpoint(::google::protobuf::int32 value) {
set_has_lastpoint();
lastpoint_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameOperateNotify
// optional int32 resumeSeat = 2;
inline bool ProJDDDZGameOperateNotify::has_resumeseat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameOperateNotify::set_has_resumeseat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameOperateNotify::clear_has_resumeseat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameOperateNotify::clear_resumeseat() {
resumeseat_ = 0;
clear_has_resumeseat();
}
inline ::google::protobuf::int32 ProJDDDZGameOperateNotify::resumeseat() const {
return resumeseat_;
}
inline void ProJDDDZGameOperateNotify::set_resumeseat(::google::protobuf::int32 value) {
set_has_resumeseat();
resumeseat_ = value;
}
// optional int32 ActionMask = 3;
inline bool ProJDDDZGameOperateNotify::has_actionmask() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameOperateNotify::set_has_actionmask() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameOperateNotify::clear_has_actionmask() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameOperateNotify::clear_actionmask() {
actionmask_ = 0;
clear_has_actionmask();
}
inline ::google::protobuf::int32 ProJDDDZGameOperateNotify::actionmask() const {
return actionmask_;
}
inline void ProJDDDZGameOperateNotify::set_actionmask(::google::protobuf::int32 value) {
set_has_actionmask();
actionmask_ = value;
}
// optional int32 ActionCard = 4;
inline bool ProJDDDZGameOperateNotify::has_actioncard() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ProJDDDZGameOperateNotify::set_has_actioncard() {
_has_bits_[0] |= 0x00000004u;
}
inline void ProJDDDZGameOperateNotify::clear_has_actioncard() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ProJDDDZGameOperateNotify::clear_actioncard() {
actioncard_ = 0;
clear_has_actioncard();
}
inline ::google::protobuf::int32 ProJDDDZGameOperateNotify::actioncard() const {
return actioncard_;
}
inline void ProJDDDZGameOperateNotify::set_actioncard(::google::protobuf::int32 value) {
set_has_actioncard();
actioncard_ = value;
}
// optional int32 time = 5;
inline bool ProJDDDZGameOperateNotify::has_time() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ProJDDDZGameOperateNotify::set_has_time() {
_has_bits_[0] |= 0x00000008u;
}
inline void ProJDDDZGameOperateNotify::clear_has_time() {
_has_bits_[0] &= ~0x00000008u;
}
inline void ProJDDDZGameOperateNotify::clear_time() {
time_ = 0;
clear_has_time();
}
inline ::google::protobuf::int32 ProJDDDZGameOperateNotify::time() const {
return time_;
}
inline void ProJDDDZGameOperateNotify::set_time(::google::protobuf::int32 value) {
set_has_time();
time_ = value;
}
// optional int32 operateseat = 6;
inline bool ProJDDDZGameOperateNotify::has_operateseat() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ProJDDDZGameOperateNotify::set_has_operateseat() {
_has_bits_[0] |= 0x00000010u;
}
inline void ProJDDDZGameOperateNotify::clear_has_operateseat() {
_has_bits_[0] &= ~0x00000010u;
}
inline void ProJDDDZGameOperateNotify::clear_operateseat() {
operateseat_ = 0;
clear_has_operateseat();
}
inline ::google::protobuf::int32 ProJDDDZGameOperateNotify::operateseat() const {
return operateseat_;
}
inline void ProJDDDZGameOperateNotify::set_operateseat(::google::protobuf::int32 value) {
set_has_operateseat();
operateseat_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameOperateResult
// optional int32 wOperateUser = 2;
inline bool ProJDDDZGameOperateResult::has_woperateuser() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameOperateResult::set_has_woperateuser() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameOperateResult::clear_has_woperateuser() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameOperateResult::clear_woperateuser() {
woperateuser_ = 0;
clear_has_woperateuser();
}
inline ::google::protobuf::int32 ProJDDDZGameOperateResult::woperateuser() const {
return woperateuser_;
}
inline void ProJDDDZGameOperateResult::set_woperateuser(::google::protobuf::int32 value) {
set_has_woperateuser();
woperateuser_ = value;
}
// optional int32 wProvideUser = 3;
inline bool ProJDDDZGameOperateResult::has_wprovideuser() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameOperateResult::set_has_wprovideuser() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameOperateResult::clear_has_wprovideuser() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameOperateResult::clear_wprovideuser() {
wprovideuser_ = 0;
clear_has_wprovideuser();
}
inline ::google::protobuf::int32 ProJDDDZGameOperateResult::wprovideuser() const {
return wprovideuser_;
}
inline void ProJDDDZGameOperateResult::set_wprovideuser(::google::protobuf::int32 value) {
set_has_wprovideuser();
wprovideuser_ = value;
}
// optional int32 wOperateCode = 4;
inline bool ProJDDDZGameOperateResult::has_woperatecode() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ProJDDDZGameOperateResult::set_has_woperatecode() {
_has_bits_[0] |= 0x00000004u;
}
inline void ProJDDDZGameOperateResult::clear_has_woperatecode() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ProJDDDZGameOperateResult::clear_woperatecode() {
woperatecode_ = 0;
clear_has_woperatecode();
}
inline ::google::protobuf::int32 ProJDDDZGameOperateResult::woperatecode() const {
return woperatecode_;
}
inline void ProJDDDZGameOperateResult::set_woperatecode(::google::protobuf::int32 value) {
set_has_woperatecode();
woperatecode_ = value;
}
// optional int32 cbOperateCard = 5;
inline bool ProJDDDZGameOperateResult::has_cboperatecard() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ProJDDDZGameOperateResult::set_has_cboperatecard() {
_has_bits_[0] |= 0x00000008u;
}
inline void ProJDDDZGameOperateResult::clear_has_cboperatecard() {
_has_bits_[0] &= ~0x00000008u;
}
inline void ProJDDDZGameOperateResult::clear_cboperatecard() {
cboperatecard_ = 0;
clear_has_cboperatecard();
}
inline ::google::protobuf::int32 ProJDDDZGameOperateResult::cboperatecard() const {
return cboperatecard_;
}
inline void ProJDDDZGameOperateResult::set_cboperatecard(::google::protobuf::int32 value) {
set_has_cboperatecard();
cboperatecard_ = value;
}
// repeated int32 handmahs = 6;
inline int ProJDDDZGameOperateResult::handmahs_size() const {
return handmahs_.size();
}
inline void ProJDDDZGameOperateResult::clear_handmahs() {
handmahs_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameOperateResult::handmahs(int index) const {
return handmahs_.Get(index);
}
inline void ProJDDDZGameOperateResult::set_handmahs(int index, ::google::protobuf::int32 value) {
handmahs_.Set(index, value);
}
inline void ProJDDDZGameOperateResult::add_handmahs(::google::protobuf::int32 value) {
handmahs_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameOperateResult::handmahs() const {
return handmahs_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameOperateResult::mutable_handmahs() {
return &handmahs_;
}
// optional int32 handcount = 7;
inline bool ProJDDDZGameOperateResult::has_handcount() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ProJDDDZGameOperateResult::set_has_handcount() {
_has_bits_[0] |= 0x00000020u;
}
inline void ProJDDDZGameOperateResult::clear_has_handcount() {
_has_bits_[0] &= ~0x00000020u;
}
inline void ProJDDDZGameOperateResult::clear_handcount() {
handcount_ = 0;
clear_has_handcount();
}
inline ::google::protobuf::int32 ProJDDDZGameOperateResult::handcount() const {
return handcount_;
}
inline void ProJDDDZGameOperateResult::set_handcount(::google::protobuf::int32 value) {
set_has_handcount();
handcount_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameOperateRequest
// optional int32 seat = 2;
inline bool ProJDDDZGameOperateRequest::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameOperateRequest::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameOperateRequest::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameOperateRequest::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameOperateRequest::seat() const {
return seat_;
}
inline void ProJDDDZGameOperateRequest::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// optional int32 wOperateCode = 3;
inline bool ProJDDDZGameOperateRequest::has_woperatecode() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameOperateRequest::set_has_woperatecode() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameOperateRequest::clear_has_woperatecode() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameOperateRequest::clear_woperatecode() {
woperatecode_ = 0;
clear_has_woperatecode();
}
inline ::google::protobuf::int32 ProJDDDZGameOperateRequest::woperatecode() const {
return woperatecode_;
}
inline void ProJDDDZGameOperateRequest::set_woperatecode(::google::protobuf::int32 value) {
set_has_woperatecode();
woperatecode_ = value;
}
// optional int32 cbOperateCard = 4;
inline bool ProJDDDZGameOperateRequest::has_cboperatecard() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ProJDDDZGameOperateRequest::set_has_cboperatecard() {
_has_bits_[0] |= 0x00000004u;
}
inline void ProJDDDZGameOperateRequest::clear_has_cboperatecard() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ProJDDDZGameOperateRequest::clear_cboperatecard() {
cboperatecard_ = 0;
clear_has_cboperatecard();
}
inline ::google::protobuf::int32 ProJDDDZGameOperateRequest::cboperatecard() const {
return cboperatecard_;
}
inline void ProJDDDZGameOperateRequest::set_cboperatecard(::google::protobuf::int32 value) {
set_has_cboperatecard();
cboperatecard_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameTrust
// optional int32 seat = 2;
inline bool ProJDDDZGameTrust::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameTrust::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameTrust::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameTrust::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameTrust::seat() const {
return seat_;
}
inline void ProJDDDZGameTrust::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// optional bool isTrust = 3;
inline bool ProJDDDZGameTrust::has_istrust() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameTrust::set_has_istrust() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameTrust::clear_has_istrust() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameTrust::clear_istrust() {
istrust_ = false;
clear_has_istrust();
}
inline bool ProJDDDZGameTrust::istrust() const {
return istrust_;
}
inline void ProJDDDZGameTrust::set_istrust(bool value) {
set_has_istrust();
istrust_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameOutMahRequest
// optional int32 seat = 2;
inline bool ProJDDDZGameOutMahRequest::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameOutMahRequest::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameOutMahRequest::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameOutMahRequest::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameOutMahRequest::seat() const {
return seat_;
}
inline void ProJDDDZGameOutMahRequest::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// repeated int32 outMahs = 3;
inline int ProJDDDZGameOutMahRequest::outmahs_size() const {
return outmahs_.size();
}
inline void ProJDDDZGameOutMahRequest::clear_outmahs() {
outmahs_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameOutMahRequest::outmahs(int index) const {
return outmahs_.Get(index);
}
inline void ProJDDDZGameOutMahRequest::set_outmahs(int index, ::google::protobuf::int32 value) {
outmahs_.Set(index, value);
}
inline void ProJDDDZGameOutMahRequest::add_outmahs(::google::protobuf::int32 value) {
outmahs_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameOutMahRequest::outmahs() const {
return outmahs_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameOutMahRequest::mutable_outmahs() {
return &outmahs_;
}
// repeated int32 noChangeMahs = 4;
inline int ProJDDDZGameOutMahRequest::nochangemahs_size() const {
return nochangemahs_.size();
}
inline void ProJDDDZGameOutMahRequest::clear_nochangemahs() {
nochangemahs_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameOutMahRequest::nochangemahs(int index) const {
return nochangemahs_.Get(index);
}
inline void ProJDDDZGameOutMahRequest::set_nochangemahs(int index, ::google::protobuf::int32 value) {
nochangemahs_.Set(index, value);
}
inline void ProJDDDZGameOutMahRequest::add_nochangemahs(::google::protobuf::int32 value) {
nochangemahs_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameOutMahRequest::nochangemahs() const {
return nochangemahs_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameOutMahRequest::mutable_nochangemahs() {
return &nochangemahs_;
}
// -------------------------------------------------------------------
// ProJDDDZGameCatchCard
// optional int32 seat = 2;
inline bool ProJDDDZGameCatchCard::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameCatchCard::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameCatchCard::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameCatchCard::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameCatchCard::seat() const {
return seat_;
}
inline void ProJDDDZGameCatchCard::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// optional int32 cbCardData = 3;
inline bool ProJDDDZGameCatchCard::has_cbcarddata() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameCatchCard::set_has_cbcarddata() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameCatchCard::clear_has_cbcarddata() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameCatchCard::clear_cbcarddata() {
cbcarddata_ = 0;
clear_has_cbcarddata();
}
inline ::google::protobuf::int32 ProJDDDZGameCatchCard::cbcarddata() const {
return cbcarddata_;
}
inline void ProJDDDZGameCatchCard::set_cbcarddata(::google::protobuf::int32 value) {
set_has_cbcarddata();
cbcarddata_ = value;
}
// optional int32 wActionMask = 4;
inline bool ProJDDDZGameCatchCard::has_wactionmask() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ProJDDDZGameCatchCard::set_has_wactionmask() {
_has_bits_[0] |= 0x00000004u;
}
inline void ProJDDDZGameCatchCard::clear_has_wactionmask() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ProJDDDZGameCatchCard::clear_wactionmask() {
wactionmask_ = 0;
clear_has_wactionmask();
}
inline ::google::protobuf::int32 ProJDDDZGameCatchCard::wactionmask() const {
return wactionmask_;
}
inline void ProJDDDZGameCatchCard::set_wactionmask(::google::protobuf::int32 value) {
set_has_wactionmask();
wactionmask_ = value;
}
// optional bool cbIsNotGang = 5;
inline bool ProJDDDZGameCatchCard::has_cbisnotgang() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ProJDDDZGameCatchCard::set_has_cbisnotgang() {
_has_bits_[0] |= 0x00000008u;
}
inline void ProJDDDZGameCatchCard::clear_has_cbisnotgang() {
_has_bits_[0] &= ~0x00000008u;
}
inline void ProJDDDZGameCatchCard::clear_cbisnotgang() {
cbisnotgang_ = false;
clear_has_cbisnotgang();
}
inline bool ProJDDDZGameCatchCard::cbisnotgang() const {
return cbisnotgang_;
}
inline void ProJDDDZGameCatchCard::set_cbisnotgang(bool value) {
set_has_cbisnotgang();
cbisnotgang_ = value;
}
// optional int32 cbLeftCount = 6;
inline bool ProJDDDZGameCatchCard::has_cbleftcount() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ProJDDDZGameCatchCard::set_has_cbleftcount() {
_has_bits_[0] |= 0x00000010u;
}
inline void ProJDDDZGameCatchCard::clear_has_cbleftcount() {
_has_bits_[0] &= ~0x00000010u;
}
inline void ProJDDDZGameCatchCard::clear_cbleftcount() {
cbleftcount_ = 0;
clear_has_cbleftcount();
}
inline ::google::protobuf::int32 ProJDDDZGameCatchCard::cbleftcount() const {
return cbleftcount_;
}
inline void ProJDDDZGameCatchCard::set_cbleftcount(::google::protobuf::int32 value) {
set_has_cbleftcount();
cbleftcount_ = value;
}
// -------------------------------------------------------------------
// JDDDZMahList
// repeated int32 Mahs = 1;
inline int JDDDZMahList::mahs_size() const {
return mahs_.size();
}
inline void JDDDZMahList::clear_mahs() {
mahs_.Clear();
}
inline ::google::protobuf::int32 JDDDZMahList::mahs(int index) const {
return mahs_.Get(index);
}
inline void JDDDZMahList::set_mahs(int index, ::google::protobuf::int32 value) {
mahs_.Set(index, value);
}
inline void JDDDZMahList::add_mahs(::google::protobuf::int32 value) {
mahs_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
JDDDZMahList::mahs() const {
return mahs_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
JDDDZMahList::mutable_mahs() {
return &mahs_;
}
// -------------------------------------------------------------------
// JDDDZScoreList
// repeated int32 roundScore = 1;
inline int JDDDZScoreList::roundscore_size() const {
return roundscore_.size();
}
inline void JDDDZScoreList::clear_roundscore() {
roundscore_.Clear();
}
inline ::google::protobuf::int32 JDDDZScoreList::roundscore(int index) const {
return roundscore_.Get(index);
}
inline void JDDDZScoreList::set_roundscore(int index, ::google::protobuf::int32 value) {
roundscore_.Set(index, value);
}
inline void JDDDZScoreList::add_roundscore(::google::protobuf::int32 value) {
roundscore_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
JDDDZScoreList::roundscore() const {
return roundscore_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
JDDDZScoreList::mutable_roundscore() {
return &roundscore_;
}
// -------------------------------------------------------------------
// JDDDZAwardList
// optional int32 seat = 1;
inline bool JDDDZAwardList::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void JDDDZAwardList::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void JDDDZAwardList::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void JDDDZAwardList::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 JDDDZAwardList::seat() const {
return seat_;
}
inline void JDDDZAwardList::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// repeated int32 CardsData = 2;
inline int JDDDZAwardList::cardsdata_size() const {
return cardsdata_.size();
}
inline void JDDDZAwardList::clear_cardsdata() {
cardsdata_.Clear();
}
inline ::google::protobuf::int32 JDDDZAwardList::cardsdata(int index) const {
return cardsdata_.Get(index);
}
inline void JDDDZAwardList::set_cardsdata(int index, ::google::protobuf::int32 value) {
cardsdata_.Set(index, value);
}
inline void JDDDZAwardList::add_cardsdata(::google::protobuf::int32 value) {
cardsdata_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
JDDDZAwardList::cardsdata() const {
return cardsdata_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
JDDDZAwardList::mutable_cardsdata() {
return &cardsdata_;
}
// optional int32 awardScore = 3;
inline bool JDDDZAwardList::has_awardscore() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void JDDDZAwardList::set_has_awardscore() {
_has_bits_[0] |= 0x00000004u;
}
inline void JDDDZAwardList::clear_has_awardscore() {
_has_bits_[0] &= ~0x00000004u;
}
inline void JDDDZAwardList::clear_awardscore() {
awardscore_ = 0;
clear_has_awardscore();
}
inline ::google::protobuf::int32 JDDDZAwardList::awardscore() const {
return awardscore_;
}
inline void JDDDZAwardList::set_awardscore(::google::protobuf::int32 value) {
set_has_awardscore();
awardscore_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameEnd
// optional int32 lGameTax = 2;
inline bool ProJDDDZGameEnd::has_lgametax() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameEnd::set_has_lgametax() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameEnd::clear_has_lgametax() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameEnd::clear_lgametax() {
lgametax_ = 0;
clear_has_lgametax();
}
inline ::google::protobuf::int32 ProJDDDZGameEnd::lgametax() const {
return lgametax_;
}
inline void ProJDDDZGameEnd::set_lgametax(::google::protobuf::int32 value) {
set_has_lgametax();
lgametax_ = value;
}
// repeated int32 cbChongGuang = 3;
inline int ProJDDDZGameEnd::cbchongguang_size() const {
return cbchongguang_.size();
}
inline void ProJDDDZGameEnd::clear_cbchongguang() {
cbchongguang_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameEnd::cbchongguang(int index) const {
return cbchongguang_.Get(index);
}
inline void ProJDDDZGameEnd::set_cbchongguang(int index, ::google::protobuf::int32 value) {
cbchongguang_.Set(index, value);
}
inline void ProJDDDZGameEnd::add_cbchongguang(::google::protobuf::int32 value) {
cbchongguang_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameEnd::cbchongguang() const {
return cbchongguang_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameEnd::mutable_cbchongguang() {
return &cbchongguang_;
}
// repeated int32 cbBaWangKing = 4;
inline int ProJDDDZGameEnd::cbbawangking_size() const {
return cbbawangking_.size();
}
inline void ProJDDDZGameEnd::clear_cbbawangking() {
cbbawangking_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameEnd::cbbawangking(int index) const {
return cbbawangking_.Get(index);
}
inline void ProJDDDZGameEnd::set_cbbawangking(int index, ::google::protobuf::int32 value) {
cbbawangking_.Set(index, value);
}
inline void ProJDDDZGameEnd::add_cbbawangking(::google::protobuf::int32 value) {
cbbawangking_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameEnd::cbbawangking() const {
return cbbawangking_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameEnd::mutable_cbbawangking() {
return &cbbawangking_;
}
// optional int32 wProvideUser = 5;
inline bool ProJDDDZGameEnd::has_wprovideuser() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ProJDDDZGameEnd::set_has_wprovideuser() {
_has_bits_[0] |= 0x00000008u;
}
inline void ProJDDDZGameEnd::clear_has_wprovideuser() {
_has_bits_[0] &= ~0x00000008u;
}
inline void ProJDDDZGameEnd::clear_wprovideuser() {
wprovideuser_ = 0;
clear_has_wprovideuser();
}
inline ::google::protobuf::int32 ProJDDDZGameEnd::wprovideuser() const {
return wprovideuser_;
}
inline void ProJDDDZGameEnd::set_wprovideuser(::google::protobuf::int32 value) {
set_has_wprovideuser();
wprovideuser_ = value;
}
// optional int32 cbChiHuCard = 6;
inline bool ProJDDDZGameEnd::has_cbchihucard() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ProJDDDZGameEnd::set_has_cbchihucard() {
_has_bits_[0] |= 0x00000010u;
}
inline void ProJDDDZGameEnd::clear_has_cbchihucard() {
_has_bits_[0] &= ~0x00000010u;
}
inline void ProJDDDZGameEnd::clear_cbchihucard() {
cbchihucard_ = 0;
clear_has_cbchihucard();
}
inline ::google::protobuf::int32 ProJDDDZGameEnd::cbchihucard() const {
return cbchihucard_;
}
inline void ProJDDDZGameEnd::set_cbchihucard(::google::protobuf::int32 value) {
set_has_cbchihucard();
cbchihucard_ = value;
}
// repeated int32 dwChiHuKind = 7;
inline int ProJDDDZGameEnd::dwchihukind_size() const {
return dwchihukind_.size();
}
inline void ProJDDDZGameEnd::clear_dwchihukind() {
dwchihukind_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameEnd::dwchihukind(int index) const {
return dwchihukind_.Get(index);
}
inline void ProJDDDZGameEnd::set_dwchihukind(int index, ::google::protobuf::int32 value) {
dwchihukind_.Set(index, value);
}
inline void ProJDDDZGameEnd::add_dwchihukind(::google::protobuf::int32 value) {
dwchihukind_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameEnd::dwchihukind() const {
return dwchihukind_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameEnd::mutable_dwchihukind() {
return &dwchihukind_;
}
// repeated int32 dwChiHuRight = 8;
inline int ProJDDDZGameEnd::dwchihuright_size() const {
return dwchihuright_.size();
}
inline void ProJDDDZGameEnd::clear_dwchihuright() {
dwchihuright_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameEnd::dwchihuright(int index) const {
return dwchihuright_.Get(index);
}
inline void ProJDDDZGameEnd::set_dwchihuright(int index, ::google::protobuf::int32 value) {
dwchihuright_.Set(index, value);
}
inline void ProJDDDZGameEnd::add_dwchihuright(::google::protobuf::int32 value) {
dwchihuright_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameEnd::dwchihuright() const {
return dwchihuright_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameEnd::mutable_dwchihuright() {
return &dwchihuright_;
}
// repeated int32 lTotaslGameScore = 9;
inline int ProJDDDZGameEnd::ltotaslgamescore_size() const {
return ltotaslgamescore_.size();
}
inline void ProJDDDZGameEnd::clear_ltotaslgamescore() {
ltotaslgamescore_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameEnd::ltotaslgamescore(int index) const {
return ltotaslgamescore_.Get(index);
}
inline void ProJDDDZGameEnd::set_ltotaslgamescore(int index, ::google::protobuf::int32 value) {
ltotaslgamescore_.Set(index, value);
}
inline void ProJDDDZGameEnd::add_ltotaslgamescore(::google::protobuf::int32 value) {
ltotaslgamescore_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameEnd::ltotaslgamescore() const {
return ltotaslgamescore_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameEnd::mutable_ltotaslgamescore() {
return <otaslgamescore_;
}
// repeated int32 lCurrentGameScore = 10;
inline int ProJDDDZGameEnd::lcurrentgamescore_size() const {
return lcurrentgamescore_.size();
}
inline void ProJDDDZGameEnd::clear_lcurrentgamescore() {
lcurrentgamescore_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameEnd::lcurrentgamescore(int index) const {
return lcurrentgamescore_.Get(index);
}
inline void ProJDDDZGameEnd::set_lcurrentgamescore(int index, ::google::protobuf::int32 value) {
lcurrentgamescore_.Set(index, value);
}
inline void ProJDDDZGameEnd::add_lcurrentgamescore(::google::protobuf::int32 value) {
lcurrentgamescore_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameEnd::lcurrentgamescore() const {
return lcurrentgamescore_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameEnd::mutable_lcurrentgamescore() {
return &lcurrentgamescore_;
}
// repeated int32 lCurrentPointScore = 11;
inline int ProJDDDZGameEnd::lcurrentpointscore_size() const {
return lcurrentpointscore_.size();
}
inline void ProJDDDZGameEnd::clear_lcurrentpointscore() {
lcurrentpointscore_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameEnd::lcurrentpointscore(int index) const {
return lcurrentpointscore_.Get(index);
}
inline void ProJDDDZGameEnd::set_lcurrentpointscore(int index, ::google::protobuf::int32 value) {
lcurrentpointscore_.Set(index, value);
}
inline void ProJDDDZGameEnd::add_lcurrentpointscore(::google::protobuf::int32 value) {
lcurrentpointscore_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameEnd::lcurrentpointscore() const {
return lcurrentpointscore_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameEnd::mutable_lcurrentpointscore() {
return &lcurrentpointscore_;
}
// repeated int32 lAttachScore = 12;
inline int ProJDDDZGameEnd::lattachscore_size() const {
return lattachscore_.size();
}
inline void ProJDDDZGameEnd::clear_lattachscore() {
lattachscore_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameEnd::lattachscore(int index) const {
return lattachscore_.Get(index);
}
inline void ProJDDDZGameEnd::set_lattachscore(int index, ::google::protobuf::int32 value) {
lattachscore_.Set(index, value);
}
inline void ProJDDDZGameEnd::add_lattachscore(::google::protobuf::int32 value) {
lattachscore_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameEnd::lattachscore() const {
return lattachscore_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameEnd::mutable_lattachscore() {
return &lattachscore_;
}
// repeated .JDDDZMahList cbHandCardData = 13;
inline int ProJDDDZGameEnd::cbhandcarddata_size() const {
return cbhandcarddata_.size();
}
inline void ProJDDDZGameEnd::clear_cbhandcarddata() {
cbhandcarddata_.Clear();
}
inline const ::JDDDZMahList& ProJDDDZGameEnd::cbhandcarddata(int index) const {
return cbhandcarddata_.Get(index);
}
inline ::JDDDZMahList* ProJDDDZGameEnd::mutable_cbhandcarddata(int index) {
return cbhandcarddata_.Mutable(index);
}
inline ::JDDDZMahList* ProJDDDZGameEnd::add_cbhandcarddata() {
return cbhandcarddata_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::JDDDZMahList >&
ProJDDDZGameEnd::cbhandcarddata() const {
return cbhandcarddata_;
}
inline ::google::protobuf::RepeatedPtrField< ::JDDDZMahList >*
ProJDDDZGameEnd::mutable_cbhandcarddata() {
return &cbhandcarddata_;
}
// repeated .JDDDZAwardList cbAwardCardData = 14;
inline int ProJDDDZGameEnd::cbawardcarddata_size() const {
return cbawardcarddata_.size();
}
inline void ProJDDDZGameEnd::clear_cbawardcarddata() {
cbawardcarddata_.Clear();
}
inline const ::JDDDZAwardList& ProJDDDZGameEnd::cbawardcarddata(int index) const {
return cbawardcarddata_.Get(index);
}
inline ::JDDDZAwardList* ProJDDDZGameEnd::mutable_cbawardcarddata(int index) {
return cbawardcarddata_.Mutable(index);
}
inline ::JDDDZAwardList* ProJDDDZGameEnd::add_cbawardcarddata() {
return cbawardcarddata_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::JDDDZAwardList >&
ProJDDDZGameEnd::cbawardcarddata() const {
return cbawardcarddata_;
}
inline ::google::protobuf::RepeatedPtrField< ::JDDDZAwardList >*
ProJDDDZGameEnd::mutable_cbawardcarddata() {
return &cbawardcarddata_;
}
// repeated int32 lOnlyWinScore = 15;
inline int ProJDDDZGameEnd::lonlywinscore_size() const {
return lonlywinscore_.size();
}
inline void ProJDDDZGameEnd::clear_lonlywinscore() {
lonlywinscore_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameEnd::lonlywinscore(int index) const {
return lonlywinscore_.Get(index);
}
inline void ProJDDDZGameEnd::set_lonlywinscore(int index, ::google::protobuf::int32 value) {
lonlywinscore_.Set(index, value);
}
inline void ProJDDDZGameEnd::add_lonlywinscore(::google::protobuf::int32 value) {
lonlywinscore_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameEnd::lonlywinscore() const {
return lonlywinscore_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameEnd::mutable_lonlywinscore() {
return &lonlywinscore_;
}
// optional bool bRoundEnd = 16;
inline bool ProJDDDZGameEnd::has_broundend() const {
return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void ProJDDDZGameEnd::set_has_broundend() {
_has_bits_[0] |= 0x00004000u;
}
inline void ProJDDDZGameEnd::clear_has_broundend() {
_has_bits_[0] &= ~0x00004000u;
}
inline void ProJDDDZGameEnd::clear_broundend() {
broundend_ = false;
clear_has_broundend();
}
inline bool ProJDDDZGameEnd::broundend() const {
return broundend_;
}
inline void ProJDDDZGameEnd::set_broundend(bool value) {
set_has_broundend();
broundend_ = value;
}
// repeated int32 lHuiTouScore = 17;
inline int ProJDDDZGameEnd::lhuitouscore_size() const {
return lhuitouscore_.size();
}
inline void ProJDDDZGameEnd::clear_lhuitouscore() {
lhuitouscore_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameEnd::lhuitouscore(int index) const {
return lhuitouscore_.Get(index);
}
inline void ProJDDDZGameEnd::set_lhuitouscore(int index, ::google::protobuf::int32 value) {
lhuitouscore_.Set(index, value);
}
inline void ProJDDDZGameEnd::add_lhuitouscore(::google::protobuf::int32 value) {
lhuitouscore_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameEnd::lhuitouscore() const {
return lhuitouscore_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameEnd::mutable_lhuitouscore() {
return &lhuitouscore_;
}
// optional bool bZhuangWin = 18;
inline bool ProJDDDZGameEnd::has_bzhuangwin() const {
return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void ProJDDDZGameEnd::set_has_bzhuangwin() {
_has_bits_[0] |= 0x00010000u;
}
inline void ProJDDDZGameEnd::clear_has_bzhuangwin() {
_has_bits_[0] &= ~0x00010000u;
}
inline void ProJDDDZGameEnd::clear_bzhuangwin() {
bzhuangwin_ = false;
clear_has_bzhuangwin();
}
inline bool ProJDDDZGameEnd::bzhuangwin() const {
return bzhuangwin_;
}
inline void ProJDDDZGameEnd::set_bzhuangwin(bool value) {
set_has_bzhuangwin();
bzhuangwin_ = value;
}
// repeated int32 cbJiangMaCardData = 19;
inline int ProJDDDZGameEnd::cbjiangmacarddata_size() const {
return cbjiangmacarddata_.size();
}
inline void ProJDDDZGameEnd::clear_cbjiangmacarddata() {
cbjiangmacarddata_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameEnd::cbjiangmacarddata(int index) const {
return cbjiangmacarddata_.Get(index);
}
inline void ProJDDDZGameEnd::set_cbjiangmacarddata(int index, ::google::protobuf::int32 value) {
cbjiangmacarddata_.Set(index, value);
}
inline void ProJDDDZGameEnd::add_cbjiangmacarddata(::google::protobuf::int32 value) {
cbjiangmacarddata_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameEnd::cbjiangmacarddata() const {
return cbjiangmacarddata_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameEnd::mutable_cbjiangmacarddata() {
return &cbjiangmacarddata_;
}
// repeated .JDDDZScoreList detailedScores = 20;
inline int ProJDDDZGameEnd::detailedscores_size() const {
return detailedscores_.size();
}
inline void ProJDDDZGameEnd::clear_detailedscores() {
detailedscores_.Clear();
}
inline const ::JDDDZScoreList& ProJDDDZGameEnd::detailedscores(int index) const {
return detailedscores_.Get(index);
}
inline ::JDDDZScoreList* ProJDDDZGameEnd::mutable_detailedscores(int index) {
return detailedscores_.Mutable(index);
}
inline ::JDDDZScoreList* ProJDDDZGameEnd::add_detailedscores() {
return detailedscores_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::JDDDZScoreList >&
ProJDDDZGameEnd::detailedscores() const {
return detailedscores_;
}
inline ::google::protobuf::RepeatedPtrField< ::JDDDZScoreList >*
ProJDDDZGameEnd::mutable_detailedscores() {
return &detailedscores_;
}
// -------------------------------------------------------------------
// ProJDDDZGameQuickSoundRequest
// optional int32 desk_id = 2;
inline bool ProJDDDZGameQuickSoundRequest::has_desk_id() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameQuickSoundRequest::set_has_desk_id() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameQuickSoundRequest::clear_has_desk_id() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameQuickSoundRequest::clear_desk_id() {
desk_id_ = 0;
clear_has_desk_id();
}
inline ::google::protobuf::int32 ProJDDDZGameQuickSoundRequest::desk_id() const {
return desk_id_;
}
inline void ProJDDDZGameQuickSoundRequest::set_desk_id(::google::protobuf::int32 value) {
set_has_desk_id();
desk_id_ = value;
}
// optional int32 seat_id = 3;
inline bool ProJDDDZGameQuickSoundRequest::has_seat_id() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameQuickSoundRequest::set_has_seat_id() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameQuickSoundRequest::clear_has_seat_id() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameQuickSoundRequest::clear_seat_id() {
seat_id_ = 0;
clear_has_seat_id();
}
inline ::google::protobuf::int32 ProJDDDZGameQuickSoundRequest::seat_id() const {
return seat_id_;
}
inline void ProJDDDZGameQuickSoundRequest::set_seat_id(::google::protobuf::int32 value) {
set_has_seat_id();
seat_id_ = value;
}
// optional int32 sound_id = 4;
inline bool ProJDDDZGameQuickSoundRequest::has_sound_id() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ProJDDDZGameQuickSoundRequest::set_has_sound_id() {
_has_bits_[0] |= 0x00000004u;
}
inline void ProJDDDZGameQuickSoundRequest::clear_has_sound_id() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ProJDDDZGameQuickSoundRequest::clear_sound_id() {
sound_id_ = 0;
clear_has_sound_id();
}
inline ::google::protobuf::int32 ProJDDDZGameQuickSoundRequest::sound_id() const {
return sound_id_;
}
inline void ProJDDDZGameQuickSoundRequest::set_sound_id(::google::protobuf::int32 value) {
set_has_sound_id();
sound_id_ = value;
}
// optional bytes text = 5;
inline bool ProJDDDZGameQuickSoundRequest::has_text() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ProJDDDZGameQuickSoundRequest::set_has_text() {
_has_bits_[0] |= 0x00000008u;
}
inline void ProJDDDZGameQuickSoundRequest::clear_has_text() {
_has_bits_[0] &= ~0x00000008u;
}
inline void ProJDDDZGameQuickSoundRequest::clear_text() {
if (text_ != &::google::protobuf::internal::kEmptyString) {
text_->clear();
}
clear_has_text();
}
inline const ::std::string& ProJDDDZGameQuickSoundRequest::text() const {
return *text_;
}
inline void ProJDDDZGameQuickSoundRequest::set_text(const ::std::string& value) {
set_has_text();
if (text_ == &::google::protobuf::internal::kEmptyString) {
text_ = new ::std::string;
}
text_->assign(value);
}
inline void ProJDDDZGameQuickSoundRequest::set_text(const char* value) {
set_has_text();
if (text_ == &::google::protobuf::internal::kEmptyString) {
text_ = new ::std::string;
}
text_->assign(value);
}
inline void ProJDDDZGameQuickSoundRequest::set_text(const void* value, size_t size) {
set_has_text();
if (text_ == &::google::protobuf::internal::kEmptyString) {
text_ = new ::std::string;
}
text_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ProJDDDZGameQuickSoundRequest::mutable_text() {
set_has_text();
if (text_ == &::google::protobuf::internal::kEmptyString) {
text_ = new ::std::string;
}
return text_;
}
inline ::std::string* ProJDDDZGameQuickSoundRequest::release_text() {
clear_has_text();
if (text_ == &::google::protobuf::internal::kEmptyString) {
return NULL;
} else {
::std::string* temp = text_;
text_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
return temp;
}
}
inline void ProJDDDZGameQuickSoundRequest::set_allocated_text(::std::string* text) {
if (text_ != &::google::protobuf::internal::kEmptyString) {
delete text_;
}
if (text) {
set_has_text();
text_ = text;
} else {
clear_has_text();
text_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
}
}
// -------------------------------------------------------------------
// ProJDDDZGameQuickSoundResponse
// optional int32 desk_id = 2;
inline bool ProJDDDZGameQuickSoundResponse::has_desk_id() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameQuickSoundResponse::set_has_desk_id() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameQuickSoundResponse::clear_has_desk_id() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameQuickSoundResponse::clear_desk_id() {
desk_id_ = 0;
clear_has_desk_id();
}
inline ::google::protobuf::int32 ProJDDDZGameQuickSoundResponse::desk_id() const {
return desk_id_;
}
inline void ProJDDDZGameQuickSoundResponse::set_desk_id(::google::protobuf::int32 value) {
set_has_desk_id();
desk_id_ = value;
}
// optional int32 seat_id = 3;
inline bool ProJDDDZGameQuickSoundResponse::has_seat_id() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameQuickSoundResponse::set_has_seat_id() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameQuickSoundResponse::clear_has_seat_id() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameQuickSoundResponse::clear_seat_id() {
seat_id_ = 0;
clear_has_seat_id();
}
inline ::google::protobuf::int32 ProJDDDZGameQuickSoundResponse::seat_id() const {
return seat_id_;
}
inline void ProJDDDZGameQuickSoundResponse::set_seat_id(::google::protobuf::int32 value) {
set_has_seat_id();
seat_id_ = value;
}
// optional int32 sound_id = 4;
inline bool ProJDDDZGameQuickSoundResponse::has_sound_id() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ProJDDDZGameQuickSoundResponse::set_has_sound_id() {
_has_bits_[0] |= 0x00000004u;
}
inline void ProJDDDZGameQuickSoundResponse::clear_has_sound_id() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ProJDDDZGameQuickSoundResponse::clear_sound_id() {
sound_id_ = 0;
clear_has_sound_id();
}
inline ::google::protobuf::int32 ProJDDDZGameQuickSoundResponse::sound_id() const {
return sound_id_;
}
inline void ProJDDDZGameQuickSoundResponse::set_sound_id(::google::protobuf::int32 value) {
set_has_sound_id();
sound_id_ = value;
}
// optional bytes text = 5;
inline bool ProJDDDZGameQuickSoundResponse::has_text() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ProJDDDZGameQuickSoundResponse::set_has_text() {
_has_bits_[0] |= 0x00000008u;
}
inline void ProJDDDZGameQuickSoundResponse::clear_has_text() {
_has_bits_[0] &= ~0x00000008u;
}
inline void ProJDDDZGameQuickSoundResponse::clear_text() {
if (text_ != &::google::protobuf::internal::kEmptyString) {
text_->clear();
}
clear_has_text();
}
inline const ::std::string& ProJDDDZGameQuickSoundResponse::text() const {
return *text_;
}
inline void ProJDDDZGameQuickSoundResponse::set_text(const ::std::string& value) {
set_has_text();
if (text_ == &::google::protobuf::internal::kEmptyString) {
text_ = new ::std::string;
}
text_->assign(value);
}
inline void ProJDDDZGameQuickSoundResponse::set_text(const char* value) {
set_has_text();
if (text_ == &::google::protobuf::internal::kEmptyString) {
text_ = new ::std::string;
}
text_->assign(value);
}
inline void ProJDDDZGameQuickSoundResponse::set_text(const void* value, size_t size) {
set_has_text();
if (text_ == &::google::protobuf::internal::kEmptyString) {
text_ = new ::std::string;
}
text_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ProJDDDZGameQuickSoundResponse::mutable_text() {
set_has_text();
if (text_ == &::google::protobuf::internal::kEmptyString) {
text_ = new ::std::string;
}
return text_;
}
inline ::std::string* ProJDDDZGameQuickSoundResponse::release_text() {
clear_has_text();
if (text_ == &::google::protobuf::internal::kEmptyString) {
return NULL;
} else {
::std::string* temp = text_;
text_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
return temp;
}
}
inline void ProJDDDZGameQuickSoundResponse::set_allocated_text(::std::string* text) {
if (text_ != &::google::protobuf::internal::kEmptyString) {
delete text_;
}
if (text) {
set_has_text();
text_ = text;
} else {
clear_has_text();
text_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
}
}
// -------------------------------------------------------------------
// ProJDDDZGameSendDiscardMahs
// optional int32 seat_id = 2;
inline bool ProJDDDZGameSendDiscardMahs::has_seat_id() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameSendDiscardMahs::set_has_seat_id() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameSendDiscardMahs::clear_has_seat_id() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameSendDiscardMahs::clear_seat_id() {
seat_id_ = 0;
clear_has_seat_id();
}
inline ::google::protobuf::int32 ProJDDDZGameSendDiscardMahs::seat_id() const {
return seat_id_;
}
inline void ProJDDDZGameSendDiscardMahs::set_seat_id(::google::protobuf::int32 value) {
set_has_seat_id();
seat_id_ = value;
}
// repeated .JDDDZMahList cbCardData = 3;
inline int ProJDDDZGameSendDiscardMahs::cbcarddata_size() const {
return cbcarddata_.size();
}
inline void ProJDDDZGameSendDiscardMahs::clear_cbcarddata() {
cbcarddata_.Clear();
}
inline const ::JDDDZMahList& ProJDDDZGameSendDiscardMahs::cbcarddata(int index) const {
return cbcarddata_.Get(index);
}
inline ::JDDDZMahList* ProJDDDZGameSendDiscardMahs::mutable_cbcarddata(int index) {
return cbcarddata_.Mutable(index);
}
inline ::JDDDZMahList* ProJDDDZGameSendDiscardMahs::add_cbcarddata() {
return cbcarddata_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::JDDDZMahList >&
ProJDDDZGameSendDiscardMahs::cbcarddata() const {
return cbcarddata_;
}
inline ::google::protobuf::RepeatedPtrField< ::JDDDZMahList >*
ProJDDDZGameSendDiscardMahs::mutable_cbcarddata() {
return &cbcarddata_;
}
// optional int32 deskCount = 4;
inline bool ProJDDDZGameSendDiscardMahs::has_deskcount() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ProJDDDZGameSendDiscardMahs::set_has_deskcount() {
_has_bits_[0] |= 0x00000004u;
}
inline void ProJDDDZGameSendDiscardMahs::clear_has_deskcount() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ProJDDDZGameSendDiscardMahs::clear_deskcount() {
deskcount_ = 0;
clear_has_deskcount();
}
inline ::google::protobuf::int32 ProJDDDZGameSendDiscardMahs::deskcount() const {
return deskcount_;
}
inline void ProJDDDZGameSendDiscardMahs::set_deskcount(::google::protobuf::int32 value) {
set_has_deskcount();
deskcount_ = value;
}
// repeated int32 outCardCount = 5;
inline int ProJDDDZGameSendDiscardMahs::outcardcount_size() const {
return outcardcount_.size();
}
inline void ProJDDDZGameSendDiscardMahs::clear_outcardcount() {
outcardcount_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameSendDiscardMahs::outcardcount(int index) const {
return outcardcount_.Get(index);
}
inline void ProJDDDZGameSendDiscardMahs::set_outcardcount(int index, ::google::protobuf::int32 value) {
outcardcount_.Set(index, value);
}
inline void ProJDDDZGameSendDiscardMahs::add_outcardcount(::google::protobuf::int32 value) {
outcardcount_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameSendDiscardMahs::outcardcount() const {
return outcardcount_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameSendDiscardMahs::mutable_outcardcount() {
return &outcardcount_;
}
// -------------------------------------------------------------------
// JDDDZWeaveItem
// optional int32 weaveKind = 1;
inline bool JDDDZWeaveItem::has_weavekind() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void JDDDZWeaveItem::set_has_weavekind() {
_has_bits_[0] |= 0x00000001u;
}
inline void JDDDZWeaveItem::clear_has_weavekind() {
_has_bits_[0] &= ~0x00000001u;
}
inline void JDDDZWeaveItem::clear_weavekind() {
weavekind_ = 0;
clear_has_weavekind();
}
inline ::google::protobuf::int32 JDDDZWeaveItem::weavekind() const {
return weavekind_;
}
inline void JDDDZWeaveItem::set_weavekind(::google::protobuf::int32 value) {
set_has_weavekind();
weavekind_ = value;
}
// optional int32 centercard = 2;
inline bool JDDDZWeaveItem::has_centercard() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void JDDDZWeaveItem::set_has_centercard() {
_has_bits_[0] |= 0x00000002u;
}
inline void JDDDZWeaveItem::clear_has_centercard() {
_has_bits_[0] &= ~0x00000002u;
}
inline void JDDDZWeaveItem::clear_centercard() {
centercard_ = 0;
clear_has_centercard();
}
inline ::google::protobuf::int32 JDDDZWeaveItem::centercard() const {
return centercard_;
}
inline void JDDDZWeaveItem::set_centercard(::google::protobuf::int32 value) {
set_has_centercard();
centercard_ = value;
}
// optional int32 provideUser = 3;
inline bool JDDDZWeaveItem::has_provideuser() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void JDDDZWeaveItem::set_has_provideuser() {
_has_bits_[0] |= 0x00000004u;
}
inline void JDDDZWeaveItem::clear_has_provideuser() {
_has_bits_[0] &= ~0x00000004u;
}
inline void JDDDZWeaveItem::clear_provideuser() {
provideuser_ = 0;
clear_has_provideuser();
}
inline ::google::protobuf::int32 JDDDZWeaveItem::provideuser() const {
return provideuser_;
}
inline void JDDDZWeaveItem::set_provideuser(::google::protobuf::int32 value) {
set_has_provideuser();
provideuser_ = value;
}
// optional int32 cardsize = 4;
inline bool JDDDZWeaveItem::has_cardsize() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void JDDDZWeaveItem::set_has_cardsize() {
_has_bits_[0] |= 0x00000008u;
}
inline void JDDDZWeaveItem::clear_has_cardsize() {
_has_bits_[0] &= ~0x00000008u;
}
inline void JDDDZWeaveItem::clear_cardsize() {
cardsize_ = 0;
clear_has_cardsize();
}
inline ::google::protobuf::int32 JDDDZWeaveItem::cardsize() const {
return cardsize_;
}
inline void JDDDZWeaveItem::set_cardsize(::google::protobuf::int32 value) {
set_has_cardsize();
cardsize_ = value;
}
// -------------------------------------------------------------------
// JDDDZWeaveItems
// repeated .JDDDZWeaveItem items = 1;
inline int JDDDZWeaveItems::items_size() const {
return items_.size();
}
inline void JDDDZWeaveItems::clear_items() {
items_.Clear();
}
inline const ::JDDDZWeaveItem& JDDDZWeaveItems::items(int index) const {
return items_.Get(index);
}
inline ::JDDDZWeaveItem* JDDDZWeaveItems::mutable_items(int index) {
return items_.Mutable(index);
}
inline ::JDDDZWeaveItem* JDDDZWeaveItems::add_items() {
return items_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::JDDDZWeaveItem >&
JDDDZWeaveItems::items() const {
return items_;
}
inline ::google::protobuf::RepeatedPtrField< ::JDDDZWeaveItem >*
JDDDZWeaveItems::mutable_items() {
return &items_;
}
// -------------------------------------------------------------------
// ProJDDDZGameSendActionMahs
// optional int32 seat_id = 2;
inline bool ProJDDDZGameSendActionMahs::has_seat_id() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameSendActionMahs::set_has_seat_id() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameSendActionMahs::clear_has_seat_id() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameSendActionMahs::clear_seat_id() {
seat_id_ = 0;
clear_has_seat_id();
}
inline ::google::protobuf::int32 ProJDDDZGameSendActionMahs::seat_id() const {
return seat_id_;
}
inline void ProJDDDZGameSendActionMahs::set_seat_id(::google::protobuf::int32 value) {
set_has_seat_id();
seat_id_ = value;
}
// repeated .JDDDZWeaveItems weaves = 3;
inline int ProJDDDZGameSendActionMahs::weaves_size() const {
return weaves_.size();
}
inline void ProJDDDZGameSendActionMahs::clear_weaves() {
weaves_.Clear();
}
inline const ::JDDDZWeaveItems& ProJDDDZGameSendActionMahs::weaves(int index) const {
return weaves_.Get(index);
}
inline ::JDDDZWeaveItems* ProJDDDZGameSendActionMahs::mutable_weaves(int index) {
return weaves_.Mutable(index);
}
inline ::JDDDZWeaveItems* ProJDDDZGameSendActionMahs::add_weaves() {
return weaves_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::JDDDZWeaveItems >&
ProJDDDZGameSendActionMahs::weaves() const {
return weaves_;
}
inline ::google::protobuf::RepeatedPtrField< ::JDDDZWeaveItems >*
ProJDDDZGameSendActionMahs::mutable_weaves() {
return &weaves_;
}
// -------------------------------------------------------------------
// ProJDDDZGameBrokenRequest
// optional int32 seat_id = 2;
inline bool ProJDDDZGameBrokenRequest::has_seat_id() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameBrokenRequest::set_has_seat_id() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameBrokenRequest::clear_has_seat_id() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameBrokenRequest::clear_seat_id() {
seat_id_ = 0;
clear_has_seat_id();
}
inline ::google::protobuf::int32 ProJDDDZGameBrokenRequest::seat_id() const {
return seat_id_;
}
inline void ProJDDDZGameBrokenRequest::set_seat_id(::google::protobuf::int32 value) {
set_has_seat_id();
seat_id_ = value;
}
// optional .JDDDZBROKEN_TYPE type = 3;
inline bool ProJDDDZGameBrokenRequest::has_type() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameBrokenRequest::set_has_type() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameBrokenRequest::clear_has_type() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameBrokenRequest::clear_type() {
type_ = 0;
clear_has_type();
}
inline ::JDDDZBROKEN_TYPE ProJDDDZGameBrokenRequest::type() const {
return static_cast< ::JDDDZBROKEN_TYPE >(type_);
}
inline void ProJDDDZGameBrokenRequest::set_type(::JDDDZBROKEN_TYPE value) {
assert(::JDDDZBROKEN_TYPE_IsValid(value));
set_has_type();
type_ = value;
}
// optional int32 time = 4;
inline bool ProJDDDZGameBrokenRequest::has_time() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ProJDDDZGameBrokenRequest::set_has_time() {
_has_bits_[0] |= 0x00000004u;
}
inline void ProJDDDZGameBrokenRequest::clear_has_time() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ProJDDDZGameBrokenRequest::clear_time() {
time_ = 0;
clear_has_time();
}
inline ::google::protobuf::int32 ProJDDDZGameBrokenRequest::time() const {
return time_;
}
inline void ProJDDDZGameBrokenRequest::set_time(::google::protobuf::int32 value) {
set_has_time();
time_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameBrokenOperate
// optional int32 seat_id = 2;
inline bool ProJDDDZGameBrokenOperate::has_seat_id() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameBrokenOperate::set_has_seat_id() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameBrokenOperate::clear_has_seat_id() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameBrokenOperate::clear_seat_id() {
seat_id_ = 0;
clear_has_seat_id();
}
inline ::google::protobuf::int32 ProJDDDZGameBrokenOperate::seat_id() const {
return seat_id_;
}
inline void ProJDDDZGameBrokenOperate::set_seat_id(::google::protobuf::int32 value) {
set_has_seat_id();
seat_id_ = value;
}
// optional .JDDDZBROKEN_OPERATE result = 3 [default = JDDDZ_BO_DISAGREE];
inline bool ProJDDDZGameBrokenOperate::has_result() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameBrokenOperate::set_has_result() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameBrokenOperate::clear_has_result() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameBrokenOperate::clear_result() {
result_ = 0;
clear_has_result();
}
inline ::JDDDZBROKEN_OPERATE ProJDDDZGameBrokenOperate::result() const {
return static_cast< ::JDDDZBROKEN_OPERATE >(result_);
}
inline void ProJDDDZGameBrokenOperate::set_result(::JDDDZBROKEN_OPERATE value) {
assert(::JDDDZBROKEN_OPERATE_IsValid(value));
set_has_result();
result_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameBrokenNotify
// optional int32 seat_id = 2;
inline bool ProJDDDZGameBrokenNotify::has_seat_id() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameBrokenNotify::set_has_seat_id() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameBrokenNotify::clear_has_seat_id() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameBrokenNotify::clear_seat_id() {
seat_id_ = 0;
clear_has_seat_id();
}
inline ::google::protobuf::int32 ProJDDDZGameBrokenNotify::seat_id() const {
return seat_id_;
}
inline void ProJDDDZGameBrokenNotify::set_seat_id(::google::protobuf::int32 value) {
set_has_seat_id();
seat_id_ = value;
}
// optional .JDDDZBROKEN_CODE operate_code = 3 [default = JDDDZ_BC_SUCCESS];
inline bool ProJDDDZGameBrokenNotify::has_operate_code() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameBrokenNotify::set_has_operate_code() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameBrokenNotify::clear_has_operate_code() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameBrokenNotify::clear_operate_code() {
operate_code_ = 0;
clear_has_operate_code();
}
inline ::JDDDZBROKEN_CODE ProJDDDZGameBrokenNotify::operate_code() const {
return static_cast< ::JDDDZBROKEN_CODE >(operate_code_);
}
inline void ProJDDDZGameBrokenNotify::set_operate_code(::JDDDZBROKEN_CODE value) {
assert(::JDDDZBROKEN_CODE_IsValid(value));
set_has_operate_code();
operate_code_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameRuleConfig
// optional int32 game_round = 1;
inline bool ProJDDDZGameRuleConfig::has_game_round() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameRuleConfig::set_has_game_round() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameRuleConfig::clear_has_game_round() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameRuleConfig::clear_game_round() {
game_round_ = 0;
clear_has_game_round();
}
inline ::google::protobuf::int32 ProJDDDZGameRuleConfig::game_round() const {
return game_round_;
}
inline void ProJDDDZGameRuleConfig::set_game_round(::google::protobuf::int32 value) {
set_has_game_round();
game_round_ = value;
}
// optional int32 need_card = 2;
inline bool ProJDDDZGameRuleConfig::has_need_card() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameRuleConfig::set_has_need_card() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameRuleConfig::clear_has_need_card() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameRuleConfig::clear_need_card() {
need_card_ = 0;
clear_has_need_card();
}
inline ::google::protobuf::int32 ProJDDDZGameRuleConfig::need_card() const {
return need_card_;
}
inline void ProJDDDZGameRuleConfig::set_need_card(::google::protobuf::int32 value) {
set_has_need_card();
need_card_ = value;
}
// optional bool have_bottom_king = 3;
inline bool ProJDDDZGameRuleConfig::has_have_bottom_king() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ProJDDDZGameRuleConfig::set_has_have_bottom_king() {
_has_bits_[0] |= 0x00000004u;
}
inline void ProJDDDZGameRuleConfig::clear_has_have_bottom_king() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ProJDDDZGameRuleConfig::clear_have_bottom_king() {
have_bottom_king_ = false;
clear_has_have_bottom_king();
}
inline bool ProJDDDZGameRuleConfig::have_bottom_king() const {
return have_bottom_king_;
}
inline void ProJDDDZGameRuleConfig::set_have_bottom_king(bool value) {
set_has_have_bottom_king();
have_bottom_king_ = value;
}
// optional bool have_mai_lei = 4;
inline bool ProJDDDZGameRuleConfig::has_have_mai_lei() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ProJDDDZGameRuleConfig::set_has_have_mai_lei() {
_has_bits_[0] |= 0x00000008u;
}
inline void ProJDDDZGameRuleConfig::clear_has_have_mai_lei() {
_has_bits_[0] &= ~0x00000008u;
}
inline void ProJDDDZGameRuleConfig::clear_have_mai_lei() {
have_mai_lei_ = false;
clear_has_have_mai_lei();
}
inline bool ProJDDDZGameRuleConfig::have_mai_lei() const {
return have_mai_lei_;
}
inline void ProJDDDZGameRuleConfig::set_have_mai_lei(bool value) {
set_has_have_mai_lei();
have_mai_lei_ = value;
}
// optional bool hava_hui_tou = 5;
inline bool ProJDDDZGameRuleConfig::has_hava_hui_tou() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ProJDDDZGameRuleConfig::set_has_hava_hui_tou() {
_has_bits_[0] |= 0x00000010u;
}
inline void ProJDDDZGameRuleConfig::clear_has_hava_hui_tou() {
_has_bits_[0] &= ~0x00000010u;
}
inline void ProJDDDZGameRuleConfig::clear_hava_hui_tou() {
hava_hui_tou_ = false;
clear_has_hava_hui_tou();
}
inline bool ProJDDDZGameRuleConfig::hava_hui_tou() const {
return hava_hui_tou_;
}
inline void ProJDDDZGameRuleConfig::set_hava_hui_tou(bool value) {
set_has_hava_hui_tou();
hava_hui_tou_ = value;
}
// optional int32 nMasterSeat = 6;
inline bool ProJDDDZGameRuleConfig::has_nmasterseat() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ProJDDDZGameRuleConfig::set_has_nmasterseat() {
_has_bits_[0] |= 0x00000020u;
}
inline void ProJDDDZGameRuleConfig::clear_has_nmasterseat() {
_has_bits_[0] &= ~0x00000020u;
}
inline void ProJDDDZGameRuleConfig::clear_nmasterseat() {
nmasterseat_ = 0;
clear_has_nmasterseat();
}
inline ::google::protobuf::int32 ProJDDDZGameRuleConfig::nmasterseat() const {
return nmasterseat_;
}
inline void ProJDDDZGameRuleConfig::set_nmasterseat(::google::protobuf::int32 value) {
set_has_nmasterseat();
nmasterseat_ = value;
}
// optional int32 current_game_count = 7;
inline bool ProJDDDZGameRuleConfig::has_current_game_count() const {
return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ProJDDDZGameRuleConfig::set_has_current_game_count() {
_has_bits_[0] |= 0x00000040u;
}
inline void ProJDDDZGameRuleConfig::clear_has_current_game_count() {
_has_bits_[0] &= ~0x00000040u;
}
inline void ProJDDDZGameRuleConfig::clear_current_game_count() {
current_game_count_ = 0;
clear_has_current_game_count();
}
inline ::google::protobuf::int32 ProJDDDZGameRuleConfig::current_game_count() const {
return current_game_count_;
}
inline void ProJDDDZGameRuleConfig::set_current_game_count(::google::protobuf::int32 value) {
set_has_current_game_count();
current_game_count_ = value;
}
// optional bool have_jianma = 8;
inline bool ProJDDDZGameRuleConfig::has_have_jianma() const {
return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void ProJDDDZGameRuleConfig::set_has_have_jianma() {
_has_bits_[0] |= 0x00000080u;
}
inline void ProJDDDZGameRuleConfig::clear_has_have_jianma() {
_has_bits_[0] &= ~0x00000080u;
}
inline void ProJDDDZGameRuleConfig::clear_have_jianma() {
have_jianma_ = false;
clear_has_have_jianma();
}
inline bool ProJDDDZGameRuleConfig::have_jianma() const {
return have_jianma_;
}
inline void ProJDDDZGameRuleConfig::set_have_jianma(bool value) {
set_has_have_jianma();
have_jianma_ = value;
}
// optional int32 nChongguanNum = 9;
inline bool ProJDDDZGameRuleConfig::has_nchongguannum() const {
return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void ProJDDDZGameRuleConfig::set_has_nchongguannum() {
_has_bits_[0] |= 0x00000100u;
}
inline void ProJDDDZGameRuleConfig::clear_has_nchongguannum() {
_has_bits_[0] &= ~0x00000100u;
}
inline void ProJDDDZGameRuleConfig::clear_nchongguannum() {
nchongguannum_ = 0;
clear_has_nchongguannum();
}
inline ::google::protobuf::int32 ProJDDDZGameRuleConfig::nchongguannum() const {
return nchongguannum_;
}
inline void ProJDDDZGameRuleConfig::set_nchongguannum(::google::protobuf::int32 value) {
set_has_nchongguannum();
nchongguannum_ = value;
}
// optional bool bbawangfanbei = 10;
inline bool ProJDDDZGameRuleConfig::has_bbawangfanbei() const {
return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void ProJDDDZGameRuleConfig::set_has_bbawangfanbei() {
_has_bits_[0] |= 0x00000200u;
}
inline void ProJDDDZGameRuleConfig::clear_has_bbawangfanbei() {
_has_bits_[0] &= ~0x00000200u;
}
inline void ProJDDDZGameRuleConfig::clear_bbawangfanbei() {
bbawangfanbei_ = false;
clear_has_bbawangfanbei();
}
inline bool ProJDDDZGameRuleConfig::bbawangfanbei() const {
return bbawangfanbei_;
}
inline void ProJDDDZGameRuleConfig::set_bbawangfanbei(bool value) {
set_has_bbawangfanbei();
bbawangfanbei_ = value;
}
// optional int32 nPlayerNum = 11;
inline bool ProJDDDZGameRuleConfig::has_nplayernum() const {
return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void ProJDDDZGameRuleConfig::set_has_nplayernum() {
_has_bits_[0] |= 0x00000400u;
}
inline void ProJDDDZGameRuleConfig::clear_has_nplayernum() {
_has_bits_[0] &= ~0x00000400u;
}
inline void ProJDDDZGameRuleConfig::clear_nplayernum() {
nplayernum_ = 0;
clear_has_nplayernum();
}
inline ::google::protobuf::int32 ProJDDDZGameRuleConfig::nplayernum() const {
return nplayernum_;
}
inline void ProJDDDZGameRuleConfig::set_nplayernum(::google::protobuf::int32 value) {
set_has_nplayernum();
nplayernum_ = value;
}
// optional bytes sRoomNum = 12;
inline bool ProJDDDZGameRuleConfig::has_sroomnum() const {
return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void ProJDDDZGameRuleConfig::set_has_sroomnum() {
_has_bits_[0] |= 0x00000800u;
}
inline void ProJDDDZGameRuleConfig::clear_has_sroomnum() {
_has_bits_[0] &= ~0x00000800u;
}
inline void ProJDDDZGameRuleConfig::clear_sroomnum() {
if (sroomnum_ != &::google::protobuf::internal::kEmptyString) {
sroomnum_->clear();
}
clear_has_sroomnum();
}
inline const ::std::string& ProJDDDZGameRuleConfig::sroomnum() const {
return *sroomnum_;
}
inline void ProJDDDZGameRuleConfig::set_sroomnum(const ::std::string& value) {
set_has_sroomnum();
if (sroomnum_ == &::google::protobuf::internal::kEmptyString) {
sroomnum_ = new ::std::string;
}
sroomnum_->assign(value);
}
inline void ProJDDDZGameRuleConfig::set_sroomnum(const char* value) {
set_has_sroomnum();
if (sroomnum_ == &::google::protobuf::internal::kEmptyString) {
sroomnum_ = new ::std::string;
}
sroomnum_->assign(value);
}
inline void ProJDDDZGameRuleConfig::set_sroomnum(const void* value, size_t size) {
set_has_sroomnum();
if (sroomnum_ == &::google::protobuf::internal::kEmptyString) {
sroomnum_ = new ::std::string;
}
sroomnum_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ProJDDDZGameRuleConfig::mutable_sroomnum() {
set_has_sroomnum();
if (sroomnum_ == &::google::protobuf::internal::kEmptyString) {
sroomnum_ = new ::std::string;
}
return sroomnum_;
}
inline ::std::string* ProJDDDZGameRuleConfig::release_sroomnum() {
clear_has_sroomnum();
if (sroomnum_ == &::google::protobuf::internal::kEmptyString) {
return NULL;
} else {
::std::string* temp = sroomnum_;
sroomnum_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
return temp;
}
}
inline void ProJDDDZGameRuleConfig::set_allocated_sroomnum(::std::string* sroomnum) {
if (sroomnum_ != &::google::protobuf::internal::kEmptyString) {
delete sroomnum_;
}
if (sroomnum) {
set_has_sroomnum();
sroomnum_ = sroomnum;
} else {
clear_has_sroomnum();
sroomnum_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
}
}
// optional bytes sPlayTime = 13;
inline bool ProJDDDZGameRuleConfig::has_splaytime() const {
return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void ProJDDDZGameRuleConfig::set_has_splaytime() {
_has_bits_[0] |= 0x00001000u;
}
inline void ProJDDDZGameRuleConfig::clear_has_splaytime() {
_has_bits_[0] &= ~0x00001000u;
}
inline void ProJDDDZGameRuleConfig::clear_splaytime() {
if (splaytime_ != &::google::protobuf::internal::kEmptyString) {
splaytime_->clear();
}
clear_has_splaytime();
}
inline const ::std::string& ProJDDDZGameRuleConfig::splaytime() const {
return *splaytime_;
}
inline void ProJDDDZGameRuleConfig::set_splaytime(const ::std::string& value) {
set_has_splaytime();
if (splaytime_ == &::google::protobuf::internal::kEmptyString) {
splaytime_ = new ::std::string;
}
splaytime_->assign(value);
}
inline void ProJDDDZGameRuleConfig::set_splaytime(const char* value) {
set_has_splaytime();
if (splaytime_ == &::google::protobuf::internal::kEmptyString) {
splaytime_ = new ::std::string;
}
splaytime_->assign(value);
}
inline void ProJDDDZGameRuleConfig::set_splaytime(const void* value, size_t size) {
set_has_splaytime();
if (splaytime_ == &::google::protobuf::internal::kEmptyString) {
splaytime_ = new ::std::string;
}
splaytime_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ProJDDDZGameRuleConfig::mutable_splaytime() {
set_has_splaytime();
if (splaytime_ == &::google::protobuf::internal::kEmptyString) {
splaytime_ = new ::std::string;
}
return splaytime_;
}
inline ::std::string* ProJDDDZGameRuleConfig::release_splaytime() {
clear_has_splaytime();
if (splaytime_ == &::google::protobuf::internal::kEmptyString) {
return NULL;
} else {
::std::string* temp = splaytime_;
splaytime_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
return temp;
}
}
inline void ProJDDDZGameRuleConfig::set_allocated_splaytime(::std::string* splaytime) {
if (splaytime_ != &::google::protobuf::internal::kEmptyString) {
delete splaytime_;
}
if (splaytime) {
set_has_splaytime();
splaytime_ = splaytime;
} else {
clear_has_splaytime();
splaytime_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
}
}
// optional int32 nselfSeat = 14;
inline bool ProJDDDZGameRuleConfig::has_nselfseat() const {
return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void ProJDDDZGameRuleConfig::set_has_nselfseat() {
_has_bits_[0] |= 0x00002000u;
}
inline void ProJDDDZGameRuleConfig::clear_has_nselfseat() {
_has_bits_[0] &= ~0x00002000u;
}
inline void ProJDDDZGameRuleConfig::clear_nselfseat() {
nselfseat_ = 0;
clear_has_nselfseat();
}
inline ::google::protobuf::int32 ProJDDDZGameRuleConfig::nselfseat() const {
return nselfseat_;
}
inline void ProJDDDZGameRuleConfig::set_nselfseat(::google::protobuf::int32 value) {
set_has_nselfseat();
nselfseat_ = value;
}
// optional bool bJingDian = 15;
inline bool ProJDDDZGameRuleConfig::has_bjingdian() const {
return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void ProJDDDZGameRuleConfig::set_has_bjingdian() {
_has_bits_[0] |= 0x00004000u;
}
inline void ProJDDDZGameRuleConfig::clear_has_bjingdian() {
_has_bits_[0] &= ~0x00004000u;
}
inline void ProJDDDZGameRuleConfig::clear_bjingdian() {
bjingdian_ = false;
clear_has_bjingdian();
}
inline bool ProJDDDZGameRuleConfig::bjingdian() const {
return bjingdian_;
}
inline void ProJDDDZGameRuleConfig::set_bjingdian(bool value) {
set_has_bjingdian();
bjingdian_ = value;
}
// optional bool bMagicCard = 16;
inline bool ProJDDDZGameRuleConfig::has_bmagiccard() const {
return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void ProJDDDZGameRuleConfig::set_has_bmagiccard() {
_has_bits_[0] |= 0x00008000u;
}
inline void ProJDDDZGameRuleConfig::clear_has_bmagiccard() {
_has_bits_[0] &= ~0x00008000u;
}
inline void ProJDDDZGameRuleConfig::clear_bmagiccard() {
bmagiccard_ = false;
clear_has_bmagiccard();
}
inline bool ProJDDDZGameRuleConfig::bmagiccard() const {
return bmagiccard_;
}
inline void ProJDDDZGameRuleConfig::set_bmagiccard(bool value) {
set_has_bmagiccard();
bmagiccard_ = value;
}
// optional bool bMasterThebe = 17;
inline bool ProJDDDZGameRuleConfig::has_bmasterthebe() const {
return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void ProJDDDZGameRuleConfig::set_has_bmasterthebe() {
_has_bits_[0] |= 0x00010000u;
}
inline void ProJDDDZGameRuleConfig::clear_has_bmasterthebe() {
_has_bits_[0] &= ~0x00010000u;
}
inline void ProJDDDZGameRuleConfig::clear_bmasterthebe() {
bmasterthebe_ = false;
clear_has_bmasterthebe();
}
inline bool ProJDDDZGameRuleConfig::bmasterthebe() const {
return bmasterthebe_;
}
inline void ProJDDDZGameRuleConfig::set_bmasterthebe(bool value) {
set_has_bmasterthebe();
bmasterthebe_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameBrokenStatus
// optional int32 broken_seat = 1;
inline bool ProJDDDZGameBrokenStatus::has_broken_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameBrokenStatus::set_has_broken_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameBrokenStatus::clear_has_broken_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameBrokenStatus::clear_broken_seat() {
broken_seat_ = 0;
clear_has_broken_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameBrokenStatus::broken_seat() const {
return broken_seat_;
}
inline void ProJDDDZGameBrokenStatus::set_broken_seat(::google::protobuf::int32 value) {
set_has_broken_seat();
broken_seat_ = value;
}
// repeated bool broken_status = 2;
inline int ProJDDDZGameBrokenStatus::broken_status_size() const {
return broken_status_.size();
}
inline void ProJDDDZGameBrokenStatus::clear_broken_status() {
broken_status_.Clear();
}
inline bool ProJDDDZGameBrokenStatus::broken_status(int index) const {
return broken_status_.Get(index);
}
inline void ProJDDDZGameBrokenStatus::set_broken_status(int index, bool value) {
broken_status_.Set(index, value);
}
inline void ProJDDDZGameBrokenStatus::add_broken_status(bool value) {
broken_status_.Add(value);
}
inline const ::google::protobuf::RepeatedField< bool >&
ProJDDDZGameBrokenStatus::broken_status() const {
return broken_status_;
}
inline ::google::protobuf::RepeatedField< bool >*
ProJDDDZGameBrokenStatus::mutable_broken_status() {
return &broken_status_;
}
// optional int32 left_time = 3;
inline bool ProJDDDZGameBrokenStatus::has_left_time() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ProJDDDZGameBrokenStatus::set_has_left_time() {
_has_bits_[0] |= 0x00000004u;
}
inline void ProJDDDZGameBrokenStatus::clear_has_left_time() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ProJDDDZGameBrokenStatus::clear_left_time() {
left_time_ = 0;
clear_has_left_time();
}
inline ::google::protobuf::int32 ProJDDDZGameBrokenStatus::left_time() const {
return left_time_;
}
inline void ProJDDDZGameBrokenStatus::set_left_time(::google::protobuf::int32 value) {
set_has_left_time();
left_time_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameDataResp
// repeated int32 total_score = 1;
inline int ProJDDDZGameDataResp::total_score_size() const {
return total_score_.size();
}
inline void ProJDDDZGameDataResp::clear_total_score() {
total_score_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameDataResp::total_score(int index) const {
return total_score_.Get(index);
}
inline void ProJDDDZGameDataResp::set_total_score(int index, ::google::protobuf::int32 value) {
total_score_.Set(index, value);
}
inline void ProJDDDZGameDataResp::add_total_score(::google::protobuf::int32 value) {
total_score_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameDataResp::total_score() const {
return total_score_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameDataResp::mutable_total_score() {
return &total_score_;
}
// optional int32 type = 2;
inline bool ProJDDDZGameDataResp::has_type() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameDataResp::set_has_type() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameDataResp::clear_has_type() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameDataResp::clear_type() {
type_ = 0;
clear_has_type();
}
inline ::google::protobuf::int32 ProJDDDZGameDataResp::type() const {
return type_;
}
inline void ProJDDDZGameDataResp::set_type(::google::protobuf::int32 value) {
set_has_type();
type_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameRecordRequest
// optional int32 seat_id = 1;
inline bool ProJDDDZGameRecordRequest::has_seat_id() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameRecordRequest::set_has_seat_id() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameRecordRequest::clear_has_seat_id() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameRecordRequest::clear_seat_id() {
seat_id_ = 0;
clear_has_seat_id();
}
inline ::google::protobuf::int32 ProJDDDZGameRecordRequest::seat_id() const {
return seat_id_;
}
inline void ProJDDDZGameRecordRequest::set_seat_id(::google::protobuf::int32 value) {
set_has_seat_id();
seat_id_ = value;
}
// optional bytes url = 2;
inline bool ProJDDDZGameRecordRequest::has_url() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameRecordRequest::set_has_url() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameRecordRequest::clear_has_url() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameRecordRequest::clear_url() {
if (url_ != &::google::protobuf::internal::kEmptyString) {
url_->clear();
}
clear_has_url();
}
inline const ::std::string& ProJDDDZGameRecordRequest::url() const {
return *url_;
}
inline void ProJDDDZGameRecordRequest::set_url(const ::std::string& value) {
set_has_url();
if (url_ == &::google::protobuf::internal::kEmptyString) {
url_ = new ::std::string;
}
url_->assign(value);
}
inline void ProJDDDZGameRecordRequest::set_url(const char* value) {
set_has_url();
if (url_ == &::google::protobuf::internal::kEmptyString) {
url_ = new ::std::string;
}
url_->assign(value);
}
inline void ProJDDDZGameRecordRequest::set_url(const void* value, size_t size) {
set_has_url();
if (url_ == &::google::protobuf::internal::kEmptyString) {
url_ = new ::std::string;
}
url_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ProJDDDZGameRecordRequest::mutable_url() {
set_has_url();
if (url_ == &::google::protobuf::internal::kEmptyString) {
url_ = new ::std::string;
}
return url_;
}
inline ::std::string* ProJDDDZGameRecordRequest::release_url() {
clear_has_url();
if (url_ == &::google::protobuf::internal::kEmptyString) {
return NULL;
} else {
::std::string* temp = url_;
url_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
return temp;
}
}
inline void ProJDDDZGameRecordRequest::set_allocated_url(::std::string* url) {
if (url_ != &::google::protobuf::internal::kEmptyString) {
delete url_;
}
if (url) {
set_has_url();
url_ = url;
} else {
clear_has_url();
url_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
}
}
// -------------------------------------------------------------------
// ProJDDDZGameRecordResponse
// optional int32 seat_id = 1;
inline bool ProJDDDZGameRecordResponse::has_seat_id() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameRecordResponse::set_has_seat_id() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameRecordResponse::clear_has_seat_id() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameRecordResponse::clear_seat_id() {
seat_id_ = 0;
clear_has_seat_id();
}
inline ::google::protobuf::int32 ProJDDDZGameRecordResponse::seat_id() const {
return seat_id_;
}
inline void ProJDDDZGameRecordResponse::set_seat_id(::google::protobuf::int32 value) {
set_has_seat_id();
seat_id_ = value;
}
// optional bytes url = 2;
inline bool ProJDDDZGameRecordResponse::has_url() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameRecordResponse::set_has_url() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameRecordResponse::clear_has_url() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameRecordResponse::clear_url() {
if (url_ != &::google::protobuf::internal::kEmptyString) {
url_->clear();
}
clear_has_url();
}
inline const ::std::string& ProJDDDZGameRecordResponse::url() const {
return *url_;
}
inline void ProJDDDZGameRecordResponse::set_url(const ::std::string& value) {
set_has_url();
if (url_ == &::google::protobuf::internal::kEmptyString) {
url_ = new ::std::string;
}
url_->assign(value);
}
inline void ProJDDDZGameRecordResponse::set_url(const char* value) {
set_has_url();
if (url_ == &::google::protobuf::internal::kEmptyString) {
url_ = new ::std::string;
}
url_->assign(value);
}
inline void ProJDDDZGameRecordResponse::set_url(const void* value, size_t size) {
set_has_url();
if (url_ == &::google::protobuf::internal::kEmptyString) {
url_ = new ::std::string;
}
url_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ProJDDDZGameRecordResponse::mutable_url() {
set_has_url();
if (url_ == &::google::protobuf::internal::kEmptyString) {
url_ = new ::std::string;
}
return url_;
}
inline ::std::string* ProJDDDZGameRecordResponse::release_url() {
clear_has_url();
if (url_ == &::google::protobuf::internal::kEmptyString) {
return NULL;
} else {
::std::string* temp = url_;
url_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
return temp;
}
}
inline void ProJDDDZGameRecordResponse::set_allocated_url(::std::string* url) {
if (url_ != &::google::protobuf::internal::kEmptyString) {
delete url_;
}
if (url) {
set_has_url();
url_ = url;
} else {
clear_has_url();
url_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
}
}
// -------------------------------------------------------------------
// ProJDDDZGameUserLocationRequest
// optional int32 seat_id = 1;
inline bool ProJDDDZGameUserLocationRequest::has_seat_id() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameUserLocationRequest::set_has_seat_id() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameUserLocationRequest::clear_has_seat_id() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameUserLocationRequest::clear_seat_id() {
seat_id_ = 0;
clear_has_seat_id();
}
inline ::google::protobuf::int32 ProJDDDZGameUserLocationRequest::seat_id() const {
return seat_id_;
}
inline void ProJDDDZGameUserLocationRequest::set_seat_id(::google::protobuf::int32 value) {
set_has_seat_id();
seat_id_ = value;
}
// optional double dwlongitude = 2;
inline bool ProJDDDZGameUserLocationRequest::has_dwlongitude() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameUserLocationRequest::set_has_dwlongitude() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameUserLocationRequest::clear_has_dwlongitude() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameUserLocationRequest::clear_dwlongitude() {
dwlongitude_ = 0;
clear_has_dwlongitude();
}
inline double ProJDDDZGameUserLocationRequest::dwlongitude() const {
return dwlongitude_;
}
inline void ProJDDDZGameUserLocationRequest::set_dwlongitude(double value) {
set_has_dwlongitude();
dwlongitude_ = value;
}
// optional double dwlatitude = 3;
inline bool ProJDDDZGameUserLocationRequest::has_dwlatitude() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ProJDDDZGameUserLocationRequest::set_has_dwlatitude() {
_has_bits_[0] |= 0x00000004u;
}
inline void ProJDDDZGameUserLocationRequest::clear_has_dwlatitude() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ProJDDDZGameUserLocationRequest::clear_dwlatitude() {
dwlatitude_ = 0;
clear_has_dwlatitude();
}
inline double ProJDDDZGameUserLocationRequest::dwlatitude() const {
return dwlatitude_;
}
inline void ProJDDDZGameUserLocationRequest::set_dwlatitude(double value) {
set_has_dwlatitude();
dwlatitude_ = value;
}
// optional bytes strDistrict = 4;
inline bool ProJDDDZGameUserLocationRequest::has_strdistrict() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ProJDDDZGameUserLocationRequest::set_has_strdistrict() {
_has_bits_[0] |= 0x00000008u;
}
inline void ProJDDDZGameUserLocationRequest::clear_has_strdistrict() {
_has_bits_[0] &= ~0x00000008u;
}
inline void ProJDDDZGameUserLocationRequest::clear_strdistrict() {
if (strdistrict_ != &::google::protobuf::internal::kEmptyString) {
strdistrict_->clear();
}
clear_has_strdistrict();
}
inline const ::std::string& ProJDDDZGameUserLocationRequest::strdistrict() const {
return *strdistrict_;
}
inline void ProJDDDZGameUserLocationRequest::set_strdistrict(const ::std::string& value) {
set_has_strdistrict();
if (strdistrict_ == &::google::protobuf::internal::kEmptyString) {
strdistrict_ = new ::std::string;
}
strdistrict_->assign(value);
}
inline void ProJDDDZGameUserLocationRequest::set_strdistrict(const char* value) {
set_has_strdistrict();
if (strdistrict_ == &::google::protobuf::internal::kEmptyString) {
strdistrict_ = new ::std::string;
}
strdistrict_->assign(value);
}
inline void ProJDDDZGameUserLocationRequest::set_strdistrict(const void* value, size_t size) {
set_has_strdistrict();
if (strdistrict_ == &::google::protobuf::internal::kEmptyString) {
strdistrict_ = new ::std::string;
}
strdistrict_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ProJDDDZGameUserLocationRequest::mutable_strdistrict() {
set_has_strdistrict();
if (strdistrict_ == &::google::protobuf::internal::kEmptyString) {
strdistrict_ = new ::std::string;
}
return strdistrict_;
}
inline ::std::string* ProJDDDZGameUserLocationRequest::release_strdistrict() {
clear_has_strdistrict();
if (strdistrict_ == &::google::protobuf::internal::kEmptyString) {
return NULL;
} else {
::std::string* temp = strdistrict_;
strdistrict_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
return temp;
}
}
inline void ProJDDDZGameUserLocationRequest::set_allocated_strdistrict(::std::string* strdistrict) {
if (strdistrict_ != &::google::protobuf::internal::kEmptyString) {
delete strdistrict_;
}
if (strdistrict) {
set_has_strdistrict();
strdistrict_ = strdistrict;
} else {
clear_has_strdistrict();
strdistrict_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
}
}
// optional bytes strStreetName = 5;
inline bool ProJDDDZGameUserLocationRequest::has_strstreetname() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ProJDDDZGameUserLocationRequest::set_has_strstreetname() {
_has_bits_[0] |= 0x00000010u;
}
inline void ProJDDDZGameUserLocationRequest::clear_has_strstreetname() {
_has_bits_[0] &= ~0x00000010u;
}
inline void ProJDDDZGameUserLocationRequest::clear_strstreetname() {
if (strstreetname_ != &::google::protobuf::internal::kEmptyString) {
strstreetname_->clear();
}
clear_has_strstreetname();
}
inline const ::std::string& ProJDDDZGameUserLocationRequest::strstreetname() const {
return *strstreetname_;
}
inline void ProJDDDZGameUserLocationRequest::set_strstreetname(const ::std::string& value) {
set_has_strstreetname();
if (strstreetname_ == &::google::protobuf::internal::kEmptyString) {
strstreetname_ = new ::std::string;
}
strstreetname_->assign(value);
}
inline void ProJDDDZGameUserLocationRequest::set_strstreetname(const char* value) {
set_has_strstreetname();
if (strstreetname_ == &::google::protobuf::internal::kEmptyString) {
strstreetname_ = new ::std::string;
}
strstreetname_->assign(value);
}
inline void ProJDDDZGameUserLocationRequest::set_strstreetname(const void* value, size_t size) {
set_has_strstreetname();
if (strstreetname_ == &::google::protobuf::internal::kEmptyString) {
strstreetname_ = new ::std::string;
}
strstreetname_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ProJDDDZGameUserLocationRequest::mutable_strstreetname() {
set_has_strstreetname();
if (strstreetname_ == &::google::protobuf::internal::kEmptyString) {
strstreetname_ = new ::std::string;
}
return strstreetname_;
}
inline ::std::string* ProJDDDZGameUserLocationRequest::release_strstreetname() {
clear_has_strstreetname();
if (strstreetname_ == &::google::protobuf::internal::kEmptyString) {
return NULL;
} else {
::std::string* temp = strstreetname_;
strstreetname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
return temp;
}
}
inline void ProJDDDZGameUserLocationRequest::set_allocated_strstreetname(::std::string* strstreetname) {
if (strstreetname_ != &::google::protobuf::internal::kEmptyString) {
delete strstreetname_;
}
if (strstreetname) {
set_has_strstreetname();
strstreetname_ = strstreetname;
} else {
clear_has_strstreetname();
strstreetname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
}
}
// -------------------------------------------------------------------
// ProJDDDZGameSyncCardResponse
// optional int32 seat = 2;
inline bool ProJDDDZGameSyncCardResponse::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameSyncCardResponse::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameSyncCardResponse::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameSyncCardResponse::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameSyncCardResponse::seat() const {
return seat_;
}
inline void ProJDDDZGameSyncCardResponse::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// repeated int32 handmahs = 3;
inline int ProJDDDZGameSyncCardResponse::handmahs_size() const {
return handmahs_.size();
}
inline void ProJDDDZGameSyncCardResponse::clear_handmahs() {
handmahs_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameSyncCardResponse::handmahs(int index) const {
return handmahs_.Get(index);
}
inline void ProJDDDZGameSyncCardResponse::set_handmahs(int index, ::google::protobuf::int32 value) {
handmahs_.Set(index, value);
}
inline void ProJDDDZGameSyncCardResponse::add_handmahs(::google::protobuf::int32 value) {
handmahs_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameSyncCardResponse::handmahs() const {
return handmahs_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameSyncCardResponse::mutable_handmahs() {
return &handmahs_;
}
// -------------------------------------------------------------------
// ProJDDDZGameUserPhoneStatusRequest
// optional int32 seat_id = 1;
inline bool ProJDDDZGameUserPhoneStatusRequest::has_seat_id() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameUserPhoneStatusRequest::set_has_seat_id() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameUserPhoneStatusRequest::clear_has_seat_id() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameUserPhoneStatusRequest::clear_seat_id() {
seat_id_ = 0;
clear_has_seat_id();
}
inline ::google::protobuf::int32 ProJDDDZGameUserPhoneStatusRequest::seat_id() const {
return seat_id_;
}
inline void ProJDDDZGameUserPhoneStatusRequest::set_seat_id(::google::protobuf::int32 value) {
set_has_seat_id();
seat_id_ = value;
}
// optional int32 userstatus = 2;
inline bool ProJDDDZGameUserPhoneStatusRequest::has_userstatus() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameUserPhoneStatusRequest::set_has_userstatus() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameUserPhoneStatusRequest::clear_has_userstatus() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameUserPhoneStatusRequest::clear_userstatus() {
userstatus_ = 0;
clear_has_userstatus();
}
inline ::google::protobuf::int32 ProJDDDZGameUserPhoneStatusRequest::userstatus() const {
return userstatus_;
}
inline void ProJDDDZGameUserPhoneStatusRequest::set_userstatus(::google::protobuf::int32 value) {
set_has_userstatus();
userstatus_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameUserGiveUpRequest
// optional int32 seat_id = 1;
inline bool ProJDDDZGameUserGiveUpRequest::has_seat_id() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameUserGiveUpRequest::set_has_seat_id() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameUserGiveUpRequest::clear_has_seat_id() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameUserGiveUpRequest::clear_seat_id() {
seat_id_ = 0;
clear_has_seat_id();
}
inline ::google::protobuf::int32 ProJDDDZGameUserGiveUpRequest::seat_id() const {
return seat_id_;
}
inline void ProJDDDZGameUserGiveUpRequest::set_seat_id(::google::protobuf::int32 value) {
set_has_seat_id();
seat_id_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameUserHintRequest
// -------------------------------------------------------------------
// ProJDDDZGameUserHintResponse
// optional int32 lenth = 1;
inline bool ProJDDDZGameUserHintResponse::has_lenth() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameUserHintResponse::set_has_lenth() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameUserHintResponse::clear_has_lenth() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameUserHintResponse::clear_lenth() {
lenth_ = 0;
clear_has_lenth();
}
inline ::google::protobuf::int32 ProJDDDZGameUserHintResponse::lenth() const {
return lenth_;
}
inline void ProJDDDZGameUserHintResponse::set_lenth(::google::protobuf::int32 value) {
set_has_lenth();
lenth_ = value;
}
// repeated int32 outMahs = 2;
inline int ProJDDDZGameUserHintResponse::outmahs_size() const {
return outmahs_.size();
}
inline void ProJDDDZGameUserHintResponse::clear_outmahs() {
outmahs_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameUserHintResponse::outmahs(int index) const {
return outmahs_.Get(index);
}
inline void ProJDDDZGameUserHintResponse::set_outmahs(int index, ::google::protobuf::int32 value) {
outmahs_.Set(index, value);
}
inline void ProJDDDZGameUserHintResponse::add_outmahs(::google::protobuf::int32 value) {
outmahs_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameUserHintResponse::outmahs() const {
return outmahs_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameUserHintResponse::mutable_outmahs() {
return &outmahs_;
}
// -------------------------------------------------------------------
// ProJDDDZGameUserCallScoreResponse
// optional int32 seat = 1;
inline bool ProJDDDZGameUserCallScoreResponse::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameUserCallScoreResponse::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameUserCallScoreResponse::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameUserCallScoreResponse::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameUserCallScoreResponse::seat() const {
return seat_;
}
inline void ProJDDDZGameUserCallScoreResponse::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// optional int32 usercallscore = 2;
inline bool ProJDDDZGameUserCallScoreResponse::has_usercallscore() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameUserCallScoreResponse::set_has_usercallscore() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameUserCallScoreResponse::clear_has_usercallscore() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameUserCallScoreResponse::clear_usercallscore() {
usercallscore_ = 0;
clear_has_usercallscore();
}
inline ::google::protobuf::int32 ProJDDDZGameUserCallScoreResponse::usercallscore() const {
return usercallscore_;
}
inline void ProJDDDZGameUserCallScoreResponse::set_usercallscore(::google::protobuf::int32 value) {
set_has_usercallscore();
usercallscore_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameUserCallScoreRequest
// optional int32 seat = 1;
inline bool ProJDDDZGameUserCallScoreRequest::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameUserCallScoreRequest::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameUserCallScoreRequest::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameUserCallScoreRequest::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameUserCallScoreRequest::seat() const {
return seat_;
}
inline void ProJDDDZGameUserCallScoreRequest::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// optional int32 usercallscore = 2;
inline bool ProJDDDZGameUserCallScoreRequest::has_usercallscore() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameUserCallScoreRequest::set_has_usercallscore() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameUserCallScoreRequest::clear_has_usercallscore() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameUserCallScoreRequest::clear_usercallscore() {
usercallscore_ = 0;
clear_has_usercallscore();
}
inline ::google::protobuf::int32 ProJDDDZGameUserCallScoreRequest::usercallscore() const {
return usercallscore_;
}
inline void ProJDDDZGameUserCallScoreRequest::set_usercallscore(::google::protobuf::int32 value) {
set_has_usercallscore();
usercallscore_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameCallNotify
// optional int32 seat = 1;
inline bool ProJDDDZGameCallNotify::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameCallNotify::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameCallNotify::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameCallNotify::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameCallNotify::seat() const {
return seat_;
}
inline void ProJDDDZGameCallNotify::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// optional int32 maxCallScore = 2;
inline bool ProJDDDZGameCallNotify::has_maxcallscore() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameCallNotify::set_has_maxcallscore() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameCallNotify::clear_has_maxcallscore() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameCallNotify::clear_maxcallscore() {
maxcallscore_ = 0;
clear_has_maxcallscore();
}
inline ::google::protobuf::int32 ProJDDDZGameCallNotify::maxcallscore() const {
return maxcallscore_;
}
inline void ProJDDDZGameCallNotify::set_maxcallscore(::google::protobuf::int32 value) {
set_has_maxcallscore();
maxcallscore_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameQiangNotify
// optional int32 seat = 1;
inline bool ProJDDDZGameQiangNotify::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameQiangNotify::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameQiangNotify::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameQiangNotify::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameQiangNotify::seat() const {
return seat_;
}
inline void ProJDDDZGameQiangNotify::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameUserCallLandlordResponse
// optional int32 iscallandlord = 1;
inline bool ProJDDDZGameUserCallLandlordResponse::has_iscallandlord() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameUserCallLandlordResponse::set_has_iscallandlord() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameUserCallLandlordResponse::clear_has_iscallandlord() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameUserCallLandlordResponse::clear_iscallandlord() {
iscallandlord_ = 0;
clear_has_iscallandlord();
}
inline ::google::protobuf::int32 ProJDDDZGameUserCallLandlordResponse::iscallandlord() const {
return iscallandlord_;
}
inline void ProJDDDZGameUserCallLandlordResponse::set_iscallandlord(::google::protobuf::int32 value) {
set_has_iscallandlord();
iscallandlord_ = value;
}
// optional int32 score = 2;
inline bool ProJDDDZGameUserCallLandlordResponse::has_score() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameUserCallLandlordResponse::set_has_score() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameUserCallLandlordResponse::clear_has_score() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameUserCallLandlordResponse::clear_score() {
score_ = 0;
clear_has_score();
}
inline ::google::protobuf::int32 ProJDDDZGameUserCallLandlordResponse::score() const {
return score_;
}
inline void ProJDDDZGameUserCallLandlordResponse::set_score(::google::protobuf::int32 value) {
set_has_score();
score_ = value;
}
// optional int32 landlordSeat = 3;
inline bool ProJDDDZGameUserCallLandlordResponse::has_landlordseat() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ProJDDDZGameUserCallLandlordResponse::set_has_landlordseat() {
_has_bits_[0] |= 0x00000004u;
}
inline void ProJDDDZGameUserCallLandlordResponse::clear_has_landlordseat() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ProJDDDZGameUserCallLandlordResponse::clear_landlordseat() {
landlordseat_ = 0;
clear_has_landlordseat();
}
inline ::google::protobuf::int32 ProJDDDZGameUserCallLandlordResponse::landlordseat() const {
return landlordseat_;
}
inline void ProJDDDZGameUserCallLandlordResponse::set_landlordseat(::google::protobuf::int32 value) {
set_has_landlordseat();
landlordseat_ = value;
}
// optional int32 seat = 4;
inline bool ProJDDDZGameUserCallLandlordResponse::has_seat() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ProJDDDZGameUserCallLandlordResponse::set_has_seat() {
_has_bits_[0] |= 0x00000008u;
}
inline void ProJDDDZGameUserCallLandlordResponse::clear_has_seat() {
_has_bits_[0] &= ~0x00000008u;
}
inline void ProJDDDZGameUserCallLandlordResponse::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameUserCallLandlordResponse::seat() const {
return seat_;
}
inline void ProJDDDZGameUserCallLandlordResponse::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// optional bool isSoundCall = 5;
inline bool ProJDDDZGameUserCallLandlordResponse::has_issoundcall() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ProJDDDZGameUserCallLandlordResponse::set_has_issoundcall() {
_has_bits_[0] |= 0x00000010u;
}
inline void ProJDDDZGameUserCallLandlordResponse::clear_has_issoundcall() {
_has_bits_[0] &= ~0x00000010u;
}
inline void ProJDDDZGameUserCallLandlordResponse::clear_issoundcall() {
issoundcall_ = false;
clear_has_issoundcall();
}
inline bool ProJDDDZGameUserCallLandlordResponse::issoundcall() const {
return issoundcall_;
}
inline void ProJDDDZGameUserCallLandlordResponse::set_issoundcall(bool value) {
set_has_issoundcall();
issoundcall_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameUserCallLandlordRequest
// optional int32 seat = 1;
inline bool ProJDDDZGameUserCallLandlordRequest::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameUserCallLandlordRequest::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameUserCallLandlordRequest::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameUserCallLandlordRequest::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameUserCallLandlordRequest::seat() const {
return seat_;
}
inline void ProJDDDZGameUserCallLandlordRequest::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// optional int32 iscallandlord = 2;
inline bool ProJDDDZGameUserCallLandlordRequest::has_iscallandlord() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameUserCallLandlordRequest::set_has_iscallandlord() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameUserCallLandlordRequest::clear_has_iscallandlord() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameUserCallLandlordRequest::clear_iscallandlord() {
iscallandlord_ = 0;
clear_has_iscallandlord();
}
inline ::google::protobuf::int32 ProJDDDZGameUserCallLandlordRequest::iscallandlord() const {
return iscallandlord_;
}
inline void ProJDDDZGameUserCallLandlordRequest::set_iscallandlord(::google::protobuf::int32 value) {
set_has_iscallandlord();
iscallandlord_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameUserQinagLandlordResponse
// optional int32 isQiangLandlord = 1;
inline bool ProJDDDZGameUserQinagLandlordResponse::has_isqianglandlord() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameUserQinagLandlordResponse::set_has_isqianglandlord() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameUserQinagLandlordResponse::clear_has_isqianglandlord() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameUserQinagLandlordResponse::clear_isqianglandlord() {
isqianglandlord_ = 0;
clear_has_isqianglandlord();
}
inline ::google::protobuf::int32 ProJDDDZGameUserQinagLandlordResponse::isqianglandlord() const {
return isqianglandlord_;
}
inline void ProJDDDZGameUserQinagLandlordResponse::set_isqianglandlord(::google::protobuf::int32 value) {
set_has_isqianglandlord();
isqianglandlord_ = value;
}
// optional int32 score = 2;
inline bool ProJDDDZGameUserQinagLandlordResponse::has_score() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameUserQinagLandlordResponse::set_has_score() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameUserQinagLandlordResponse::clear_has_score() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameUserQinagLandlordResponse::clear_score() {
score_ = 0;
clear_has_score();
}
inline ::google::protobuf::int32 ProJDDDZGameUserQinagLandlordResponse::score() const {
return score_;
}
inline void ProJDDDZGameUserQinagLandlordResponse::set_score(::google::protobuf::int32 value) {
set_has_score();
score_ = value;
}
// optional int32 landlordSeat = 3;
inline bool ProJDDDZGameUserQinagLandlordResponse::has_landlordseat() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ProJDDDZGameUserQinagLandlordResponse::set_has_landlordseat() {
_has_bits_[0] |= 0x00000004u;
}
inline void ProJDDDZGameUserQinagLandlordResponse::clear_has_landlordseat() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ProJDDDZGameUserQinagLandlordResponse::clear_landlordseat() {
landlordseat_ = 0;
clear_has_landlordseat();
}
inline ::google::protobuf::int32 ProJDDDZGameUserQinagLandlordResponse::landlordseat() const {
return landlordseat_;
}
inline void ProJDDDZGameUserQinagLandlordResponse::set_landlordseat(::google::protobuf::int32 value) {
set_has_landlordseat();
landlordseat_ = value;
}
// optional int32 seat = 4;
inline bool ProJDDDZGameUserQinagLandlordResponse::has_seat() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ProJDDDZGameUserQinagLandlordResponse::set_has_seat() {
_has_bits_[0] |= 0x00000008u;
}
inline void ProJDDDZGameUserQinagLandlordResponse::clear_has_seat() {
_has_bits_[0] &= ~0x00000008u;
}
inline void ProJDDDZGameUserQinagLandlordResponse::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameUserQinagLandlordResponse::seat() const {
return seat_;
}
inline void ProJDDDZGameUserQinagLandlordResponse::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameUserQiangLandlordRequest
// optional int32 seat = 1;
inline bool ProJDDDZGameUserQiangLandlordRequest::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameUserQiangLandlordRequest::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameUserQiangLandlordRequest::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameUserQiangLandlordRequest::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameUserQiangLandlordRequest::seat() const {
return seat_;
}
inline void ProJDDDZGameUserQiangLandlordRequest::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// optional int32 isQiangLandlord = 2;
inline bool ProJDDDZGameUserQiangLandlordRequest::has_isqianglandlord() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameUserQiangLandlordRequest::set_has_isqianglandlord() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameUserQiangLandlordRequest::clear_has_isqianglandlord() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameUserQiangLandlordRequest::clear_isqianglandlord() {
isqianglandlord_ = 0;
clear_has_isqianglandlord();
}
inline ::google::protobuf::int32 ProJDDDZGameUserQiangLandlordRequest::isqianglandlord() const {
return isqianglandlord_;
}
inline void ProJDDDZGameUserQiangLandlordRequest::set_isqianglandlord(::google::protobuf::int32 value) {
set_has_isqianglandlord();
isqianglandlord_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameSendLastCard
// optional int32 seat = 1;
inline bool ProJDDDZGameSendLastCard::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameSendLastCard::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameSendLastCard::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameSendLastCard::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameSendLastCard::seat() const {
return seat_;
}
inline void ProJDDDZGameSendLastCard::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// repeated .JDDDZMahList cbHandCardData = 2;
inline int ProJDDDZGameSendLastCard::cbhandcarddata_size() const {
return cbhandcarddata_.size();
}
inline void ProJDDDZGameSendLastCard::clear_cbhandcarddata() {
cbhandcarddata_.Clear();
}
inline const ::JDDDZMahList& ProJDDDZGameSendLastCard::cbhandcarddata(int index) const {
return cbhandcarddata_.Get(index);
}
inline ::JDDDZMahList* ProJDDDZGameSendLastCard::mutable_cbhandcarddata(int index) {
return cbhandcarddata_.Mutable(index);
}
inline ::JDDDZMahList* ProJDDDZGameSendLastCard::add_cbhandcarddata() {
return cbhandcarddata_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::JDDDZMahList >&
ProJDDDZGameSendLastCard::cbhandcarddata() const {
return cbhandcarddata_;
}
inline ::google::protobuf::RepeatedPtrField< ::JDDDZMahList >*
ProJDDDZGameSendLastCard::mutable_cbhandcarddata() {
return &cbhandcarddata_;
}
// repeated int32 lastmahs = 3;
inline int ProJDDDZGameSendLastCard::lastmahs_size() const {
return lastmahs_.size();
}
inline void ProJDDDZGameSendLastCard::clear_lastmahs() {
lastmahs_.Clear();
}
inline ::google::protobuf::int32 ProJDDDZGameSendLastCard::lastmahs(int index) const {
return lastmahs_.Get(index);
}
inline void ProJDDDZGameSendLastCard::set_lastmahs(int index, ::google::protobuf::int32 value) {
lastmahs_.Set(index, value);
}
inline void ProJDDDZGameSendLastCard::add_lastmahs(::google::protobuf::int32 value) {
lastmahs_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ProJDDDZGameSendLastCard::lastmahs() const {
return lastmahs_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ProJDDDZGameSendLastCard::mutable_lastmahs() {
return &lastmahs_;
}
// optional int32 laizi = 4;
inline bool ProJDDDZGameSendLastCard::has_laizi() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ProJDDDZGameSendLastCard::set_has_laizi() {
_has_bits_[0] |= 0x00000008u;
}
inline void ProJDDDZGameSendLastCard::clear_has_laizi() {
_has_bits_[0] &= ~0x00000008u;
}
inline void ProJDDDZGameSendLastCard::clear_laizi() {
laizi_ = 0;
clear_has_laizi();
}
inline ::google::protobuf::int32 ProJDDDZGameSendLastCard::laizi() const {
return laizi_;
}
inline void ProJDDDZGameSendLastCard::set_laizi(::google::protobuf::int32 value) {
set_has_laizi();
laizi_ = value;
}
// optional bool isReCome = 5;
inline bool ProJDDDZGameSendLastCard::has_isrecome() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ProJDDDZGameSendLastCard::set_has_isrecome() {
_has_bits_[0] |= 0x00000010u;
}
inline void ProJDDDZGameSendLastCard::clear_has_isrecome() {
_has_bits_[0] &= ~0x00000010u;
}
inline void ProJDDDZGameSendLastCard::clear_isrecome() {
isrecome_ = false;
clear_has_isrecome();
}
inline bool ProJDDDZGameSendLastCard::isrecome() const {
return isrecome_;
}
inline void ProJDDDZGameSendLastCard::set_isrecome(bool value) {
set_has_isrecome();
isrecome_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameUserMingPaiRequest
// optional int32 seat = 1;
inline bool ProJDDDZGameUserMingPaiRequest::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameUserMingPaiRequest::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameUserMingPaiRequest::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameUserMingPaiRequest::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameUserMingPaiRequest::seat() const {
return seat_;
}
inline void ProJDDDZGameUserMingPaiRequest::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// optional bool isMingPai = 2;
inline bool ProJDDDZGameUserMingPaiRequest::has_ismingpai() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameUserMingPaiRequest::set_has_ismingpai() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameUserMingPaiRequest::clear_has_ismingpai() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameUserMingPaiRequest::clear_ismingpai() {
ismingpai_ = false;
clear_has_ismingpai();
}
inline bool ProJDDDZGameUserMingPaiRequest::ismingpai() const {
return ismingpai_;
}
inline void ProJDDDZGameUserMingPaiRequest::set_ismingpai(bool value) {
set_has_ismingpai();
ismingpai_ = value;
}
// optional int32 beilv = 3;
inline bool ProJDDDZGameUserMingPaiRequest::has_beilv() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ProJDDDZGameUserMingPaiRequest::set_has_beilv() {
_has_bits_[0] |= 0x00000004u;
}
inline void ProJDDDZGameUserMingPaiRequest::clear_has_beilv() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ProJDDDZGameUserMingPaiRequest::clear_beilv() {
beilv_ = 0;
clear_has_beilv();
}
inline ::google::protobuf::int32 ProJDDDZGameUserMingPaiRequest::beilv() const {
return beilv_;
}
inline void ProJDDDZGameUserMingPaiRequest::set_beilv(::google::protobuf::int32 value) {
set_has_beilv();
beilv_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameUserMingPaiResponse
// optional int32 seat = 1;
inline bool ProJDDDZGameUserMingPaiResponse::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameUserMingPaiResponse::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameUserMingPaiResponse::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameUserMingPaiResponse::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameUserMingPaiResponse::seat() const {
return seat_;
}
inline void ProJDDDZGameUserMingPaiResponse::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// optional bool isMingPai = 2;
inline bool ProJDDDZGameUserMingPaiResponse::has_ismingpai() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameUserMingPaiResponse::set_has_ismingpai() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameUserMingPaiResponse::clear_has_ismingpai() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameUserMingPaiResponse::clear_ismingpai() {
ismingpai_ = false;
clear_has_ismingpai();
}
inline bool ProJDDDZGameUserMingPaiResponse::ismingpai() const {
return ismingpai_;
}
inline void ProJDDDZGameUserMingPaiResponse::set_ismingpai(bool value) {
set_has_ismingpai();
ismingpai_ = value;
}
// optional int32 score = 3;
inline bool ProJDDDZGameUserMingPaiResponse::has_score() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ProJDDDZGameUserMingPaiResponse::set_has_score() {
_has_bits_[0] |= 0x00000004u;
}
inline void ProJDDDZGameUserMingPaiResponse::clear_has_score() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ProJDDDZGameUserMingPaiResponse::clear_score() {
score_ = 0;
clear_has_score();
}
inline ::google::protobuf::int32 ProJDDDZGameUserMingPaiResponse::score() const {
return score_;
}
inline void ProJDDDZGameUserMingPaiResponse::set_score(::google::protobuf::int32 value) {
set_has_score();
score_ = value;
}
// optional int32 mingtag = 4;
inline bool ProJDDDZGameUserMingPaiResponse::has_mingtag() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ProJDDDZGameUserMingPaiResponse::set_has_mingtag() {
_has_bits_[0] |= 0x00000008u;
}
inline void ProJDDDZGameUserMingPaiResponse::clear_has_mingtag() {
_has_bits_[0] &= ~0x00000008u;
}
inline void ProJDDDZGameUserMingPaiResponse::clear_mingtag() {
mingtag_ = 0;
clear_has_mingtag();
}
inline ::google::protobuf::int32 ProJDDDZGameUserMingPaiResponse::mingtag() const {
return mingtag_;
}
inline void ProJDDDZGameUserMingPaiResponse::set_mingtag(::google::protobuf::int32 value) {
set_has_mingtag();
mingtag_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameMingNotify
// optional int32 seat = 1;
inline bool ProJDDDZGameMingNotify::has_seat() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProJDDDZGameMingNotify::set_has_seat() {
_has_bits_[0] |= 0x00000001u;
}
inline void ProJDDDZGameMingNotify::clear_has_seat() {
_has_bits_[0] &= ~0x00000001u;
}
inline void ProJDDDZGameMingNotify::clear_seat() {
seat_ = 0;
clear_has_seat();
}
inline ::google::protobuf::int32 ProJDDDZGameMingNotify::seat() const {
return seat_;
}
inline void ProJDDDZGameMingNotify::set_seat(::google::protobuf::int32 value) {
set_has_seat();
seat_ = value;
}
// optional int32 tag = 2;
inline bool ProJDDDZGameMingNotify::has_tag() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProJDDDZGameMingNotify::set_has_tag() {
_has_bits_[0] |= 0x00000002u;
}
inline void ProJDDDZGameMingNotify::clear_has_tag() {
_has_bits_[0] &= ~0x00000002u;
}
inline void ProJDDDZGameMingNotify::clear_tag() {
tag_ = 0;
clear_has_tag();
}
inline ::google::protobuf::int32 ProJDDDZGameMingNotify::tag() const {
return tag_;
}
inline void ProJDDDZGameMingNotify::set_tag(::google::protobuf::int32 value) {
set_has_tag();
tag_ = value;
}
// optional float time = 3;
inline bool ProJDDDZGameMingNotify::has_time() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ProJDDDZGameMingNotify::set_has_time() {
_has_bits_[0] |= 0x00000004u;
}
inline void ProJDDDZGameMingNotify::clear_has_time() {
_has_bits_[0] &= ~0x00000004u;
}
inline void ProJDDDZGameMingNotify::clear_time() {
time_ = 0;
clear_has_time();
}
inline float ProJDDDZGameMingNotify::time() const {
return time_;
}
inline void ProJDDDZGameMingNotify::set_time(float value) {
set_has_time();
time_ = value;
}
// -------------------------------------------------------------------
// ProJDDDZGameStartAgain
// @@protoc_insertion_point(namespace_scope)
#ifndef SWIG
namespace google {
namespace protobuf {
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameStatusResponse_MSGID>() {
return ::ProJDDDZGameStatusResponse_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameDeskInfoResponse_MSGID>() {
return ::ProJDDDZGameDeskInfoResponse_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameReadyNotify_MSGID>() {
return ::ProJDDDZGameReadyNotify_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameReadyRequest_MSGID>() {
return ::ProJDDDZGameReadyRequest_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameReadyResponse_MSGID>() {
return ::ProJDDDZGameReadyResponse_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameStart_MSGID>() {
return ::ProJDDDZGameStart_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameDiceNotify_MSGID>() {
return ::ProJDDDZGameDiceNotify_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameDiceRequest_MSGID>() {
return ::ProJDDDZGameDiceRequest_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameDiceResult_MSGID>() {
return ::ProJDDDZGameDiceResult_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameSendMahs_MSGID>() {
return ::ProJDDDZGameSendMahs_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameKingData_MSGID>() {
return ::ProJDDDZGameKingData_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameOutMahsResponse_MSGID>() {
return ::ProJDDDZGameOutMahsResponse_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameTimerPower_MSGID>() {
return ::ProJDDDZGameTimerPower_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameOperateNotify_MSGID>() {
return ::ProJDDDZGameOperateNotify_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameOperateResult_MSGID>() {
return ::ProJDDDZGameOperateResult_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameOperateRequest_MSGID>() {
return ::ProJDDDZGameOperateRequest_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameTrust_MSGID>() {
return ::ProJDDDZGameTrust_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameOutMahRequest_MSGID>() {
return ::ProJDDDZGameOutMahRequest_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameCatchCard_MSGID>() {
return ::ProJDDDZGameCatchCard_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameEnd_MSGID>() {
return ::ProJDDDZGameEnd_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameQuickSoundRequest_MSGID>() {
return ::ProJDDDZGameQuickSoundRequest_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameQuickSoundResponse_MSGID>() {
return ::ProJDDDZGameQuickSoundResponse_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameSendDiscardMahs_MSGID>() {
return ::ProJDDDZGameSendDiscardMahs_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameSendActionMahs_MSGID>() {
return ::ProJDDDZGameSendActionMahs_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameBrokenRequest_MSGID>() {
return ::ProJDDDZGameBrokenRequest_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameBrokenOperate_MSGID>() {
return ::ProJDDDZGameBrokenOperate_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameBrokenNotify_MSGID>() {
return ::ProJDDDZGameBrokenNotify_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameRuleConfig_MSGID>() {
return ::ProJDDDZGameRuleConfig_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameBrokenStatus_MSGID>() {
return ::ProJDDDZGameBrokenStatus_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameDataResp_MSGID>() {
return ::ProJDDDZGameDataResp_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameRecordRequest_MSGID>() {
return ::ProJDDDZGameRecordRequest_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameRecordResponse_MSGID>() {
return ::ProJDDDZGameRecordResponse_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameUserLocationRequest_MSGID>() {
return ::ProJDDDZGameUserLocationRequest_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameSyncCardResponse_MSGID>() {
return ::ProJDDDZGameSyncCardResponse_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameUserPhoneStatusRequest_MSGID>() {
return ::ProJDDDZGameUserPhoneStatusRequest_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameUserGiveUpRequest_MSGID>() {
return ::ProJDDDZGameUserGiveUpRequest_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameUserHintRequest_MSGID>() {
return ::ProJDDDZGameUserHintRequest_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameUserHintResponse_MSGID>() {
return ::ProJDDDZGameUserHintResponse_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameUserCallScoreResponse_MSGID>() {
return ::ProJDDDZGameUserCallScoreResponse_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameUserCallScoreRequest_MSGID>() {
return ::ProJDDDZGameUserCallScoreRequest_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameCallNotify_MSGID>() {
return ::ProJDDDZGameCallNotify_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameQiangNotify_MSGID>() {
return ::ProJDDDZGameQiangNotify_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameUserCallLandlordResponse_MSGID>() {
return ::ProJDDDZGameUserCallLandlordResponse_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameUserCallLandlordRequest_MSGID>() {
return ::ProJDDDZGameUserCallLandlordRequest_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameUserQinagLandlordResponse_MSGID>() {
return ::ProJDDDZGameUserQinagLandlordResponse_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameUserQiangLandlordRequest_MSGID>() {
return ::ProJDDDZGameUserQiangLandlordRequest_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameSendLastCard_MSGID>() {
return ::ProJDDDZGameSendLastCard_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameUserMingPaiRequest_MSGID>() {
return ::ProJDDDZGameUserMingPaiRequest_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameUserMingPaiResponse_MSGID>() {
return ::ProJDDDZGameUserMingPaiResponse_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameMingNotify_MSGID>() {
return ::ProJDDDZGameMingNotify_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ProJDDDZGameStartAgain_MSGID>() {
return ::ProJDDDZGameStartAgain_MSGID_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::JDDDZGameState>() {
return ::JDDDZGameState_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::JDDDZSEND_TYPE>() {
return ::JDDDZSEND_TYPE_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::JDDDZKIGN_TYPE>() {
return ::JDDDZKIGN_TYPE_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::JDDDZBROKEN_TYPE>() {
return ::JDDDZBROKEN_TYPE_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::JDDDZBROKEN_OPERATE>() {
return ::JDDDZBROKEN_OPERATE_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::JDDDZBROKEN_CODE>() {
return ::JDDDZBROKEN_CODE_descriptor();
}
} // namespace google
} // namespace protobuf
#endif // SWIG
// @@protoc_insertion_point(global_scope)
#endif // PROTOBUF_jdddzpk_2eproto__INCLUDED
| [
"153274152@qq.com"
] | 153274152@qq.com |
88c3129bc55dda8c189690eabccfb5d6469f8c50 | 118aaad005fa08384aa41989b8370a32ee50e3e9 | /Projects/Consol/net.cpp | 5c2ae46a5e049de99ceeb0953545d53ab3ac290d | [] | no_license | Roman2017-2018/-9 | 37e0f860212ed335f7f71c9cc5d1b90dc2cbceda | dfa6a30a4428da85129b0f5a13795113124aa2d1 | refs/heads/master | 2020-03-30T15:41:39.175559 | 2019-09-12T19:21:37 | 2019-09-12T19:21:37 | 151,375,159 | 4 | 0 | null | 2018-10-03T18:47:43 | 2018-10-03T07:18:48 | C# | UTF-8 | C++ | false | false | 2,376 | cpp | #include "trainingSet.h"
#include "neuron.h"
#include "net.h"
double net::recentAverageSmoothingFactor = 100.0; // Number of training samples to average over
net::net(const std::vector<unsigned> &topology)
{
unsigned numLayers = topology.size();
for (unsigned layerNum = 0; layerNum < numLayers; ++layerNum) {
layers.push_back(Layer());
unsigned numOutputs = layerNum == topology.size() - 1 ? 0 : topology[layerNum + 1];
for (unsigned neuronNum = 0; neuronNum <= topology[layerNum]; ++neuronNum) {
layers.back().push_back(neuron(numOutputs, neuronNum));
}
layers.back().back().setOutputVal(1.0);
}
}
void net::getResults(std::vector<double> &resultVals) const
{
resultVals.clear();
for (unsigned n = 0; n < layers.back().size() - 1; ++n)
{
resultVals.push_back(layers.back()[n].getOutputVal());
}
}
void net::backProp(const std::vector<double> &targetVals)
{
Layer &outputLayer = layers.back();
error = 0.0;
for (unsigned n = 0; n < outputLayer.size() - 1; ++n)
{
double delta = targetVals[n] - outputLayer[n].getOutputVal();
error += delta * delta;
}
error /= outputLayer.size() - 1;
error = sqrt(error);
recentAverageError =
(recentAverageError * recentAverageSmoothingFactor + error)
/ (recentAverageSmoothingFactor + 1.0);
for (unsigned n = 0; n < outputLayer.size() - 1; ++n)
{
outputLayer[n].calcOutputGradients(targetVals[n]);
}
for (unsigned layerNum = layers.size() - 2; layerNum > 0; --layerNum)
{
Layer &hiddenLayer = layers[layerNum];
Layer &nextLayer = layers[layerNum + 1];
for (unsigned n = 0; n < hiddenLayer.size(); ++n)
{
hiddenLayer[n].calcHiddenGradients(nextLayer);
}
}
for (unsigned layerNum = layers.size() - 1; layerNum > 0; --layerNum)
{
Layer &layer = layers[layerNum];
Layer &prevLayer = layers[layerNum - 1];
for (unsigned n = 0; n < layer.size() - 1; ++n)
{
layer[n].updateInputWeights(prevLayer);
}
}
}
void net::feedForward(const std::vector<double> &inputVals)
{
assert(inputVals.size() == layers[0].size() - 1);
for (unsigned i = 0; i < inputVals.size(); ++i) {
layers[0][i].setOutputVal(inputVals[i]);
}
for (unsigned layerNum = 1; layerNum < layers.size(); ++layerNum) {
Layer &prevLayer = layers[layerNum - 1];
for (unsigned n = 0; n < layers[layerNum].size() - 1; ++n) {
layers[layerNum][n].feedForward(prevLayer);
}
}
}
| [
"papa-ap@list.ru"
] | papa-ap@list.ru |
78d055418d00467aefb735f2b4f1307116ca2bf3 | e1515c513a35bc54471ebee88a3bbf6636af3b9d | /An/완전탐색1/1759_암호만들기.cpp | ea98c3149058380703af140bd38d947f7e9d71ee | [] | no_license | anjaekwang/SW-Algorithm | 1158624ec55a03ac4eaf4c04273c55c490ecbe11 | b04dd00ba8b17c2d71b28e251db576be2367a31e | refs/heads/master | 2020-05-18T11:59:42.236334 | 2019-11-08T07:35:20 | 2019-11-08T07:35:20 | 184,395,990 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 1,117 | cpp | /*#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
char s[15];
bool check(char a) //모음 여부
{
char S[5] = { 'a', 'e', 'i', 'o', 'u' };
for(int i=0; i<5; i++)
{
if (a == S[i]) return true;
}
return false;
}
int main()
{
int L, C;
scanf("%d %d", &L, &C);
vector<int> mask(C, 0);
vector<char> temp;
vector<vector<char>> ans;
for (int i = C-L; i < C; i++) mask[i] = 1;
for (int i = 0; i < C; i++) scanf(" %c", s + i);
do
{
int a = 0, b = 0; //a 모음개수, b 자음개수
for (int i = 0; i < C; i++)
{
if (mask[i] == 1)
{
if (check(s[i])) a++;
else b++;
temp.push_back(s[i]);
}
}
if (a >= 1 && b >= 2)
{
sort(temp.begin(), temp.end());
ans.push_back(temp);
}
temp.clear();
} while (next_permutation(mask.begin(), mask.end()));
int size = ans.size();
sort(ans.begin(), ans.end());
for (int i = 0; i < size; i++)
{
for (int j = 0; j < L; j++) printf("%c", ans[i][j]);
printf("\n");
}
system("pause");
return 0;
}*/
/*
영어모음 아에이오우 aeiou밖에없음
*/ | [
"dksworhkd123@naver.com"
] | dksworhkd123@naver.com |
2bd23be24f1a7cab86cae9583a28dfaf9484cb0d | a4d451d991e52520f3e671fb6e9d9dd6d756ed19 | /dumbo_hardware_interface/src/dumbo_hw.cpp | b9b2bd5e3c91cf78cc90f54b8edd69fbaddabf35 | [] | no_license | kth-ros-pkg/dumbo_control | 7bdb9f600b9441264bc0a6273e1720e16a0ae9de | 7b474578def525700ebc0535e52d55c972d61cfa | refs/heads/hydro-devel | 2020-04-14T19:10:49.446731 | 2015-03-26T19:15:20 | 2015-03-26T19:15:20 | 26,872,840 | 3 | 2 | null | 2015-03-26T17:39:22 | 2014-11-19T17:26:31 | null | UTF-8 | C++ | false | false | 5,699 | cpp | /*
* dumbo_hw.cpp
*
* Dumbo hardware interface for the ros_control framework
* Created on: Nov 20, 2014
* Authors: Francisco Viña
* fevb <at> kth.se
*/
/* Copyright (c) 2014, Francisco Vina, CVAP, KTH
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the KTH nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL KTH BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <dumbo_hardware_interface/dumbo_hw.h>
namespace dumbo_hardware_interface
{
DumboHW::DumboHW(): disengage_arms_(false)
{
boost::shared_ptr<pthread_mutex_t> left_arm_CAN_mutex(new pthread_mutex_t);
*left_arm_CAN_mutex = PTHREAD_MUTEX_INITIALIZER;
boost::shared_ptr<canHandle> left_arm_CAN_handle(new canHandle(0));
left_arm_hw.reset(new SchunkArmHW(ros::NodeHandle("/left_arm"),
left_arm_CAN_mutex,
left_arm_CAN_handle));
pg70_hw.reset(new PG70HW(ros::NodeHandle("/PG70_gripper"),
left_arm_CAN_mutex,
left_arm_CAN_handle));
boost::shared_ptr<pthread_mutex_t> right_arm_CAN_mutex(new pthread_mutex_t);
*right_arm_CAN_mutex = PTHREAD_MUTEX_INITIALIZER;
boost::shared_ptr<canHandle> right_arm_CAN_handle(new canHandle(0));
right_arm_hw.reset(new SchunkArmHW(ros::NodeHandle("/right_arm"),
right_arm_CAN_mutex,
right_arm_CAN_handle));
left_ft_sensor_hw.reset(new ForceTorqueSensorHW(ros::NodeHandle("/left_arm_ft_sensor")));
right_ft_sensor_hw.reset(new ForceTorqueSensorHW(ros::NodeHandle("/right_arm_ft_sensor")));
// register hardware interfaces
registerHW();
}
DumboHW::~DumboHW()
{
}
void DumboHW::connect()
{
if(!left_arm_hw->connect())
{
ROS_ERROR("Error connecting to left arm");
}
if(!right_arm_hw->connect())
{
ROS_ERROR("Error connecting to right arm");
}
if(!pg70_hw->connect())
{
ROS_ERROR("Error connecting to PG70 gripper");
}
if(!left_ft_sensor_hw->connect())
{
ROS_ERROR("Error connecting left arm FT sensor");
}
if(!right_ft_sensor_hw->connect())
{
ROS_ERROR("Error connecting right arm FT sensor");
}
}
void DumboHW::disconnect()
{
left_arm_hw->disconnect();
right_arm_hw->disconnect();
pg70_hw->disconnect();
left_ft_sensor_hw->disconnect();
right_ft_sensor_hw->disconnect();
}
void DumboHW::stop()
{
left_arm_hw->stop();
right_arm_hw->stop();
}
void DumboHW::recover()
{
left_arm_hw->recover();
right_arm_hw->recover();
pg70_hw->recover();
}
void DumboHW::read()
{
if(!disengage_arms_)
{
left_arm_hw->read(true);
right_arm_hw->read(true);
}
pg70_hw->read();
left_ft_sensor_hw->read();
right_ft_sensor_hw->read();
}
void DumboHW::write()
{
pg70_hw->writeReadVel();
if(!disengage_arms_)
{
left_arm_hw->write();
right_arm_hw->write();
}
left_ft_sensor_hw->write();
right_ft_sensor_hw->write();
}
void DumboHW::write(double gripper_pos_command)
{
// send position command to PG70
pg70_hw->writeReadPos(gripper_pos_command);
if(!disengage_arms_)
{
left_arm_hw->write();
right_arm_hw->write();
}
left_ft_sensor_hw->write();
right_ft_sensor_hw->write();
}
void DumboHW::disengageArms()
{
disengage_arms_ = true;
}
void DumboHW::engageArms()
{
disengage_arms_ = false;
}
void DumboHW::registerHW()
{
// register the handles
left_arm_hw->registerHandles(js_interface_,
vj_interface_);
right_arm_hw->registerHandles(js_interface_,
vj_interface_);
pg70_hw->registerHandles(js_interface_,
vj_interface_,
pj_interface_);
left_ft_sensor_hw->registerHandles(ft_sensor_interface_);
right_ft_sensor_hw->registerHandles(ft_sensor_interface_);
// register the interfaces
registerInterface(&js_interface_);
registerInterface(&vj_interface_);
registerInterface(&pj_interface_);
registerInterface(&ft_sensor_interface_);
}
}
| [
"fevb@kth.se"
] | fevb@kth.se |
964c40295bdc7aac75c09eba64357855dc5b8c28 | 23181caa1b1ef6160ec011e016145c0ac160aa2c | /src/cpp/euler.cpp | 2d95780bdeda7e3c39ddbc9356705bc41815be00 | [] | no_license | PhoenixDigitalFX/pimath | 695614730eabf867eb6229ed6721c912a3c79e54 | d79c56d492887d52e1e6f7ec0ffa1966a4717b0a | refs/heads/master | 2023-07-22T05:49:57.571378 | 2011-07-22T02:43:39 | 2011-07-22T02:43:39 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,806 | cpp | /*******************************************************************************
Copyright (c) 2011, Dr. D. Studios
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list
of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or other
materials provided with the distribution.
Neither the name of the Dr. D. Studios nor the names of its contributors may be
used to endorse or promote products derived from this software without specific
prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
OF THE POSSIBILITY OF SUCH DAMAGE.
*******************************************************************************/
#include "../Euler.hpp"
using namespace pimath;
namespace bp = boost::python;
void _pimath_export_euler()
{
EulerBind<float>("Eulerf");
EulerBind<double>("Eulerd");
}
| [
"mstreatfield@gmail.com@2ee467b0-33ec-a958-3b7e-56152324c2fe"
] | mstreatfield@gmail.com@2ee467b0-33ec-a958-3b7e-56152324c2fe |
d65c1e01c849c3e2751de39f98167efe36552d26 | 1554f8f6b5252debb68b8c49099091e552a835e8 | /AnEngine/DTimer.cpp | 6156a809be71a3434f4a88deee9b36a93d39dff3 | [
"MIT"
] | permissive | jcyongqin/AnEngine | dad6f9dcc520f9695b008ad118593c5175ae7fd2 | 19e2463705248d72fb64262f56690419d5a9cb3c | refs/heads/master | 2020-03-09T00:56:50.101570 | 2020-01-26T14:28:35 | 2020-01-26T14:28:35 | 128,500,996 | 0 | 0 | MIT | 2020-01-26T14:30:28 | 2018-04-07T05:56:57 | C++ | UTF-8 | C++ | false | false | 3,678 | cpp | #include "DTimer.h"
#include "ThreadPool.hpp"
namespace AnEngine
{
//DTimer* DTimer::m_uniqueObj = nullptr;
DTimer::DTimer() :
m_elapsedTicks(0), m_frameCount(0), m_framesPerSecond(0), m_framesThisSecond(0),
m_isFixedTimeStep(false), m_leftOverTicks(false), m_qpcSecondCounter(0),
m_targetElapsedTicks(TicksPerSecond / 60), m_totalTicks(0)
{
QueryPerformanceFrequency(&m_qpcFrequency);
QueryPerformanceCounter(&m_qpcLastTime);
m_qpcMaxDelta = m_qpcFrequency.QuadPart / 10;
// 将最大增量设置为0.1s
/*Utility::u_s_threadPool.Commit([this]()
{
while (this->m_running)
{
this_thread::sleep_for(std::chrono::milliseconds(1));
this->Tick(nullptr);
}
})*/;
}
DTimer::~DTimer()
{
m_running = false;
}
/*DTimer* DTimer::Instance()
{
if (m_uniqueObj == nullptr)
{
m_uniqueObj = new DTimer();
}
return m_uniqueObj;
}*/
const uint64_t DTimer::GetElapsedTicks()
{
//Tick(nullptr);
return m_elapsedTicks;
}
const double DTimer::GetElapsedSeconds()
{
//Tick(nullptr);
return TicksToSeconds(m_elapsedTicks);
}
const uint64_t DTimer::GetTotalTicks()
{
//Tick(nullptr);
return m_totalTicks;
}
const double DTimer::GetTotalSeconds()
{
//Tick(nullptr);
return TicksToSeconds(m_totalTicks);
}
uint32_t DTimer::GetFrameCount()
{
return m_frameCount;
}
uint32_t DTimer::GetFramePerSecond()
{
return m_framesPerSecond;
}
void DTimer::SetFixedFramerate(bool _isFixedTimeStep)
{
m_isFixedTimeStep = _isFixedTimeStep;
}
void DTimer::SetTargetElapsedTicks(uint64_t _targetElapsed)
{
m_targetElapsedTicks = _targetElapsed;
}
void DTimer::SetTargetElapsedSeconds(double _targetElapsed)
{
m_targetElapsedTicks = SecondsToTicks(_targetElapsed);
}
double DTimer::TicksToSeconds(uint64_t _ticks)
{
return static_cast<double>(_ticks) / TicksPerSecond;
}
uint64_t DTimer::SecondsToTicks(double _seconds)
{
return static_cast<uint64_t>(_seconds * TicksPerSecond);
}
void DTimer::ResetElapsedTime()
{
QueryPerformanceCounter(&m_qpcLastTime);
m_leftOverTicks = 0;
m_framesPerSecond = 0;
m_framesThisSecond = 0;
m_qpcSecondCounter = 0;
}
void DTimer::Tick(LpUpdateFunc _update)
{
LARGE_INTEGER currentTime;
QueryPerformanceCounter(¤tTime);
uint64_t delta = currentTime.QuadPart - m_qpcLastTime.QuadPart;
m_qpcLastTime = currentTime;
m_qpcSecondCounter += delta;
if (delta > m_qpcMaxDelta)
{
delta = m_qpcMaxDelta;
} // 控制过大的delta，例如在debug中中断
delta *= TicksPerSecond;
delta /= m_qpcFrequency.QuadPart;
// QPC单位转国际单位
uint32_t lastFrameCount = m_frameCount;
if (m_isFixedTimeStep)
{
if (abs(static_cast<int>(delta - m_targetElapsedTicks)) < TicksPerSecond / 4000) // ??
{
delta = m_targetElapsedTicks;
}
m_leftOverTicks += delta;
// 防止失之毫厘谬以千里。固定帧率时，打开了垂直同步的程序会由于显示器的问题累积下微小误差
while (m_leftOverTicks >= m_targetElapsedTicks)
{
m_elapsedTicks = m_targetElapsedTicks;
m_totalTicks += m_targetElapsedTicks;
m_leftOverTicks -= m_targetElapsedTicks;
m_frameCount++;
if (_update)
{
_update();
}
}
}
else
{
m_elapsedTicks = delta;
m_totalTicks += delta;
m_leftOverTicks = 0;
m_frameCount++;
if (_update)
{
_update();
}
}
if (m_frameCount != lastFrameCount)
{
m_framesThisSecond++;
}
if (m_qpcSecondCounter >= static_cast<uint64_t>(m_qpcFrequency.QuadPart))
{
m_framesPerSecond = m_framesThisSecond;
m_framesThisSecond = 0;
m_qpcSecondCounter %= m_qpcFrequency.QuadPart;
}
}
} | [
"MyGuanDY@outlook.com"
] | MyGuanDY@outlook.com |
aa88978ffc67a78e5332ef579edffa1ed7dc294a | 8518c8950df85be1e08b11afabcb9e20705fb082 | /nwjs/arduino/lib/Adafruit_NeoPixel/Adafruit_NeoPixel.h | b051d7d17f807bf3be1ac6a50d85b8537696b81f | [
"LGPL-3.0-only",
"BSD-3-Clause"
] | permissive | fendicloser/Kittenblock | b774f33d21af0bab638437a00ac6c6c05ad8f79b | 22f658996c611fb59039e3047c0d4dedd134ab69 | refs/heads/master | 2020-04-01T00:49:11.842018 | 2017-01-09T12:12:21 | 2017-01-09T12:12:21 | 152,714,741 | 1 | 1 | BSD-3-Clause | 2018-10-12T07:58:16 | 2018-10-12T07:58:16 | null | UTF-8 | C++ | false | false | 7,141 | h | /*--------------------------------------------------------------------
This file is part of the Adafruit NeoPixel library.
NeoPixel is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation, either version 3 of
the License, or (at your option) any later version.
NeoPixel 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 NeoPixel. If not, see
<http://www.gnu.org/licenses/>.
--------------------------------------------------------------------*/
#ifndef ADAFRUIT_NEOPIXEL_H
#define ADAFRUIT_NEOPIXEL_H
#if (ARDUINO >= 100)
#include <Arduino.h>
#else
#include <WProgram.h>
#include <pins_arduino.h>
#endif
// The order of primary colors in the NeoPixel data stream can vary
// among device types, manufacturers and even different revisions of
// the same item. The third parameter to the Adafruit_NeoPixel
// constructor encodes the per-pixel byte offsets of the red, green
// and blue primaries (plus white, if present) in the data stream --
// the following #defines provide an easier-to-use named version for
// each permutation. e.g. NEO_GRB indicates a NeoPixel-compatible
// device expecting three bytes per pixel, with the first byte
// containing the green value, second containing red and third
// containing blue. The in-memory representation of a chain of
// NeoPixels is the same as the data-stream order; no re-ordering of
// bytes is required when issuing data to the chain.
// Bits 5,4 of this value are the offset (0-3) from the first byte of
// a pixel to the location of the red color byte. Bits 3,2 are the
// green offset and 1,0 are the blue offset. If it is an RGBW-type
// device (supporting a white primary in addition to R,G,B), bits 7,6
// are the offset to the white byte...otherwise, bits 7,6 are set to
// the same value as 5,4 (red) to indicate an RGB (not RGBW) device.
// i.e. binary representation:
// 0bWWRRGGBB for RGBW devices
// 0bRRRRGGBB for RGB
// RGB NeoPixel permutations; white and red offsets are always same
// Offset: W R G B
#define NEO_RGB ((0 << 6) | (0 << 4) | (1 << 2) | (2))
#define NEO_RBG ((0 << 6) | (0 << 4) | (2 << 2) | (1))
#define NEO_GRB ((1 << 6) | (1 << 4) | (0 << 2) | (2))
#define NEO_GBR ((2 << 6) | (2 << 4) | (0 << 2) | (1))
#define NEO_BRG ((1 << 6) | (1 << 4) | (2 << 2) | (0))
#define NEO_BGR ((2 << 6) | (2 << 4) | (1 << 2) | (0))
// RGBW NeoPixel permutations; all 4 offsets are distinct
// Offset: W R G B
#define NEO_WRGB ((0 << 6) | (1 << 4) | (2 << 2) | (3))
#define NEO_WRBG ((0 << 6) | (1 << 4) | (3 << 2) | (2))
#define NEO_WGRB ((0 << 6) | (2 << 4) | (1 << 2) | (3))
#define NEO_WGBR ((0 << 6) | (3 << 4) | (1 << 2) | (2))
#define NEO_WBRG ((0 << 6) | (2 << 4) | (3 << 2) | (1))
#define NEO_WBGR ((0 << 6) | (3 << 4) | (2 << 2) | (1))
#define NEO_RWGB ((1 << 6) | (0 << 4) | (2 << 2) | (3))
#define NEO_RWBG ((1 << 6) | (0 << 4) | (3 << 2) | (2))
#define NEO_RGWB ((2 << 6) | (0 << 4) | (1 << 2) | (3))
#define NEO_RGBW ((3 << 6) | (0 << 4) | (1 << 2) | (2))
#define NEO_RBWG ((2 << 6) | (0 << 4) | (3 << 2) | (1))
#define NEO_RBGW ((3 << 6) | (0 << 4) | (2 << 2) | (1))
#define NEO_GWRB ((1 << 6) | (2 << 4) | (0 << 2) | (3))
#define NEO_GWBR ((1 << 6) | (3 << 4) | (0 << 2) | (2))
#define NEO_GRWB ((2 << 6) | (1 << 4) | (0 << 2) | (3))
#define NEO_GRBW ((3 << 6) | (1 << 4) | (0 << 2) | (2))
#define NEO_GBWR ((2 << 6) | (3 << 4) | (0 << 2) | (1))
#define NEO_GBRW ((3 << 6) | (2 << 4) | (0 << 2) | (1))
#define NEO_BWRG ((1 << 6) | (2 << 4) | (3 << 2) | (0))
#define NEO_BWGR ((1 << 6) | (3 << 4) | (2 << 2) | (0))
#define NEO_BRWG ((2 << 6) | (1 << 4) | (3 << 2) | (0))
#define NEO_BRGW ((3 << 6) | (1 << 4) | (2 << 2) | (0))
#define NEO_BGWR ((2 << 6) | (3 << 4) | (1 << 2) | (0))
#define NEO_BGRW ((3 << 6) | (2 << 4) | (1 << 2) | (0))
// Add NEO_KHZ400 to the color order value to indicate a 400 KHz
// device. All but the earliest v1 NeoPixels expect an 800 KHz data
// stream, this is the default if unspecified. Because flash space
// is very limited on ATtiny devices (e.g. Trinket, Gemma), v1
// NeoPixels aren't handled by default on those chips, though it can
// be enabled by removing the ifndef/endif below -- but code will be
// bigger. Conversely, can disable the NEO_KHZ400 line on other MCUs
// to remove v1 support and save a little space.
#define NEO_KHZ800 0x0000 // 800 KHz datastream
#ifndef __AVR_ATtiny85__
#define NEO_KHZ400 0x0100 // 400 KHz datastream
#endif
// If 400 KHz support is enabled, the third parameter to the constructor
// requires a 16-bit value (in order to select 400 vs 800 KHz speed).
// If only 800 KHz is enabled (as is default on ATtiny), an 8-bit value
// is sufficient to encode pixel color order, saving some space.
#ifdef NEO_KHZ400
typedef uint16_t neoPixelType;
#else
typedef uint8_t neoPixelType;
#endif
class Adafruit_NeoPixel {
public:
// Constructor: number of LEDs, pin number, LED type
Adafruit_NeoPixel(uint16_t n, uint8_t p=6, neoPixelType t=NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel(void);
~Adafruit_NeoPixel();
void
begin(void),
show(void),
setPin(uint8_t p),
setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b),
setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b, uint8_t w),
setPixelColor(uint16_t n, uint32_t c),
setBrightness(uint8_t),
clear(),
updateLength(uint16_t n),
updateType(neoPixelType t);
uint8_t
*getPixels(void) const,
getBrightness(void) const;
int8_t
getPin(void) { return pin; };
uint16_t
numPixels(void) const;
static uint32_t
Color(uint8_t r, uint8_t g, uint8_t b),
Color(uint8_t r, uint8_t g, uint8_t b, uint8_t w);
uint32_t
getPixelColor(uint16_t n) const;
inline bool
canShow(void) { return (micros() - endTime) >= 50L; }
private:
boolean
#ifdef NEO_KHZ400 // If 400 KHz NeoPixel support enabled...
is800KHz, // ...true if 800 KHz pixels
#endif
begun; // true if begin() previously called
uint16_t
numLEDs, // Number of RGB LEDs in strip
numBytes; // Size of 'pixels' buffer below (3 or 4 bytes/pixel)
int8_t
pin; // Output pin number (-1 if not yet set)
uint8_t
brightness,
*pixels, // Holds LED color values (3 or 4 bytes each)
rOffset, // Index of red byte within each 3- or 4-byte pixel
gOffset, // Index of green byte
bOffset, // Index of blue byte
wOffset; // Index of white byte (same as rOffset if no white)
uint32_t
endTime; // Latch timing reference
#ifdef __AVR__
volatile uint8_t
*port; // Output PORT register
uint8_t
pinMask; // Output PORT bitmask
#endif
};
#endif // ADAFRUIT_NEOPIXEL_H
| [
"4771215@qq.com"
] | 4771215@qq.com |
cb80b3ba6255f0b2d5fe318a84270f8db1ed6f02 | ae5772eb2cf656840741c5973e02668ed78eeaab | /codes_cpp/0026_Remove_Duplicates_from_Sorted_Array.cpp | 6551e53653f38cac8b2842d03c7883ddfa5cb073 | [] | no_license | mondler/leetcode | c71e7381ba93452a8d074270951b67e932e7a07d | 4af44f7364c6fb4d95309056f7a7853de779b3bb | refs/heads/master | 2022-07-21T01:18:49.481991 | 2022-07-06T04:30:22 | 2022-07-06T04:30:22 | 243,165,317 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,576 | cpp | // Given a sorted array nums, remove the duplicates in-place such that each element appear only once and return the new length.
//
// Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.
//
// Example 1:
//
// Given nums = [1,1,2],
//
// Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively.
//
// It doesn't matter what you leave beyond the returned length.
// Example 2:
//
// Given nums = [0,0,1,1,1,2,2,3,3,4],
//
// Your function should return length = 5, with the first five elements of nums being modified to 0, 1, 2, 3, and 4 respectively.
//
// It doesn't matter what values are set beyond the returned length.
// Clarification:
//
// Confused why the returned value is an integer but your answer is an array?
//
// Note that the input array is passed in by reference, which means modification to the input array will be known to the caller as well.
//
// Internally you can think of this:
//
// // nums is passed in by reference. (i.e., without making a copy)
// int len = removeDuplicates(nums);
//
// // any modification to nums in your function would be known by the caller.
// // using the length returned by your function, it prints the first len elements.
// for (int i = 0; i < len; i++) {
// print(nums[i]);
// }
#include <iostream>
#include <vector>
#include <string>
using namespace std;
//
class Solution {
public:
// void swap(int& x, int&y){
// int temp;
// temp = x;
// x = y;
// y = temp;
// return;
// }
int removeDuplicates(vector<int>& nums) {
int s = nums.size();
if (s <= 1) {
return s;
}
int i, j;
i = 1;
j = 1;
int prev = nums[0];
while ((i < s) && (j < s)) {
while ((i < s) && (nums[i] > prev)) {
prev = nums[i];
i++;
}
j = max(j, i + 1);
while ((j < s) && (nums[j] <= prev)) {
j++;
}
cout << i << ' ' << j << endl;
if ((i < s) && (j < s)) {
swap(nums[i], nums[j]);
}
}
return i;
}
};
//
int main() {
std::vector<int> nums = {1, 1, 2};
// int val = 2;
Solution foo = Solution();
cout << foo.removeDuplicates(nums) << endl;
for (const auto i: nums)
cout << i << ' ';
return 0;
}
| [
"mondler0418@yahoo.com"
] | mondler0418@yahoo.com |
0bf9afd04f692fdf1b29f5b5948de88eb075e4e7 | e0d7aced8e3abd1e3dfa7942f247761b7cd1a6e8 | /game_over_scene.h | da0582f7b943e7c6e481af3a084a9e6a6b89dc0d | [] | no_license | royfa28/Break-the-Brick | 7eeb2ff5edd3a52e034ab450bfc442d16828f5d1 | bfa454ce9d47be2f6bb6f422093a516ea223a691 | refs/heads/master | 2022-11-06T05:00:43.387173 | 2020-06-16T08:36:51 | 2020-06-16T08:36:51 | 264,792,066 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 187 | h | #pragma once
#include "scene.h"
class Game_Over_Scene : public Scene {
public:
Game_Over_Scene();
~Game_Over_Scene();
virtual void update(SDL_Window* window) override;
}; | [
"roy.felix1609@gmail.com"
] | roy.felix1609@gmail.com |
a0c088ee69283984367dd6d4ce2953f74ff89bb7 | 21553f6afd6b81ae8403549467230cdc378f32c9 | /arm/cortex/Freescale/MK51D10/include/arch/reg/cmt.hpp | cd8a05150568b7c6e0f6dd1f52ed29e2dd7ef46f | [] | no_license | digint/openmptl-reg-arm-cortex | 3246b68dcb60d4f7c95a46423563cab68cb02b5e | 88e105766edc9299348ccc8d2ff7a9c34cddacd3 | refs/heads/master | 2021-07-18T19:56:42.569685 | 2017-10-26T11:11:35 | 2017-10-26T11:11:35 | 108,407,162 | 3 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 5,557 | hpp | /*
* OpenMPTL - C++ Microprocessor Template Library
*
* This program is a derivative representation of a CMSIS System View
* Description (SVD) file, and is subject to the corresponding license
* (see "Freescale CMSIS-SVD License Agreement.pdf" in the parent directory).
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*/
////////////////////////////////////////////////////////////////////////
//
// Import from CMSIS-SVD: "Freescale/MK51D10.svd"
//
// vendor: Freescale Semiconductor, Inc.
// vendorID: Freescale
// name: MK51D10
// series: Kinetis_K
// version: 1.6
// description: MK51D10 Freescale Microcontroller
// --------------------------------------------------------------------
//
// C++ Header file, containing architecture specific register
// declarations for use in OpenMPTL. It has been converted directly
// from a CMSIS-SVD file.
//
// https://digint.ch/openmptl
// https://github.com/posborne/cmsis-svd
//
#ifndef ARCH_REG_CMT_HPP_INCLUDED
#define ARCH_REG_CMT_HPP_INCLUDED
#warning "using untested register declarations"
#include <register.hpp>
namespace mptl {
/**
* Carrier Modulator Transmitter
*/
struct CMT
{
static constexpr reg_addr_t base_addr = 0x40062000;
/**
* CMT Carrier Generator High Data Register 1
*/
struct CGH1
: public reg< uint8_t, base_addr + 0, rw, 0 >
{
using type = reg< uint8_t, base_addr + 0, rw, 0 >;
using PH = regbits< type, 0, 8 >; /**< Primary Carrier High Time Data Value */
};
/**
* CMT Carrier Generator Low Data Register 1
*/
struct CGL1
: public reg< uint8_t, base_addr + 0x1, rw, 0 >
{
using type = reg< uint8_t, base_addr + 0x1, rw, 0 >;
using PL = regbits< type, 0, 8 >; /**< Primary Carrier Low Time Data Value */
};
/**
* CMT Carrier Generator High Data Register 2
*/
struct CGH2
: public reg< uint8_t, base_addr + 0x2, rw, 0 >
{
using type = reg< uint8_t, base_addr + 0x2, rw, 0 >;
using SH = regbits< type, 0, 8 >; /**< Secondary Carrier High Time Data Value */
};
/**
* CMT Carrier Generator Low Data Register 2
*/
struct CGL2
: public reg< uint8_t, base_addr + 0x3, rw, 0 >
{
using type = reg< uint8_t, base_addr + 0x3, rw, 0 >;
using SL = regbits< type, 0, 8 >; /**< Secondary Carrier Low Time Data Value */
};
/**
* CMT Output Control Register
*/
struct OC
: public reg< uint8_t, base_addr + 0x4, rw, 0 >
{
using type = reg< uint8_t, base_addr + 0x4, rw, 0 >;
using IROPEN = regbits< type, 5, 1 >; /**< IRO Pin Enable */
using CMTPOL = regbits< type, 6, 1 >; /**< CMT Output Polarity */
using IROL = regbits< type, 7, 1 >; /**< IRO Latch Control */
};
/**
* CMT Modulator Status and Control Register
*/
struct MSC
: public reg< uint8_t, base_addr + 0x5, rw, 0 >
{
using type = reg< uint8_t, base_addr + 0x5, rw, 0 >;
using MCGEN = regbits< type, 0, 1 >; /**< Modulator and Carrier Generator Enable */
using EOCIE = regbits< type, 1, 1 >; /**< End of Cycle Interrupt Enable */
using FSK = regbits< type, 2, 1 >; /**< FSK Mode Select */
using BASE = regbits< type, 3, 1 >; /**< Baseband Enable */
using EXSPC = regbits< type, 4, 1 >; /**< Extended Space Enable */
using CMTDIV = regbits< type, 5, 2 >; /**< CMT Clock Divide Prescaler */
using EOCF = regbits< type, 7, 1 >; /**< End Of Cycle Status Flag */
};
/**
* CMT Modulator Data Register Mark High
*/
struct CMD1
: public reg< uint8_t, base_addr + 0x6, rw, 0 >
{
using type = reg< uint8_t, base_addr + 0x6, rw, 0 >;
using MB = regbits< type, 0, 8 >; /**< Controls the upper mark periods of the modulator for all modes. */
};
/**
* CMT Modulator Data Register Mark Low
*/
struct CMD2
: public reg< uint8_t, base_addr + 0x7, rw, 0 >
{
using type = reg< uint8_t, base_addr + 0x7, rw, 0 >;
using MB = regbits< type, 0, 8 >; /**< Controls the lower mark periods of the modulator for all modes. */
};
/**
* CMT Modulator Data Register Space High
*/
struct CMD3
: public reg< uint8_t, base_addr + 0x8, rw, 0 >
{
using type = reg< uint8_t, base_addr + 0x8, rw, 0 >;
using SB = regbits< type, 0, 8 >; /**< Controls the upper space periods of the modulator for all modes. */
};
/**
* CMT Modulator Data Register Space Low
*/
struct CMD4
: public reg< uint8_t, base_addr + 0x9, rw, 0 >
{
using type = reg< uint8_t, base_addr + 0x9, rw, 0 >;
using SB = regbits< type, 0, 8 >; /**< Controls the lower space periods of the modulator for all modes. */
};
/**
* CMT Primary Prescaler Register
*/
struct PPS
: public reg< uint8_t, base_addr + 0xa, rw, 0 >
{
using type = reg< uint8_t, base_addr + 0xa, rw, 0 >;
using PPSDIV = regbits< type, 0, 4 >; /**< Primary Prescaler Divider */
};
/**
* CMT Direct Memory Access Register
*/
struct DMA
: public reg< uint8_t, base_addr + 0xb, rw, 0 >
{
using type = reg< uint8_t, base_addr + 0xb, rw, 0 >;
// fixme: Field name equals parent register name: DMA
using DMA_ = regbits< type, 0, 1 >; /**< DMA Enable */
};
};
} // namespace mptl
#endif // ARCH_REG_CMT_HPP_INCLUDED
| [
"axel@tty0.ch"
] | axel@tty0.ch |
d1b2c64a5dcb929fab6a96254389b40a87d78b67 | a68d7d1081a1636ef179d9b5ba31895ef3978a89 | /gdal/ogr/ogrsf_frmts/osm/ogrosmdriver.cpp | 51edfd04dce856406b99de85ec7edc147e14fbd4 | [
"LicenseRef-scancode-warranty-disclaimer",
"LicenseRef-scancode-info-zip-2005-02",
"BSD-3-Clause",
"SunPro",
"MIT",
"LicenseRef-scancode-public-domain",
"LicenseRef-scancode-other-permissive"
] | permissive | alexandreleroux/gdal | 4694927d696378428980bf021706997b39d4274c | ee35b10bc691775e9334f7e7e02d7d1c41e77be8 | refs/heads/trunk | 2020-04-06T06:42:46.840700 | 2015-10-27T13:36:24 | 2015-10-27T13:36:24 | 45,046,215 | 1 | 0 | null | 2015-10-27T14:23:55 | 2015-10-27T14:23:55 | null | UTF-8 | C++ | false | false | 5,132 | cpp | /******************************************************************************
* $Id$
*
* Project: OpenGIS Simple Features Reference Implementation
* Purpose: Implements OGROSMDriver class.
* Author: Even Rouault, <even dot rouault at mines dash paris dot org>
*
******************************************************************************
* Copyright (c) 2012, Even Rouault <even dot rouault at mines-paris dot 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 "ogr_osm.h"
#include "cpl_conv.h"
/* g++ -DHAVE_EXPAT -fPIC -g -Wall ogr/ogrsf_frmts/osm/ogrosmdriver.cpp ogr/ogrsf_frmts/osm/ogrosmdatasource.cpp ogr/ogrsf_frmts/osm/ogrosmlayer.cpp -Iport -Igcore -Iogr -Iogr/ogrsf_frmts/osm -Iogr/ogrsf_frmts/mitab -Iogr/ogrsf_frmts -shared -o ogr_OSM.so -L. -lgdal */
extern "C" void CPL_DLL RegisterOGROSM();
CPL_CVSID("$Id$");
/************************************************************************/
/* OGROSMDriverIdentify() */
/************************************************************************/
static int OGROSMDriverIdentify( GDALOpenInfo* poOpenInfo )
{
if (poOpenInfo->fpL == NULL )
return FALSE;
const char* pszExt = CPLGetExtension(poOpenInfo->pszFilename);
if( EQUAL(pszExt, "pbf") ||
EQUAL(pszExt, "osm") )
return TRUE;
if( STARTS_WITH_CI(poOpenInfo->pszFilename, "/vsicurl_streaming/") ||
strcmp(poOpenInfo->pszFilename, "/vsistdin/") == 0 ||
strcmp(poOpenInfo->pszFilename, "/dev/stdin/") == 0 )
return -1;
return FALSE;
}
/************************************************************************/
/* Open() */
/************************************************************************/
static GDALDataset *OGROSMDriverOpen( GDALOpenInfo* poOpenInfo )
{
if (poOpenInfo->eAccess == GA_Update )
return NULL;
if( OGROSMDriverIdentify(poOpenInfo) == FALSE )
return NULL;
OGROSMDataSource *poDS = new OGROSMDataSource();
if( !poDS->Open( poOpenInfo->pszFilename, poOpenInfo->papszOpenOptions ) )
{
delete poDS;
poDS = NULL;
}
return poDS;
}
/************************************************************************/
/* RegisterOGROSM() */
/************************************************************************/
void RegisterOGROSM()
{
if (! GDAL_CHECK_VERSION("OGR/OSM driver"))
return;
GDALDriver *poDriver;
if( GDALGetDriverByName( "OSM" ) == NULL )
{
poDriver = new GDALDriver();
poDriver->SetDescription( "OSM" );
poDriver->SetMetadataItem( GDAL_DCAP_VECTOR, "YES" );
poDriver->SetMetadataItem( GDAL_DMD_LONGNAME,
"OpenStreetMap XML and PBF" );
poDriver->SetMetadataItem( GDAL_DMD_EXTENSIONS, "osm pbf" );
poDriver->SetMetadataItem( GDAL_DMD_HELPTOPIC,
"drv_osm.html" );
poDriver->SetMetadataItem( GDAL_DCAP_VIRTUALIO, "YES" );
poDriver->SetMetadataItem( GDAL_DMD_OPENOPTIONLIST,
"<OpenOptionList>"
" <Option name='CONFIG_FILE' type='string' description='Configuration filename.'/>"
" <Option name='USE_CUSTOM_INDEXING' type='boolean' description='Whether to enable custom indexing.' default='YES'/>"
" <Option name='COMPRESS_NODES' type='boolean' description='Whether to compress nodes in temporary DB.' default='NO'/>"
" <Option name='MAX_TMPFILE_SIZE' type='int' description='Maximum size in MB of in-memory temporary file. If it exceeds that value, it will go to disk' default='100'/>"
" <Option name='INTERLEAVED_READING' type='boolean' description='Whether to enable interleveaved reading.' default='NO'/>"
"</OpenOptionList>" );
poDriver->pfnOpen = OGROSMDriverOpen;
poDriver->pfnIdentify = OGROSMDriverIdentify;
GetGDALDriverManager()->RegisterDriver( poDriver );
}
}
| [
"even.rouault@mines-paris.org"
] | even.rouault@mines-paris.org |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.