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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
0ea13e4e0cf10630dce8fe1b211245bad23e6808 | 299648a8c633728662d0b7651cd98afdc28db902 | /src/thirdparty/cefbinary_72/include/wrapper/cef_helpers.h | 0c5820dbb552a0966a3fca24c6c4703996e6f3e0 | [
"BSD-3-Clause",
"LicenseRef-scancode-unknown"
] | permissive | aardvarkxr/aardvark | 2978277b34c2c3894d6aafc4c590f3bda50f4d43 | 300d0d5e9b872ed839fae932c56eff566967d24b | refs/heads/master | 2023-01-12T18:42:10.705028 | 2021-08-18T04:09:02 | 2021-08-18T04:09:02 | 182,431,653 | 183 | 25 | BSD-3-Clause | 2023-01-07T12:42:14 | 2019-04-20T16:55:30 | TypeScript | UTF-8 | C++ | false | false | 4,385 | h | // Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the name Chromium Embedded
// Framework nor the names of its contributors may be used to endorse
// or promote products derived from this software without specific prior
// written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// ---------------------------------------------------------------------------
//
// The contents of this file are only available to applications that link
// against the libcef_dll_wrapper target.
//
#ifndef CEF_INCLUDE_WRAPPER_CEF_HELPERS_H_
#define CEF_INCLUDE_WRAPPER_CEF_HELPERS_H_
#pragma once
#include <cstring>
#include <string>
#include <vector>
#include "include/base/cef_bind.h"
#include "include/base/cef_logging.h"
#include "include/base/cef_macros.h"
#include "include/cef_task.h"
#define CEF_REQUIRE_UI_THREAD() DCHECK(CefCurrentlyOn(TID_UI));
#define CEF_REQUIRE_IO_THREAD() DCHECK(CefCurrentlyOn(TID_IO));
#define CEF_REQUIRE_FILE_THREAD() DCHECK(CefCurrentlyOn(TID_FILE));
#define CEF_REQUIRE_RENDERER_THREAD() DCHECK(CefCurrentlyOn(TID_RENDERER));
// Use this struct in conjuction with refcounted types to ensure that an
// object is deleted on the specified thread. For example:
//
// class Foo : public base::RefCountedThreadSafe<Foo, CefDeleteOnUIThread> {
// public:
// Foo();
// void DoSomething();
//
// private:
// // Allow deletion via scoped_refptr only.
// friend struct CefDeleteOnThread<TID_UI>;
// friend class base::RefCountedThreadSafe<Foo, CefDeleteOnUIThread>;
//
// virtual ~Foo() {}
// };
//
// base::scoped_refptr<Foo> foo = new Foo();
// foo->DoSomething();
// foo = NULL; // Deletion of |foo| will occur on the UI thread.
//
template <CefThreadId thread>
struct CefDeleteOnThread {
template <typename T>
static void Destruct(const T* x) {
if (CefCurrentlyOn(thread)) {
delete x;
} else {
CefPostTask(thread,
base::Bind(&CefDeleteOnThread<thread>::Destruct<T>, x));
}
}
};
struct CefDeleteOnUIThread : public CefDeleteOnThread<TID_UI> {};
struct CefDeleteOnIOThread : public CefDeleteOnThread<TID_IO> {};
struct CefDeleteOnFileThread : public CefDeleteOnThread<TID_FILE> {};
struct CefDeleteOnRendererThread : public CefDeleteOnThread<TID_RENDERER> {};
///
// Helper class to manage a scoped copy of |argv|.
///
class CefScopedArgArray {
public:
CefScopedArgArray(int argc, char* argv[]) {
// argv should have (argc + 1) elements, the last one always being NULL.
array_ = new char*[argc + 1];
for (int i = 0; i < argc; ++i) {
values_.push_back(argv[i]);
array_[i] = const_cast<char*>(values_[i].c_str());
}
array_[argc] = NULL;
}
~CefScopedArgArray() { delete[] array_; }
char** array() const { return array_; }
private:
char** array_;
// Keep values in a vector separate from |array_| because various users may
// modify |array_| and we still want to clean up memory properly.
std::vector<std::string> values_;
DISALLOW_COPY_AND_ASSIGN(CefScopedArgArray);
};
#endif // CEF_INCLUDE_WRAPPER_CEF_HELPERS_H_
| [
"joe@valvesoftware.com"
] | joe@valvesoftware.com |
6245249e5a339b0c806b464a9d601e2f5a3fccaf | 24cbfe81c4fc15619e1e1862dfbfc6b5f9a3619d | /week-3/izo/izo.cpp | 6044bfbd6c36096224cdbfe3c127f3b6284e9aee | [
"MIT"
] | permissive | amwolff/ALGO2020 | 198322b3b51e02c2ca21d468a22370b8cdd2f91c | 6fc361d999ed12e94eb9f86d190ddaac4916d03a | refs/heads/master | 2021-03-13T10:36:06.789574 | 2020-09-08T21:06:25 | 2020-09-08T21:06:25 | 246,670,782 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 461 | cpp | #include <algorithm>
#include <cstdio>
#include <vector>
using namespace std;
int main() {
int n;
scanf("%d\n", &n);
vector<int> a(n);
for (size_t i = 0; i < a.size(); i++) {
scanf("%d\n", &a[i]);
}
sort(a.begin(), a.end());
size_t i = 0;
size_t j = a.size() - 1;
int ans = 0;
while (i <= j) {
if (i == j) {
ans += a[i];
break;
}
ans += 2 * a[j];
i++;
j--;
}
printf("%d\n", ans);
return 0;
}
| [
"artur.m.wolff@gmail.com"
] | artur.m.wolff@gmail.com |
ef43da03c0561e3b11ef2abc78adbe9615f494e6 | 62092f08c00b8d6630276574bf2e1b84bc22a82a | /src/Soundex.h | d56fb7677e157c0b2f5e4741bb79feeeea4f4b80 | [] | no_license | Keunho77/MyTest1 | fed85b0307e3a08e10e00aac35c0173f37ca1d94 | ae14fbe80a64741c9f6fa906a3caa0ec9fd8666b | refs/heads/master | 2021-01-10T16:49:03.279318 | 2015-12-21T09:50:31 | 2015-12-21T09:50:31 | 48,313,382 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,818 | h |
#ifndef SRC_SOUNDEX_H_
#define SRC_SOUNDEX_H_
#include <iostream>
#include <string>
#include <unordered_map>
class Soundex {
public :
std::string encodedDigit(char letter) const {
const std::unordered_map<char, std::string> encodings {
{'b', "1"},{'f', "1"},{'p', "1"}, {'v', "1"},
{'c', "2"},{'g', "2"},{'j', "2"}, {'k', "2"}, {'q', "2"}, {'s', "2"},{'x', "2"}, {'z', "2"},
{'d', "3"},{'t', "3"},
{'l', "4"},
{'m', "5"},{'n', "5"},
{'r', "6"}
};
auto it = encodings.find(letter);
return it == encodings.end() ? "": it->second;
}
std::string encode(const std::string& word) const {
return zeroPad(head(word) + encodedDigits(tail(word)));
}
private :
std::string head(const std::string& word) const {
return word.substr(0,1);
}
std::string tail(const std::string& word) const {
return word.substr(1);
}
std::string lastDigit(const std::string& encoding) const {
if (encoding.empty()) return "";
return std::string(1, encoding.back());
}
std::string encodedDigits(const std::string& word) const {
// if(word.empty()) return "";
std::string encoding;
for(auto letter:word) {
if(isComplete(encoding)) break;
if(encodedDigit(letter) != lastDigit(encoding))
encoding += encodedDigit(letter);
}
return encoding;
// return encodedDigit(word.front());
}
bool isComplete(const std::string& encoding) const {
return encoding.length() == MaxCodeLength -1;
}
static const size_t MaxCodeLength{4};
std::string zeroPad(const std::string& word) const {
auto zeroNeeded = MaxCodeLength - word.length();
// std::cout << "word is "<< word << ". Zero needed is " << zeroNeeded << std::endl;
return word + std::string(zeroNeeded, '0');
}
/* void test(const char* str) {
// str = "Test";
str[0] = "a";
}*/
};
#endif /* SRC_SOUNDEX_H_ */
| [
"keunho77@gmail.com"
] | keunho77@gmail.com |
fc0307a8c665e1bb716e71d735c1a4466219de95 | d54a9f1856eb7aaa18be4855a504a7d1e4623d63 | /server.h | f79f1d4862548923330246762f61a4771192400a | [] | no_license | Mazar1ni/CubanglesServer | 938c1d119705fd8da938e25c0ee3e2e51a5182c5 | 1836d7d9a446b8276deb0355b27626dec1eb20d2 | refs/heads/master | 2020-04-13T22:56:11.432243 | 2018-12-29T08:31:23 | 2018-12-29T08:31:23 | 163,492,931 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 366 | h | #ifndef SERVER_H
#define SERVER_H
#include <QTcpServer>
class Socket;
class RoomManager;
class SearchGame;
class Server : public QTcpServer
{
public:
Server();
void startServer();
protected:
void incomingConnection(int handle);
public:
QList<Socket*> socketList;
RoomManager* roomManager;
SearchGame* searchGame;
};
#endif // SERVER_H
| [
"xmazarini17@gmail.com"
] | xmazarini17@gmail.com |
d731eab3acddb9beaaae2321b614452b88642726 | 2d5001934fcafacde5c441b9344f1f0d94b9ac3e | /TractionControl.h | 64223e3805c4cb0d22502a4144504077fea88091 | [] | no_license | CircuitBirds-FRC4601/CB1 | 9186d52f321404b2b5427b6a4626eb4f9ef3781c | 7e181e868e85d696cc19e7c384016c22263d66bb | refs/heads/master | 2016-09-05T13:26:49.548552 | 2014-02-28T00:49:22 | 2014-02-28T00:49:22 | 17,270,582 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 767 | h | #ifndef TRACTIONCONTROL_H_
#define TRACTIONCONTROL_H_
#include "Encoder.h"
#include "Timer.h"
class AugmentedEncoder {
//augments the functionality of an encoder
float acceleration;
float velocity;
float distance;
float delta_v; //change in velocity
float delta_d; //change in distance
float delta_t; //change in time
float distance_per_tick; //distance per tick of the encoder
public:
typedef enum {
k1X, k2X, k4X
} AugEncoderState;
AugmentedEncoder(int a_channel, int b_channel, float d_p_t, bool reverse);
void Start();
void Recalculate();
void Reset();
float GetAcceleration();
float GetVelocity();
float GetDistance();
private:
Encoder *encoder;
Timer *timer;
AugEncoderState mAugEncoderState;
};
#endif // TRACTIONCONTROL_H_
| [
"kyle@kylekthompson.com"
] | kyle@kylekthompson.com |
3af816d18d9737ec3b81a2f999c1e0599c4c1807 | 99f1550e0a3c2e21088e2ffc72bc5dadabb1188f | /ui/UICTRL/Src/Control/RichEdit/OLE/comreole.cpp | 408de8431b882e94a97a25924b96bfe63f65925b | [] | no_license | flymolon/UI2017 | 0d0bb1c173e015e7fe26ada47358b4581f3b0e29 | e7182b19d9227abe6d3f91600e85d13c85917e71 | refs/heads/master | 2020-04-11T01:42:49.336393 | 2017-02-12T04:15:19 | 2017-02-12T04:15:19 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,463 | cpp | #include "stdafx.h"
#include "comreole.h"
using namespace UI;
namespace UI
{
extern UINT g_cfRichEditUnicodeXmlFormat;
extern UINT CF_HTML;
}
ComREOle::ComREOle()
{
m_pOleObject = NULL;
memset(&m_clsid, 0, sizeof(m_clsid));
}
ComREOle::~ComREOle()
{
SAFE_RELEASE(m_pOleObject);
}
HRESULT ComREOle::GetOleObject(IOleObject** ppOleObject, bool bAddRef)
{
if (NULL == ppOleObject)
return E_INVALIDARG;
if (NULL == m_pOleObject)
return E_FAIL;
*ppOleObject = m_pOleObject;
if (bAddRef)
m_pOleObject->AddRef();
return S_OK;
}
HRESULT ComREOle::GetClipboardData(UINT nClipFormat, __out BSTR* pbstrData)
{
if (nClipFormat == g_cfRichEditUnicodeXmlFormat)
{
WCHAR szText[128] = {0};
WCHAR szGUID[64] = {0};
StringFromCLSID(m_clsid, (LPOLESTR*)&szGUID);
wsprintf(szText, L"<com version=\"1.0\" clsid=\"%s\"/>", szGUID);
*pbstrData = SysAllocString(szText);
return S_OK;
}
return E_FAIL;
}
HRESULT ComREOle::GetClipboardDataEx(IDataObject* pDataObject)
{
return E_FAIL;
}
HRESULT ComREOle::Attach(CLSID clsid)
{
SAFE_RELEASE(m_pOleObject);
m_clsid = clsid;
return ::CoCreateInstance(clsid, NULL, CLSCTX_INPROC, IID_IOleObject, (void**)&m_pOleObject);
}
ULONG STDMETHODCALLTYPE ComREOle::AddRef( void)
{
return AddRefImpl();
}
ULONG STDMETHODCALLTYPE ComREOle::Release( void)
{
return ReleaseImpl();
}
| [
"libo30@lenovo.com"
] | libo30@lenovo.com |
cf5b3f227c05ceff1fbaaefdb171c8803c35cf5a | 4dd44b69c18016ec7e42600a2831bb47b5364e92 | /standard_openssl/secp256k1.cpp | 17732396e88a4aaa4c062ea053953080bcdfbe49 | [] | no_license | zzGHzz/EVM_CryptoLIb | 0056c10d178fde4ac9f4ea77620f2191fc858500 | e917e592e1873959660ee0d82245cec3407fba6a | refs/heads/master | 2020-06-19T19:37:11.611223 | 2019-12-20T09:49:23 | 2019-12-20T09:49:23 | 196,844,997 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,504 | cpp | //
// Created by 王星凯 on 2019-08-08.
//
#include "include/secp256k1.h"
#include <cassert>
#include <iostream>
#include <string>
using namespace std;
void Secp256k1_point::init()
{
group = NULL;
point = NULL;
ctx = NULL;
group = EC_GROUP_new_by_curve_name(NID_secp256k1);
if (!group) {
throw runtime_error("secp256k1_point::init(): NEW CURVE GENERATED FAILED!!");
}
point = EC_POINT_new(group);
if (!point) {
EC_GROUP_free(group);
throw runtime_error("secp256k1_point::init(): NEW POINT GENERATED FAILED!!");
}
ctx = BN_CTX_new();
if (!ctx) {
EC_GROUP_free(group);
EC_POINT_free(point);
throw runtime_error("secp256k1_point::init(): BN_CTX_new FAILED!!");
}
return;
}
Secp256k1_point::Secp256k1_point(const Secp256k1_point& src)
{
init();
if (!EC_GROUP_copy(group, src.group))
throw runtime_error("secp256k1_point::secp256k1_point(copy): EC_GROUP_copy failed!!");
if (!EC_POINT_copy(point, src.point))
throw runtime_error("secp256k1_point::secp256k1_point(copy): EC_POINT_copy failed!!");
}
Secp256k1_point::Secp256k1_point(const vector<unsigned char> &bytes) {
init();
BIGNUM* bn = BN_bin2bn(&bytes[0], bytes.size(), NULL);
if (!bn) {
throw runtime_error("secp256k1_point::secp256k1_point(bin): BN_bin2bn failed!!");
}
if (!EC_POINT_bn2point(group, bn, point, ctx)) {
BN_clear_free(bn);
throw runtime_error("secp256k1_point::secp256k1_point(bin): EC_POINT_bn2point failed!!");
}
}
Secp256k1_point::~Secp256k1_point()
{
if (point)
EC_POINT_free(point);
if (group)
EC_GROUP_free(group);
if (ctx)
BN_CTX_free(ctx);
}
Secp256k1_point& Secp256k1_point::operator=(const Secp256k1_point& rhs)
{
if (!EC_GROUP_copy(group, rhs.group)) throw std::runtime_error("secp256k1_point::operator= - EC_GROUP_copy failed.");
if (!EC_POINT_copy(point, rhs.point)) throw std::runtime_error("secp256k1_point::operator= - EC_POINT_copy failed.");
return *this;
}
vector<unsigned char> Secp256k1_point::toBin() const {
vector<unsigned char> bytes(33);
BIGNUM* bn = BN_new();
if (!bn) {
throw runtime_error("secp256k1_point::toBin: bn_new failed!!");
}
if (!EC_POINT_point2bn(group, point, POINT_CONVERSION_COMPRESSED, bn, ctx)) {
BN_clear_free(bn);
throw runtime_error("secp256k1_point::toBin: point2bin failed!!");
}
assert(BN_num_bytes(bn) == 33);
BN_bn2bin(bn, &bytes[0]);
return bytes;
}
Secp256k1_point& Secp256k1_point::operator+=(const Secp256k1_point& rhs)
{
if (!EC_POINT_add(group, point, point, rhs.point, ctx)) {
throw std::runtime_error("secp256k1_point::operator+= - EC_POINT_add failed.");
}
return *this;
}
Secp256k1_point& Secp256k1_point::operator*=(const vector<unsigned char>& rhs)
{
BIGNUM* bn = BN_bin2bn(&rhs[0], rhs.size(), NULL);
if (!bn) {
throw std::runtime_error("secp256k1_point::operator*= - BN_bin2bn failed.");
}
int rval = EC_POINT_mul(group, point, NULL, point, bn, ctx);
BN_clear_free(bn);
if (rval == 0) {
throw std::runtime_error("secp256k1_point::operator*= - EC_POINT_mul failed.");
}
return *this;
}
// Computes n*G + K where K is this and G is the group generator
//void secp256k1_point::generator_mul(const bytes_t& n)
//{
// BIGNUM* bn = BN_bin2bn(&n[0], n.size(), NULL);
// if (!bn) throw std::runtime_error("secp256k1_point::generator_mul - BN_bin2bn failed.");
//
// //int rval = EC_POINT_mul(group, point, bn, (is_at_infinity() ? NULL : point), BN_value_one(), ctx);
// int rval = EC_POINT_mul(group, point, bn, point, BN_value_one(), ctx);
// BN_clear_free(bn);
//
// if (rval == 0) throw std::runtime_error("secp256k1_point::generator_mul - EC_POINT_mul failed.");
//}
// Sets to n*G
void Secp256k1_point::set_ng(const vector<unsigned char>& n)
{
BIGNUM* bn = BN_bin2bn(&n[0], n.size(), NULL);
if (!bn) throw std::runtime_error("secp256k1_point::set_generator_mul - BN_bin2bn failed.");
int rval = EC_POINT_mul(group, point, bn, NULL, NULL, ctx);
BN_clear_free(bn);
if (rval == 0) throw std::runtime_error("secp256k1_point::set_generator_mul - EC_POINT_mul failed.");
}
void Secp256k1_point::set_O() {
if (!EC_POINT_set_to_infinity(group, point)) {
throw runtime_error("secp256k1_point::set_0: EC_POINT_set_to_infinity failed!!");
}
}
| [
"starshine87@sjtu.edu.cn"
] | starshine87@sjtu.edu.cn |
175aed8f04e7f2a65cba8ded82f42df1f149f38c | d32591b7a6a4b73d13ec530135d60727e737a20e | /GameOfInterview/Map.h | 5dbb0251a1001eea911211a58138372fe1d3323c | [] | no_license | sayidli/Minesweeper | 6323b02eabe6998f5d663d794d83043464676322 | 7db17258a78cdfe48bcde0fc0add505d43a0e4dc | refs/heads/master | 2020-08-28T03:56:21.766348 | 2019-11-01T01:50:46 | 2019-11-01T01:50:46 | 217,580,884 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 695 | h | //
// Map.h
// GameOfInterview
//
// Created by lipengyao on 2019/10/24.
// Copyright © 2019 lipengyao. All rights reserved.
//
#ifndef Map_h
#define Map_h
#endif /* Map_h */
#include "IMapBase.h"
#include "IPlayerBase.h"
class GameMap:public IMapOperater, public IMapBase
{
public:
GameMap();
//IMapBase
bool virtual create(int row, int col, int bombNum);
bool virtual isEnd();
void virtual showView();
//IMapOperater
void virtual openBox(int row, int col);
void virtual putFlag(int row, int col);
~GameMap();
protected:
vector<vector<char>> mapData_;
vector<vector<char>> mapDataCover_;
bool isContinue = true;
};
| [
"itislipengyao@hotmail.com"
] | itislipengyao@hotmail.com |
3cc98a8137eaf0e9769a397c534428fb437ec9e5 | 1a17167c38dc9a12c1f72dd0f3ae7288f5cd7da0 | /Source/ThirdParty/angle/third_party/SwiftShader/src/OpenGL/compiler/preprocessor/DirectiveParser.cpp | ed2ec074686ba7efd085667ab56c53fcca3182a0 | [
"BSD-3-Clause",
"LicenseRef-scancode-unknown-license-reference",
"MIT",
"LicenseRef-scancode-warranty-disclaimer",
"Zlib",
"LicenseRef-scancode-khronos",
"BSL-1.0",
"BSD-2-Clause",
"Apache-2.0"
] | permissive | elix22/Urho3D | c57c7ecb58975f51fabb95bcc4330bc5b0812de7 | 99902ae2a867be0d6dbe4c575f9c8c318805ec64 | refs/heads/master | 2023-06-01T01:19:57.155566 | 2021-12-07T16:47:20 | 2021-12-07T17:46:58 | 165,504,739 | 21 | 4 | MIT | 2021-11-05T01:02:08 | 2019-01-13T12:51:17 | C++ | UTF-8 | C++ | false | false | 25,631 | cpp | // Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "DirectiveParser.h"
#include <algorithm>
#include <cassert>
#include <cstdlib>
#include <sstream>
#include "DiagnosticsBase.h"
#include "DirectiveHandlerBase.h"
#include "ExpressionParser.h"
#include "MacroExpander.h"
#include "Token.h"
#include "Tokenizer.h"
namespace {
enum DirectiveType
{
DIRECTIVE_NONE,
DIRECTIVE_DEFINE,
DIRECTIVE_UNDEF,
DIRECTIVE_IF,
DIRECTIVE_IFDEF,
DIRECTIVE_IFNDEF,
DIRECTIVE_ELSE,
DIRECTIVE_ELIF,
DIRECTIVE_ENDIF,
DIRECTIVE_ERROR,
DIRECTIVE_PRAGMA,
DIRECTIVE_EXTENSION,
DIRECTIVE_VERSION,
DIRECTIVE_LINE
};
} // namespace
static DirectiveType getDirective(const pp::Token *token)
{
static const char kDirectiveDefine[] = "define";
static const char kDirectiveUndef[] = "undef";
static const char kDirectiveIf[] = "if";
static const char kDirectiveIfdef[] = "ifdef";
static const char kDirectiveIfndef[] = "ifndef";
static const char kDirectiveElse[] = "else";
static const char kDirectiveElif[] = "elif";
static const char kDirectiveEndif[] = "endif";
static const char kDirectiveError[] = "error";
static const char kDirectivePragma[] = "pragma";
static const char kDirectiveExtension[] = "extension";
static const char kDirectiveVersion[] = "version";
static const char kDirectiveLine[] = "line";
if (token->type != pp::Token::IDENTIFIER)
return DIRECTIVE_NONE;
if (token->text == kDirectiveDefine)
return DIRECTIVE_DEFINE;
else if (token->text == kDirectiveUndef)
return DIRECTIVE_UNDEF;
else if (token->text == kDirectiveIf)
return DIRECTIVE_IF;
else if (token->text == kDirectiveIfdef)
return DIRECTIVE_IFDEF;
else if (token->text == kDirectiveIfndef)
return DIRECTIVE_IFNDEF;
else if (token->text == kDirectiveElse)
return DIRECTIVE_ELSE;
else if (token->text == kDirectiveElif)
return DIRECTIVE_ELIF;
else if (token->text == kDirectiveEndif)
return DIRECTIVE_ENDIF;
else if (token->text == kDirectiveError)
return DIRECTIVE_ERROR;
else if (token->text == kDirectivePragma)
return DIRECTIVE_PRAGMA;
else if (token->text == kDirectiveExtension)
return DIRECTIVE_EXTENSION;
else if (token->text == kDirectiveVersion)
return DIRECTIVE_VERSION;
else if (token->text == kDirectiveLine)
return DIRECTIVE_LINE;
return DIRECTIVE_NONE;
}
static bool isConditionalDirective(DirectiveType directive)
{
switch (directive)
{
case DIRECTIVE_IF:
case DIRECTIVE_IFDEF:
case DIRECTIVE_IFNDEF:
case DIRECTIVE_ELSE:
case DIRECTIVE_ELIF:
case DIRECTIVE_ENDIF:
return true;
default:
return false;
}
}
// Returns true if the token represents End Of Directive.
static bool isEOD(const pp::Token *token)
{
return (token->type == '\n') || (token->type == pp::Token::LAST);
}
static void skipUntilEOD(pp::Lexer *lexer, pp::Token *token)
{
while(!isEOD(token))
{
lexer->lex(token);
}
}
static bool isMacroNameReserved(const std::string& name)
{
// Names prefixed with "GL_" are reserved.
return (name.substr(0, 3) == "GL_");
}
bool hasDoubleUnderscores(const std::string &name)
{
return (name.find("__") != std::string::npos);
}
static bool isMacroPredefined(const std::string& name,
const pp::MacroSet& macroSet)
{
pp::MacroSet::const_iterator iter = macroSet.find(name);
return iter != macroSet.end() ? iter->second->predefined : false;
}
namespace pp
{
class DefinedParser : public Lexer
{
public:
DefinedParser(Lexer *lexer, const MacroSet *macroSet, Diagnostics *diagnostics)
: mLexer(lexer), mMacroSet(macroSet), mDiagnostics(diagnostics)
{
}
protected:
void lex(Token *token) override
{
const char kDefined[] = "defined";
mLexer->lex(token);
if (token->type != Token::IDENTIFIER)
return;
if (token->text != kDefined)
return;
bool paren = false;
mLexer->lex(token);
if (token->type == '(')
{
paren = true;
mLexer->lex(token);
}
if (token->type != Token::IDENTIFIER)
{
mDiagnostics->report(Diagnostics::PP_UNEXPECTED_TOKEN, token->location, token->text);
skipUntilEOD(mLexer, token);
return;
}
MacroSet::const_iterator iter = mMacroSet->find(token->text);
std::string expression = iter != mMacroSet->end() ? "1" : "0";
if (paren)
{
mLexer->lex(token);
if (token->type != ')')
{
mDiagnostics->report(Diagnostics::PP_UNEXPECTED_TOKEN,
token->location, token->text);
skipUntilEOD(mLexer, token);
return;
}
}
// We have a valid defined operator.
// Convert the current token into a CONST_INT token.
token->type = Token::CONST_INT;
token->text = expression;
}
private:
Lexer *mLexer;
const MacroSet *mMacroSet;
Diagnostics *mDiagnostics;
};
DirectiveParser::DirectiveParser(Tokenizer *tokenizer,
MacroSet *macroSet,
Diagnostics *diagnostics,
DirectiveHandler *directiveHandler,
int maxMacroExpansionDepth)
: mPastFirstStatement(false),
mSeenNonPreprocessorToken(false),
mTokenizer(tokenizer),
mMacroSet(macroSet),
mDiagnostics(diagnostics),
mDirectiveHandler(directiveHandler),
mShaderVersion(100),
mMaxMacroExpansionDepth(maxMacroExpansionDepth)
{
}
DirectiveParser::~DirectiveParser()
{
}
void DirectiveParser::lex(Token *token)
{
do
{
mTokenizer->lex(token);
if (token->type == Token::PP_HASH)
{
parseDirective(token);
mPastFirstStatement = true;
}
else if (!isEOD(token))
{
mSeenNonPreprocessorToken = true;
}
if (token->type == Token::LAST)
{
if (!mConditionalStack.empty())
{
const ConditionalBlock &block = mConditionalStack.back();
mDiagnostics->report(Diagnostics::PP_CONDITIONAL_UNTERMINATED,
block.location, block.type);
}
break;
}
} while (skipping() || (token->type == '\n'));
mPastFirstStatement = true;
}
void DirectiveParser::parseDirective(Token *token)
{
assert(token->type == Token::PP_HASH);
mTokenizer->lex(token);
if (isEOD(token))
{
// Empty Directive.
return;
}
DirectiveType directive = getDirective(token);
// While in an excluded conditional block/group,
// we only parse conditional directives.
if (skipping() && !isConditionalDirective(directive))
{
skipUntilEOD(mTokenizer, token);
return;
}
switch(directive)
{
case DIRECTIVE_NONE:
mDiagnostics->report(Diagnostics::PP_DIRECTIVE_INVALID_NAME,
token->location, token->text);
skipUntilEOD(mTokenizer, token);
break;
case DIRECTIVE_DEFINE:
parseDefine(token);
break;
case DIRECTIVE_UNDEF:
parseUndef(token);
break;
case DIRECTIVE_IF:
parseIf(token);
break;
case DIRECTIVE_IFDEF:
parseIfdef(token);
break;
case DIRECTIVE_IFNDEF:
parseIfndef(token);
break;
case DIRECTIVE_ELSE:
parseElse(token);
break;
case DIRECTIVE_ELIF:
parseElif(token);
break;
case DIRECTIVE_ENDIF:
parseEndif(token);
break;
case DIRECTIVE_ERROR:
parseError(token);
break;
case DIRECTIVE_PRAGMA:
parsePragma(token);
break;
case DIRECTIVE_EXTENSION:
parseExtension(token);
break;
case DIRECTIVE_VERSION:
parseVersion(token);
break;
case DIRECTIVE_LINE:
parseLine(token);
break;
default:
assert(false);
break;
}
skipUntilEOD(mTokenizer, token);
if (token->type == Token::LAST)
{
mDiagnostics->report(Diagnostics::PP_EOF_IN_DIRECTIVE,
token->location, token->text);
}
}
void DirectiveParser::parseDefine(Token *token)
{
assert(getDirective(token) == DIRECTIVE_DEFINE);
mTokenizer->lex(token);
if (token->type != Token::IDENTIFIER)
{
mDiagnostics->report(Diagnostics::PP_UNEXPECTED_TOKEN,
token->location, token->text);
return;
}
if (isMacroPredefined(token->text, *mMacroSet))
{
mDiagnostics->report(Diagnostics::PP_MACRO_PREDEFINED_REDEFINED,
token->location, token->text);
return;
}
if (isMacroNameReserved(token->text))
{
mDiagnostics->report(Diagnostics::PP_MACRO_NAME_RESERVED,
token->location, token->text);
return;
}
// Using double underscores is allowed, but may result in unintended
// behavior, so a warning is issued. At the time of writing this was
// specified in ESSL 3.10, but the intent judging from Khronos
// discussions and dEQP tests was that double underscores should be
// allowed in earlier ESSL versions too.
if (hasDoubleUnderscores(token->text))
{
mDiagnostics->report(Diagnostics::PP_WARNING_MACRO_NAME_RESERVED, token->location,
token->text);
}
std::shared_ptr<Macro> macro = std::make_shared<Macro>();
macro->type = Macro::kTypeObj;
macro->name = token->text;
mTokenizer->lex(token);
if (token->type == '(' && !token->hasLeadingSpace())
{
// Function-like macro. Collect arguments.
macro->type = Macro::kTypeFunc;
do {
mTokenizer->lex(token);
if (token->type != Token::IDENTIFIER)
break;
if (std::find(macro->parameters.begin(), macro->parameters.end(), token->text) != macro->parameters.end())
{
mDiagnostics->report(Diagnostics::PP_MACRO_DUPLICATE_PARAMETER_NAMES,
token->location, token->text);
return;
}
macro->parameters.push_back(token->text);
mTokenizer->lex(token); // Get ','.
} while (token->type == ',');
if (token->type != ')')
{
mDiagnostics->report(Diagnostics::PP_UNEXPECTED_TOKEN,
token->location,
token->text);
return;
}
mTokenizer->lex(token); // Get ')'.
}
while ((token->type != '\n') && (token->type != Token::LAST))
{
// Reset the token location because it is unnecessary in replacement
// list. Resetting it also allows us to reuse Token::equals() to
// compare macros.
token->location = SourceLocation();
macro->replacements.push_back(*token);
mTokenizer->lex(token);
}
if (!macro->replacements.empty())
{
// Whitespace preceding the replacement list is not considered part of
// the replacement list for either form of macro.
macro->replacements.front().setHasLeadingSpace(false);
}
// Check for macro redefinition.
MacroSet::const_iterator iter = mMacroSet->find(macro->name);
if (iter != mMacroSet->end() && !macro->equals(*iter->second))
{
mDiagnostics->report(Diagnostics::PP_MACRO_REDEFINED, token->location, macro->name);
return;
}
mMacroSet->insert(std::make_pair(macro->name, macro));
}
void DirectiveParser::parseUndef(Token *token)
{
assert(getDirective(token) == DIRECTIVE_UNDEF);
mTokenizer->lex(token);
if (token->type != Token::IDENTIFIER)
{
mDiagnostics->report(Diagnostics::PP_UNEXPECTED_TOKEN,
token->location, token->text);
return;
}
MacroSet::iterator iter = mMacroSet->find(token->text);
if (iter != mMacroSet->end())
{
if (iter->second->predefined)
{
mDiagnostics->report(Diagnostics::PP_MACRO_PREDEFINED_UNDEFINED,
token->location, token->text);
return;
}
else if (iter->second->expansionCount > 0)
{
mDiagnostics->report(Diagnostics::PP_MACRO_UNDEFINED_WHILE_INVOKED,
token->location, token->text);
return;
}
else
{
mMacroSet->erase(iter);
}
}
mTokenizer->lex(token);
if (!isEOD(token))
{
mDiagnostics->report(Diagnostics::PP_UNEXPECTED_TOKEN, token->location, token->text);
skipUntilEOD(mTokenizer, token);
}
}
void DirectiveParser::parseIf(Token *token)
{
assert(getDirective(token) == DIRECTIVE_IF);
parseConditionalIf(token);
}
void DirectiveParser::parseIfdef(Token *token)
{
assert(getDirective(token) == DIRECTIVE_IFDEF);
parseConditionalIf(token);
}
void DirectiveParser::parseIfndef(Token *token)
{
assert(getDirective(token) == DIRECTIVE_IFNDEF);
parseConditionalIf(token);
}
void DirectiveParser::parseElse(Token *token)
{
assert(getDirective(token) == DIRECTIVE_ELSE);
if (mConditionalStack.empty())
{
mDiagnostics->report(Diagnostics::PP_CONDITIONAL_ELSE_WITHOUT_IF,
token->location, token->text);
skipUntilEOD(mTokenizer, token);
return;
}
ConditionalBlock &block = mConditionalStack.back();
if (block.skipBlock)
{
// No diagnostics. Just skip the whole line.
skipUntilEOD(mTokenizer, token);
return;
}
if (block.foundElseGroup)
{
mDiagnostics->report(Diagnostics::PP_CONDITIONAL_ELSE_AFTER_ELSE,
token->location, token->text);
skipUntilEOD(mTokenizer, token);
return;
}
block.foundElseGroup = true;
block.skipGroup = block.foundValidGroup;
block.foundValidGroup = true;
// Check if there are extra tokens after #else.
mTokenizer->lex(token);
if (!isEOD(token))
{
mDiagnostics->report(Diagnostics::PP_CONDITIONAL_UNEXPECTED_TOKEN,
token->location, token->text);
skipUntilEOD(mTokenizer, token);
}
}
void DirectiveParser::parseElif(Token *token)
{
assert(getDirective(token) == DIRECTIVE_ELIF);
if (mConditionalStack.empty())
{
mDiagnostics->report(Diagnostics::PP_CONDITIONAL_ELIF_WITHOUT_IF,
token->location, token->text);
skipUntilEOD(mTokenizer, token);
return;
}
ConditionalBlock &block = mConditionalStack.back();
if (block.skipBlock)
{
// No diagnostics. Just skip the whole line.
skipUntilEOD(mTokenizer, token);
return;
}
if (block.foundElseGroup)
{
mDiagnostics->report(Diagnostics::PP_CONDITIONAL_ELIF_AFTER_ELSE,
token->location, token->text);
skipUntilEOD(mTokenizer, token);
return;
}
if (block.foundValidGroup)
{
// Do not parse the expression.
// Also be careful not to emit a diagnostic.
block.skipGroup = true;
skipUntilEOD(mTokenizer, token);
return;
}
int expression = parseExpressionIf(token);
block.skipGroup = expression == 0;
block.foundValidGroup = expression != 0;
}
void DirectiveParser::parseEndif(Token *token)
{
assert(getDirective(token) == DIRECTIVE_ENDIF);
if (mConditionalStack.empty())
{
mDiagnostics->report(Diagnostics::PP_CONDITIONAL_ENDIF_WITHOUT_IF,
token->location, token->text);
skipUntilEOD(mTokenizer, token);
return;
}
mConditionalStack.pop_back();
// Check if there are tokens after #endif.
mTokenizer->lex(token);
if (!isEOD(token))
{
mDiagnostics->report(Diagnostics::PP_CONDITIONAL_UNEXPECTED_TOKEN,
token->location, token->text);
skipUntilEOD(mTokenizer, token);
}
}
void DirectiveParser::parseError(Token *token)
{
assert(getDirective(token) == DIRECTIVE_ERROR);
std::ostringstream stream;
mTokenizer->lex(token);
while ((token->type != '\n') && (token->type != Token::LAST))
{
stream << *token;
mTokenizer->lex(token);
}
mDirectiveHandler->handleError(token->location, stream.str());
}
// Parses pragma of form: #pragma name[(value)].
void DirectiveParser::parsePragma(Token *token)
{
assert(getDirective(token) == DIRECTIVE_PRAGMA);
enum State
{
PRAGMA_NAME,
LEFT_PAREN,
PRAGMA_VALUE,
RIGHT_PAREN
};
bool valid = true;
std::string name, value;
int state = PRAGMA_NAME;
mTokenizer->lex(token);
bool stdgl = token->text == "STDGL";
if (stdgl)
{
mTokenizer->lex(token);
}
while ((token->type != '\n') && (token->type != Token::LAST))
{
switch(state++)
{
case PRAGMA_NAME:
name = token->text;
valid = valid && (token->type == Token::IDENTIFIER);
break;
case LEFT_PAREN:
valid = valid && (token->type == '(');
break;
case PRAGMA_VALUE:
value = token->text;
valid = valid && (token->type == Token::IDENTIFIER);
break;
case RIGHT_PAREN:
valid = valid && (token->type == ')');
break;
default:
valid = false;
break;
}
mTokenizer->lex(token);
}
valid = valid && ((state == PRAGMA_NAME) || // Empty pragma.
(state == LEFT_PAREN) || // Without value.
(state == RIGHT_PAREN + 1)); // With value.
if (!valid)
{
mDiagnostics->report(Diagnostics::PP_UNRECOGNIZED_PRAGMA, token->location, name);
}
else if (state > PRAGMA_NAME) // Do not notify for empty pragma.
{
mDirectiveHandler->handlePragma(token->location, name, value, stdgl);
}
}
void DirectiveParser::parseExtension(Token *token)
{
assert(getDirective(token) == DIRECTIVE_EXTENSION);
enum State
{
EXT_NAME,
COLON,
EXT_BEHAVIOR
};
bool valid = true;
std::string name, behavior;
int state = EXT_NAME;
mTokenizer->lex(token);
while ((token->type != '\n') && (token->type != Token::LAST))
{
switch (state++)
{
case EXT_NAME:
if (valid && (token->type != Token::IDENTIFIER))
{
mDiagnostics->report(Diagnostics::PP_INVALID_EXTENSION_NAME, token->location,
token->text);
valid = false;
}
if (valid)
name = token->text;
break;
case COLON:
if (valid && (token->type != ':'))
{
mDiagnostics->report(Diagnostics::PP_UNEXPECTED_TOKEN, token->location,
token->text);
valid = false;
}
break;
case EXT_BEHAVIOR:
if (valid && (token->type != Token::IDENTIFIER))
{
mDiagnostics->report(Diagnostics::PP_INVALID_EXTENSION_BEHAVIOR,
token->location, token->text);
valid = false;
}
if (valid)
behavior = token->text;
break;
default:
if (valid)
{
mDiagnostics->report(Diagnostics::PP_UNEXPECTED_TOKEN, token->location,
token->text);
valid = false;
}
break;
}
mTokenizer->lex(token);
}
if (valid && (state != EXT_BEHAVIOR + 1))
{
mDiagnostics->report(Diagnostics::PP_INVALID_EXTENSION_DIRECTIVE, token->location,
token->text);
valid = false;
}
if (valid && mSeenNonPreprocessorToken)
{
if (mShaderVersion >= 300)
{
mDiagnostics->report(Diagnostics::PP_NON_PP_TOKEN_BEFORE_EXTENSION_ESSL3,
token->location, token->text);
valid = false;
}
else
{
mDiagnostics->report(Diagnostics::PP_NON_PP_TOKEN_BEFORE_EXTENSION_ESSL1,
token->location, token->text);
}
}
if (valid)
mDirectiveHandler->handleExtension(token->location, name, behavior);
}
void DirectiveParser::parseVersion(Token *token)
{
assert(getDirective(token) == DIRECTIVE_VERSION);
if (mPastFirstStatement)
{
mDiagnostics->report(Diagnostics::PP_VERSION_NOT_FIRST_STATEMENT, token->location,
token->text);
skipUntilEOD(mTokenizer, token);
return;
}
enum State
{
VERSION_NUMBER,
VERSION_PROFILE,
VERSION_ENDLINE
};
bool valid = true;
int version = 0;
int state = VERSION_NUMBER;
mTokenizer->lex(token);
while (valid && (token->type != '\n') && (token->type != Token::LAST))
{
switch (state)
{
case VERSION_NUMBER:
if (token->type != Token::CONST_INT)
{
mDiagnostics->report(Diagnostics::PP_INVALID_VERSION_NUMBER,
token->location, token->text);
valid = false;
}
if (valid && !token->iValue(&version))
{
mDiagnostics->report(Diagnostics::PP_INTEGER_OVERFLOW,
token->location, token->text);
valid = false;
}
if (valid)
{
state = (version < 300) ? VERSION_ENDLINE : VERSION_PROFILE;
}
break;
case VERSION_PROFILE:
if (token->type != Token::IDENTIFIER || token->text != "es")
{
mDiagnostics->report(Diagnostics::PP_INVALID_VERSION_DIRECTIVE,
token->location, token->text);
valid = false;
}
state = VERSION_ENDLINE;
break;
default:
mDiagnostics->report(Diagnostics::PP_UNEXPECTED_TOKEN,
token->location, token->text);
valid = false;
break;
}
mTokenizer->lex(token);
}
if (valid && (state != VERSION_ENDLINE))
{
mDiagnostics->report(Diagnostics::PP_INVALID_VERSION_DIRECTIVE,
token->location, token->text);
valid = false;
}
if (valid && version >= 300 && token->location.line > 1)
{
mDiagnostics->report(Diagnostics::PP_VERSION_NOT_FIRST_LINE_ESSL3, token->location,
token->text);
valid = false;
}
if (valid)
{
mDirectiveHandler->handleVersion(token->location, version);
mShaderVersion = version;
PredefineMacro(mMacroSet, "__VERSION__", version);
}
}
void DirectiveParser::parseLine(Token *token)
{
assert(getDirective(token) == DIRECTIVE_LINE);
bool valid = true;
bool parsedFileNumber = false;
int line = 0, file = 0;
MacroExpander macroExpander(mTokenizer, mMacroSet, mDiagnostics, false, mMaxMacroExpansionDepth);
// Lex the first token after "#line" so we can check it for EOD.
macroExpander.lex(token);
if (isEOD(token))
{
mDiagnostics->report(Diagnostics::PP_INVALID_LINE_DIRECTIVE, token->location, token->text);
valid = false;
}
else
{
ExpressionParser expressionParser(¯oExpander, mDiagnostics);
ExpressionParser::ErrorSettings errorSettings;
// See GLES3 section 12.42
errorSettings.integerLiteralsMustFit32BitSignedRange = true;
errorSettings.unexpectedIdentifier = Diagnostics::PP_INVALID_LINE_NUMBER;
// The first token was lexed earlier to check if it was EOD. Include
// the token in parsing for a second time by setting the
// parsePresetToken flag to true.
expressionParser.parse(token, &line, true, errorSettings, &valid);
if (!isEOD(token) && valid)
{
errorSettings.unexpectedIdentifier = Diagnostics::PP_INVALID_FILE_NUMBER;
// After parsing the line expression expressionParser has also
// advanced to the first token of the file expression - this is the
// token that makes the parser reduce the "input" rule for the line
// expression and stop. So we're using parsePresetToken = true here
// as well.
expressionParser.parse(token, &file, true, errorSettings, &valid);
parsedFileNumber = true;
}
if (!isEOD(token))
{
if (valid)
{
mDiagnostics->report(Diagnostics::PP_UNEXPECTED_TOKEN,
token->location, token->text);
valid = false;
}
skipUntilEOD(mTokenizer, token);
}
}
if (valid)
{
mTokenizer->setLineNumber(line);
if (parsedFileNumber)
mTokenizer->setFileNumber(file);
}
}
bool DirectiveParser::skipping() const
{
if (mConditionalStack.empty())
return false;
const ConditionalBlock &block = mConditionalStack.back();
return block.skipBlock || block.skipGroup;
}
void DirectiveParser::parseConditionalIf(Token *token)
{
ConditionalBlock block;
block.type = token->text;
block.location = token->location;
if (skipping())
{
// This conditional block is inside another conditional group
// which is skipped. As a consequence this whole block is skipped.
// Be careful not to parse the conditional expression that might
// emit a diagnostic.
skipUntilEOD(mTokenizer, token);
block.skipBlock = true;
}
else
{
DirectiveType directive = getDirective(token);
int expression = 0;
switch (directive)
{
case DIRECTIVE_IF:
expression = parseExpressionIf(token);
break;
case DIRECTIVE_IFDEF:
expression = parseExpressionIfdef(token);
break;
case DIRECTIVE_IFNDEF:
expression = parseExpressionIfdef(token) == 0 ? 1 : 0;
break;
default:
assert(false);
break;
}
block.skipGroup = expression == 0;
block.foundValidGroup = expression != 0;
}
mConditionalStack.push_back(block);
}
int DirectiveParser::parseExpressionIf(Token *token)
{
assert((getDirective(token) == DIRECTIVE_IF) || (getDirective(token) == DIRECTIVE_ELIF));
DefinedParser definedParser(mTokenizer, mMacroSet, mDiagnostics);
MacroExpander macroExpander(&definedParser, mMacroSet, mDiagnostics, true, mMaxMacroExpansionDepth);
ExpressionParser expressionParser(¯oExpander, mDiagnostics);
int expression = 0;
ExpressionParser::ErrorSettings errorSettings;
errorSettings.integerLiteralsMustFit32BitSignedRange = false;
errorSettings.unexpectedIdentifier = Diagnostics::PP_CONDITIONAL_UNEXPECTED_TOKEN;
bool valid = true;
expressionParser.parse(token, &expression, false, errorSettings, &valid);
// Check if there are tokens after #if expression.
if (!isEOD(token))
{
mDiagnostics->report(Diagnostics::PP_CONDITIONAL_UNEXPECTED_TOKEN,
token->location, token->text);
skipUntilEOD(mTokenizer, token);
}
return expression;
}
int DirectiveParser::parseExpressionIfdef(Token* token)
{
assert((getDirective(token) == DIRECTIVE_IFDEF) ||
(getDirective(token) == DIRECTIVE_IFNDEF));
mTokenizer->lex(token);
if (token->type != Token::IDENTIFIER)
{
mDiagnostics->report(Diagnostics::PP_UNEXPECTED_TOKEN,
token->location, token->text);
skipUntilEOD(mTokenizer, token);
return 0;
}
MacroSet::const_iterator iter = mMacroSet->find(token->text);
int expression = iter != mMacroSet->end() ? 1 : 0;
// Check if there are tokens after #ifdef expression.
mTokenizer->lex(token);
if (!isEOD(token))
{
mDiagnostics->report(Diagnostics::PP_CONDITIONAL_UNEXPECTED_TOKEN,
token->location, token->text);
skipUntilEOD(mTokenizer, token);
}
return expression;
}
} // namespace pp
| [
"elix22@gmail.com"
] | elix22@gmail.com |
f1b75bc5d3625b044c9df80dfcf5f33f5e7de451 | eef2c36fbeeda1f8198e47f462a4815b910f90f9 | /src/Model/CTECList.h | 4fd96a5b3e9c7771b020ec873f0e1c246655b7fa | [] | no_license | RanchBean/NodeProject | 430d3598e52a69dd5c12523279bc2fafa991538a | 96875715c61c4380c8182ad2b3e3a2d8661f8406 | refs/heads/master | 2021-01-10T16:10:02.204024 | 2016-03-02T20:26:01 | 2016-03-02T20:26:01 | 52,994,003 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 697 | h | /*
* CTECList.h
*
* Created on: Mar 2, 2016
* Author: ethr5627
*/
#ifndef MODEL_CTECLIST_H_
#define MODEL_CTECLIST_H_
#include "ArrayNode.h"
template <class Type>
class CTECList
{
private:
int size;
ArrayNode<Type> * head;
ArrayNode<Type> * end;
void calculateSize();
public:
CTECList(int size);
virtual ~CTECList();
int getSize();
void addToFront(const Type& value);
void addToEnd(const Type& value);
void addAtIndex(int index, const Type& value);
Type getFront();
Type getEnd();
Type getFromIndex(int index);
Type removeFromFront();
Type removeFromEnd();
Type removeFromIndex(int index);
Type set(int index, const Type& value);
};
#endif /* MODEL_CTECLIST_H_ */
| [
"Ethunderson1@gmail.com"
] | Ethunderson1@gmail.com |
5d0f04346e40dab0341ee6c1437504b090d308c0 | 988d2a132be3d3f36a985d848f6d4cc54748d5e7 | /src/Platform.Linux/TimeSourceLinux.cpp | 7a35fc359d233ae2f11f83ed286ff81f80262f1e | [
"MIT"
] | permissive | ValtoForks/pomdog | 24336f3342c51a25a0260144bdc72f6bf0bb4a35 | 73798ae5f4a4c3b9b1e1e96239187c4b842c93b2 | refs/heads/master | 2021-05-03T15:47:12.979889 | 2019-01-04T15:42:05 | 2019-01-04T15:42:05 | 120,486,114 | 0 | 0 | NOASSERTION | 2019-01-04T15:42:06 | 2018-02-06T16:15:53 | C++ | UTF-8 | C++ | false | false | 667 | cpp | // Copyright (c) 2013-2018 mogemimi. Distributed under the MIT license.
#include "TimeSourceLinux.hpp"
#include "Pomdog/Utility/Exception.hpp"
#include <ctime>
namespace Pomdog {
namespace Detail {
namespace Linux {
TimePoint TimeSourceLinux::Now() const
{
struct timespec now;
if (0 != clock_gettime(CLOCK_MONOTONIC, &now)) {
POMDOG_THROW_EXCEPTION(std::runtime_error, "FUS RO DAH");
}
constexpr double nanoScale = (1.0 / 1000000000LL);
return TimePoint { Duration {
static_cast<double>(now.tv_sec) +
static_cast<double>(now.tv_nsec) * nanoScale}};
}
} // namespace Linux
} // namespace Detail
} // namespace Pomdog
| [
"mogemimi@enginetrouble.net"
] | mogemimi@enginetrouble.net |
6e7f7cb5173b98b2da90b494b8da0b5ec85bf5ae | 6b660cb96baa003de9e18e332b048c0f1fa67ab9 | /External/SDK/Proposal_TheAshenDragon_Chapter4_classes.h | bdac822c037b2471503394a6d8e5b6e985fce7dd | [] | no_license | zanzo420/zSoT-SDK | 1edbff62b3e12695ecf3969537a6d2631a0ff36f | 5e581eb0400061f6e5f93b3affd95001f62d4f7c | refs/heads/main | 2022-07-30T03:35:51.225374 | 2021-07-07T01:07:20 | 2021-07-07T01:07:20 | 383,634,601 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 859 | h | #pragma once
// Name: SoT, Version: 2.2.0.2
/*!!DEFINE!!*/
/*!!HELPER_DEF!!*/
/*!!HELPER_INC!!*/
#ifdef _MSC_VER
#pragma pack(push, 0x01)
#endif
namespace CG
{
//---------------------------------------------------------------------------
// Classes
//---------------------------------------------------------------------------
// BlueprintGeneratedClass Proposal_TheAshenDragon_Chapter4.Proposal_TheAshenDragon_Chapter4_C
// 0x0000 (FullSize[0x0140] - InheritedSize[0x0140])
class UProposal_TheAshenDragon_Chapter4_C : public UVoyageCheckpointProposalDesc
{
public:
static UClass* StaticClass()
{
static auto ptr = UObject::FindClass("BlueprintGeneratedClass Proposal_TheAshenDragon_Chapter4.Proposal_TheAshenDragon_Chapter4_C");
return ptr;
}
void AfterRead();
void BeforeDelete();
};
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"Massimo.linker@gmail.com"
] | Massimo.linker@gmail.com |
42d78e6dc50ba65a998f75af5136b5e53369ab21 | db3562d8fa915393c7ffa760af62647ebccf8212 | /common/src/colorf.hpp | ac84d2e9456baca390f255e7c80870d5ab032be6 | [] | no_license | haoqoo/mir2x | 1269cf2ab70a7664a5565a6a56746cf30cdf0659 | c2fed4e6e4f8c0e40ce6b13c122fc26ef808dab9 | refs/heads/master | 2023-07-08T11:03:12.462614 | 2021-08-08T19:50:00 | 2021-08-08T19:50:00 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,455 | hpp | /*
* =====================================================================================
*
* Filename: colorf.hpp
* Created: 03/31/2016 19:46:27
* Description:
*
* Version: 1.0
* Revision: none
* Compiler: gcc
*
* Author: ANHONG
* Email: anhonghe@gmail.com
* Organization: USTC
*
* =====================================================================================
*/
#pragma once
#include <array>
#include <cstdint>
#include <SDL2/SDL.h>
namespace colorf
{
constexpr uint32_t R_MASK = 0X000000FF;
constexpr uint32_t G_MASK = 0X0000FF00;
constexpr uint32_t B_MASK = 0X00FF0000;
constexpr uint32_t A_MASK = 0XFF000000;
constexpr int R_SHIFT = 0;
constexpr int G_SHIFT = 8;
constexpr int B_SHIFT = 16;
constexpr int A_SHIFT = 24;
constexpr uint8_t R(uint32_t color) { return (color & R_MASK) >> R_SHIFT; }
constexpr uint8_t G(uint32_t color) { return (color & G_MASK) >> G_SHIFT; }
constexpr uint8_t B(uint32_t color) { return (color & B_MASK) >> B_SHIFT; }
constexpr uint8_t A(uint32_t color) { return (color & A_MASK) >> A_SHIFT; }
constexpr uint32_t R_SHF(uint8_t r) { return (uint32_t)(r) << R_SHIFT; }
constexpr uint32_t G_SHF(uint8_t g) { return (uint32_t)(g) << G_SHIFT; }
constexpr uint32_t B_SHF(uint8_t b) { return (uint32_t)(b) << B_SHIFT; }
constexpr uint32_t A_SHF(uint8_t a) { return (uint32_t)(a) << A_SHIFT; }
constexpr uint32_t RGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a)
{
return R_SHF(r) | G_SHF(g) | B_SHF(b) | A_SHF(a);
}
constexpr uint32_t RGB(uint8_t r, uint8_t g, uint8_t b)
{
return R_SHF(r) | G_SHF(g) | B_SHF(b);
}
constexpr uint32_t maskRGB(uint32_t color)
{
return color & (R_MASK | G_MASK | B_MASK);
}
template<typename T> constexpr uint8_t round255(T val)
{
if(val <= T(0)){
return 0;
}
if(val >= T(255)){
return 255;
}
return (uint8_t)(val);
}
constexpr uint32_t RGBA_F(double fr, double fg, double fb, double fa)
{
return RGBA(round255(fr * 255.0), round255(fg * 255.0), round255(fb * 255.0), round255(fa * 255.0));
}
constexpr uint32_t RED = RGB(0XFF, 0X00, 0X00);
constexpr uint32_t GREEN = RGB(0X00, 0XFF, 0X00);
constexpr uint32_t BLUE = RGB(0X00, 0X00, 0XFF);
constexpr uint32_t YELLOW = RGB(0XFF, 0XFF, 0X00);
constexpr uint32_t CYAN = RGB(0X00, 0XFF, 0XFF);
constexpr uint32_t MAGENTA = RGB(0XFF, 0X00, 0XFF);
constexpr uint32_t BLACK = RGB(0X00, 0X00, 0X00);
constexpr uint32_t GREY = RGB(0X80, 0X80, 0X80);
constexpr uint32_t WHITE = RGB(0XFF, 0XFF, 0XFF);
constexpr uint32_t modRGBA(uint32_t origColor, uint32_t modColor)
{
const float r_R = 1.0f * R(modColor) / 255.0;
const float r_G = 1.0f * G(modColor) / 255.0;
const float r_B = 1.0f * B(modColor) / 255.0;
const float r_A = 1.0f * A(modColor) / 255.0;
const auto newR = round255(r_R * R(origColor));
const auto newG = round255(r_G * G(origColor));
const auto newB = round255(r_B * B(origColor));
const auto newA = round255(r_A * A(origColor));
return RGBA(newR, newG, newB, newA);
}
constexpr uint32_t renderRGBA(uint32_t dstColor, uint32_t srcColor)
{
auto dstR = R(dstColor);
auto dstG = G(dstColor);
auto dstB = B(dstColor);
auto dstA = A(dstColor);
auto srcR = R(srcColor);
auto srcG = G(srcColor);
auto srcB = B(srcColor);
auto srcA = A(srcColor);
double fAlpha = srcA / 255.0;
dstR = round255(fAlpha * srcR + (1.0 - fAlpha) * dstR);
dstG = round255(fAlpha * srcG + (1.0 - fAlpha) * dstG);
dstB = round255(fAlpha * srcB + (1.0 - fAlpha) * dstB);
dstA = round255( srcA + (1.0 - fAlpha) * dstA);
return RGBA(dstR, dstG, dstB, dstA);
}
constexpr uint32_t fadeRGBA(uint32_t fromColor, uint32_t toColor, float r)
{
const uint32_t fromR = colorf::R(fromColor);
const uint32_t fromG = colorf::G(fromColor);
const uint32_t fromB = colorf::B(fromColor);
const uint32_t fromA = colorf::A(fromColor);
const uint32_t toR = colorf::R(toColor);
const uint32_t toG = colorf::G(toColor);
const uint32_t toB = colorf::B(toColor);
const uint32_t toA = colorf::A(toColor);
const uint32_t dstR = round255(fromR * (1.0 - r) + toR * r);
const uint32_t dstG = round255(fromG * (1.0 - r) + toG * r);
const uint32_t dstB = round255(fromB * (1.0 - r) + toB * r);
const uint32_t dstA = round255(fromA * (1.0 - r) + toA * r);
return colorf::RGBA(dstR, dstG, dstB, dstA);
}
template<size_t N> std::array<uint32_t, N> gradColor(uint32_t beginColor, uint32_t endColor)
{
static_assert(N >= 2);
std::array<uint32_t, N> result;
const auto beginR = (float)(R(beginColor));
const auto beginG = (float)(G(beginColor));
const auto beginB = (float)(B(beginColor));
const auto beginA = (float)(A(beginColor));
const auto fdR = ((float)(R(endColor)) - beginR) / (N - 1.0);
const auto fdG = ((float)(G(endColor)) - beginG) / (N - 1.0);
const auto fdB = ((float)(B(endColor)) - beginB) / (N - 1.0);
const auto fdA = ((float)(A(endColor)) - beginA) / (N - 1.0);
for(size_t i = 0; i < N; ++i){
result[i] = RGBA(round255(beginR + i * fdR), round255(beginG + i * fdG), round255(beginB + i * fdB), round255(beginA + i * fdA));
}
return result;
}
inline SDL_Color RGBA2SDLColor(uint8_t r, uint8_t g, uint8_t b, uint8_t a)
{
SDL_Color color;
color.r = r;
color.g = g;
color.b = b;
color.a = a;
return color;
}
inline SDL_Color RGBA2SDLColor(uint32_t color)
{
return RGBA2SDLColor(colorf::R(color), colorf::G(color), colorf::B(color), colorf::A(color));
}
inline uint32_t SDLColor2RGBA(const SDL_Color &color)
{
return RGBA(color.r, color.g, color.b, color.a);
}
inline uint32_t compColor(uint32_t color)
{
return RGBA(255 - R(color), 255 - G(color), 255 - B(color), 255 - A(color));
}
uint32_t string2RGBA(const char *);
}
| [
"anhonghe@gmail.com"
] | anhonghe@gmail.com |
d3fe5b6bab72bdd3606aeaf978e57ec48ab2584f | 91a882547e393d4c4946a6c2c99186b5f72122dd | /Source/XPSP1/NT/multimedia/directx/dmusic/dmusic/des8.h | 2638e9a462fc263ba3d784d39e77162faa8c2de1 | [] | no_license | IAmAnubhavSaini/cryptoAlgorithm-nt5src | 94f9b46f101b983954ac6e453d0cf8d02aa76fc7 | d9e1cdeec650b9d6d3ce63f9f0abe50dabfaf9e2 | refs/heads/master | 2023-09-02T10:14:14.795579 | 2021-11-20T13:47:06 | 2021-11-20T13:47:06 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 24,978 | h | //------------------------------------------------------------------------------
//
// des8.h -- Design of DirectX 8 interfaces for DirectMusic
//
// Copyright (c) 1998-1999 Microsoft Corporation
//
//------------------------------------------------------------------------------
//
// Prototypes for new DirectX 8 interfaces for DirectMusic core
//
// This header discusses interfaces which manange wave playback between
// the wave object, the DirectMusic port, and a DirectMusic software synth.
// It does not address communication between the wave track and the wave
// object or the software synth and DirectSound, or directly between the
// wave object and DirectSound.
//
// These interfaces are based on my understanding of our recent hallway
// discussions.
//
// Issues which need futher discussion are marked with XXX.
//
//
//
// New schedule breakdown
//
// 1. Port (synth and WDM)
// a. IDirectMusicPort::DownloadWave
// Code is very similar for WDM or software synth
// i. Get needed information from WO and create IDirectSoundSource 0.5
// ii. If oneshot, track and download header and wave data 3.5
// iii. If streaming, download header 0.5
//
// b. IDirectMusicPort::UnloadWave
// i. Arbitrate with device for 0 refcount of download 1.0
//
// c. IDirectMusicPort::AllocVoice
// i. Allocate voice ID 0.5
// ii. If streaming, allocate preread samples and streaming buffers 2.5
//
// d. Voice Service Thread
// i. Init and shutdown code at port create/destroy 1.0
// ii. Call listed voices every ~100 ms 0.5
//
// e. CDirectMusicVoice::Service
// i. Communicate with device to determine each voice position 0.5
// ii. Calculate how much more wave data is needed 1.0
// iii. Fill wave data from IDirectSoundSource and send to device 1.0
// iv. Determine when playback is complete and stop voice 0.5
//
// f. IDirectMusicVoice::Play
// i. Communicate request to device 0.3
// ii. Send down timestamped preread data 0.3
// iii. Insert into VST 0.3
//
// g. IDirectMusicVoice::Stop
// i. Flag voice as stopped 0.5
// ii. Forward request to device 0.0
//
// h. Setup and connection
//
// i. Move sink code into DSound 3.0
//
//
15.5
//
// Things to change
//
// * We will model the DownloadWave interface after the Download interface
// and will pass things down to the synth as such:
//
// DLH + WAD -> Download header + Wave Articulation Data
// (contains loop points and count, etc.)
//
// DLH + DATA -> Download header + data
//
// * For oneshot data we want to do download refcounting like we do for
// regular DLS downloads. For streams we do not since the data that comes
// down in each download is the next set of data for the device to play.
//
// Download waves first, then wave articulations
// Separate multichannel downloads
// Rotating buffers and refresh for streaming
//
// New generic typedefs and #defines
//
typedef ULONGLONG SAMPLE_TIME; // Sample position w/in stream
typedef SAMPLESPOS *PSAMPLE_TIME;
#define DMUS_DOWNLOADINFO_WAVEARTICULATION 4 // Wave articulation data
#define DMUS_DOWNLOADINFO_STREAMINGWAVE 5 // One chunk of a streaming
// wave
// This is built by the wave object from the 'smpl' chunk embedded in the
// wave file if there is one, else it is just defaults.
//
typedef struct _DMUS_WAVEART
{
DWORD cbSize; // As usual
WSMPL WSMP; // Wave sample as per DLS1
WLOOP WLOOP[1]; // If cSampleCount > 1
} DMUS_WAVEART;
//------------------------------------------------------------------------------
//
// IDirectSoundSource
//
// An IDirectSound source is the interface to what we've been calling the
// viewport object.
//
//
//
interface IDirectSoundSource
{
// Init
//
// Gives the interface of the connected sink
STDMETHOD(Init)
(THIS_
IDirectSoundSink *pSink // Connected sink
);
// GetFormat
//
// Returns the format the source is returning the wave data in
//
STDMETHOD(GetFormat)
(THIS_
LPWAVEFORMATEX *pwfx, // Wave format to fill in
LPDWORD pcbwfx // Size of wave format,
// returns actual size
) PURE;
// Seek
//
// Seek to the given sample position in the stream. May be inexact
// due to accuracy settings of wave object. To account for this
//
STDMETHOD(Seek)
(THIS_
SAMPLEPOS sp // New sample position
) PURE;
// Read
//
// Read the given amount of sample data into the provided buffer starting
// from the read cursor. The read cursor is set with seek and advanced
// with each successive call to Read.
//
STDMETHOD(Read)
(THIS_
LPVOID *ppvBuffer, // Array of pvBuffer's
DWORD cpvBuffer, // and how many are passed in
PSAMPLEPOS pcb // In: number of samples to read
// Out: number of samples read
) PURE;
// GetSize
//
// Returns the size of the entire wave, in bytes, in the requested format
//
STDMETHOD(GetSize)
(THIS_
PULONG *pcb // Out: Bytes in stream
) PURE;
};
//------------------------------------------------------------------------------
//
// IDirectSoundSink
//
// An IDirectSound sink is the interface which feeds itself from one
// IDirectSoundSource. It is based on the IDirectMusicSynthSink interface
//
//
interface IDirectSoundSink
{
// Init
//
// Sets up the source to render from
//
STDMETHOD(Init)
(THIS_
IDirectSoundSource *pSource // The source from which we read
) PURE;
// SetMasterClock
//
// Sets the master clock (reference time) to use
//
STDMETHOD(SetMasterClock)
(THIS_
IReferenceClock *pClock // Master timebase
) PURE;
// GetLatencyClock
//
// Returns the clock which reads latency time, relative to
// the master clock
//
STDMETHOD(GetLatencyClock)
(THIS_
IReferenceClock **ppClock // Returns latency clock
) PURE;
// Activate
//
// Starts or stops rendering
//
STDMETHOD(Activate)
(THIS_
BOOL fEnable // Get ready or stop
) PURE;
// SampleToRefTime
//
// Converts a sample position in the stream to
// master clock time
//
STDMETHOD(SampleToRefTime)
(THIS_
SAMPLE_TIME sp, // Sample time in
REFERENCE_TIME *prt // Reference time out
) PURE;
// RefToSampleTime
//
// Converts a reference time to the nearest
// sample
//
STDMETHOD(RefToSampleTime)
(THIS_
REFERENCE_TIME rt, // Reference time in
SAMPLE_TIME *psp // Sample time out
) PURE;
};
//------------------------------------------------------------------------------
//
// IDirectSoundWave
//
// Public interface for the wave object
//
#define DSWCS_F_DEINTERLEAVED 0x00000001 // Multi-channel data as
// multiple buffers
interface IDirectSoundWave
{
// GetWaveArticulation
//
// Returns wave articulation data, either based on a 'smpl' chunk
// from the wave file or a default.
//
STDMETHOD(GetWaveArticulation)
(THIS_
WAVEARTICULATION *pArticulation // Articulation to fill in
) PURE;
// CreateSource
//
// Creates a new IDirectSoundSource to read wave data from
// this wave
//
STDMEHTOD(CreateSource)
(THIS_
IDirectSoundSource **ppSource // Created viewport object
LPWAVEFORMATEX pwfex, // Desired format
DWORD dwFlags // DSWCS_xxx
) PURE;
};
//------------------------------------------------------------------------------
//
// IDirectMusicPort8
//
//
//
#define DMDLW_STREAM 0x00000001
interface IDirectMusicPort8 extends IDirectMusicPort
{
// DownloadWave
//
// Creates a downloaded wave object representing the wave on this
// port.
//
STDMETHOD(DownloadWave)
(THIS_
IDirectSoundWave *pWave, // Wave object
ULONGLONG rtStart, // Start position (stream only)
DWORD dwFlags, // DMDLW_xxx
IDirectSoundDownloadedWave **ppWave // Returned downloaded wave
) PURE;
// UnloadWave
//
// Releases the downloaded wave object as soon as there are no voices
// left referencing it.
//
STDMETHOD(UnloadWave)
(THIS_
IDirectSoundDownloadedWave *pWave // Wave to unload
) PURE;
// AllocVoice
//
// Allocate one playback instance of the downloaded wave on this
// port.
//
STDMETHOD(AllocVoice)
(THIS_
IDirectSoundDownloadedWave *pWave, // Wave to play on this voice
DWORD dwChannel, // Channel and channel group
DWORD dwChannelGroup, // this voice will play on
SAMPLE_TIME stReadAhead, // How much to read ahead
IDirectMusicVoice **ppVoice // Returned voice
) PURE;
};
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//
// DownloadWave (normal use)
//
// 1. Application calls GetObject to load segment which contains a wave track.
// This causes GetObject to be called on all related waves, creating wave
// objects for all of them.
//
// 2. Wave track calls SetParam on each wave object to set up author-time
// parameters on the wave. This includes:
// - One-shot versus stream-ness
// - Readahead amount
//
// 3. Application calls SetParam(GUID_Download,...) to force download. As well
// as downloading DLS instruments (band track), the wave track calls
// DownloadWave for every wave to download. (Note: are we using the same GUID
// for download? It doesn't appear that SetParam on a segment is broadcast
// too all tracks, but rather is sent to the first track that understands
// the GUID, or the nth if an index is given. This would mean that
// the application would have to call SetParam twice with the same GUID
// and a different track index if there are both band and wave tracks
// in the segment??
//
// Returned is an IDirectMusicDownloadedWave(DirectSound?) to track the wave.
//
// The following happen during the DownloadWave method call:
//
// 4. The port queries the wave object for the stream-ness and readahead
// properties.
//
// XXX We decided that these things were per wave object, right?
// (As opposed to the viewport). And the wave object already knows them or
// is the right object to provide reasonable defaults.
//
// 5. The port requests a viewport from the wave object in its native format.
//
// 6. The port allocates buffer space. The buffer must be big enough to handle
// the entire wave in the case of the one shot, or at least big enough to
// handle the readahead samples in the streaming case. The streaming buffer
// may be allocated larger, however, if it is going to be used for the
// entire streaming session. Buffer choice here may be affected by the
// underlying port.
//
// I assume we are going to parallel the DLS architecture as much as
// possible here and are going to be able to trigger a downloaded wave
// more than once at the same time. In that case the buffer would have
// to be stored in the _voice_, not the DownloadedWave (except perhaps
// for the readahead which should always be kept around). Is this
// duplication of effort if we're going to be caching in the wave
// object as well?
//
// 7. If the wave is a one-shot, then the port will request the entire data
// for the wave from the viewport and downloads it to the device. At this
// point the viewport is released since the entire data for the wave is in
// the synth. If the wave is streaming, then nothing is done at the device
// level.
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//
// UnloadWave
//
// This tells the port that the application is done with the wave as soon as
// there are no more voice references to it. Internally it just calls
// Release() on the downloaded wave object. The dlwave object can then no longer
// be used to create voices. However, the dlwave will only really be released
// once all voices that currently use it are released.
//
// This is identical to calling Release() on the dlwave object directly
// (why does it exist?)
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//
// AllocVoice
//
// Allocate a voice object to play back the a wave on a channel group
//
// This call is simple. All it does it ask the synth for a voice ID (which
// is just a cookie that only has meaning to the synth) and creates the voice
// object.
//
// At this point the download is bound to the channel, since MIDI articulations
// sent to the voice before playback begins will need to know that.
//
// The voice object addref's the downloaded wave object.
//
//------------------------------------------------------------------------------
//
// IDirectMusicVoice
//
// One playback instance of a downloaded wave on a port
//
// Note that since we're already bound to a channel after the voice is
// created, we don't need any methods on the voice object for MIDI
// articulation. That can just go through the normal synth mechanism.
//
interface IDirectMusicVoice
{
public:
// Play
//
STDMETHOD(Play)
(_THIS
REFERENCE_TIME rtStart, // Time to play
REFERENCE_TIME rtStartInWave // XXX Move this
// Where in stream to start
) PURE;
// Should stop be scheduled or immediate?
//
STDMETHOD(Stop)
(_THIS
REFERENCE_TIME rtStop, // When to stop
) PURE;
};
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//
// QueryInterface(IID_IKsControl)
//
// All of the effects control should be in the DirectSound side now.
// However, IKsControl can still be used as in 6.1 and 7 to determine
// synth caps.
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//
// Play
//
// XXX I am not sure this is the right place to deal with preread. However,
// we can't deal with it at DownloadWave(), because we don't know at that
// point where to start (the app may play the stream from different
// starting points on different voice). We *could* do it at voice allocation
// time; that would just mean that the stream start position is fixed for
// a particular voice no matter how many times the voice is triggered.
// This is an issue because preread may take some time if decompression is
// taking place and the seek request is far into the wave; it may cause
// problems with low-latency Play commands.
//
// Note that I am delegating the quality versus efficiency flag to private
// communication between the wave object and the wave track or application.
//
// 1. Call Play() on the synth voice ID associated with this voice. If the
// associated wave is a one-shot, this is all that needs to be done.
//
// 2. For a stream, no preread data has been allocated yet. Tell the wave
// object to seek to the given position and preread. Give the preread data
// to the device via StreamVoiceData().
//
// 3. If the associated wave is a stream, insert this voice into the voice
// service list. This will cause push-pull arbiration to be done on the
// voice until it finishes or Stop() is called.
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//
// Stop
//
// 1. Call Stop() on the synth voice.
//
// 2. If the voice is streaming and not done, pull it from the voice service
// thread.
//
//------------------------------------------------------------------------------
//
// IDirectMusicSynth8
//
// New methods on the synthesizer interface for managing wave playback.
// A parallel to these methods will be needed on a hardware synth, probably
// implemented as a property set.
//
interface IDirectMusicSynth8 extends IDirectMusicSynth
{
public:
STDMETHOD(DownloadWave)
(THIS_
LPHANDLE pHandle, // Returned handle representing DL
LPVOID pvData, // Initial data
// XXX >1 channel -> buffers?
LPBOOL pbFree, // Is port allowed to free data?
BOOL bStream // This is preroll data for a stream
) PURE;
STDMETHOD(UnloadWave)
(THIS_
HANDLE phDownload, // Handle from DownloadWave
HRESULT (CALLBACK *pfnFreeHandle)(HANDLE,HANDLE),
// Callback to call when done
HANDLE hUserData // User data to pass back in
// callback
) PURE;
STDMETHOD(PlayVoice)
(THIS_
REFERENCE_TIME rt, // Time to start playback
DWORD dwVoiceId, // Voice ID allocated by port
DWORD dwChannelGroup, // Channel group and
DWORD dwChannel, // channel to start voice on
DWORD dwDLId // Download ID of the wave to play
// (This will be of the wave
// articulation)
) PURE;
STDMETHOD(StopVoice)
(THIS_
DWORD dwVoice, // Voice to stop
REFERENCE_TIME rt // When to stop
) PURE;
struct VOICE_POSITION
{
ULONGLONG ullSample; // Sample w/in wave
DWORD dwSamplesPerSec; // Playback rate at current pitch
};
STDMETHOD(GetVoicePosition)
(THIS_
HANDLE ahVoice[], // Array of handles to get position
DWORD cbVoice, // Elements in ahVoice and avp
VOICE_POSITION avp[] // Returned voice position
) PURE;
STDMETHOD(StreamVoiceData)
(THIS_
HANDLE hVoice, // Which voice this data is for
LPVOID pvData, // New sample data
DWORD cSamples // Number of samples in pvData
) PURE;
};
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//
// DownloadWave
//
// This could be the same as Download except that we need to deal with
// the streaming case.
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//
// UnloadWave
//
// Works just like Unload. In the streaming case, the callback will be
// called after _all_ data in the stream is free. Note that if UnloadWave
// is called while the wave is still playing, this could be quite some
// time.
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//
// PlayVoice
//
// Schedule the voice to be played. The synth already has the data
// for a oneshot wave, so starting playback is very fast. If the data is
// to be streamed it is the caller's responsibility (i.e. the port) to
// keep the stream fed via StreamVoiceData()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//
// StopVoice
//
// Just what it says.
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//
// GetVoicePosition
//
// This call retrieves the position of a set of voices. For each voice, the
// current sample position relative to the start of the stream and the
// average number of samples per second at the current pitch is returned. This
// gives the caller all the information it needs to stay ahead of the
// voice playback. This call is intended for use on streaming voices.
//
// Note that the playback position is an implication that all data up to the
// point of that sample is done with and the buffer space can be freed. This
// allows recycling of buffers in a streaming wave.
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//
// StreamVoiceData
//
// This call queues more data for a streaming voice.
//
// XXX This implies that there will be a discontinuity in the memory used
// by the synth mixer. How do we deal with that?
//
//
//------------------------------------------------------------------------------
//
// General questions and discussion
//
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//
// What can be underneath a DirectMusic port?
//
// In 6.1 and 7 this was easy; either a SW synth on top of DSound
// (synth port), or a kernel sw synth or hw synth (WDM port). (Not
// counting the dmusic16 code which will not be changing in 8).
//
// What are the scenarios we have now? Does it make sense (or is it even
// possible in light of backwards compat) to change what a port wraps?
// The two scenarios which match the existing ports are:
//
// Scenario: Software synthesizer on top of DirectSound as we have today.
// The hookup logic changes (we're talking n mono busses, etc.) but the
// mechanics do not: the application can still just hand us a DirectSound
// object and we connect it to the bottom of the synthesizer. This still has
// to work with pre-8 applications making the same set of API calls they
// always did, but internally it can be totally different.
// XXX Did we ever expose the IDirectMusicSynthSink and methods for hooking
// it up? Can this change? (It has to...) I _think_ this was a DDK thing...
// The application can also create a DX8 DirectSound buffer with all the
// bells and whistles and have that work as well. We need some (DX8) specific
// mechanism for routing what goes out of the synth into the n mono inputs
// of the DirectSound buffer if it's more than just a legacy stereo buffer.
//
//
// Scenario: We sit on top of a hardware or KM synth on top of *everything*
// else in kernel mode. We need private communication between DirectMusic,
// DirectSound, and SysAudio in order to hook this up, or we need to
// delegate the graph building tasks totally to DirectSound and have it
// deal exlusively with SysAudio connections. The latter is probably the
// way to go. In this case we fail if we cannot get a WDM driver under
// DirectSound to talk to, or if the DirectSound buffer is not totally in
// hardware. (This all argues for having DirectSound be able to instantiate
// the KM synth on top of the buffer rather than arbitrating with DirectMusic
// to do it). We need to define this interface ASAP.
// (Me, Dugan, Mohan, MikeM).
//
//
| [
"support@cryptoalgo.cf"
] | support@cryptoalgo.cf |
a2f65fbc834a3532902c96505214ba2362c7863b | 4a3e5419e89dfbd9788a4539740b8ea7321ee7ef | /152/a.cpp | fa919f60ef1c681b36c9a9c357b2d61fae12f726 | [] | no_license | tars0x9752/atcoder | d3cbfefeb5164edab72d87f8feb16e1160c231a2 | 0e54c9a34055e47ae6bb19d4493306e974a50eee | refs/heads/master | 2022-11-19T15:36:17.711849 | 2020-07-19T12:56:31 | 2020-07-19T12:56:31 | 182,626,178 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 286 | cpp | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
string ans = "Yes";
if (n != m) {
ans = "No";
}
cout << ans << endl;
return 0;
} | [
"46079709+huffhuffman@users.noreply.github.com"
] | 46079709+huffhuffman@users.noreply.github.com |
404b9c1345f96937f4acd9b8392a8434776209f6 | 3879d1ca43c573c209f962182cd1e7f7fe978fbf | /leetcode/328. Odd Even Linked List/328.cpp | 77270284afc81ea2f79021cccca32bc071e5cc56 | [] | no_license | DoctorLai/ACM | 34a5600a5adf22660c5d81b2d8b7a358be537ecf | aefa170f74c55c1230eb6f352770512b1e3f469e | refs/heads/master | 2023-09-01T02:13:01.604508 | 2023-08-31T15:42:07 | 2023-08-31T15:42:07 | 146,173,024 | 62 | 18 | null | 2020-10-11T13:19:57 | 2018-08-26T11:00:36 | C++ | UTF-8 | C++ | false | false | 752 | cpp | // https://helloacm.com/reconnect-the-nodes-in-linked-list-by-odd-even-in-place-odd-even-linked-list/
// https://leetcode.com/problems/odd-even-linked-list/
// MEDIUM, LINKED LIST
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* oddEvenList(ListNode* head) {
if (head == nullptr) return NULL;
auto odd = head, even = head->next, evenHead = even;
while (even && even->next) {
odd->next = even->next;
odd = odd->next;
even->next = odd->next;
even = even->next;
}
odd->next = evenHead;
return head;
}
};
| [
"dr.zhihua.lai@gmail.com"
] | dr.zhihua.lai@gmail.com |
2dfff90ac86c2615167ceac368040aaf6006ca9d | 203c4602712963d4b431902ff1a6e1f9da6bd56a | /FiveCardStud.h | 5c38c4464a102479eb094fba081e72dc7579ba00 | [] | no_license | Woogachaka/gcc-fivecardstud | 30872f219bf3f5973219b8324becd7fe7a50fb0a | 307e69cc622d125f142f5027182c4b252f23cad6 | refs/heads/master | 2020-12-11T05:56:18.188708 | 2014-02-20T17:59:56 | 2014-02-20T17:59:56 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,267 | h | #ifndef __GAME_H
#define __GAME_H
#include "Player.h"
#include "Card.h"
#include <iostream>
#include <vector>
#include <string>
#include <math.h>
class FiveCardStud
{
static const int PLAYER_STARTING_BANK = 100;
static const int ante = 1;
public:
FiveCardStud();
~FiveCardStud();
void setup(int nPlayers); //initiates a game with the set number of players
void play(); // plays multiple rounds until someone runs out of money
void packUp(); // after a game has finished
private:
int getPot() { return pot; } // dollars
void emptyPot() { pot = 0; }
void addPot(int value) { pot += value * 100; }
// implementable
void playRound(); // runs many times per game, one winner per round, goes through a few betting rounds
void performBetting(); // asks for a round of bets, starting from the dealer's left (or next in vector array, first if dealer is last), adding to the pot from player's banks
void shuffleDeck();
// ui functions
void ui_renderPlayerView(int playerId); // renders complete game view as it appears to player, clears screen and prompts for input
void ui_showWinner(int playerId);
std::vector<Player> players;
int dealerId; // contains the index for the player
//UserInterface ui;
std::vector<Card> deck;
int pot;
};
#endif | [
"jv789521@gmail.com"
] | jv789521@gmail.com |
8dc3c21065bf5fcde4b35eec4716dd7eeac5be6d | aeb95623970cf4a93317c38ab4eb27837adff35f | /Array/1252_CellswithOddValuesinaMatrix.cpp | 2c3716e2e285ab32c113f59c2cfcb4a33c95c959 | [] | no_license | CodingOfZero/LeetCode | e153e99b19887d1bc65ab45bd973e7ee3d328ac8 | 06c4b4c506d378144a7d5d1db5d9f4e06999fbe0 | refs/heads/master | 2021-07-20T16:31:56.675310 | 2021-07-05T12:06:31 | 2021-07-05T12:06:31 | 141,298,691 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 2,296 | cpp | /*
时间：2019年12月20日 16:19:32
题目：Given n and m which are the dimensions of a matrix initialized by zeros
and given an array indices where indices[i] = [ri, ci].
For each pair of [ri, ci] you have to increment all cells in row ri and column ci by 1
题意：将ri行加一，ci列加一
*/
#include<vector>
#include<iostream>
using namespace std;
/*
Runtime: 4 ms, faster than 83.07% of C++ online submissions for Cells with Odd Values in a Matrix.
Memory Usage: 9.2 MB, less than 100.00% of C++ online submissions for Cells with Odd Values in a Matrix.
*/
#define MAXN 55
#define MAXM 55
int cells[MAXN][MAXM];
int oddCells_1(int n, int m, vector<vector<int>>& indices) {//直接暴力求解
int odd = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
cells[i][j] = 0;
for (size_t i = 0; i < indices.size(); i++) {
int a = indices[i][0];
int b = indices[i][1];
for (int i = 0; i < m; i++)
cells[a][i]++;
for (int i = 0; i < n; i++)
cells[i][b]++;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (cells[i][j] % 2 != 0)
odd++;
return odd;
}
/*
Runtime: 0 ms, faster than 100.00% of C++ online submissions for Cells with Odd Values in a Matrix.
Memory Usage: 9.3 MB, less than 100.00% of C++ online submissions for Cells with Odd Values in a Matrix.
*/
int oddCells_2(int n, int m, vector<vector<int>>& indices) {
vector<int> oddRows;
vector<int> oddCols;
//初始化所有行与列,0是偶数
oddRows.assign(n, 0);
oddCols.assign(m, 0);
for (const auto &elem : indices) {
oddRows[elem[0]] = 1 - oddRows[elem[0]];
oddCols[elem[1]] = 1 - oddCols[elem[1]];
}
//统计奇数的列数
int numOddCols = 0;
for (const auto c : oddCols)//这种写法会比下方速度快
numOddCols += c;
/*for (size_t i = 0; i < oddCols.size(); i++)
if (oddCols[i] == 1)
numOddCols++;*/
int numEvenCols = m - numOddCols;
//输出奇数个数
int Odd = 0;
for (auto r:oddRows)
Odd += r ? numEvenCols : numOddCols;
return Odd;
}
int main() {
vector<vector<int>> indices = { {1,1},{0,0} };
vector<vector<int>> indices2 = { { 0,1 },{ 1,1 } };
int odd1=oddCells_1(2, 2, indices);
int odd2= oddCells_2(2, 3, indices2);
cout << odd2;
}
| [
"895756412@qq.com"
] | 895756412@qq.com |
c4f58ecdbb82c5c17e0a16579b6252d5ef97f4e1 | b6fb6785e6689c1e22c30327e690e290e54f57b0 | /MainWindow.cpp | 3c9ba6294f8ca0a64b4518dfa2b5d0cf442c7345 | [] | no_license | MetalStrikerXLR/FQMCv2-GUI-QT | 15ef8dc44d3939b0b69e2a58d7cc9c750f8428d8 | 62176e3d81b8ec50d6e3ce390506b7d482de4429 | refs/heads/master | 2023-08-05T06:44:49.018291 | 2019-11-06T19:49:46 | 2019-11-06T19:49:46 | 404,446,010 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 22,020 | cpp |
#ifndef MAINWINDOW_CPP
#define MAINWINDOW_CPP
#endif
#include "MainWindow.h"
#include "ui_MainWindow.h"
using namespace std;
MainWindow::MainWindow( QWidget *parent ) :
QMainWindow( parent ),
m_ui( new Ui::MainWindow ),
m_timerId ( 0 ),
m_steps ( 0 ),
m_realTime ( 0.0 )
{
m_ui->setupUi( this );
logtimer = new QTimer(this);
blinkTimer = new QTimer(this);
///////////////////////////////////////////////////////////////////////////////////////////////////////////
m_ui->Connection_Status->setTextFormat(Qt::RichText);
m_ui->Connection_Status->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>Disconnected</span>");
m_ui->Pump_status1->setTextFormat(Qt::RichText);
m_ui->Pump_status2->setTextFormat(Qt::RichText);
m_ui->Valve_status1->setTextFormat(Qt::RichText);
m_ui->Valve_status2->setTextFormat(Qt::RichText);
m_ui->Valve_status3->setTextFormat(Qt::RichText);
m_ui->Valve_status4->setTextFormat(Qt::RichText);
m_ui->Pump_status1->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>OFF</span>");
m_ui->Pump_status2->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>OFF</span>");
m_ui->Valve_status1->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>CLOSED</span>");
m_ui->Valve_status2->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>CLOSED</span>");
m_ui->Valve_status3->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>CLOSED</span>");
m_ui->Valve_status4->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>CLOSED</span>");
m_ui->green_1->hide();
m_ui->green_2->hide();
m_ui->green_3->hide();
m_ui->green_4->hide();
m_ui->green_5->hide();
m_ui->green_6->hide();
m_ui->red_1->hide();
m_ui->red_2->hide();
m_ui->red_3->hide();
m_ui->red_4->hide();
m_ui->red_5->hide();
m_ui->red_6->hide();
redLight_1 = 1;
redLight_2 = 1;
redLight_3 = 1;
redLight_4 = 1;
redLight_5 = 1;
redLight_6 = 1;
m_ui->fuel_status_ind->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>LO FUEL</span>");
m_ui->P1_status_ind->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>LO PR</span>");
m_ui->P2_status_ind->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>LO PR</span>");
m_ui->P3_status_ind->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>LO PR</span>");
m_ui->P4_status_ind->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>LO PR</span>");
m_ui->temp_status_ind->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>LO TEMP</span>");
m_ui->Log_frame->setStyleSheet("#Log_frame { border: 3px solid cyan; }");
scrollbar = m_ui->Log_Display->verticalScrollBar();
///////////////////////////////////////////////////////////////////////////////////////////////////////////
PressureGauge1 = new QcGaugeWidget;
PressureGauge1->addBackground(99);
QcBackgroundItem *bkg1 = PressureGauge1->addBackground(92);
bkg1->clearrColors();
bkg1->addColor(float(0.1),Qt::black);
bkg1->addColor(1.0,Qt::white);
QcBackgroundItem *bkg2 = PressureGauge1->addBackground(88);
bkg2->clearrColors();
bkg2->addColor(float(0.1),Qt::darkGray);
bkg2->addColor(1.0,Qt::darkGray);
PressureGauge1->addArc(55);
PressureGauge1->addDegrees(65)->setValueRange(0,50);
PressureGauge1->addColorBand(50);
PressureGauge1->addValues(75)->setValueRange(0,50);
PressureGauge1->addLabel(65)->setText("T1->T3");
QcLabelItem *lab = PressureGauge1->addLabel(40);
lab->setText("0");
Needle1 = PressureGauge1->addNeedle(60);
Needle1->setLabel(lab);
Needle1->setColor(Qt::black);
Needle1->setValueRange(0,50);
PressureGauge1->addBackground(7);
PressureGauge1->addGlass(88);
m_ui->p1_gauge_layout->addWidget(PressureGauge1);
PressureGauge2 = new QcGaugeWidget;
PressureGauge2->addBackground(99);
QcBackgroundItem *bkg3 = PressureGauge2->addBackground(92);
bkg3->clearrColors();
bkg3->addColor(float(0.1),Qt::black);
bkg3->addColor(1.0,Qt::white);
QcBackgroundItem *bkg4 = PressureGauge2->addBackground(88);
bkg4->clearrColors();
bkg4->addColor(float(0.1),Qt::darkGray);
bkg4->addColor(1.0,Qt::darkGray);
PressureGauge2->addArc(55);
PressureGauge2->addDegrees(65)->setValueRange(0,50);
PressureGauge2->addColorBand(50);
PressureGauge2->addValues(75)->setValueRange(0,50);
PressureGauge2->addLabel(65)->setText("T3->T1");
QcLabelItem *lab2 = PressureGauge2->addLabel(40);
lab2->setText("0");
Needle2 = PressureGauge2->addNeedle(60);
Needle2->setLabel(lab2);
Needle2->setColor(Qt::black);
Needle2->setValueRange(0,50);
PressureGauge2->addBackground(7);
PressureGauge2->addGlass(88);
m_ui->p2_gauge_layout->addWidget(PressureGauge2);
PressureGauge3 = new QcGaugeWidget;
PressureGauge3->addBackground(99);
QcBackgroundItem *bkg5 = PressureGauge3->addBackground(92);
bkg5->clearrColors();
bkg5->addColor(float(0.1),Qt::black);
bkg5->addColor(1.0,Qt::white);
QcBackgroundItem *bkg6 = PressureGauge3->addBackground(88);
bkg6->clearrColors();
bkg6->addColor(float(0.1),Qt::darkGray);
bkg6->addColor(1.0,Qt::darkGray);
PressureGauge3->addArc(55);
PressureGauge3->addDegrees(65)->setValueRange(0,50);
PressureGauge3->addColorBand(50);
PressureGauge3->addValues(75)->setValueRange(0,50);
PressureGauge3->addLabel(65)->setText("VENT-L");
QcLabelItem *lab3 = PressureGauge3->addLabel(40);
lab3->setText("0");
Needle3 = PressureGauge3->addNeedle(60);
Needle3->setLabel(lab3);
Needle3->setColor(Qt::black);
Needle3->setValueRange(0,50);
PressureGauge3->addBackground(7);
PressureGauge3->addGlass(88);
m_ui->p3_gauge_layout->addWidget(PressureGauge3);
PressureGauge4 = new QcGaugeWidget;
PressureGauge4->addBackground(99);
QcBackgroundItem *bkg7 = PressureGauge4->addBackground(92);
bkg7->clearrColors();
bkg7->addColor(float(0.1),Qt::black);
bkg7->addColor(1.0,Qt::white);
QcBackgroundItem *bkg8 = PressureGauge4->addBackground(88);
bkg8->clearrColors();
bkg8->addColor(float(0.1),Qt::darkGray);
bkg8->addColor(1.0,Qt::darkGray);
PressureGauge4->addArc(55);
PressureGauge4->addDegrees(65)->setValueRange(0,50);
PressureGauge4->addColorBand(50);
PressureGauge4->addValues(75)->setValueRange(0,50);
PressureGauge4->addLabel(65)->setText("ENG-L");
QcLabelItem *lab4 = PressureGauge4->addLabel(40);
lab4->setText("0");
Needle4 = PressureGauge4->addNeedle(60);
Needle4->setLabel(lab4);
Needle4->setColor(Qt::black);
Needle4->setValueRange(0,50);
PressureGauge4->addBackground(7);
PressureGauge4->addGlass(88);
m_ui->p4_gauge_layout->addWidget(PressureGauge4);
///////////////////////////////////////////////////////////////////////////////////////////////////////////
connect(logtimer, SIGNAL(timeout()),this, SLOT(updateLog()));
connect(blinkTimer, SIGNAL(timeout()),this, SLOT(blink()));
connect(&TCPsocket, SIGNAL(sendUpdate(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float)), this, SLOT(applyUpdate(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float)));
connect(&TCPsocket,SIGNAL(updateConnectionStatus(QString)),this,SLOT(connectionStatus(QString))); // Connection Status Signal
connect(this,SIGNAL(retrySignal()),&TCPsocket,SLOT(retry())); // Retry Button Signal
connect(this, SIGNAL(requestData()),&TCPsocket, SLOT(requestSignal()));
///////////////////////////////////////////////////////////////////////////////////////////////////////////
TCPsocket.moveToThread(&socketThread);
socketThread.start();
emit retrySignal();
///////////////////////////////////////////////////////////////////////////////////////////////////////////
m_timerId = startTimer( 0 );
m_time.start();
logtimer->start(1000);
blinkTimer->start(500);
}
///////////////////////////////// MainWindow Destructor ///////////////////////////////////////////////////////
MainWindow::~MainWindow() // Main Window Destructor
{
socketThread.quit();
socketThread.wait();
cout << "Average time step: " << ( double(m_realTime) ) / ( double(m_steps )) << " s" << endl;
if ( m_timerId ) killTimer( m_timerId );
if ( m_ui )
{
delete m_ui;
}
m_ui = nullptr;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void MainWindow::timerEvent( QTimerEvent *event )
{
/////////////////////////////////
QMainWindow::timerEvent( event );
/////////////////////////////////
float timeStep = m_time.restart();
m_realTime = m_realTime + timeStep / 1000.0f;
emit requestData();
m_ui->Temp_display->display(double(temp));
m_ui->PP1_display->display(double(pres1));
m_ui->PP2_display->display(double(pres2));
m_ui->PP3_display->display(double(pres3));
m_ui->EPP_display->display(double(EnPres));
Needle1->setCurrentValue(pres1);
Needle2->setCurrentValue(pres2);
Needle3->setCurrentValue(pres3);
Needle4->setCurrentValue(EnPres);
m_ui->FWD_vol->display(double(vol1));
m_ui->MID_vol->display(double(vol2));
m_ui->REAR_vol->display(double(vol3));
m_ui->LT_vol_display->display(double(vol4));
m_ui->RT_vol_display->display(double(vol5));
m_ui->Lvl1_display->display(double(lvl1));
m_ui->Lvl2_display->display(double(lvl2));
m_ui->Lvl3_display->display(double(lvl3));
m_ui->Lvl4_display->display(double(lvl4));
m_ui->Lvl5_display->display(double(lvl5));
m_ui->TankFWD->setValue(int(per1));
m_ui->TankMID->setValue(int(per2));
m_ui->TankREAR->setValue(int(per3));
m_ui->RTank->setPercentage(int(per4));
m_ui->LTank->setPercentage(int(per5));
m_ui->TankFWD->setFormat("FWD: "+QString::number(double(per1))+"%"+" | "+QString::number(double(vol1))+"L");
m_ui->TankMID->setFormat("MID: "+QString::number(double(per2))+"%"+" | "+QString::number(double(vol2))+"L");
m_ui->TankREAR->setFormat("REAR: "+QString::number(double(per3))+"%"+" | "+QString::number(double(vol3))+"L");
m_ui->TankFWD->update();
m_ui->TankMID->update();
m_ui->TankREAR->update();
updatePumpandValves();
checkWarnings();
m_ui->datetime_label->setText(QDateTime::currentDateTime().toString("yyyy-MM-dd HH:mm:ss"));
m_steps++;
}
void MainWindow::applyUpdate(float data1, float data2, float data3, float data4, float data5, float data6, float data7, float data8, float data9, float data10, float data11, float data12, float data13, float data14, float data15, float data16, float data17, float data18, float data19, float data20, float data21, float data22, float data23, float data24, float data25, float data26, float data27, float data28, float data29, float data30, float data31, float data32, float data33, float data34, float data35, float data36, float data37, float data38, float data39, float data40)
{
roll = data1;
pitch = data2;
heading = data3;
temp = data4;
per1 = data5;
per2 = data6;
per3 = data7;
per4 = data8;
per5 = data9;
mass1 = data10;
mass2 = data11;
mass3 = data12;
mass4 = data13;
mass5 = data14;
vol1 = data15;
vol2 = data16;
vol3 = data17;
vol4 = data18;
vol5 = data19;
lvl1 = data20;
lvl2 = data21;
lvl3 = data22;
lvl4 = data23;
lvl5 = data24;
// pressure1 = data;
// pressure2 = data;
// pressure3 = data;
// EPres = data;
// Pump_state1 = data;
// Pump_state2 = data;
// Valve_state1 = data;
// Valve_state2 = data;
// Valve_state3 = data;
// Valve_state4 = data;
// CGx = data;
// CGy = data;
// av_fuel = data;
// ffr = data;
// con_fuel = data;
}
void MainWindow::updateLog()
{
scrollbar->setValue(scrollbar->maximum());
m_ui->Log_Display->insertPlainText(QDateTime::currentDateTime().toString("[yyyy-MM-dd HH:mm:ss] ") + "pitch: " + QString::number(double(pitch)) + ", roll: " + QString::number(double(roll)) + ", heading: " + QString::number(double(heading)) + ", temp: " + QString::number(double(temp)) + ", perFWD: " + QString::number(double(per1)) + ", perMID: " + QString::number(double(per2)) + ", perREAR: " + QString::number(double(per3)) + ", perLT: " + QString::number(double(per4)) + ", perRT: " + QString::number(double(per5)) + ", massFWD: " + QString::number(double(mass1)) + ", massMID: " + QString::number(double(mass2)) + ", massREAR: " + QString::number(double(mass3)) + ", massLT: " + QString::number(double(mass4)) + ", massRT: " + QString::number(double(mass5)) + ", roll: " + QString::number(double(roll)) + ", roll: " + QString::number(double(roll)) + ", roll: " + QString::number(double(roll)) + ", roll: " + QString::number(double(roll)) + ", roll: " + QString::number(double(roll)) + ", roll: " + QString::number(double(roll)) + ", roll: " + QString::number(double(roll)) + ", roll: " + QString::number(double(roll)) + ", roll: " + QString::number(double(roll)) + ", roll: " + QString::number(double(roll)) + ", roll: " + QString::number(double(roll)) + ", roll: " + QString::number(double(roll)) + ", roll: " + QString::number(double(roll)) + ", roll: " + QString::number(double(roll)) + ", roll: " + QString::number(double(roll)) + ", roll: " + QString::number(double(roll)) + ", roll: " + QString::number(double(roll)) + ", roll: " + QString::number(double(roll)) + ", roll: " + QString::number(double(roll)) + ", roll: " + QString::number(double(roll)) + ", roll: " + QString::number(double(roll)) + ", roll: " + QString::number(double(roll)) + ", roll: " + QString::number(double(roll)) + "\n");
}
void MainWindow::blink()
{
if(trigger == 0)
{
if(redLight_1 == 1)
{
m_ui->red_1->show();
}
else
{
m_ui->green_1->show();
}
if(redLight_2 == 1)
{
m_ui->red_2->show();
}
else
{
m_ui->green_2->show();
}
if(redLight_3 == 1)
{
m_ui->red_3->show();
}
else
{
m_ui->green_3->show();
}
if(redLight_4 == 1)
{
m_ui->red_4->show();
}
else
{
m_ui->green_4->show();
}
if(redLight_5 == 1)
{
m_ui->red_5->show();
}
else
{
m_ui->green_5->show();
}
if(redLight_6 == 1)
{
m_ui->red_6->show();
}
else
{
m_ui->green_6->show();
}
trigger = 1;
}
else
{
if(redLight_1 == 1)
{
m_ui->red_1->hide();
}
else
{
m_ui->green_1->hide();
}
if(redLight_2 == 1)
{
m_ui->red_2->hide();
}
else
{
m_ui->green_2->hide();
}
if(redLight_3 == 1)
{
m_ui->red_3->hide();
}
else
{
m_ui->green_3->hide();
}
if(redLight_4 == 1)
{
m_ui->red_4->hide();
}
else
{
m_ui->green_4->hide();
}
if(redLight_5 == 1)
{
m_ui->red_5->hide();
}
else
{
m_ui->green_5->hide();
}
if(redLight_6 == 1)
{
m_ui->red_6->hide();
}
else
{
m_ui->green_6->hide();
}
trigger = 0;
}
}
void MainWindow::connectionStatus(QString status)
{
ConnectionStatusLogin = status;
if(status == "Connected")
{
m_ui->Connection_Status->setText("<span style=' font-size:14pt; font-weight:600; color:#00ff00'>Connected</span>");
}
else if(status == "Retrying")
{
m_ui->Connection_Status->setText("<span style=' font-size:14pt; font-weight:600; color:#ffaa00;'>Connecting</span>");
}
else
{
m_ui->Connection_Status->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>Disconnected</span>");
}
}
void MainWindow::updatePumpandValves()
{
if(Pump_state1 == 1)
{
m_ui->Pump_status1->setText("<span style=' font-size:14pt; font-weight:600; color:#00ff00'>ON</span>");
}
else
{
m_ui->Pump_status1->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>OFF</span>");
}
if(Pump_state2 == 1)
{
m_ui->Pump_status2->setText("<span style=' font-size:14pt; font-weight:600; color:#00ff00'>ON</span>");
}
else
{
m_ui->Pump_status2->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>OFF</span>");
}
if(Valve_state1 == 1)
{
m_ui->Valve_status1->setText("<span style=' font-size:14pt; font-weight:600; color:#00ff00'>OPEN</span>");
}
else
{
m_ui->Valve_status1->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>CLOSED</span>");
}
if(Valve_state2 == 1)
{
m_ui->Valve_status2->setText("<span style=' font-size:14pt; font-weight:600; color:#00ff00'>OPEN</span>");
}
else
{
m_ui->Valve_status2->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>CLOSED</span>");
}
if(Valve_state3 == 1)
{
m_ui->Valve_status3->setText("<span style=' font-size:14pt; font-weight:600; color:#00ff00'>OPEN</span>");
}
else
{
m_ui->Valve_status3->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>CLOSED</span>");
}
if(Valve_state4 == 1)
{
m_ui->Valve_status4->setText("<span style=' font-size:14pt; font-weight:600; color:#00ff00'>OPEN</span>");
}
else
{
m_ui->Valve_status4->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>CLOSED</span>");
}
}
void MainWindow::checkWarnings()
{
if(av_fuel <= 70)
{
m_ui->fuel_status_ind->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>LO FUEL</span>");
redLight_1 = 1;
}
else
{
m_ui->fuel_status_ind->setText("<span style=' font-size:14pt; font-weight:600; color:#00ff00'>NORMAL</span>");
redLight_1 = 0;
}
if(pres1 <= 20 && pres1 >= 12)
{
m_ui->P1_status_ind->setText("<span style=' font-size:14pt; font-weight:600; color:#00ff00'>NORMAL</span>");
redLight_4 = 0;
}
else if(pres1 > 20)
{
m_ui->P1_status_ind->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>HI PR</span>");
redLight_4 = 1;
}
else
{
m_ui->P1_status_ind->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>LO PR</span>");
redLight_4 = 1;
}
if(pres2 <= 20 && pres2 >= 12)
{
m_ui->P2_status_ind->setText("<span style=' font-size:14pt; font-weight:600; color:#00ff00'>NORMAL</span>");
redLight_5 = 0;
}
else if(pres2 > 20)
{
m_ui->P2_status_ind->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>HI PR</span>");
redLight_5 = 1;
}
else
{
m_ui->P2_status_ind->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>LO PR</span>");
redLight_5 = 1;
}
if(pres3 <= 20 && pres3 >= 12)
{
m_ui->P3_status_ind->setText("<span style=' font-size:14pt; font-weight:600; color:#00ff00'>NORMAL</span>");
redLight_2 = 0;
}
else if(pres3 > 20)
{
m_ui->P3_status_ind->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>HI PR</span>");
redLight_2 = 1;
}
else
{
m_ui->P3_status_ind->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>LO PR</span>");
redLight_2 = 1;
}
if(EnPres <= 40 && EnPres >= 20)
{
m_ui->P4_status_ind->setText("<span style=' font-size:14pt; font-weight:600; color:#00ff00'>NORMAL</span>");
redLight_3 = 0;
}
else if(EnPres > 20)
{
m_ui->P4_status_ind->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>HI PR</span>");
redLight_3 = 1;
}
else
{
m_ui->P4_status_ind->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>LO PR</span>");
redLight_3 = 1;
}
if(temp <= 50 && temp >= 0)
{
m_ui->temp_status_ind->setText("<span style=' font-size:14pt; font-weight:600; color:#00ff00'>NORMAL</span>");
redLight_6 = 0;
}
else if(temp > 50)
{
m_ui->temp_status_ind->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>HI TEMP</span>");
redLight_6 = 1;
}
else
{
m_ui->temp_status_ind->setText("<span style=' font-size:14pt; font-weight:600; color:#ff0000'>LO TEMP</span>");
redLight_6 = 1;
}
}
void MainWindow::on_Retrybutton_clicked()
{
emit retrySignal();
}
| [
"metal.striker.xlr@gmail.com"
] | metal.striker.xlr@gmail.com |
b2c47231fb28a42dd9c2f4e636cde531d200bb39 | df0dc0fcdcc4d0b62d8d3b596415870d06975972 | /Programacion 2017 - 2018/Programacion 2017/Final Verano/Estudio Final Prog/Drive/C++(la consigna es correr el main)/clase libro/libro/libro.h | f4ef3126f262b7ad8124793303d1ea5e42c7098d | [] | no_license | diego-rico-dk/Programacion-Unlam | 169f1be80ce18eb210f3773515522381b31ae125 | 30cc0781a3f65fd1f5026180055da1ca41dc4ee8 | refs/heads/master | 2022-01-08T21:31:11.371443 | 2019-04-11T03:46:20 | 2019-04-11T03:46:20 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 499 | h | #ifndef LIBRO_H_INCLUDED
#define LIBRO_H_INCLUDED
#include <iostream>
#include <string.h>
using namespace std;
class Libro
{
private:
char nombre[60];
char autor[50];
int paginas;
public:
Libro(char* nom="El libro de Cosme Fulanito",char* au="Cosme Fulanito" ,int pag=1000);
Libro operator+(const Libro&)const;
bool operator==(const Libro&)const;
friend ostream& operator<<(ostream& out,Libro& libro);
};
#endif // LIBRO_H_INCLUDED
| [
"tocinonaro_juan@yahoo.com.ar"
] | tocinonaro_juan@yahoo.com.ar |
ce8458093056b79223184a041a461b9011c71c30 | eb70adcfcc30ac8301341ccf72ec146de41a1665 | /src/commonjobadder.h | 567c1eb71cbc669ca8278cabef06ad5675586228 | [] | no_license | Beliaf/leechcraft | ff2166070913f2d7ee480f40542ccdf148e49cad | 0823a7d8f85d11bed0b81e61ddb3bf329f9d5d39 | refs/heads/master | 2021-01-18T11:00:38.531356 | 2009-06-14T22:44:13 | 2009-06-14T22:44:13 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 481 | h | #ifndef COMMONJOBADDER_H
#define COMMONJOBADDER_H
#include <QDialog>
#include "ui_commonjobadder.h"
namespace LeechCraft
{
class CommonJobAdder : public QDialog,
private Ui::CommonJobAdder
{
Q_OBJECT
public:
CommonJobAdder (QWidget *parent = 0);
virtual ~CommonJobAdder ();
QString GetString () const;
QString GetWhere () const;
private slots:
void on_Browse__released ();
void on_BrowseWhere__released ();
void on_Paste__released ();
};
};
#endif
| [
"0xd34df00d@gmail.com"
] | 0xd34df00d@gmail.com |
6fc82d0557142d5c3bb018cede07d41c0d0c526d | b776ec3da034afa276356667c1b3a3de17aeb3bd | /Game/Source/Physics2D/Box2DManager.cpp | fe288df248ad86f81c04962547442d2637d9c398 | [] | no_license | zrcoy/Ewe | b25865071be738be1ec788f5445bb370d59c825b | 5359a699884ea8915730ddb11e644e05e06f48e1 | refs/heads/master | 2020-04-27T09:04:37.378059 | 2019-03-06T18:56:11 | 2019-03-06T18:56:11 | 174,199,795 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 493 | cpp | #include "GamePCH.h"
#include "Box2DManager.h"
#include "Box2DContactListener.h"
#include "../../Libraries/Box2D/Box2D/Box2D.h"
Box2DManager::Box2DManager()
{
m_pWorld = new b2World( b2Vec2( 0, -10 ) );
m_pContactListener = new Box2DContactListener();
m_pWorld->SetContactListener( m_pContactListener );
}
Box2DManager::~Box2DManager()
{
delete m_pContactListener;
delete m_pWorld;
}
void Box2DManager::Update(float deltatime)
{
m_pWorld->Step( 1/60.0f, 3, 8 );
}
| [
"zhan0472@algonquinlive.com"
] | zhan0472@algonquinlive.com |
960e7e2a1d2b61a7bb4282f33b27ff43f961b6d0 | 935fa4f586f4990b506a693dff8945d2b7f9c677 | /afl/net/http/chunkedsink.hpp | 25cee37d8e30f6b88fff2d338e8bafcb8602da5d | [] | no_license | stefanreuther/afl | 8e96be19a502463cdb72b42b6042cdd6869ecf0b | 35d2eb7c6be1a3aebfdf1ce046e6e1310dc7caf8 | refs/heads/master | 2023-07-20T11:12:27.849160 | 2023-05-07T11:03:03 | 2023-05-07T11:03:03 | 69,809,604 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,313 | hpp | /**
* \file afl/net/http/chunkedsink.hpp
* \brief Class afl::net::http::ChunkedSink
*/
#ifndef AFL_AFL_NET_HTTP_CHUNKEDSINK_HPP
#define AFL_AFL_NET_HTTP_CHUNKEDSINK_HPP
#include <memory>
#include "afl/io/datasink.hpp"
#include "afl/io/stream.hpp"
#include "afl/base/uncopyable.hpp"
namespace afl { namespace net { namespace http {
/** HTTP "chunked" encoding decoder.
Decodes a chunked body and gives the decoded data to another DataSink.
Grammar according to RFC 2616:
<pre>
Chunked-Body = *chunk
last-chunk
trailer
CRLF
chunk = chunk-size [ chunk-extension ] CRLF
chunk-data CRLF
chunk-size = 1*HEX
last-chunk = 1*("0") [ chunk-extension ] CRLF
chunk-extension= *( ";" chunk-ext-name [ "=" chunk-ext-val ] )
chunk-ext-name = token
chunk-ext-val = token | quoted-string
chunk-data = chunk-size(OCTET)
trailer = *(entity-header CRLF)
</pre>
chunk-extension and trailer are completely ignored. */
class ChunkedSink : public afl::io::DataSink, private afl::base::Uncopyable {
public:
/** Constructor.
\param peer Target sink that receives data. Lifetime must exceed that of the ChunkedSink. */
ChunkedSink(afl::io::DataSink& peer);
/** Destructor. */
virtual ~ChunkedSink();
// DataSink:
virtual bool handleData(afl::base::ConstBytes_t& data);
private:
enum State {
ChunkSize, // reading hex digits
Extension, // skipping to EOL
Payload, // reading payload
PayloadEnd, // reading the CRLF after the payload
Trailer, // reading the file trailer
TrailerHeader, // reading a header in the file trailer
Final // final state reached, not reading anymore
};
State m_state;
afl::io::DataSink& m_peer;
afl::io::Stream::FileSize_t m_size;
};
} } }
#endif
| [
"streu@gmx.de"
] | streu@gmx.de |
256669f37f053acf3cef320611f5cf6d94c17ec4 | 35e12426b8cd82a766a8ef4d6f14b7b6e5943dd4 | /simulation/humanvector.cpp | 2192b357b9e51688576158e94ad000a98631151c | [] | no_license | demarsis/Panic | 2bcd939907d885b913b6b4be7f6b386037749f94 | 3842655eb5bd51c894e138015362223ab0e60a9d | refs/heads/master | 2021-09-04T03:25:36.060507 | 2018-01-15T08:54:58 | 2018-01-15T08:54:58 | 115,006,990 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,017 | cpp | #include "humanvector.h"
Directions HumanVector::dirs = Directions(true);
Vector HumanVector::getIntentionVector(HumanPtr &human, FloorPtr &floor)
{
if (!human) return Vector();
if (!floor) return Vector();
std::vector<CellPtr> humanCells = getHumanCells(human, floor);
// get penalties for all directions
std::vector<std::pair<Vector, Penalty>> possibleVectors;
for (const Directions::DirVector &dirvect : dirs.getAllDirections())
{
Penalty pen = getCellsPenalty(floor, humanCells, dirvect.first);
possibleVectors.push_back(std::make_pair(dirvect.second * HUMAN_INTENTION_SPEED_COEFF, pen));
}
if (possibleVectors.empty()) return Vector();
// sort by min penalty
/* std::sort(possibleVectors.begin(), possibleVectors.end(),
[](const std::pair<Vector, Penalty> &left,
const std::pair<Vector, Penalty> &right) -> bool
{
return left.second < right.second;
}
);*/
// search min penalty
Penalty minPenalty = PENALTY_MAX;
for (const std::pair<Vector, Penalty> &pair : possibleVectors)
{
if (minPenalty > pair.second) minPenalty = pair.second;
}
// leave only mins
possibleVectors.erase(std::remove_if(possibleVectors.begin(), possibleVectors.end(),
[minPenalty](const std::pair<Vector, Penalty> &pair)
{
return pair.second > minPenalty;
}),
possibleVectors.end()
);
int rnd = Probability::instance().random(possibleVectors.size());
Vector &result = possibleVectors[rnd].first;
// use speed coeff
result *= human->getSpeedCoeff();
return result;
}
std::vector<CellPtr> HumanVector::getHumanCells(HumanPtr &human, FloorPtr &floor)
{
std::vector<CellPtr> result;
if (!human) return result;
if (!floor) return result;
Position center(human->getPosition().x, human->getPosition().y);
int radius = human->getDiameter() / 2;
Position lefttop(center.x - radius, center.y - radius);
Position rightbottom(center.x + radius, center.y + radius);
for (int x = lefttop.x; x <= rightbottom.x; x++)
{
for (int y = lefttop.y; y <= rightbottom.y; y++)
{
float currentRadius = (x - center.x) * (x - center.x) + (y - center.y) * (y - center.y);
if (currentRadius > radius * radius) continue;
if (!floor->isValidPosition(Position(x, y))) continue;
CellPtr cell = floor->getCell(x, y);
if (cell)
{
result.push_back(cell);
}
}
}
return result;
}
Penalty HumanVector::getCellsPenalty(FloorPtr &floor, const std::vector<CellPtr> &cells, const Position &offset)
{
if (!floor) return PENALTY_ZERO;
Penalty result = 0;
for (const CellPtr &cell : cells)
{
Position pos = cell->getPosition();
pos.x += offset.x;
pos.y += offset.y;
if (!floor->isValidPosition(pos))
{
result += PENALTY_MAX;
continue;
}
CellPtr &offsetedCell = floor->getCell(pos);
if (!offsetedCell)
{
result += PENALTY_MAX;
continue;
}
result += offsetedCell->getAdditionalData().wayPenalty;
}
return result;
}
bool HumanVector::isNewPositionIntersectedWithOther(const HumanPtr &human, const Vector &vec, const HumanPtr &other)
{
// get new position
PositionF pos = human->getPosition();
pos.x += vec.getX();
pos.y += vec.getY();
// other's position
const PositionF &othersPosition = other->getPosition();
// check with others
float squaredLength = (pos.x - othersPosition.x) * (pos.x - othersPosition.x) +
(pos.y - othersPosition.y) * (pos.y - othersPosition.y);
float squaredDiameter = human->getDiameter() / 2 + other->getDiameter() / 2;
squaredDiameter *= squaredDiameter;
// check
if (squaredLength < squaredDiameter) return true;
return false;
}
Vector HumanVector::getPushesVector(const HumanPtr &human, const HumanPtr &other)
{
const PositionF &humanPosition = human->getPosition();
const PositionF &otherPosition = other->getPosition();
float length = sqrt((humanPosition.x - otherPosition.x) * (humanPosition.x - otherPosition.x) +
(humanPosition.y - otherPosition.y) * (humanPosition.y - otherPosition.y));
float radiuses = human->getDiameter() / 2 + other->getDiameter() / 2;
float diff = radiuses - length;
float k = diff / length;
k /= 2;
k *= HUMAN_PUSH_COEFF;
float cx = (humanPosition.x - otherPosition.x) * k;
float cy = (humanPosition.y - otherPosition.y) * k;
return Vector(cx, cy);
}
| [
"demarsis@mail.ru"
] | demarsis@mail.ru |
cf0ccf0b71eac960ab2777326233c7c1d141cd99 | 7849554c268311afab49d919d68a0deed784c221 | /src/SimulatorApp/org.alljoyn.Notification.Dismisser/pch.h | e985839c4b8302432edad8dc6d8723c6cf32334f | [
"MIT"
] | permissive | dotMorten/AllJoynDeviceSimulator | aa30a73e188c738daa7ba5cc143e7af72c65d005 | b5a7e7198983c0aad02f78d1868a083940f7c57f | refs/heads/master | 2020-12-29T00:30:27.844468 | 2016-08-16T04:13:28 | 2016-08-16T04:13:28 | 49,626,641 | 8 | 5 | null | 2016-08-08T19:45:35 | 2016-01-14T06:08:58 | C++ | UTF-8 | C++ | false | false | 1,804 | h |
//-----------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
//
// Tool: AllJoynCodeGenerator.exe
//
// This tool is located in the Windows 10 SDK and the Windows 10 AllJoyn
// Visual Studio Extension in the Visual Studio Gallery.
//
// The generated code should be packaged in a Windows 10 C++/CX Runtime
// Component which can be consumed in any UWP-supported language using
// APIs that are available in Windows.Devices.AllJoyn.
//
// Using AllJoynCodeGenerator - Invoke the following command with a valid
// Introspection XML file and a writable output directory:
// AllJoynCodeGenerator -i <INPUT XML FILE> -o <OUTPUT DIRECTORY>
// </auto-generated>
//-----------------------------------------------------------------------------
#pragma once
#include <windows.h>
#include <ppltasks.h>
#include <concrt.h>
#include <collection.h>
#include <windows.devices.alljoyn.interop.h>
#include <map>
#include <alljoyn_c/busattachment.h>
#include <alljoyn_c/dbusstddefines.h>
#include <alljoyn_c/AboutData.h>
#include <alljoyn_c/AboutObj.h>
#include <alljoyn_c/AboutObjectDescription.h>
#include "AllJoynHelpers.h"
#include "AllJoynBusObjectManager.h"
#define PROJECT_NAMESPACE org::alljoyn::Notification::Dismisser
#include "DismisserStructures.h"
#include "TypeConversionHelpers.h"
#include "DismisserMethodResults.h"
#include "DismisserEventArgs.h"
#include "IDismisserService.h"
#include "DismisserSignals.h"
#include "DismisserProducer.h"
#include "DismisserWatcher.h"
#include "DismisserConsumer.h"
#include "DismisserServiceEventArgs.h"
#include "DismisserServiceEventAdapter.h" | [
"mnielsen@esri.com"
] | mnielsen@esri.com |
0353e56c6f3e5e79c85bce1a90f43ea0507bd976 | 154ad9b7b26b5c52536bbd83cdaf0a359e6125c3 | /components/sync/js/js_event_handler.h | ec5a3e908040343f066a968b804ccbc79fa6b662 | [
"BSD-3-Clause"
] | permissive | bopopescu/jstrace | 6cc239d57e3a954295b67fa6b8875aabeb64f3e2 | 2069a7b0a2e507a07cd9aacec4d9290a3178b815 | refs/heads/master | 2021-06-14T09:08:34.738245 | 2017-05-03T23:17:06 | 2017-05-03T23:17:06 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 771 | h | // Copyright 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMPONENTS_SYNC_JS_JS_EVENT_HANDLER_H_
#define COMPONENTS_SYNC_JS_JS_EVENT_HANDLER_H_
// See README.js for design comments.
#include <string>
#include "components/sync/base/sync_export.h"
namespace syncer {
class JsEventDetails;
// An interface for objects that handle Javascript events (e.g.,
// WebUIs).
class SYNC_EXPORT JsEventHandler {
public:
virtual void HandleJsEvent(const std::string& name,
const JsEventDetails& details) = 0;
protected:
virtual ~JsEventHandler() {}
};
} // namespace syncer
#endif // COMPONENTS_SYNC_JS_JS_EVENT_HANDLER_H_
| [
"zzbthechaos@gmail.com"
] | zzbthechaos@gmail.com |
e61bb471f7ef658faa5442de5174bcd167223153 | 560cd3685da109fd6f08dd1264a002d5c2f60e8b | /3DGameEngine/CoreEngine.h | c0118cd6c2154f9cc58590058904f1148543ee43 | [] | no_license | Lars-Haakon/3DOpenGLEngine | 709f6e56f2ef5da0769f3d9bd5ee62ae815e1615 | 72b70f599af87ee1df0385885efcf719ce995902 | refs/heads/master | 2021-05-29T13:33:07.875964 | 2015-02-01T16:02:48 | 2015-02-01T16:02:48 | 30,045,734 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 304 | h | #ifndef COREENGINE_H
#define COREENGINE_H
#include "Window.h"
#include "TestGame.h"
#include <Windows.h>
class CoreEngine
{
public:
double FPS;
CoreEngine(Window *window);
~CoreEngine();
void run(HDC &hdc);
private:
void glInit();
void setProjection(int w, int h);
TestGame *game;
};
#endif | [
"lars-haakon@hotmail.com"
] | lars-haakon@hotmail.com |
8a19e680a087933748ea5095485f9a8fb18cd0d2 | 0ff6579660ccf6d912bf613f58fab80abcfae87f | /main.cpp | eb7f56a34c59eadaf499753b35d423f2c726825a | [] | no_license | karolinneoc/ElRefPattern | e680e907e5be484fbfa81d69d8fccb0a00ad1db5 | 2c84e4cfe5b34441e9b3f77a7f3404e2cc0d8b37 | refs/heads/master | 2020-08-04T16:41:30.047768 | 2019-10-11T14:03:16 | 2019-10-11T14:03:16 | 212,206,432 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,405 | cpp | #include "mkl.h"
#include "pzmatrix.h"
#include "TPZPardisoControl.h"
#include "pzcmesh.h"
#include "pzgengrid.h"
#include "TPZMatLaplacian.h"
#include "pzbndcond.h"
#include "pzanalysis.h"
#include "TPZVTKGeoMesh.h"
#include "pzgnode.h"
#include "TPZRefPattern.h"
#include "TPZRefPatternTools.h"
#include "TPZGeoElRefPattern.h"
#include "pzgmesh.h"
enum MMATID {EGroup, Ebc1, Ebc2, Ebc3, Ebc4, Emat1};
int main(){
MElementType element = EQuadrilateral;
bool solve = true;
bool RefinementPattern = false;
int porder = 1;
if(element == EQuadrilateral){
TPZGeoMesh *gmesh = new TPZGeoMesh();
gmesh->NodeVec().Resize(6);
for (int i=0; i<6; i++) {
TPZManVector<REAL,4> x(3,0);
if (i>2) {
x[1]=1;
}
if (i==1 || i==4){
x[0]=1;
} else if (i==2 || i==5){
x[0]=2;
}
TPZGeoNode node;
node.Initialize(x, *gmesh);
gmesh->NodeVec()[i] = node;
// gmesh->NodeVec()[i].SetCoord(i,x);
// gmesh->NodeVec()[i].SetNodeId(i);
}
TPZVec<int64_t> cornerindexes(4,0);
cornerindexes[0]=0;cornerindexes[1]=1;cornerindexes[2]=4;cornerindexes[3]=3;
int64_t index = 0;
TPZGeoEl *gel = gmesh->CreateGeoElement(EQuadrilateral, cornerindexes, EGroup, index);
cornerindexes[0]=1;cornerindexes[1]=2;cornerindexes[2]=5;cornerindexes[3]=4;
index=1;
gel = gmesh->CreateGeoElement(EQuadrilateral, cornerindexes, EGroup, index);
gmesh->BuildConnectivity();
TPZVec<TPZGeoEl *> subel;
gmesh->Element(0)->Divide(subel);
gmesh->BuildConnectivity();
gmesh->Print();
std::ofstream out("Geometry.vtk");
TPZVTKGeoMesh vtk;
vtk.PrintGMeshVTK(gmesh, out, true);
if(RefinementPattern){
TPZGeoMesh *gmesh2 = new TPZGeoMesh(*gmesh);
gmesh2->BuildConnectivity();
int nnodes = gmesh->NNodes();
gmesh->NodeVec().Resize(nnodes +2);
TPZVec<REAL> x(3,0);
x[0]=-0.5;x[1]=-1;
gmesh->NodeVec()[nnodes].Initialize(nnodes, x, *gmesh);
x[0]=0.9;x[1]=1;
gmesh->NodeVec()[nnodes+1].Initialize(nnodes+1, x, *gmesh);
cornerindexes[0]=0;cornerindexes[1]=1;cornerindexes[2]=4;cornerindexes[3]=5;
index = 1;
gmesh->CreateGeoElement(EQuadrilateral, cornerindexes, EGroup, index);
cornerindexes[0]=1;cornerindexes[1]=2;cornerindexes[2]=3;cornerindexes[3]=4;
index = 2;
gmesh->CreateGeoElement(EQuadrilateral, cornerindexes, EGroup, index);
gmesh->Element(1)->SetFather(gmesh->Element(0));
gmesh->Element(2)->SetFather(gmesh->Element(0));
gmesh->BuildConnectivity();
gmesh->Print(std::cout);
std::ofstream out("Geometry.vtk");
TPZVTKGeoMesh vtk;
vtk.PrintGMeshVTK(gmesh, out, true);
TPZRefPattern *ref = new TPZRefPattern(*gmesh);
ref->SetName("Karol");
TPZAutoPointer<TPZRefPattern> autoref(ref);
gRefDBase.InsertRefPattern(autoref);
autoref->InsertPermuted();
auto karol = gRefDBase.FindRefPattern("Karol");
TPZVec<TPZGeoEl *> gelvec;
// gmesh2->Element(0)->SetRefPattern(karol);
gmesh2->Element(0)->Divide(gelvec);
gmesh2->Element(1)->SetRefPattern(karol);
gmesh2->Element(1)->Divide(gelvec);
std::ofstream out2("Geometry2.vtk");
TPZVTKGeoMesh vtk2;
vtk2.PrintGMeshVTK(gmesh2, out2, true);
for(int i=4;i<6;i++){
std::map<int, std::pair<TPZGeoEl *, std::map<int,int> > > neighCorresp;
TPZRefPatternTools::ModelRefPattern(gmesh2->Element(i),neighCorresp);
TPZAutoPointer<TPZRefPattern> ref = TPZRefPatternTools::DragModelPatNodes(gmesh2->Element(i), karol,neighCorresp);
gmesh2->Element(i)->SetRefPattern(ref);
// gmesh2->Element(1)->SetRefPattern();
gmesh2->Element(i)->Divide(gelvec);
std::ofstream out2("Geometry2.vtk");
TPZVTKGeoMesh vtk2;
vtk2.PrintGMeshVTK(gmesh2, out2, true);
}
// for(int i=0;i<600;i++){
// gmesh2->Element(i)->SetRefPattern(karol);
// gmesh2->Element(i)->Divide(gelvec);
// }
std::cout << gmesh2->NElements() << std::endl;
std::ofstream out3("Geometry3.vtk");
TPZVTKGeoMesh vtk3;
vtk3.PrintGMeshVTK(gmesh2, out3, true);
}
if(solve){
gmesh->Element(0)->CreateBCGeoEl(4, -Ebc1);
gmesh->Element(0)->CreateBCGeoEl(6, -Ebc1);
gmesh->Element(0)->CreateBCGeoEl(7, -Ebc1);
gmesh->Element(1)->CreateBCGeoEl(4, -Ebc1);
gmesh->Element(1)->CreateBCGeoEl(5, -Ebc1);
gmesh->Element(1)->CreateBCGeoEl(6, -Ebc1);
TPZCompMesh *cmesh = new TPZCompMesh(gmesh);
cmesh->SetDefaultOrder(porder);
cmesh->SetDimModel(2);
TPZMatLaplacian *matloc = new TPZMatLaplacian(EGroup);
matloc->SetDimension(2);
matloc->SetSymmetric();
TPZMaterial *material;
material = matloc;
int nstate = 1;
TPZFMatrix<STATE> val1(nstate,nstate,0.), val2(nstate,1,0.);
TPZMaterial * BCond1 = material->CreateBC(material,-Ebc1,0, val1, val2);
cmesh->InsertMaterialObject(material);
cmesh->InsertMaterialObject(BCond1);
// cmesh->SetAllCreateFunctionsContinuous();
cmesh->SetAllCreateFunctionsHDiv();
cmesh->AutoBuild();
std::ofstream file("cmeshhdiv.dat");
cmesh->Print(file);
TPZAnalysis * Analysis = new TPZAnalysis(cmesh,true);
Analysis->Run();
TPZFMatrix<REAL> sol = Analysis->Solution();
bool plotshape = true;
if(plotshape)
{
TPZFMatrix<REAL> sol0 = sol;
for (int i=0; i<sol0.Rows() ;i++){
TPZFNMatrix<3,REAL> sol = cmesh->Solution();
sol.Zero();
sol(i,0) = 1;
cmesh->LoadSolution(sol);
Analysis->LoadSolution(sol);
TPZStack<std::string> vecnames,scalnames;
// scalar
scalnames.Push("State");
Analysis->DefineGraphMesh(2, scalnames, vecnames, "../ShapeFunctions.vtk");
Analysis->PostProcess(3);
}
cmesh->LoadSolution(sol0);
Analysis->LoadSolution(sol0);
}
}
} else if (element == ETriangle){
TPZManVector<REAL,4> x0(3,-1.),x1(3,1.),x2(3,1.);
x0[0] = 0;
x0[1] = 0;
x0[2] = 0;
x1[0] = 1;
x1[1] = 0;
x1[2] = 0;
x2[0] = 0;
x2[1] = 1;
x2[2] = 0;
TPZGeoMesh *gmesh = new TPZGeoMesh();
gmesh->NodeVec().Resize(3);
gmesh->NodeVec()[0].SetCoord(x0);
gmesh->NodeVec()[1].SetCoord(x1);
gmesh->NodeVec()[2].SetCoord(x2);
gmesh->NodeVec()[0].SetNodeId(0);
gmesh->NodeVec()[1].SetNodeId(1);
gmesh->NodeVec()[2].SetNodeId(2);
TPZVec<int64_t> cornerindexes(3,0);
cornerindexes[0]=0;cornerindexes[1]=1;cornerindexes[2]=2;
int64_t index = 0;
gmesh->CreateGeoElement(ETriangle, cornerindexes, EGroup, index);
gmesh->BuildConnectivity();
gmesh->Element(0)->CreateBCGeoEl(3, -Ebc1);
gmesh->Element(0)->CreateBCGeoEl(4, -Ebc2);
gmesh->Element(0)->CreateBCGeoEl(5, -Ebc3);
std::ofstream out("Geometry.vtk");
TPZVTKGeoMesh vtk;
vtk.PrintGMeshVTK(gmesh, out, true);
TPZCompMesh *cmesh = new TPZCompMesh(gmesh);
cmesh->SetDefaultOrder(porder);
TPZMatLaplacian *matloc = new TPZMatLaplacian(EGroup);
matloc->SetDimension(2);
matloc->SetSymmetric();
TPZMaterial *material;
material = matloc;
int nstate = 1;
TPZFMatrix<STATE> val1(nstate,nstate,0.), val2(nstate,1,0.);
TPZMaterial * BCond1 = material->CreateBC(material,-Ebc1,0, val1, val2);
TPZMaterial * BCond2 = material->CreateBC(material,-Ebc2,0, val1, val2);
TPZMaterial * BCond3 = material->CreateBC(material,-Ebc3,0, val1, val2);
cmesh->InsertMaterialObject(material);
cmesh->InsertMaterialObject(BCond1);
cmesh->InsertMaterialObject(BCond2);
cmesh->InsertMaterialObject(BCond3);
cmesh->SetAllCreateFunctionsContinuous();
cmesh->AutoBuild();
TPZAnalysis * Analysis = new TPZAnalysis(cmesh,true);
Analysis->Run();
TPZFMatrix<REAL> sol = Analysis->Solution();
bool plotshape = true;
if(plotshape)
{
TPZFMatrix<REAL> sol0 = sol;
for (int i=0; i<sol0.Rows() ;i++){
TPZFNMatrix<3,REAL> sol = cmesh->Solution();
sol.Zero();
sol(i,0) = 1;
cmesh->LoadSolution(sol);
Analysis->LoadSolution(sol);
TPZStack<std::string> vecnames,scalnames;
// scalar
scalnames.Push("State");
Analysis->DefineGraphMesh(2, scalnames, vecnames, "../ShapeFunctions.vtk");
Analysis->PostProcess(3);
}
cmesh->LoadSolution(sol0);
Analysis->LoadSolution(sol0);
}
}
return 0;
}
| [
"30835631+karolinneoc@users.noreply.github.com"
] | 30835631+karolinneoc@users.noreply.github.com |
00b5eb6d4357f4a5db91da1798c3909fb5d8c994 | d3e1f9a07e09953ac689c74ad1f7f1ada982dd77 | /SDK/IStoreProduct_functions.cpp | 40640124ba833e9829fc2e0a56493218f9d472ee | [] | no_license | xnf4o/HSH_SURVIVE_SDK | 5857159731ceda7c06e158711003fbaf22021842 | 2f49c97a5f14b4eadf7dc3387b55c09bc968da66 | refs/heads/main | 2023-04-12T06:52:47.854249 | 2021-04-27T03:13:24 | 2021-04-27T03:13:24 | 361,965,544 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,296 | cpp | // Name: hsh, Version: 2
#include "../pch.h"
/*!!DEFINE!!*/
/*!!HELPER_DEF!!*/
/*!!HELPER_INC!!*/
#ifdef _MSC_VER
#pragma pack(push, 0x01)
#endif
namespace CG
{
//---------------------------------------------------------------------------
// Functions
//---------------------------------------------------------------------------
// Function IStoreProduct.IStoreProduct_C.ShowSoldOut
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool bIsShow (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor)
void UIStoreProduct_C::ShowSoldOut(bool bIsShow)
{
static auto fn = nullptr;
if (!fn)
fn =
UObject::FindObject<UFunction>("Function IStoreProduct.IStoreProduct_C.ShowSoldOut");
UIStoreProduct_C_ShowSoldOut_Params params;
params.bIsShow = bIsShow;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function IStoreProduct.IStoreProduct_C.RefreshProduct
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FS_StoreProduct Product (BlueprintVisible, BlueprintReadOnly, Parm, HasGetValueTypeHash)
// struct FSlateBrush ImageBG (BlueprintVisible, BlueprintReadOnly, Parm)
// struct FVector2D ImageSize (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// struct FVector2D ImagePosition (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool bShowTooltip (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor)
// struct FDateTime EndDate (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// TEnumAsByte<E_GameCurrency_E_GameCurrency> Currency (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// TEnumAsByte<E_StoreType_E_StoreType> StoreType (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
void UIStoreProduct_C::RefreshProduct(const struct FS_StoreProduct& Product, const struct FSlateBrush& ImageBG, const struct FVector2D& ImageSize, const struct FVector2D& ImagePosition, bool bShowTooltip, const struct FDateTime& EndDate, TEnumAsByte<E_GameCurrency_E_GameCurrency> Currency, TEnumAsByte<E_StoreType_E_StoreType> StoreType)
{
static auto fn = nullptr;
if (!fn)
fn =
UObject::FindObject<UFunction>("Function IStoreProduct.IStoreProduct_C.RefreshProduct");
UIStoreProduct_C_RefreshProduct_Params params;
params.Product = Product;
params.ImageBG = ImageBG;
params.ImageSize = ImageSize;
params.ImagePosition = ImagePosition;
params.bShowTooltip = bShowTooltip;
params.EndDate = EndDate;
params.Currency = Currency;
params.StoreType = StoreType;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"xnf4o@inbox.ru"
] | xnf4o@inbox.ru |
d7969f24ab4766c0033ea724f765f3afb03f386c | 61223eee05ad0179788931e35f4db59a896a2bd0 | /lib/bbq/NTCSensor.cpp | 997ba1e9c1b0adfc24ff468757ea98cadda04da5 | [
"MIT"
] | permissive | rvt/bbq-controller | 60155717c0ec33b327d74203f14e6ed6ffcc0ae0 | a70f13dfc1c53dc6416fff2fa4ef9e393884dab5 | refs/heads/master | 2022-05-01T23:14:02.520911 | 2022-04-10T18:32:13 | 2022-04-10T18:32:13 | 164,915,821 | 24 | 3 | MIT | 2020-08-19T18:45:53 | 2019-01-09T18:25:35 | C++ | UTF-8 | C++ | false | false | 3,833 | cpp | #include "NTCSensor.h"
#include <math.h>
#ifndef UNIT_TEST
#include <Arduino.h>
#else
extern "C" uint32_t analogRead(uint8_t);
#define INPUT_PULLUP 2
#define A0 0xa0
#endif
constexpr float ZERO_KELVIN = -273.15f;
NTCSensor::NTCSensor(int8_t p_pin, int16_t p_offset, float p_r1, float p_ka, float p_kb, float p_kc) :
NTCSensor(p_pin, false, p_offset, 0.1f, p_r1, p_ka, p_kb, p_kc) {
}
NTCSensor::NTCSensor(int8_t p_pin, bool p_upDownStream, int16_t p_offset, float p_alpha, float p_r1, float p_ka, float p_kb, float p_kc) :
TemperatureSensor(),
m_pin(p_pin),
m_upDownStream(p_upDownStream),
m_offset(p_offset),
m_alpha(p_alpha),
m_r1(p_r1),
m_ka(p_ka),
m_kb(p_kb),
m_kc(p_kc),
m_lastTemp(0.0f),
m_recover(0),
m_state(READY) {
#if defined(ESP32)
analogReadResolution(12);
// These two do not work, possible because we take to much time between start and end??
// analogSetSamples(4);
// analogSetClockDiv(1);
// End
analogSetPinAttenuation(m_pin, ADC_11db); // ADC_11db to measure 0--3.3V
adcAttachPin(m_pin);
#elif defined(ESP8266)
#endif
}
float NTCSensor::get() const {
return m_lastTemp;
}
// Calculations based on https://create.arduino.cc/projecthub/iasonas-christoulakis/make-an-arduino-temperature-sensor-thermistor-tutorial-b26ed3
// With an additional filter
#if defined(ESP32)
void NTCSensor::handle() {
switch (m_state) {
case READY:
adcStart(m_pin);
m_state = BUZY;
m_recover = 0;
break;
case BUZY:
if (!adcBusy(m_pin)) {
m_state = DONE;
} else if (++m_recover == 255) {
m_state = READY;
}
break;
case DONE:
// TODO: SEE https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/peripherals/adc.html
// Iw possible we can read the internal calibration of the reference voltage
m_state = READY;
float R2;
if (m_upDownStream) {
R2 = m_r1 * (4095.0f / (adcEnd(m_pin) + m_offset) - 1.0f);
} else {
R2 = m_r1 / (4095.0f / (adcEnd(m_pin) + m_offset) - 1.0f);
}
float logR2 = log(R2);
float degreesC = m_ka + m_kb * logR2 + m_kc * logR2 * logR2 * logR2;
degreesC = 1.0f / degreesC + ZERO_KELVIN;
// T = (T * 9.0f) / 5.0f + 32.0f;
// float farenheit = ((degreesC * 9) / 5) + 32.
// Filter
m_lastTemp = m_lastTemp + (degreesC - m_lastTemp) * m_alpha;
break;
}
}
#elif defined(ESP8266)
// This portion of code was not tested on ESP2866
void NTCSensor::handle() {
float R2;
if (m_upDownStream) {
R2 = m_r1 * (1023.0f / (analogRead(A0) + m_offset) - 1.0f);
} else {
R2 = m_r1 / (1023.0f / (analogRead(A0) + m_offset) - 1.0f);
}
float logR2 = log(R2);
float degreesC = m_ka + m_kb * logR2 + m_kc * logR2 * logR2 * logR2;
degreesC = 1.0f / degreesC + ZERO_KELVIN;
// T = (T * 9.0f) / 5.0f + 32.0f;
// float farenheit = ((degreesC * 9) / 5) + 32.
// Filter
m_lastTemp = m_lastTemp + (degreesC - m_lastTemp) * m_alpha;
}
#endif
void NTCSensor::calculateSteinhart(float r, float r1, float t1, float r2, float t2, float r3, float t3, float& a, float& b, float& c) {
float l1 = log(r1);
float l2 = log(r2);
float l3 = log(r3);
float y1 = 1.0f / (t1 - ZERO_KELVIN);
float y2 = 1.0f / (t2 - ZERO_KELVIN);
float y3 = 1.0f / (t3 - ZERO_KELVIN);
float g2 = (y2 - y1) / (l2 - l1);
float g3 = (y3 - y1) / (l3 - l1);
c = (g3 - g2) / (l3 - l2) * 1.0f / (l1 + l2 + l3);
b = g2 - c * (l1 * l1 + l1 * l2 + l2 * l2);
a = y1 - (b + l1 * l1 * c) * l1;
}
| [
"github@rvt.dds.nl"
] | github@rvt.dds.nl |
1b23acc0c1c2541890b43a70340c04a0fbbfd523 | b42365c7502900abe47669cfce630e360cc9156b | /src/engine/3dsLoader.h | 6a03bbf641cb5e1284f7bd87c3d8d3726ae8a3e1 | [
"BSD-3-Clause"
] | permissive | ycaihua/arbarlith2 | 0686bacfad3414f04a4ce655ea0cad0bd754d53c | 820ffc8c3efcb636eb2c639487815fb9aabdc82e | refs/heads/master | 2020-12-07T02:34:25.117495 | 2010-08-25T03:38:21 | 2010-08-25T03:38:21 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,670 | h | /*
Author: Andrew Fox
E-Mail: mailto:foxostro@gmail.com
Copyright (c) 2007,2009 Game Creation Society
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 Game Creation Society 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 Game Creation Society ``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 Game Creation Society BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _3DSLOADER_H_
#define _3DSLOADER_H_
#include "ModelLoader.h"
namespace Engine {
/** 3DS model loader */
class _3dsLoader : public ModelLoader
{
private:
/**
Loads a model from file
@param fileName The file name of the model
*/
virtual AnimationController* loadFromFile(const string &fileName) const;
/** Attach material data to the model */
class Wrapper
{
private:
vector<Material> materials;
public:
Model model;
void addMaterial(const Material &material)
{
materials.push_back(material); // copy the material
}
Material& getMostRecentMaterial(void)
{
ASSERT(!materials.empty(), "no materials to get");
return materials[materials.size()-1];
}
Material& getMaterial(const string &materialName)
{
ASSERT(!materials.empty(), "no materials to get");
for(size_t i=0; i<materials.size(); ++i)
{
if(materialName == materials[i].getName())
return materials[i];
}
FAIL("failed to retrieve material: " + materialName);
return materials[0]; // return anything at all
}
};
/** structure for 3DS indices (since .3DS stores 4 unsigned shorts) */
struct Indices
{
/** This will hold point1, 2, and 3 index's into the vertex array plus a visible flag */
unsigned short a, b, c, bVisible;
};
/** Generic chunk */
class Chunk : public File
{
public:
/**
Constructs a chunk by reading it out of a parent chunk
@param parentChunk The parent chunk to read the chunk from
*/
Chunk(Chunk &parentChunk);
/**
Constructs a chunk by reading it out of a file
@param file The file to read the chunk from
*/
Chunk(File &file);
/**
Reads a string from file
@param file the file is assumed to be seek'd to the positon of the string
@param s returns the string that was read
@return the number of bytes read (including the null terminator)
*/
int getString(char *s);
/**
get the chunk ID
@return ID
*/
unsigned short int getID(void) const
{
return ID;
}
private:
/** The chunk's ID */
unsigned short int ID;
};
/**
Loads a single model from file
@param fileName File name of the 3DS model
@return Model
*/
Engine::Model loadKeyFrame(const string &fileName) const;
/**
Reads the next large chunk
@param parentChunk The parent chunk
@param wrapper the partially loaded model
*/
void processNextChunk(Chunk &parentChunk, Wrapper &wrapper) const;
/**
Processes the version data
@param file Assumes that the file is seek'd to the data section
@param currentChunk chunk data
*/
void processVersionChunk(Chunk ¤tChunk) const;
/**
Processes the object info data
@param currentChunk chunk data
@param wrapper the partially loaded model
*/
void processObjectInfoChunk(Chunk ¤tChunk, Wrapper &wrapper) const;
/**
Processes the object data
@param currentChunk chunk data
@param wrapper the partially loaded model
*/
void processObjectChunk(Chunk ¤tChunk, Wrapper &wrapper) const;
/**
Processes a material chunk
@param currentChunk chunk data
@param model the partially loaded model
*/
void processMaterialChunk(Chunk &parentChunk, Wrapper &wrapper) const;
/**
Reads the next object chunk
@param currentChunk the current chunk
@param wrapper the partially loaded model
@param mesh the next mesh allocated for the model
*/
void processNextObjectChunk(Chunk ¤tChunk, Wrapper &wrapper, Mesh *mesh) const;
/**
Reads the next material chunk
@param currentChunk chunk data
@param material partially loaded material
*/
void processNextMaterialChunk(Chunk ¤tChunk, Material &material) const;
/**
Reads the objects vertices
@param currentChunk Chunk data
@param mesh partially loaded mesh
*/
void readVertices(Chunk ¤tChunk, Mesh *mesh) const;
/**
Because 3D Studio Max Models with the Z-Axis pointing up, we
need to flip the y values with the z values in our vertices.
That way it will be normal, with Y pointing up.
@param mesh partially loaded mesh
*/
void fixVertices(Mesh *mesh) const;
/**
Truespace defaults to having the front view face the opposite direction on the Z-Axis
It is a lot easier to fix it here than to try to get an artist to fix the models...
@param mesh partially loaded mesh
*/
void fixTrueSpaceVertices(Engine::Model &model) const;
/**
Truespace defaults to having the front view face the opposite direction on the Z-Axis
It is a lot easier to fix it here than to try to get an artist to fix the models...
@param mesh partially loaded mesh
*/
void fixTrueSpaceVertices(Mesh *mesh) const;
/**
Removes and frees degenerate meshes within the model
@param mesh partially loaded mesh
*/
void cullDegenerateMeshes(Engine::Model &model) const;
/**
Generate surface normals for the loaded vertices and faces
@param mesh partially loaded mesh
*/
void generateNormals(Mesh *mesh) const;
/**
Reads the objects face information
@param currentChunk Chunk data
@param wrapper partially loaded mesh
*/
void readVertexIndices(Chunk ¤tChunk, Wrapper &wrapper, Mesh *mesh) const;
/**
Reads the texture coordinates of the object
@param currentChunk Chunk data
@param mesh partially loaded mesh
*/
void readUVCoordinates(Chunk ¤tChunk, Mesh *mesh) const;
/**
Reads in the material name assigned to the object and sets the materialID
@param currentChunk Chunk data
@param wrapper partially loaded model
@param mesh partially loaded mesh
*/
void readObjectMaterial(Chunk ¤tChunk, Wrapper &wrapper, Mesh *mesh) const;
/**
Reads the material name
@param currentChunk chunk data
@param material current material
*/
void readMaterialName(Chunk ¤tChunk, Material &material) const;
/**
Reads the material texture file
@param currentChunk chunk data
@param material current material
*/
void readMaterialMapFile(Chunk ¤tChunk, Material &material) const;
/**
Forces the skin to the specified value
@param model The model to alter
@param skinFileName The filename of the skin
*/
void forceSkin(Engine::Model &model, const string &skinFileName) const;
};
} // namespace Engine
#endif
| [
"foxostro@gmail.com"
] | foxostro@gmail.com |
89978454aa36a4889d169dbbe9b5c25ef5c3698d | b85325897c5803c7b928ef64db46bb55c2e04467 | /games/ChessGame.hpp | efebf81dc399be9250126c027104fa20ad54e804 | [
"Apache-2.0"
] | permissive | celrati/BoardFramework | 1b5e4c66f50ff5ee2bb09fd95a070a47b69be10c | 2325ffcaedf1e6b5104a3766bbc5a5281253a741 | refs/heads/master | 2020-08-22T11:37:59.604786 | 2019-10-20T15:51:53 | 2019-10-20T15:51:53 | 216,386,131 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 998 | hpp | #ifndef CHESS_GAME_HPP
#define CHESS_GAME_HPP
#include "../lib/ShortCutUtil.hpp"
#include "../Core/Game.hpp"
#include "boards/ChessBoard.hpp"
#include "../Core/Player.hpp"
#include "../pipe/InputReader.hpp"
#include "rules/ChessRule.hpp"
#include <vector>
#include <utility>
#include "../lib/Position.hpp"
class ChessGame : public Game{
private:
//state_game --
ChessBoard * chessBoard;
Player * player_1;
Player * player_2;
int turn_player;
InputReader<ChessBoard,ChessRule> * inputReader;
vector< pair< Position, Position> > moves_players_list;
public:
ChessGame(int mode); // 1 vs 2 or vs machine
virtual void gameStart();
virtual void gamePause();
virtual void gameStop();
virtual void gameOver();
virtual bool gameLoad();
virtual bool gameSave(string name_file);
virtual void gameRestart();
virtual void printBoard();
virtual void saveMove(char a, char b, char c, char d);
virtual char getMaxColumn();
virtual char getMaxRow();
static void launchGame();
};
#endif | [
"m.charif.achraf@gmail.com"
] | m.charif.achraf@gmail.com |
06307c3b6ac9392193252dda8158f0035b447c13 | 6f54db0c47de3c46f2d1fc87e430809768e17c81 | /p13 12用switch实现多分支选择结构/p13 12用switch实现多分支选择结构/p13 12用switch实现多分支选择结构.cpp | 21c94875f33e1e4e5f11933f72378f1c9f8004f0 | [] | no_license | loveyuan2019/Cplusplus | 6ed6115bb39aaa8e8cb20cb9e038c0d53a4b5842 | d2f5b7c06d3b434c90d420bb6d0edaff953ae5c2 | refs/heads/master | 2022-11-22T21:27:01.474687 | 2020-07-31T08:41:57 | 2020-07-31T08:41:57 | 283,985,428 | 1 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,479 | cpp | //2020-07-23 星期四 早晨 林业楼小平房
#include<iostream>
using namespace std;
int main(){
//需求1，输入0-6，输出对应的星期，六日输出周末。if语句来实现
int x = 0;
cout << "请输入数字" << endl;
cin >> x;
/*if (x == 1)
{
cout << "今天是星期一" << endl;
}
if (x == 2)
{
cout << "今天是星期二" << endl;
}
if (x == 3)
{
cout << "今天是星期三" << endl;
}
if (x == 4)
{
cout << "今天是星期四" << endl;
}
if (x == 5)
{
cout << "今天是星期五" << endl;
}
if (x == 5)
{
cout << "今天是星期五" << endl;
}
if (x == 6)
{
cout << "今天是星期六" << endl;
}
if (x == 0)
{
cout << "今天是星期日" << endl;
}*/
//需求2，输入0-6，输出对应的星期，六日输出周末。switch语句来实现,如果没有break,如果输入2，会显示星期二及以后的，有则跳出switch
switch (x)
{
case 0:
cout << "今天是星期日" << endl;
cout << "今天是星周末" << endl;
break;
case 1:
cout << "今天是星期一" << endl;
break;
case 2:
cout << "今天是星期二" << endl;
break;
case 3:
cout << "今天是星期三" << endl;
break;
case 4:
cout << "今天是星期四" << endl;
break;
case 5:
cout << "今天是星期五" << endl;
break;
case 6:
cout << "今天是星期六" << endl;
cout << "今天是星周末" << endl;
break;
default:
cout << "您输入的数字有误" << endl;
}
return 0;
} | [
"smywsmyw@163.com"
] | smywsmyw@163.com |
33c74aabf2479dc0f6f9449c043be342ada7736d | ef9e15db20a82b4d5e22caae4d7a5065a65cff27 | /CPP_99(입출력연산자오버로딩_OverLoading)/CPP_99/main.cpp | 57f5f9f38c7d11bf8702ddc78ce29c78749271e4 | [] | no_license | jinseongbe/cpp_study | 62a0b688a8f6b27f02449686a3a05dd053632f2f | 37be65a75eb33516a4b4434a05975ed61fce7194 | refs/heads/master | 2023-04-10T17:32:03.788508 | 2021-04-18T14:35:07 | 2021-04-18T14:35:07 | 354,449,067 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,596 | cpp | #include <iostream>
#include <fstream>
using namespace std;
class Point
{
private:
double m_x, m_y, m_z;
public:
Point(double x = 0.0, double y = 0.0, double z = 0.0)
: m_x(x), m_y(y), m_z(z)
{}
double getX() { return m_x; }
double getY() { return m_y; }
double getZ() { return m_z; }
void print()
{
cout << m_x << "\t" << m_y << "\t" << m_z << endl;
}
friend std::ostream &operator << (std::ostream &out, const Point &point) // MemberFunction이 아닌 Friend로 사용하는 이유
{ // => 첫번째 파라미터가 Point의 것이 아닌 std::ostream것이기 때문, 즉 첫번쨰 파라미터가 Class자신의 것이여야함!
out << "( " << point.m_x << "\t" << point.m_y << "\t" << point.m_z << " )";
return out;
}
friend std::istream &operator >> (std::istream &in, Point &point) // input이니까 const 쓰면 안되죠~
{
in >> point.m_x >> point.m_y >> point.m_z;
return in;
}
};
int main()
{
Point p1(0.0, 0.1, 0.2), p2(3.4, 1.5, 2.0);
p1.print();
p2.print();
cout << endl;
// 연산자 오버로딩
cout << p1 << endl << p2 << endl;
// file로 출력
ofstream of("out.txt");
of << p1 << endl << p2 << endl;
of.close(); // 알아서 닫고 나가지만 그래도 해주면 성실한 프로그래머!
Point P1, P2;
cin >> P1 >> P2;
cout << P1 << endl << P2;
return 0;
}
| [
"jinseongbe@google.com"
] | jinseongbe@google.com |
0a788e44cf69be301cf8c29dbf56274ba4aa2a56 | 9c92864c827e7e25bb2ccb773e2602d3bef7630e | /URI/URI 1136 - Bingo!.cpp | 81578843b44c38c6f3c30db668a472f4737c40e5 | [
"Unlicense"
] | permissive | pravgcet/competitive_programming | 25a0456c8a8457ef30ec97bc4fb75cffb94dccc1 | 17f27248ee843e424fcad9de3872b768113a7713 | refs/heads/master | 2021-01-21T03:49:28.384786 | 2014-06-23T16:08:40 | 2014-06-23T16:08:40 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 733 | cpp | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
bool canCallOutAll(const vector<int>& balls, int n) {
vector<bool> checked(n + 1, false);
checked[0] = true;
for(int i = 0; i < balls.size(); ++i)
for(int j = 0; j < i; ++j)
checked[balls[i] - balls[j]] = true;
for(int i = 0; i < n + 1; ++i)
if (!checked[i])
return false;
return true;
}
int main() {
int n, ballNumber;
while(cin >> n >> ballNumber && n > 0 && ballNumber > 0) {
vector<int> balls(ballNumber);
for(int i = 0; i < ballNumber; ++i)
cin >> balls[i];
sort(balls.begin(), balls.end());
cout << (canCallOutAll(balls, n) ? 'Y' : 'N') << '\n';
}
}
| [
"dancas2@gmail.com"
] | dancas2@gmail.com |
23c48612626db0bc806fdd0f79bf61a073d6fd9e | 47610aa612655d17c2d2e88116bff8ce8ebc0a26 | /src/analysis/PandaXEnergyDepositionHit.cc | 36bb662dbb455b04a6041b2063fbd5c395fcfe77 | [] | no_license | Catofes/BambooMC | 6aa154f6ad0a4a305300eef2ff3d26735c4404a4 | 42ab135729ed4ec7d0c90050043a1bce6a9deacb | refs/heads/main | 2020-05-21T19:10:36.629301 | 2016-09-11T01:20:41 | 2016-09-11T01:20:41 | 62,614,871 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,738 | cc | #include "analysis/PandaXEnergyDepositionHit.hh"
G4Allocator<PandaXEnergyDepositionHit> * pandaXEnergyDepositionHitAllocator = new G4Allocator<PandaXEnergyDepositionHit>;
PandaXEnergyDepositionHit::PandaXEnergyDepositionHit()
: _trackId(-1), _parentId(-1), _energy(0), _x(0), _y(0), _z(0),
_type("unknown"), _creatorProcess("unknown"), _depositionProcess("unknown"), _parent("none")
{
}
PandaXEnergyDepositionHit::~PandaXEnergyDepositionHit()
{
}
const PandaXEnergyDepositionHit & PandaXEnergyDepositionHit::operator=(const PandaXEnergyDepositionHit & right)
{
_trackId = right._trackId;
_parentId = right._parentId;
_energy = right._energy;
_x = right._x;
_y = right._y;
_z = right._z;
_t = right._t;
_type = right._type;
_creatorProcess = right._creatorProcess;
_depositionProcess = right._depositionProcess;
_parent = right._parent;
return * this;
}
int PandaXEnergyDepositionHit::operator==(const PandaXEnergyDepositionHit &right) const
{
return ((this == &right)?1:0);
}
int PandaXEnergyDepositionHit::getTrackId () const
{
return _trackId;
}
int PandaXEnergyDepositionHit::getParentId () const
{
return _parentId;
}
double PandaXEnergyDepositionHit::getEnergy() const
{
return _energy;
}
double PandaXEnergyDepositionHit::getX() const
{
return _x;
}
double PandaXEnergyDepositionHit::getY() const
{
return _y;
}
double PandaXEnergyDepositionHit::getZ() const
{
return _z;
}
double PandaXEnergyDepositionHit::getT() const
{
return _t;
}
const string & PandaXEnergyDepositionHit::getType() const
{
return _type;
}
const string & PandaXEnergyDepositionHit::getCreatorProcess() const
{
return _creatorProcess;
}
const string & PandaXEnergyDepositionHit::getDepositionProcess() const
{
return _depositionProcess;
}
const string & PandaXEnergyDepositionHit::getParent() const
{
return _parent;
}
void PandaXEnergyDepositionHit::setTrackId (int id)
{
_trackId = id;
}
void PandaXEnergyDepositionHit::setParentId (int id)
{
_parentId = id;
}
void PandaXEnergyDepositionHit::setEnergy(double energy)
{
_energy = energy;
}
void PandaXEnergyDepositionHit::setX(double x)
{
_x = x;
}
void PandaXEnergyDepositionHit::setY(double y)
{
_y = y;
}
void PandaXEnergyDepositionHit::setZ(double z)
{
_z = z;
}
void PandaXEnergyDepositionHit::setT(double t)
{
_t = t;
}
void PandaXEnergyDepositionHit::setType(const string &type)
{
_type = type;
}
void PandaXEnergyDepositionHit::setCreatorProcess(const string &process)
{
_creatorProcess = process;
}
void PandaXEnergyDepositionHit::setDepositionProcess(const string &process)
{
_depositionProcess = process;
}
void PandaXEnergyDepositionHit::setParent(const string &parent)
{
_parent = parent;
}
| [
"xun.revive@gmail.com"
] | xun.revive@gmail.com |
2bde1c403a9a8eb994890ac9c3a53cdb03a6d46f | 3bbf8a6c3d629c6a612d6d33ca220eecdb935e12 | /aws-cpp-sdk-sms-voice/include/aws/sms-voice/model/EventDestination.h | 2e037ba4488a369553bb54ba83ae9a5e20c81ac8 | [
"MIT",
"Apache-2.0",
"JSON"
] | permissive | julio-gorge/aws-sdk-cpp | a8c067adf072ff43c686a15092e54ad2393cc1d4 | 06b0d54110172b3cf9b3f5602060304e36afd225 | refs/heads/master | 2021-10-22T15:00:07.328784 | 2019-03-11T12:08:52 | 2019-03-11T12:08:52 | 161,850,005 | 0 | 0 | Apache-2.0 | 2018-12-14T23:11:43 | 2018-12-14T23:11:43 | null | UTF-8 | C++ | false | false | 7,654 | h | /*
* Copyright 2010-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#pragma once
#include <aws/sms-voice/PinpointSMSVoice_EXPORTS.h>
#include <aws/sms-voice/model/CloudWatchLogsDestination.h>
#include <aws/sms-voice/model/KinesisFirehoseDestination.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/sms-voice/model/SnsDestination.h>
#include <aws/sms-voice/model/EventType.h>
#include <utility>
namespace Aws
{
namespace Utils
{
namespace Json
{
class JsonValue;
class JsonView;
} // namespace Json
} // namespace Utils
namespace PinpointSMSVoice
{
namespace Model
{
/**
* An object that defines an event destination.<p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/pinpoint-sms-voice-2018-09-05/EventDestination">AWS
* API Reference</a></p>
*/
class AWS_PINPOINTSMSVOICE_API EventDestination
{
public:
EventDestination();
EventDestination(Aws::Utils::Json::JsonView jsonValue);
EventDestination& operator=(Aws::Utils::Json::JsonView jsonValue);
Aws::Utils::Json::JsonValue Jsonize() const;
inline const CloudWatchLogsDestination& GetCloudWatchLogsDestination() const{ return m_cloudWatchLogsDestination; }
inline void SetCloudWatchLogsDestination(const CloudWatchLogsDestination& value) { m_cloudWatchLogsDestinationHasBeenSet = true; m_cloudWatchLogsDestination = value; }
inline void SetCloudWatchLogsDestination(CloudWatchLogsDestination&& value) { m_cloudWatchLogsDestinationHasBeenSet = true; m_cloudWatchLogsDestination = std::move(value); }
inline EventDestination& WithCloudWatchLogsDestination(const CloudWatchLogsDestination& value) { SetCloudWatchLogsDestination(value); return *this;}
inline EventDestination& WithCloudWatchLogsDestination(CloudWatchLogsDestination&& value) { SetCloudWatchLogsDestination(std::move(value)); return *this;}
/**
* Indicates whether or not the event destination is enabled. If the event
* destination is enabled, then Amazon Pinpoint sends response data to the
* specified event destination.
*/
inline bool GetEnabled() const{ return m_enabled; }
/**
* Indicates whether or not the event destination is enabled. If the event
* destination is enabled, then Amazon Pinpoint sends response data to the
* specified event destination.
*/
inline void SetEnabled(bool value) { m_enabledHasBeenSet = true; m_enabled = value; }
/**
* Indicates whether or not the event destination is enabled. If the event
* destination is enabled, then Amazon Pinpoint sends response data to the
* specified event destination.
*/
inline EventDestination& WithEnabled(bool value) { SetEnabled(value); return *this;}
inline const KinesisFirehoseDestination& GetKinesisFirehoseDestination() const{ return m_kinesisFirehoseDestination; }
inline void SetKinesisFirehoseDestination(const KinesisFirehoseDestination& value) { m_kinesisFirehoseDestinationHasBeenSet = true; m_kinesisFirehoseDestination = value; }
inline void SetKinesisFirehoseDestination(KinesisFirehoseDestination&& value) { m_kinesisFirehoseDestinationHasBeenSet = true; m_kinesisFirehoseDestination = std::move(value); }
inline EventDestination& WithKinesisFirehoseDestination(const KinesisFirehoseDestination& value) { SetKinesisFirehoseDestination(value); return *this;}
inline EventDestination& WithKinesisFirehoseDestination(KinesisFirehoseDestination&& value) { SetKinesisFirehoseDestination(std::move(value)); return *this;}
inline const Aws::Vector<EventType>& GetMatchingEventTypes() const{ return m_matchingEventTypes; }
inline void SetMatchingEventTypes(const Aws::Vector<EventType>& value) { m_matchingEventTypesHasBeenSet = true; m_matchingEventTypes = value; }
inline void SetMatchingEventTypes(Aws::Vector<EventType>&& value) { m_matchingEventTypesHasBeenSet = true; m_matchingEventTypes = std::move(value); }
inline EventDestination& WithMatchingEventTypes(const Aws::Vector<EventType>& value) { SetMatchingEventTypes(value); return *this;}
inline EventDestination& WithMatchingEventTypes(Aws::Vector<EventType>&& value) { SetMatchingEventTypes(std::move(value)); return *this;}
inline EventDestination& AddMatchingEventTypes(const EventType& value) { m_matchingEventTypesHasBeenSet = true; m_matchingEventTypes.push_back(value); return *this; }
inline EventDestination& AddMatchingEventTypes(EventType&& value) { m_matchingEventTypesHasBeenSet = true; m_matchingEventTypes.push_back(std::move(value)); return *this; }
/**
* A name that identifies the event destination configuration.
*/
inline const Aws::String& GetName() const{ return m_name; }
/**
* A name that identifies the event destination configuration.
*/
inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
/**
* A name that identifies the event destination configuration.
*/
inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
/**
* A name that identifies the event destination configuration.
*/
inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
/**
* A name that identifies the event destination configuration.
*/
inline EventDestination& WithName(const Aws::String& value) { SetName(value); return *this;}
/**
* A name that identifies the event destination configuration.
*/
inline EventDestination& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
/**
* A name that identifies the event destination configuration.
*/
inline EventDestination& WithName(const char* value) { SetName(value); return *this;}
inline const SnsDestination& GetSnsDestination() const{ return m_snsDestination; }
inline void SetSnsDestination(const SnsDestination& value) { m_snsDestinationHasBeenSet = true; m_snsDestination = value; }
inline void SetSnsDestination(SnsDestination&& value) { m_snsDestinationHasBeenSet = true; m_snsDestination = std::move(value); }
inline EventDestination& WithSnsDestination(const SnsDestination& value) { SetSnsDestination(value); return *this;}
inline EventDestination& WithSnsDestination(SnsDestination&& value) { SetSnsDestination(std::move(value)); return *this;}
private:
CloudWatchLogsDestination m_cloudWatchLogsDestination;
bool m_cloudWatchLogsDestinationHasBeenSet;
bool m_enabled;
bool m_enabledHasBeenSet;
KinesisFirehoseDestination m_kinesisFirehoseDestination;
bool m_kinesisFirehoseDestinationHasBeenSet;
Aws::Vector<EventType> m_matchingEventTypes;
bool m_matchingEventTypesHasBeenSet;
Aws::String m_name;
bool m_nameHasBeenSet;
SnsDestination m_snsDestination;
bool m_snsDestinationHasBeenSet;
};
} // namespace Model
} // namespace PinpointSMSVoice
} // namespace Aws
| [
"aws-sdk-cpp-automation@github.com"
] | aws-sdk-cpp-automation@github.com |
3e65d1676b3dae5173ac46584b67e23e1f19863f | 911ea9deb0418b350531ebed386567c3c784b37d | /HeroscapeEditor/Maths/COLOR.h | 8cabded43734a56783ca328f285d10277c3d4bcd | [] | no_license | dkniffin/virtualscape | 7088ca22a2815f7c1ba22d43671dd192eea77d32 | 7c80625e1b152fb1e7836c83d4165cf79eca1c7d | refs/heads/master | 2020-12-31T03:26:12.985542 | 2014-03-11T16:51:11 | 2014-03-11T16:51:11 | 17,637,322 | 5 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,901 | h | //////////////////////////////////////////////////////////////////////////////////////////
// COLOR.h
// Class declaration for an RGBA color
// You may use this code however you wish, but if you do, please credit me and
// provide a link to my website in a readme file or similar
// Downloaded from: www.paulsprojects.net
// Created: 20th July 2002
// Modified: 7th November 2002 - Some speed improvements
// - Removed clamping after adds etc. Do it yourself!
// To enable use with floating point color buffers
// - Corrected lerp (reversed f and 1-f)
// 13th December 2002 - Added default parameter to alpha of Set()
// - Added red, green, blue constant COLORs
//////////////////////////////////////////////////////////////////////////////////////////
#ifndef COLOR_H
#define COLOR_H
class COLOR
{
public:
//constructors
COLOR()
{ r=g=b=a=0.0f; }
COLOR(float newR, float newG, float newB, float newA=0.0f)
{ r=newR; g=newG; b=newB; a=newA; }
COLOR(const float * rhs)
{ r=*rhs; g=*(rhs+1); b=*(rhs+2); a=*(rhs+3); }
COLOR(const COLOR & rhs)
{ r=rhs.r; g=rhs.g; b=rhs.b; a=rhs.a;}
~COLOR() {} //empty
void Set(float newR, float newG, float newB, float newA=0.0f)
{ r=newR; g=newG; b=newB; a=newA; }
//accessors kept for compatability
void SetR(float newR) {r = newR;}
void SetG(float newG) {g = newG;}
void SetB(float newB) {b = newB;}
void SetA(float newA) {a = newA;}
float GetR() const {return r;} //public accessor functions
float GetG() const {return g;} //inline, const
float GetB() const {return b;}
float GetA() const {return a;}
void ClampTo01(void); //clamp all components to [0,1]
void SetBlack(void) {r=g=b=a=1.0f;}
void SetWhite(void) {r=g=b=a=0.0f;}
void SetGrey(float shade) {r=g=b=a=shade;}
//linear interpolate
COLOR lerp(const COLOR & c2, float factor)
{ return (*this)*(1.0f-factor) + c2*factor; }
//binary operators
COLOR operator+(const COLOR & rhs) const
{ return COLOR(r+rhs.r, g+rhs.g, b+rhs.b, a+rhs.a); }
COLOR operator-(const COLOR & rhs) const
{ return COLOR(r-rhs.r, g-rhs.g, b-rhs.b, a-rhs.a); }
COLOR operator*(const COLOR & rhs) const
{ return COLOR(r*rhs.r, g*rhs.g, b*rhs.b, a*rhs.a); }
COLOR operator/(const COLOR & rhs) const
{ return COLOR(r/rhs.r, g/rhs.g, b/rhs.b, a/rhs.a); }
COLOR operator*(const float rhs) const
{ return COLOR(r*rhs, g*rhs, b*rhs, a*rhs); }
COLOR operator/(const float rhs) const
{ return COLOR(r/rhs, g/rhs, b/rhs, a/rhs); }
//multiply by a float, eg 3*c
friend COLOR operator*(float scaleFactor, const COLOR & rhs);
bool operator==(const COLOR & rhs) const;
bool operator!=(const COLOR & rhs) const
{ return !((*this)==rhs); }
//self-add etc
COLOR operator+=(const COLOR & rhs)
{ (*this)=(*this)+rhs; return (*this); }
COLOR operator-=(const COLOR & rhs)
{ (*this)=(*this)-rhs; return (*this); }
COLOR operator*=(const COLOR & rhs)
{ (*this)=(*this)*rhs; return (*this); }
COLOR operator/=(const COLOR & rhs)
{ (*this)=(*this)/rhs; return (*this); }
COLOR operator*=(const float rhs)
{ (*this)=(*this)*rhs; return (*this); }
COLOR operator/=(const float rhs)
{ (*this)=(*this)/rhs; return (*this); }
//unary operators
COLOR operator-(void) const {return COLOR(-r,-g, -b, -a);}
COLOR operator+(void) const {return (*this);}
//cast to pointer to float for glColor4fv etc
operator float* () const {return (float*) this;}
operator const float* () const {return (const float*) this;}
//member variables
float r;
float g;
float b;
float a;
};
const COLOR white(1.0f, 1.0f, 1.0f, 1.0f);
const COLOR black(0.0f, 0.0f, 0.0f, 0.0f);
const COLOR red(1.0f, 0.0f, 0.0f, 1.0f);
const COLOR green(0.0f, 1.0f, 0.0f, 1.0f);
const COLOR blue(0.0f, 0.0f, 1.0f, 1.0f);
const COLOR cyan(0.0f, 1.0f, 1.0f, 1.0f);
const COLOR magenta(1.0f, 0.0f, 1.0f, 1.0f);
const COLOR yellow(1.0f, 1.0f, 0.0f, 1.0f);
#endif //COLOR_H | [
"oddityoverseer13@gmail.com"
] | oddityoverseer13@gmail.com |
5d7d756f6e4abb226a1ad4c010a3c66e320623d6 | cdea9b673d668c6eda9d90f9c606eeb8cb967d4b | /libs/vm/tests/cpu_tests.cpp | 1c223ca9a98297010e963a7ebd1699d05965c78d | [
"MIT"
] | permissive | tiaanl/emulator | 9965aa39248bfe81bd682b8d3554a23d08e97b49 | a962f5136972a272294795579a2966f1af221f61 | refs/heads/main | 2023-01-22T19:33:55.749535 | 2020-12-08T16:07:36 | 2020-12-08T16:07:36 | 313,039,898 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 199 | cpp | #include <vm/emulator/cpu.h>
#include <vm/emulator/memory.h>
#include <catch2/catch.hpp>
namespace vm {
TEST_CASE("registers") {
Memory memory;
Bus bus;
CPU cpu(&bus);
}
} // namespace vm
| [
"tiaanl@gmail.com"
] | tiaanl@gmail.com |
358e987560734e48c1fde7eb5421848f162ba774 | 0babb8cbe975befd62e6b4393fdc4a68307ca457 | /ConsoleApplication1/Computer graphics.cpp | bc3e936152afbdb897362880620ac2a01dfc55d2 | [] | no_license | kimujinu/OpenGL | 477ca3d2230fa81d173457754038f115a1b183ec | aa2eac01caac424cdb07979c950c7ecc443c0aee | refs/heads/master | 2020-11-28T10:33:46.828446 | 2019-12-23T16:31:27 | 2019-12-23T16:31:27 | 229,783,124 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,739 | cpp |
#include <stdlib.h>
#include <math.h>
#include <stdio.h>
#include <GL/glut.h>
void idleFunc();
void displayFunc();
void reshapeFunc(GLsizei width, GLsizei height);
void keyboardFunc(unsigned char, int, int);
void mouseFunc(int button, int state, int x, int y);
void initialize();
void render();
void mirror(GLfloat val);
#define INC_VAL 2.0f
#ifndef M_PI
#define M_PI 3.14159265359
#endif
// width and height of the window
GLsizei g_width = 480;
GLsizei g_height = 360;
// whether to animate
GLboolean g_rotate = GL_TRUE;
// light 0 position
GLfloat g_light0_pos[4] = { 10.0f, 5.0f, 0.0f, 1.0f };
// clipping planes
GLdouble eqn1[4] = { 0.0, 0.0, 1.0, 0.0 };
GLfloat g_inc = 0.0f;
int main(int argc, char ** argv)
{
// initialize GLUT
glutInit(&argc, argv);
// double buffer, use rgb color, enable depth buffer
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH |
GLUT_STENCIL);
// initialize the window size
glutInitWindowSize(g_width, g_height);
// set the window postion
glutInitWindowPosition(100, 100);
// create the window
glutCreateWindow("Mirror Sample");
// set the idle function - called when idle
glutIdleFunc(g_rotate ? idleFunc : NULL);
// set the display function - called when redrawing
glutDisplayFunc(displayFunc);
// set the reshape function - called when client area changes
glutReshapeFunc(reshapeFunc);
// set the keyboard function - called on keyboard events
glutKeyboardFunc(keyboardFunc);
// set the mouse function - called on mouse stuff
glutMouseFunc(mouseFunc);
// do our own initialization
initialize();
// let GLUT handle the current thread from here
glutMainLoop();
return 0;
}
void initialize()
{
// set the GL clear color - use when the color buffer is cleared
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
// set the shading model to 'smooth'
glShadeModel(GL_SMOOTH);
// enable depth
glEnable(GL_DEPTH_TEST);
// set the front faces of polygons
glFrontFace(GL_CCW);
// set fill mode
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// set the line width
glLineWidth(2.0f);
// enable lighting
glEnable(GL_LIGHTING);
// enable lighting for front
glLightModeli(GL_FRONT, GL_TRUE);
// material have diffuse and ambient lighting
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
// enable color
glEnable(GL_COLOR_MATERIAL);
// enable light 0
glEnable(GL_LIGHT0);
}
void reshapeFunc(GLsizei w, GLsizei h)
{
// save the new window size
g_width = w; g_height = h;
// map the view port to the client area
glViewport(0, 0, w, h);
// set the matrix mode to project
glMatrixMode(GL_PROJECTION);
// load the identity matrix
glLoadIdentity();
// create the viewing frustum
gluPerspective(45.0, (GLfloat)w / (GLfloat)h, 1.0, 300.0);
// set the matrix mode to modelview
glMatrixMode(GL_MODELVIEW);
// load the identity matrix
glLoadIdentity();
// position the view point
gluLookAt(0.0f, 1.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
}
void keyboardFunc(unsigned char key, int x, int y)
{
switch (key)
{
case 'Q':
case 'q':
exit(1);
break;
}
// do a reshape since g_eye_y might have changed
reshapeFunc(g_width, g_height);
glutPostRedisplay();
}
void mouseFunc(int button, int state, int x, int y)
{
if (button == GLUT_LEFT_BUTTON)
{
// rotate
if (state == GLUT_DOWN)
g_inc -= INC_VAL;
else
g_inc += INC_VAL;
}
else if (button == GLUT_RIGHT_BUTTON)
{
if (state == GLUT_DOWN)
g_inc += INC_VAL;
else
g_inc -= INC_VAL;
}
else
g_inc = 0.0f;
glutPostRedisplay();
}
void idleFunc()
{
// render the scene
glutPostRedisplay();
}
void displayFunc()
{
static GLfloat angle = 0.0;
GLfloat val = .8f;
GLint buffers = GL_NONE;
// get the current color buffer being drawn to
glGetIntegerv(GL_DRAW_BUFFER, &buffers);
glPushMatrix();
// rotate the viewpoint
glRotatef(angle += g_inc, 0.0f, 1.0f, 0.0f);
// set the clear value
glClearStencil(0x0);
// clear the stencil buffer
glClear(GL_STENCIL_BUFFER_BIT);
// always pass the stencil test
glStencilFunc(GL_ALWAYS, 0x1, 0x1);
// set the operation to modify the stencil buffer
glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
// disable drawing to the color buffer
glDrawBuffer(GL_NONE);
// enable stencil
glEnable(GL_STENCIL_TEST);
// draw the stencil mask
glBegin(GL_QUADS);
mirror(val);
glEnd();
// reenable drawing to color buffer
glDrawBuffer((GLenum)buffers);
// make stencil buffer read only
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
// clear the color and depth buffers
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// draw the mirror image
glPushMatrix();
// invert image about xy plane
glScalef(1.0f, 1.0f, -1.0f);
// invert the clipping plane based on the view point
if (cos(angle * M_PI / 180.0) < 0.0)
eqn1[2] = -1.0;
else
eqn1[2] = 1.0;
// clip one side of the plane
glClipPlane(GL_CLIP_PLANE0, eqn1);
glEnable(GL_CLIP_PLANE0);
// draw only where the stencil buffer == 1
glStencilFunc(GL_EQUAL, 0x1, 0x1);
// draw the object
render();
// turn off clipping plane
glDisable(GL_CLIP_PLANE0);
glPopMatrix();
// disable the stencil buffer
glDisable(GL_STENCIL_TEST);
// disable drawing to the color buffer
glDrawBuffer(GL_NONE);
// draw the mirror pane into depth buffer -
// to prevent object behind mirror from being render
glBegin(GL_QUADS);
mirror(val);
glEnd();
// enable drawing to the color buffer
glDrawBuffer((GLenum)buffers);
// draw the normal image, without stencil test
glPushMatrix();
render();
glPopMatrix();
// draw the outline of the mirror
glColor3f(0.4f, 0.4f, 1.0f);
glBegin(GL_LINE_LOOP);
mirror(val);
glEnd();
// mirror shine
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
glDepthMask(GL_FALSE);
glDepthFunc(GL_LEQUAL);
glDisable(GL_LIGHTING);
glColor4f(1.0f, 1.0f, 1.0f, .2f);
glTranslatef(0.0f, 0.0f, 0.01f * eqn1[2]);
glBegin(GL_QUADS);
mirror(val);
glEnd();
glDisable(GL_BLEND);
glDepthMask(GL_TRUE);
glDepthFunc(GL_LESS);
glEnable(GL_LIGHTING);
glPopMatrix();
glFlush();
glutSwapBuffers();
}
void mirror(GLfloat val)
{
glVertex3f(val, val, 0.0f);
glVertex3f(-val, val, 0.0f);
glVertex3f(-val, -val, 0.0f);
glVertex3f(val, -val, 0.0f);
}
void render()
{
glLightfv(GL_LIGHT0, GL_POSITION, g_light0_pos);
glPushMatrix();
glColor3f(.4f, 1.0f, .4f);
glTranslatef(0.0f, 0.0f, 2.5f);
glutSolidSphere(0.5, 12, 12);
glTranslatef(0.5f, 0.0f, -0.7f);
glColor3f(1.0f, .4f, .4f);
glutWireTeapot(0.0);
glTranslatef(-0.5f, 0.0f, -0.2f);
glRotatef(-90, 1.0f, 0.0f, 0.0f);
glColor3f(1.0f, 1.0f, .4f);
glutSolidCone(.3, .6, 8, 8);
glPopMatrix();
glPushMatrix();
glTranslatef(0.2f, 0.3f, -2.0f);
glColor3f(.9f, .4f, .9f);
glutWireTeapot(0.5);
glPopMatrix();
}
| [
"dnehd6739@naver.com"
] | dnehd6739@naver.com |
ca2c7f0d9d083451b72bdfb294000b8bd3f6b3aa | 21a221c20313339ac7380f8d92f8006e5435ef1d | /src/arcscripts/src/InstanceScripts/Instance_MagistersTerrace.cpp | 45e252d1dc15d0ebf45bf211e3f4c11f35f5b45a | [] | no_license | AwkwardDev/Descent-core-scripts-3.3.5 | a947a98d0fdedae36a488c542642fcf61472c3d7 | d773b1a41ed3f9f970d81962235e858d0848103f | refs/heads/master | 2021-01-18T10:16:03.750112 | 2014-08-12T16:28:15 | 2014-08-12T16:28:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 19,671 | cpp | /*
* ArcScripts for ArcEmu MMORPG Server
* Copyright (C) 2009 ArcEmu Team <http://www.arcemu.org/>
* Copyright (C) 2008-2009 Sun++ Team <http://www.sunscripting.com/>
* Copyright (C) 2005-2007 Ascent Team <http://www.ascentemu.com/>
* Copyright (C) 2007-2008 Moon++ Team <http://www.moonplusplus.info/>
*
* 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
* 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 "Setup.h"
//MagisterTerrace Script
//Bosses
//Selin Firehart Encounter
// Creature Entry's
#define TRASH_FelCrystal 24722
#define BOSS_SelinFireheart 24723
// Normal & Heroic Spells
/*
Mana Rage
Caster: Fel Crystal
Details: Empowers the caster with fel energy, restoring their mana for 10 sec.
Triggers: Increases the target's mana by 10%.
*/
#define FC_MANARAGE 44320
#define FC_MANARAGE_TRIGGER 44321
/*
Fel Explosion
Caster Selin Fireheart
Details: Area of effect damage spell, cast continually until Selin is out of mana
*/
#define SF_FELEXPLOSION 44314
/*
Drain Life
Caster Selin Fireheart
Details: Randomly targeted channeled spell, deals damage and heals Selin.
*/
#define SF_DRAINLIFE 44294
// Heroic Spells
/*
Drain Mana (Heroic Mode Only)
Caster Selin Fireheart
Details: Randomly targeted channeled spell on a player with mana, drain Mana to the player and give it to Selin.
*/
#define SF_DRAINMANA 46153
// Fel Crystal Spawn Locations
static LocationExtra FelCrystals[]={
{225.969f, -20.0775f, -2.9731f, 0.942478f, TRASH_FelCrystal},
{226.314f, 20.2183f, -2.98127f, 5.32325f, TRASH_FelCrystal},
{247.888f, -14.6252f, 3.80777f, 2.33874f, TRASH_FelCrystal},
{248.053f, 14.592f, 3.74882f, 3.94444f, TRASH_FelCrystal},
{263.149f, 0.309245f, 1.32057f, 3.15905f, TRASH_FelCrystal}
};
class SelinFireheartAI : public MoonScriptCreatureAI
{
MOONSCRIPT_FACTORY_FUNCTION(SelinFireheartAI, MoonScriptCreatureAI);
SelinFireheartAI(Creature* pCreature) : MoonScriptCreatureAI(pCreature)
{
AddSpell(SF_DRAINLIFE, Target_RandomPlayer, 8, 0, 35);
if(_unit->GetMapMgr()->iInstanceMode == MODE_HEROIC)
AddSpell(SF_DRAINMANA, Target_RandomPlayer, 8, 0, 35);
ManaRage = dbcSpell.LookupEntry(FC_MANARAGE);
ManaRageTrigger = AddSpell(FC_MANARAGE_TRIGGER, Target_Self, 0, 0, 0);
FelExplosion = AddSpell(SF_FELEXPLOSION, Target_Self, 0, 0, 0);
}
void OnCombatStart(Unit* pTarget)
{
/*
Selin Fireheart starts with 0 mana and drains it from the felcrystals in the room
- ToDo: Set it so mana regen is off
*/
_unit->SetUInt32Value(UNIT_FIELD_POWER1, 0);
ParentClass::OnCombatStart(pTarget);
}
/*
During the AIUpdate() Selin will spam FelExplosion until hes out of mana
He will then attempt to gain mana from a FelCrystal thats in the room by running to them
*/
void AIUpdate()
{
// 10% of his mana according to wowhead is 3231 which is whats needed to cast FelExplosion
if(GetManaPercent() < 10 || FelExplosion->mEnabled == false)
Mana();
else if(!IsCasting())// Mana is greater than 10%
CastFelExplosion();
ParentClass::AIUpdate();
}
void Mana()
{
/*
Attempt to get a Fel Crystal and move to it if not in range.
Once in range we get the FelCrystal to cast Mana Rage on Selin
*/
Unit* FelCrystal = NULL;
PreventActions(false);
FelCrystal = FindFelCrystal();
if(!FelCrystal || !FelCrystal->isAlive())
{
PreventActions(true);
FelCrystal = NULL;
return;
}
// Not in range
if(_unit->GetDistance2dSq(FelCrystal) > 100)
{
MoveTo(FelCrystal->GetPositionX(), FelCrystal->GetPositionY(), FelCrystal->GetPositionZ());
FelCrystal = NULL;
return;
}
_unit->GetAIInterface()->StopMovement(0);
if(!FelCrystal->GetCurrentSpell())
FelCrystal->CastSpell(_unit, ManaRage, false);
// Mana Rage giving of mana doesnt work so we give 10%(3231) / AIUpdate() Event.
CastSpellNowNoScheduling(ManaRageTrigger);
uint32 mana = _unit->GetPower(POWER_TYPE_MANA)+3231;
if(mana >= _unit->GetMaxPower(POWER_TYPE_MANA))
mana = _unit->GetMaxPower(POWER_TYPE_MANA);
_unit->SetUInt32Value(UNIT_FIELD_POWER1, mana);
// Re-Enable FelExplosion
if(GetManaPercent() >= 100)
PreventActions(true);
FelCrystal = NULL;
}
void PreventActions(bool Allow)
{
FelExplosion->mEnabled = Allow;
SetAllowMelee(Allow);
SetAllowRanged(Allow);
SetAllowSpell(Allow);
SetAllowTargeting(Allow);
}
Unit* FindFelCrystal()
{
/*
Find a FelCrystal
*/
Unit* FC = NULL;
for(int x=0; x<5; x++)
{
FC = _unit->GetMapMgr()->GetInterface()->GetCreatureNearestCoords(FelCrystals[x].x, FelCrystals[x].y, FelCrystals[x].z, FelCrystals[x].addition);
if(!FC || !FC->isAlive() || FC->GetInstanceID() != _unit->GetInstanceID())
FC = NULL;
else
break;
}
return FC;
}
void CastFelExplosion()
{
CastSpellNowNoScheduling(FelExplosion);
// No Idea why the mana isnt taken when the spell is cast so had to manually take it -_-
_unit->SetUInt32Value(UNIT_FIELD_POWER1, _unit->GetPower(POWER_TYPE_MANA) - 3231);
}
SpellEntry* ManaRage;
SpellDesc* ManaRageTrigger;
SpellDesc* FelExplosion;
};
/*
Vexallus
*/
#define BOSS_VEXALLUS 24744
#define CN_PURE_ENERGY 24745
#define VEXALLUS_CHAIN_LIGHTNING 44318
#define VEXALLUS_OVERLOAD 44353
#define VEXALLUS_ARCANE_SHOCK 44319
#define VEXALLUS_SUMMON_PURE_ENERGY 44322
class VexallusAI : public MoonScriptBossAI
{
MOONSCRIPT_FACTORY_FUNCTION(VexallusAI, MoonScriptBossAI);
VexallusAI(Creature* pCreature) : MoonScriptBossAI(pCreature)
{
AddPhaseSpell( 1, AddSpell( VEXALLUS_CHAIN_LIGHTNING, Target_Current, 19, 0, 8, 0, 0));
AddPhaseSpell( 1, AddSpell( VEXALLUS_ARCANE_SHOCK, Target_ClosestPlayer, 12, 0, 20, 0, 0, true, "Un...con...tainable.", Text_Yell, 12392));
AddPhaseSpell( 2, AddSpell( VEXALLUS_OVERLOAD, Target_Self, 85, 0, 3, 0, 0));
mPureEnergy = AddSpell( VEXALLUS_SUMMON_PURE_ENERGY, Target_Self, 85, 0, 3);
AddEmote( Event_OnTargetDied, "Con...sume.", Text_Yell, 12393);
mSummon = 0;
}
void OnCombatStart(Unit* pTarget)
{
Emote("Drain... life...", Text_Yell, 12389);
SetPhase(1);
ParentClass::OnCombatStart(pTarget);
}
void AIUpdate()
{
if((GetHealthPercent() <= 85 && mSummon == 0) ||
( GetHealthPercent() <= 70 && mSummon == 1 ) ||
( GetHealthPercent() <= 55 && mSummon == 2 ) ||
( GetHealthPercent() <= 40 && mSummon == 3 ) ||
( GetHealthPercent() <= 25 && mSummon == 4 ))
{
CastSpell(mPureEnergy);
++mSummon;
//SpawnCreature(CN_PURE_ENERGY, 231, -207, 6, 0, true);
}
if( GetHealthPercent() <= 10 && GetPhase() == 1 )
SetPhase(2);
ParentClass::AIUpdate();
}
SpellDesc* mPureEnergy;
uint8 mSummon;
};
//Priestess Delrissa
#define BOSS_Priestess_Delrissa 24560
#define PRIESTESS_DELRISSA_DISPEL_MAGIC 27609
#define PRIESTESS_DELRISSA_FLASH_HEAL 17843
#define PRIESTESS_DELRISSA_SHADOWWORD_PAIN 15654
#define PRIESTESS_DELRISSA_POWERWORD_SHIELD 44291
#define PRIESTESS_DELRISSA_RENEW 44174
class Priestess_DelrissaAI : public MoonScriptBossAI
{
MOONSCRIPT_FACTORY_FUNCTION(Priestess_DelrissaAI, MoonScriptBossAI);
Priestess_DelrissaAI(Creature* pCreature) : MoonScriptBossAI(pCreature)
{
AddSpell(PRIESTESS_DELRISSA_DISPEL_MAGIC, Target_RandomFriendly, 35, 0, 5, 0, 30);
AddSpell(PRIESTESS_DELRISSA_FLASH_HEAL, Target_RandomFriendly, 40, 1.5, 7, 0, 40);
AddSpell(PRIESTESS_DELRISSA_SHADOWWORD_PAIN, Target_RandomPlayer, 45, 0, 18, 0, 30);
AddSpell(PRIESTESS_DELRISSA_POWERWORD_SHIELD, Target_RandomFriendly, 32, 0, 15, 0, 40);
AddSpell(PRIESTESS_DELRISSA_RENEW, Target_RandomFriendly, 30, 0, 18, 0, 40);
AddEmote(Event_OnDied, "Not what I had... planned...", Text_Yell, 12397);
mClearHateList = AddTimer(15000);
mKilledPlayers = 0;
};
void OnCombatStart(Unit* pTarget)
{
Emote("Annihilate them!", Text_Yell, 12395);
//AggroRandomUnit(); // Want to aggro random unit ? Set it instead of calling premade
// method that in this case recursively loops this procedure
ParentClass::OnCombatStart(pTarget);
};
void OnTargetDied(Unit* pTarget)
{
if(!pTarget || !pTarget->IsPlayer())
return;
++mKilledPlayers;
if(mKilledPlayers == 1)
Emote("I call that a good start.", Text_Yell, 12405);
else if(mKilledPlayers == 2)
Emote("I could have sworn there were more of you.", Text_Yell, 12407);
else if(mKilledPlayers == 3)
Emote("Not really much of a group, anymore, is it?", Text_Yell, 12409);
else if(mKilledPlayers == 4)
Emote("One is such a lonely number.", Text_Yell, 12410);
else if(mKilledPlayers == 5)
Emote("It's been a kick, really.", Text_Yell, 12411);
ParentClass::OnTargetDied(pTarget);
};
void OnCombatStop(Unit* pTarget)
{
Emote("It's been a kick, really.", Text_Yell, 12411);
mKilledPlayers = 0;
ParentClass::OnCombatStop(pTarget);
};
void AIUpdate()
{
if( IsTimerFinished(mClearHateList) )
{
ClearHateList();
AggroRandomUnit();
ResetTimer(mClearHateList, 15000);
};
ParentClass::AIUpdate();
};
protected:
uint8 mKilledPlayers;
int32 mClearHateList;
};
//Kagani Nightstrike
#define CN_KaganiNightstrike 24557
#define KAGANI_NIGHTSTRIKE_Eviscerate 46189
#define KAGANI_NIGHTSTRIKE_KidneyShot 27615
#define KAGANI_NIGHTSTRIKE_Gouge 12540
class Kagani_NightstrikeAI : public MoonScriptBossAI
{
MOONSCRIPT_FACTORY_FUNCTION(Kagani_NightstrikeAI, MoonScriptBossAI);
Kagani_NightstrikeAI(Creature* pCreature) : MoonScriptBossAI(pCreature)
{
AddSpell(KAGANI_NIGHTSTRIKE_KidneyShot, Target_Current, 80, 0, 25, 0, 30);
AddSpell(KAGANI_NIGHTSTRIKE_Gouge, Target_ClosestPlayer, 20, 0, 18, 0, 30);
AddSpell(KAGANI_NIGHTSTRIKE_Eviscerate, Target_Current, 8, 0, 45, 0, 30);
}
};
//Ellrys Duskhallow
#define CN_EllrysDuskhallow 14558
#define EllrysDuskhallow_Immolate 44267
#define EllrysDuskhallow_ShadowBolt 12471
#define EllrysDuskhallow_CurseofAgony 14875
#define EllrysDuskhallow_Fear 38595
class Ellrys_DuskhallowAI : public MoonScriptBossAI
{
MOONSCRIPT_FACTORY_FUNCTION(Ellrys_DuskhallowAI, MoonScriptBossAI);
Ellrys_DuskhallowAI(Creature* pCreature) : MoonScriptBossAI(pCreature)
{
AddSpell(EllrysDuskhallow_Immolate, Target_Current, 75, 2, 15, 0, 30);
AddSpell(EllrysDuskhallow_ShadowBolt, Target_RandomPlayer, 75, 3, 5, 4, 40);
AddSpell(EllrysDuskhallow_CurseofAgony, Target_RandomPlayer, 75, 0, 4, 0, 30);
AddSpell(EllrysDuskhallow_Fear, Target_RandomPlayer, 75, 1.5, 9, 0, 20);
}
};
//Eramas Brightblaze
#define CN_EramasBrightblaze 24554
#define ERAMAS_BRIGHTBLAZE_KNOCKDOWN 11428
#define ERAMAS_BRIGHTBLAZE_SNAP_KICK 46182
class Eramas_BrightblazeAI : public MoonScriptBossAI
{
MOONSCRIPT_FACTORY_FUNCTION(Eramas_BrightblazeAI, MoonScriptBossAI);
Eramas_BrightblazeAI(Creature* pCreature) : MoonScriptBossAI(pCreature)
{
AddSpell(ERAMAS_BRIGHTBLAZE_KNOCKDOWN, Target_Current, 25, 0, 5, 0, 5);
AddSpell(ERAMAS_BRIGHTBLAZE_SNAP_KICK, Target_SecondMostHated, 40, 0, 2, 0, 5);
}
};
//Yazzai
#define CN_YAZZAI 24561
#define YAZZAI_POLYMORPH 13323
#define YAZZAI_ICE_BLOCK 27619
#define YAZZAI_BLIZZARD 44178
#define YAZZAI_CONE_OF_COLD 38384
#define YAZZAI_FROSTBOLT 15530
class YazzaiAI : public MoonScriptBossAI
{
MOONSCRIPT_FACTORY_FUNCTION(YazzaiAI, MoonScriptBossAI);
YazzaiAI(Creature* pCreature) : MoonScriptBossAI(pCreature)
{
AddSpell(YAZZAI_POLYMORPH, Target_RandomPlayer, 30, 1.5, 16, 0, 30);
AddSpell(YAZZAI_ICE_BLOCK, Target_Self, 20, 0, 300, 0, 1);
AddSpell(YAZZAI_BLIZZARD, Target_RandomPlayer, 25, 0, 20, 0, 30);
AddSpell(YAZZAI_CONE_OF_COLD, Target_Self, 10, 0, 19, 0, 1);
AddSpell(YAZZAI_FROSTBOLT, Target_RandomPlayer, 80, 3, 14, 0, 40);
}
};
//Warlord Salaris
#define CN_WARLORD_SALARIS 24559
#define WARLORD_SALARIS_INTERCEPT 27577
#define WARLORD_SALARIS_DISARM 27581
#define WARLORD_SALARIS_PIERCING_HOWL 23600
#define WARLORD_SALARIS_FRIGHTENING_SHOUT 19134
#define WARLORD_SALARIS_HAMSTRING 27584
//#define WARLORD_SALARIS_BATTLE_SHOUT 27578
#define WARLORD_SALARIS_MORTAL_STRIKE 44268
class Warlord_SalarisAI : public MoonScriptBossAI
{
MOONSCRIPT_FACTORY_FUNCTION(Warlord_SalarisAI, MoonScriptBossAI);
Warlord_SalarisAI(Creature* pCreature) : MoonScriptBossAI(pCreature)
{
//AddSpell(uint32 pSpellId, TargetType pTargetType, float pChance, float pCastTime, int32 pCooldown, float pMinRange, float pMaxRange
AddSpell(WARLORD_SALARIS_INTERCEPT, Target_RandomPlayer , 25, 0, 8, 8, 25 );
AddSpell(WARLORD_SALARIS_DISARM, Target_Current, 100, 0, 60, 0, 5 );
AddSpell(WARLORD_SALARIS_PIERCING_HOWL, Target_Self, 22, 0, 17, 0, 1);
AddSpell(WARLORD_SALARIS_FRIGHTENING_SHOUT, Target_RandomPlayer, 30, 0, 9, 0, 10);
AddSpell(WARLORD_SALARIS_HAMSTRING, Target_ClosestPlayer, 10, 0, 20, 0, 5);
AddSpell(WARLORD_SALARIS_MORTAL_STRIKE, Target_Current, 100, 0, 6, 0, 5);
}
};
//Geraxxas
#define CN_GARAXXAS 24555
#define GARAXXAS_AIMED_SHOT 44271
#define GARAXXAS_SHOOT 15620
#define GARAXXAS_CONCUSSIV_SHOT 27634
#define GARAXXAS_MULTI_SHOT 44285
#define GARAXXAS_WING_CLIP 44286
class GaraxxasAI : public MoonScriptBossAI
{
MOONSCRIPT_FACTORY_FUNCTION(GaraxxasAI, MoonScriptBossAI);
GaraxxasAI(Creature* pCreature) : MoonScriptBossAI(pCreature)
{
AddSpell(GARAXXAS_AIMED_SHOT, Target_RandomPlayer, 90, 3, 6, 5, 35);
AddSpell(GARAXXAS_SHOOT, Target_RandomPlayer, 90, 2.5, 5, 5, 30);
AddSpell(GARAXXAS_CONCUSSIV_SHOT, Target_RandomPlayer, 40, 0, 8, 5, 35);
AddSpell(GARAXXAS_MULTI_SHOT, Target_RandomPlayer, 25, 0, 12, 5, 30);
AddSpell(GARAXXAS_WING_CLIP, Target_Current, 30, 0, 9, 0, 5);
}
};
//Apoko
#define CN_APOKO 24553
#define APOKO_FROST_SHOCK 21401
#define APOKO_LESSER_HEALING_WAVE 44256
#define APOKO_PURGE 27626
class ApokoAI : public MoonScriptCreatureAI
{
MOONSCRIPT_FACTORY_FUNCTION(ApokoAI, MoonScriptCreatureAI);
ApokoAI(Creature* pCreature) : MoonScriptCreatureAI(pCreature)
{
AddSpell(APOKO_FROST_SHOCK, Target_RandomPlayer, 40, 0, 8, 0, 20);
AddSpell(APOKO_LESSER_HEALING_WAVE, Target_RandomFriendly, 50, 1.5, 10, 0, 40);
AddSpell(APOKO_PURGE, Target_RandomUnit, 20, 0, 40, 0, 30);
}
};
//Zelfan
#define CN_ZELFAN 24556
#define ZELFAN_GOBLIN_DRAGON_GUN 44272
#define ZELFAN_HIGH_EXPLOSIV_SHEEP 44276
#define ZELFAN_ROCKET_LAUNCH 44137
class ZelfanAI : public MoonScriptCreatureAI
{
MOONSCRIPT_FACTORY_FUNCTION(ZelfanAI, MoonScriptCreatureAI);
ZelfanAI(Creature* pCreature) : MoonScriptCreatureAI(pCreature)
{
AddSpell(ZELFAN_GOBLIN_DRAGON_GUN, Target_Current, 90, 0, 15, 0, 5);
AddSpell(ZELFAN_HIGH_EXPLOSIV_SHEEP, Target_Self, 90, 2, 80);
AddSpell(ZELFAN_ROCKET_LAUNCH, Target_RandomPlayer, 99, 3.5, 60, 0, 45);
}
};
//Trash mobs
//Coilskar Witch
#define CN_COILSKAR_WITCH 24696
#define COILSKAR_WITCH_FORKED_LIGHTNING 46150
#define COILSKAR_WITCH_FROST_ARROW 44639
#define COILSKAR_WITCH_MANA_SHIELD 46151
#define COILSKAR_WITCH_SHOOT 35946
class CoilskarWitchAI : public MoonScriptBossAI
{
MOONSCRIPT_FACTORY_FUNCTION(CoilskarWitchAI, MoonScriptBossAI);
CoilskarWitchAI(Creature* pCreature) : MoonScriptBossAI(pCreature)
{
AddSpell(COILSKAR_WITCH_FORKED_LIGHTNING, Target_Current, 60, 2, 12, 0, 30);
AddSpell(COILSKAR_WITCH_FROST_ARROW, Target_RandomPlayer, 15, 0, 16, 0, 40);
AddSpell(COILSKAR_WITCH_MANA_SHIELD, Target_Self, 6, 0, 40, 0, 0);
AddSpell(COILSKAR_WITCH_SHOOT, Target_RandomPlayer, 75, 1.5, 4, 5, 30);
}
};
//Sister of Torment
#define CN_SISTER_OF_TORMENT 24697
#define SISTER_OF_TORMENT_DEADLY_EMBRACE 44547
#define SISTER_OF_TORMENT_LASH_OF_PAIN 44640
class SisterOfTormentAI : public MoonScriptBossAI
{
MOONSCRIPT_FACTORY_FUNCTION(SisterOfTormentAI, MoonScriptBossAI);
SisterOfTormentAI(Creature* pCreature) : MoonScriptBossAI(pCreature)
{
AddSpell(SISTER_OF_TORMENT_LASH_OF_PAIN, Target_Current, 60, 0, 8, 0, 5);
AddSpell(SISTER_OF_TORMENT_DEADLY_EMBRACE, Target_RandomPlayer, 20, 1.5, 16, 0, 20);
}
};
//Sunblade Blood Knight
#define CN_SB_BLOOD_KNIGHT 24684
#define BLOOD_KNIGHT_HOLY_LIGHT 46029
#define BLOOD_KNIGHT_JUDGEMENT_OF_WRATH 44482
#define BLOOD_KNIGHT_SEAL_OF_WRATH 46030
class SunbladeBloodKnightAI : public MoonScriptBossAI
{
MOONSCRIPT_FACTORY_FUNCTION(SunbladeBloodKnightAI, MoonScriptBossAI);
SunbladeBloodKnightAI(Creature* pCreature) : MoonScriptBossAI(pCreature)
{
AddSpell(BLOOD_KNIGHT_JUDGEMENT_OF_WRATH, Target_Current, 20, 0, 30, 0, 5);
AddSpell(BLOOD_KNIGHT_SEAL_OF_WRATH, Target_Self, 99, 0, 30, 0, 0);
AddSpell(BLOOD_KNIGHT_HOLY_LIGHT, Target_Self, 10, 2, 30, 0, 40);
}
};
//Sunblade Imp
#define CN_SB_IMP 24815
#define IMP_FIREBOLT 44577
class SunbladeImpAI : public MoonScriptBossAI
{
MOONSCRIPT_FACTORY_FUNCTION(SunbladeImpAI, MoonScriptBossAI);
SunbladeImpAI(Creature* pCreature) : MoonScriptBossAI(pCreature)
{
AddSpell(IMP_FIREBOLT, Target_Current, 100, 2, (int32)2.5, 0, 30);
}
};
//Sunblade Mage Guard
#define CN_SB_MAGE_GUARD 24683
#define MAGE_GUARD_GLAVE_THROW 46028
#define MAGE_GUARD_MAGIC_DAMPENING_FIELD 44475
class SunbladeMageGuardAI : public MoonScriptBossAI
{
MOONSCRIPT_FACTORY_FUNCTION(SunbladeMageGuardAI, MoonScriptBossAI);
SunbladeMageGuardAI(Creature* pCreature) : MoonScriptBossAI(pCreature)
{
AddSpell(MAGE_GUARD_GLAVE_THROW, Target_Current, 60, 0, 25, 0, 5);
AddSpell(MAGE_GUARD_MAGIC_DAMPENING_FIELD, Target_RandomPlayer, 20, 1, 35, 0, 20);
}
};
//Sunblade Magister
#define CN_SB_MAGISTER 24685
#define MAGISTER_ARCANE_NOVA 46036
#define MAGISTER_FROSTBOLT 46035
class SunbladeMagisterAI : public MoonScriptBossAI
{
MOONSCRIPT_FACTORY_FUNCTION(SunbladeMagisterAI, MoonScriptBossAI);
SunbladeMagisterAI(Creature* pCreature) : MoonScriptBossAI(pCreature)
{
AddSpell(MAGISTER_FROSTBOLT, Target_Current, 65, 2, 4, 0, 30);
AddSpell(MAGISTER_ARCANE_NOVA, Target_Self, 12, 1.5, 40, 0, 0);
}
};
void SetupMagistersTerrace(ScriptMgr* pScriptMgr)
{
//Bosses
pScriptMgr->register_creature_script(BOSS_SelinFireheart, &SelinFireheartAI::Create);
pScriptMgr->register_creature_script(BOSS_VEXALLUS, &VexallusAI::Create);
pScriptMgr->register_creature_script(BOSS_Priestess_Delrissa, &Priestess_DelrissaAI::Create);
//Priestess Delrissa Encounter Creature AI
pScriptMgr->register_creature_script(CN_KaganiNightstrike, &Kagani_NightstrikeAI::Create);
pScriptMgr->register_creature_script(CN_EllrysDuskhallow, &Ellrys_DuskhallowAI::Create);
pScriptMgr->register_creature_script(CN_EramasBrightblaze, &Eramas_BrightblazeAI::Create);
pScriptMgr->register_creature_script(CN_YAZZAI, &YazzaiAI::Create);
pScriptMgr->register_creature_script(CN_WARLORD_SALARIS, &Warlord_SalarisAI::Create);
pScriptMgr->register_creature_script(CN_GARAXXAS, &GaraxxasAI::Create);
pScriptMgr->register_creature_script(CN_APOKO, &ApokoAI::Create);
pScriptMgr->register_creature_script(CN_ZELFAN, &ZelfanAI::Create);
//Trash Mobs
pScriptMgr->register_creature_script(CN_COILSKAR_WITCH, &CoilskarWitchAI::Create);
pScriptMgr->register_creature_script(CN_SISTER_OF_TORMENT, &SisterOfTormentAI::Create);
pScriptMgr->register_creature_script(CN_SB_IMP, &SunbladeImpAI::Create);
pScriptMgr->register_creature_script(CN_SB_MAGE_GUARD, &SunbladeMageGuardAI::Create);
pScriptMgr->register_creature_script(CN_SB_MAGISTER, &SunbladeMagisterAI::Create);
}
| [
"jozsab1@gmail.com"
] | jozsab1@gmail.com |
d19ea66f92953b50e3d7c58e43af0d2b5d2ce530 | eb1517897d7e9e372538b0982223b7ecaaff46b0 | /third_party/blink/renderer/modules/hid/hid.h | 318b581ed45bb2d888f0efbc66649f8145516549 | [
"BSD-3-Clause",
"LGPL-2.0-or-later",
"GPL-1.0-or-later",
"MIT",
"Apache-2.0",
"LicenseRef-scancode-warranty-disclaimer",
"LGPL-2.1-only",
"GPL-2.0-only",
"LGPL-2.0-only",
"BSD-2-Clause",
"LicenseRef-scancode-other-copyleft"
] | permissive | jiachengii/chromium | c93e9cfa8fb79d6a0b5e66848dc204e87236252c | ead0d3601849269629ff31de4daed20fce453ba7 | refs/heads/master | 2022-11-16T02:35:53.671352 | 2020-06-13T06:43:44 | 2020-06-13T06:43:44 | 271,964,385 | 0 | 0 | BSD-3-Clause | 2020-06-13T07:47:21 | 2020-06-13T07:47:21 | null | UTF-8 | C++ | false | false | 3,447 | h | // Copyright 2019 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.
#ifndef THIRD_PARTY_BLINK_RENDERER_MODULES_HID_HID_H_
#define THIRD_PARTY_BLINK_RENDERER_MODULES_HID_HID_H_
#include "services/device/public/mojom/hid.mojom-blink-forward.h"
#include "third_party/blink/public/mojom/hid/hid.mojom-blink.h"
#include "third_party/blink/renderer/bindings/core/v8/script_promise.h"
#include "third_party/blink/renderer/core/dom/events/event_target.h"
#include "third_party/blink/renderer/core/execution_context/execution_context_lifecycle_observer.h"
#include "third_party/blink/renderer/platform/bindings/script_wrappable.h"
#include "third_party/blink/renderer/platform/heap/handle.h"
#include "third_party/blink/renderer/platform/mojo/heap_mojo_remote.h"
#include "third_party/blink/renderer/platform/mojo/heap_mojo_wrapper_mode.h"
#include "third_party/blink/renderer/platform/scheduler/public/frame_or_worker_scheduler.h"
namespace blink {
class ExecutionContext;
class HIDDevice;
class HIDDeviceRequestOptions;
class ScriptPromiseResolver;
class ScriptState;
class HID : public EventTargetWithInlineData, public ExecutionContextClient {
DEFINE_WRAPPERTYPEINFO();
USING_GARBAGE_COLLECTED_MIXIN(HID);
public:
explicit HID(ExecutionContext& context);
~HID() override;
// EventTarget:
ExecutionContext* GetExecutionContext() const override;
const AtomicString& InterfaceName() const override;
// Web-exposed interfaces:
DEFINE_ATTRIBUTE_EVENT_LISTENER(connect, kConnect)
DEFINE_ATTRIBUTE_EVENT_LISTENER(disconnect, kDisconnect)
ScriptPromise getDevices(ScriptState*, ExceptionState&);
ScriptPromise requestDevice(ScriptState*,
const HIDDeviceRequestOptions*,
ExceptionState&);
void Connect(const String& device_guid,
mojo::PendingRemote<device::mojom::blink::HidConnectionClient>
connection_client,
device::mojom::blink::HidManager::ConnectCallback callback);
void Trace(Visitor*) const override;
protected:
// EventTarget:
void AddedEventListener(const AtomicString& event_type,
RegisteredEventListener&) override;
private:
// Returns the HIDDevice matching |info| from |device_cache_|. If the device
// is not in the cache, a new device is created and added to the cache.
HIDDevice* GetOrCreateDevice(device::mojom::blink::HidDeviceInfoPtr info);
// Opens a connection to HidService, or does nothing if the connection is
// already open.
void EnsureServiceConnection();
void OnServiceConnectionError();
void FinishGetDevices(ScriptPromiseResolver*,
Vector<device::mojom::blink::HidDeviceInfoPtr>);
void FinishRequestDevice(ScriptPromiseResolver*,
Vector<device::mojom::blink::HidDeviceInfoPtr>);
HeapMojoRemote<mojom::blink::HidService,
HeapMojoWrapperMode::kWithoutContextObserver>
service_;
HeapHashSet<Member<ScriptPromiseResolver>> get_devices_promises_;
HeapHashSet<Member<ScriptPromiseResolver>> request_device_promises_;
HeapHashMap<String, WeakMember<HIDDevice>> device_cache_;
FrameOrWorkerScheduler::SchedulingAffectingFeatureHandle
feature_handle_for_scheduler_;
};
} // namespace blink
#endif // THIRD_PARTY_BLINK_RENDERER_MODULES_HID_HID_H_
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
f865172e89f71fddb2c2ea67cb5cef8b0cf99992 | a0b0eb383ecfeaeed3d2b0271657a0c32472bf8e | /lydsy/4802.cpp | dc803b3b47807cf4026fdda108a0a387bbdc5450 | [
"Apache-2.0"
] | permissive | tangjz/acm-icpc | 45764d717611d545976309f10bebf79c81182b57 | f1f3f15f7ed12c0ece39ad0dd044bfe35df9136d | refs/heads/master | 2023-04-07T10:23:07.075717 | 2022-12-24T15:30:19 | 2022-12-26T06:22:53 | 13,367,317 | 53 | 20 | Apache-2.0 | 2022-12-26T06:22:54 | 2013-10-06T18:57:09 | C++ | UTF-8 | C++ | false | false | 1,716 | cpp | #include <ctime>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
using namespace std;
typedef long long LL;
typedef long double DB;
const int maxs = 16, maxm = 1 << 16, maxt = 10;
int cnt, sum;
LL n, pp[maxs], sei[maxs], ans[maxm];
LL mod_add(LL x, LL y, LL p)
{
return (x += y) < p ? x : x - p;
}
LL mod_mul(LL x, LL y, LL p)
{
return (x = x * y - (LL)((DB)x * y / p + 0.001) * p) < 0 ? x + p : x;
}
LL mod_pow(LL x, LL k, LL p)
{
LL ret = 1;
for( ; k > 0; k >>= 1, x = mod_mul(x, x, p))
if(k & 1)
ret = mod_mul(ret, x, p);
return ret;
}
bool miller_rabin(LL n)
{
if(n == 2)
return 1;
if(n < 2 || !(n & 1))
return 0;
LL s = 0, r = n - 1;
for( ; !(r & 1); r >>= 1, ++s);
for(int i = 0; i < maxt; ++i)
{
LL cur = mod_pow(rand() % (n - 2) + 2, r, n), nxt;
for(int j = 0; j < s; ++j)
{
nxt = mod_mul(cur, cur, n);
if(nxt == 1 && cur != 1 && cur != n - 1)
return 0;
cur = nxt;
}
if(cur != 1)
return 0;
}
return 1;
}
LL pollard_rho(LL n)
{
LL x = (LL)rand() * rand() % n, y = x, c = (LL)rand() * rand() % n, r;
for(LL i = 1, k = 2; ; ++i)
{
if(i == k)
{
y = x;
k <<= 1;
}
x = mod_add(mod_mul(x, x, n), c, n);
r = __gcd(abs(y - x), n);
if(r != 1)
return r;
}
}
void decomposition(LL n)
{
if(miller_rabin(n))
{
bool flag = 0;
for(int i = 0; i < cnt; ++i)
if(n == pp[i])
{
flag = 1;
break;
}
if(!flag)
pp[cnt++] = n;
}
else
{
LL fact;
while((fact = pollard_rho(n)) == n);
decomposition(fact);
decomposition(n / fact);
}
}
int main()
{
scanf("%lld", &n);
if(n == 1)
{
puts("1");
return 0;
}
decomposition(n);
for(int i = 0; i < cnt; ++i)
n -= n / pp[i];
printf("%lld\n", n);
return 0;
}
| [
"t251346744@gmail.com"
] | t251346744@gmail.com |
5da31f9d3c8770bf59ab4676c8fc0271a7c24e4e | fb7efe44f4d9f30d623f880d0eb620f3a81f0fbd | /third_party/WebKit/Source/core/dom/NodeIteratorBase.h | e21d76c5b034e50906fa44ac4dbd62ee8eb05178 | [
"BSD-3-Clause",
"BSD-2-Clause",
"LGPL-2.1-only",
"LGPL-2.0-only",
"LGPL-2.0-or-later",
"GPL-1.0-or-later",
"MIT",
"Apache-2.0",
"LicenseRef-scancode-warranty-disclaimer",
"GPL-2.0-only",
"LicenseRef-scancode-other-copyleft"
] | permissive | wzyy2/chromium-browser | 2644b0daf58f8b3caee8a6c09a2b448b2dfe059c | eb905f00a0f7e141e8d6c89be8fb26192a88c4b7 | refs/heads/master | 2022-11-23T20:25:08.120045 | 2018-01-16T06:41:26 | 2018-01-16T06:41:26 | 117,618,467 | 3 | 2 | BSD-3-Clause | 2022-11-20T22:03:57 | 2018-01-16T02:09:10 | null | UTF-8 | C++ | false | false | 1,896 | h | /*
* Copyright (C) 1999 Lars Knoll (knoll@kde.org)
* Copyright (C) 2000 Frederik Holljen (frederik.holljen@hig.no)
* Copyright (C) 2001 Peter Kelly (pmk@post.com)
* Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
* Copyright (C) 2004, 2008 Apple Inc. All rights reserved.
*
* 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., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*
*/
#ifndef NodeIteratorBase_h
#define NodeIteratorBase_h
#include "platform/bindings/TraceWrapperMember.h"
#include "platform/heap/Handle.h"
namespace blink {
class ExceptionState;
class Node;
class V8NodeFilterCondition;
class NodeIteratorBase : public GarbageCollectedMixin {
public:
Node* root() const { return root_.Get(); }
unsigned whatToShow() const { return what_to_show_; }
V8NodeFilterCondition* filter() const { return filter_.Get(); }
DECLARE_VIRTUAL_TRACE();
DECLARE_VIRTUAL_TRACE_WRAPPERS();
protected:
NodeIteratorBase(Node*, unsigned what_to_show, V8NodeFilterCondition*);
unsigned AcceptNode(Node*, ExceptionState&) const;
private:
Member<Node> root_;
unsigned what_to_show_;
TraceWrapperMember<V8NodeFilterCondition> filter_;
};
} // namespace blink
#endif // NodeIteratorBase_h
| [
"jacob-chen@iotwrt.com"
] | jacob-chen@iotwrt.com |
a176f963724d34018e27d1db1206f2abd6fdcad0 | 9f7a5e5c6dfce8daa9c6c748c61851a5e8b1464b | /034_QWidget/testWidget01/build/ui_newfile.h | 0d2f41b23d097a20e628a247db58837ee0bde1ec | [] | no_license | jash-git/Jash_QT | fdaf4eb2d6575d19ed17f35c57af25940f80554d | 5e44333512e048649e6b7038428487348fda52aa | refs/heads/master | 2023-05-28T11:24:23.585919 | 2021-06-06T12:43:10 | 2021-06-06T12:43:10 | 372,838,837 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,224 | h | /********************************************************************************
** Form generated from reading ui file 'newfile.ui'
**
** Created: Sun Aug 22 15:52:29 2010
** by: Qt User Interface Compiler version 4.5.0
**
** WARNING! All changes made in this file will be lost when recompiling ui file!
********************************************************************************/
#ifndef UI_NEWFILE_H
#define UI_NEWFILE_H
#include <QtCore/QVariant>
#include <QtGui/QAction>
#include <QtGui/QApplication>
#include <QtGui/QButtonGroup>
#include <QtGui/QHeaderView>
#include <QtGui/QWidget>
QT_BEGIN_NAMESPACE
class Ui_Form
{
public:
void setupUi(QWidget *Form)
{
if (Form->objectName().isEmpty())
Form->setObjectName(QString::fromUtf8("Form"));
Form->resize(400, 300);
retranslateUi(Form);
QMetaObject::connectSlotsByName(Form);
} // setupUi
void retranslateUi(QWidget *Form)
{
Form->setWindowTitle(QApplication::translate("Form", "Form", 0, QApplication::UnicodeUTF8));
Q_UNUSED(Form);
} // retranslateUi
};
namespace Ui {
class Form: public Ui_Form {};
} // namespace Ui
QT_END_NAMESPACE
#endif // UI_NEWFILE_H
| [
"jash.liao@gmail.com"
] | jash.liao@gmail.com |
68c9a892eec3970819f8c2bff34f5a57feb1d679 | 59c94d223c8e1eb1720d608b9fc040af22f09e3a | /zircon/system/ulib/minfs/test/inspector-test.cpp | 660dc0df0919dddf370cec6787a9a94814df75f3 | [
"BSD-3-Clause",
"MIT"
] | permissive | bootingman/fuchsia2 | 67f527712e505c4dca000a9d54d3be1a4def3afa | 04012f0aa1edd1d4108a2ac647a65e59730fc4c2 | refs/heads/master | 2022-12-25T20:28:37.134803 | 2019-05-14T08:26:08 | 2019-05-14T08:26:08 | 186,606,695 | 1 | 1 | BSD-3-Clause | 2022-12-16T21:17:16 | 2019-05-14T11:17:16 | C++ | UTF-8 | C++ | false | false | 6,899 | cpp | // Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Tests minfs inspector behavior.
#include <minfs/inspector.h>
#include "minfs-private.h"
#include "inspector-private.h"
#include <lib/disk-inspector/disk-inspector.h>
#include <zxtest/zxtest.h>
namespace minfs {
namespace {
// Mock InodeManager class to be used in inspector tests.
class MockInodeManager : public InspectableInodeManager {
public:
MockInodeManager();
MockInodeManager(const MockInodeManager&)= delete;
MockInodeManager(MockInodeManager&&) = delete;
MockInodeManager& operator=(const MockInodeManager&) = delete;
MockInodeManager& operator=(MockInodeManager&&) = delete;
void Load(ino_t inode_num, Inode* out) const final;
const Allocator* GetInodeAllocator() const final;
};
MockInodeManager::MockInodeManager() {}
void MockInodeManager::Load(ino_t inode_num, Inode* out) const {}
const Allocator* MockInodeManager::GetInodeAllocator() const {
return nullptr;
}
constexpr Superblock superblock = {};
// Mock Minfs class to be used in inspector tests.
class MockMinfs : public InspectableFilesystem {
public:
MockMinfs() = default;
MockMinfs(const MockMinfs&)= delete;
MockMinfs(MockMinfs&&) = delete;
MockMinfs& operator=(const MockMinfs&) = delete;
MockMinfs& operator=(MockMinfs&&) = delete;
const Superblock& Info() const {
return superblock;
}
const InspectableInodeManager* GetInodeManager() const final {
return nullptr;
}
const Allocator* GetBlockAllocator() const final {
return nullptr;
}
zx_status_t ReadBlock(blk_t start_block_num, void* out_data) const final {
return ZX_OK;
}
};
TEST(InspectorTest, TestRoot) {
auto fs = std::unique_ptr<MockMinfs>(new MockMinfs());
std::unique_ptr<RootObject> root_obj(new RootObject(std::move(fs)));
ASSERT_STR_EQ(kRootName, root_obj->GetName());
ASSERT_EQ(kRootNumElements, root_obj->GetNumElements());
// Superblock.
std::unique_ptr<disk_inspector::DiskObject> obj0 = root_obj->GetElementAt(0);
ASSERT_STR_EQ(kSuperBlockName, obj0->GetName());
ASSERT_EQ(kSuperblockNumElements, obj0->GetNumElements());
// Inode Table.
std::unique_ptr<disk_inspector::DiskObject> obj1 = root_obj->GetElementAt(1);
ASSERT_STR_EQ(kInodeTableName, obj1->GetName());
// Journal info.
std::unique_ptr<disk_inspector::DiskObject> obj2 = root_obj->GetElementAt(2);
ASSERT_STR_EQ(kJournalName, obj2->GetName());
ASSERT_EQ(kJournalNumElements, obj2->GetNumElements());
}
TEST(InspectorTest, TestInodeTable) {
auto inode_table_obj = std::unique_ptr<MockInodeManager>(new MockInodeManager());
std::unique_ptr<InodeTableObject> inode_mgr(new InodeTableObject(inode_table_obj.get(), 2));
ASSERT_STR_EQ(kInodeTableName, inode_mgr->GetName());
ASSERT_EQ(2, inode_mgr->GetNumElements());
std::unique_ptr<disk_inspector::DiskObject> obj0 = inode_mgr->GetElementAt(0);
ASSERT_STR_EQ(kInodeName, obj0->GetName());
ASSERT_EQ(kInodeNumElements, obj0->GetNumElements());
std::unique_ptr<disk_inspector::DiskObject> obj1 = inode_mgr->GetElementAt(1);
ASSERT_STR_EQ(kInodeName, obj1->GetName());
ASSERT_EQ(kInodeNumElements, obj1->GetNumElements());
}
TEST(InspectorTest, TestSuperblock) {
Superblock sb;
sb.magic0 = kMinfsMagic0;
sb.magic1 = kMinfsMagic1;
sb.version = kMinfsVersion;
sb.flags = kMinfsFlagClean;
sb.block_size = kMinfsBlockSize;
sb.inode_size = kMinfsInodeSize;
size_t size;
const void* buffer = nullptr;
std::unique_ptr<SuperBlockObject> superblock(new SuperBlockObject(sb));
ASSERT_STR_EQ(kSuperBlockName, superblock->GetName());
ASSERT_EQ(kSuperblockNumElements, superblock->GetNumElements());
std::unique_ptr<disk_inspector::DiskObject> obj0 = superblock->GetElementAt(0);
obj0->GetValue(&buffer, &size);
ASSERT_EQ(kMinfsMagic0, *(reinterpret_cast<const uint64_t*>(buffer)));
std::unique_ptr<disk_inspector::DiskObject> obj1 = superblock->GetElementAt(1);
obj1->GetValue(&buffer, &size);
ASSERT_EQ(kMinfsMagic1, *(reinterpret_cast<const uint64_t*>(buffer)));
std::unique_ptr<disk_inspector::DiskObject> obj2 = superblock->GetElementAt(2);
obj2->GetValue(&buffer, &size);
ASSERT_EQ(kMinfsVersion, *(reinterpret_cast<const uint32_t*>(buffer)));
std::unique_ptr<disk_inspector::DiskObject> obj3 = superblock->GetElementAt(3);
obj3->GetValue(&buffer, &size);
ASSERT_EQ(kMinfsFlagClean, *(reinterpret_cast<const uint32_t*>(buffer)));
std::unique_ptr<disk_inspector::DiskObject> obj4 = superblock->GetElementAt(4);
obj4->GetValue(&buffer, &size);
ASSERT_EQ(kMinfsBlockSize, *(reinterpret_cast<const uint32_t*>(buffer)));
std::unique_ptr<disk_inspector::DiskObject> obj5 = superblock->GetElementAt(5);
obj5->GetValue(&buffer, &size);
ASSERT_EQ(kMinfsInodeSize, *(reinterpret_cast<const uint32_t*>(buffer)));
}
TEST(InspectorTest, TestJournal) {
JournalInfo jinfo;
jinfo.magic = kJournalMagic;
auto info = std::make_unique <JournalInfo>(jinfo);
std::unique_ptr<JournalObject> journalObj(new JournalObject(std::move(info)));
ASSERT_STR_EQ(kJournalName, journalObj->GetName());
ASSERT_EQ(kJournalNumElements, journalObj->GetNumElements());
size_t size;
const void* buffer = nullptr;
std::unique_ptr<disk_inspector::DiskObject> obj0 = journalObj->GetElementAt(0);
obj0->GetValue(&buffer, &size);
ASSERT_EQ(kJournalMagic, *(reinterpret_cast<const uint64_t*>(buffer)));
}
TEST(InspectorTest, TestInode) {
Inode fileInode;
fileInode.magic = kMinfsMagicFile;
fileInode.size = 10;
fileInode.block_count = 2;
fileInode.link_count = 1;
std::unique_ptr<InodeObject> finodeObj(new InodeObject(fileInode));
ASSERT_STR_EQ(kInodeName, finodeObj->GetName());
ASSERT_EQ(kInodeNumElements, finodeObj->GetNumElements());
size_t size;
const void* buffer = nullptr;
std::unique_ptr<disk_inspector::DiskObject> obj0 = finodeObj->GetElementAt(0);
obj0->GetValue(&buffer, &size);
ASSERT_EQ(kMinfsMagicFile, *(reinterpret_cast<const uint32_t*>(buffer)));
std::unique_ptr<disk_inspector::DiskObject> obj1 = finodeObj->GetElementAt(1);
obj1->GetValue(&buffer, &size);
ASSERT_EQ(10, *(reinterpret_cast<const uint32_t*>(buffer)));
std::unique_ptr<disk_inspector::DiskObject> obj2 = finodeObj->GetElementAt(2);
obj2->GetValue(&buffer, &size);
ASSERT_EQ(2, *(reinterpret_cast<const uint32_t*>(buffer)));
std::unique_ptr<disk_inspector::DiskObject> obj3 = finodeObj->GetElementAt(3);
obj3->GetValue(&buffer, &size);
ASSERT_EQ(1, *(reinterpret_cast<const uint32_t*>(buffer)));
}
} // namespace
} // namespace minfs
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
27d5bdf9d25145be58502b632bff8b311b85be28 | cfbe32d3c679487610e0a8e924c33ab6aa64f3d1 | /codeforces/381B.cpp | b1399cf812c2a813d2ac3e0f53e1a88630cc0cf0 | [] | no_license | hophacker/algorithm_coding | 6062fafd00e276baeb5ef92198c6c1dab66b6184 | bfc9a124ed21eabf241590b90105427f0a2b6573 | refs/heads/master | 2020-06-04T00:41:25.378594 | 2014-07-07T00:50:35 | 2014-07-07T00:50:35 | 18,478,412 | 5 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,718 | cpp | #include <cmath>
#include <vector>
#include <map>
#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cassert>
using namespace std;
#define bit(x,i) (x&(1<<i))
#define max(a,b) (a<b?b:a)
#define abs(x) (x<0?-x:x)
#define IN(i,l,r) (l<i&&i<r)
#define LINR(i,l,r) (l<=i&&i<=r)
#define LIN(i,l,r) (l<=i&&i<r)
#define INR(i,l,r) (l<i&&i<r)
#define F(i,L,R) for (int i = L; i < R; i++)
#define FE(i,L,R) for (int i = L; i <= R; i++)
#define FF(i,L,R) for (int i = L; i > R; i--)
#define FFE(i,L,R) for (int i = L; i >= R; i--)
#define char2Int(c) (c-'0')
#define lastEle(vec) vec[vec.size()-1]
#define hBit(msb,n) asm("bsrl %1,%0" : "=r"(msb) : "r"(n))
#define clr(a,x) memset(a,x,sizeof(a))
#define getI(a) scanf("%d", &a)
#define getII(a,b) scanf("%d%d", &a, &b)
#define getIII(a,b,c) scanf("%d%d%d", &a, &b, &c)
#define getS(x) scanf("%s", x);
#define ll long long
#define ui unsigned int
#define us unsigned short
int main ( int argc, char *argv[] ) {
//ios_base::sync_with_stdio(0);
int N;
int a[100010];
int b[100010], bN = 0, c[100010], cN = 1;
getI(N);
F(i,0,N) getI(a[i]);
sort(a, a+N);
int count = 1, total = 1;
c[0] = a[0];
F(i,1,N) {
if (a[i] == a[i-1])
count++;
else count = 1;
if (count == 2){
b[bN++] = a[i];
total++;
} else if (count == 1){
c[cN++] = a[i];
total++;
}
}
if (b[bN-1] == c[cN-1]) total--, bN--;
cout << total << endl;
printf("%d", c[0]);
F(i,1,cN) printf(" %d", c[i]);
FFE(i,bN-1,0) printf(" %d", b[i]);
printf("\n");
return EXIT_SUCCESS;
}
| [
"jokerfeng2010@gmail.com"
] | jokerfeng2010@gmail.com |
730a9289e70893efe3ea3959d3f8c5c6eb3ed405 | 25fa9beca657e1c25ba6096a0f2e017219dd3773 | /include/VBE-Physics2D/Box2D/Dynamics/Joints/b2PulleyJoint.h | 4f986192acfc310d4f3b7a504b5416e4e6080bb0 | [] | no_license | Towerthousand/VBE-Physics2D | 527ec1e4b0f281f3b015cfa5f24031530946cac5 | 129f2db38fc8b0c3b9f6d6f9cf307d9691cb6aaa | refs/heads/master | 2021-01-01T20:01:06.442867 | 2015-01-19T23:38:17 | 2015-01-19T23:38:17 | 27,102,607 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,455 | h | /*
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
*
* 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 B2_PULLEY_JOINT_H
#define B2_PULLEY_JOINT_H
#include <VBE-Physics2D/Box2D/Dynamics/Joints/b2Joint.h>
const float32 b2_minPulleyLength = 2.0f;
/// Pulley joint definition. This requires two ground anchors,
/// two dynamic body anchor points, and a pulley ratio.
struct b2PulleyJointDef : public b2JointDef
{
b2PulleyJointDef()
{
type = e_pulleyJoint;
groundAnchorA.Set(-1.0f, 1.0f);
groundAnchorB.Set(1.0f, 1.0f);
localAnchorA.Set(-1.0f, 0.0f);
localAnchorB.Set(1.0f, 0.0f);
lengthA = 0.0f;
lengthB = 0.0f;
ratio = 1.0f;
collideConnected = true;
}
/// Initialize the bodies, anchors, lengths, max lengths, and ratio using the world anchors.
void Initialize(b2Body* bodyA, b2Body* bodyB,
const b2Vec2& groundAnchorA, const b2Vec2& groundAnchorB,
const b2Vec2& anchorA, const b2Vec2& anchorB,
float32 ratio);
/// The first ground anchor in world coordinates. This point never moves.
b2Vec2 groundAnchorA;
/// The second ground anchor in world coordinates. This point never moves.
b2Vec2 groundAnchorB;
/// The local anchor point relative to bodyA's origin.
b2Vec2 localAnchorA;
/// The local anchor point relative to bodyB's origin.
b2Vec2 localAnchorB;
/// The a reference length for the segment attached to bodyA.
float32 lengthA;
/// The a reference length for the segment attached to bodyB.
float32 lengthB;
/// The pulley ratio, used to simulate a block-and-tackle.
float32 ratio;
};
/// The pulley joint is connected to two bodies and two fixed ground points.
/// The pulley supports a ratio such that:
/// length1 + ratio * length2 <= constant
/// Yes, the force transmitted is scaled by the ratio.
/// Warning: the pulley joint can get a bit squirrelly by itself. They often
/// work better when combined with prismatic joints. You should also cover the
/// the anchor points with static shapes to prevent one side from going to
/// zero length.
class b2PulleyJoint : public b2Joint
{
public:
b2Vec2 GetAnchorA() const;
b2Vec2 GetAnchorB() const;
b2Vec2 GetReactionForce(float32 inv_dt) const;
float32 GetReactionTorque(float32 inv_dt) const;
/// Get the first ground anchor.
b2Vec2 GetGroundAnchorA() const;
/// Get the second ground anchor.
b2Vec2 GetGroundAnchorB() const;
/// Get the current length of the segment attached to bodyA.
float32 GetLengthA() const;
/// Get the current length of the segment attached to bodyB.
float32 GetLengthB() const;
/// Get the pulley ratio.
float32 GetRatio() const;
/// Get the current length of the segment attached to bodyA.
float32 GetCurrentLengthA() const;
/// Get the current length of the segment attached to bodyB.
float32 GetCurrentLengthB() const;
/// Dump joint to dmLog
void Dump();
/// Implement b2Joint::ShiftOrigin
void ShiftOrigin(const b2Vec2& newOrigin);
protected:
friend class b2Joint;
b2PulleyJoint(const b2PulleyJointDef* data);
void InitVelocityConstraints(const b2SolverData& data);
void SolveVelocityConstraints(const b2SolverData& data);
bool SolvePositionConstraints(const b2SolverData& data);
b2Vec2 m_groundAnchorA;
b2Vec2 m_groundAnchorB;
float32 m_lengthA;
float32 m_lengthB;
// Solver shared
b2Vec2 m_localAnchorA;
b2Vec2 m_localAnchorB;
float32 m_constant;
float32 m_ratio;
float32 m_impulse;
// Solver temp
int32 m_indexA;
int32 m_indexB;
b2Vec2 m_uA;
b2Vec2 m_uB;
b2Vec2 m_rA;
b2Vec2 m_rB;
b2Vec2 m_localCenterA;
b2Vec2 m_localCenterB;
float32 m_invMassA;
float32 m_invMassB;
float32 m_invIA;
float32 m_invIB;
float32 m_mass;
};
#endif
| [
"dani.torramilans@gmail.com"
] | dani.torramilans@gmail.com |
59c3436918d76cfe0142242d180624c2a51a5124 | 9f4b1f53e4541ffe546bc2d4607683a5f2cfa2db | /HostKernel/scancontrol/scancontrol.cpp | 6f17c85f370c3d714e3e7654a1d5b2def40ee861 | [] | no_license | CtScanMasters/HostProject | a2a63747719f3e6bbcd8600174e625c735cf9e05 | 4318def9ef836acccb70f2b9e94898a6c0383807 | refs/heads/master | 2020-03-10T20:22:43.881695 | 2018-06-22T18:48:51 | 2018-06-22T18:48:51 | 129,569,088 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,973 | cpp | #include "scancontrol.h"
#include <QDebug>
#include <QThread>
#include "hardwarecontrol/bcm2835.h"
ScanControl::ScanControl(QObject *parent)
{
setName("ScanControl: ");
logMessage(MSG_INFO, "build");
enableLogging(false);
m_numberOfArrays = 8;
m_numberOfSources = 8;
m_sourceMuxAddress = 127;
m_chipSelectPin1 = BCM2835_SPI_CS1;
m_EN_1 = RPI_V2_GPIO_P1_11;
m_A0_1 = RPI_V2_GPIO_P1_16;
m_A1_1 = RPI_V2_GPIO_P1_13;
m_A2_1 = RPI_V2_GPIO_P1_15;
m_sensorMuxAddress = 128;
m_chipSelectPin0 = BCM2835_SPI_CS0;
m_EN_0 = RPI_V2_GPIO_P1_35;
m_A0_0 = RPI_V2_GPIO_P1_36;
m_A1_0 = RPI_V2_GPIO_P1_37;
m_A2_0 = RPI_V2_GPIO_P1_38;
buildScanControl();
}
void ScanControl::doScan(quint8 startAddress, ScanData &scanData)
{
logMessage(MSG_INFO, QString("doScan: %1").arg(startAddress));
for(quint8 arrayAddress = startAddress; arrayAddress < (startAddress + 4); arrayAddress++)
{
for(quint8 sourceNumber = 0; sourceNumber < m_numberOfSources; sourceNumber++)
{
m_multiplexerSource->setChannel(arrayAddress);
m_sourceArrayManager->setSource(arrayAddress, sourceNumber);
bcm2835_delay(10);
scanData.addArrayScan(arrayAddress, sourceNumber);
m_sensorArrayManager->scanArray(arrayAddress, scanData);
}
m_sourceArrayManager->clearSource(arrayAddress);
}
}
void ScanControl::buildScanControl()
{
m_multiplexerSensor = new Multiplexer(m_sourceMuxAddress, m_EN_0, m_A0_0, m_A1_0, m_A2_0);
m_multiplexerSource = new Multiplexer(m_sensorMuxAddress, m_EN_1, m_A0_1, m_A1_1, m_A2_1);
m_chipSelectManager = new ChipSelectManager(m_multiplexerSource, m_chipSelectPin0, m_multiplexerSensor, m_chipSelectPin1);
m_sourceArrayManager = new SourceArrayManager(m_chipSelectManager);
m_sensorArrayManager = new SensorArrayManager(m_chipSelectManager);
m_sourceArrayManager->initialize();
}
| [
"dvdv@quicknet.nl"
] | dvdv@quicknet.nl |
111ff6d541f11e05c315b358ba47a6a06000e592 | 958488bc7f3c2044206e0358e56d7690b6ae696c | /c++/test.cpp | 06bf3a1aa590c61723afcaeab5df8520da90e16a | [] | no_license | possientis/Prog | a08eec1c1b121c2fd6c70a8ae89e2fbef952adb4 | d4b3debc37610a88e0dac3ac5914903604fd1d1f | refs/heads/master | 2023-08-17T09:15:17.723600 | 2023-08-11T12:32:59 | 2023-08-11T12:32:59 | 40,361,602 | 3 | 0 | null | 2023-03-27T05:53:58 | 2015-08-07T13:24:19 | Coq | UTF-8 | C++ | false | false | 342 | cpp | #include<functional>
class myclass {
private:
std::function<int(int,int)> func;
public:
myclass(std::function<int(int,int)> func):func(func){}
myclass(const myclass& other):func(other.func){}
int operator()(int a,int b){return func(a,b);};
};
int main(){
myclass a([](int i,int j){ return 2*i + j; });
return 0;
}
| [
"paul_ossientis@riseup.net"
] | paul_ossientis@riseup.net |
abb31211fca05bdb4d9b5517dff37eba5ef44732 | 3287ddd28c9c8c3e066ce3176018a1e354923cc9 | /RezillaSource/Rezilla_Src/Architecture/CRezillaPlugin.h | c8d06c0a3042a0390e17c40fb19209671677bc50 | [] | no_license | chrisballinger/rezilla | 9e6bf9f0343712fae0a6fd5931259a48e7e5ec2b | 72c4cfd1a2d45565d2b429bd6afff8bf426f5c65 | refs/heads/master | 2021-05-11T09:31:21.967833 | 2018-01-19T04:24:33 | 2018-01-19T04:24:33 | 118,075,864 | 8 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,024 | h | // ===========================================================================
// CRezillaPlugin.h
//
// Created: 2005-09-26 09:48:26
// Last modification: 2006-11-25 07:31:00
// Author: Bernard Desgraupes
// e-mail: <bdesgraupes@sourceforge.users.fr>
// www: <http://rezilla.sourceforge.net/>
// (c) Copyright: Bernard Desgraupes, 2005-2006
// All rights reserved.
// ===========================================================================
#ifndef _H_CRezillaPlugin
#define _H_CRezillaPlugin
#pragma once
#include "RezillaPluginInterface.h"
#include <LModelObject.h>
class CRezMap;
class CRezillaPlugin : public LModelObject {
public:
CRezillaPlugin(CFBundleRef inBundleRef);
virtual ~CRezillaPlugin();
OSErr Load();
Boolean IsSupported(ResType inType);
CRezMap * OpenResources();
UInt8 CreateMenus(UInt8 inMenuCount, MenuID * inMenuIDs);
virtual SPluginEditorInterface** GetInterface() {return mInterface;}
virtual CFPlugInRef GetPluginRef() { return mPluginRef;}
virtual short GetRefnum() { return mRefNum;}
UInt32 CountEditTypes() { return mEditTypes.GetCount(); }
// AppleEvents
virtual void MakeSelfSpecifier(
AEDesc& inSuperSpecifier,
AEDesc& outSelfSpecifier) const;
virtual void GetAEProperty(
DescType inProperty,
const AEDesc& inRequestedType,
AEDesc& outPropertyDesc) const;
virtual bool AEPropertyExists(
DescType inProperty) const;
static SInt32 GetAEPosition(const CRezillaPlugin * inPlugin);
// Accessors
TArray<OSType> * GetEditTypes() { return &mEditTypes;}
TArray<LMenu*> * GetMenusList() { return &mMenusList;}
CFStringRef GetName() { return mName;}
UInt32 GetPluginType() { return mPluginType;}
UInt32 GetPluginCreator() { return mPluginCreator;}
UInt32 GetPluginVersion() { return mPluginVersion;}
UInt32 GetPluginRole() { return mPluginRole;}
Boolean IsLoaded() { return mIsLoaded;}
IconRef GetIconRef() { return mIconRef;}
protected:
CFPlugInRef mPluginRef;
short mRefNum;
SPluginEditorInterface ** mInterface;
TArray<OSType> mEditTypes;
TArray<LMenu*> mMenusList;
Boolean mMenusBuilt;
Boolean mIsLoaded; // differed loading
UInt32 mPluginType,
mPluginCreator,
mPluginVersion,
mPluginRole;
CFStringRef mName;
IconRef mIconRef;
private:
void Initialize(CFBundleRef inBundleRef);
};
// ===========================================================================
// Inline function definitions
// ===========================================================================
// ---------------------------------------------------------------------------
// IsSupported [inline] [public]
// ---------------------------------------------------------------------------
inline Boolean
CRezillaPlugin::IsSupported(ResType inType) { return mEditTypes.ContainsItem(inType); }
#endif
| [
"bdesgraupes@a0aff4df-974a-46cd-ba52-22e6818bbca1"
] | bdesgraupes@a0aff4df-974a-46cd-ba52-22e6818bbca1 |
c49ade43b9fad7aa56213033fcf5e61aeb435451 | 9c7c58220a546d583e22f8737a59e7cc8bb206e6 | /Project/MyProject/MyProject/Source/MyProject/Private/BaseFrame/Libs/Resource/ResLoad/LoadItem/DataAssetLoadItem.cpp | 2cb73a83ec01edd2b416f37c0d049d80e1050ad9 | [] | no_license | SiCoYu/UE | 7176f9ece890e226f21cf972e5da4c3c4c4bfe41 | 31722c056d40ad362e5c4a0cba53b05f51a19324 | refs/heads/master | 2021-03-08T05:00:32.137142 | 2019-07-03T12:20:25 | 2019-07-03T12:20:25 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 886 | cpp | #include "MyProject.h"
#include "DataAssetLoadItem.h"
#include "MByteBuffer.h"
//UDataAssetLoadItem::UDataAssetLoadItem(const FObjectInitializer& ObjectInitializer)
// : Super(ObjectInitializer)
//{
//
//}
void UDataAssetLoadItem::loadFile(const FString& Filename)
{
// if the file has some data in it, read it in
if (IFileManager::Get().FileSize(*Filename) >= 0)
{
/*FString Text;
if (FFileHelper::LoadFileToString(Text, *Filename))
{
MByteBuffer* fileBU = new MByteBuffer(Text.GetAllocatedSize());
fileBU->writeBytes(TCHAR_TO_ANSI(Text.GetCharArray().GetData()), 0, Text.GetAllocatedSize());
}*/
TArray<uint8> arrayBuffer;
if (FFileHelper::LoadFileToArray(arrayBuffer, *Filename))
{
MByteBuffer* fileBU = MY_NEW MByteBuffer(arrayBuffer.GetAllocatedSize());
fileBU->writeBytes((char*)(arrayBuffer.GetData()), 0, arrayBuffer.GetAllocatedSize());
}
}
} | [
"kuangben2001@163.com"
] | kuangben2001@163.com |
12836861c1965856f16fc0300b0f5e47f05d5275 | f950882940764ace71e51a1512c16a5ac3bc47bc | /src/GisEngine/GeoDatabase/ShapefileRowCursor.h | bfd2cedc2d665310b0dd0c0049cbd3ef50744ee6 | [] | no_license | ViacheslavN/GIS | 3291a5685b171dc98f6e82595dccc9f235e67bdf | e81b964b866954de9db6ee6977bbdf6635e79200 | refs/heads/master | 2021-01-23T19:45:24.548502 | 2018-03-12T09:55:02 | 2018-03-12T09:55:02 | 22,220,159 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,253 | h | #ifndef GIS_ENGINE_GEO_DATABASE_SHAPEFILEROWCURSOR_H
#define GIS_ENGINE_GEO_DATABASE_SHAPEFILEROWCURSOR_H
#include "GeoDatabase.h"
#include "ShapefileUtils.h"
#include "CursorBase.h"
#include "../../EmbDB/DatasetLite/SpatialDataset.h"
namespace GisEngine
{
namespace GeoDatabase
{
class CShapefileFeatureClass;
class CShapefileRowCursor : ICursorBase<ICursor>
{
public:
typedef ICursorBase<ICursor> TBase;
CShapefileRowCursor(IQueryFilter* filter, bool recycling, CShapefileFeatureClass* fclass);
virtual ~CShapefileRowCursor();
public:
// IRowCursor
virtual bool NextRow(IRowPtr* row);
/*virtual IFieldSetPtr GetFieldSet() const {return IFieldSetPtr();}
virtual IFieldsPtr GetSourceFields() const {return IFieldsPtr();}
virtual bool IsFieldSelected(int index) const {return false;}*/
protected:
bool NextRowEx(IRowPtr* row, IRow* rowCache);
bool EOC();
bool FillRow(IRow* row);
void SimpleNext();
bool AlterShape(CommonLib::CGeoShape* pShape) const;
protected:
//IQueryFilterPtr m_pFilter;
int m_nCurrentRowID;
ShapefileUtils::SHPGuard* m_pShp;
ShapefileUtils::DBFGuard* m_pDbf;
/*std::vector<int> m_vecOids;
std::vector<int>::iterator m_RowIDIt;
IFieldsPtr m_pSourceFields;
std::vector<int> m_vecFieldsExists;
std::vector<int> m_vecActualFieldsIndexes;
std::vector<eDataTypes> m_vecActualFieldsTypes;
IRowPtr m_pCurrentRow;*/
ShapeLib::SHPObject* m_pCacheObject;
CommonLib::IGeoShapePtr m_pCacheShape;
int m_nRecordCount;
/*GisBoundingBox m_Extent;*/
CShapefileFeatureClass* m_pParentFC;
bool m_bInvalidCursor;
DatasetLite::IShapeFileIndexPtr m_pShapeIndex;
DatasetLite::IShapeCursorPtr m_pCursor;
//bool m_bRecycling;
// Spatial Queries
/*GisGeometry::IEnvelopePtr m_pExtentOutput;
GisGeometry::IEnvelopePtr m_pExtentSource;
bool m_bNeedTransform;
int m_nOidFieldIndex;
int m_nShapeFieldIndex;
int m_nAnnoFieldIndex;
eSpatialRel m_spatialRel;*/
};
}
}
#endif | [
"nk.viacheslav@gmail.com"
] | nk.viacheslav@gmail.com |
f6a9cb535c1730f3dc429a80f7ec3287deffac1b | c8b39acfd4a857dc15ed3375e0d93e75fa3f1f64 | /Engine/Plugins/Experimental/AlembicImporter/Source/ThirdParty/Alembic/alembic/lib/Alembic/AbcCoreOgawa/ArImpl.h | 0f17e1c3350be2dd35f5d7258ad3402b4fefe14a | [
"MIT",
"LicenseRef-scancode-proprietary-license",
"LicenseRef-scancode-unknown-license-reference",
"BSL-1.0"
] | permissive | windystrife/UnrealEngine_NVIDIAGameWorks | c3c7863083653caf1bc67d3ef104fb4b9f302e2a | b50e6338a7c5b26374d66306ebc7807541ff815e | refs/heads/4.18-GameWorks | 2023-03-11T02:50:08.471040 | 2022-01-13T20:50:29 | 2022-01-13T20:50:29 | 124,100,479 | 262 | 179 | MIT | 2022-12-16T05:36:38 | 2018-03-06T15:44:09 | C++ | UTF-8 | C++ | false | false | 4,386 | h | //-*****************************************************************************
//
// Copyright (c) 2013,
// Sony Pictures Imageworks Inc. and
// Industrial Light & Magic, a division of Lucasfilm Entertainment Company Ltd.
//
// 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 Sony Pictures Imageworks, nor
// Industrial Light & Magic, nor the names of their contributors may be used
// to endorse or promote products derived from this software without specific
// prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//-*****************************************************************************
#ifndef _Alembic_AbcCoreOgawa_ArImpl_h_
#define _Alembic_AbcCoreOgawa_ArImpl_h_
#include <Alembic/AbcCoreOgawa/Foundation.h>
#include <Alembic/AbcCoreOgawa/StreamManager.h>
namespace Alembic {
namespace AbcCoreOgawa {
namespace ALEMBIC_VERSION_NS {
//-*****************************************************************************
class OrData;
//-*****************************************************************************
class ArImpl
: public AbcA::ArchiveReader
, public Alembic::Util::enable_shared_from_this<ArImpl>
{
private:
friend class ReadArchive;
ArImpl( const std::string &iFileName,
size_t iNumStreams=1 );
ArImpl( const std::vector< std::istream * > & iStreams );
public:
virtual ~ArImpl();
//-*************************************************************************
// ABSTRACT FUNCTIONS
//-*************************************************************************
virtual const std::string &getName() const;
virtual const AbcA::MetaData &getMetaData() const;
virtual AbcA::ObjectReaderPtr getTop();
virtual AbcA::TimeSamplingPtr getTimeSampling( Util::uint32_t iIndex );
virtual AbcA::ArchiveReaderPtr asArchivePtr();
virtual AbcA::ReadArraySampleCachePtr getReadArraySampleCachePtr()
{
return AbcA::ReadArraySampleCachePtr();
}
virtual void
setReadArraySampleCachePtr( AbcA::ReadArraySampleCachePtr iPtr )
{
}
virtual AbcA::index_t getMaxNumSamplesForTimeSamplingIndex(
Util::uint32_t iIndex );
virtual Util::uint32_t getNumTimeSamplings()
{
return m_timeSamples.size();
}
virtual Util::int32_t getArchiveVersion()
{
return m_archiveVersion;
}
StreamIDPtr getStreamID();
const std::vector< AbcA::MetaData > & getIndexedMetaData();
private:
void init();
std::string m_fileName;
size_t m_numStreams;
Ogawa::IArchive m_archive;
Alembic::Util::weak_ptr< AbcA::ObjectReader > m_top;
Alembic::Util::shared_ptr < OrData > m_data;
Alembic::Util::mutex m_orlock;
Util::int32_t m_archiveVersion;
std::vector < AbcA::TimeSamplingPtr > m_timeSamples;
std::vector < AbcA::index_t > m_maxSamples;
ObjectHeaderPtr m_header;
StreamManager m_manager;
std::vector< AbcA::MetaData > m_indexMetaData;
};
} // End namespace ALEMBIC_VERSION_NS
using namespace ALEMBIC_VERSION_NS;
} // End namespace AbcCoreOgawa
} // End namespace Alembic
#endif
| [
"tungnt.rec@gmail.com"
] | tungnt.rec@gmail.com |
c08829a98acf67616a51bd8f99a995f0fe1d2454 | 7869cd658cc2bf4bcaa29d5295f33740c2384bae | /src/opengl/shader.hpp | 882d1a2590076b19a920ced8a4c4bb016d2d759b | [
"MIT"
] | permissive | geaz/emu-chip-8 | 19a5f8d3999c6f4b3648dfa1010d1593b4eadb0f | 82a768e363378d666a7e06245e598f77fa1fd555 | refs/heads/master | 2021-06-19T03:13:15.201775 | 2021-05-17T13:22:55 | 2021-05-17T13:22:55 | 207,106,803 | 35 | 5 | MIT | 2021-05-17T13:22:56 | 2019-09-08T12:06:51 | C++ | UTF-8 | C++ | false | false | 4,587 | hpp | // Shader Loader took from https://learnopengl.com
#pragma once
#ifndef SHADER_H
#define SHADER_H
#include <glad/glad.h>
#include <gtc/matrix_transform.hpp>
#include <gtc/type_ptr.hpp>
#include <string>
#include <fstream>
#include <sstream>
#include <iostream>
class Shader
{
public:
Shader() { }
Shader(const char* vertexPath, const char* fragmentPath)
{
std::string vertexCode;
std::string fragmentCode;
std::ifstream vShaderFile;
std::ifstream fShaderFile;
vShaderFile.exceptions (std::ifstream::failbit | std::ifstream::badbit);
fShaderFile.exceptions (std::ifstream::failbit | std::ifstream::badbit);
try
{
vShaderFile.open(vertexPath);
fShaderFile.open(fragmentPath);
std::stringstream vShaderStream, fShaderStream;
vShaderStream << vShaderFile.rdbuf();
fShaderStream << fShaderFile.rdbuf();
vShaderFile.close();
fShaderFile.close();
vertexCode = vShaderStream.str();
fragmentCode = fShaderStream.str();
}
catch (std::ifstream::failure e)
{
std::cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ" << std::endl;
}
const char* vShaderCode = vertexCode.c_str();
const char * fShaderCode = fragmentCode.c_str();
unsigned int vertex, fragment;
vertex = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertex, 1, &vShaderCode, NULL);
glCompileShader(vertex);
checkCompileErrors(vertex, "VERTEX");
fragment = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragment, 1, &fShaderCode, NULL);
glCompileShader(fragment);
checkCompileErrors(fragment, "FRAGMENT");
ID = glCreateProgram();
glAttachShader(ID, vertex);
glAttachShader(ID, fragment);
glLinkProgram(ID);
checkCompileErrors(ID, "PROGRAM");
glDeleteShader(vertex);
glDeleteShader(fragment);
}
void use()
{
glUseProgram(ID);
}
void setBool(const std::string &name, bool value)
{
int location = glGetUniformLocation(ID, name.c_str());
glUniform1i(location, (int)value);
}
void setInt(const std::string &name, int value)
{
int location = glGetUniformLocation(ID, name.c_str());
glUniform1i(location, value);
}
void setFloat(const std::string &name, float value)
{
int location = glGetUniformLocation(ID, name.c_str());
glUniform1f(location, value);
}
void setVec4(const std::string &name, float value1, float value2, float value3, float value4)
{
int location = glGetUniformLocation(ID, name.c_str());
glUniform4f(location, value1, value2, value3, value4);
}
void setMatrix4(const std::string &name, const glm::mat4 &matrix)
{
int location = glGetUniformLocation(ID, name.c_str());
glUniformMatrix4fv(location, 1, GL_FALSE, glm::value_ptr(matrix));
}
unsigned int ID;
private:
void checkCompileErrors(unsigned int shader, std::string type)
{
int success;
char infoLog[1024];
if (type != "PROGRAM")
{
glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
if (!success)
{
glGetShaderInfoLog(shader, 1024, NULL, infoLog);
std::cout << "ERROR::SHADER_COMPILATION_ERROR of type: " << type << "\n" << infoLog << "\n -- --------------------------------------------------- -- " << std::endl;
}
}
else
{
glGetProgramiv(shader, GL_LINK_STATUS, &success);
if (!success)
{
glGetProgramInfoLog(shader, 1024, NULL, infoLog);
std::cout << "ERROR::PROGRAM_LINKING_ERROR of type: " << type << "\n" << infoLog << "\n -- --------------------------------------------------- -- " << std::endl;
}
}
}
};
#endif
| [
"geaz@users.noreply.github.com"
] | geaz@users.noreply.github.com |
efe39af88a44b626de390e10f16920f875458c1c | bfa6d5324e2c6551064b36f7ffb9ec5c12877938 | /IEEEXTREME19/strictly.cpp | 18be51521d985872fb67566ed9674bb2e524aaa1 | [] | no_license | Bruno-Mascarenhas/competitive-programming | 6c1ff45418e589601bb347c5a86ff06d59fe1b41 | 93d35ed8abc825673cff57a3540d96f30e6c527b | refs/heads/master | 2021-06-15T05:43:36.961850 | 2021-04-18T05:20:37 | 2021-04-18T05:20:37 | 180,717,967 | 1 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 3,090 | cpp | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pi 3.1415926535897932384626
#define pb push_back
#define ff first
#define ss second
#define debug(x) cout << #x " = " << (x) << endl
#define DESYNC ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define endl '\n'
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int,int> pii;
typedef vector<pii> vii;
//Compilation flags // g++ -std=c++17 -O3 -Wshadow -Wall -fsanitize=address -fsanitize=undefined -D_GLIBCXX_DEBUG -g
struct point{
int x, y;
point(){};
point(int _x, int _y) : x(_x), y(_y) {};
bool operator<(const point &a) const{
return make_pair(x,y) < make_pair(a.x,a.y);
}
point operator+(const point &a){
return point(x + a.x, y + a.y);
}
point operator-(const point &a){
return point(x - a.x, y - a.y);
}
};
int dot(point a, point b){
return a.x*b.x + a.y*b.y;
}
int cross(point a, point b){
return a.x*b.y - a.y*b.x;
}
bool ccw(point a, point b, point c){
return cross(b-a,c-a) > 0;
}
bool intersect(point a, point b, point c, point d){
if(ccw(a,b,c) != ccw(a,b,d) && ccw(c,d,a) != ccw(c,d,b))
return true;
return false;
}
vector<point> ConvexHull(vector<point> points){
int n = points.size(), k = 0;
sort(points.begin(),points.end());
vector<point> ans(2*n);
for(int i=0; i<n; i++){
while(k>=2 && !ccw(ans[k-2],ans[k-1],points[i])) k--;
ans[k++] = points[i];
}
for(int i=n-2, t=k+1; i>=0; i--){
while(k>=t && !ccw(ans[k-2],ans[k-1],points[i])) k--;
ans[k++] = points[i];
}
ans.resize(k);
return ans;
}
bool onSegment(point a, point b, point c){
int crossproduct = (c.y - a.y) * (b.x - a.x) - (c.x - a.x) * (b.y - a.y);
if(crossproduct != 0) return false;
int dotproduct = (c.x - a.x) * (b.x - a.x) + (c.y - a.y)*(b.y - a.y);
if(dotproduct < 0) return false;
int squaredlengthba = (b.x - a.x)*(b.x - a.x) + (b.y - a.y)*(b.y - a.y);
if(dotproduct > squaredlengthba) return false;
return true;
}
int n, m;
int32_t main(){
DESYNC;
cin>>n>>m;
vector<point> hull(n), pts(m);
for(auto &x:hull) cin>>x.x>>x.y;
for(auto &x:pts) cin>>x.x>>x.y;
vector<point> polygon = ConvexHull(hull);
int ans=0;
map<pair<point,point>,int> cnt;
for(int i=0; i<m; i++)
for(int j=0; j<m; j++)
if(i!=j){
bool f = 1;
for(int k=1; k<n; k++)
if(intersect(pts[i],pts[j],polygon[k],polygon[k-1]) || onSegment(pts[i],pts[j],polygon[k]) || onSegment(pts[i],pts[j],polygon[k-1])){
f=0; break;
}
if(f){
if(cnt[{pts[i],pts[j]}]==0 && cnt[{pts[j],pts[i]}]==0){
ans++;
cnt[{pts[i],pts[j]}]=1;
//cout<<pts[i].x<<" "<<pts[i].y<<" "<<pts[j].x<<" "<<pts[j].y<<endl;
}
}
}
cout<<ans<<endl;
}
| [
"brunomasck@gmail.com"
] | brunomasck@gmail.com |
cb6940110e61d69dcad453507231659c810ae2bb | c901b8389d196012f3cd1a3230ead6c2fc46a89b | /code/Karplus-Strong Synth/Karplus-Strong Synth.ino | 2b8192601855956ba03847efa65c116e3c3e32d6 | [] | no_license | Marquets/SMC-Master-Thesis | 99ec41ec69bf3a40a168a8f334f65e10f0989ac3 | 675ace2cd14dfeb4151baf9b901f69a042bf03a1 | refs/heads/master | 2023-01-31T10:35:27.432119 | 2020-12-17T13:55:57 | 2020-12-17T13:55:57 | 296,834,085 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,403 | ino | #include <Audio.h>
#include <Wire.h>
#include <SD.h>
#include <SPI.h>
#include <SerialFlash.h>
#include "modularInterpInstrMIDI.h"
#include <ResponsiveAnalogRead.h>
modularInterpInstrMIDI karplus;
AudioOutputI2S out;
AudioControlSGTL5000 audioShield;
AudioAmplifier amp1;
AudioConnection patchCord0(karplus,0,amp1,0);
AudioConnection patchCord1(amp1,0,out,0);
AudioConnection patchCord2(amp1,0,out,1);
//Mux 1 control pins for analog signal (Sig_pin)
const int S0 = 0;
const int S1 = 1;
const int S2 = 2;
const int S3 = 3;
// Mux 1 in "SIG" pin default
const int SIG_PIN = A0;
//Mux 2 control pins for analog signal (Sig_pin)
const int W0 = 19;
const int W1 = 18;
const int W2 = 17;
const int W3 = 16;
// Mux 2 in "SIG" pin default
const int WIG_PIN = 22;
//Array of values for selecting the disered channel of the multiplexers
const boolean muxChannel[16][4] = {
{0, 0, 0, 0}, //channel 0
{1, 0, 0, 0}, //channel 1
{0, 1, 0, 0}, //channel 2
{1, 1, 0, 0}, //channel 3
{0, 0, 1, 0}, //channel 4
{1, 0, 1, 0}, //channel 5
{0, 1, 1, 0}, //channel 6
{1, 1, 1, 0}, //channel 7
{0, 0, 0, 1}, //channel 8
{1, 0, 0, 1}, //channel 9
{0, 1, 0, 1}, //channel 10
{1, 1, 0, 1}, //channel 11
{0, 0, 1, 1}, //channel 12
{1, 0, 1, 1}, //channel 13
{0, 1, 1, 1}, //channel 14
{1, 1, 1, 1} //channel 15
};
float lowestNotes[] = {41.204 * 4, 55 * 4 , 73.416 * 4 , 97.999 * 4};
float previous_note = 0;
float just_intonation[] = {1,(float)256/243,(float)9/8,(float)32/27,(float)81/64,(float)4/3,(float)729/512,(float)3/2,(float)128/81,(float)27/16,(float)16/9,(float)243/128,2};
float shruti[] = {1,(float)256/243,(float)16/15,(float)10/9,(float)9/8,(float)32/27,(float)6/5,(float)5/4,(float)81/64,(float)4/3,(float)27/20,(float)45/32,(float)729/512,(float)3/2,
(float)128/81, (float)8/5, (float) 5/3, (float)27/16, (float)16/9, (float)9/5, (float)15/8, (float)243/128,2};
float quarter_tone[] = {1,(float)33/32,(float)17/16,(float)12/11,(float)9/8,(float)22/19,(float)19/16,(float)11/9,(float)24/19,(float) 22/17,(float)4/3,(float)11/8,(float)17/12,(float)16/11,
(float)3/2, (float)17/11, (float) 19/12, (float)18/11, (float)32/19, (float)16/9, (float)11/6, (float)33/17,2};
void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
AudioMemory(15);
pinMode(S0, OUTPUT);
pinMode(S1, OUTPUT);
pinMode(S2, OUTPUT);
pinMode(S3, OUTPUT);
pinMode(SIG_PIN, INPUT);
pinMode(W0, OUTPUT);
pinMode(W1, OUTPUT);
pinMode(W2, OUTPUT);
pinMode(W3, OUTPUT);
//pinMode(WIG_PIN, INPUT);
digitalWrite(S0, LOW);
digitalWrite(S1, LOW);
digitalWrite(S2, LOW);
digitalWrite(S3, LOW);
digitalWrite(W0, LOW);
digitalWrite(W1, LOW);
digitalWrite(W2, LOW);
digitalWrite(W3, LOW);
audioShield.enable();
audioShield.volume(0.9);
amp1.gain(0.5);
}
void loop() {
// put your main code here, to run repeatedly:
int i = 0;
while( i < 4) {
float freq = 0.0;
// Reading values from sensors and knobs
int index = map(readMux(0 + i*3), 0, 1023,0,12);
float fsr = map(readMux(1 + i*3), 0, 1023, 1.0, 2.0);
float fsr2 = map(readMux(2 + i*3), 0, 1023, -2.0, 1.0);
float pluck = (float) readMux2(6) / 1023;
float body_shape = (float) readMux2(7) / 1023;
float body_scale = (float) readMux2(5) / 1023;
int tonal = map(readMux2(4), 0, 1023, 0, 4);
// Applying the corresponding ratios depending on the tonal system
if ( tonal == 0) {
int index = map(readMux(0 + i*3), 0, 1023,0,12);
freq = lowestNotes[i] * just_intonation[index];
}
else if (tonal == 1) {
int index = map(readMux(0 + i*3), 0, 1023,0,21);
freq = lowestNotes[i] * shruti[index];
}
else if (tonal == 2) {
int index = map(readMux(0 + i*3), 0, 1023,0,22);
freq = lowestNotes[i] * quarter_tone[index];
}
else if (tonal == 3) {
freq = map(readMux(0 + i*3), 0, 1023,lowestNotes[i],lowestNotes[i] + (2 * 12));
}
else if (tonal == 4) {
freq = map(readMux(0 + i*3), 0, 1023,lowestNotes[i],lowestNotes[i] + (2 * 24));
}
if (freq > lowestNotes[i]) {
karplus.setParamValue("gate",1);
karplus.setParamValue("gain",0.5);
karplus.setParamValue("pluckPosition",pluck);
karplus.setParamValue("freq",freq);
//karplus.setParamValue("bend",fsr2);
karplus.setParamValue("shape",body_shape);
karplus.setParamValue("scale",body_scale);
//delay(20);
}
else {
audioShield.disable();
karplus.setParamValue("gain",0);
karplus.setParamValue("gate",0);
i++;
}
}
}
int readMux(byte channel){
byte controlPin[] = {S0, S1, S2, S3};
//byte controlPin2[] = {W0, W1, W2, W3};
for(int i = 0; i < 4; i ++){
digitalWrite(controlPin[i], muxChannel[channel][i]);
}
//read the value at the SIG pin
delayMicroseconds(50);
int val = analogRead(SIG_PIN);
//return the value
return val;
}
int readMux2(byte channel){
byte controlPin[] = {W0, W1, W2, W3};
for(int i = 0; i < 4; i ++){
digitalWrite(controlPin[i], muxChannel[channel][i]);
//Serial.println(muxChannel[channel][i]);
}
//read the value at the SIG pin
delayMicroseconds(50);
int val = analogRead(WIG_PIN);
//Serial.println(val);
//return the value
return val;
}
| [
"marcog07@ucm.es"
] | marcog07@ucm.es |
51e259fb0d051a8aed7733bf50f5fdfc7cdb6c70 | e87411251cd274762cfd542eb4a5dd7438d17d32 | /026-050/028_实现strStr()_L/main.cpp | 097023ffd64ca579c5436260bb5c131836f4f3e6 | [] | no_license | 7182514362/leetcode | 2356798bcb0693badd764106fcc341b56f914abc | 45ab9857ee4f4cd3f0e210034a6ab9a88f525837 | refs/heads/main | 2023-03-24T00:51:13.136609 | 2021-03-23T10:35:55 | 2021-03-23T10:35:55 | 350,672,432 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 190 | cpp | #include <iostream>
#include <vector>
using namespace std;
class Solution {
public:
int strStr(string haystack, string needle) {
}
};
int main(){
Solution sol;
return 0;
} | [
"2454024733@qq.com"
] | 2454024733@qq.com |
41ac0c8b5c0603ba461c25e151100d769bbfed16 | 08d19b0dcce1d0cf666c538a8ff289f8beca63b8 | /hdmap/ad_map/ad_map_access/impl/tests/generated/ad/map/lane/GeoBorderValidInputRangeTests.cpp | f1a4e3b2570f7720cc4ee052bea6fb03fd8c4a5e | [] | no_license | feiyuxiaoThu/IITS | faf8e84aeb8c4a412bc6f955149f9fdf0dd2d092 | 0f5cd710a6fff1c19795662f8032cb9e22575bd7 | refs/heads/main | 2023-06-26T11:19:22.680078 | 2021-07-29T11:26:59 | 2021-07-29T11:26:59 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,543 | cpp | /*
* ----------------- BEGIN LICENSE BLOCK ---------------------------------
*
* Copyright (C) 2018-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
* ----------------- END LICENSE BLOCK -----------------------------------
*/
/*
* Generated file
*/
#include <gtest/gtest.h>
#include <limits>
#include "ad/map/lane/GeoBorderValidInputRange.hpp"
TEST(GeoBorderValidInputRangeTests, testValidInputRange) {
::ad::map::lane::GeoBorder value;
::ad::map::point::GeoEdge valueLeft;
::ad::map::point::GeoPoint valueLeftElement;
::ad::map::point::Longitude valueLeftElementLongitude(-180);
valueLeftElement.longitude = valueLeftElementLongitude;
::ad::map::point::Latitude valueLeftElementLatitude(-90);
valueLeftElement.latitude = valueLeftElementLatitude;
::ad::map::point::Altitude valueLeftElementAltitude(-11000);
valueLeftElement.altitude = valueLeftElementAltitude;
valueLeft.resize(1, valueLeftElement);
value.left = valueLeft;
::ad::map::point::GeoEdge valueRight;
::ad::map::point::GeoPoint valueRightElement;
::ad::map::point::Longitude valueRightElementLongitude(-180);
valueRightElement.longitude = valueRightElementLongitude;
::ad::map::point::Latitude valueRightElementLatitude(-90);
valueRightElement.latitude = valueRightElementLatitude;
::ad::map::point::Altitude valueRightElementAltitude(-11000);
valueRightElement.altitude = valueRightElementAltitude;
valueRight.resize(1, valueRightElement);
value.right = valueRight;
ASSERT_TRUE(withinValidInputRange(value));
}
| [
"dawei.wang@inceptio.ai"
] | dawei.wang@inceptio.ai |
31d630bf0802cbe8d6777972ba2de08a7d16b6a7 | 63c637fc2773ef46cd22e08e3334121512c31074 | /3wkSeries/Day1/ELBOW_CASES/elbow_tri/67/U | 0c49a226b21a55317fc2c9b84c5a85ae27a1720c | [] | no_license | asvogel/OpenFOAMEducation | 438f811ad47631a414f6016e643dd12792613828 | a1cf886fb6f9759eada7ecc34e62f97037ffd0e5 | refs/heads/main | 2023-09-03T17:26:24.525385 | 2021-11-05T18:08:49 | 2021-11-05T18:08:49 | 425,034,654 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 27,023 | /*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: 9
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class volVectorField;
location "67";
object U;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 1 -1 0 0 0 0];
internalField nonuniform List<vector>
918
(
(0.98516 -0.000507254 0)
(0.00501551 2.96625 0)
(0.00779814 0.888511 0)
(0.979704 0.00214567 0)
(-0.0121508 2.0624 3.76002e-20)
(-0.00704872 2.9488 -2.46022e-18)
(0.819586 1.16311 4.49282e-19)
(0.11566 0.0702736 -1.47368e-20)
(0.999909 -0.000276743 0)
(0.066285 0.731336 0)
(0.0112952 0.509249 0)
(0.732838 -0.00460443 0)
(0.0111099 2.93039 0)
(0.00251242 2.79518 0)
(-0.0179005 3.14916 7.80713e-19)
(-0.0218048 1.91486 8.46605e-21)
(0.282026 0.0499831 1.01778e-18)
(0.188829 1.14255 3.16779e-19)
(0.962725 0.00501674 0)
(0.00739593 0.479553 0)
(-0.0183333 0.0883392 -6.94125e-19)
(1.00197 -0.00497521 0)
(1.00023 -0.00978461 0)
(0.975738 -0.00643884 0)
(0.59843 0.0271489 0)
(0.0148453 2.64145 0)
(-0.014915 2.91002 9.04509e-19)
(0.00965293 0.936083 0)
(-0.0172778 1.17996 0)
(0.0114835 0.918951 0)
(-0.0143196 2.59402 0)
(-0.00109413 2.11665 -3.00294e-20)
(-0.0113419 1.89494 0)
(-0.0206023 2.98761 -8.84059e-23)
(-0.0166846 3.00529 1.91195e-18)
(0.00209747 3.00017 0)
(0.871384 -0.00965503 0)
(0.402724 0.933254 1.8006e-19)
(0.804628 1.17741 -5.13004e-19)
(0.956295 1.02267 5.57397e-19)
(0.67329 1.26922 -1.04105e-19)
(0.674195 1.24357 5.99284e-19)
(0.154023 0.124658 1.43769e-20)
(0.140615 0.0539558 0)
(1.15976 0.562833 0)
(0.128828 0.103979 6.53905e-20)
(0.0904799 0.0597136 -6.78524e-20)
(0.919908 -0.00745785 0)
(1.00027 0.000161336 0)
(0.999909 0.000338582 0)
(1.00363 -0.0077595 0)
(1.00096 -0.000918632 0)
(1.00017 3.70284e-05 0)
(0.0731823 1.82623 -7.72736e-19)
(0.0319521 0.946124 0)
(0.0997825 0.811601 0)
(0.0125018 0.895503 0)
(0.0390267 0.650625 0)
(0.00646731 2.01426 0)
(-0.00356445 0.80096 0)
(0.0117003 0.518792 0)
(-0.0025529 0.791789 0)
(0.00820381 0.499967 0)
(0.841737 -0.0156847 0)
(0.840626 0.0303262 0)
(0.762989 -0.0064826 0)
(0.801872 0.0311015 0)
(0.702155 0.00826204 0)
(0.0146825 3.00041 9.11818e-19)
(0.0114846 3.00807 0)
(0.00610497 3.00274 0)
(0.0135362 2.99737 1.03414e-23)
(0.00796236 2.95848 -1.35519e-18)
(0.0145043 2.98205 0)
(0.0108888 2.90354 0)
(0.024225 2.93089 2.07161e-24)
(0.00474526 2.82511 0)
(0.0302615 2.91661 0)
(-0.00465891 2.7453 0)
(0.305128 3.54205 0)
(-0.131623 3.62268 0)
(0.137684 3.23926 -7.26525e-19)
(-0.013637 2.97766 0)
(-0.0255911 1.98677 0)
(-0.00713227 2.16932 -8.35002e-21)
(-0.0157774 1.92304 2.67842e-21)
(0.346128 0.142874 -3.5345e-19)
(0.312363 0.0286859 -3.43483e-19)
(0.301198 0.148612 -1.05802e-18)
(0.24444 0.0577648 -6.87834e-19)
(0.229239 0.983272 0)
(0.272193 1.29329 -3.68057e-19)
(0.365625 1.22728 6.13828e-19)
(0.987434 0.00857289 0)
(0.941857 0.00582585 0)
(1.0003 0.000581049 0)
(1.00286 0.00930952 0)
(1.00301 0.00847168 -2.7437e-18)
(0.991908 0.00969568 2.07194e-18)
(-0.0100528 0.786207 0)
(0.00879199 0.488733 0)
(-0.0448073 1.00612 0)
(-0.0248684 0.8288 0)
(0.00585597 0.480787 0)
(-0.0292442 0.109287 2.14809e-19)
(0.0652507 0.072562 0)
(0.993554 -0.00837047 0)
(0.954466 -0.00653166 0)
(0.743691 0.0303459 0)
(0.680702 0.0246024 0)
(0.662559 0.0166124 0)
(0.971151 -0.00733572 0)
(0.593122 0.0713726 0)
(0.450922 -0.00991215 1.54105e-18)
(-0.037389 2.86138 6.67001e-19)
(0.0410415 2.90984 0)
(0.0535572 2.88631 0)
(-0.00452549 2.70066 0)
(-0.0131199 2.98526 8.5587e-19)
(-0.0178058 2.89508 0)
(-0.0153706 2.98806 -2.65491e-18)
(-0.0132942 2.92519 9.09053e-19)
(-0.0273202 1.34495 0)
(-0.00321909 1.37394 0)
(-0.00742369 2.13403 4.8447e-22)
(-0.00635448 2.09598 0)
(-0.0238953 1.9024 0)
(0.938629 -0.0073807 0)
(0.857545 -0.00997778 0)
(0.863292 0.00553932 0)
(0.949617 -0.0078082 0)
(0.884082 -0.00819316 0)
(0.514172 1.12619 -2.27381e-19)
(0.56334 1.17722 0)
(0.367332 0.878225 3.36079e-20)
(0.309984 0.736902 0)
(0.917245 1.06014 -1.53771e-19)
(1.03539 0.869398 3.12707e-19)
(0.358392 1.35443 0)
(0.525892 1.32507 0)
(0.548838 1.26384 0)
(0.120967 0.184775 -3.02111e-19)
(0.178375 0.127464 0)
(0.178241 0.0762959 1.91094e-19)
(1.00635 0.924004 0)
(1.08033 0.777925 0)
(1.10547 0.719473 -2.48649e-19)
(1.13917 0.622299 0)
(1.1898 0.406182 5.72833e-20)
(0.957772 -0.00869651 0)
(0.962521 -0.0100304 0)
(0.901769 -0.0079863 0)
(0.984206 -0.0091448 0)
(0.974716 -0.00932999 0)
(0.937141 -0.00637362 0)
(1.00019 0.00234019 0)
(1.0009 0.00141543 0)
(0.999909 0.000855268 0)
(0.0355654 2.07324 4.28208e-19)
(0.118817 1.76908 0)
(0.0181076 2.18714 6.58392e-19)
(0.0461038 1.88039 -5.49101e-19)
(0.106359 1.14843 -2.59401e-19)
(0.0494612 1.02758 0)
(0.143006 0.978663 0)
(0.00396802 0.851442 0)
(0.0160285 0.589104 0)
(-0.00107187 2.24228 -8.27645e-22)
(0.0157721 2.0187 0)
(-0.00196844 2.24475 -2.98479e-20)
(0.00779746 2.0236 4.65541e-20)
(-0.00112364 0.827529 0)
(-0.00397238 0.813068 0)
(0.0103339 0.544639 0)
(-0.00773745 0.78755 0)
(0.00645984 0.489686 0)
(0.938507 0.00980651 0)
(0.850319 -0.0146168 0)
(0.927671 0.000440253 0)
(0.842632 -0.0128787 0)
(0.811919 -0.00268516 0)
(0.89804 0.0232513 0)
(0.872903 0.0280934 0)
(0.788134 -0.00641462 0)
(0.00562792 3.06478 -8.49462e-21)
(0.0167338 3.05779 0)
(0.0146903 2.96901 0)
(0.00865226 2.87615 0)
(0.920731 3.95455 0)
(1.23407 3.28816 9.26507e-19)
(0.0690474 3.06995 0)
(-0.0292006 2.90275 0)
(-0.00856503 1.39577 0)
(-0.0306134 1.69558 0)
(-0.0174233 1.53007 0)
(-0.0301485 2.55223 -8.10599e-21)
(-0.013744 2.24339 0)
(-0.0198604 2.39113 0)
(-0.0017067 1.95034 8.8686e-22)
(-0.00370978 2.24077 -6.7646e-21)
(-0.00549766 2.20451 -2.88901e-21)
(-0.00958477 1.93519 0)
(0.398953 0.124595 5.39924e-19)
(0.361206 0.0180505 -5.29785e-19)
(0.258823 1.58506 0)
(0.277496 0.756316 -3.15672e-19)
(0.177078 1.67236 -1.04832e-18)
(0.225976 1.21996 1.05061e-18)
(0.901995 0.00636038 0)
(0.967386 0.0111377 0)
(0.974536 0.0108153 0)
(0.923287 0.00640794 0)
(-0.00920203 0.785315 0)
(-0.00862619 0.782168 0)
(0.00510365 0.484045 0)
(0.117439 0.089176 6.05619e-19)
(0.104961 0.077385 -7.1666e-19)
(0.0740941 0.0581365 0)
(1.09929 0.0863423 2.7039e-20)
(1.08138 0.0395582 0)
(1.01341 0.0400553 0)
(0.907415 -0.005439 0)
(0.451856 0.105376 0)
(0.511778 0.0873586 -2.46227e-18)
(0.406691 0.0116919 9.20658e-19)
(0.00867297 2.98071 7.16113e-19)
(-0.0328711 2.86525 4.65771e-20)
(0.00362426 3.05022 -1.79881e-20)
(0.0202331 3.04338 6.40246e-19)
(-0.015018 2.99658 2.98574e-20)
(-0.0129489 2.94949 -1.20155e-22)
(-0.0172537 3.01192 -5.5282e-19)
(0.0148689 3.02376 3.99939e-19)
(0.00737632 3.03679 -6.33365e-19)
(0.93407 -0.0011866 0)
(0.939519 -0.00317871 0)
(0.846061 -0.00945988 0)
(0.956508 0.0119277 0)
(0.942604 0.0132908 0)
(0.881567 0.00582302 0)
(0.916235 0.0182213 0)
(0.925656 0.0152589 0)
(0.838522 0.00159651 0)
(0.716616 1.40336 4.03019e-20)
(0.749918 1.51203 0)
(0.181394 0.315265 7.05337e-20)
(0.228533 0.668843 5.67811e-19)
(0.262351 0.720467 -3.31818e-19)
(0.263002 0.521232 6.60237e-19)
(0.346057 0.810928 1.59009e-18)
(0.140519 0.230038 3.75505e-19)
(0.257442 0.150806 7.27874e-19)
(0.215916 0.145146 1.88708e-19)
(0.211914 0.0683222 3.57395e-19)
(1.17884 0.464196 6.39608e-20)
(1.19443 0.257028 5.92499e-20)
(0.010269 2.23577 2.53589e-19)
(0.0403724 1.94854 0)
(0.970793 0.0293923 0)
(0.943429 0.013955 0)
(0.869186 -0.017883 0)
(0.0112262 3.07423 0)
(0.0195966 2.944 1.17052e-18)
(0.0164315 2.95626 0)
(0.00642808 2.85063 -1.16112e-18)
(0.00629378 3.09083 2.83866e-19)
(0.00727491 3.08271 0)
(0.782711 1.81354 -1.58892e-19)
(1.24194 2.48912 4.03775e-19)
(0.764707 1.95287 -1.22937e-18)
(0.0196977 2.98033 -6.1696e-19)
(0.0352854 2.99943 0)
(-0.0343238 2.87681 0)
(-0.00418399 2.22408 -1.3095e-20)
(-0.00328084 2.24512 9.74139e-21)
(0.00100256 1.98547 -7.22038e-21)
(0.278214 1.39434 1.0246e-18)
(0.23881 0.550701 -7.02554e-19)
(0.0638006 1.99793 7.62549e-19)
(0.135299 1.88416 -9.10215e-19)
(0.180221 1.51165 9.49578e-20)
(0.00205937 3.1186 -1.76899e-18)
(0.0164364 3.11794 1.89661e-18)
(-0.00914655 2.98106 7.85824e-19)
(-0.00357618 2.97737 -7.42256e-19)
(-0.0210438 2.88117 -8.00341e-19)
(0.00862517 3.0996 -2.10998e-18)
(0.00226201 3.10636 2.05994e-18)
(0.282094 0.695164 0)
(0.248361 0.684174 -1.18011e-18)
(0.0959326 0.225163 5.23936e-19)
(0.357745 0.938006 1.11226e-18)
(0.195647 0.276051 -1.71484e-18)
(1.186 0.175131 6.27487e-20)
(1.19485 0.311684 0)
(1.17438 0.122817 -6.10052e-21)
(0.00145375 2.25415 -1.47569e-21)
(0.00491112 2.24562 0)
(0.0245916 1.98413 0)
(0.340074 1.30317 -3.67884e-19)
(0.37477 1.1499 -7.99744e-19)
(0.210293 0.37801 1.42587e-18)
(1.00588 -0.0108285 0)
(1.00767 -0.00763373 5.06142e-19)
(-0.0227818 1.32552 0)
(-0.0392157 1.32443 0)
(1.00221 0.00351432 1.81172e-21)
(1.00366 0.00946974 1.03345e-18)
(-0.0184861 2.53671 1.02716e-20)
(-0.023882 2.57934 0)
(0.0345114 3.17706 4.07476e-19)
(0.390626 3.48402 0)
(1.1751 0.663637 -5.7161e-20)
(1.01285 0.0131427 -2.13515e-21)
(1.02134 -0.0102848 0)
(1.0017 0.000130699 7.86508e-23)
(0.113823 1.36983 0)
(0.143778 2.56856 0)
(0.0256087 1.31013 0)
(-0.000155361 2.62026 2.82308e-20)
(-0.0212786 2.5777 3.66127e-21)
(0.998274 0.029458 1.97781e-21)
(1.06313 0.00467414 0)
(1.09766 0.0251535 0)
(-0.02917 1.73846 0)
(-0.0184715 2.57951 0)
(-0.00514271 1.31179 0)
(0.311598 1.48196 -1.68375e-19)
(1.0113 -0.00961516 0)
(1.0094 -0.0149146 0)
(1.00237 0.000753823 6.46837e-19)
(1.00547 -0.00479947 -7.60257e-19)
(1.00118 -0.000969412 0)
(-0.0144896 1.46294 0)
(-0.00727042 1.37424 0)
(-0.00800123 1.42027 0)
(-0.00911572 1.29944 0)
(-0.0188563 1.28659 0)
(-0.00967769 1.26953 0)
(1.03505 -0.00602544 0)
(1.0196 0.0155345 -8.29288e-22)
(0.821289 1.27348 2.60633e-19)
(1.00224 0.000320687 -6.44395e-19)
(1.00406 0.00526197 7.54392e-19)
(1.00118 0.00207567 0)
(1.01273 0.0103637 6.41284e-19)
(1.00798 0.00831438 -7.77017e-19)
(1.00856 0.0146969 0)
(-0.0236534 2.6074 0)
(-0.0256256 2.58694 -1.83727e-20)
(-0.0230132 2.60102 1.30588e-20)
(1.23779 0.268003 5.80024e-19)
(1.16254 0.0871461 0)
(0.0406833 3.0779 -9.11694e-19)
(0.0650128 2.85646 -6.63005e-20)
(0.138617 3.19224 1.39429e-18)
(0.133876 3.22005 -1.96989e-19)
(0.132883 3.23098 0)
(0.0198233 3.13731 2.35242e-19)
(0.0747237 3.16013 8.99088e-19)
(0.0675757 3.18524 -4.43445e-19)
(0.0221762 3.13002 0)
(0.583761 0.282446 0)
(0.51766 0.30171 0)
(1.14652 0.699691 1.29886e-19)
(1.14025 0.821094 -1.13576e-19)
(1.20298 0.586524 0)
(1.23074 0.521037 0)
(1.01604 0.0133783 -1.19536e-18)
(1.01498 0.0142807 1.50056e-18)
(1.02539 -0.0098006 0)
(1.02345 -0.011847 0)
(1.00642 0.00263827 0)
(1.01041 0.00374704 0)
(1.00458 0.00186758 0)
(1.00978 0.00625405 0)
(1.00781 0.00596699 0)
(1.00451 0.00472023 0)
(0.102902 1.36834 0)
(0.0998501 1.33143 0)
(0.133119 1.40539 0)
(0.151153 1.41056 0)
(0.145501 2.59363 0)
(0.185236 2.66383 -4.23402e-19)
(0.101556 2.64896 0)
(0.0852782 2.65184 1.98347e-19)
(0.0387986 2.67478 -1.48766e-19)
(0.013678 1.32178 0)
(0.0215762 1.24478 0)
(0.0183093 1.33188 0)
(0.0359973 1.26906 0)
(0.0042549 1.98377 3.41406e-21)
(-0.020081 2.60538 -1.88577e-20)
(-0.00823512 2.66152 1.38333e-20)
(-0.0181405 2.68082 0)
(-0.0229889 2.61125 -4.71116e-21)
(-0.0231234 2.60617 1.29839e-20)
(0.0131103 1.98215 3.93969e-22)
(-0.00696454 2.39319 2.52996e-20)
(-0.012978 2.41537 -1.5689e-20)
(1.01113 0.0394285 1.2114e-18)
(1.00511 0.0185132 -1.50629e-18)
(1.00415 0.0457471 -1.23331e-18)
(0.977125 0.0364443 1.55201e-18)
(1.06436 0.00849413 0)
(1.04947 -0.00821689 0)
(1.09462 0.0353333 0)
(1.07452 0.0130623 0)
(1.07235 0.00059398 0)
(1.14057 0.0835875 0)
(1.1121 0.0448552 0)
(1.11597 0.0327002 0)
(-0.0254262 2.42966 1.04771e-21)
(-0.0140389 2.01225 0)
(-0.0168084 2.21487 0)
(-0.0203578 2.60013 -1.08192e-20)
(-0.0175641 2.61008 1.89719e-22)
(0.00295825 1.57437 -3.568e-20)
(-0.00602479 1.50256 3.63505e-20)
(-0.0154776 1.39137 0)
(-0.0190699 1.39801 0)
(-0.0241841 1.39265 0)
(-0.00336636 1.31294 0)
(0.00923382 1.23812 0)
(0.386434 1.49931 2.73977e-19)
(0.429711 1.50013 1.45158e-19)
(0.597479 2.44405 -2.40263e-19)
(0.398245 2.54104 7.07171e-19)
(0.349158 2.05269 7.14328e-20)
(1.02108 -0.00810203 0)
(1.01551 -0.00974109 0)
(1.01492 -0.0155013 0)
(1.0074 -0.00107001 0)
(1.00493 -0.000907263 0)
(1.00778 -0.00468261 0)
(1.00927 -0.00360502 0)
(1.01423 -0.0043656 0)
(1.02035 0.0163665 1.17141e-18)
(1.01764 0.015483 -1.49606e-18)
(1.02064 0.018448 -1.18108e-18)
(1.01827 0.016783 1.4744e-18)
(0.784661 1.32475 0)
(0.720963 1.37498 2.46858e-19)
(0.896788 1.22433 9.81117e-20)
(0.942733 1.16946 -1.30556e-19)
(1.15452 2.59951 2.78347e-19)
(0.767522 0.123002 5.9991e-19)
(1.16377 0.109447 0)
(1.21291 0.195072 -4.66797e-19)
(1.20007 0.155717 -1.9874e-20)
(1.00634 0.157484 0)
(0.129039 2.95832 5.30867e-19)
(0.105226 2.86429 -1.15464e-18)
(0.012883 2.3739 7.71186e-19)
(0.0969151 -0.15633 -3.27128e-19)
(0.335508 3.41424 -2.15612e-19)
(0.190684 3.30897 0)
(0.234464 3.34958 2.80804e-19)
(0.239437 3.03093 -1.77529e-18)
(0.333066 3.18925 0)
(0.00582686 3.12113 4.58828e-20)
(0.0155565 3.12986 -5.41797e-19)
(0.0140655 3.12592 7.9741e-19)
(0.034743 3.14008 0)
(0.03325 3.15021 0)
(1.21016 2.59708 0)
(0.546323 0.804208 -5.27655e-19)
(1.06651 0.993963 -8.983e-21)
(1.00122 1.07853 0)
(0.854367 0.97393 -1.09513e-19)
(1.0923 0.895026 2.7909e-20)
(0.310623 0.33433 -8.49171e-19)
(0.657058 0.325039 -1.70099e-20)
(0.554906 0.222325 4.06462e-19)
(0.543194 0.336317 2.97398e-20)
(0.43541 0.275242 -1.1951e-18)
(0.61673 0.325801 0)
(0.710087 0.424671 6.70667e-19)
(0.711094 0.426074 0)
(0.581884 0.340626 0)
(0.508709 0.247575 0)
(0.827166 0.625209 4.09879e-19)
(1.23901 0.290377 -4.881e-19)
(1.23916 0.429275 0)
(1.24744 0.369715 0)
(0.684718 0.195607 6.20145e-19)
(0.873844 0.553773 -3.75159e-19)
(0.77149 0.52667 6.67844e-19)
(0.962913 0.446516 -7.35598e-19)
(1.01915 0.0149829 8.02067e-19)
(1.01755 0.0143592 -8.07988e-19)
(1.0159 0.0153572 0)
(1.03652 -0.00556772 0)
(1.02992 -0.0083541 -7.5702e-19)
(1.02797 -0.0119472 7.49491e-19)
(1.02486 0.0105794 0)
(1.02334 0.0143691 0)
(1.01141 0.00416969 0)
(1.01419 0.00916274 0)
(1.01515 0.00418858 0)
(1.01426 0.00290413 0)
(0.0716636 1.35213 0)
(0.0778539 1.29779 0)
(0.149571 1.38627 9.22124e-21)
(0.28196 1.48045 8.94571e-20)
(0.17741 1.45131 1.88025e-19)
(0.210351 1.45653 -3.06738e-19)
(0.174646 1.41122 0)
(0.136696 1.59916 -7.08224e-20)
(0.117705 1.57818 0)
(0.34551 2.0023 -1.03864e-19)
(0.341814 2.33821 6.14487e-19)
(0.193702 1.46397 6.17382e-20)
(0.268948 1.39661 2.35375e-20)
(0.202564 1.38961 -1.90199e-20)
(0.278273 1.33905 -1.03171e-19)
(0.243011 1.57896 0)
(0.267532 1.6161 1.12328e-19)
(0.0311165 2.25844 -2.92291e-20)
(0.0439592 2.66386 0)
(0.066688 2.39488 1.35938e-19)
(0.0633921 2.41563 0)
(0.0697278 2.66541 -2.19801e-19)
(0.0493283 2.69407 0)
(0.0272594 1.43914 3.26041e-20)
(0.0358592 1.49039 0)
(0.0293476 1.40605 0)
(0.0242909 1.41135 -3.67903e-20)
(0.00065976 2.64783 -1.70159e-20)
(0.0299543 2.6932 1.67045e-19)
(0.010524 2.71836 1.17678e-21)
(0.00392528 1.83692 -3.25569e-21)
(-0.00153618 1.69098 -3.42407e-21)
(0.0111657 1.30092 0)
(0.0202853 1.22085 0)
(0.047276 1.5949 -2.58478e-20)
(0.0334117 1.47147 -3.31227e-20)
(0.0376679 1.53487 4.08994e-20)
(0.0410797 1.61879 0)
(-0.0292184 2.26917 9.60808e-20)
(-0.0302177 2.54712 -4.0312e-20)
(-0.0160535 2.44482 3.93145e-21)
(-0.00282673 1.85285 3.94395e-21)
(-0.0251404 2.49677 2.13253e-21)
(-0.0202039 2.44048 2.51071e-22)
(1.01844 0.0213723 -8.00069e-19)
(1.01457 0.0279631 8.0574e-19)
(1.01313 0.0163601 0)
(1.01083 0.0708744 1.12665e-18)
(0.991868 0.0597045 -1.26159e-18)
(0.950622 0.0568755 1.41017e-18)
(1.01441 0.112236 -1.5034e-19)
(1.04297 -0.00555642 0)
(1.05138 -0.00117029 7.21965e-19)
(1.03924 -0.00974351 -7.2342e-19)
(1.07191 0.0429462 -4.29252e-20)
(1.06504 0.0242198 3.70204e-19)
(1.06336 0.0570599 0)
(1.05402 0.0502869 -1.33118e-19)
(1.03236 0.0428484 0)
(1.02594 0.0398857 0)
(1.02789 0.0137079 0)
(1.02382 0.016344 0)
(1.04042 0.0332188 2.74204e-19)
(1.03897 0.0277482 -6.06381e-19)
(1.05138 0.034657 -2.90621e-19)
(1.04847 0.0347858 -3.20108e-19)
(1.0717 0.0653488 6.24607e-19)
(1.09715 0.0531671 0)
(1.10624 0.0973585 0)
(-0.0248707 2.27422 5.36124e-20)
(-0.024024 2.01778 8.05372e-22)
(-0.0200926 2.02524 0)
(-0.0265373 2.4431 -5.33698e-20)
(-0.0215477 2.39936 -1.80437e-21)
(-0.0327374 2.47074 5.3023e-21)
(-0.0205375 2.61887 -1.16824e-20)
(-0.0227569 2.56078 6.53657e-23)
(-0.0211418 2.51244 -3.12498e-21)
(-0.0157313 2.61298 1.02535e-20)
(-0.0207185 2.61487 -1.0947e-20)
(-0.00584373 1.49632 -6.3495e-22)
(0.00373659 1.62268 -3.37548e-20)
(0.371277 1.44749 -1.15947e-19)
(0.371169 1.38095 3.63889e-20)
(0.661478 1.42564 -2.38819e-19)
(0.528743 1.49283 -1.42794e-19)
(0.587136 1.45823 0)
(0.593257 2.42112 2.06898e-19)
(0.661679 2.41659 3.37456e-19)
(0.411105 2.5105 8.78508e-20)
(0.402329 2.53496 -6.09211e-19)
(0.509954 2.47614 6.13969e-19)
(0.55318 2.45785 0)
(0.487977 2.51533 -5.59202e-19)
(0.248355 2.58754 1.14346e-18)
(0.354681 2.55967 -7.73507e-20)
(0.283914 2.64925 -1.58621e-18)
(0.948033 2.37449 7.26576e-19)
(0.838192 2.37962 0)
(1.01108 0.000529692 2.62409e-20)
(1.01536 -0.00536519 -2.12851e-20)
(1.01767 -0.00347035 -3.88751e-19)
(1.01504 -0.000832381 3.90866e-19)
(1.01246 0.00126935 0)
(0.647758 1.2907 0)
(0.671114 1.18427 0)
(0.785041 1.1027 0)
(0.66421 1.14793 0)
(1.18461 2.61304 5.97356e-20)
(1.07261 2.36036 0)
(0.834108 2.16455 3.83162e-21)
(0.8236 2.43041 0)
(0.921697 2.52418 -4.21496e-19)
(0.956924 2.48028 2.80374e-19)
(0.797905 0.184608 0)
(0.739783 0.157346 1.62822e-19)
(0.907312 0.15216 9.47681e-19)
(0.822944 0.156113 -3.55294e-19)
(0.779255 0.0904137 -1.09485e-18)
(1.08289 0.2418 -8.91268e-19)
(1.00039 0.30444 -1.77705e-20)
(0.928964 0.308123 8.59075e-19)
(1.00774 0.234955 7.21138e-19)
(0.948135 0.199684 -1.25348e-18)
(0.910587 0.203804 1.5675e-19)
(0.948164 0.270655 -3.326e-19)
(0.92614 0.231205 0)
(0.996024 0.19577 6.18233e-19)
(1.04746 0.194806 0)
(1.04504 0.223168 0)
(1.10769 0.121614 2.89651e-19)
(1.07183 0.181563 -1.50331e-20)
(1.07629 0.241769 -1.57708e-19)
(1.10193 0.207706 0)
(1.02331 0.0467393 6.16627e-19)
(1.03931 0.0603788 7.71336e-19)
(1.03451 0.0464712 -6.12329e-19)
(1.04299 0.0680022 -5.17283e-19)
(1.02035 0.0756914 -7.93677e-19)
(0.985471 0.160253 0)
(0.990355 0.106153 0)
(0.965306 0.0747031 -5.01102e-19)
(0.905537 0.098544 1.99377e-19)
(1.04009 0.108137 7.15821e-19)
(1.06974 0.125237 -8.35494e-19)
(1.07649 0.157644 7.46094e-19)
(1.03115 0.151378 0)
(1.07528 0.112697 0)
(1.0543 0.0935172 -3.42473e-19)
(1.04335 0.098132 -5.8435e-19)
(0.57892 1.0554 1.39778e-19)
(0.60429 1.38011 -4.12236e-20)
(1.15445 2.72868 -2.27349e-19)
(1.22008 3.07107 2.01204e-21)
(1.24623 2.71184 -1.23543e-19)
(1.2747 2.69512 -3.18833e-20)
(1.20215 2.33541 -1.1094e-20)
(1.20778 2.97495 -9.36109e-20)
(1.22791 2.94048 2.34547e-19)
(1.21025 3.22394 -1.42793e-19)
(1.36989 2.95485 1.97313e-19)
(1.35862 2.87294 0)
(0.563735 0.812952 -5.0305e-20)
(0.109904 1.22502 5.69647e-19)
(0.557849 0.357386 5.55121e-19)
(0.396901 0.104248 6.02165e-19)
(0.479598 0.315416 6.776e-19)
(0.545313 0.433591 -1.09577e-18)
(0.547259 0.429879 8.97451e-19)
(0.466501 0.314674 -3.40939e-19)
(0.345121 0.242812 7.70719e-19)
(0.709912 0.269393 -3.58146e-19)
(0.669593 0.292349 0)
(0.608641 0.207728 6.61013e-21)
(0.74306 0.507178 3.63503e-19)
(0.721048 0.477805 -1.32153e-18)
(0.623566 0.445488 1.11868e-20)
(0.620617 0.436502 0)
(0.69335 0.717697 3.96307e-19)
(0.855493 0.779248 3.94145e-19)
(0.779115 0.861768 -4.61231e-19)
(0.900968 0.816447 -1.54026e-19)
(0.932037 0.861787 -3.7157e-20)
(0.939121 0.861513 3.8052e-20)
(0.86763 0.6597 -6.78517e-19)
(0.947537 0.713357 1.43018e-19)
(1.00688 0.728467 0)
(0.997903 0.705071 -1.93199e-19)
(1.03015 0.344908 2.11873e-19)
(1.14983 0.306708 2.87348e-19)
(1.07089 0.279129 3.64248e-19)
(1.01941 0.377343 -4.30321e-19)
(1.0677 0.439733 0)
(1.12368 0.421427 0)
(0.923484 0.381153 1.51461e-21)
(0.840002 0.317476 0)
(0.88531 0.313108 4.06519e-19)
(0.910539 0.316735 -8.04879e-21)
(0.957338 0.449957 2.04912e-18)
(0.918424 0.505402 5.27088e-19)
(0.923183 0.471974 -5.61944e-19)
(0.83898 0.459334 6.03009e-19)
(0.823588 0.452239 3.61617e-19)
(0.79562 0.434585 -3.55623e-19)
(1.02742 -0.000189416 6.47604e-19)
(1.02 0.000106343 0)
(1.01855 0.00103225 4.22286e-19)
(1.02174 -0.00150511 -9.56582e-19)
(1.02238 0.00454486 4.64721e-19)
(1.0203 0.011577 -9.73133e-19)
(1.02119 0.0109354 0)
(1.02043 0.0111408 -2.02827e-19)
(1.01593 0.0078681 5.08862e-19)
(1.01658 0.010659 -2.5391e-19)
(1.01728 0.0100076 1.86984e-19)
(0.0299829 1.32654 0)
(0.0364406 1.38088 0)
(0.048836 1.32827 0)
(0.053566 1.27524 0)
(0.0746417 1.40116 -4.98273e-20)
(0.0834017 1.3671 2.2325e-20)
(0.117689 1.54516 -1.41667e-20)
(0.104402 1.38934 -5.70485e-21)
(0.0385188 1.47688 1.77308e-20)
(0.0426357 1.47066 -1.36184e-20)
(0.0670594 1.38756 -1.01333e-20)
(0.0594877 1.38895 4.57329e-20)
(0.0508811 1.36518 6.80149e-21)
(0.0426425 1.38694 3.65558e-21)
(0.107788 2.36326 -1.50118e-19)
(0.0965917 2.41158 0)
(0.1706 2.03732 1.08149e-19)
(0.113403 1.70383 3.95366e-20)
(0.234036 2.03398 -8.97957e-20)
(0.200338 2.42512 0)
(0.262544 2.3751 -6.05763e-19)
(0.302513 2.37279 4.28122e-19)
(0.22912 1.99378 -2.4963e-19)
(0.155323 2.15288 1.69698e-19)
(0.14176 2.26014 0)
(0.0191578 1.87818 4.61173e-21)
(0.00042681 2.38779 -3.39415e-20)
(0.00699531 2.14573 0)
(0.0116532 2.45136 -1.36241e-20)
(0.0286133 2.2943 9.30945e-21)
(0.0152245 1.41827 -7.05325e-21)
(0.0126578 1.39995 1.17543e-19)
(0.012574 1.40644 -3.88897e-20)
(0.0211914 1.41129 -3.26985e-20)
(0.0254706 1.44283 0)
(0.00857829 1.38774 0)
(0.00106317 1.29775 -4.61488e-20)
(0.00480035 1.3796 1.31767e-20)
(0.00853508 1.37941 0)
(0.00666961 1.28956 -3.45221e-20)
(0.0173265 1.21175 7.01269e-20)
(1.04084 0.0121682 0)
(1.04707 0.00839682 -6.77337e-20)
(1.03876 0.0223712 -4.88919e-19)
(1.04861 0.0211713 0)
(1.05253 0.0210313 0)
(1.0364 0.012359 -6.85337e-21)
(1.03101 0.0121871 7.85832e-19)
(1.03166 0.0172147 9.52652e-19)
(1.02549 0.0211288 0)
(1.02218 0.0215496 0)
(1.03527 0.0260995 4.87444e-19)
(1.02561 0.0279148 0)
(1.02358 0.0279755 0)
(-0.0179805 2.02291 0)
(0.000770207 1.6533 -4.37601e-21)
(-0.00453508 1.76066 -3.02723e-20)
(-0.00125246 1.38797 0)
(-0.00650504 1.55438 -1.85393e-20)
(-0.00894696 1.46454 1.15673e-20)
(-0.00596536 1.40147 0)
(0.388535 1.64368 0)
(0.373764 1.30708 -7.13799e-20)
(0.300713 1.34043 0)
(0.425662 1.30593 6.50541e-21)
(0.476356 1.47034 0)
(0.456691 1.41464 2.51667e-20)
(1.0364 2.67522 -1.53602e-20)
(0.968437 2.40323 -9.13178e-19)
(0.921569 2.19154 1.02439e-18)
(0.852213 2.37155 2.41968e-19)
(0.847789 2.48468 0)
(0.917518 2.48085 0)
(0.931381 2.36802 0)
(0.910343 2.35721 -9.44182e-19)
(0.686731 2.44854 -3.94065e-19)
(0.799901 2.438 -9.7647e-20)
(0.810243 2.41217 7.41854e-20)
(0.695548 2.38976 0)
(0.800808 2.3851 0)
(0.758963 2.39849 -3.68634e-19)
(0.767506 2.4744 0)
(0.631299 1.09371 0)
(0.480468 0.900025 -5.12161e-19)
(0.567561 0.944079 -3.2409e-20)
(0.519161 1.03393 0)
(0.519609 0.977024 7.67e-19)
(0.799867 0.884643 -1.29751e-19)
(0.808706 1.02084 0)
(0.783843 0.987126 1.8525e-19)
(0.668074 1.03396 0)
(0.669409 0.9355 0)
(1.16346 2.75183 -2.29802e-19)
(1.14091 2.81515 -9.71249e-20)
(0.928944 2.32926 1.00447e-19)
(0.896742 2.30869 -8.33015e-20)
(1.12904 2.72485 0)
(1.08286 2.69431 1.00219e-19)
(1.08895 2.4783 -3.13708e-19)
(0.983473 2.23132 -3.03756e-20)
(0.49224 1.33038 0)
(0.507986 1.06044 -1.23202e-19)
(0.576424 1.16708 0)
(0.853185 0.249379 0)
(0.759696 0.199556 0)
(0.670661 0.155954 0)
(0.844351 0.251625 -6.39873e-19)
(0.732526 0.242641 3.73566e-19)
(0.92196 0.0903628 -4.11305e-19)
(0.926597 0.132904 0)
(0.913901 0.140804 1.77645e-19)
(0.850343 0.11855 7.1023e-19)
(0.814425 0.0802648 -4.45486e-19)
(1.15564 3.34891 -7.1792e-19)
(1.20458 3.2684 0)
(1.15337 3.37786 -1.48779e-18)
(0.641524 3.53939 1.26228e-18)
(0.863117 3.108 7.17075e-20)
(0.522176 0.799935 6.05136e-19)
(0.423966 0.797339 0)
(0.308088 0.38533 -1.48778e-19)
(0.4725 0.650001 8.56345e-19)
(0.561667 0.360252 -1.95547e-19)
(0.515667 0.465521 2.30866e-19)
(0.674865 0.511621 4.91318e-19)
(0.714002 0.550437 0)
(0.663992 0.574896 0)
(0.629136 0.526054 0)
(1.00837 0.615087 8.82966e-20)
(0.923398 0.554935 -5.13147e-19)
(0.948697 0.586509 3.86554e-19)
(0.979338 0.526556 -3.97288e-19)
(1.0868 0.495122 0)
(1.09519 0.586004 -9.67127e-20)
(0.859324 0.412052 -8.29856e-19)
(0.858198 0.400903 -1.02876e-18)
(0.792762 0.393907 6.39064e-19)
(0.802993 0.377897 -6.48693e-19)
(0.846052 0.337085 -5.19191e-19)
(0.792982 0.337537 6.35101e-19)
(1.02668 0.00612979 -4.93083e-19)
(1.02638 0.00634793 1.0021e-18)
(1.02947 0.00026736 6.27552e-19)
(1.03371 0.00118404 -7.55769e-19)
(1.03383 0.00935202 0)
(1.03007 0.0100554 -1.23054e-18)
(0.0636815 1.64109 1.95187e-20)
(0.0516743 1.5908 0)
(0.0901937 1.69043 1.24605e-19)
(0.0981455 1.6712 -1.10082e-19)
(0.0938951 1.54812 2.5336e-20)
(0.093216 1.54921 0)
(0.0119513 1.6871 0)
(-0.0042689 1.49547 7.38056e-21)
(-0.00208035 1.44134 -6.63987e-21)
(-0.00741807 1.55133 5.36213e-21)
(0.00215669 1.88463 1.1023e-20)
(-0.00969973 1.93756 -1.72607e-21)
(0.496715 1.35731 -2.75014e-19)
(0.490216 1.3577 3.02182e-19)
(0.453076 1.30152 -3.09725e-20)
(0.436332 1.28403 7.71439e-21)
(0.640081 1.30826 0)
(0.555426 1.39862 1.05385e-19)
(0.570793 1.40599 -1.02593e-19)
(0.466731 1.29125 3.01997e-20)
(0.521487 1.24092 0)
(0.573123 1.20374 0)
(0.65362 2.40807 5.7889e-19)
(0.669305 2.44958 1.25929e-18)
(0.713777 2.46026 -8.67733e-19)
(0.609992 2.43408 -2.01791e-19)
(0.559775 2.5245 2.83521e-19)
(0.509058 2.49928 -7.56701e-19)
(0.978175 2.37474 -5.73294e-19)
(1.01233 2.38691 0)
(0.925751 2.16962 -6.58935e-19)
(1.05384 2.67334 0)
(1.05613 2.65995 0)
(0.598738 2.25697 -1.27069e-19)
(1.0366 3.15384 1.28523e-19)
(0.90775 3.02421 -3.17449e-20)
(0.264105 0.847928 0)
(0.290693 0.691249 -3.17203e-19)
(0.460474 0.651119 -3.19009e-19)
(0.378615 2.00131 0)
(0.46219 2.77884 -4.99168e-20)
(0.415773 2.54146 0)
(0.716331 0.66803 -8.37296e-19)
(0.801214 0.685856 1.12161e-18)
(0.821042 0.626867 -1.1082e-18)
(0.693333 0.631132 -1.07328e-19)
(0.748553 0.589125 -4.39939e-19)
(1.00044 2.75275 -9.7746e-20)
(1.04135 2.81395 -1.65155e-19)
(0.631653 2.12069 6.9768e-19)
(0.584151 1.68931 -4.97058e-19)
(0.693584 1.88875 -4.06918e-19)
(0.986657 2.43662 -1.12836e-19)
(0.993668 2.42956 2.962e-19)
(0.649333 1.8221 2.82775e-20)
(0.440848 1.30999 1.44324e-19)
)
;
boundaryField
{
wall-4
{
type noSlip;
}
velocity-inlet-5
{
type fixedValue;
value uniform (1 0 0);
}
velocity-inlet-6
{
type fixedValue;
value uniform (0 3 0);
}
pressure-outlet-7
{
type zeroGradient;
}
wall-8
{
type noSlip;
}
frontAndBackPlanes
{
type empty;
}
}
// ************************************************************************* //
| [
"avogel1994@gmail.com"
] | avogel1994@gmail.com | |
1df21450fc881a70da40740395006f90b2427c37 | e9f244a624aff647768a876b38c42ef7e88d76cc | /sample/BundleSample/BundleSample.cpp | aa9156cb1f5b148fb898c1ef47c23a9030b93c5c | [
"Zlib",
"OpenSSL",
"LicenseRef-scancode-unicode",
"Apache-2.0",
"LicenseRef-scancode-openssl",
"LicenseRef-scancode-ssleay-windows",
"MIT",
"LicenseRef-scancode-generic-cla"
] | permissive | rudyhuyn/msix-packaging | fcb2936089405d563ae800027be6eba60c3dcb82 | 8e847de81290efa378aae0d7c86ece3e11a262bc | refs/heads/master | 2020-04-22T16:17:45.643414 | 2019-04-29T21:39:28 | 2019-04-29T21:39:28 | 170,503,469 | 2 | 0 | null | 2019-02-13T12:21:56 | 2019-02-13T12:21:56 | null | UTF-8 | C++ | false | false | 9,881 | cpp | //
// Copyright (C) 2017 Microsoft. All rights reserved.
// See LICENSE file in the project root for full license information.
//
#include "AppxPackaging.hpp"
#include "MSIXWindows.hpp"
#include <iostream>
#define RETURN_IF_FAILED(a) \
{ HRESULT __hr = a; \
if (FAILED(__hr)) \
{ return __hr; } \
}
// Stripped down ComPtr provided for those platforms that do not already have a ComPtr class.
template <class T>
class ComPtr
{
public:
// default ctor
ComPtr() = default;
ComPtr(T* ptr) : m_ptr(ptr) { InternalAddRef(); }
~ComPtr() { InternalRelease(); }
inline T* operator->() const { return m_ptr; }
inline T* Get() const { return m_ptr; }
inline T** operator&()
{ InternalRelease();
return &m_ptr;
}
protected:
T* m_ptr = nullptr;
inline void InternalAddRef() { if (m_ptr) { m_ptr->AddRef(); } }
inline void InternalRelease()
{
T* temp = m_ptr;
if (temp)
{ m_ptr = nullptr;
temp->Release();
}
}
};
// Or you can use what-ever allocator/deallocator is best for your platform...
LPVOID STDMETHODCALLTYPE MyAllocate(SIZE_T cb) { return std::malloc(cb); }
void STDMETHODCALLTYPE MyFree(LPVOID pv) { std::free(pv); }
// Helper class to free string buffers obtained from the packaging APIs.
template<typename T>
class Text
{
public:
T** operator&() { return &content; }
~Text() { Cleanup(); }
T* Get() { return content; }
T* content = nullptr;
protected:
void Cleanup() { if (content) { MyFree(content); content = nullptr; } }
};
int Help()
{
std::cout << std::endl;
std::cout << "Usage:" << std::endl;
std::cout << "------" << std::endl;
std::cout << "\t" << "BundleSample <bundle>" << std::endl;
std::cout << std::endl;
std::cout << "Description:" << std::endl;
std::cout << "------------" << std::endl;
std::cout << "\tShow information about the packages in the the bundle." << std::endl;
std::cout << std::endl;
return 0;
}
HRESULT ShowInformationOfPackage(IAppxFile* packageFile)
{
Text<WCHAR> packageName;
RETURN_IF_FAILED(packageFile->GetName(&packageName));
std::wcout << L"\tName: " << packageName.Get() << std::endl;
ComPtr<IAppxFactory> factory;
RETURN_IF_FAILED(CoCreateAppxFactoryWithHeap(
MyAllocate,
MyFree,
MSIX_VALIDATION_OPTION::MSIX_VALIDATION_OPTION_SKIPSIGNATURE,
&factory));
// Get stream of the package and package reader
ComPtr<IStream> packageStream;
RETURN_IF_FAILED(packageFile->GetStream(&packageStream));
ComPtr<IAppxPackageReader> packageReader;
RETURN_IF_FAILED(factory->CreatePackageReader(packageStream.Get(), &packageReader));
// Get information about the package from the manifest
ComPtr<IAppxManifestReader> manifest;
RETURN_IF_FAILED(packageReader->GetManifest(&manifest));
ComPtr<IAppxManifestPackageId> bundlePackageId;
RETURN_IF_FAILED(manifest->GetPackageId(&bundlePackageId));
// Get full name of the bundle
Text<WCHAR> fullName;
RETURN_IF_FAILED(bundlePackageId->GetPackageFullName(&fullName));
std::wcout << L"\tFull Name: " << fullName.Get() << std::endl;
// Get AUMIDs in the package
ComPtr<IAppxManifestApplicationsEnumerator> applications;
RETURN_IF_FAILED(manifest->GetApplications(&applications))
BOOL hasCurrent = FALSE;
RETURN_IF_FAILED(applications->GetHasCurrent(&hasCurrent));
while(hasCurrent)
{
ComPtr<IAppxManifestApplication> application;
RETURN_IF_FAILED(applications->GetCurrent(&application));
Text<WCHAR> aumid;
RETURN_IF_FAILED(application->GetAppUserModelId(&aumid));
std::wcout << L"\tAppUserModelId: " << aumid.Get() << std::endl;
RETURN_IF_FAILED(applications->MoveNext(&hasCurrent));
}
// Show what are the target device families of the package.
ComPtr<IAppxManifestReader3> manifest3;
// AppxPackaging.hpp contains a helper UuidOfImpl<I>::iid for QueryInterface.
// It returns the GUID associated with the interface
RETURN_IF_FAILED(manifest->QueryInterface(UuidOfImpl<IAppxManifestReader3>::iid, reinterpret_cast<void**>(&manifest3)));
ComPtr<IAppxManifestTargetDeviceFamiliesEnumerator> tdfEnum;
RETURN_IF_FAILED(manifest3->GetTargetDeviceFamilies(&tdfEnum));
hasCurrent = FALSE;
RETURN_IF_FAILED(tdfEnum->GetHasCurrent(&hasCurrent));
while (hasCurrent)
{
ComPtr<IAppxManifestTargetDeviceFamily> tdf;
RETURN_IF_FAILED(tdfEnum->GetCurrent(&tdf));
Text<WCHAR> tdfName;
RETURN_IF_FAILED(tdf->GetName(&tdfName));
std::wcout << L"\tTarget Device Family: " << tdfName.Get() << std::endl;
RETURN_IF_FAILED(tdfEnum->MoveNext(&hasCurrent));
}
return S_OK;
}
HRESULT ShowInformationOfBundle(char* bundleName)
{
// Initialize the factory with full validation and applicability options.
ComPtr<IAppxBundleFactory> bundleFactory;
RETURN_IF_FAILED(CoCreateAppxBundleFactoryWithHeap(
MyAllocate,
MyFree,
MSIX_VALIDATION_OPTION::MSIX_VALIDATION_OPTION_SKIPSIGNATURE,
MSIX_APPLICABILITY_OPTIONS::MSIX_APPLICABILITY_OPTION_FULL,
&bundleFactory));
// Create stream on the file provided.
ComPtr<IStream> inputStream;
RETURN_IF_FAILED(CreateStreamOnFile(const_cast<char*>(bundleName), true, &inputStream));
// Now get the bundle reader
ComPtr<IAppxBundleReader> bundleReader;
RETURN_IF_FAILED(bundleFactory->CreateBundleReader(inputStream.Get(), &bundleReader));
// Get basic information about this bundle from the bundle manifest
ComPtr<IAppxBundleManifestReader> manifestReader;
RETURN_IF_FAILED(bundleReader->GetManifest(&manifestReader));
ComPtr<IAppxManifestPackageId> bundlePackageId;
RETURN_IF_FAILED(manifestReader->GetPackageId(&bundlePackageId));
// This should be the same name as the one passed into this function
Text<WCHAR> name;
RETURN_IF_FAILED(bundlePackageId->GetName(&name));
std::wcout << L"File: " << name.Get() << std::endl;
// Get full name of the bundle
Text<WCHAR> fullName;
RETURN_IF_FAILED(bundlePackageId->GetPackageFullName(&fullName));
std::wcout << L"Full Name: " << fullName.Get() << std::endl;
// A bundle using MSIX_APPLICABILITY_OPTION_FULL will only show the packages
// that are applicable to the current platform, as well as the resources
// packages with the languages of the system. Get the applicable
// package by calling GetPayloadPackages
ComPtr<IAppxFilesEnumerator> applicablePackages;
RETURN_IF_FAILED(bundleReader->GetPayloadPackages(&applicablePackages));
BOOL hasCurrent = FALSE;
RETURN_IF_FAILED(applicablePackages->GetHasCurrent(&hasCurrent));
std::wcout << L"Applicable Packages: " << std::endl;
while(hasCurrent)
{
ComPtr<IAppxFile> applicablePackage;
RETURN_IF_FAILED(applicablePackages->GetCurrent(&applicablePackage));
RETURN_IF_FAILED(ShowInformationOfPackage(applicablePackage.Get()));
std::wcout << std::endl;
RETURN_IF_FAILED(applicablePackages->MoveNext(&hasCurrent));
}
// It is possible to see all the packages in the bundle by looking into the
// information of the bundle manifest.
ComPtr<IAppxBundleManifestPackageInfoEnumerator> bundleInfoEnumerator;
RETURN_IF_FAILED(manifestReader->GetPackageInfoItems(&bundleInfoEnumerator));
hasCurrent = FALSE;
RETURN_IF_FAILED(bundleInfoEnumerator->GetHasCurrent(&hasCurrent));
std::wcout << L"Packages In Bundle: " << std::endl;
while(hasCurrent)
{
ComPtr<IAppxBundleManifestPackageInfo> bundlePackageInfo;
RETURN_IF_FAILED(bundleInfoEnumerator->GetCurrent(&bundlePackageInfo));
Text<WCHAR> packageName;
RETURN_IF_FAILED(bundlePackageInfo->GetFileName(&packageName));
ComPtr<IAppxFile> package;
RETURN_IF_FAILED(bundleReader->GetPayloadPackage(packageName.Get(), &package));
RETURN_IF_FAILED(ShowInformationOfPackage(package.Get()));
// Get the languages of this package.
ComPtr<IAppxManifestQualifiedResourcesEnumerator> resourceEnumerator;
RETURN_IF_FAILED(bundlePackageInfo->GetResources(&resourceEnumerator));
BOOL hasLanguage = FALSE;
RETURN_IF_FAILED(resourceEnumerator->GetHasCurrent(&hasLanguage));
while (hasLanguage)
{
ComPtr<IAppxManifestQualifiedResource> resource;
RETURN_IF_FAILED(resourceEnumerator->GetCurrent(&resource));
Text<WCHAR> language;
RETURN_IF_FAILED(resource->GetLanguage(&language));
std::wcout << L"\tLanguage: " << language.Get() << std::endl;
RETURN_IF_FAILED(resourceEnumerator->MoveNext(&hasLanguage));
}
std::wcout << std::endl;
RETURN_IF_FAILED(bundleInfoEnumerator->MoveNext(&hasCurrent));
}
return S_OK;
}
int main(int argc, char* argv[])
{
if (argc != 2)
{
return Help();
}
HRESULT hr = ShowInformationOfBundle(argv[1]);
if (FAILED(hr))
{
std::cout << "Error: " << std::hex << hr << " while extracting the appx package" <<std::endl;
Text<char> text;
auto logResult = GetLogTextUTF8(MyAllocate, &text);
if (0 == logResult)
{ std::cout << "LOG:" << std::endl << text.content << std::endl;
}
else
{ std::cout << "UNABLE TO GET LOG WITH HR=" << std::hex << logResult << std::endl;
}
}
return 0;
}
| [
"36937303+msftrubengu@users.noreply.github.com"
] | 36937303+msftrubengu@users.noreply.github.com |
395a9d8376bf845a34f07440cc310f9290ba2f05 | 7e8c47307531cace46a11861b51f98efa0cfb5cb | /Library/Model.cpp | 28b29c3196e915653c9055466cacd29176d600fd | [] | no_license | AsterNighT/2020CG | 15bca0599cc9ce45cb6d8d83f341c18779bb742c | 4fea0cf6a65f34d5196b8bc554d05e9dfa36d627 | refs/heads/master | 2022-11-05T21:25:59.972138 | 2020-06-22T08:36:18 | 2020-06-22T08:36:18 | 264,388,197 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,155 | cpp | #include "Model.h"
#include "Scene.h"
#include "Mesh.h"
#include "ModelMaterial.h"
#include <assimp/Importer.hpp>
#include <assimp/scene.h>
#include <assimp/postprocess.h>
Model::Model(Scene& bScene, const std::string& filename, bool flipUVs, const std::string& tangentFileName) : mScene(bScene), mMeshes(), mMaterials(){
Assimp::Importer importer;
UINT flags;
flags = aiProcess_Triangulate | aiProcess_ValidateDataStructure | aiProcess_FixInfacingNormals | aiProcess_GenNormals | aiProcess_JoinIdenticalVertices | aiProcess_PreTransformVertices | aiProcess_GenUVCoords | aiProcess_TransformUVCoords | aiProcess_CalcTangentSpace;
if (flipUVs) {
flags |= aiProcess_FlipUVs;
}
const aiScene* scene = importer.ReadFile(filename, flags);
if (scene->HasMaterials()) {
for (UINT i = 0; i < scene->mNumMaterials; i++) {
mMaterials.push_back(new ModelMaterial(*this, scene->mMaterials[i]));
}
}
if (scene->HasMeshes()) {
for (UINT i = 0; i < scene->mNumMeshes; i++) {
Mesh* mesh;
mesh = new Mesh(*(scene->mMeshes[i]));
mMeshes.push_back(mesh);
}
}
}
Model::~Model() {
for (Mesh* mesh : mMeshes) {
delete mesh;
}
}
Scene& Model::GetScene() {
return mScene;
}
bool Model::HasMeshes() const {
return (mMeshes.size() > 0);
}
bool Model::HasMaterials() const {
return (mMaterials.size() > 0);
}
const std::vector<Mesh*>& Model::Meshes() const {
return mMeshes;
}
const std::vector<ModelMaterial*>& Model::Materials() const {
return mMaterials;
}
std::vector<Item*> Model::loadModel(const std::string& filename, bool flipUVs){
Assimp::Importer importer;
UINT flags;
flags = aiProcess_Triangulate | aiProcess_ValidateDataStructure | aiProcess_FixInfacingNormals | aiProcess_GenNormals | aiProcess_GenUVCoords;
if (flipUVs) {
flags |= aiProcess_FlipUVs;
}
const aiScene* scene = importer.ReadFile(filename, flags);
std::vector<Item*> data;
if (scene->HasMeshes()) {
for (UINT i = 0; i < scene->mNumMeshes; i++) {
Mesh* mesh;
mesh = new Mesh(*(scene->mMeshes[i]));
auto item = new Item();
item->mesh = mesh;
item->name = mesh->Name();
data.emplace_back(item);
}
}
return data;
}
| [
"klxjt99@outlook.com"
] | klxjt99@outlook.com |
586f46cd34b34f49406aab770631c0230733b4b2 | ad3f34546afba57daf888798ad2d29db0361dcca | /T3000/Json-cpp/dist/jsoncpp.cpp | c9e6049bea46ef500d705cecd71aa0e8e1e12a54 | [
"MIT"
] | permissive | temcocontrols/T3000_Building_Automation_System | b7303be5d447cd8d40b1d2424b32b6c7683c2570 | 5fc9204df43aabfe57ccd1a5183b69940d525e2d | refs/heads/master | 2023-08-31T13:37:39.375528 | 2023-08-29T03:30:48 | 2023-08-29T03:30:48 | 6,994,906 | 66 | 62 | MIT | 2023-08-08T12:38:00 | 2012-12-04T05:29:25 | C++ | UTF-8 | C++ | false | false | 163,304 | cpp | /// Json-cpp amalgamated source (http://jsoncpp.sourceforge.net/).
/// It is intended to be used with #include "json/json.h"
// //////////////////////////////////////////////////////////////////////
// Beginning of content of file: LICENSE
// //////////////////////////////////////////////////////////////////////
/*
The JsonCpp library's source code, including accompanying documentation,
tests and demonstration applications, are licensed under the following
conditions...
Baptiste Lepilleur and The JsonCpp Authors explicitly disclaim copyright in all
jurisdictions which recognize such a disclaimer. In such jurisdictions,
this software is released into the Public Domain.
In jurisdictions which do not recognize Public Domain property (e.g. Germany as of
2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur and
The JsonCpp Authors, and is released under the terms of the MIT License (see below).
In jurisdictions which recognize Public Domain property, the user of this
software may choose to accept it either as 1) Public Domain, 2) under the
conditions of the MIT License (see below), or 3) under the terms of dual
Public Domain/MIT License conditions described here, as they choose.
The MIT License is about as close to Public Domain as a license can get, and is
described in clear, concise terms at:
http://en.wikipedia.org/wiki/MIT_License
The full text of the MIT License follows:
========================================================================
Copyright (c) 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
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.
========================================================================
(END LICENSE TEXT)
The MIT license is compatible with both the GPL and commercial
software, affording one all of the rights of Public Domain with the
minor nuisance of being required to keep the above copyright notice
and license text in the source code. Note also that by accepting the
Public Domain "license" you can re-license your copy using whatever
license you like.
*/
// //////////////////////////////////////////////////////////////////////
// End of content of file: LICENSE
// //////////////////////////////////////////////////////////////////////
#include "json/json.h"
#ifndef JSON_IS_AMALGAMATION
#error "Compile with -I PATH_TO_JSON_DIRECTORY"
#endif
// //////////////////////////////////////////////////////////////////////
// Beginning of content of file: src/lib_json/json_tool.h
// //////////////////////////////////////////////////////////////////////
// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#ifndef LIB_JSONCPP_JSON_TOOL_H_INCLUDED
#define LIB_JSONCPP_JSON_TOOL_H_INCLUDED
#if !defined(JSON_IS_AMALGAMATION)
#include <json/config.h>
#endif
// Also support old flag NO_LOCALE_SUPPORT
#ifdef NO_LOCALE_SUPPORT
#define JSONCPP_NO_LOCALE_SUPPORT
#endif
#ifndef JSONCPP_NO_LOCALE_SUPPORT
#include <clocale>
#endif
/* This header provides common string manipulation support, such as UTF-8,
* portable conversion from/to string...
*
* It is an internal header that must not be exposed.
*/
namespace Json {
static inline char getDecimalPoint() {
#ifdef JSONCPP_NO_LOCALE_SUPPORT
return '\0';
#else
struct lconv* lc = localeconv();
return lc ? *(lc->decimal_point) : '\0';
#endif
}
/// Converts a unicode code-point to UTF-8.
static inline String codePointToUTF8(unsigned int cp) {
String result;
// based on description from http://en.wikipedia.org/wiki/UTF-8
if (cp <= 0x7f) {
result.resize(1);
result[0] = static_cast<char>(cp);
} else if (cp <= 0x7FF) {
result.resize(2);
result[1] = static_cast<char>(0x80 | (0x3f & cp));
result[0] = static_cast<char>(0xC0 | (0x1f & (cp >> 6)));
} else if (cp <= 0xFFFF) {
result.resize(3);
result[2] = static_cast<char>(0x80 | (0x3f & cp));
result[1] = static_cast<char>(0x80 | (0x3f & (cp >> 6)));
result[0] = static_cast<char>(0xE0 | (0xf & (cp >> 12)));
} else if (cp <= 0x10FFFF) {
result.resize(4);
result[3] = static_cast<char>(0x80 | (0x3f & cp));
result[2] = static_cast<char>(0x80 | (0x3f & (cp >> 6)));
result[1] = static_cast<char>(0x80 | (0x3f & (cp >> 12)));
result[0] = static_cast<char>(0xF0 | (0x7 & (cp >> 18)));
}
return result;
}
enum {
/// Constant that specify the size of the buffer that must be passed to
/// uintToString.
uintToStringBufferSize = 3 * sizeof(LargestUInt) + 1
};
// Defines a char buffer for use with uintToString().
using UIntToStringBuffer = char[uintToStringBufferSize];
/** Converts an unsigned integer to string.
* @param value Unsigned integer to convert to string
* @param current Input/Output string buffer.
* Must have at least uintToStringBufferSize chars free.
*/
static inline void uintToString(LargestUInt value, char*& current) {
*--current = 0;
do {
*--current = static_cast<char>(value % 10U + static_cast<unsigned>('0'));
value /= 10;
} while (value != 0);
}
/** Change ',' to '.' everywhere in buffer.
*
* We had a sophisticated way, but it did not work in WinCE.
* @see https://github.com/open-source-parsers/jsoncpp/pull/9
*/
template <typename Iter> Iter fixNumericLocale(Iter begin, Iter end) {
for (; begin != end; ++begin) {
if (*begin == ',') {
*begin = '.';
}
}
return begin;
}
template <typename Iter> void fixNumericLocaleInput(Iter begin, Iter end) {
char decimalPoint = getDecimalPoint();
if (decimalPoint == '\0' || decimalPoint == '.') {
return;
}
for (; begin != end; ++begin) {
if (*begin == '.') {
*begin = decimalPoint;
}
}
}
/**
* Return iterator that would be the new end of the range [begin,end), if we
* were to delete zeros in the end of string, but not the last zero before '.'.
*/
template <typename Iter>
Iter fixZerosInTheEnd(Iter begin, Iter end, unsigned int precision) {
for (; begin != end; --end) {
if (*(end - 1) != '0') {
return end;
}
// Don't delete the last zero before the decimal point.
if (begin != (end - 1) && begin != (end - 2) && *(end - 2) == '.') {
if (precision) {
return end;
}
return end - 2;
}
}
return end;
}
} // namespace Json
#endif // LIB_JSONCPP_JSON_TOOL_H_INCLUDED
// //////////////////////////////////////////////////////////////////////
// End of content of file: src/lib_json/json_tool.h
// //////////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////////
// Beginning of content of file: src/lib_json/json_reader.cpp
// //////////////////////////////////////////////////////////////////////
// Copyright 2007-2011 Baptiste Lepilleur and The JsonCpp Authors
// Copyright (C) 2016 InfoTeCS JSC. All rights reserved.
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#if !defined(JSON_IS_AMALGAMATION)
#include "json_tool.h"
#include <json/assertions.h>
#include <json/reader.h>
#include <json/value.h>
#endif // if !defined(JSON_IS_AMALGAMATION)
#include <algorithm>
#include <cassert>
#include <cstring>
#include <iostream>
#include <istream>
#include <limits>
#include <memory>
#include <set>
#include <sstream>
#include <utility>
#include <cstdio>
#if __cplusplus >= 201103L
#if !defined(sscanf)
#define sscanf std::sscanf
#endif
#endif //__cplusplus
#if defined(_MSC_VER)
#if !defined(_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES)
#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1
#endif //_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES
#endif //_MSC_VER
#if defined(_MSC_VER)
// Disable warning about strdup being deprecated.
#pragma warning(disable : 4996)
#endif
// Define JSONCPP_DEPRECATED_STACK_LIMIT as an appropriate integer at compile
// time to change the stack limit
#if !defined(JSONCPP_DEPRECATED_STACK_LIMIT)
#define JSONCPP_DEPRECATED_STACK_LIMIT 1000
#endif
static size_t const stackLimit_g =
JSONCPP_DEPRECATED_STACK_LIMIT; // see readValue()
namespace Json {
#if __cplusplus >= 201103L || (defined(_CPPLIB_VER) && _CPPLIB_VER >= 520)
using CharReaderPtr = std::unique_ptr<CharReader>;
#else
using CharReaderPtr = std::auto_ptr<CharReader>;
#endif
// Implementation of class Features
// ////////////////////////////////
Features::Features() = default;
Features Features::all() { return {}; }
Features Features::strictMode() {
Features features;
features.allowComments_ = false;
features.strictRoot_ = true;
features.allowDroppedNullPlaceholders_ = false;
features.allowNumericKeys_ = false;
return features;
}
// Implementation of class Reader
// ////////////////////////////////
bool Reader::containsNewLine(Reader::Location begin, Reader::Location end) {
return std::any_of(begin, end, [](char b) { return b == '\n' || b == '\r'; });
}
// Class Reader
// //////////////////////////////////////////////////////////////////
Reader::Reader() : features_(Features::all()) {}
Reader::Reader(const Features& features) : features_(features) {}
bool Reader::parse(const std::string& document, Value& root,
bool collectComments) {
document_.assign(document.begin(), document.end());
const char* begin = document_.c_str();
const char* end = begin + document_.length();
return parse(begin, end, root, collectComments);
}
bool Reader::parse(std::istream& is, Value& root, bool collectComments) {
// std::istream_iterator<char> begin(is);
// std::istream_iterator<char> end;
// Those would allow streamed input from a file, if parse() were a
// template function.
// Since String is reference-counted, this at least does not
// create an extra copy.
String doc(std::istreambuf_iterator<char>(is), {});
return parse(doc.data(), doc.data() + doc.size(), root, collectComments);
}
bool Reader::parse(const char* beginDoc, const char* endDoc, Value& root,
bool collectComments) {
if (!features_.allowComments_) {
collectComments = false;
}
begin_ = beginDoc;
end_ = endDoc;
collectComments_ = collectComments;
current_ = begin_;
lastValueEnd_ = nullptr;
lastValue_ = nullptr;
commentsBefore_.clear();
errors_.clear();
while (!nodes_.empty())
nodes_.pop();
nodes_.push(&root);
bool successful = readValue();
Token token;
skipCommentTokens(token);
if (collectComments_ && !commentsBefore_.empty())
root.setComment(commentsBefore_, commentAfter);
if (features_.strictRoot_) {
if (!root.isArray() && !root.isObject()) {
// Set error location to start of doc, ideally should be first token found
// in doc
token.type_ = tokenError;
token.start_ = beginDoc;
token.end_ = endDoc;
addError(
"A valid JSON document must be either an array or an object value.",
token);
return false;
}
}
return successful;
}
bool Reader::readValue() {
// readValue() may call itself only if it calls readObject() or ReadArray().
// These methods execute nodes_.push() just before and nodes_.pop)() just
// after calling readValue(). parse() executes one nodes_.push(), so > instead
// of >=.
if (nodes_.size() > stackLimit_g)
throwRuntimeError("Exceeded stackLimit in readValue().");
Token token;
skipCommentTokens(token);
bool successful = true;
if (collectComments_ && !commentsBefore_.empty()) {
currentValue().setComment(commentsBefore_, commentBefore);
commentsBefore_.clear();
}
switch (token.type_) {
case tokenObjectBegin:
successful = readObject(token);
currentValue().setOffsetLimit(current_ - begin_);
break;
case tokenArrayBegin:
successful = readArray(token);
currentValue().setOffsetLimit(current_ - begin_);
break;
case tokenNumber:
successful = decodeNumber(token);
break;
case tokenString:
successful = decodeString(token);
break;
case tokenTrue: {
Value v(true);
currentValue().swapPayload(v);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
} break;
case tokenFalse: {
Value v(false);
currentValue().swapPayload(v);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
} break;
case tokenNull: {
Value v;
currentValue().swapPayload(v);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
} break;
case tokenArraySeparator:
case tokenObjectEnd:
case tokenArrayEnd:
if (features_.allowDroppedNullPlaceholders_) {
// "Un-read" the current token and mark the current value as a null
// token.
current_--;
Value v;
currentValue().swapPayload(v);
currentValue().setOffsetStart(current_ - begin_ - 1);
currentValue().setOffsetLimit(current_ - begin_);
break;
} // Else, fall through...
default:
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return addError("Syntax error: value, object or array expected.", token);
}
if (collectComments_) {
lastValueEnd_ = current_;
lastValue_ = ¤tValue();
}
return successful;
}
void Reader::skipCommentTokens(Token& token) {
if (features_.allowComments_) {
do {
readToken(token);
} while (token.type_ == tokenComment);
} else {
readToken(token);
}
}
bool Reader::readToken(Token& token) {
skipSpaces();
token.start_ = current_;
Char c = getNextChar();
bool ok = true;
switch (c) {
case '{':
token.type_ = tokenObjectBegin;
break;
case '}':
token.type_ = tokenObjectEnd;
break;
case '[':
token.type_ = tokenArrayBegin;
break;
case ']':
token.type_ = tokenArrayEnd;
break;
case '"':
token.type_ = tokenString;
ok = readString();
break;
case '/':
token.type_ = tokenComment;
ok = readComment();
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case '-':
token.type_ = tokenNumber;
readNumber();
break;
case 't':
token.type_ = tokenTrue;
ok = match("rue", 3);
break;
case 'f':
token.type_ = tokenFalse;
ok = match("alse", 4);
break;
case 'n':
token.type_ = tokenNull;
ok = match("ull", 3);
break;
case ',':
token.type_ = tokenArraySeparator;
break;
case ':':
token.type_ = tokenMemberSeparator;
break;
case 0:
token.type_ = tokenEndOfStream;
break;
default:
ok = false;
break;
}
if (!ok)
token.type_ = tokenError;
token.end_ = current_;
return ok;
}
void Reader::skipSpaces() {
while (current_ != end_) {
Char c = *current_;
if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
++current_;
else
break;
}
}
bool Reader::match(const Char* pattern, int patternLength) {
if (end_ - current_ < patternLength)
return false;
int index = patternLength;
while (index--)
if (current_[index] != pattern[index])
return false;
current_ += patternLength;
return true;
}
bool Reader::readComment() {
Location commentBegin = current_ - 1;
Char c = getNextChar();
bool successful = false;
if (c == '*')
successful = readCStyleComment();
else if (c == '/')
successful = readCppStyleComment();
if (!successful)
return false;
if (collectComments_) {
CommentPlacement placement = commentBefore;
if (lastValueEnd_ && !containsNewLine(lastValueEnd_, commentBegin)) {
if (c != '*' || !containsNewLine(commentBegin, current_))
placement = commentAfterOnSameLine;
}
addComment(commentBegin, current_, placement);
}
return true;
}
String Reader::normalizeEOL(Reader::Location begin, Reader::Location end) {
String normalized;
normalized.reserve(static_cast<size_t>(end - begin));
Reader::Location current = begin;
while (current != end) {
char c = *current++;
if (c == '\r') {
if (current != end && *current == '\n')
// convert dos EOL
++current;
// convert Mac EOL
normalized += '\n';
} else {
normalized += c;
}
}
return normalized;
}
void Reader::addComment(Location begin, Location end,
CommentPlacement placement) {
assert(collectComments_);
const String& normalized = normalizeEOL(begin, end);
if (placement == commentAfterOnSameLine) {
assert(lastValue_ != nullptr);
lastValue_->setComment(normalized, placement);
} else {
commentsBefore_ += normalized;
}
}
bool Reader::readCStyleComment() {
while ((current_ + 1) < end_) {
Char c = getNextChar();
if (c == '*' && *current_ == '/')
break;
}
return getNextChar() == '/';
}
bool Reader::readCppStyleComment() {
while (current_ != end_) {
Char c = getNextChar();
if (c == '\n')
break;
if (c == '\r') {
// Consume DOS EOL. It will be normalized in addComment.
if (current_ != end_ && *current_ == '\n')
getNextChar();
// Break on Moc OS 9 EOL.
break;
}
}
return true;
}
void Reader::readNumber() {
Location p = current_;
char c = '0'; // stopgap for already consumed character
// integral part
while (c >= '0' && c <= '9')
c = (current_ = p) < end_ ? *p++ : '\0';
// fractional part
if (c == '.') {
c = (current_ = p) < end_ ? *p++ : '\0';
while (c >= '0' && c <= '9')
c = (current_ = p) < end_ ? *p++ : '\0';
}
// exponential part
if (c == 'e' || c == 'E') {
c = (current_ = p) < end_ ? *p++ : '\0';
if (c == '+' || c == '-')
c = (current_ = p) < end_ ? *p++ : '\0';
while (c >= '0' && c <= '9')
c = (current_ = p) < end_ ? *p++ : '\0';
}
}
bool Reader::readString() {
Char c = '\0';
while (current_ != end_) {
c = getNextChar();
if (c == '\\')
getNextChar();
else if (c == '"')
break;
}
return c == '"';
}
bool Reader::readObject(Token& token) {
Token tokenName;
String name;
Value init(objectValue);
currentValue().swapPayload(init);
currentValue().setOffsetStart(token.start_ - begin_);
while (readToken(tokenName)) {
bool initialTokenOk = true;
while (tokenName.type_ == tokenComment && initialTokenOk)
initialTokenOk = readToken(tokenName);
if (!initialTokenOk)
break;
if (tokenName.type_ == tokenObjectEnd && name.empty()) // empty object
return true;
name.clear();
if (tokenName.type_ == tokenString) {
if (!decodeString(tokenName, name))
return recoverFromError(tokenObjectEnd);
} else if (tokenName.type_ == tokenNumber && features_.allowNumericKeys_) {
Value numberName;
if (!decodeNumber(tokenName, numberName))
return recoverFromError(tokenObjectEnd);
name = numberName.asString();
} else {
break;
}
Token colon;
if (!readToken(colon) || colon.type_ != tokenMemberSeparator) {
return addErrorAndRecover("Missing ':' after object member name", colon,
tokenObjectEnd);
}
Value& value = currentValue()[name];
nodes_.push(&value);
bool ok = readValue();
nodes_.pop();
if (!ok) // error already set
return recoverFromError(tokenObjectEnd);
Token comma;
if (!readToken(comma) ||
(comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator &&
comma.type_ != tokenComment)) {
return addErrorAndRecover("Missing ',' or '}' in object declaration",
comma, tokenObjectEnd);
}
bool finalizeTokenOk = true;
while (comma.type_ == tokenComment && finalizeTokenOk)
finalizeTokenOk = readToken(comma);
if (comma.type_ == tokenObjectEnd)
return true;
}
return addErrorAndRecover("Missing '}' or object member name", tokenName,
tokenObjectEnd);
}
bool Reader::readArray(Token& token) {
Value init(arrayValue);
currentValue().swapPayload(init);
currentValue().setOffsetStart(token.start_ - begin_);
skipSpaces();
if (current_ != end_ && *current_ == ']') // empty array
{
Token endArray;
readToken(endArray);
return true;
}
int index = 0;
for (;;) {
Value& value = currentValue()[index++];
nodes_.push(&value);
bool ok = readValue();
nodes_.pop();
if (!ok) // error already set
return recoverFromError(tokenArrayEnd);
Token currentToken;
// Accept Comment after last item in the array.
ok = readToken(currentToken);
while (currentToken.type_ == tokenComment && ok) {
ok = readToken(currentToken);
}
bool badTokenType = (currentToken.type_ != tokenArraySeparator &&
currentToken.type_ != tokenArrayEnd);
if (!ok || badTokenType) {
return addErrorAndRecover("Missing ',' or ']' in array declaration",
currentToken, tokenArrayEnd);
}
if (currentToken.type_ == tokenArrayEnd)
break;
}
return true;
}
bool Reader::decodeNumber(Token& token) {
Value decoded;
if (!decodeNumber(token, decoded))
return false;
currentValue().swapPayload(decoded);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return true;
}
bool Reader::decodeNumber(Token& token, Value& decoded) {
// Attempts to parse the number as an integer. If the number is
// larger than the maximum supported value of an integer then
// we decode the number as a double.
Location current = token.start_;
bool isNegative = *current == '-';
if (isNegative)
++current;
// TODO: Help the compiler do the div and mod at compile time or get rid of
// them.
Value::LargestUInt maxIntegerValue =
isNegative ? Value::LargestUInt(Value::maxLargestInt) + 1
: Value::maxLargestUInt;
Value::LargestUInt threshold = maxIntegerValue / 10;
Value::LargestUInt value = 0;
while (current < token.end_) {
Char c = *current++;
if (c < '0' || c > '9')
return decodeDouble(token, decoded);
auto digit(static_cast<Value::UInt>(c - '0'));
if (value >= threshold) {
// We've hit or exceeded the max value divided by 10 (rounded down). If
// a) we've only just touched the limit, b) this is the last digit, and
// c) it's small enough to fit in that rounding delta, we're okay.
// Otherwise treat this number as a double to avoid overflow.
if (value > threshold || current != token.end_ ||
digit > maxIntegerValue % 10) {
return decodeDouble(token, decoded);
}
}
value = value * 10 + digit;
}
if (isNegative && value == maxIntegerValue)
decoded = Value::minLargestInt;
else if (isNegative)
decoded = -Value::LargestInt(value);
else if (value <= Value::LargestUInt(Value::maxInt))
decoded = Value::LargestInt(value);
else
decoded = value;
return true;
}
bool Reader::decodeDouble(Token& token) {
Value decoded;
if (!decodeDouble(token, decoded))
return false;
currentValue().swapPayload(decoded);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return true;
}
bool Reader::decodeDouble(Token& token, Value& decoded) {
double value = 0;
String buffer(token.start_, token.end_);
IStringStream is(buffer);
if (!(is >> value))
return addError(
"'" + String(token.start_, token.end_) + "' is not a number.", token);
decoded = value;
return true;
}
bool Reader::decodeString(Token& token) {
String decoded_string;
if (!decodeString(token, decoded_string))
return false;
Value decoded(decoded_string);
currentValue().swapPayload(decoded);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return true;
}
bool Reader::decodeString(Token& token, String& decoded) {
decoded.reserve(static_cast<size_t>(token.end_ - token.start_ - 2));
Location current = token.start_ + 1; // skip '"'
Location end = token.end_ - 1; // do not include '"'
while (current != end) {
Char c = *current++;
if (c == '"')
break;
if (c == '\\') {
if (current == end)
return addError("Empty escape sequence in string", token, current);
Char escape = *current++;
switch (escape) {
case '"':
decoded += '"';
break;
case '/':
decoded += '/';
break;
case '\\':
decoded += '\\';
break;
case 'b':
decoded += '\b';
break;
case 'f':
decoded += '\f';
break;
case 'n':
decoded += '\n';
break;
case 'r':
decoded += '\r';
break;
case 't':
decoded += '\t';
break;
case 'u': {
unsigned int unicode;
if (!decodeUnicodeCodePoint(token, current, end, unicode))
return false;
decoded += codePointToUTF8(unicode);
} break;
default:
return addError("Bad escape sequence in string", token, current);
}
} else {
decoded += c;
}
}
return true;
}
bool Reader::decodeUnicodeCodePoint(Token& token, Location& current,
Location end, unsigned int& unicode) {
if (!decodeUnicodeEscapeSequence(token, current, end, unicode))
return false;
if (unicode >= 0xD800 && unicode <= 0xDBFF) {
// surrogate pairs
if (end - current < 6)
return addError(
"additional six characters expected to parse unicode surrogate pair.",
token, current);
if (*(current++) == '\\' && *(current++) == 'u') {
unsigned int surrogatePair;
if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) {
unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
} else
return false;
} else
return addError("expecting another \\u token to begin the second half of "
"a unicode surrogate pair",
token, current);
}
return true;
}
bool Reader::decodeUnicodeEscapeSequence(Token& token, Location& current,
Location end,
unsigned int& ret_unicode) {
if (end - current < 4)
return addError(
"Bad unicode escape sequence in string: four digits expected.", token,
current);
int unicode = 0;
for (int index = 0; index < 4; ++index) {
Char c = *current++;
unicode *= 16;
if (c >= '0' && c <= '9')
unicode += c - '0';
else if (c >= 'a' && c <= 'f')
unicode += c - 'a' + 10;
else if (c >= 'A' && c <= 'F')
unicode += c - 'A' + 10;
else
return addError(
"Bad unicode escape sequence in string: hexadecimal digit expected.",
token, current);
}
ret_unicode = static_cast<unsigned int>(unicode);
return true;
}
bool Reader::addError(const String& message, Token& token, Location extra) {
ErrorInfo info;
info.token_ = token;
info.message_ = message;
info.extra_ = extra;
errors_.push_back(info);
return false;
}
bool Reader::recoverFromError(TokenType skipUntilToken) {
size_t const errorCount = errors_.size();
Token skip;
for (;;) {
if (!readToken(skip))
errors_.resize(errorCount); // discard errors caused by recovery
if (skip.type_ == skipUntilToken || skip.type_ == tokenEndOfStream)
break;
}
errors_.resize(errorCount);
return false;
}
bool Reader::addErrorAndRecover(const String& message, Token& token,
TokenType skipUntilToken) {
addError(message, token);
return recoverFromError(skipUntilToken);
}
Value& Reader::currentValue() { return *(nodes_.top()); }
Reader::Char Reader::getNextChar() {
if (current_ == end_)
return 0;
return *current_++;
}
void Reader::getLocationLineAndColumn(Location location, int& line,
int& column) const {
Location current = begin_;
Location lastLineStart = current;
line = 0;
while (current < location && current != end_) {
Char c = *current++;
if (c == '\r') {
if (*current == '\n')
++current;
lastLineStart = current;
++line;
} else if (c == '\n') {
lastLineStart = current;
++line;
}
}
// column & line start at 1
column = int(location - lastLineStart) + 1;
++line;
}
String Reader::getLocationLineAndColumn(Location location) const {
int line, column;
getLocationLineAndColumn(location, line, column);
char buffer[18 + 16 + 16 + 1];
jsoncpp_snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
return buffer;
}
// Deprecated. Preserved for backward compatibility
String Reader::getFormatedErrorMessages() const {
return getFormattedErrorMessages();
}
String Reader::getFormattedErrorMessages() const {
String formattedMessage;
for (const auto& error : errors_) {
formattedMessage +=
"* " + getLocationLineAndColumn(error.token_.start_) + "\n";
formattedMessage += " " + error.message_ + "\n";
if (error.extra_)
formattedMessage +=
"See " + getLocationLineAndColumn(error.extra_) + " for detail.\n";
}
return formattedMessage;
}
std::vector<Reader::StructuredError> Reader::getStructuredErrors() const {
std::vector<Reader::StructuredError> allErrors;
for (const auto& error : errors_) {
Reader::StructuredError structured;
structured.offset_start = error.token_.start_ - begin_;
structured.offset_limit = error.token_.end_ - begin_;
structured.message = error.message_;
allErrors.push_back(structured);
}
return allErrors;
}
bool Reader::pushError(const Value& value, const String& message) {
ptrdiff_t const length = end_ - begin_;
if (value.getOffsetStart() > length || value.getOffsetLimit() > length)
return false;
Token token;
token.type_ = tokenError;
token.start_ = begin_ + value.getOffsetStart();
token.end_ = begin_ + value.getOffsetLimit();
ErrorInfo info;
info.token_ = token;
info.message_ = message;
info.extra_ = nullptr;
errors_.push_back(info);
return true;
}
bool Reader::pushError(const Value& value, const String& message,
const Value& extra) {
ptrdiff_t const length = end_ - begin_;
if (value.getOffsetStart() > length || value.getOffsetLimit() > length ||
extra.getOffsetLimit() > length)
return false;
Token token;
token.type_ = tokenError;
token.start_ = begin_ + value.getOffsetStart();
token.end_ = begin_ + value.getOffsetLimit();
ErrorInfo info;
info.token_ = token;
info.message_ = message;
info.extra_ = begin_ + extra.getOffsetStart();
errors_.push_back(info);
return true;
}
bool Reader::good() const { return errors_.empty(); }
// Originally copied from the Features class (now deprecated), used internally
// for features implementation.
class OurFeatures {
public:
static OurFeatures all();
bool allowComments_;
bool allowTrailingCommas_;
bool strictRoot_;
bool allowDroppedNullPlaceholders_;
bool allowNumericKeys_;
bool allowSingleQuotes_;
bool failIfExtra_;
bool rejectDupKeys_;
bool allowSpecialFloats_;
bool skipBom_;
size_t stackLimit_;
}; // OurFeatures
OurFeatures OurFeatures::all() { return {}; }
// Implementation of class Reader
// ////////////////////////////////
// Originally copied from the Reader class (now deprecated), used internally
// for implementing JSON reading.
class OurReader {
public:
using Char = char;
using Location = const Char*;
struct StructuredError {
ptrdiff_t offset_start;
ptrdiff_t offset_limit;
String message;
};
explicit OurReader(OurFeatures const& features);
bool parse(const char* beginDoc, const char* endDoc, Value& root,
bool collectComments = true);
String getFormattedErrorMessages() const;
std::vector<StructuredError> getStructuredErrors() const;
private:
OurReader(OurReader const&); // no impl
void operator=(OurReader const&); // no impl
enum TokenType {
tokenEndOfStream = 0,
tokenObjectBegin,
tokenObjectEnd,
tokenArrayBegin,
tokenArrayEnd,
tokenString,
tokenNumber,
tokenTrue,
tokenFalse,
tokenNull,
tokenNaN,
tokenPosInf,
tokenNegInf,
tokenArraySeparator,
tokenMemberSeparator,
tokenComment,
tokenError
};
class Token {
public:
TokenType type_;
Location start_;
Location end_;
};
class ErrorInfo {
public:
Token token_;
String message_;
Location extra_;
};
using Errors = std::deque<ErrorInfo>;
bool readToken(Token& token);
void skipSpaces();
void skipBom(bool skipBom);
bool match(const Char* pattern, int patternLength);
bool readComment();
bool readCStyleComment(bool* containsNewLineResult);
bool readCppStyleComment();
bool readString();
bool readStringSingleQuote();
bool readNumber(bool checkInf);
bool readValue();
bool readObject(Token& token);
bool readArray(Token& token);
bool decodeNumber(Token& token);
bool decodeNumber(Token& token, Value& decoded);
bool decodeString(Token& token);
bool decodeString(Token& token, String& decoded);
bool decodeDouble(Token& token);
bool decodeDouble(Token& token, Value& decoded);
bool decodeUnicodeCodePoint(Token& token, Location& current, Location end,
unsigned int& unicode);
bool decodeUnicodeEscapeSequence(Token& token, Location& current,
Location end, unsigned int& unicode);
bool addError(const String& message, Token& token, Location extra = nullptr);
bool recoverFromError(TokenType skipUntilToken);
bool addErrorAndRecover(const String& message, Token& token,
TokenType skipUntilToken);
void skipUntilSpace();
Value& currentValue();
Char getNextChar();
void getLocationLineAndColumn(Location location, int& line,
int& column) const;
String getLocationLineAndColumn(Location location) const;
void addComment(Location begin, Location end, CommentPlacement placement);
void skipCommentTokens(Token& token);
static String normalizeEOL(Location begin, Location end);
static bool containsNewLine(Location begin, Location end);
using Nodes = std::stack<Value*>;
Nodes nodes_{};
Errors errors_{};
String document_{};
Location begin_ = nullptr;
Location end_ = nullptr;
Location current_ = nullptr;
Location lastValueEnd_ = nullptr;
Value* lastValue_ = nullptr;
bool lastValueHasAComment_ = false;
String commentsBefore_{};
OurFeatures const features_;
bool collectComments_ = false;
}; // OurReader
// complete copy of Read impl, for OurReader
bool OurReader::containsNewLine(OurReader::Location begin,
OurReader::Location end) {
return std::any_of(begin, end, [](char b) { return b == '\n' || b == '\r'; });
}
OurReader::OurReader(OurFeatures const& features) : features_(features) {}
bool OurReader::parse(const char* beginDoc, const char* endDoc, Value& root,
bool collectComments) {
if (!features_.allowComments_) {
collectComments = false;
}
begin_ = beginDoc;
end_ = endDoc;
collectComments_ = collectComments;
current_ = begin_;
lastValueEnd_ = nullptr;
lastValue_ = nullptr;
commentsBefore_.clear();
errors_.clear();
while (!nodes_.empty())
nodes_.pop();
nodes_.push(&root);
// skip byte order mark if it exists at the beginning of the UTF-8 text.
skipBom(features_.skipBom_);
bool successful = readValue();
nodes_.pop();
Token token;
skipCommentTokens(token);
if (features_.failIfExtra_ && (token.type_ != tokenEndOfStream)) {
addError("Extra non-whitespace after JSON value.", token);
return false;
}
if (collectComments_ && !commentsBefore_.empty())
root.setComment(commentsBefore_, commentAfter);
if (features_.strictRoot_) {
if (!root.isArray() && !root.isObject()) {
// Set error location to start of doc, ideally should be first token found
// in doc
token.type_ = tokenError;
token.start_ = beginDoc;
token.end_ = endDoc;
addError(
"A valid JSON document must be either an array or an object value.",
token);
return false;
}
}
return successful;
}
bool OurReader::readValue() {
// To preserve the old behaviour we cast size_t to int.
if (nodes_.size() > features_.stackLimit_)
throwRuntimeError("Exceeded stackLimit in readValue().");
Token token;
skipCommentTokens(token);
bool successful = true;
if (collectComments_ && !commentsBefore_.empty()) {
currentValue().setComment(commentsBefore_, commentBefore);
commentsBefore_.clear();
}
switch (token.type_) {
case tokenObjectBegin:
successful = readObject(token);
currentValue().setOffsetLimit(current_ - begin_);
break;
case tokenArrayBegin:
successful = readArray(token);
currentValue().setOffsetLimit(current_ - begin_);
break;
case tokenNumber:
successful = decodeNumber(token);
break;
case tokenString:
successful = decodeString(token);
break;
case tokenTrue: {
Value v(true);
currentValue().swapPayload(v);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
} break;
case tokenFalse: {
Value v(false);
currentValue().swapPayload(v);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
} break;
case tokenNull: {
Value v;
currentValue().swapPayload(v);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
} break;
case tokenNaN: {
Value v(std::numeric_limits<double>::quiet_NaN());
currentValue().swapPayload(v);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
} break;
case tokenPosInf: {
Value v(std::numeric_limits<double>::infinity());
currentValue().swapPayload(v);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
} break;
case tokenNegInf: {
Value v(-std::numeric_limits<double>::infinity());
currentValue().swapPayload(v);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
} break;
case tokenArraySeparator:
case tokenObjectEnd:
case tokenArrayEnd:
if (features_.allowDroppedNullPlaceholders_) {
// "Un-read" the current token and mark the current value as a null
// token.
current_--;
Value v;
currentValue().swapPayload(v);
currentValue().setOffsetStart(current_ - begin_ - 1);
currentValue().setOffsetLimit(current_ - begin_);
break;
} // else, fall through ...
default:
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return addError("Syntax error: value, object or array expected.", token);
}
if (collectComments_) {
lastValueEnd_ = current_;
lastValueHasAComment_ = false;
lastValue_ = ¤tValue();
}
return successful;
}
void OurReader::skipCommentTokens(Token& token) {
if (features_.allowComments_) {
do {
readToken(token);
} while (token.type_ == tokenComment);
} else {
readToken(token);
}
}
bool OurReader::readToken(Token& token) {
skipSpaces();
token.start_ = current_;
Char c = getNextChar();
bool ok = true;
switch (c) {
case '{':
token.type_ = tokenObjectBegin;
break;
case '}':
token.type_ = tokenObjectEnd;
break;
case '[':
token.type_ = tokenArrayBegin;
break;
case ']':
token.type_ = tokenArrayEnd;
break;
case '"':
token.type_ = tokenString;
ok = readString();
break;
case '\'':
if (features_.allowSingleQuotes_) {
token.type_ = tokenString;
ok = readStringSingleQuote();
} else {
// If we don't allow single quotes, this is a failure case.
ok = false;
}
break;
case '/':
token.type_ = tokenComment;
ok = readComment();
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
token.type_ = tokenNumber;
readNumber(false);
break;
case '-':
if (readNumber(true)) {
token.type_ = tokenNumber;
} else {
token.type_ = tokenNegInf;
ok = features_.allowSpecialFloats_ && match("nfinity", 7);
}
break;
case '+':
if (readNumber(true)) {
token.type_ = tokenNumber;
} else {
token.type_ = tokenPosInf;
ok = features_.allowSpecialFloats_ && match("nfinity", 7);
}
break;
case 't':
token.type_ = tokenTrue;
ok = match("rue", 3);
break;
case 'f':
token.type_ = tokenFalse;
ok = match("alse", 4);
break;
case 'n':
token.type_ = tokenNull;
ok = match("ull", 3);
break;
case 'N':
if (features_.allowSpecialFloats_) {
token.type_ = tokenNaN;
ok = match("aN", 2);
} else {
ok = false;
}
break;
case 'I':
if (features_.allowSpecialFloats_) {
token.type_ = tokenPosInf;
ok = match("nfinity", 7);
} else {
ok = false;
}
break;
case ',':
token.type_ = tokenArraySeparator;
break;
case ':':
token.type_ = tokenMemberSeparator;
break;
case 0:
token.type_ = tokenEndOfStream;
break;
default:
ok = false;
break;
}
if (!ok)
token.type_ = tokenError;
token.end_ = current_;
return ok;
}
void OurReader::skipSpaces() {
while (current_ != end_) {
Char c = *current_;
if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
++current_;
else
break;
}
}
void OurReader::skipBom(bool skipBom) {
// The default behavior is to skip BOM.
if (skipBom) {
if ((end_ - begin_) >= 3 && strncmp(begin_, "\xEF\xBB\xBF", 3) == 0) {
begin_ += 3;
current_ = begin_;
}
}
}
bool OurReader::match(const Char* pattern, int patternLength) {
if (end_ - current_ < patternLength)
return false;
int index = patternLength;
while (index--)
if (current_[index] != pattern[index])
return false;
current_ += patternLength;
return true;
}
bool OurReader::readComment() {
const Location commentBegin = current_ - 1;
const Char c = getNextChar();
bool successful = false;
bool cStyleWithEmbeddedNewline = false;
const bool isCStyleComment = (c == '*');
const bool isCppStyleComment = (c == '/');
if (isCStyleComment) {
successful = readCStyleComment(&cStyleWithEmbeddedNewline);
} else if (isCppStyleComment) {
successful = readCppStyleComment();
}
if (!successful)
return false;
if (collectComments_) {
CommentPlacement placement = commentBefore;
if (!lastValueHasAComment_) {
if (lastValueEnd_ && !containsNewLine(lastValueEnd_, commentBegin)) {
if (isCppStyleComment || !cStyleWithEmbeddedNewline) {
placement = commentAfterOnSameLine;
lastValueHasAComment_ = true;
}
}
}
addComment(commentBegin, current_, placement);
}
return true;
}
String OurReader::normalizeEOL(OurReader::Location begin,
OurReader::Location end) {
String normalized;
normalized.reserve(static_cast<size_t>(end - begin));
OurReader::Location current = begin;
while (current != end) {
char c = *current++;
if (c == '\r') {
if (current != end && *current == '\n')
// convert dos EOL
++current;
// convert Mac EOL
normalized += '\n';
} else {
normalized += c;
}
}
return normalized;
}
void OurReader::addComment(Location begin, Location end,
CommentPlacement placement) {
assert(collectComments_);
const String& normalized = normalizeEOL(begin, end);
if (placement == commentAfterOnSameLine) {
assert(lastValue_ != nullptr);
lastValue_->setComment(normalized, placement);
} else {
commentsBefore_ += normalized;
}
}
bool OurReader::readCStyleComment(bool* containsNewLineResult) {
*containsNewLineResult = false;
while ((current_ + 1) < end_) {
Char c = getNextChar();
if (c == '*' && *current_ == '/')
break;
if (c == '\n')
*containsNewLineResult = true;
}
return getNextChar() == '/';
}
bool OurReader::readCppStyleComment() {
while (current_ != end_) {
Char c = getNextChar();
if (c == '\n')
break;
if (c == '\r') {
// Consume DOS EOL. It will be normalized in addComment.
if (current_ != end_ && *current_ == '\n')
getNextChar();
// Break on Moc OS 9 EOL.
break;
}
}
return true;
}
bool OurReader::readNumber(bool checkInf) {
Location p = current_;
if (checkInf && p != end_ && *p == 'I') {
current_ = ++p;
return false;
}
char c = '0'; // stopgap for already consumed character
// integral part
while (c >= '0' && c <= '9')
c = (current_ = p) < end_ ? *p++ : '\0';
// fractional part
if (c == '.') {
c = (current_ = p) < end_ ? *p++ : '\0';
while (c >= '0' && c <= '9')
c = (current_ = p) < end_ ? *p++ : '\0';
}
// exponential part
if (c == 'e' || c == 'E') {
c = (current_ = p) < end_ ? *p++ : '\0';
if (c == '+' || c == '-')
c = (current_ = p) < end_ ? *p++ : '\0';
while (c >= '0' && c <= '9')
c = (current_ = p) < end_ ? *p++ : '\0';
}
return true;
}
bool OurReader::readString() {
Char c = 0;
while (current_ != end_) {
c = getNextChar();
if (c == '\\')
getNextChar();
else if (c == '"')
break;
}
return c == '"';
}
bool OurReader::readStringSingleQuote() {
Char c = 0;
while (current_ != end_) {
c = getNextChar();
if (c == '\\')
getNextChar();
else if (c == '\'')
break;
}
return c == '\'';
}
bool OurReader::readObject(Token& token) {
Token tokenName;
String name;
Value init(objectValue);
currentValue().swapPayload(init);
currentValue().setOffsetStart(token.start_ - begin_);
while (readToken(tokenName)) {
bool initialTokenOk = true;
while (tokenName.type_ == tokenComment && initialTokenOk)
initialTokenOk = readToken(tokenName);
if (!initialTokenOk)
break;
if (tokenName.type_ == tokenObjectEnd &&
(name.empty() ||
features_.allowTrailingCommas_)) // empty object or trailing comma
return true;
name.clear();
if (tokenName.type_ == tokenString) {
if (!decodeString(tokenName, name))
return recoverFromError(tokenObjectEnd);
} else if (tokenName.type_ == tokenNumber && features_.allowNumericKeys_) {
Value numberName;
if (!decodeNumber(tokenName, numberName))
return recoverFromError(tokenObjectEnd);
name = numberName.asString();
} else {
break;
}
if (name.length() >= (1U << 30))
throwRuntimeError("keylength >= 2^30");
if (features_.rejectDupKeys_ && currentValue().isMember(name)) {
String msg = "Duplicate key: '" + name + "'";
return addErrorAndRecover(msg, tokenName, tokenObjectEnd);
}
Token colon;
if (!readToken(colon) || colon.type_ != tokenMemberSeparator) {
return addErrorAndRecover("Missing ':' after object member name", colon,
tokenObjectEnd);
}
Value& value = currentValue()[name];
nodes_.push(&value);
bool ok = readValue();
nodes_.pop();
if (!ok) // error already set
return recoverFromError(tokenObjectEnd);
Token comma;
if (!readToken(comma) ||
(comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator &&
comma.type_ != tokenComment)) {
return addErrorAndRecover("Missing ',' or '}' in object declaration",
comma, tokenObjectEnd);
}
bool finalizeTokenOk = true;
while (comma.type_ == tokenComment && finalizeTokenOk)
finalizeTokenOk = readToken(comma);
if (comma.type_ == tokenObjectEnd)
return true;
}
return addErrorAndRecover("Missing '}' or object member name", tokenName,
tokenObjectEnd);
}
bool OurReader::readArray(Token& token) {
Value init(arrayValue);
currentValue().swapPayload(init);
currentValue().setOffsetStart(token.start_ - begin_);
int index = 0;
for (;;) {
skipSpaces();
if (current_ != end_ && *current_ == ']' &&
(index == 0 ||
(features_.allowTrailingCommas_ &&
!features_.allowDroppedNullPlaceholders_))) // empty array or trailing
// comma
{
Token endArray;
readToken(endArray);
return true;
}
Value& value = currentValue()[index++];
nodes_.push(&value);
bool ok = readValue();
nodes_.pop();
if (!ok) // error already set
return recoverFromError(tokenArrayEnd);
Token currentToken;
// Accept Comment after last item in the array.
ok = readToken(currentToken);
while (currentToken.type_ == tokenComment && ok) {
ok = readToken(currentToken);
}
bool badTokenType = (currentToken.type_ != tokenArraySeparator &&
currentToken.type_ != tokenArrayEnd);
if (!ok || badTokenType) {
return addErrorAndRecover("Missing ',' or ']' in array declaration",
currentToken, tokenArrayEnd);
}
if (currentToken.type_ == tokenArrayEnd)
break;
}
return true;
}
bool OurReader::decodeNumber(Token& token) {
Value decoded;
if (!decodeNumber(token, decoded))
return false;
currentValue().swapPayload(decoded);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return true;
}
bool OurReader::decodeNumber(Token& token, Value& decoded) {
// Attempts to parse the number as an integer. If the number is
// larger than the maximum supported value of an integer then
// we decode the number as a double.
Location current = token.start_;
const bool isNegative = *current == '-';
if (isNegative) {
++current;
}
// We assume we can represent the largest and smallest integer types as
// unsigned integers with separate sign. This is only true if they can fit
// into an unsigned integer.
static_assert(Value::maxLargestInt <= Value::maxLargestUInt,
"Int must be smaller than UInt");
// We need to convert minLargestInt into a positive number. The easiest way
// to do this conversion is to assume our "threshold" value of minLargestInt
// divided by 10 can fit in maxLargestInt when absolute valued. This should
// be a safe assumption.
static_assert(Value::minLargestInt <= -Value::maxLargestInt,
"The absolute value of minLargestInt must be greater than or "
"equal to maxLargestInt");
static_assert(Value::minLargestInt / 10 >= -Value::maxLargestInt,
"The absolute value of minLargestInt must be only 1 magnitude "
"larger than maxLargest Int");
static constexpr Value::LargestUInt positive_threshold =
Value::maxLargestUInt / 10;
static constexpr Value::UInt positive_last_digit = Value::maxLargestUInt % 10;
// For the negative values, we have to be more careful. Since typically
// -Value::minLargestInt will cause an overflow, we first divide by 10 and
// then take the inverse. This assumes that minLargestInt is only a single
// power of 10 different in magnitude, which we check above. For the last
// digit, we take the modulus before negating for the same reason.
static constexpr auto negative_threshold =
Value::LargestUInt(-(Value::minLargestInt / 10));
static constexpr auto negative_last_digit =
Value::UInt(-(Value::minLargestInt % 10));
const Value::LargestUInt threshold =
isNegative ? negative_threshold : positive_threshold;
const Value::UInt max_last_digit =
isNegative ? negative_last_digit : positive_last_digit;
Value::LargestUInt value = 0;
while (current < token.end_) {
Char c = *current++;
if (c < '0' || c > '9')
return decodeDouble(token, decoded);
const auto digit(static_cast<Value::UInt>(c - '0'));
if (value >= threshold) {
// We've hit or exceeded the max value divided by 10 (rounded down). If
// a) we've only just touched the limit, meaing value == threshold,
// b) this is the last digit, or
// c) it's small enough to fit in that rounding delta, we're okay.
// Otherwise treat this number as a double to avoid overflow.
if (value > threshold || current != token.end_ ||
digit > max_last_digit) {
return decodeDouble(token, decoded);
}
}
value = value * 10 + digit;
}
if (isNegative) {
// We use the same magnitude assumption here, just in case.
const auto last_digit = static_cast<Value::UInt>(value % 10);
decoded = -Value::LargestInt(value / 10) * 10 - last_digit;
} else if (value <= Value::LargestUInt(Value::maxLargestInt)) {
decoded = Value::LargestInt(value);
} else {
decoded = value;
}
return true;
}
bool OurReader::decodeDouble(Token& token) {
Value decoded;
if (!decodeDouble(token, decoded))
return false;
currentValue().swapPayload(decoded);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return true;
}
bool OurReader::decodeDouble(Token& token, Value& decoded) {
double value = 0;
const String buffer(token.start_, token.end_);
IStringStream is(buffer);
if (!(is >> value)) {
return addError(
"'" + String(token.start_, token.end_) + "' is not a number.", token);
}
decoded = value;
return true;
}
bool OurReader::decodeString(Token& token) {
String decoded_string;
if (!decodeString(token, decoded_string))
return false;
Value decoded(decoded_string);
currentValue().swapPayload(decoded);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return true;
}
bool OurReader::decodeString(Token& token, String& decoded) {
decoded.reserve(static_cast<size_t>(token.end_ - token.start_ - 2));
Location current = token.start_ + 1; // skip '"'
Location end = token.end_ - 1; // do not include '"'
while (current != end) {
Char c = *current++;
if (c == '"')
break;
if (c == '\\') {
if (current == end)
return addError("Empty escape sequence in string", token, current);
Char escape = *current++;
switch (escape) {
case '"':
decoded += '"';
break;
case '/':
decoded += '/';
break;
case '\\':
decoded += '\\';
break;
case 'b':
decoded += '\b';
break;
case 'f':
decoded += '\f';
break;
case 'n':
decoded += '\n';
break;
case 'r':
decoded += '\r';
break;
case 't':
decoded += '\t';
break;
case 'u': {
unsigned int unicode;
if (!decodeUnicodeCodePoint(token, current, end, unicode))
return false;
decoded += codePointToUTF8(unicode);
} break;
default:
return addError("Bad escape sequence in string", token, current);
}
} else {
decoded += c;
}
}
return true;
}
bool OurReader::decodeUnicodeCodePoint(Token& token, Location& current,
Location end, unsigned int& unicode) {
if (!decodeUnicodeEscapeSequence(token, current, end, unicode))
return false;
if (unicode >= 0xD800 && unicode <= 0xDBFF) {
// surrogate pairs
if (end - current < 6)
return addError(
"additional six characters expected to parse unicode surrogate pair.",
token, current);
if (*(current++) == '\\' && *(current++) == 'u') {
unsigned int surrogatePair;
if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) {
unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
} else
return false;
} else
return addError("expecting another \\u token to begin the second half of "
"a unicode surrogate pair",
token, current);
}
return true;
}
bool OurReader::decodeUnicodeEscapeSequence(Token& token, Location& current,
Location end,
unsigned int& ret_unicode) {
if (end - current < 4)
return addError(
"Bad unicode escape sequence in string: four digits expected.", token,
current);
int unicode = 0;
for (int index = 0; index < 4; ++index) {
Char c = *current++;
unicode *= 16;
if (c >= '0' && c <= '9')
unicode += c - '0';
else if (c >= 'a' && c <= 'f')
unicode += c - 'a' + 10;
else if (c >= 'A' && c <= 'F')
unicode += c - 'A' + 10;
else
return addError(
"Bad unicode escape sequence in string: hexadecimal digit expected.",
token, current);
}
ret_unicode = static_cast<unsigned int>(unicode);
return true;
}
bool OurReader::addError(const String& message, Token& token, Location extra) {
ErrorInfo info;
info.token_ = token;
info.message_ = message;
info.extra_ = extra;
errors_.push_back(info);
return false;
}
bool OurReader::recoverFromError(TokenType skipUntilToken) {
size_t errorCount = errors_.size();
Token skip;
for (;;) {
if (!readToken(skip))
errors_.resize(errorCount); // discard errors caused by recovery
if (skip.type_ == skipUntilToken || skip.type_ == tokenEndOfStream)
break;
}
errors_.resize(errorCount);
return false;
}
bool OurReader::addErrorAndRecover(const String& message, Token& token,
TokenType skipUntilToken) {
addError(message, token);
return recoverFromError(skipUntilToken);
}
Value& OurReader::currentValue() { return *(nodes_.top()); }
OurReader::Char OurReader::getNextChar() {
if (current_ == end_)
return 0;
return *current_++;
}
void OurReader::getLocationLineAndColumn(Location location, int& line,
int& column) const {
Location current = begin_;
Location lastLineStart = current;
line = 0;
while (current < location && current != end_) {
Char c = *current++;
if (c == '\r') {
if (*current == '\n')
++current;
lastLineStart = current;
++line;
} else if (c == '\n') {
lastLineStart = current;
++line;
}
}
// column & line start at 1
column = int(location - lastLineStart) + 1;
++line;
}
String OurReader::getLocationLineAndColumn(Location location) const {
int line, column;
getLocationLineAndColumn(location, line, column);
char buffer[18 + 16 + 16 + 1];
jsoncpp_snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
return buffer;
}
String OurReader::getFormattedErrorMessages() const {
String formattedMessage;
for (const auto& error : errors_) {
formattedMessage +=
"* " + getLocationLineAndColumn(error.token_.start_) + "\n";
formattedMessage += " " + error.message_ + "\n";
if (error.extra_)
formattedMessage +=
"See " + getLocationLineAndColumn(error.extra_) + " for detail.\n";
}
return formattedMessage;
}
std::vector<OurReader::StructuredError> OurReader::getStructuredErrors() const {
std::vector<OurReader::StructuredError> allErrors;
for (const auto& error : errors_) {
OurReader::StructuredError structured;
structured.offset_start = error.token_.start_ - begin_;
structured.offset_limit = error.token_.end_ - begin_;
structured.message = error.message_;
allErrors.push_back(structured);
}
return allErrors;
}
class OurCharReader : public CharReader {
bool const collectComments_;
OurReader reader_;
public:
OurCharReader(bool collectComments, OurFeatures const& features)
: collectComments_(collectComments), reader_(features) {}
bool parse(char const* beginDoc, char const* endDoc, Value* root,
String* errs) override {
bool ok = reader_.parse(beginDoc, endDoc, *root, collectComments_);
if (errs) {
*errs = reader_.getFormattedErrorMessages();
}
return ok;
}
};
CharReaderBuilder::CharReaderBuilder() { setDefaults(&settings_); }
CharReaderBuilder::~CharReaderBuilder() = default;
CharReader* CharReaderBuilder::newCharReader() const {
bool collectComments = settings_["collectComments"].asBool();
OurFeatures features = OurFeatures::all();
features.allowComments_ = settings_["allowComments"].asBool();
features.allowTrailingCommas_ = settings_["allowTrailingCommas"].asBool();
features.strictRoot_ = settings_["strictRoot"].asBool();
features.allowDroppedNullPlaceholders_ =
settings_["allowDroppedNullPlaceholders"].asBool();
features.allowNumericKeys_ = settings_["allowNumericKeys"].asBool();
features.allowSingleQuotes_ = settings_["allowSingleQuotes"].asBool();
// Stack limit is always a size_t, so we get this as an unsigned int
// regardless of it we have 64-bit integer support enabled.
features.stackLimit_ = static_cast<size_t>(settings_["stackLimit"].asUInt());
features.failIfExtra_ = settings_["failIfExtra"].asBool();
features.rejectDupKeys_ = settings_["rejectDupKeys"].asBool();
features.allowSpecialFloats_ = settings_["allowSpecialFloats"].asBool();
features.skipBom_ = settings_["skipBom"].asBool();
return new OurCharReader(collectComments, features);
}
bool CharReaderBuilder::validate(Json::Value* invalid) const {
static const auto& valid_keys = *new std::set<String>{
"collectComments",
"allowComments",
"allowTrailingCommas",
"strictRoot",
"allowDroppedNullPlaceholders",
"allowNumericKeys",
"allowSingleQuotes",
"stackLimit",
"failIfExtra",
"rejectDupKeys",
"allowSpecialFloats",
"skipBom",
};
for (auto si = settings_.begin(); si != settings_.end(); ++si) {
auto key = si.name();
if (valid_keys.count(key))
continue;
if (invalid)
(*invalid)[key] = *si;
else
return false;
}
return invalid ? invalid->empty() : true;
}
Value& CharReaderBuilder::operator[](const String& key) {
return settings_[key];
}
// static
void CharReaderBuilder::strictMode(Json::Value* settings) {
//! [CharReaderBuilderStrictMode]
(*settings)["allowComments"] = false;
(*settings)["allowTrailingCommas"] = false;
(*settings)["strictRoot"] = true;
(*settings)["allowDroppedNullPlaceholders"] = false;
(*settings)["allowNumericKeys"] = false;
(*settings)["allowSingleQuotes"] = false;
(*settings)["stackLimit"] = 1000;
(*settings)["failIfExtra"] = true;
(*settings)["rejectDupKeys"] = true;
(*settings)["allowSpecialFloats"] = false;
(*settings)["skipBom"] = true;
//! [CharReaderBuilderStrictMode]
}
// static
void CharReaderBuilder::setDefaults(Json::Value* settings) {
//! [CharReaderBuilderDefaults]
(*settings)["collectComments"] = true;
(*settings)["allowComments"] = true;
(*settings)["allowTrailingCommas"] = true;
(*settings)["strictRoot"] = false;
(*settings)["allowDroppedNullPlaceholders"] = false;
(*settings)["allowNumericKeys"] = false;
(*settings)["allowSingleQuotes"] = false;
(*settings)["stackLimit"] = 1000;
(*settings)["failIfExtra"] = false;
(*settings)["rejectDupKeys"] = false;
(*settings)["allowSpecialFloats"] = false;
(*settings)["skipBom"] = true;
//! [CharReaderBuilderDefaults]
}
//////////////////////////////////
// global functions
bool parseFromStream(CharReader::Factory const& fact, IStream& sin, Value* root,
String* errs) {
OStringStream ssin;
ssin << sin.rdbuf();
String doc = ssin.str();
char const* begin = doc.data();
char const* end = begin + doc.size();
// Note that we do not actually need a null-terminator.
CharReaderPtr const reader(fact.newCharReader());
return reader->parse(begin, end, root, errs);
}
IStream& operator>>(IStream& sin, Value& root) {
CharReaderBuilder b;
String errs;
bool ok = parseFromStream(b, sin, &root, &errs);
if (!ok) {
throwRuntimeError(errs);
}
return sin;
}
} // namespace Json
// //////////////////////////////////////////////////////////////////////
// End of content of file: src/lib_json/json_reader.cpp
// //////////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////////
// Beginning of content of file: src/lib_json/json_valueiterator.inl
// //////////////////////////////////////////////////////////////////////
// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
// included by json_value.cpp
namespace Json {
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// class ValueIteratorBase
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
ValueIteratorBase::ValueIteratorBase() : current_() {}
ValueIteratorBase::ValueIteratorBase(
const Value::ObjectValues::iterator& current)
: current_(current), isNull_(false) {}
Value& ValueIteratorBase::deref() { return current_->second; }
const Value& ValueIteratorBase::deref() const { return current_->second; }
void ValueIteratorBase::increment() { ++current_; }
void ValueIteratorBase::decrement() { --current_; }
ValueIteratorBase::difference_type
ValueIteratorBase::computeDistance(const SelfType& other) const {
// Iterator for null value are initialized using the default
// constructor, which initialize current_ to the default
// std::map::iterator. As begin() and end() are two instance
// of the default std::map::iterator, they can not be compared.
// To allow this, we handle this comparison specifically.
if (isNull_ && other.isNull_) {
return 0;
}
// Usage of std::distance is not portable (does not compile with Sun Studio 12
// RogueWave STL,
// which is the one used by default).
// Using a portable hand-made version for non random iterator instead:
// return difference_type( std::distance( current_, other.current_ ) );
difference_type myDistance = 0;
for (Value::ObjectValues::iterator it = current_; it != other.current_;
++it) {
++myDistance;
}
return myDistance;
}
bool ValueIteratorBase::isEqual(const SelfType& other) const {
if (isNull_) {
return other.isNull_;
}
return current_ == other.current_;
}
void ValueIteratorBase::copy(const SelfType& other) {
current_ = other.current_;
isNull_ = other.isNull_;
}
Value ValueIteratorBase::key() const {
const Value::CZString czstring = (*current_).first;
if (czstring.data()) {
if (czstring.isStaticString())
return Value(StaticString(czstring.data()));
return Value(czstring.data(), czstring.data() + czstring.length());
}
return Value(czstring.index());
}
UInt ValueIteratorBase::index() const {
const Value::CZString czstring = (*current_).first;
if (!czstring.data())
return czstring.index();
return Value::UInt(-1);
}
String ValueIteratorBase::name() const {
char const* keey;
char const* end;
keey = memberName(&end);
if (!keey)
return String();
return String(keey, end);
}
char const* ValueIteratorBase::memberName() const {
const char* cname = (*current_).first.data();
return cname ? cname : "";
}
char const* ValueIteratorBase::memberName(char const** end) const {
const char* cname = (*current_).first.data();
if (!cname) {
*end = nullptr;
return nullptr;
}
*end = cname + (*current_).first.length();
return cname;
}
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// class ValueConstIterator
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
ValueConstIterator::ValueConstIterator() = default;
ValueConstIterator::ValueConstIterator(
const Value::ObjectValues::iterator& current)
: ValueIteratorBase(current) {}
ValueConstIterator::ValueConstIterator(ValueIterator const& other)
: ValueIteratorBase(other) {}
ValueConstIterator& ValueConstIterator::
operator=(const ValueIteratorBase& other) {
copy(other);
return *this;
}
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// class ValueIterator
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
ValueIterator::ValueIterator() = default;
ValueIterator::ValueIterator(const Value::ObjectValues::iterator& current)
: ValueIteratorBase(current) {}
ValueIterator::ValueIterator(const ValueConstIterator& other)
: ValueIteratorBase(other) {
throwRuntimeError("ConstIterator to Iterator should never be allowed.");
}
ValueIterator::ValueIterator(const ValueIterator& other) = default;
ValueIterator& ValueIterator::operator=(const SelfType& other) {
copy(other);
return *this;
}
} // namespace Json
// //////////////////////////////////////////////////////////////////////
// End of content of file: src/lib_json/json_valueiterator.inl
// //////////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////////
// Beginning of content of file: src/lib_json/json_value.cpp
// //////////////////////////////////////////////////////////////////////
// Copyright 2011 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#if !defined(JSON_IS_AMALGAMATION)
#include <json/assertions.h>
#include <json/value.h>
#include <json/writer.h>
#endif // if !defined(JSON_IS_AMALGAMATION)
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstddef>
#include <cstring>
#include <iostream>
#include <sstream>
#include <utility>
// Provide implementation equivalent of std::snprintf for older _MSC compilers
#if defined(_MSC_VER) && _MSC_VER < 1900
#include <stdarg.h>
static int msvc_pre1900_c99_vsnprintf(char* outBuf, size_t size,
const char* format, va_list ap) {
int count = -1;
if (size != 0)
count = _vsnprintf_s(outBuf, size, _TRUNCATE, format, ap);
if (count == -1)
count = _vscprintf(format, ap);
return count;
}
int JSON_API msvc_pre1900_c99_snprintf(char* outBuf, size_t size,
const char* format, ...) {
va_list ap;
va_start(ap, format);
const int count = msvc_pre1900_c99_vsnprintf(outBuf, size, format, ap);
va_end(ap);
return count;
}
#endif
// Disable warning C4702 : unreachable code
#if defined(_MSC_VER)
#pragma warning(disable : 4702)
#endif
#define JSON_ASSERT_UNREACHABLE assert(false)
namespace Json {
template <typename T>
static std::unique_ptr<T> cloneUnique(const std::unique_ptr<T>& p) {
std::unique_ptr<T> r;
if (p) {
r = std::unique_ptr<T>(new T(*p));
}
return r;
}
// This is a walkaround to avoid the static initialization of Value::null.
// kNull must be word-aligned to avoid crashing on ARM. We use an alignment of
// 8 (instead of 4) as a bit of future-proofing.
#if defined(__ARMEL__)
#define ALIGNAS(byte_alignment) __attribute__((aligned(byte_alignment)))
#else
#define ALIGNAS(byte_alignment)
#endif
// static
Value const& Value::nullSingleton() {
static Value const nullStatic;
return nullStatic;
}
#if JSON_USE_NULLREF
// for backwards compatibility, we'll leave these global references around, but
// DO NOT use them in JSONCPP library code any more!
// static
Value const& Value::null = Value::nullSingleton();
// static
Value const& Value::nullRef = Value::nullSingleton();
#endif
#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
template <typename T, typename U>
static inline bool InRange(double d, T min, U max) {
// The casts can lose precision, but we are looking only for
// an approximate range. Might fail on edge cases though. ~cdunn
return d >= static_cast<double>(min) && d <= static_cast<double>(max);
}
#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
static inline double integerToDouble(Json::UInt64 value) {
return static_cast<double>(Int64(value / 2)) * 2.0 +
static_cast<double>(Int64(value & 1));
}
template <typename T> static inline double integerToDouble(T value) {
return static_cast<double>(value);
}
template <typename T, typename U>
static inline bool InRange(double d, T min, U max) {
return d >= integerToDouble(min) && d <= integerToDouble(max);
}
#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
/** Duplicates the specified string value.
* @param value Pointer to the string to duplicate. Must be zero-terminated if
* length is "unknown".
* @param length Length of the value. if equals to unknown, then it will be
* computed using strlen(value).
* @return Pointer on the duplicate instance of string.
*/
static inline char* duplicateStringValue(const char* value, size_t length) {
// Avoid an integer overflow in the call to malloc below by limiting length
// to a sane value.
if (length >= static_cast<size_t>(Value::maxInt))
length = Value::maxInt - 1;
auto newString = static_cast<char*>(malloc(length + 1));
if (newString == nullptr) {
throwRuntimeError("in Json::Value::duplicateStringValue(): "
"Failed to allocate string value buffer");
}
memcpy(newString, value, length);
newString[length] = 0;
return newString;
}
/* Record the length as a prefix.
*/
static inline char* duplicateAndPrefixStringValue(const char* value,
unsigned int length) {
// Avoid an integer overflow in the call to malloc below by limiting length
// to a sane value.
JSON_ASSERT_MESSAGE(length <= static_cast<unsigned>(Value::maxInt) -
sizeof(unsigned) - 1U,
"in Json::Value::duplicateAndPrefixStringValue(): "
"length too big for prefixing");
size_t actualLength = sizeof(length) + length + 1;
auto newString = static_cast<char*>(malloc(actualLength));
if (newString == nullptr) {
throwRuntimeError("in Json::Value::duplicateAndPrefixStringValue(): "
"Failed to allocate string value buffer");
}
*reinterpret_cast<unsigned*>(newString) = length;
memcpy(newString + sizeof(unsigned), value, length);
newString[actualLength - 1U] =
0; // to avoid buffer over-run accidents by users later
return newString;
}
inline static void decodePrefixedString(bool isPrefixed, char const* prefixed,
unsigned* length, char const** value) {
if (!isPrefixed) {
*length = static_cast<unsigned>(strlen(prefixed));
*value = prefixed;
} else {
*length = *reinterpret_cast<unsigned const*>(prefixed);
*value = prefixed + sizeof(unsigned);
}
}
/** Free the string duplicated by
* duplicateStringValue()/duplicateAndPrefixStringValue().
*/
#if JSONCPP_USING_SECURE_MEMORY
static inline void releasePrefixedStringValue(char* value) {
unsigned length = 0;
char const* valueDecoded;
decodePrefixedString(true, value, &length, &valueDecoded);
size_t const size = sizeof(unsigned) + length + 1U;
memset(value, 0, size);
free(value);
}
static inline void releaseStringValue(char* value, unsigned length) {
// length==0 => we allocated the strings memory
size_t size = (length == 0) ? strlen(value) : length;
memset(value, 0, size);
free(value);
}
#else // !JSONCPP_USING_SECURE_MEMORY
static inline void releasePrefixedStringValue(char* value) { free(value); }
static inline void releaseStringValue(char* value, unsigned) { free(value); }
#endif // JSONCPP_USING_SECURE_MEMORY
} // namespace Json
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// ValueInternals...
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
#if !defined(JSON_IS_AMALGAMATION)
#include "json_valueiterator.inl"
#endif // if !defined(JSON_IS_AMALGAMATION)
namespace Json {
#if JSON_USE_EXCEPTION
Exception::Exception(String msg) : msg_(std::move(msg)) {}
Exception::~Exception() noexcept = default;
char const* Exception::what() const noexcept { return msg_.c_str(); }
RuntimeError::RuntimeError(String const& msg) : Exception(msg) {}
LogicError::LogicError(String const& msg) : Exception(msg) {}
JSONCPP_NORETURN void throwRuntimeError(String const& msg) {
throw RuntimeError(msg);
}
JSONCPP_NORETURN void throwLogicError(String const& msg) {
throw LogicError(msg);
}
#else // !JSON_USE_EXCEPTION
JSONCPP_NORETURN void throwRuntimeError(String const& msg) {
std::cerr << msg << std::endl;
abort();
}
JSONCPP_NORETURN void throwLogicError(String const& msg) {
std::cerr << msg << std::endl;
abort();
}
#endif
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// class Value::CZString
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// Notes: policy_ indicates if the string was allocated when
// a string is stored.
Value::CZString::CZString(ArrayIndex index) : cstr_(nullptr), index_(index) {}
Value::CZString::CZString(char const* str, unsigned length,
DuplicationPolicy allocate)
: cstr_(str) {
// allocate != duplicate
storage_.policy_ = allocate & 0x3;
storage_.length_ = length & 0x3FFFFFFF;
}
Value::CZString::CZString(const CZString& other) {
cstr_ = (other.storage_.policy_ != noDuplication && other.cstr_ != nullptr
? duplicateStringValue(other.cstr_, other.storage_.length_)
: other.cstr_);
storage_.policy_ =
static_cast<unsigned>(
other.cstr_
? (static_cast<DuplicationPolicy>(other.storage_.policy_) ==
noDuplication
? noDuplication
: duplicate)
: static_cast<DuplicationPolicy>(other.storage_.policy_)) &
3U;
storage_.length_ = other.storage_.length_;
}
Value::CZString::CZString(CZString&& other) noexcept
: cstr_(other.cstr_), index_(other.index_) {
other.cstr_ = nullptr;
}
Value::CZString::~CZString() {
if (cstr_ && storage_.policy_ == duplicate) {
releaseStringValue(const_cast<char*>(cstr_),
storage_.length_ + 1U); // +1 for null terminating
// character for sake of
// completeness but not actually
// necessary
}
}
void Value::CZString::swap(CZString& other) {
std::swap(cstr_, other.cstr_);
std::swap(index_, other.index_);
}
Value::CZString& Value::CZString::operator=(const CZString& other) {
cstr_ = other.cstr_;
index_ = other.index_;
return *this;
}
Value::CZString& Value::CZString::operator=(CZString&& other) noexcept {
cstr_ = other.cstr_;
index_ = other.index_;
other.cstr_ = nullptr;
return *this;
}
bool Value::CZString::operator<(const CZString& other) const {
if (!cstr_)
return index_ < other.index_;
// return strcmp(cstr_, other.cstr_) < 0;
// Assume both are strings.
unsigned this_len = this->storage_.length_;
unsigned other_len = other.storage_.length_;
unsigned min_len = std::min<unsigned>(this_len, other_len);
JSON_ASSERT(this->cstr_ && other.cstr_);
int comp = memcmp(this->cstr_, other.cstr_, min_len);
if (comp < 0)
return true;
if (comp > 0)
return false;
return (this_len < other_len);
}
bool Value::CZString::operator==(const CZString& other) const {
if (!cstr_)
return index_ == other.index_;
// return strcmp(cstr_, other.cstr_) == 0;
// Assume both are strings.
unsigned this_len = this->storage_.length_;
unsigned other_len = other.storage_.length_;
if (this_len != other_len)
return false;
JSON_ASSERT(this->cstr_ && other.cstr_);
int comp = memcmp(this->cstr_, other.cstr_, this_len);
return comp == 0;
}
ArrayIndex Value::CZString::index() const { return index_; }
// const char* Value::CZString::c_str() const { return cstr_; }
const char* Value::CZString::data() const { return cstr_; }
unsigned Value::CZString::length() const { return storage_.length_; }
bool Value::CZString::isStaticString() const {
return storage_.policy_ == noDuplication;
}
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// class Value::Value
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
/*! \internal Default constructor initialization must be equivalent to:
* memset( this, 0, sizeof(Value) )
* This optimization is used in ValueInternalMap fast allocator.
*/
Value::Value(ValueType type) {
static char const emptyString[] = "";
initBasic(type);
switch (type) {
case nullValue:
break;
case intValue:
case uintValue:
value_.int_ = 0;
break;
case realValue:
value_.real_ = 0.0;
break;
case stringValue:
// allocated_ == false, so this is safe.
value_.string_ = const_cast<char*>(static_cast<char const*>(emptyString));
break;
case arrayValue:
case objectValue:
value_.map_ = new ObjectValues();
break;
case booleanValue:
value_.bool_ = false;
break;
default:
JSON_ASSERT_UNREACHABLE;
}
}
Value::Value(Int value) {
initBasic(intValue);
value_.int_ = value;
}
Value::Value(UInt value) {
initBasic(uintValue);
value_.uint_ = value;
}
#if defined(JSON_HAS_INT64)
Value::Value(Int64 value) {
initBasic(intValue);
value_.int_ = value;
}
Value::Value(UInt64 value) {
initBasic(uintValue);
value_.uint_ = value;
}
#endif // defined(JSON_HAS_INT64)
Value::Value(double value) {
initBasic(realValue);
value_.real_ = value;
}
Value::Value(const char* value) {
initBasic(stringValue, true);
JSON_ASSERT_MESSAGE(value != nullptr,
"Null Value Passed to Value Constructor");
value_.string_ = duplicateAndPrefixStringValue(
value, static_cast<unsigned>(strlen(value)));
}
Value::Value(const char* begin, const char* end) {
initBasic(stringValue, true);
value_.string_ =
duplicateAndPrefixStringValue(begin, static_cast<unsigned>(end - begin));
}
Value::Value(const String& value) {
initBasic(stringValue, true);
value_.string_ = duplicateAndPrefixStringValue(
value.data(), static_cast<unsigned>(value.length()));
}
Value::Value(const StaticString& value) {
initBasic(stringValue);
value_.string_ = const_cast<char*>(value.c_str());
}
Value::Value(bool value) {
initBasic(booleanValue);
value_.bool_ = value;
}
Value::Value(const Value& other) {
dupPayload(other);
dupMeta(other);
}
Value::Value(Value&& other) noexcept {
initBasic(nullValue);
swap(other);
}
Value::~Value() {
releasePayload();
value_.uint_ = 0;
}
Value& Value::operator=(const Value& other) {
Value(other).swap(*this);
return *this;
}
Value& Value::operator=(Value&& other) noexcept {
other.swap(*this);
return *this;
}
void Value::swapPayload(Value& other) {
std::swap(bits_, other.bits_);
std::swap(value_, other.value_);
}
void Value::copyPayload(const Value& other) {
releasePayload();
dupPayload(other);
}
void Value::swap(Value& other) {
swapPayload(other);
std::swap(comments_, other.comments_);
std::swap(start_, other.start_);
std::swap(limit_, other.limit_);
}
void Value::copy(const Value& other) {
copyPayload(other);
dupMeta(other);
}
ValueType Value::type() const {
return static_cast<ValueType>(bits_.value_type_);
}
int Value::compare(const Value& other) const {
if (*this < other)
return -1;
if (*this > other)
return 1;
return 0;
}
bool Value::operator<(const Value& other) const {
int typeDelta = type() - other.type();
if (typeDelta)
return typeDelta < 0;
switch (type()) {
case nullValue:
return false;
case intValue:
return value_.int_ < other.value_.int_;
case uintValue:
return value_.uint_ < other.value_.uint_;
case realValue:
return value_.real_ < other.value_.real_;
case booleanValue:
return value_.bool_ < other.value_.bool_;
case stringValue: {
if ((value_.string_ == nullptr) || (other.value_.string_ == nullptr)) {
return other.value_.string_ != nullptr;
}
unsigned this_len;
unsigned other_len;
char const* this_str;
char const* other_str;
decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len,
&this_str);
decodePrefixedString(other.isAllocated(), other.value_.string_, &other_len,
&other_str);
unsigned min_len = std::min<unsigned>(this_len, other_len);
JSON_ASSERT(this_str && other_str);
int comp = memcmp(this_str, other_str, min_len);
if (comp < 0)
return true;
if (comp > 0)
return false;
return (this_len < other_len);
}
case arrayValue:
case objectValue: {
auto thisSize = value_.map_->size();
auto otherSize = other.value_.map_->size();
if (thisSize != otherSize)
return thisSize < otherSize;
return (*value_.map_) < (*other.value_.map_);
}
default:
JSON_ASSERT_UNREACHABLE;
}
return false; // unreachable
}
bool Value::operator<=(const Value& other) const { return !(other < *this); }
bool Value::operator>=(const Value& other) const { return !(*this < other); }
bool Value::operator>(const Value& other) const { return other < *this; }
bool Value::operator==(const Value& other) const {
if (type() != other.type())
return false;
switch (type()) {
case nullValue:
return true;
case intValue:
return value_.int_ == other.value_.int_;
case uintValue:
return value_.uint_ == other.value_.uint_;
case realValue:
return value_.real_ == other.value_.real_;
case booleanValue:
return value_.bool_ == other.value_.bool_;
case stringValue: {
if ((value_.string_ == nullptr) || (other.value_.string_ == nullptr)) {
return (value_.string_ == other.value_.string_);
}
unsigned this_len;
unsigned other_len;
char const* this_str;
char const* other_str;
decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len,
&this_str);
decodePrefixedString(other.isAllocated(), other.value_.string_, &other_len,
&other_str);
if (this_len != other_len)
return false;
JSON_ASSERT(this_str && other_str);
int comp = memcmp(this_str, other_str, this_len);
return comp == 0;
}
case arrayValue:
case objectValue:
return value_.map_->size() == other.value_.map_->size() &&
(*value_.map_) == (*other.value_.map_);
default:
JSON_ASSERT_UNREACHABLE;
}
return false; // unreachable
}
bool Value::operator!=(const Value& other) const { return !(*this == other); }
const char* Value::asCString() const {
JSON_ASSERT_MESSAGE(type() == stringValue,
"in Json::Value::asCString(): requires stringValue");
if (value_.string_ == nullptr)
return nullptr;
unsigned this_len;
char const* this_str;
decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len,
&this_str);
return this_str;
}
#if JSONCPP_USING_SECURE_MEMORY
unsigned Value::getCStringLength() const {
JSON_ASSERT_MESSAGE(type() == stringValue,
"in Json::Value::asCString(): requires stringValue");
if (value_.string_ == 0)
return 0;
unsigned this_len;
char const* this_str;
decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len,
&this_str);
return this_len;
}
#endif
bool Value::getString(char const** begin, char const** end) const {
if (type() != stringValue)
return false;
if (value_.string_ == nullptr)
return false;
unsigned length;
decodePrefixedString(this->isAllocated(), this->value_.string_, &length,
begin);
*end = *begin + length;
return true;
}
String Value::asString() const {
switch (type()) {
case nullValue:
return "";
case stringValue: {
if (value_.string_ == nullptr)
return "";
unsigned this_len;
char const* this_str;
decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len,
&this_str);
return String(this_str, this_len);
}
case booleanValue:
return value_.bool_ ? "true" : "false";
case intValue:
return valueToString(value_.int_);
case uintValue:
return valueToString(value_.uint_);
case realValue:
return valueToString(value_.real_);
default:
JSON_FAIL_MESSAGE("Type is not convertible to string");
}
}
Value::Int Value::asInt() const {
switch (type()) {
case intValue:
JSON_ASSERT_MESSAGE(isInt(), "LargestInt out of Int range");
return Int(value_.int_);
case uintValue:
JSON_ASSERT_MESSAGE(isInt(), "LargestUInt out of Int range");
return Int(value_.uint_);
case realValue:
JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt, maxInt),
"double out of Int range");
return Int(value_.real_);
case nullValue:
return 0;
case booleanValue:
return value_.bool_ ? 1 : 0;
default:
break;
}
JSON_FAIL_MESSAGE("Value is not convertible to Int.");
}
Value::UInt Value::asUInt() const {
switch (type()) {
case intValue:
JSON_ASSERT_MESSAGE(isUInt(), "LargestInt out of UInt range");
return UInt(value_.int_);
case uintValue:
JSON_ASSERT_MESSAGE(isUInt(), "LargestUInt out of UInt range");
return UInt(value_.uint_);
case realValue:
JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt),
"double out of UInt range");
return UInt(value_.real_);
case nullValue:
return 0;
case booleanValue:
return value_.bool_ ? 1 : 0;
default:
break;
}
JSON_FAIL_MESSAGE("Value is not convertible to UInt.");
}
#if defined(JSON_HAS_INT64)
Value::Int64 Value::asInt64() const {
switch (type()) {
case intValue:
return Int64(value_.int_);
case uintValue:
JSON_ASSERT_MESSAGE(isInt64(), "LargestUInt out of Int64 range");
return Int64(value_.uint_);
case realValue:
JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt64, maxInt64),
"double out of Int64 range");
return Int64(value_.real_);
case nullValue:
return 0;
case booleanValue:
return value_.bool_ ? 1 : 0;
default:
break;
}
JSON_FAIL_MESSAGE("Value is not convertible to Int64.");
}
Value::UInt64 Value::asUInt64() const {
switch (type()) {
case intValue:
JSON_ASSERT_MESSAGE(isUInt64(), "LargestInt out of UInt64 range");
return UInt64(value_.int_);
case uintValue:
return UInt64(value_.uint_);
case realValue:
JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt64),
"double out of UInt64 range");
return UInt64(value_.real_);
case nullValue:
return 0;
case booleanValue:
return value_.bool_ ? 1 : 0;
default:
break;
}
JSON_FAIL_MESSAGE("Value is not convertible to UInt64.");
}
#endif // if defined(JSON_HAS_INT64)
LargestInt Value::asLargestInt() const {
#if defined(JSON_NO_INT64)
return asInt();
#else
return asInt64();
#endif
}
LargestUInt Value::asLargestUInt() const {
#if defined(JSON_NO_INT64)
return asUInt();
#else
return asUInt64();
#endif
}
double Value::asDouble() const {
switch (type()) {
case intValue:
return static_cast<double>(value_.int_);
case uintValue:
#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
return static_cast<double>(value_.uint_);
#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
return integerToDouble(value_.uint_);
#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
case realValue:
return value_.real_;
case nullValue:
return 0.0;
case booleanValue:
return value_.bool_ ? 1.0 : 0.0;
default:
break;
}
JSON_FAIL_MESSAGE("Value is not convertible to double.");
}
float Value::asFloat() const {
switch (type()) {
case intValue:
return static_cast<float>(value_.int_);
case uintValue:
#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
return static_cast<float>(value_.uint_);
#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
// This can fail (silently?) if the value is bigger than MAX_FLOAT.
return static_cast<float>(integerToDouble(value_.uint_));
#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
case realValue:
return static_cast<float>(value_.real_);
case nullValue:
return 0.0;
case booleanValue:
return value_.bool_ ? 1.0F : 0.0F;
default:
break;
}
JSON_FAIL_MESSAGE("Value is not convertible to float.");
}
bool Value::asBool() const {
switch (type()) {
case booleanValue:
return value_.bool_;
case nullValue:
return false;
case intValue:
return value_.int_ != 0;
case uintValue:
return value_.uint_ != 0;
case realValue: {
// According to JavaScript language zero or NaN is regarded as false
const auto value_classification = std::fpclassify(value_.real_);
return value_classification != FP_ZERO && value_classification != FP_NAN;
}
default:
break;
}
JSON_FAIL_MESSAGE("Value is not convertible to bool.");
}
bool Value::isConvertibleTo(ValueType other) const {
switch (other) {
case nullValue:
return (isNumeric() && asDouble() == 0.0) ||
(type() == booleanValue && !value_.bool_) ||
(type() == stringValue && asString().empty()) ||
(type() == arrayValue && value_.map_->empty()) ||
(type() == objectValue && value_.map_->empty()) ||
type() == nullValue;
case intValue:
return isInt() ||
(type() == realValue && InRange(value_.real_, minInt, maxInt)) ||
type() == booleanValue || type() == nullValue;
case uintValue:
return isUInt() ||
(type() == realValue && InRange(value_.real_, 0, maxUInt)) ||
type() == booleanValue || type() == nullValue;
case realValue:
return isNumeric() || type() == booleanValue || type() == nullValue;
case booleanValue:
return isNumeric() || type() == booleanValue || type() == nullValue;
case stringValue:
return isNumeric() || type() == booleanValue || type() == stringValue ||
type() == nullValue;
case arrayValue:
return type() == arrayValue || type() == nullValue;
case objectValue:
return type() == objectValue || type() == nullValue;
}
JSON_ASSERT_UNREACHABLE;
return false;
}
/// Number of values in array or object
ArrayIndex Value::size() const {
switch (type()) {
case nullValue:
case intValue:
case uintValue:
case realValue:
case booleanValue:
case stringValue:
return 0;
case arrayValue: // size of the array is highest index + 1
if (!value_.map_->empty()) {
ObjectValues::const_iterator itLast = value_.map_->end();
--itLast;
return (*itLast).first.index() + 1;
}
return 0;
case objectValue:
return ArrayIndex(value_.map_->size());
}
JSON_ASSERT_UNREACHABLE;
return 0; // unreachable;
}
bool Value::empty() const {
if (isNull() || isArray() || isObject())
return size() == 0U;
return false;
}
Value::operator bool() const { return !isNull(); }
void Value::clear() {
JSON_ASSERT_MESSAGE(type() == nullValue || type() == arrayValue ||
type() == objectValue,
"in Json::Value::clear(): requires complex value");
start_ = 0;
limit_ = 0;
switch (type()) {
case arrayValue:
case objectValue:
value_.map_->clear();
break;
default:
break;
}
}
void Value::resize(ArrayIndex newSize) {
JSON_ASSERT_MESSAGE(type() == nullValue || type() == arrayValue,
"in Json::Value::resize(): requires arrayValue");
if (type() == nullValue)
*this = Value(arrayValue);
ArrayIndex oldSize = size();
if (newSize == 0)
clear();
else if (newSize > oldSize)
for (ArrayIndex i = oldSize; i < newSize; ++i)
(*this)[i];
else {
for (ArrayIndex index = newSize; index < oldSize; ++index) {
value_.map_->erase(index);
}
JSON_ASSERT(size() == newSize);
}
}
Value& Value::operator[](ArrayIndex index) {
JSON_ASSERT_MESSAGE(
type() == nullValue || type() == arrayValue,
"in Json::Value::operator[](ArrayIndex): requires arrayValue");
if (type() == nullValue)
*this = Value(arrayValue);
CZString key(index);
auto it = value_.map_->lower_bound(key);
if (it != value_.map_->end() && (*it).first == key)
return (*it).second;
ObjectValues::value_type defaultValue(key, nullSingleton());
it = value_.map_->insert(it, defaultValue);
return (*it).second;
}
Value& Value::operator[](int index) {
JSON_ASSERT_MESSAGE(
index >= 0,
"in Json::Value::operator[](int index): index cannot be negative");
return (*this)[ArrayIndex(index)];
}
const Value& Value::operator[](ArrayIndex index) const {
JSON_ASSERT_MESSAGE(
type() == nullValue || type() == arrayValue,
"in Json::Value::operator[](ArrayIndex)const: requires arrayValue");
if (type() == nullValue)
return nullSingleton();
CZString key(index);
ObjectValues::const_iterator it = value_.map_->find(key);
if (it == value_.map_->end())
return nullSingleton();
return (*it).second;
}
const Value& Value::operator[](int index) const {
JSON_ASSERT_MESSAGE(
index >= 0,
"in Json::Value::operator[](int index) const: index cannot be negative");
return (*this)[ArrayIndex(index)];
}
void Value::initBasic(ValueType type, bool allocated) {
setType(type);
setIsAllocated(allocated);
comments_ = Comments{};
start_ = 0;
limit_ = 0;
}
void Value::dupPayload(const Value& other) {
setType(other.type());
setIsAllocated(false);
switch (type()) {
case nullValue:
case intValue:
case uintValue:
case realValue:
case booleanValue:
value_ = other.value_;
break;
case stringValue:
if (other.value_.string_ && other.isAllocated()) {
unsigned len;
char const* str;
decodePrefixedString(other.isAllocated(), other.value_.string_, &len,
&str);
value_.string_ = duplicateAndPrefixStringValue(str, len);
setIsAllocated(true);
} else {
value_.string_ = other.value_.string_;
}
break;
case arrayValue:
case objectValue:
value_.map_ = new ObjectValues(*other.value_.map_);
break;
default:
JSON_ASSERT_UNREACHABLE;
}
}
void Value::releasePayload() {
switch (type()) {
case nullValue:
case intValue:
case uintValue:
case realValue:
case booleanValue:
break;
case stringValue:
if (isAllocated())
releasePrefixedStringValue(value_.string_);
break;
case arrayValue:
case objectValue:
delete value_.map_;
break;
default:
JSON_ASSERT_UNREACHABLE;
}
}
void Value::dupMeta(const Value& other) {
comments_ = other.comments_;
start_ = other.start_;
limit_ = other.limit_;
}
// Access an object value by name, create a null member if it does not exist.
// @pre Type of '*this' is object or null.
// @param key is null-terminated.
Value& Value::resolveReference(const char* key) {
JSON_ASSERT_MESSAGE(
type() == nullValue || type() == objectValue,
"in Json::Value::resolveReference(): requires objectValue");
if (type() == nullValue)
*this = Value(objectValue);
CZString actualKey(key, static_cast<unsigned>(strlen(key)),
CZString::noDuplication); // NOTE!
auto it = value_.map_->lower_bound(actualKey);
if (it != value_.map_->end() && (*it).first == actualKey)
return (*it).second;
ObjectValues::value_type defaultValue(actualKey, nullSingleton());
it = value_.map_->insert(it, defaultValue);
Value& value = (*it).second;
return value;
}
// @param key is not null-terminated.
Value& Value::resolveReference(char const* key, char const* end) {
JSON_ASSERT_MESSAGE(
type() == nullValue || type() == objectValue,
"in Json::Value::resolveReference(key, end): requires objectValue");
if (type() == nullValue)
*this = Value(objectValue);
CZString actualKey(key, static_cast<unsigned>(end - key),
CZString::duplicateOnCopy);
auto it = value_.map_->lower_bound(actualKey);
if (it != value_.map_->end() && (*it).first == actualKey)
return (*it).second;
ObjectValues::value_type defaultValue(actualKey, nullSingleton());
it = value_.map_->insert(it, defaultValue);
Value& value = (*it).second;
return value;
}
Value Value::get(ArrayIndex index, const Value& defaultValue) const {
const Value* value = &((*this)[index]);
return value == &nullSingleton() ? defaultValue : *value;
}
bool Value::isValidIndex(ArrayIndex index) const { return index < size(); }
Value const* Value::find(char const* begin, char const* end) const {
JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue,
"in Json::Value::find(begin, end): requires "
"objectValue or nullValue");
if (type() == nullValue)
return nullptr;
CZString actualKey(begin, static_cast<unsigned>(end - begin),
CZString::noDuplication);
ObjectValues::const_iterator it = value_.map_->find(actualKey);
if (it == value_.map_->end())
return nullptr;
return &(*it).second;
}
Value* Value::demand(char const* begin, char const* end) {
JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue,
"in Json::Value::demand(begin, end): requires "
"objectValue or nullValue");
return &resolveReference(begin, end);
}
const Value& Value::operator[](const char* key) const {
Value const* found = find(key, key + strlen(key));
if (!found)
return nullSingleton();
return *found;
}
Value const& Value::operator[](const String& key) const {
Value const* found = find(key.data(), key.data() + key.length());
if (!found)
return nullSingleton();
return *found;
}
Value& Value::operator[](const char* key) {
return resolveReference(key, key + strlen(key));
}
Value& Value::operator[](const String& key) {
return resolveReference(key.data(), key.data() + key.length());
}
Value& Value::operator[](const StaticString& key) {
return resolveReference(key.c_str());
}
Value& Value::append(const Value& value) { return append(Value(value)); }
Value& Value::append(Value&& value) {
JSON_ASSERT_MESSAGE(type() == nullValue || type() == arrayValue,
"in Json::Value::append: requires arrayValue");
if (type() == nullValue) {
*this = Value(arrayValue);
}
return this->value_.map_->emplace(size(), std::move(value)).first->second;
}
bool Value::insert(ArrayIndex index, const Value& newValue) {
return insert(index, Value(newValue));
}
bool Value::insert(ArrayIndex index, Value&& newValue) {
JSON_ASSERT_MESSAGE(type() == nullValue || type() == arrayValue,
"in Json::Value::insert: requires arrayValue");
ArrayIndex length = size();
if (index > length) {
return false;
}
for (ArrayIndex i = length; i > index; i--) {
(*this)[i] = std::move((*this)[i - 1]);
}
(*this)[index] = std::move(newValue);
return true;
}
Value Value::get(char const* begin, char const* end,
Value const& defaultValue) const {
Value const* found = find(begin, end);
return !found ? defaultValue : *found;
}
Value Value::get(char const* key, Value const& defaultValue) const {
return get(key, key + strlen(key), defaultValue);
}
Value Value::get(String const& key, Value const& defaultValue) const {
return get(key.data(), key.data() + key.length(), defaultValue);
}
bool Value::removeMember(const char* begin, const char* end, Value* removed) {
if (type() != objectValue) {
return false;
}
CZString actualKey(begin, static_cast<unsigned>(end - begin),
CZString::noDuplication);
auto it = value_.map_->find(actualKey);
if (it == value_.map_->end())
return false;
if (removed)
*removed = std::move(it->second);
value_.map_->erase(it);
return true;
}
bool Value::removeMember(const char* key, Value* removed) {
return removeMember(key, key + strlen(key), removed);
}
bool Value::removeMember(String const& key, Value* removed) {
return removeMember(key.data(), key.data() + key.length(), removed);
}
void Value::removeMember(const char* key) {
JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue,
"in Json::Value::removeMember(): requires objectValue");
if (type() == nullValue)
return;
CZString actualKey(key, unsigned(strlen(key)), CZString::noDuplication);
value_.map_->erase(actualKey);
}
void Value::removeMember(const String& key) { removeMember(key.c_str()); }
bool Value::removeIndex(ArrayIndex index, Value* removed) {
if (type() != arrayValue) {
return false;
}
CZString key(index);
auto it = value_.map_->find(key);
if (it == value_.map_->end()) {
return false;
}
if (removed)
*removed = it->second;
ArrayIndex oldSize = size();
// shift left all items left, into the place of the "removed"
for (ArrayIndex i = index; i < (oldSize - 1); ++i) {
CZString keey(i);
(*value_.map_)[keey] = (*this)[i + 1];
}
// erase the last one ("leftover")
CZString keyLast(oldSize - 1);
auto itLast = value_.map_->find(keyLast);
value_.map_->erase(itLast);
return true;
}
bool Value::isMember(char const* begin, char const* end) const {
Value const* value = find(begin, end);
return nullptr != value;
}
bool Value::isMember(char const* key) const {
return isMember(key, key + strlen(key));
}
bool Value::isMember(String const& key) const {
return isMember(key.data(), key.data() + key.length());
}
Value::Members Value::getMemberNames() const {
JSON_ASSERT_MESSAGE(
type() == nullValue || type() == objectValue,
"in Json::Value::getMemberNames(), value must be objectValue");
if (type() == nullValue)
return Value::Members();
Members members;
members.reserve(value_.map_->size());
ObjectValues::const_iterator it = value_.map_->begin();
ObjectValues::const_iterator itEnd = value_.map_->end();
for (; it != itEnd; ++it) {
members.push_back(String((*it).first.data(), (*it).first.length()));
}
return members;
}
static bool IsIntegral(double d) {
double integral_part;
return modf(d, &integral_part) == 0.0;
}
bool Value::isNull() const { return type() == nullValue; }
bool Value::isBool() const { return type() == booleanValue; }
bool Value::isInt() const {
switch (type()) {
case intValue:
#if defined(JSON_HAS_INT64)
return value_.int_ >= minInt && value_.int_ <= maxInt;
#else
return true;
#endif
case uintValue:
return value_.uint_ <= UInt(maxInt);
case realValue:
return value_.real_ >= minInt && value_.real_ <= maxInt &&
IsIntegral(value_.real_);
default:
break;
}
return false;
}
bool Value::isUInt() const {
switch (type()) {
case intValue:
#if defined(JSON_HAS_INT64)
return value_.int_ >= 0 && LargestUInt(value_.int_) <= LargestUInt(maxUInt);
#else
return value_.int_ >= 0;
#endif
case uintValue:
#if defined(JSON_HAS_INT64)
return value_.uint_ <= maxUInt;
#else
return true;
#endif
case realValue:
return value_.real_ >= 0 && value_.real_ <= maxUInt &&
IsIntegral(value_.real_);
default:
break;
}
return false;
}
bool Value::isInt64() const {
#if defined(JSON_HAS_INT64)
switch (type()) {
case intValue:
return true;
case uintValue:
return value_.uint_ <= UInt64(maxInt64);
case realValue:
// Note that maxInt64 (= 2^63 - 1) is not exactly representable as a
// double, so double(maxInt64) will be rounded up to 2^63. Therefore we
// require the value to be strictly less than the limit.
return value_.real_ >= double(minInt64) &&
value_.real_ < double(maxInt64) && IsIntegral(value_.real_);
default:
break;
}
#endif // JSON_HAS_INT64
return false;
}
bool Value::isUInt64() const {
#if defined(JSON_HAS_INT64)
switch (type()) {
case intValue:
return value_.int_ >= 0;
case uintValue:
return true;
case realValue:
// Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
// double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
// require the value to be strictly less than the limit.
return value_.real_ >= 0 && value_.real_ < maxUInt64AsDouble &&
IsIntegral(value_.real_);
default:
break;
}
#endif // JSON_HAS_INT64
return false;
}
bool Value::isIntegral() const {
switch (type()) {
case intValue:
case uintValue:
return true;
case realValue:
#if defined(JSON_HAS_INT64)
// Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
// double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
// require the value to be strictly less than the limit.
return value_.real_ >= double(minInt64) &&
value_.real_ < maxUInt64AsDouble && IsIntegral(value_.real_);
#else
return value_.real_ >= minInt && value_.real_ <= maxUInt &&
IsIntegral(value_.real_);
#endif // JSON_HAS_INT64
default:
break;
}
return false;
}
bool Value::isDouble() const {
return type() == intValue || type() == uintValue || type() == realValue;
}
bool Value::isNumeric() const { return isDouble(); }
bool Value::isString() const { return type() == stringValue; }
bool Value::isArray() const { return type() == arrayValue; }
bool Value::isObject() const { return type() == objectValue; }
Value::Comments::Comments(const Comments& that)
: ptr_{cloneUnique(that.ptr_)} {}
Value::Comments::Comments(Comments&& that) noexcept
: ptr_{std::move(that.ptr_)} {}
Value::Comments& Value::Comments::operator=(const Comments& that) {
ptr_ = cloneUnique(that.ptr_);
return *this;
}
Value::Comments& Value::Comments::operator=(Comments&& that) noexcept {
ptr_ = std::move(that.ptr_);
return *this;
}
bool Value::Comments::has(CommentPlacement slot) const {
return ptr_ && !(*ptr_)[slot].empty();
}
String Value::Comments::get(CommentPlacement slot) const {
if (!ptr_)
return {};
return (*ptr_)[slot];
}
void Value::Comments::set(CommentPlacement slot, String comment) {
if (slot >= CommentPlacement::numberOfCommentPlacement)
return;
if (!ptr_)
ptr_ = std::unique_ptr<Array>(new Array());
(*ptr_)[slot] = std::move(comment);
}
void Value::setComment(String comment, CommentPlacement placement) {
if (!comment.empty() && (comment.back() == '\n')) {
// Always discard trailing newline, to aid indentation.
comment.pop_back();
}
JSON_ASSERT(!comment.empty());
JSON_ASSERT_MESSAGE(
comment[0] == '\0' || comment[0] == '/',
"in Json::Value::setComment(): Comments must start with /");
comments_.set(placement, std::move(comment));
}
bool Value::hasComment(CommentPlacement placement) const {
return comments_.has(placement);
}
String Value::getComment(CommentPlacement placement) const {
return comments_.get(placement);
}
void Value::setOffsetStart(ptrdiff_t start) { start_ = start; }
void Value::setOffsetLimit(ptrdiff_t limit) { limit_ = limit; }
ptrdiff_t Value::getOffsetStart() const { return start_; }
ptrdiff_t Value::getOffsetLimit() const { return limit_; }
String Value::toStyledString() const {
StreamWriterBuilder builder;
String out = this->hasComment(commentBefore) ? "\n" : "";
out += Json::writeString(builder, *this);
out += '\n';
return out;
}
Value::const_iterator Value::begin() const {
switch (type()) {
case arrayValue:
case objectValue:
if (value_.map_)
return const_iterator(value_.map_->begin());
break;
default:
break;
}
return {};
}
Value::const_iterator Value::end() const {
switch (type()) {
case arrayValue:
case objectValue:
if (value_.map_)
return const_iterator(value_.map_->end());
break;
default:
break;
}
return {};
}
Value::iterator Value::begin() {
switch (type()) {
case arrayValue:
case objectValue:
if (value_.map_)
return iterator(value_.map_->begin());
break;
default:
break;
}
return iterator();
}
Value::iterator Value::end() {
switch (type()) {
case arrayValue:
case objectValue:
if (value_.map_)
return iterator(value_.map_->end());
break;
default:
break;
}
return iterator();
}
// class PathArgument
// //////////////////////////////////////////////////////////////////
PathArgument::PathArgument() = default;
PathArgument::PathArgument(ArrayIndex index)
: index_(index), kind_(kindIndex) {}
PathArgument::PathArgument(const char* key) : key_(key), kind_(kindKey) {}
PathArgument::PathArgument(String key) : key_(std::move(key)), kind_(kindKey) {}
// class Path
// //////////////////////////////////////////////////////////////////
Path::Path(const String& path, const PathArgument& a1, const PathArgument& a2,
const PathArgument& a3, const PathArgument& a4,
const PathArgument& a5) {
InArgs in;
in.reserve(5);
in.push_back(&a1);
in.push_back(&a2);
in.push_back(&a3);
in.push_back(&a4);
in.push_back(&a5);
makePath(path, in);
}
void Path::makePath(const String& path, const InArgs& in) {
const char* current = path.c_str();
const char* end = current + path.length();
auto itInArg = in.begin();
while (current != end) {
if (*current == '[') {
++current;
if (*current == '%')
addPathInArg(path, in, itInArg, PathArgument::kindIndex);
else {
ArrayIndex index = 0;
for (; current != end && *current >= '0' && *current <= '9'; ++current)
index = index * 10 + ArrayIndex(*current - '0');
args_.push_back(index);
}
if (current == end || *++current != ']')
invalidPath(path, int(current - path.c_str()));
} else if (*current == '%') {
addPathInArg(path, in, itInArg, PathArgument::kindKey);
++current;
} else if (*current == '.' || *current == ']') {
++current;
} else {
const char* beginName = current;
while (current != end && !strchr("[.", *current))
++current;
args_.push_back(String(beginName, current));
}
}
}
void Path::addPathInArg(const String& /*path*/, const InArgs& in,
InArgs::const_iterator& itInArg,
PathArgument::Kind kind) {
if (itInArg == in.end()) {
// Error: missing argument %d
} else if ((*itInArg)->kind_ != kind) {
// Error: bad argument type
} else {
args_.push_back(**itInArg++);
}
}
void Path::invalidPath(const String& /*path*/, int /*location*/) {
// Error: invalid path.
}
const Value& Path::resolve(const Value& root) const {
const Value* node = &root;
for (const auto& arg : args_) {
if (arg.kind_ == PathArgument::kindIndex) {
if (!node->isArray() || !node->isValidIndex(arg.index_)) {
// Error: unable to resolve path (array value expected at position... )
return Value::nullSingleton();
}
node = &((*node)[arg.index_]);
} else if (arg.kind_ == PathArgument::kindKey) {
if (!node->isObject()) {
// Error: unable to resolve path (object value expected at position...)
return Value::nullSingleton();
}
node = &((*node)[arg.key_]);
if (node == &Value::nullSingleton()) {
// Error: unable to resolve path (object has no member named '' at
// position...)
return Value::nullSingleton();
}
}
}
return *node;
}
Value Path::resolve(const Value& root, const Value& defaultValue) const {
const Value* node = &root;
for (const auto& arg : args_) {
if (arg.kind_ == PathArgument::kindIndex) {
if (!node->isArray() || !node->isValidIndex(arg.index_))
return defaultValue;
node = &((*node)[arg.index_]);
} else if (arg.kind_ == PathArgument::kindKey) {
if (!node->isObject())
return defaultValue;
node = &((*node)[arg.key_]);
if (node == &Value::nullSingleton())
return defaultValue;
}
}
return *node;
}
Value& Path::make(Value& root) const {
Value* node = &root;
for (const auto& arg : args_) {
if (arg.kind_ == PathArgument::kindIndex) {
if (!node->isArray()) {
// Error: node is not an array at position ...
}
node = &((*node)[arg.index_]);
} else if (arg.kind_ == PathArgument::kindKey) {
if (!node->isObject()) {
// Error: node is not an object at position...
}
node = &((*node)[arg.key_]);
}
}
return *node;
}
} // namespace Json
// //////////////////////////////////////////////////////////////////////
// End of content of file: src/lib_json/json_value.cpp
// //////////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////////
// Beginning of content of file: src/lib_json/json_writer.cpp
// //////////////////////////////////////////////////////////////////////
// Copyright 2011 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#if !defined(JSON_IS_AMALGAMATION)
#include "json_tool.h"
#include <json/writer.h>
#endif // if !defined(JSON_IS_AMALGAMATION)
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cstring>
#include <iomanip>
#include <memory>
#include <set>
#include <sstream>
#include <utility>
#if __cplusplus >= 201103L
#include <cmath>
#include <cstdio>
#if !defined(isnan)
#define isnan std::isnan
#endif
#if !defined(isfinite)
#define isfinite std::isfinite
#endif
#else
#include <cmath>
#include <cstdio>
#if defined(_MSC_VER)
#if !defined(isnan)
#include <float.h>
#define isnan _isnan
#endif
#if !defined(isfinite)
#include <float.h>
#define isfinite _finite
#endif
#if !defined(_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES)
#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1
#endif //_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES
#endif //_MSC_VER
#if defined(__sun) && defined(__SVR4) // Solaris
#if !defined(isfinite)
#include <ieeefp.h>
#define isfinite finite
#endif
#endif
#if defined(__hpux)
#if !defined(isfinite)
#if defined(__ia64) && !defined(finite)
#define isfinite(x) \
((sizeof(x) == sizeof(float) ? _Isfinitef(x) : _IsFinite(x)))
#endif
#endif
#endif
#if !defined(isnan)
// IEEE standard states that NaN values will not compare to themselves
#define isnan(x) ((x) != (x))
#endif
#if !defined(__APPLE__)
#if !defined(isfinite)
#define isfinite finite
#endif
#endif
#endif
#if defined(_MSC_VER)
// Disable warning about strdup being deprecated.
#pragma warning(disable : 4996)
#endif
namespace Json {
#if __cplusplus >= 201103L || (defined(_CPPLIB_VER) && _CPPLIB_VER >= 520)
using StreamWriterPtr = std::unique_ptr<StreamWriter>;
#else
using StreamWriterPtr = std::auto_ptr<StreamWriter>;
#endif
String valueToString(LargestInt value) {
UIntToStringBuffer buffer;
char* current = buffer + sizeof(buffer);
if (value == Value::minLargestInt) {
uintToString(LargestUInt(Value::maxLargestInt) + 1, current);
*--current = '-';
} else if (value < 0) {
uintToString(LargestUInt(-value), current);
*--current = '-';
} else {
uintToString(LargestUInt(value), current);
}
assert(current >= buffer);
return current;
}
String valueToString(LargestUInt value) {
UIntToStringBuffer buffer;
char* current = buffer + sizeof(buffer);
uintToString(value, current);
assert(current >= buffer);
return current;
}
#if defined(JSON_HAS_INT64)
String valueToString(Int value) { return valueToString(LargestInt(value)); }
String valueToString(UInt value) { return valueToString(LargestUInt(value)); }
#endif // # if defined(JSON_HAS_INT64)
namespace {
String valueToString(double value, bool useSpecialFloats,
unsigned int precision, PrecisionType precisionType) {
// Print into the buffer. We need not request the alternative representation
// that always has a decimal point because JSON doesn't distinguish the
// concepts of reals and integers.
if (!isfinite(value)) {
static const char* const reps[2][3] = {{"NaN", "-Infinity", "Infinity"},
{"null", "-1e+9999", "1e+9999"}};
return reps[useSpecialFloats ? 0 : 1]
[isnan(value) ? 0 : (value < 0) ? 1 : 2];
}
String buffer(size_t(36), '\0');
while (true) {
int len = jsoncpp_snprintf(
&*buffer.begin(), buffer.size(),
(precisionType == PrecisionType::significantDigits) ? "%.*g" : "%.*f",
precision, value);
assert(len >= 0);
auto wouldPrint = static_cast<size_t>(len);
if (wouldPrint >= buffer.size()) {
buffer.resize(wouldPrint + 1);
continue;
}
buffer.resize(wouldPrint);
break;
}
buffer.erase(fixNumericLocale(buffer.begin(), buffer.end()), buffer.end());
// try to ensure we preserve the fact that this was given to us as a double on
// input
if (buffer.find('.') == buffer.npos && buffer.find('e') == buffer.npos) {
buffer += ".0";
}
// strip the zero padding from the right
if (precisionType == PrecisionType::decimalPlaces) {
buffer.erase(fixZerosInTheEnd(buffer.begin(), buffer.end(), precision),
buffer.end());
}
return buffer;
}
} // namespace
String valueToString(double value, unsigned int precision,
PrecisionType precisionType) {
return valueToString(value, false, precision, precisionType);
}
String valueToString(bool value) { return value ? "true" : "false"; }
static bool doesAnyCharRequireEscaping(char const* s, size_t n) {
assert(s || !n);
return std::any_of(s, s + n, [](unsigned char c) {
return c == '\\' || c == '"' || c < 0x20 || c > 0x7F;
});
}
static unsigned int utf8ToCodepoint(const char*& s, const char* e) {
const unsigned int REPLACEMENT_CHARACTER = 0xFFFD;
unsigned int firstByte = static_cast<unsigned char>(*s);
if (firstByte < 0x80)
return firstByte;
if (firstByte < 0xE0) {
if (e - s < 2)
return REPLACEMENT_CHARACTER;
unsigned int calculated =
((firstByte & 0x1F) << 6) | (static_cast<unsigned int>(s[1]) & 0x3F);
s += 1;
// oversized encoded characters are invalid
return calculated < 0x80 ? REPLACEMENT_CHARACTER : calculated;
}
if (firstByte < 0xF0) {
if (e - s < 3)
return REPLACEMENT_CHARACTER;
unsigned int calculated = ((firstByte & 0x0F) << 12) |
((static_cast<unsigned int>(s[1]) & 0x3F) << 6) |
(static_cast<unsigned int>(s[2]) & 0x3F);
s += 2;
// surrogates aren't valid codepoints itself
// shouldn't be UTF-8 encoded
if (calculated >= 0xD800 && calculated <= 0xDFFF)
return REPLACEMENT_CHARACTER;
// oversized encoded characters are invalid
return calculated < 0x800 ? REPLACEMENT_CHARACTER : calculated;
}
if (firstByte < 0xF8) {
if (e - s < 4)
return REPLACEMENT_CHARACTER;
unsigned int calculated = ((firstByte & 0x07) << 18) |
((static_cast<unsigned int>(s[1]) & 0x3F) << 12) |
((static_cast<unsigned int>(s[2]) & 0x3F) << 6) |
(static_cast<unsigned int>(s[3]) & 0x3F);
s += 3;
// oversized encoded characters are invalid
return calculated < 0x10000 ? REPLACEMENT_CHARACTER : calculated;
}
return REPLACEMENT_CHARACTER;
}
static const char hex2[] = "000102030405060708090a0b0c0d0e0f"
"101112131415161718191a1b1c1d1e1f"
"202122232425262728292a2b2c2d2e2f"
"303132333435363738393a3b3c3d3e3f"
"404142434445464748494a4b4c4d4e4f"
"505152535455565758595a5b5c5d5e5f"
"606162636465666768696a6b6c6d6e6f"
"707172737475767778797a7b7c7d7e7f"
"808182838485868788898a8b8c8d8e8f"
"909192939495969798999a9b9c9d9e9f"
"a0a1a2a3a4a5a6a7a8a9aaabacadaeaf"
"b0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
"c0c1c2c3c4c5c6c7c8c9cacbcccdcecf"
"d0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
"e0e1e2e3e4e5e6e7e8e9eaebecedeeef"
"f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff";
static String toHex16Bit(unsigned int x) {
const unsigned int hi = (x >> 8) & 0xff;
const unsigned int lo = x & 0xff;
String result(4, ' ');
result[0] = hex2[2 * hi];
result[1] = hex2[2 * hi + 1];
result[2] = hex2[2 * lo];
result[3] = hex2[2 * lo + 1];
return result;
}
static void appendRaw(String& result, unsigned ch) {
result += static_cast<char>(ch);
}
static void appendHex(String& result, unsigned ch) {
result.append("\\u").append(toHex16Bit(ch));
}
static String valueToQuotedStringN(const char* value, size_t length,
bool emitUTF8 = false) {
if (value == nullptr)
return "";
if (!doesAnyCharRequireEscaping(value, length))
return String("\"") + value + "\"";
// We have to walk value and escape any special characters.
// Appending to String is not efficient, but this should be rare.
// (Note: forward slashes are *not* rare, but I am not escaping them.)
String::size_type maxsize = length * 2 + 3; // allescaped+quotes+NULL
String result;
result.reserve(maxsize); // to avoid lots of mallocs
result += "\"";
char const* end = value + length;
for (const char* c = value; c != end; ++c) {
switch (*c) {
case '\"':
result += "\\\"";
break;
case '\\':
result += "\\\\";
break;
case '\b':
result += "\\b";
break;
case '\f':
result += "\\f";
break;
case '\n':
result += "\\n";
break;
case '\r':
result += "\\r";
break;
case '\t':
result += "\\t";
break;
// case '/':
// Even though \/ is considered a legal escape in JSON, a bare
// slash is also legal, so I see no reason to escape it.
// (I hope I am not misunderstanding something.)
// blep notes: actually escaping \/ may be useful in javascript to avoid </
// sequence.
// Should add a flag to allow this compatibility mode and prevent this
// sequence from occurring.
default: {
if (emitUTF8) {
unsigned codepoint = static_cast<unsigned char>(*c);
if (codepoint < 0x20) {
appendHex(result, codepoint);
} else {
appendRaw(result, codepoint);
}
} else {
unsigned codepoint = utf8ToCodepoint(c, end); // modifies `c`
if (codepoint < 0x20) {
appendHex(result, codepoint);
} else if (codepoint < 0x80) {
appendRaw(result, codepoint);
} else if (codepoint < 0x10000) {
// Basic Multilingual Plane
appendHex(result, codepoint);
} else {
// Extended Unicode. Encode 20 bits as a surrogate pair.
codepoint -= 0x10000;
appendHex(result, 0xd800 + ((codepoint >> 10) & 0x3ff));
appendHex(result, 0xdc00 + (codepoint & 0x3ff));
}
}
} break;
}
}
result += "\"";
return result;
}
String valueToQuotedString(const char* value) {
return valueToQuotedStringN(value, strlen(value));
}
// Class Writer
// //////////////////////////////////////////////////////////////////
Writer::~Writer() = default;
// Class FastWriter
// //////////////////////////////////////////////////////////////////
FastWriter::FastWriter()
= default;
void FastWriter::enableYAMLCompatibility() { yamlCompatibilityEnabled_ = true; }
void FastWriter::dropNullPlaceholders() { dropNullPlaceholders_ = true; }
void FastWriter::omitEndingLineFeed() { omitEndingLineFeed_ = true; }
String FastWriter::write(const Value& root) {
document_.clear();
writeValue(root);
if (!omitEndingLineFeed_)
document_ += '\n';
return document_;
}
void FastWriter::writeValue(const Value& value) {
switch (value.type()) {
case nullValue:
if (!dropNullPlaceholders_)
document_ += "null";
break;
case intValue:
document_ += valueToString(value.asLargestInt());
break;
case uintValue:
document_ += valueToString(value.asLargestUInt());
break;
case realValue:
document_ += valueToString(value.asDouble());
break;
case stringValue: {
// Is NULL possible for value.string_? No.
char const* str;
char const* end;
bool ok = value.getString(&str, &end);
if (ok)
document_ += valueToQuotedStringN(str, static_cast<size_t>(end - str));
break;
}
case booleanValue:
document_ += valueToString(value.asBool());
break;
case arrayValue: {
document_ += '[';
ArrayIndex size = value.size();
for (ArrayIndex index = 0; index < size; ++index) {
if (index > 0)
document_ += ',';
writeValue(value[index]);
}
document_ += ']';
} break;
case objectValue: {
Value::Members members(value.getMemberNames());
document_ += '{';
for (auto it = members.begin(); it != members.end(); ++it) {
const String& name = *it;
if (it != members.begin())
document_ += ',';
document_ += valueToQuotedStringN(name.data(), name.length());
document_ += yamlCompatibilityEnabled_ ? ": " : ":";
writeValue(value[name]);
}
document_ += '}';
} break;
}
}
// Class StyledWriter
// //////////////////////////////////////////////////////////////////
StyledWriter::StyledWriter() = default;
String StyledWriter::write(const Value& root) {
document_.clear();
addChildValues_ = false;
indentString_.clear();
writeCommentBeforeValue(root);
writeValue(root);
writeCommentAfterValueOnSameLine(root);
document_ += '\n';
return document_;
}
void StyledWriter::writeValue(const Value& value) {
switch (value.type()) {
case nullValue:
pushValue("null");
break;
case intValue:
pushValue(valueToString(value.asLargestInt()));
break;
case uintValue:
pushValue(valueToString(value.asLargestUInt()));
break;
case realValue:
pushValue(valueToString(value.asDouble()));
break;
case stringValue: {
// Is NULL possible for value.string_? No.
char const* str;
char const* end;
bool ok = value.getString(&str, &end);
if (ok)
pushValue(valueToQuotedStringN(str, static_cast<size_t>(end - str)));
else
pushValue("");
break;
}
case booleanValue:
pushValue(valueToString(value.asBool()));
break;
case arrayValue:
writeArrayValue(value);
break;
case objectValue: {
Value::Members members(value.getMemberNames());
if (members.empty())
pushValue("{}");
else {
writeWithIndent("{");
indent();
auto it = members.begin();
for (;;) {
const String& name = *it;
const Value& childValue = value[name];
writeCommentBeforeValue(childValue);
writeWithIndent(valueToQuotedString(name.c_str()));
document_ += " : ";
writeValue(childValue);
if (++it == members.end()) {
writeCommentAfterValueOnSameLine(childValue);
break;
}
document_ += ',';
writeCommentAfterValueOnSameLine(childValue);
}
unindent();
writeWithIndent("}");
}
} break;
}
}
void StyledWriter::writeArrayValue(const Value& value) {
size_t size = value.size();
if (size == 0)
pushValue("[]");
else {
bool isArrayMultiLine = isMultilineArray(value);
if (isArrayMultiLine) {
writeWithIndent("[");
indent();
bool hasChildValue = !childValues_.empty();
ArrayIndex index = 0;
for (;;) {
const Value& childValue = value[index];
writeCommentBeforeValue(childValue);
if (hasChildValue)
writeWithIndent(childValues_[index]);
else {
writeIndent();
writeValue(childValue);
}
if (++index == size) {
writeCommentAfterValueOnSameLine(childValue);
break;
}
document_ += ',';
writeCommentAfterValueOnSameLine(childValue);
}
unindent();
writeWithIndent("]");
} else // output on a single line
{
assert(childValues_.size() == size);
document_ += "[ ";
for (size_t index = 0; index < size; ++index) {
if (index > 0)
document_ += ", ";
document_ += childValues_[index];
}
document_ += " ]";
}
}
}
bool StyledWriter::isMultilineArray(const Value& value) {
ArrayIndex const size = value.size();
bool isMultiLine = size * 3 >= rightMargin_;
childValues_.clear();
for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
const Value& childValue = value[index];
isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
!childValue.empty());
}
if (!isMultiLine) // check if line length > max line length
{
childValues_.reserve(size);
addChildValues_ = true;
ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
for (ArrayIndex index = 0; index < size; ++index) {
if (hasCommentForValue(value[index])) {
isMultiLine = true;
}
writeValue(value[index]);
lineLength += static_cast<ArrayIndex>(childValues_[index].length());
}
addChildValues_ = false;
isMultiLine = isMultiLine || lineLength >= rightMargin_;
}
return isMultiLine;
}
void StyledWriter::pushValue(const String& value) {
if (addChildValues_)
childValues_.push_back(value);
else
document_ += value;
}
void StyledWriter::writeIndent() {
if (!document_.empty()) {
char last = document_[document_.length() - 1];
if (last == ' ') // already indented
return;
if (last != '\n') // Comments may add new-line
document_ += '\n';
}
document_ += indentString_;
}
void StyledWriter::writeWithIndent(const String& value) {
writeIndent();
document_ += value;
}
void StyledWriter::indent() { indentString_ += String(indentSize_, ' '); }
void StyledWriter::unindent() {
assert(indentString_.size() >= indentSize_);
indentString_.resize(indentString_.size() - indentSize_);
}
void StyledWriter::writeCommentBeforeValue(const Value& root) {
if (!root.hasComment(commentBefore))
return;
document_ += '\n';
writeIndent();
const String& comment = root.getComment(commentBefore);
String::const_iterator iter = comment.begin();
while (iter != comment.end()) {
document_ += *iter;
if (*iter == '\n' && ((iter + 1) != comment.end() && *(iter + 1) == '/'))
writeIndent();
++iter;
}
// Comments are stripped of trailing newlines, so add one here
document_ += '\n';
}
void StyledWriter::writeCommentAfterValueOnSameLine(const Value& root) {
if (root.hasComment(commentAfterOnSameLine))
document_ += " " + root.getComment(commentAfterOnSameLine);
if (root.hasComment(commentAfter)) {
document_ += '\n';
document_ += root.getComment(commentAfter);
document_ += '\n';
}
}
bool StyledWriter::hasCommentForValue(const Value& value) {
return value.hasComment(commentBefore) ||
value.hasComment(commentAfterOnSameLine) ||
value.hasComment(commentAfter);
}
// Class StyledStreamWriter
// //////////////////////////////////////////////////////////////////
StyledStreamWriter::StyledStreamWriter(String indentation)
: document_(nullptr), indentation_(std::move(indentation)),
addChildValues_(), indented_(false) {}
void StyledStreamWriter::write(OStream& out, const Value& root) {
document_ = &out;
addChildValues_ = false;
indentString_.clear();
indented_ = true;
writeCommentBeforeValue(root);
if (!indented_)
writeIndent();
indented_ = true;
writeValue(root);
writeCommentAfterValueOnSameLine(root);
*document_ << "\n";
document_ = nullptr; // Forget the stream, for safety.
}
void StyledStreamWriter::writeValue(const Value& value) {
switch (value.type()) {
case nullValue:
pushValue("null");
break;
case intValue:
pushValue(valueToString(value.asLargestInt()));
break;
case uintValue:
pushValue(valueToString(value.asLargestUInt()));
break;
case realValue:
pushValue(valueToString(value.asDouble()));
break;
case stringValue: {
// Is NULL possible for value.string_? No.
char const* str;
char const* end;
bool ok = value.getString(&str, &end);
if (ok)
pushValue(valueToQuotedStringN(str, static_cast<size_t>(end - str)));
else
pushValue("");
break;
}
case booleanValue:
pushValue(valueToString(value.asBool()));
break;
case arrayValue:
writeArrayValue(value);
break;
case objectValue: {
Value::Members members(value.getMemberNames());
if (members.empty())
pushValue("{}");
else {
writeWithIndent("{");
indent();
auto it = members.begin();
for (;;) {
const String& name = *it;
const Value& childValue = value[name];
writeCommentBeforeValue(childValue);
writeWithIndent(valueToQuotedString(name.c_str()));
*document_ << " : ";
writeValue(childValue);
if (++it == members.end()) {
writeCommentAfterValueOnSameLine(childValue);
break;
}
*document_ << ",";
writeCommentAfterValueOnSameLine(childValue);
}
unindent();
writeWithIndent("}");
}
} break;
}
}
void StyledStreamWriter::writeArrayValue(const Value& value) {
unsigned size = value.size();
if (size == 0)
pushValue("[]");
else {
bool isArrayMultiLine = isMultilineArray(value);
if (isArrayMultiLine) {
writeWithIndent("[");
indent();
bool hasChildValue = !childValues_.empty();
unsigned index = 0;
for (;;) {
const Value& childValue = value[index];
writeCommentBeforeValue(childValue);
if (hasChildValue)
writeWithIndent(childValues_[index]);
else {
if (!indented_)
writeIndent();
indented_ = true;
writeValue(childValue);
indented_ = false;
}
if (++index == size) {
writeCommentAfterValueOnSameLine(childValue);
break;
}
*document_ << ",";
writeCommentAfterValueOnSameLine(childValue);
}
unindent();
writeWithIndent("]");
} else // output on a single line
{
assert(childValues_.size() == size);
*document_ << "[ ";
for (unsigned index = 0; index < size; ++index) {
if (index > 0)
*document_ << ", ";
*document_ << childValues_[index];
}
*document_ << " ]";
}
}
}
bool StyledStreamWriter::isMultilineArray(const Value& value) {
ArrayIndex const size = value.size();
bool isMultiLine = size * 3 >= rightMargin_;
childValues_.clear();
for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
const Value& childValue = value[index];
isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
!childValue.empty());
}
if (!isMultiLine) // check if line length > max line length
{
childValues_.reserve(size);
addChildValues_ = true;
ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
for (ArrayIndex index = 0; index < size; ++index) {
if (hasCommentForValue(value[index])) {
isMultiLine = true;
}
writeValue(value[index]);
lineLength += static_cast<ArrayIndex>(childValues_[index].length());
}
addChildValues_ = false;
isMultiLine = isMultiLine || lineLength >= rightMargin_;
}
return isMultiLine;
}
void StyledStreamWriter::pushValue(const String& value) {
if (addChildValues_)
childValues_.push_back(value);
else
*document_ << value;
}
void StyledStreamWriter::writeIndent() {
// blep intended this to look at the so-far-written string
// to determine whether we are already indented, but
// with a stream we cannot do that. So we rely on some saved state.
// The caller checks indented_.
*document_ << '\n' << indentString_;
}
void StyledStreamWriter::writeWithIndent(const String& value) {
if (!indented_)
writeIndent();
*document_ << value;
indented_ = false;
}
void StyledStreamWriter::indent() { indentString_ += indentation_; }
void StyledStreamWriter::unindent() {
assert(indentString_.size() >= indentation_.size());
indentString_.resize(indentString_.size() - indentation_.size());
}
void StyledStreamWriter::writeCommentBeforeValue(const Value& root) {
if (!root.hasComment(commentBefore))
return;
if (!indented_)
writeIndent();
const String& comment = root.getComment(commentBefore);
String::const_iterator iter = comment.begin();
while (iter != comment.end()) {
*document_ << *iter;
if (*iter == '\n' && ((iter + 1) != comment.end() && *(iter + 1) == '/'))
// writeIndent(); // would include newline
*document_ << indentString_;
++iter;
}
indented_ = false;
}
void StyledStreamWriter::writeCommentAfterValueOnSameLine(const Value& root) {
if (root.hasComment(commentAfterOnSameLine))
*document_ << ' ' << root.getComment(commentAfterOnSameLine);
if (root.hasComment(commentAfter)) {
writeIndent();
*document_ << root.getComment(commentAfter);
}
indented_ = false;
}
bool StyledStreamWriter::hasCommentForValue(const Value& value) {
return value.hasComment(commentBefore) ||
value.hasComment(commentAfterOnSameLine) ||
value.hasComment(commentAfter);
}
//////////////////////////
// BuiltStyledStreamWriter
/// Scoped enums are not available until C++11.
struct CommentStyle {
/// Decide whether to write comments.
enum Enum {
None, ///< Drop all comments.
Most, ///< Recover odd behavior of previous versions (not implemented yet).
All ///< Keep all comments.
};
};
struct BuiltStyledStreamWriter : public StreamWriter {
BuiltStyledStreamWriter(String indentation, CommentStyle::Enum cs,
String colonSymbol, String nullSymbol,
String endingLineFeedSymbol, bool useSpecialFloats,
bool emitUTF8, unsigned int precision,
PrecisionType precisionType);
int write(Value const& root, OStream* sout) override;
private:
void writeValue(Value const& value);
void writeArrayValue(Value const& value);
bool isMultilineArray(Value const& value);
void pushValue(String const& value);
void writeIndent();
void writeWithIndent(String const& value);
void indent();
void unindent();
void writeCommentBeforeValue(Value const& root);
void writeCommentAfterValueOnSameLine(Value const& root);
static bool hasCommentForValue(const Value& value);
using ChildValues = std::vector<String>;
ChildValues childValues_;
String indentString_;
unsigned int rightMargin_;
String indentation_;
CommentStyle::Enum cs_;
String colonSymbol_;
String nullSymbol_;
String endingLineFeedSymbol_;
bool addChildValues_ : 1;
bool indented_ : 1;
bool useSpecialFloats_ : 1;
bool emitUTF8_ : 1;
unsigned int precision_;
PrecisionType precisionType_;
};
BuiltStyledStreamWriter::BuiltStyledStreamWriter(
String indentation, CommentStyle::Enum cs, String colonSymbol,
String nullSymbol, String endingLineFeedSymbol, bool useSpecialFloats,
bool emitUTF8, unsigned int precision, PrecisionType precisionType)
: rightMargin_(74), indentation_(std::move(indentation)), cs_(cs),
colonSymbol_(std::move(colonSymbol)), nullSymbol_(std::move(nullSymbol)),
endingLineFeedSymbol_(std::move(endingLineFeedSymbol)),
addChildValues_(false), indented_(false),
useSpecialFloats_(useSpecialFloats), emitUTF8_(emitUTF8),
precision_(precision), precisionType_(precisionType) {}
int BuiltStyledStreamWriter::write(Value const& root, OStream* sout) {
sout_ = sout;
addChildValues_ = false;
indented_ = true;
indentString_.clear();
writeCommentBeforeValue(root);
if (!indented_)
writeIndent();
indented_ = true;
writeValue(root);
writeCommentAfterValueOnSameLine(root);
*sout_ << endingLineFeedSymbol_;
sout_ = nullptr;
return 0;
}
void BuiltStyledStreamWriter::writeValue(Value const& value) {
switch (value.type()) {
case nullValue:
pushValue(nullSymbol_);
break;
case intValue:
pushValue(valueToString(value.asLargestInt()));
break;
case uintValue:
pushValue(valueToString(value.asLargestUInt()));
break;
case realValue:
pushValue(valueToString(value.asDouble(), useSpecialFloats_, precision_,
precisionType_));
break;
case stringValue: {
// Is NULL is possible for value.string_? No.
char const* str;
char const* end;
bool ok = value.getString(&str, &end);
if (ok)
pushValue(
valueToQuotedStringN(str, static_cast<size_t>(end - str), emitUTF8_));
else
pushValue("");
break;
}
case booleanValue:
pushValue(valueToString(value.asBool()));
break;
case arrayValue:
writeArrayValue(value);
break;
case objectValue: {
Value::Members members(value.getMemberNames());
if (members.empty())
pushValue("{}");
else {
writeWithIndent("{");
indent();
auto it = members.begin();
for (;;) {
String const& name = *it;
Value const& childValue = value[name];
writeCommentBeforeValue(childValue);
writeWithIndent(
valueToQuotedStringN(name.data(), name.length(), emitUTF8_));
*sout_ << colonSymbol_;
writeValue(childValue);
if (++it == members.end()) {
writeCommentAfterValueOnSameLine(childValue);
break;
}
*sout_ << ",";
writeCommentAfterValueOnSameLine(childValue);
}
unindent();
writeWithIndent("}");
}
} break;
}
}
void BuiltStyledStreamWriter::writeArrayValue(Value const& value) {
unsigned size = value.size();
if (size == 0)
pushValue("[]");
else {
bool isMultiLine = (cs_ == CommentStyle::All) || isMultilineArray(value);
if (isMultiLine) {
writeWithIndent("[");
indent();
bool hasChildValue = !childValues_.empty();
unsigned index = 0;
for (;;) {
Value const& childValue = value[index];
writeCommentBeforeValue(childValue);
if (hasChildValue)
writeWithIndent(childValues_[index]);
else {
if (!indented_)
writeIndent();
indented_ = true;
writeValue(childValue);
indented_ = false;
}
if (++index == size) {
writeCommentAfterValueOnSameLine(childValue);
break;
}
*sout_ << ",";
writeCommentAfterValueOnSameLine(childValue);
}
unindent();
writeWithIndent("]");
} else // output on a single line
{
assert(childValues_.size() == size);
*sout_ << "[";
if (!indentation_.empty())
*sout_ << " ";
for (unsigned index = 0; index < size; ++index) {
if (index > 0)
*sout_ << ((!indentation_.empty()) ? ", " : ",");
*sout_ << childValues_[index];
}
if (!indentation_.empty())
*sout_ << " ";
*sout_ << "]";
}
}
}
bool BuiltStyledStreamWriter::isMultilineArray(Value const& value) {
ArrayIndex const size = value.size();
bool isMultiLine = size * 3 >= rightMargin_;
childValues_.clear();
for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
Value const& childValue = value[index];
isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
!childValue.empty());
}
if (!isMultiLine) // check if line length > max line length
{
childValues_.reserve(size);
addChildValues_ = true;
ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
for (ArrayIndex index = 0; index < size; ++index) {
if (hasCommentForValue(value[index])) {
isMultiLine = true;
}
writeValue(value[index]);
lineLength += static_cast<ArrayIndex>(childValues_[index].length());
}
addChildValues_ = false;
isMultiLine = isMultiLine || lineLength >= rightMargin_;
}
return isMultiLine;
}
void BuiltStyledStreamWriter::pushValue(String const& value) {
if (addChildValues_)
childValues_.push_back(value);
else
*sout_ << value;
}
void BuiltStyledStreamWriter::writeIndent() {
// blep intended this to look at the so-far-written string
// to determine whether we are already indented, but
// with a stream we cannot do that. So we rely on some saved state.
// The caller checks indented_.
if (!indentation_.empty()) {
// In this case, drop newlines too.
*sout_ << '\n' << indentString_;
}
}
void BuiltStyledStreamWriter::writeWithIndent(String const& value) {
if (!indented_)
writeIndent();
*sout_ << value;
indented_ = false;
}
void BuiltStyledStreamWriter::indent() { indentString_ += indentation_; }
void BuiltStyledStreamWriter::unindent() {
assert(indentString_.size() >= indentation_.size());
indentString_.resize(indentString_.size() - indentation_.size());
}
void BuiltStyledStreamWriter::writeCommentBeforeValue(Value const& root) {
if (cs_ == CommentStyle::None)
return;
if (!root.hasComment(commentBefore))
return;
if (!indented_)
writeIndent();
const String& comment = root.getComment(commentBefore);
String::const_iterator iter = comment.begin();
while (iter != comment.end()) {
*sout_ << *iter;
if (*iter == '\n' && ((iter + 1) != comment.end() && *(iter + 1) == '/'))
// writeIndent(); // would write extra newline
*sout_ << indentString_;
++iter;
}
indented_ = false;
}
void BuiltStyledStreamWriter::writeCommentAfterValueOnSameLine(
Value const& root) {
if (cs_ == CommentStyle::None)
return;
if (root.hasComment(commentAfterOnSameLine))
*sout_ << " " + root.getComment(commentAfterOnSameLine);
if (root.hasComment(commentAfter)) {
writeIndent();
*sout_ << root.getComment(commentAfter);
}
}
// static
bool BuiltStyledStreamWriter::hasCommentForValue(const Value& value) {
return value.hasComment(commentBefore) ||
value.hasComment(commentAfterOnSameLine) ||
value.hasComment(commentAfter);
}
///////////////
// StreamWriter
StreamWriter::StreamWriter() : sout_(nullptr) {}
StreamWriter::~StreamWriter() = default;
StreamWriter::Factory::~Factory() = default;
StreamWriterBuilder::StreamWriterBuilder() { setDefaults(&settings_); }
StreamWriterBuilder::~StreamWriterBuilder() = default;
StreamWriter* StreamWriterBuilder::newStreamWriter() const {
const String indentation = settings_["indentation"].asString();
const String cs_str = settings_["commentStyle"].asString();
const String pt_str = settings_["precisionType"].asString();
const bool eyc = settings_["enableYAMLCompatibility"].asBool();
const bool dnp = settings_["dropNullPlaceholders"].asBool();
const bool usf = settings_["useSpecialFloats"].asBool();
const bool emitUTF8 = settings_["emitUTF8"].asBool();
unsigned int pre = settings_["precision"].asUInt();
CommentStyle::Enum cs = CommentStyle::All;
if (cs_str == "All") {
cs = CommentStyle::All;
} else if (cs_str == "None") {
cs = CommentStyle::None;
} else {
throwRuntimeError("commentStyle must be 'All' or 'None'");
}
PrecisionType precisionType(significantDigits);
if (pt_str == "significant") {
precisionType = PrecisionType::significantDigits;
} else if (pt_str == "decimal") {
precisionType = PrecisionType::decimalPlaces;
} else {
throwRuntimeError("precisionType must be 'significant' or 'decimal'");
}
String colonSymbol = " : ";
if (eyc) {
colonSymbol = ": ";
} else if (indentation.empty()) {
colonSymbol = ":";
}
String nullSymbol = "null";
if (dnp) {
nullSymbol.clear();
}
if (pre > 17)
pre = 17;
String endingLineFeedSymbol;
return new BuiltStyledStreamWriter(indentation, cs, colonSymbol, nullSymbol,
endingLineFeedSymbol, usf, emitUTF8, pre,
precisionType);
}
bool StreamWriterBuilder::validate(Json::Value* invalid) const {
static const auto& valid_keys = *new std::set<String>{
"indentation",
"commentStyle",
"enableYAMLCompatibility",
"dropNullPlaceholders",
"useSpecialFloats",
"emitUTF8",
"precision",
"precisionType",
};
for (auto si = settings_.begin(); si != settings_.end(); ++si) {
auto key = si.name();
if (valid_keys.count(key))
continue;
if (invalid)
(*invalid)[key] = *si;
else
return false;
}
return invalid ? invalid->empty() : true;
}
Value& StreamWriterBuilder::operator[](const String& key) {
return settings_[key];
}
// static
void StreamWriterBuilder::setDefaults(Json::Value* settings) {
//! [StreamWriterBuilderDefaults]
(*settings)["commentStyle"] = "All";
(*settings)["indentation"] = "\t";
(*settings)["enableYAMLCompatibility"] = false;
(*settings)["dropNullPlaceholders"] = false;
(*settings)["useSpecialFloats"] = false;
(*settings)["emitUTF8"] = false;
(*settings)["precision"] = 17;
(*settings)["precisionType"] = "significant";
//! [StreamWriterBuilderDefaults]
}
String writeString(StreamWriter::Factory const& factory, Value const& root) {
OStringStream sout;
StreamWriterPtr const writer(factory.newStreamWriter());
writer->write(root, &sout);
return sout.str();
}
OStream& operator<<(OStream& sout, Value const& root) {
StreamWriterBuilder builder;
StreamWriterPtr const writer(builder.newStreamWriter());
writer->write(root, &sout);
return sout;
}
} // namespace Json
// //////////////////////////////////////////////////////////////////////
// End of content of file: src/lib_json/json_writer.cpp
// //////////////////////////////////////////////////////////////////////
| [
"alaa@temcocontrols.com"
] | alaa@temcocontrols.com |
855b4b06d0e2b424188e6f2721b9d217118804b6 | 8b734b0ddef937c222b8d2a50fb511faac52af7b | /SNES_Jukebox/progress_bar.h | c949a9a0571329bad875cbeea68b286fa3710867 | [
"MIT"
] | permissive | rrogovski/snes-jukebox | 82fcd747854cb4d08ec2fe03fc7a88f1f21d210a | 268e7d4b595a9318cd9fbbdd0ce2396a7ceacb5f | refs/heads/master | 2020-03-25T06:10:30.462199 | 2015-10-21T05:15:44 | 2015-10-21T05:35:13 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,335 | h | #ifndef PROGRESS_BAR_H
#define PROGRESS_BAR_H
#include "jukebox_io.h"
class ProgressBar {
public:
#define PROGRESS_BAR_HEIGHT 8
ProgressBar(Adafruit_ST7735 &lcd_, byte x_, byte y_, byte width_, uint32_t maxProgress_) : lcd(lcd_), x(x_), y(y_), width(width_), maxProgress(maxProgress_) {
currentProgress = 0;
lastProgress = 0;
beginLcdWrite();
lcd.drawRect(x, y, width, PROGRESS_BAR_HEIGHT, ST7735_WHITE);
lcd.fillRect(x + 1, y + 1, width - 2, PROGRESS_BAR_HEIGHT - 2, ST7735_BLACK);
endLcdWrite();
}
void addProgress(uint32_t newProgress) {
currentProgress += newProgress;
if (currentProgress > maxProgress)
currentProgress = maxProgress;
int lastProgressWidth = (int)floor(((float)lastProgress / maxProgress) * (width - 2));
int currentProgressWidth = (int)floor(((float)currentProgress / maxProgress) * (width - 2));
if (currentProgressWidth > lastProgressWidth) {
beginLcdWrite();
lcd.fillRect(x + 1 + lastProgressWidth, y + 1, (currentProgressWidth - lastProgressWidth), PROGRESS_BAR_HEIGHT - 2, ST7735_GREEN);
endLcdWrite();
}
lastProgress = currentProgress;
}
private:
Adafruit_ST7735 &lcd;
byte x;
byte y;
byte width;
uint32_t maxProgress;
uint32_t currentProgress;
uint32_t lastProgress;
};
#endif
| [
"pika242@gmail.com"
] | pika242@gmail.com |
f1cb3ba5a22448d47e15dc7c6e882cba16904f17 | eb2f8b3271e8ef9c9b092fcaeff3ff8307f7af86 | /Grade 10-12/2018 autumn/NOIP/NOIP2018提高组Day2程序包/answers/GD-0609/game/game.cpp | ab23b10f26e465ed2c357af83c40d31a749d1c6d | [] | no_license | Orion545/OI-Record | 0071ecde8f766c6db1f67b9c2adf07d98fd4634f | fa7d3a36c4a184fde889123d0a66d896232ef14c | refs/heads/master | 2022-01-13T19:39:22.590840 | 2019-05-26T07:50:17 | 2019-05-26T07:50:17 | 188,645,194 | 4 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 746 | cpp | #include <cstdio>
#include <cstring>
#include <cstdlib>
const int N = 1000007, M = 5, P = 1e9 + 7;
int f[N][1 << M];
int n, m, full;
int main()
{
freopen("game.in", "r", stdin);
freopen("game.out", "w", stdout);
scanf("%d%d", &n, &m);
if (n == 3 && m == 3) { printf("112\n"); return 0; }
if (n == 5 && m == 5) { printf("7136\n"); return 0; }
full = (1 << n) - 1;
for (int s = 0; s <= full; s++) f[1][s] = 1;
for (int i = 2; i <= m; i++)
for (int s = 0; s <= full; s++)
for (int s1 = 0; s1 <= full; s1++)
if (((s >> 1) & s1) == (s >> 1))
f[i][s] = (f[i][s] + f[i - 1][s1]) % P;
int ans = 0;
for (int s = 0; s <= full; s++) ans = (ans + f[m][s]) % P;
printf("%d\n", ans);
fclose(stdin);
fclose(stdout);
return 0;
}
| [
"orion545@qq.com"
] | orion545@qq.com |
0444fb12a3c592cd507628028757a58ecfafb3df | e0cd22a3dbf1589cee37c33374607ed2ce66e95e | /cpp/opensourcesrcs/ace/ace/config-hpux-10.x-g++.h | 0d5cac38abfe8b5844f65bbf9f93cc62b7b7a834 | [
"BSD-3-Clause"
] | permissive | CodeOpsTech/DesignPatternsCpp | 1335402e2c88a4b8715430210ec153af7bb733be | 2c67495ffdc65443fae98b2879f7b608e3562876 | refs/heads/master | 2021-01-11T19:19:48.498940 | 2017-07-19T02:52:56 | 2017-07-19T02:52:56 | 79,355,314 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 801 | h | /* -*- C++ -*- */
// config-hpux-10.x-g++.h,v 4.24 2000/03/23 21:27:02 nanbor Exp
// The following configuration file is designed to work for HP
// platforms running HP/UX 10.x using G++.
#ifndef ACE_CONFIG_H
#define ACE_CONFIG_H
#include "ace/pre.h"
// config-g++-common.h undef's ACE_HAS_STRING_CLASS with -frepo, so
// this must appear before its #include.
#define ACE_HAS_STRING_CLASS
#include "ace/config-g++-common.h"
// These are apparantly some things which are special to g++ on HP? They are
// compiler-related settings, but not in config-g++-common.h
#define ACE_HAS_BROKEN_CONVERSIONS
// Compiler supports the ssize_t typedef.
#define ACE_HAS_SSIZE_T
#define _CLOCKID_T
#include "ace/config-hpux-10.x.h"
#include "ace/post.h"
#endif /* ACE_CONFIG_H */
| [
"ganesh@codeops.tech"
] | ganesh@codeops.tech |
05653133e4960acb4c4133bbaa100d38b5626c85 | 18a3f93e4b94f4f24ff17280c2820497e019b3db | /geant4/G4GeomTestSegment.hh | 41ed345061c0bb3df9b94ce79695368dc0565998 | [] | no_license | jjzhang166/BOSS_ExternalLibs | 0e381d8420cea17e549d5cae5b04a216fc8a01d7 | 9b3b30f7874ed00a582aa9526c23ca89678bf796 | refs/heads/master | 2023-03-15T22:24:21.249109 | 2020-11-22T15:11:45 | 2020-11-22T15:11:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,203 | hh | //
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// $Id: G4GeomTestSegment.hh,v 1.4 2007/05/11 13:43:59 gcosmo Exp $
// GEANT4 tag $Name: geant4-09-03-patch-01 $
//
// --------------------------------------------------------------------
// GEANT 4 class header file
//
// G4GeomTestSegment
//
// Class description:
//
// Locate all points on a line that intersect a solid,
// and return them in no particular order
// Author: D.C.Williams, UCSC (davidw@scipp.ucsc.edu)
// --------------------------------------------------------------------
#ifndef G4GeomTestSegment_hh
#define G4GeomTestSegment_hh
#include "G4Types.hh"
#include "G4ThreeVector.hh"
#include "G4GeomTestPoint.hh"
#include <vector>
class G4VSolid;
class G4GeomTestLogger;
class G4GeomTestSegment
{
public: // with description
G4GeomTestSegment( const G4VSolid *theSolid,
const G4ThreeVector &theP,
const G4ThreeVector &theV,
G4GeomTestLogger *logger );
// Constructor
const G4VSolid *GetSolid() const;
const G4ThreeVector &GetP() const;
const G4ThreeVector &GetV() const;
const G4GeomTestPoint &GetPoint( G4int i ) const;
G4int GetNumberPoints() const;
// Accessors
private:
void FindPoints( G4GeomTestLogger *logger );
void FindSomePoints( G4GeomTestLogger *logger, G4bool forward );
void PatchInconsistencies( G4GeomTestLogger *logger );
const G4VSolid * solid;
const G4ThreeVector p0,v;
std::vector<G4GeomTestPoint> points;
G4double kCarTolerance;
};
#endif
| [
"r.e.deboer@students.uu.nl"
] | r.e.deboer@students.uu.nl |
4130f0284587b7db58d4db4cf0bf8b54d2eef0e0 | 11b90205f3f37db632d47f3623932fd0207bf512 | /Parser.cpp | 0ffbbdf109a0b24bad77655cd52a743d68a209a2 | [] | no_license | yaelwb/CPUParser | d3c91438c1a300f61efb219ad3704e094acc3667 | f68723f5ce87c2106f1b550b1d81a0a7c75a68a5 | refs/heads/master | 2021-01-25T07:34:20.745679 | 2013-01-06T07:26:49 | 2013-01-06T07:26:49 | 7,314,408 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,729 | cpp | #include "stdafx.h"
#include "Parser.h"
Parser::Parser(): m_cmd_count(0)
{
m_cmdMap["mov"] = CMD_2_REGS;
m_cmdMap["xor"] = CMD_3_REGS;
m_cmdMap["and"] = CMD_3_REGS;
m_cmdMap["or"] = CMD_3_REGS;
m_cmdMap["nxor"] = CMD_3_REGS;
m_cmdMap["nor"] = CMD_3_REGS;
m_cmdMap["nand"] = CMD_3_REGS;
m_cmdMap["add"] = CMD_3_REGS;
m_cmdMap["sub"] = CMD_3_REGS;
m_cmdMap["mul"] = CMD_3_REGS;
m_cmdMap["div"] = CMD_3_REGS;
m_cmdMap["addfp"] = CMD_3_REGS_FP;
m_cmdMap["subfp"] = CMD_3_REGS_FP;
m_cmdMap["mulfp"] = CMD_3_REGS_FP;
m_cmdMap["divfp"] = CMD_3_REGS_FP;
m_cmdMap["cmpreg"] = CMD_3_REGS;
m_cmdMap["not"] = CMD_2_REGS;
m_cmdMap["abs"] = CMD_2_REGS;
m_cmdMap["absfp"] = CMD_2_REGS_FP;
m_cmdMap["sllr"] = CMD_2_REGS;
m_cmdMap["slar"] = CMD_2_REGS;
m_cmdMap["srlr"] = CMD_2_REGS;
m_cmdMap["srar"] = CMD_2_REGS;
m_cmdMap["rotlr"] = CMD_2_REGS;
m_cmdMap["rotrr"] = CMD_2_REGS;
m_cmdMap["ldfm"] = CMD_LDFM;
m_cmdMap["stfm"] = CMD_STFM;
m_cmdMap["xori"] = CMD_2_REGS_IMM;
m_cmdMap["andi"] = CMD_2_REGS_IMM;
m_cmdMap["ori"] = CMD_2_REGS_IMM;
m_cmdMap["nxori"] = CMD_2_REGS_IMM;
m_cmdMap["nori"] = CMD_2_REGS_IMM;
m_cmdMap["nandi"] = CMD_2_REGS_IMM;
m_cmdMap["addi"] = CMD_2_REGS_IMM;
m_cmdMap["subi"] = CMD_2_REGS_IMM;
m_cmdMap["muli"] = CMD_2_REGS_IMM;
m_cmdMap["divi"] = CMD_2_REGS_IMM;
m_cmdMap["addfpi"] = CMD_2_REGS_IMM_FP;
m_cmdMap["subfpi"] = CMD_2_REGS_IMM_FP;
m_cmdMap["mulfpi"] = CMD_2_REGS_IMM_FP;
m_cmdMap["divfpi"] = CMD_2_REGS_IMM_FP;
m_cmdMap["cmpregi"] = CMD_2_REGS_IMM;
m_cmdMap["jmp"] = CMD_JUMP;
m_cmdMap["bre"] = CMD_JUMP;
m_cmdMap["brue"] = CMD_JUMP;
m_cmdMap["brg"] = CMD_JUMP;
m_cmdMap["bls"] = CMD_JUMP;
m_cmdMap["btr"] = CMD_JUMP;
m_cmdMap["bfs"] = CMD_JUMP;
m_cmdMap["jmpr"] = CMD_REG_IMM;
m_cmdMap["slli"] = CMD_REG_IMM;
m_cmdMap["slai"] = CMD_REG_IMM;
m_cmdMap["srli"] = CMD_REG_IMM;
m_cmdMap["srai"] = CMD_REG_IMM;
m_cmdMap["rotli"] = CMD_REG_IMM;
m_cmdMap["rotri"] = CMD_REG_IMM;
m_cmdMap["ldfh"] = CMD_LDFH;
m_cmdMap["ldfl"] = CMD_LDFL;
m_cmdMap["ldf"] = CMD_LDF;
m_cmdMap["goto"] = CMD_GOTO;
m_cmdMap["nop"] = CMD_SINGLE;
m_cmdMap["clr"] = CMD_SINGLE;
}
int Parser::PostProcessLabels()
{
int cmd_idx = 0, imm_val = 0;
map<int, string>::iterator it = m_unresolvedLabels.begin();
for (; it != m_unresolvedLabels.end(); it++)
{
cmd_idx = (*it).first;
string lbl((*it).second);
CmdInfo &cmdInfo = m_commands[cmd_idx];
map<string, int>::iterator it1 = m_labelsMap.find(lbl);
if (it1 != m_labelsMap.end())
cmdInfo.SetImm(it1->second);
}
return NO_ERROR_FOUND;
}
int Parser::ProcessLine(string assembly_cmd)
{
string cmd, label;
int ret = NO_ERROR_FOUND;
CmdInfo cmdInfo;
//eliminate whitespaces
size_t start_pos = 0, end_pos = 0;
string whitespaces (" \t\f\v\n\r");
eliminatePreceedingWhitespaces(assembly_cmd);
eliminateSucceedingWhitespaces(assembly_cmd);
//parse labels
while ((end_pos = assembly_cmd.find_first_of(":")) != string::npos)
{
label = assembly_cmd.substr(0,end_pos);
assembly_cmd.erase(0,end_pos +1);
eliminatePreceedingWhitespaces(label);
eliminateSucceedingWhitespaces(label);
if(!label.empty() && label.find_first_not_of(whitespaces) != string::npos)
m_labelsMap[label] = m_cmd_count;
}
eliminatePreceedingWhitespaces(assembly_cmd);
if(assembly_cmd.empty())
return NO_ERROR_FOUND;
//isolate command
end_pos = assembly_cmd.find_first_of(whitespaces);
cmd = assembly_cmd.substr(0,end_pos);
assembly_cmd.erase(0,end_pos);
eliminatePreceedingWhitespaces(assembly_cmd);
map<string,int>::iterator it = m_cmdMap.find(cmd);
if (it == m_cmdMap.end())
return UNKNOWN_CMD;
int command_type = it->second;
cmdInfo.SetAssemblyStr(assembly_cmd);
cmdInfo.SetCommand(cmd);
cmdInfo.SetCommandType(command_type);
switch (command_type)
{
case CMD_3_REGS:
ret = parse3Regs(cmdInfo);
break;
case CMD_2_REGS:
ret = parse2Regs(cmdInfo);
break;
case CMD_2_REGS_IMM:
ret = parse2RegsIMM(cmdInfo);
break;
case CMD_3_REGS_FP:
ret = parse3Regs_FP(cmdInfo);
break;
case CMD_2_REGS_FP:
ret = parse2Regs_FP(cmdInfo);
break;
case CMD_2_REGS_IMM_FP:
ret = parse2RegsIMM_FP(cmdInfo);
break;
case CMD_IMM:
ret = parseIMM(cmdInfo);
break;
case CMD_REG_IMM:
ret = parseRegsIMM(cmdInfo);
break;
case CMD_SINGLE:
break;
case CMD_JUMP:
ret = parseJump(cmdInfo);
break;
case CMD_GOTO:
ret = parseGOTO(cmdInfo);
break;
case CMD_LDFM:
ret = parseLDFM(cmdInfo);
break;
case CMD_STFM:
ret = parseSTFM(cmdInfo);
break;
case CMD_LDF:
ret = parseLDF(cmdInfo);
cmdInfo.SetCommandType(CMD_LDFH);
cmdInfo.SetCommand("ldfh");
break;
default:
ret = UNKNOWN_CMD;
}
if (ret != NO_ERROR_FOUND)
return ret;
if (parseRemainingChars(cmdInfo.GetAssemblyStr()) != NO_ERROR_FOUND)
return ILLEGAL_CMD_STX;
m_commands.push_back(cmdInfo);
m_cmd_count++;
if(command_type == CMD_LDF)
{
CmdInfo cmdInfoLow;
cmdInfoLow.SetCommandType(CMD_LDFL);
cmdInfoLow.SetCommand("ldfl");
cmdInfoLow.SetFloat(cmdInfo.GetFloat());
cmdInfoLow.SetR1(cmdInfo.GetR1());
m_commands.push_back(cmdInfoLow);
m_cmd_count++;
}
return NO_ERROR_FOUND;
}
int Parser::parse3Regs(CmdInfo &cmdInfo)
{
int err = NO_ERROR_FOUND;
if ((err = parseReg(cmdInfo.m_assembly_str, cmdInfo.m_r1)) == NO_ERROR_FOUND &&
(err = parseReg(cmdInfo.m_assembly_str, cmdInfo.m_r2)) == NO_ERROR_FOUND &&
(err = parseReg(cmdInfo.m_assembly_str, cmdInfo.m_r3)) == NO_ERROR_FOUND)
return NO_ERROR_FOUND;
return err;
}
int Parser::parse2Regs(CmdInfo &cmdInfo)
{
int err = NO_ERROR_FOUND;
if ((err = parseReg(cmdInfo.m_assembly_str, cmdInfo.m_r1)) == NO_ERROR_FOUND &&
(err = parseReg(cmdInfo.m_assembly_str, cmdInfo.m_r2)) == NO_ERROR_FOUND)
return NO_ERROR_FOUND;
return err;
}
int Parser::parse2RegsIMM(CmdInfo &cmdInfo)
{
int err = NO_ERROR_FOUND;
if ((err = parseReg(cmdInfo.m_assembly_str, cmdInfo.m_r1)) == NO_ERROR_FOUND &&
(err = parseReg(cmdInfo.m_assembly_str, cmdInfo.m_r2)) == NO_ERROR_FOUND &&
(err = parseIMM(cmdInfo)) == NO_ERROR_FOUND)
return NO_ERROR_FOUND;
return err;
}
int Parser::parse3Regs_FP(CmdInfo &cmdInfo)
{
int err = NO_ERROR_FOUND;
if ((err = parseFReg(cmdInfo.m_assembly_str, cmdInfo.m_r1)) == NO_ERROR_FOUND &&
(err = parseFReg(cmdInfo.m_assembly_str, cmdInfo.m_r2)) == NO_ERROR_FOUND &&
(err = parseFReg(cmdInfo.m_assembly_str, cmdInfo.m_r3)) == NO_ERROR_FOUND)
return NO_ERROR_FOUND;
return err;
}
int Parser::parse2Regs_FP(CmdInfo &cmdInfo)
{
int err = NO_ERROR_FOUND;
if ((err = parseFReg(cmdInfo.m_assembly_str, cmdInfo.m_r1)) == NO_ERROR_FOUND &&
(err = parseFReg(cmdInfo.m_assembly_str, cmdInfo.m_r2)) == NO_ERROR_FOUND)
return NO_ERROR_FOUND;
return err;
}
int Parser::parse2RegsIMM_FP(CmdInfo &cmdInfo)
{
int err = NO_ERROR_FOUND;
if ((err = parseFReg(cmdInfo.m_assembly_str, cmdInfo.m_r1)) == NO_ERROR_FOUND &&
(err = parseFReg(cmdInfo.m_assembly_str, cmdInfo.m_r2)) == NO_ERROR_FOUND &&
(err = parseIMM(cmdInfo)) == NO_ERROR_FOUND)
return NO_ERROR_FOUND;
return err;
}
int Parser::parseIMM(CmdInfo &cmdInfo)
{
int n = 0;
eliminatePreceedingWhitespaces(cmdInfo.m_assembly_str);
eliminateSucceedingWhitespaces(cmdInfo.m_assembly_str);
n = atoi(cmdInfo.m_assembly_str.c_str());
if(n > 32767 || n < -32767)
return ILLEGAL_IMM_VAL;
cmdInfo.SetImm(n);
string numeric ("0123456789-");
size_t end_pos = cmdInfo.m_assembly_str.find_first_not_of(numeric);
cmdInfo.m_assembly_str.erase(0,end_pos);
return NO_ERROR_FOUND;
}
int Parser::parseF(CmdInfo &cmdInfo)
{
float f = 0;
eliminatePreceedingWhitespaces(cmdInfo.m_assembly_str);
eliminateSucceedingWhitespaces(cmdInfo.m_assembly_str);
sscanf(cmdInfo.m_assembly_str.c_str(),"%f",&f);
cmdInfo.SetFloat(f);
string numeric ("0123456789.-");
size_t end_pos = cmdInfo.m_assembly_str.find_first_not_of(numeric);
cmdInfo.m_assembly_str.erase(0,end_pos);
return NO_ERROR_FOUND;
}
int Parser::parseRegsIMM(CmdInfo &cmdInfo)
{
int err = NO_ERROR_FOUND;
if ((err = parseReg(cmdInfo.m_assembly_str, cmdInfo.m_r1)) == NO_ERROR_FOUND &&
(err = parseIMM(cmdInfo)) == NO_ERROR_FOUND)
return NO_ERROR_FOUND;
return err;
}
int Parser::parseJump(CmdInfo &cmdInfo)
{
eliminatePreceedingWhitespaces(cmdInfo.m_assembly_str);
eliminateSucceedingWhitespaces(cmdInfo.m_assembly_str);
cmdInfo.SetImm(atoi(cmdInfo.m_assembly_str.c_str()));
string numeric ("0123456789");
size_t end_pos = cmdInfo.m_assembly_str.find_first_not_of(numeric);
cmdInfo.m_assembly_str.erase(0,end_pos);
return NO_ERROR_FOUND;
}
int Parser::parseGOTO(CmdInfo &cmdInfo)
{
eliminatePreceedingWhitespaces(cmdInfo.m_assembly_str);
eliminateSucceedingWhitespaces(cmdInfo.m_assembly_str);
map<string, int>::iterator it = m_labelsMap.find(cmdInfo.GetAssemblyStr());
if (it != m_labelsMap.end())
{
cmdInfo.SetImm(it->second);
cmdInfo.m_assembly_str.clear();
return NO_ERROR_FOUND;
}
m_unresolvedLabels[m_cmd_count] = cmdInfo.GetAssemblyStr();
cmdInfo.m_assembly_str.clear();
return NO_ERROR_FOUND;
}
int Parser::parseReg(string &assembly_str, int &r)
{
eliminatePreceedingWhitespaces(assembly_str);
if(assembly_str[0] != 'R')
return ILLEGAL_CMD_STX;
assembly_str.erase(0,1);
int n = ILLEGAL_VALUE;
n = atoi(assembly_str.c_str());
if(n > 31 || n < 0)
return ILLEGAL_REG_NO;
r = n;
int pos = ((n>9)? 2:1);
assembly_str.erase(0,pos);
return NO_ERROR_FOUND;
}
int Parser::parseFReg(string &assembly_str, int &r)
{
eliminatePreceedingWhitespaces(assembly_str);
if(assembly_str[0] != 'F' || assembly_str[1] != 'R')
return ILLEGAL_CMD_STX;
assembly_str.erase(0,2);
int n = ILLEGAL_VALUE;
n = atoi(assembly_str.c_str());
if(n > 7 || n < 0)
return ILLEGAL_REG_NO;
r = n;
assembly_str.erase(0,1);
return NO_ERROR_FOUND;
}
void Parser::eliminatePreceedingWhitespaces(string &assembly_str)
{
size_t start_pos = 0;
string whitespaces (" \t\f\v\n\r");
start_pos = assembly_str.find_first_not_of(whitespaces);
if (start_pos!=string::npos)
assembly_str.erase(0,start_pos);
}
void Parser::eliminateSucceedingWhitespaces(string &assembly_str)
{
string whitespaces (" \t\f\v\n\r");
size_t end_pos = assembly_str.find_last_not_of(whitespaces);
if (end_pos!=string::npos)
assembly_str.erase(end_pos+1);
}
int Parser::parseRemainingChars(string &assembly_str)
{
string whitespaces (" \t\f\v\n\r");
size_t start_pos = assembly_str.find_first_not_of(whitespaces);
if (start_pos!=string::npos)
return ILLEGAL_CMD_STX;
return NO_ERROR_FOUND;
}
int Parser::parseLDFM(CmdInfo &cmdInfo)
{
int err = NO_ERROR_FOUND;
if ((err = parseIMM(cmdInfo)) == NO_ERROR_FOUND &&
(err = parseFReg(cmdInfo.m_assembly_str, cmdInfo.m_r1)) == NO_ERROR_FOUND)
return NO_ERROR_FOUND;
return err;
}
int Parser::parseSTFM(CmdInfo &cmdInfo)
{
int err = NO_ERROR_FOUND;
if ((err = parseFReg(cmdInfo.m_assembly_str, cmdInfo.m_r1)) == NO_ERROR_FOUND &&
(err = parseIMM(cmdInfo)) == NO_ERROR_FOUND)
return NO_ERROR_FOUND;
return err;
}
int Parser::parseLDF(CmdInfo &cmdInfo)
{
int err = NO_ERROR_FOUND;
if ((err = parseFReg(cmdInfo.m_assembly_str, cmdInfo.m_r1)) == NO_ERROR_FOUND &&
(err = parseF(cmdInfo)) == NO_ERROR_FOUND)
return NO_ERROR_FOUND;
return err;
}
Parser::~Parser()
{
} | [
"yaelwb@gmail.com"
] | yaelwb@gmail.com |
a95a4726ef05df980fb52d55a0a0c8a439c07d89 | 3bbc63175bbff8163b5f6b6af94a4499db10a581 | /StuMgr/Mid/RecvThread.h | be9503bbac348b22620cf6555c626e1c38806304 | [] | no_license | chancelee/MyProject | 76f8eb642544a969efbb10fa4e468daeba5b88ef | 62f5825b244f36ed50f6c88868e13670e37281d5 | refs/heads/master | 2021-09-16T01:31:00.158096 | 2018-06-14T10:08:42 | 2018-06-14T10:08:42 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 664 | h | // RecvThread.h: interface for the CRecvThread class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_RECVTHREAD_H__FD2FA857_694B_476A_82A1_50FE2DB67F1D__INCLUDED_)
#define AFX_RECVTHREAD_H__FD2FA857_694B_476A_82A1_50FE2DB67F1D__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "..\common\ICommand.h"
class CRecvThread : public ICommand
{
public:
CRecvThread(LPVOID lParam, SOCKET socket);
virtual ~CRecvThread();
virtual BOOL Exec();
private:
SOCKET m_sockClient;
LPVOID m_lParam;
};
#endif // !defined(AFX_RECVTHREAD_H__FD2FA857_694B_476A_82A1_50FE2DB67F1D__INCLUDED_)
| [
"styxschip@sina.com"
] | styxschip@sina.com |
22010febe91c178139fba8c4a490bb499782c2d3 | 2f10f807d3307b83293a521da600c02623cdda82 | /deps/boost/win/debug/include/boost/multiprecision/cpp_int/limits.hpp | 20267cc40a4810e4ab15200f272fcb4a32243be1 | [] | no_license | xpierrohk/dpt-rp1-cpp | 2ca4e377628363c3e9d41f88c8cbccc0fc2f1a1e | 643d053983fce3e6b099e2d3c9ab8387d0ea5a75 | refs/heads/master | 2021-05-23T08:19:48.823198 | 2019-07-26T17:35:28 | 2019-07-26T17:35:28 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 130 | hpp | version https://git-lfs.github.com/spec/v1
oid sha256:12b8d653f334d43b593fc7fe77d0c55a9891909c6b14fb3b0b9915c2ac50bb82
size 20489
| [
"YLiLarry@gmail.com"
] | YLiLarry@gmail.com |
57f74df476df092daa5c376a0e60d9059edc2e17 | 2550a0de6c2285d94fd3f42b24f8f2a6696045c3 | /Normal/1082/A.cpp | c449c0bb95600062c2d89dd2390371b27f44317f | [] | no_license | Mohd-3/Codeforces-Solutions | a2b26cf2072de7cdc0d2e754d7f0df0bad50174f | 97b0caf353a811f134a4c0206fd3c74fb4707149 | refs/heads/master | 2020-09-01T22:51:20.581848 | 2019-11-04T00:25:09 | 2019-11-04T00:25:09 | 219,078,353 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 597 | cpp | #include <bits/stdc++.h>
using namespace std;
int t, n, d, x, y;
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d %d %d %d", &n, &x, &y, &d);
int ans = 1e9;
if (abs(x-y)%d == 0) {
ans = min(ans, abs(x-y)/d);
}
if ((y-1)%d == 0) {
ans = min(ans, (x-1+(d-1))/d + ((y-1)/d));
}
if ((n-y)%d == 0) {
ans = min((n-x+(d-1))/d + (n-y)/d, ans);
}
if (ans == 1e9)
printf("-1\n");
else
printf("%d\n", ans);
}
return 0;
}
| [
"mohd@al-abdulhadi.com"
] | mohd@al-abdulhadi.com |
c339e22d9ec14283043065fc0d6a065ad0a8e130 | 13e692134aca70d66f03325b08384210a5e6fef1 | /process_vcf_seq_utils.h | dcb58dd6a585c7b02f69d62748bd8b7b3689c923 | [] | no_license | millanek/evo | 2fdbb1d026ab4afe7c9936706ac1d39c878a4ef5 | 88e673061f2a67ebd8f51fd4151b18d04e0182c4 | refs/heads/master | 2022-08-05T20:14:30.629362 | 2022-08-03T12:35:13 | 2022-08-03T12:35:13 | 17,292,881 | 7 | 6 | null | 2019-10-01T12:21:19 | 2014-02-28T16:52:16 | C++ | UTF-8 | C++ | false | false | 5,885 | h | //
// process_vcf_seq_utils.h
// process_vcf
//
// Created by Milan Malinsky on 17/10/2013.
// Copyright (c) 2013 Milan Malinsky. All rights reserved.
//
#ifndef process_vcf_process_vcf_seq_utils_h
#define process_vcf_process_vcf_seq_utils_h
#include <iostream>
#include <vector>
#include <map>
#include <sstream>
#include <fstream>
#include "process_vcf_IUPAC.h"
#include "process_vcf_utils.h"
inline void appendGenotypeBaseToString(std::string& toExtend, const std::string& ref, const std::string& alt, const std::vector<char>& genotype, char hetTreatment) {
if (genotype[0] == '0' && genotype[1] == '0')
toExtend.append(ref);
else if (genotype[0] == '1' && genotype[1] == '1')
toExtend.append(alt);
else {
if (hetTreatment == 'r') {
double rn = ((double) rand() / RAND_MAX);
if (rn <= 0.5) {
toExtend.append(ref);
} else {
toExtend.append(alt);
}
} else if(hetTreatment == 'p') {
if (genotype[0] == '0')
toExtend.append(ref);
if (genotype[0] == '1')
toExtend.append(alt);
} else if (hetTreatment == 'i') {
std::string ambiguityBase = getAmbiguityCode(ref, alt);
toExtend.append(ambiguityBase);
} else if (hetTreatment == 'b') {
if (genotype[1] == '0')
toExtend.append(ref);
if (genotype[1] == '1')
toExtend.append(alt);
}
}
}
inline std::vector<std::string> returnGenotypeBaseAndZeroOne(const std::string& ref, const std::string& alt, const std::vector<char>& genotype, char hetTreatment) {
std::vector<std::string> baseZeroOne;
if (genotype[0] == '0' && genotype[1] == '0') {
baseZeroOne.push_back(ref); baseZeroOne.push_back("0");
return baseZeroOne;
} else if (genotype[0] == '1' && genotype[1] == '1') {
baseZeroOne.push_back(alt); baseZeroOne.push_back("1");
return baseZeroOne;
} else if (genotype[0] == '.' && genotype[1] == '.') { // Missing data
baseZeroOne.push_back("."); baseZeroOne.push_back("0");
return baseZeroOne;
} else {
if (hetTreatment == 'r') {
double rn = ((double) rand() / RAND_MAX);
if (rn <= 0.5) {
baseZeroOne.push_back(ref); baseZeroOne.push_back("0");
return baseZeroOne;
} else {
baseZeroOne.push_back(alt); baseZeroOne.push_back("1");
return baseZeroOne;
}
} else if(hetTreatment == 'p') {
if (genotype[0] == '0') {
baseZeroOne.push_back(ref); baseZeroOne.push_back("0");
return baseZeroOne;
} else if (genotype[0] == '1') {
baseZeroOne.push_back(alt); baseZeroOne.push_back("1");
return baseZeroOne;
}
} else if (hetTreatment == 'b') {
if (genotype[1] == '0') {
baseZeroOne.push_back(ref); baseZeroOne.push_back("0");
return baseZeroOne;
} else if (genotype[1] == '1') {
baseZeroOne.push_back(alt); baseZeroOne.push_back("1");
return baseZeroOne;
}
} else {
exit(1);
}
}
exit(1);
}
inline std::string returnGenotypeBaseZeroOne(const std::vector<char>& genotype, char hetTreatment) {
if (genotype[0] == '0' && genotype[1] == '0')
return "0";
else if (genotype[0] == '1' && genotype[1] == '1')
return "1";
else {
if (hetTreatment == 'r') {
double rn = ((double) rand() / RAND_MAX);
if (rn <= 0.5) {
return "0";
} else {
return "1";
}
} else if(hetTreatment == 'p') {
if (genotype[0] == '0')
return "0";
if (genotype[0] == '1')
return "1";
} else if (hetTreatment == 'b') {
if (genotype[1] == '0')
return "0";
if (genotype[1] == '1')
return "1";
} else {
exit(1);
}
}
exit(1);
}
// Read a scaffold from a reference genome fasta file into a single string +
// put the name of the next scaffold into the "nextScaffoldName" variable
inline std::string readScaffold(std::ifstream*& genomeFile, std::string& nextScaffoldName) {
std::string scaffoldString;
scaffoldString.reserve(100000000);
std::string line = "";
while (getline(*genomeFile, line) && line[0] != '>') {
scaffoldString.append(line);
}
if (line[0] == '>')
nextScaffoldName = split(line,' ')[0];
else
nextScaffoldName = "";
return scaffoldString;
}
// Read the last scaffold from a reference genome fasta file into a single string
/*inline std::string readLastScaffold(std::ifstream*& genomeFile) {
std::string scaffoldString;
scaffoldString.reserve(100000000);
std::string line = "";
while (getline(*genomeFile, line) && line[0] != '>') {
scaffoldString.append(line);
}
return scaffoldString;
} */
// Deal with the situation that there are scaffolds without any variable sites
// read through the genome file until the next scaffold to be read is the scaffold referred to in the vcf file
inline void forwardGenomeToScaffold(const std::string& thisInVCF, std::ifstream*& genomeFile, std::string& nextInGenome) {
while (thisInVCF != nextInGenome) {
std::cerr << "Starting to read " << nextInGenome << std::endl;
std::cerr << "No variants in " << nextInGenome << std::endl;
std::string currentScaffoldReference = readScaffold(genomeFile, nextInGenome);
std::cerr << "Finished reading" << std::endl;
nextInGenome.erase(0,1);
}
}
#endif
| [
"millanek@gmail.com"
] | millanek@gmail.com |
adc16f6e5e3ef7c77b56f1d7c35631a64f4075a4 | 51e329979e832fe0d710b809b2c20adc23a15670 | /iocore/net/P_Connection.h | 6b1ce74ef13e703994ba937318771e3dff4df84d | [] | no_license | marlinprotocol/Petrum | 3a75d9ac35b2c649629c88ca2a7e3f87baab92a2 | 9d76d80f9f3a353c1fdc7cc7df279db2bf2031cb | refs/heads/master | 2022-12-24T06:57:10.775344 | 2020-07-14T17:18:16 | 2020-07-14T17:18:16 | 298,849,810 | 5 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 5,601 | h | /** @file
A brief file description
@section license License
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
/**************************************************************************
Connection.h
Description:
struct Connection
struct Server
struct ConnectionManager
struct ConnectionManager
========================
struct ConnectionManager provides the interface for network or disk
connections. There is a global ConnectionManager in the system
(connectionManager).
Connection * connect()
Connection * accept()
The accept call is a blocking call while connect is non-blocking. They
returns a new Connection instance which is an handle to the newly created
connection. The connection `q instance can be used later for read/writes
using an intance of IOProcessor class.
**************************************************************************/
#pragma once
#include "tscore/ink_platform.h"
struct NetVCOptions;
//
// Defines
//
#define NON_BLOCKING_CONNECT true
#define BLOCKING_CONNECT false
#define CONNECT_WITH_TCP true
#define CONNECT_WITH_UDP false
#define NON_BLOCKING true
#define BLOCKING false
#define BIND_RANDOM_PORT true
#define BIND_ANY_PORT false
#define ENABLE_MC_LOOPBACK true
#define DISABLE_MC_LOOPBACK false
#define BC_NO_CONNECT true
#define BC_CONNECT false
#define BC_NO_BIND true
#define BC_BIND false
///////////////////////////////////////////////////////////////////////
//
// Connection
//
///////////////////////////////////////////////////////////////////////
struct Connection {
SOCKET fd; ///< Socket for connection.
IpEndpoint addr; ///< Associated address.
bool is_bound; ///< Flag for already bound to a local address.
bool is_connected; ///< Flag for already connected.
int sock_type;
/** Create and initialize the socket for this connection.
A socket is created and the options specified by @a opt are
set. The socket is @b not connected.
@note It is important to pass the same @a opt to this method and
@c connect.
@return 0 on success, -ERRNO on failure.
@see connect
*/
int open(NetVCOptions const &opt = DEFAULT_OPTIONS ///< Socket options.
);
/** Connect the socket.
The socket is connected to the remote @a addr and @a port. The
@a opt structure is used to control blocking on the socket. All
other options are set via @c open. It is important to pass the
same @a opt to this method as was passed to @c open.
@return 0 on success, -ERRNO on failure.
@see open
*/
int connect(sockaddr const *to, ///< Remote address and port.
NetVCOptions const &opt = DEFAULT_OPTIONS ///< Socket options
);
/// Set the internal socket address struct.
void
setRemote(sockaddr const *remote_addr ///< Address and port.
)
{
ats_ip_copy(&addr, remote_addr);
}
int setup_mc_send(sockaddr const *mc_addr, sockaddr const *my_addr, bool non_blocking = NON_BLOCKING, unsigned char mc_ttl = 1,
bool mc_loopback = DISABLE_MC_LOOPBACK, Continuation *c = nullptr);
int setup_mc_receive(sockaddr const *from, sockaddr const *my_addr, bool non_blocking = NON_BLOCKING,
Connection *sendchan = nullptr, Continuation *c = nullptr);
int close(); // 0 on success, -errno on failure
void apply_options(NetVCOptions const &opt);
virtual ~Connection();
Connection();
Connection(Connection const &that) = delete;
/// Default options.
static NetVCOptions const DEFAULT_OPTIONS;
/**
* Move control of the socket from the argument object orig to the current object.
*/
void move(Connection &);
protected:
/** Assignment operator.
*
* @param that Source object.
* @return @a this
*
* This is protected because it is not safe in the general case, but is valid for
* certain subclasses. Those provide a public assignemnt that depends on this method.
*/
Connection &operator=(Connection const &that) = default;
void _cleanup();
};
///////////////////////////////////////////////////////////////////////
//
// Server
//
///////////////////////////////////////////////////////////////////////
struct Server : public Connection {
/// Client side (inbound) local IP address.
IpEndpoint accept_addr;
/// If set, a kernel HTTP accept filter
bool http_accept_filter;
int accept(Connection *c);
//
// Listen on a socket. We assume the port is in host by order, but
// that the IP address (specified by accept_addr) has already been
// converted into network byte order
//
int listen(bool non_blocking, const NetProcessor::AcceptOptions &opt);
int setup_fd_for_listen(bool non_blocking, const NetProcessor::AcceptOptions &opt);
Server() : Connection(), http_accept_filter(false) { ink_zero(accept_addr); }
};
| [
"cryptkit@marlin.pro"
] | cryptkit@marlin.pro |
ee05712c8c08d45da17026e70ee45e29bca968f9 | 14f0ed3b523c71ff783b2b077939cb8affd949db | /C/Main.cpp | ee53dcaab5938ef19ed7cc26dc440f9ce64a03d3 | [
"MIT"
] | permissive | AnasBrital98/Genetic-Algorithm-in-all-languages | 7b6528cdb6759a6446c32a0e6956ed591454c1cb | c04efa86d2ac1c31f6070488e94f2b8ce807151f | refs/heads/master | 2023-07-15T10:18:37.686818 | 2021-08-19T14:56:16 | 2021-08-19T14:56:16 | 391,142,662 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 192 | cpp | #include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include "GeneticAlgorithm.cpp"
int main(int argc , char** argv)
{
srand(time(NULL));
GeneticAlgorithm(200,50,0.1,15);
return 0;
} | [
"anass.brital98@gmail.com"
] | anass.brital98@gmail.com |
a6de200a8c3cb4bf104de06a3630b60000eed80a | 49ca052c08b6a6480337e2c0ca7963b12e44c0c1 | /experiments/metastring.cpp | 6353fa96811034383252f17843a3530702d04d8f | [
"BSD-2-Clause"
] | permissive | alzwded/ConstExprShenanigans | 177309dff5cd5cd98626df8d66167bb12db16701 | 64c642691e25eb3811491c256b0716ddae70ad3e | refs/heads/master | 2021-01-18T21:09:09.281278 | 2016-12-22T13:23:05 | 2016-12-22T13:23:05 | 53,246,611 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,398 | cpp | // THING ====================================================
#include <type_traits>
template<typename T>
struct ThingHelper
{
constexpr T value() const;
};
template<>
constexpr void ThingHelper<void>::value() const {}
template<typename T>
constexpr T ThingHelper<T>::value() const { return {}; }
template<char C, typename TAIL = void>
struct Thing
{
constexpr char head() const { return C; }
template<typename Y = TAIL>
constexpr Y tail() const
{
return ThingHelper<Y>().value();
}
typedef TAIL tail_t;
constexpr bool more() const { return std::is_void<TAIL>::value; }
};
// PRINTY ===================================================
#include <cstdio>
template<typename T>
struct printyHelper2
{
constexpr void continuee() const;
};
template<bool more> void printyHelper(char);
template<typename T, bool more = true>
void printy(T t)
{
printyHelper<t.more()>(t.head());
printyHelper2<typename T::tail_t>().continuee();
}
template<>
constexpr void printyHelper2<void>::continuee() const {}
template<typename T>
constexpr void printyHelper2<T>::continuee() const
{
T t;
printy<T, t.more()>(t);
}
template<>
void printyHelper<true>(char c)
{
printf("%c", c);
}
template<>
void printyHelper<false>(char c)
{
printf("%c\n", c);
}
int main()
{
Thing<'a', Thing<'b', Thing<'c'>>> thing;
printy(thing);
}
| [
"alzwded@gmail.com"
] | alzwded@gmail.com |
ee76ea3311b35e54a341196681938829d5515d0a | e98bce72249d4d00da6f76c221f97a6675420cfd | /video_receiver_helper.h | 8ff7a64624c6b59f4081f7f7adc357d7e4cde9b2 | [] | no_license | asdlei99/video_receiver_helper | 656756e4b6da262be537372f2f5929e1eb85cc8f | a7258a43fd4d4152550e003f9050124081bda371 | refs/heads/master | 2020-08-21T11:01:25.766701 | 2019-10-04T04:40:35 | 2019-10-04T04:40:35 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 670 | h | #ifndef _VIDEO_RECEIVER_HELPER_H___
#define _VIDEO_RECEIVER_HELPER_H___
#include <memory>
#include <string>
#include "video_receiver/video_track_receiver.h"
#include "rendering_server_client/rendering_server_client.h"
namespace webrtc {
class MediaStreamTrackInterface;
}
namespace grt {
//class video_track_receiver;
//class sender;
std::unique_ptr< video_track_receiver>
set_video_renderer(webrtc::MediaStreamTrackInterface*, std::shared_ptr<grt::sender> sender, std::string const& id);
void async_reset_video_renderer(std::shared_ptr<grt::sender> sender, std::string const& id);
}//namespace grt
#endif//_VIDEO_RECEIVER_HELPER_H___ | [
"aks.dce.007@gmail.com"
] | aks.dce.007@gmail.com |
2cd88367dc50d9ca777ee475c4de6d3c4b3123a0 | 99b97e802008e7e578f074e25c0a2f5b85cbd83e | /顺序栈.cpp | 70ba9f655d1457f873fa9f2a0157dfac2ed115e3 | [] | no_license | jx-66/jx | 2f57afbbaa6b2a5f9d7db90d70c77c9733edd63d | 5f51ac9194876d2b62a1afaaf17ef0350c187b90 | refs/heads/main | 2023-01-08T11:14:05.573062 | 2020-11-06T01:37:12 | 2020-11-06T01:37:12 | 309,133,479 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,421 | cpp | #include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
#define N 50
typedef char Elemtype;
typedef struct SqStack{
Elemtype *base; //栈底
Elemtype *top; //栈顶
int StackSize;
}SqStack;
//初始化栈
int InitStack(SqStack &s)
{
s.base=(Elemtype*)malloc(sizeof(Elemtype));
if(!s.base) return 0; //分配失败
s.top=s.base;
s.StackSize=N;
}
//销毁栈
int DestroyStack(SqStack &s)
{
}
//清空一个栈
void ClearStack(SqStack &s)
{
s.base=s.top;
}
//判断栈是否为空
bool StackEmpty(SqStack s)
{
if(s.base==s.top) return true;
else return false;
}
//栈中元素的个数
int StackLength(SqStack s)
{
return s.top-s.base;
}
//将元素压入栈
int Push(SqStack &s,Elemtype e)
{
if(s.top-s.base>=N) return 0;//栈已满
*(s.top)=e;
s.top++; //*(s.top++)=e;
return 1;
}
//删除栈顶元素
int Pop(SqStack &s,Elemtype &e)
{
if(s.top-s.base==0) return 0;//栈已为空
--s.top;
e=*(s.top);//e=*(--s.top);
return 1;
}
int main()
{
SqStack s;
InitStack(s);
cout<<"请输入5个元素：";
for(int i=0;i<5;i++)
{
char ch;
cin>>ch;
Elemtype tmp=ch;
Push(s,tmp);
}
cout<<"栈中元素个数："<<StackLength(s)<<endl;
cout<<"栈中元素：";
for(int i=0;i<4;i++)
{
Elemtype e;
Pop(s,e);
cout<<e;
}
cout<<endl;
cout<<"栈是否为空？"<<StackEmpty(s)<<endl;
ClearStack(s);
cout<<"栈是否为空？"<<StackEmpty(s)<<endl;
return 0;
} | [
"73505853+ZZZzzz175@users.noreply.github.com"
] | 73505853+ZZZzzz175@users.noreply.github.com |
7d9436213dc34d8b15abd0be4f24ee3602964c25 | 855dc81eb63aa2ce1463343580c078afc84e2934 | /src/graphnode.cpp | 43bd1ac54c4e08386d83bc546cf930c4be6a6cd4 | [] | no_license | tusharsangam/Cpp-Memory-Management-Chatbot | e398bbc8ac8756c861768eefd68359e1f0dd12a4 | d36d44d746b2018883663eb6c04fb09e4e6c4477 | refs/heads/master | 2021-04-21T23:00:24.428812 | 2020-03-24T21:43:32 | 2020-03-24T21:43:32 | 249,823,639 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,020 | cpp | #include "graphedge.h"
#include "graphnode.h"
GraphNode::GraphNode(int id)
{
_id = id;
}
GraphNode::~GraphNode()
{
//// STUDENT CODE
////
//delete _chatBot;
////
//// EOF STUDENT CODE
}
void GraphNode::AddToken(std::string token)
{
_answers.emplace_back(token);
}
void GraphNode::AddEdgeToParentNode(GraphEdge* edge)
{
_parentEdges.emplace_back(edge);
}
void GraphNode::AddEdgeToChildNode(std::unique_ptr<GraphEdge> edge)
{
_childEdges.emplace_back(std::move(edge));
}
//// STUDENT CODE
////
void GraphNode::MoveChatbotHere(ChatBot chatbot)
{
_chatBot = std::move(chatbot);
_chatBot.SetCurrentNode(this);
}
void GraphNode::MoveChatbotToNewNode(GraphNode *newNode)
{
newNode->MoveChatbotHere(std::move(_chatBot));
//_chatBot = nullptr; // invalidate pointer at source
}
////
//// EOF STUDENT CODE
GraphEdge *GraphNode::GetChildEdgeAtIndex(int index)
{
//// STUDENT CODE
////
return _childEdges[index].get();
////
//// EOF STUDENT CODE
} | [
"tusharsangam5@gmail.com"
] | tusharsangam5@gmail.com |
7d8f2b61eeb86db0da46d3d844508135c2a40504 | 1a2cd5cda7b9eace27d7fc9a0dd307960868c0ed | /alpha/MemoryList-inl.h | b16fd00e8aa4c7e91efef58e41c77588a3d3da6a | [] | no_license | jacobwpeng/alpha | bc045e82acb0a3e107b9a16a84c84ef32241b5b8 | 6e1258977f78970e6c49e8377dc92d82293299a6 | refs/heads/master | 2022-12-10T01:20:11.431867 | 2022-12-06T05:36:59 | 2022-12-06T05:36:59 | 28,303,729 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,062 | h | /*
* ==============================================================================
*
* Filename: MemoryList-inl.h
* Created: 05/17/15 23:32:21
* Author: Peng Wang
* Email: pw2191195@gmail.com
* Description:
*
* ==============================================================================
*/
#include <alpha/MemoryList.h>
#define MemoryListType \
MemoryList<T, \
typename std::enable_if<std::is_pod<T>::value && \
!std::is_pointer<T>::value>::type>
template <typename T>
std::unique_ptr<MemoryListType> MemoryListType::Create(char* buffer,
SizeType size) {
if (size < sizeof(Header)) {
return nullptr;
}
std::unique_ptr<MemoryListType> m(new MemoryListType);
m->header_ = reinterpret_cast<Header*>(buffer);
m->header_->magic = kMagic;
m->header_->size = 0;
m->header_->buffer_size = size;
m->header_->node_size = sizeof(T);
m->header_->free_list = kInvalidNodeId;
m->header_->free_area = (sizeof(Header) + sizeof(T) - 1) / sizeof(T);
m->buffer_ = buffer;
m->base_ = m->header_->free_area;
return std::move(m);
}
template <typename T>
std::unique_ptr<MemoryListType> MemoryListType::Restore(char* buffer,
SizeType size) {
if (size < sizeof(Header)) {
return nullptr;
}
auto header = reinterpret_cast<Header*>(buffer);
if (header->magic != kMagic || header->buffer_size < size ||
header->node_size != sizeof(T)) {
return nullptr;
}
auto header_slots = (sizeof(Header) + sizeof(T) - 1) / sizeof(T);
auto slots = size / sizeof(T);
if (header->free_list != kInvalidNodeId &&
(header->free_list < header_slots || header->free_list >= slots)) {
return nullptr;
}
if (header->free_area < header_slots || header->free_area > slots) {
return nullptr;
}
std::unique_ptr<MemoryListType> m(new MemoryListType);
m->header_ = header;
m->buffer_ = buffer;
m->base_ = header_slots;
return std::move(m);
}
template <typename T>
typename MemoryListType::NodeId MemoryListType::Allocate() {
NodeId result;
if (header_->free_list != kInvalidNodeId) {
result = header_->free_list;
header_->free_list = *NodeIdToNodeIdPtr(result);
} else {
CHECK(header_->free_area >= base_);
if (header_->free_area - base_ == max_size()) {
throw std::bad_alloc();
} else {
result = header_->free_area;
++header_->free_area;
}
}
++header_->size;
return result;
}
template <typename T>
void MemoryListType::Deallocate(NodeId id) {
*NodeIdToNodeIdPtr(id) = header_->free_list;
header_->free_list = id;
--header_->size;
}
template <typename T>
void MemoryListType::Clear() {
header_->size = 0;
header_->free_list = kInvalidNodeId;
header_->free_area = (sizeof(Header) + sizeof(T) - 1) / sizeof(T);
}
template <typename T>
T* MemoryListType::Get(NodeId id) {
return reinterpret_cast<T*>(NodeIdToAddress(id));
}
template <typename T>
const T* MemoryListType::Get(NodeId id) const {
return reinterpret_cast<T*>(NodeIdToAddress(id));
}
template <typename T>
bool MemoryListType::empty() const {
return header_->size == 0;
}
template <typename T>
typename MemoryListType::NodeId* MemoryListType::NodeIdToNodeIdPtr(NodeId id) {
assert(id != kInvalidNodeId);
return reinterpret_cast<NodeId*>(NodeIdToAddress(id));
}
template <typename T>
char* MemoryListType::NodeIdToAddress(NodeId id) {
assert(id != kInvalidNodeId);
return const_cast<char*>(buffer_) + id * sizeof(T);
}
template <typename T>
typename MemoryListType::SizeType MemoryListType::size() const {
return header_->size;
}
template <typename T>
typename MemoryListType::SizeType MemoryListType::max_size() const {
auto header_slots = (sizeof(Header) + sizeof(T) - 1) / sizeof(T);
return header_->buffer_size / sizeof(T) - header_slots;
}
#undef MemoryListType
| [
"pw2191195@gmail.com"
] | pw2191195@gmail.com |
5cebb2e50f42a8a307fe3695ee48e9f9347442fd | 8eea3d715692194bf09e3c19520ba3eb9254cb8f | /Advance_Bit.cpp | 73cac607250e15f796487ec1bb6cb4350d623855 | [] | no_license | ismail-ru-cse-39/Programming_Samsung_internship | 9971cb6c73407c8ff7bec6e266536812dd9a9110 | ba464785bc695972819f3ed1fd54adcf9c47ab87 | refs/heads/master | 2020-05-06T15:47:54.235235 | 2019-05-17T01:21:01 | 2019-05-17T01:21:01 | 180,208,766 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,519 | cpp | //Advance
//Bit
//solution
//solved
#include <stdio.h>
#define SZ 110
int N, M, K,Test_case;
int Ar_grid[SZ][SZ];
int Case;
int Ans = 0;
int Max(int a, int b)
{
if (a > b){
return a;
}
return b;
}
void take_input()
{
int i, j;
scanf("%d %d %d", &N, &M, &K);
for (i = 0; i < N; i++){
for (j = 0; j < M; j++){
scanf("%d", &Ar_grid[i][j]);
}
}
}
int cntzero(int i)
{
int j;
int cnt = 0;
for (j = 0; j < M; j++){
if (Ar_grid[i][j] == 0){
cnt++;
}
}
return cnt;
}
int isSame(int row1, int row2){
int j;
for (j = 0; j < M; j++){
if (Ar_grid[row1][j] != Ar_grid[row2][j]){
return 0;
}
}
return 1;
}
void solve_case()
{
int i;
int cnt_zero_1;
int cnt_zero_2;
int cnt = 0;
int flag = 0;
Ans = 0;
for (i = 0; i < N ; i++){
cnt_zero_1 = cntzero(i);
cnt = 0;
if (cnt_zero_1 == K || (K>= cnt_zero_1 &&(K-cnt_zero_1)%2 == 0)){
cnt = 1;
for (int j = i + 1; j < N; j++){
if (isSame(i, j)){
cnt++;
/*if (cnt > 0){
flag = 1;
}*/
}
}
Ans = Max(Ans, cnt);
}
}
/*if (flag > 0){
Ans++;
}*/
}
void print_case()
{
printf("#%d %d\n",Case, Ans);
}
int main()
{
//freopen("in.txt", "r", stdin);
freopen("in_bit.txt", "r", stdin);
freopen("out.txt", "w", stdout);
scanf("%d", &Test_case);
for (Case = 1; Case <= Test_case; Case++){
take_input();
solve_case();
print_case();
}
}
| [
"shaikat.ru.39@gmail.com"
] | shaikat.ru.39@gmail.com |
b841a09e819fe3dd9adfa744f7c2d86114fe7186 | e206517b0417f19f49b17e8e35f7fef9cd2e61c3 | /sources/dll/sources/Point.cpp | 236d3f78d3e66c119ed5eaef56e09d1b495e818b | [] | no_license | Bence886/LightFinder_GPU | 0beaaf89bc153183ad2a9b4753caa58e69bbd224 | 703c082a3f2ded319f2d81295a43a7f28c1640ee | refs/heads/master | 2021-04-06T00:27:01.254535 | 2018-05-10T15:35:53 | 2018-05-10T15:35:53 | 124,689,181 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,484 | cpp | #include "Point.h"
#include <sstream>
#include "math.h"
CUDA_CALLABLE_MEMBER Point::Point()
{
}
CUDA_CALLABLE_MEMBER Point::Point(float x, float y, float z) : X(x), Y(y), Z(z)
{
}
CUDA_CALLABLE_MEMBER Point::~Point()
{
}
CUDA_CALLABLE_MEMBER Point & Point::operator-(const Point &otherPoint) const
{
return Point(X - otherPoint.X, Y - otherPoint.Y, Z - otherPoint.Z);
}
CUDA_CALLABLE_MEMBER Point & Point::operator+(const Point &otherPoint) const
{
return Point(X + otherPoint.X, Y + otherPoint.Y, Z + otherPoint.Z);
}
CUDA_CALLABLE_MEMBER bool Point::operator==(const Point &otherPoint) const
{
return (X == otherPoint.X && Y == otherPoint.Y && Z == otherPoint.Z);
}
CUDA_CALLABLE_MEMBER Point & Point::operator=(const Point &otherPoint)
{
if (this == &otherPoint)
{
return *this;
}
X = otherPoint.X;
Y = otherPoint.Y;
Z = otherPoint.Z;
return *this;
}
CUDA_CALLABLE_MEMBER Point & Point::operator+=(const Point & otherPoint)
{
this->X += otherPoint.X;
this->Y += otherPoint.Y;
this->Z += otherPoint.Z;
return *this;
}
CUDA_CALLABLE_MEMBER void Point::MultiplyByLambda(float l)
{
X *= l;
Y *= l;
Z *= l;
}
CUDA_CALLABLE_MEMBER void Point::DevideByLambda(float l)
{
X /= l;
Y /= l;
Z /= l;
}
CUDA_CALLABLE_MEMBER void Point::Normalize()
{
float d = sqrt(X * X + Y * Y + Z * Z);
if (d != 0)
{
DevideByLambda(fabs(d));
}
}
CUDA_CALLABLE_MEMBER float Point::Length()
{
return Distance(Point(0, 0, 0), *this);
}
std::string Point::ToFile()
{
std::stringstream ss;
ss << "(" << X << ", " << Y << ", " << Z << ")";
return ss.str();
}
CUDA_CALLABLE_MEMBER Point Point::GetMidlePoint(const Point & p1, const Point & p2)
{
Point midle;
midle = p1 + p2;
midle.DevideByLambda(2);
return midle;
}
CUDA_CALLABLE_MEMBER float Point::DotProduct(const Point & p1, const Point & p2)
{
//http://www.lighthouse3d.com/tutorials/maths/inner-product/
return (p1.X * p2.X + p1.Y * p2.Y + p1.Z * p2.Z);
}
Point Point::CrossProduct(const Point & p1, const Point & p2)
{
//http://www.lighthouse3d.com/tutorials/maths/vector-cross-product/
Point p = Point(p1.Y * p2.Z - p1.Z * p2.Y, p1.Z * p2.X - p1.X * p2.Z, p1.X * p2.Y - p1.Y * p2.X);
return p;
}
CUDA_CALLABLE_MEMBER float Point::Distance(const Point & p1, const Point & p2)
{
return sqrt((p1.X - p2.X) * (p1.X - p2.X) + (p1.Y - p2.Y) * (p1.Y - p2.Y) + (p1.Z - p2.Z) * (p1.Z - p2.Z));
}
CUDA_CALLABLE_MEMBER bool Point::CompFloat(float f1, float f2, float e)
{
return fabs(f1 - f2) < e;
} | [
"tbencet96@gmail.com"
] | tbencet96@gmail.com |
249329a9471c85330b729a2612d5fc76704f483d | 8d1c1e1bbd0ca4ca290d181f92e6af48595de71a | /Project/Graphics.cpp | 80c7c0c64ddb34a1ce504f782856bfae6cb534c4 | [] | no_license | gapantiru/PankyGame | 2f4ceca22c715e4fc5df76d068451becfcc3fc8f | 43148af732ad5b6ff6b3da3c7e2f62e4bf106b71 | refs/heads/main | 2023-06-16T13:42:14.488012 | 2021-07-15T10:23:38 | 2021-07-15T10:23:38 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,013 | cpp | /* Graphic class
*
*/
#include "graphics.h"
#include "globals.h"
#include <SDL_image.h>
#include <SDL.h>
Graphics::Graphics() {
SDL_CreateWindowAndRenderer(globals::SCREEN_WIDTH, globals::SCREEN_HEIGHT, 0, &this->_window, &this->_renderer);
SDL_SetWindowTitle(this->_window, "Panky");
}
Graphics::~Graphics() {
SDL_DestroyWindow(this->_window);
SDL_DestroyRenderer(this->_renderer);
}
SDL_Surface* Graphics::loadImage(const std::string &filePath) {
if (this->_spriteSheets.count(filePath) == 0) {
this->_spriteSheets[filePath] = IMG_Load(filePath.c_str());
}
return this->_spriteSheets[filePath];
}
void Graphics::blitSurface(SDL_Texture* texture, SDL_Rect* sourceRectangle, SDL_Rect* destinationRectangle) {
SDL_RenderCopy( this->_renderer, texture, sourceRectangle, destinationRectangle);
}
void Graphics::flip() {
SDL_RenderPresent(this->_renderer);
}
void Graphics::clear() {
SDL_RenderClear(this->_renderer);
}
SDL_Renderer* Graphics::getRenderer() const {
return this->_renderer;
}
| [
"gapantiru@bitdefender.com"
] | gapantiru@bitdefender.com |
56d20517f1f7ad0f4c0ad4ceae7c232e8f8dc5d9 | 33d1314ced7b45381f819603e305f22b304fbd1f | /While/CalcularDobroNoIntervalo.cpp | 73cfc269da240dc537eb5f00893a3a3cb60548f0 | [] | no_license | LustosaJunior/Estrutura-de-Dados | b1320dca0b583434023d2ecbe47bc424f4f801ba | 0b77e0ad1720f9c56f9fbf6de4f874e7226ad1e5 | refs/heads/main | 2023-05-01T13:46:07.151391 | 2021-05-21T00:07:58 | 2021-05-21T00:07:58 | 358,425,742 | 0 | 0 | null | null | null | null | ISO-8859-1 | C++ | false | false | 579 | cpp | /* 62. Faça um programa que receba 10 números inteiros positivos quaisquer, calcule e mostre na tela o dobro dos valores pertencentes ao intervalo: 5< x <20. (do .. while e if)*/
#include<stdio.h>
#include<conio.h>
#include<locale.h>
int main() {
setlocale(LC_ALL, "Portuguese");
int number, x2, cont = 0;
do {
printf("Informe um número inteiro: ");
scanf("%i", &number);
if(number > 5 && number < 20){
x2 = number*2;
printf("O dobro do número %i é %i\n",number, x2);
}
cont++;
} while(cont < 10);
getch();
return 0;
}
| [
"junior_dj_decio@hotmail.com"
] | junior_dj_decio@hotmail.com |
2b70b048f3d349d2dff00d9e1dd79cc56ebe323b | b36a8c4495fd41c5a77fdf66a7875016f4d48880 | /Warmup 12 - Split String by Identical Character/Warmup 12 - Split String by Identical Character.cpp | 0a71977dc1dd1cc204e61172002c736bb5d74dc3 | [] | no_license | comi999/Warmup-Exercises | 651b0dc010f188154ea9b850cd5135d4bf5e380d | dcfc56a5117eac689fca07347febfa08596a9f8c | refs/heads/master | 2022-11-25T06:10:51.407215 | 2020-08-07T02:34:24 | 2020-08-07T02:34:24 | 273,102,767 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,439 | cpp | #include <iostream>
#include <vector>
std::vector<std::string> splitGroups(std::string s)
{
std::vector<std::string> result;
char count = 0, current;
for (int i = 0; i < s.size(); i++)
{
current = s[i];
while (current == *(&s[i] + count) && s[i] != '\0') count++;
result.push_back(s.substr(i, count));
i += -1 + count; count = 0;
}
return result;
}
int main()
{
std::string a = "555";
std::string b = "5556667788";
std::string c = "aaabbbaabbab";
std::string d = "abbbcc88999&&!!!_";
std::cout << a << ":" << std::endl;
std::vector<std::string> resulta = splitGroups(a);
for (int i = 0; i < resulta.size(); i++)
std::cout << resulta[i] << std::endl;
std::cout << std::endl;
std::cout << b << ":" << std::endl;
std::vector<std::string> resultb = splitGroups(b);
for (int i = 0; i < resultb.size(); i++)
std::cout << resultb[i] << std::endl;
std::cout << std::endl;
std::cout << c << ":" << std::endl;
std::vector<std::string> resultc = splitGroups(c);
for (int i = 0; i < resultc.size(); i++)
std::cout << resultc[i] << std::endl;
std::cout << std::endl;
std::cout << d << ":" << std::endl;
std::vector<std::string> resultd = splitGroups(d);
for (int i = 0; i < resultd.size(); i++)
std::cout << resultd[i] << std::endl;
std::cout << std::endl;
while (1);
} | [
"glizzyzbro@hotmail.com"
] | glizzyzbro@hotmail.com |
5584740a7a4bb46f93106431f14aaf3ac21cc530 | 48e8d00debd2be1bbbfebd48de6e03c090a16649 | /cdb/include/tencentcloud/cdb/v20170320/model/Inbound.h | 2e288b98f8bf77a87c9dbe3545e16832358decdb | [
"Apache-2.0"
] | permissive | xuliangyu1991/tencentcloud-sdk-cpp | b3ef802c0aa5010e5af42d68de84080697f717d5 | f4b057e66ddb1e8761df2152f1faaa10870cc5c7 | refs/heads/master | 2020-06-19T03:24:04.286285 | 2019-06-20T07:04:49 | 2019-06-20T07:04:49 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,124 | h | /*
* Copyright (c) 2017-2019 THL A29 Limited, a Tencent company. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef TENCENTCLOUD_CDB_V20170320_MODEL_INBOUND_H_
#define TENCENTCLOUD_CDB_V20170320_MODEL_INBOUND_H_
#include <string>
#include <vector>
#include <map>
#include <tencentcloud/core/utils/rapidjson/document.h>
#include <tencentcloud/core/utils/rapidjson/writer.h>
#include <tencentcloud/core/utils/rapidjson/stringbuffer.h>
#include <tencentcloud/core/AbstractModel.h>
namespace TencentCloud
{
namespace Cdb
{
namespace V20170320
{
namespace Model
{
/**
* 安全组入站规则
*/
class Inbound : public AbstractModel
{
public:
Inbound();
~Inbound() = default;
void ToJsonObject(rapidjson::Value &value, rapidjson::Document::AllocatorType& allocator) const;
CoreInternalOutcome Deserialize(const rapidjson::Value &value);
/**
* 获取策略，ACCEPT或者DROP
* @return Action 策略，ACCEPT或者DROP
*/
std::string GetAction() const;
/**
* 设置策略，ACCEPT或者DROP
* @param Action 策略，ACCEPT或者DROP
*/
void SetAction(const std::string& _action);
/**
* 判断参数 Action 是否已赋值
* @return Action 是否已赋值
*/
bool ActionHasBeenSet() const;
/**
* 获取来源Ip或Ip段，例如192.168.0.0/16
* @return CidrIp 来源Ip或Ip段，例如192.168.0.0/16
*/
std::string GetCidrIp() const;
/**
* 设置来源Ip或Ip段，例如192.168.0.0/16
* @param CidrIp 来源Ip或Ip段，例如192.168.0.0/16
*/
void SetCidrIp(const std::string& _cidrIp);
/**
* 判断参数 CidrIp 是否已赋值
* @return CidrIp 是否已赋值
*/
bool CidrIpHasBeenSet() const;
/**
* 获取端口
* @return PortRange 端口
*/
std::string GetPortRange() const;
/**
* 设置端口
* @param PortRange 端口
*/
void SetPortRange(const std::string& _portRange);
/**
* 判断参数 PortRange 是否已赋值
* @return PortRange 是否已赋值
*/
bool PortRangeHasBeenSet() const;
/**
* 获取网络协议，支持udp、tcp等
* @return IpProtocol 网络协议，支持udp、tcp等
*/
std::string GetIpProtocol() const;
/**
* 设置网络协议，支持udp、tcp等
* @param IpProtocol 网络协议，支持udp、tcp等
*/
void SetIpProtocol(const std::string& _ipProtocol);
/**
* 判断参数 IpProtocol 是否已赋值
* @return IpProtocol 是否已赋值
*/
bool IpProtocolHasBeenSet() const;
/**
* 获取规则限定的方向，进站规则为INPUT
* @return Dir 规则限定的方向，进站规则为INPUT
*/
std::string GetDir() const;
/**
* 设置规则限定的方向，进站规则为INPUT
* @param Dir 规则限定的方向，进站规则为INPUT
*/
void SetDir(const std::string& _dir);
/**
* 判断参数 Dir 是否已赋值
* @return Dir 是否已赋值
*/
bool DirHasBeenSet() const;
private:
/**
* 策略，ACCEPT或者DROP
*/
std::string m_action;
bool m_actionHasBeenSet;
/**
* 来源Ip或Ip段，例如192.168.0.0/16
*/
std::string m_cidrIp;
bool m_cidrIpHasBeenSet;
/**
* 端口
*/
std::string m_portRange;
bool m_portRangeHasBeenSet;
/**
* 网络协议，支持udp、tcp等
*/
std::string m_ipProtocol;
bool m_ipProtocolHasBeenSet;
/**
* 规则限定的方向，进站规则为INPUT
*/
std::string m_dir;
bool m_dirHasBeenSet;
};
}
}
}
}
#endif // !TENCENTCLOUD_CDB_V20170320_MODEL_INBOUND_H_
| [
"jimmyzhuang@tencent.com"
] | jimmyzhuang@tencent.com |
da19680b2d33df94a91ed530baead95299dda7a7 | 85e7114ea63a080c1b9b0579e66c7a2d126cffec | /SDK/SoT_BP_CustomisableLadder_functions.cpp | de4db1fd5ab35589671a2fc15957a2e9a6e3504e | [] | no_license | EO-Zanzo/SeaOfThieves-Hack | 97094307d943c2b8e2af071ba777a000cf1369c2 | d8e2a77b1553154e1d911a3e0c4e68ff1c02ee51 | refs/heads/master | 2020-04-02T14:18:24.844616 | 2018-10-24T15:02:43 | 2018-10-24T15:02:43 | 154,519,316 | 0 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 7,032 | cpp | // Sea of Thieves (1.2.6) SDK
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
#include "SoT_BP_CustomisableLadder_parameters.hpp"
namespace SDK
{
//---------------------------------------------------------------------------
//Functions
//---------------------------------------------------------------------------
// Function BP_CustomisableLadder.BP_CustomisableLadder_C.GetDockableInfo
// (Event, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FDockableInfo ReturnValue (Parm, OutParm, ReturnParm)
struct FDockableInfo ABP_CustomisableLadder_C::GetDockableInfo()
{
static auto fn = UObject::FindObject<UFunction>("Function BP_CustomisableLadder.BP_CustomisableLadder_C.GetDockableInfo");
ABP_CustomisableLadder_C_GetDockableInfo_Params params;
UObject::ProcessEvent(fn, ¶ms);
return params.ReturnValue;
}
// Function BP_CustomisableLadder.BP_CustomisableLadder_C.Construct Ladder
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
void ABP_CustomisableLadder_C::Construct_Ladder()
{
static auto fn = UObject::FindObject<UFunction>("Function BP_CustomisableLadder.BP_CustomisableLadder_C.Construct Ladder");
ABP_CustomisableLadder_C_Construct_Ladder_Params params;
UObject::ProcessEvent(fn, ¶ms);
}
// Function BP_CustomisableLadder.BP_CustomisableLadder_C.Get Total Height Before Cap
// (Public, HasOutParms, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// float Height (Parm, OutParm, ZeroConstructor, IsPlainOldData)
void ABP_CustomisableLadder_C::Get_Total_Height_Before_Cap(float* Height)
{
static auto fn = UObject::FindObject<UFunction>("Function BP_CustomisableLadder.BP_CustomisableLadder_C.Get Total Height Before Cap");
ABP_CustomisableLadder_C_Get_Total_Height_Before_Cap_Params params;
UObject::ProcessEvent(fn, ¶ms);
if (Height != nullptr)
*Height = params.Height;
}
// Function BP_CustomisableLadder.BP_CustomisableLadder_C.Get Steps
// (Public, HasOutParms, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// int Num_Steps (Parm, OutParm, ZeroConstructor, IsPlainOldData)
void ABP_CustomisableLadder_C::Get_Steps(int* Num_Steps)
{
static auto fn = UObject::FindObject<UFunction>("Function BP_CustomisableLadder.BP_CustomisableLadder_C.Get Steps");
ABP_CustomisableLadder_C_Get_Steps_Params params;
UObject::ProcessEvent(fn, ¶ms);
if (Num_Steps != nullptr)
*Num_Steps = params.Num_Steps;
}
// Function BP_CustomisableLadder.BP_CustomisableLadder_C.GetBottomLadderRungTransform
// (Event, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
struct FTransform ABP_CustomisableLadder_C::GetBottomLadderRungTransform()
{
static auto fn = UObject::FindObject<UFunction>("Function BP_CustomisableLadder.BP_CustomisableLadder_C.GetBottomLadderRungTransform");
ABP_CustomisableLadder_C_GetBottomLadderRungTransform_Params params;
UObject::ProcessEvent(fn, ¶ms);
return params.ReturnValue;
}
// Function BP_CustomisableLadder.BP_CustomisableLadder_C.GetTopLadderRungTransform
// (Event, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
struct FTransform ABP_CustomisableLadder_C::GetTopLadderRungTransform()
{
static auto fn = UObject::FindObject<UFunction>("Function BP_CustomisableLadder.BP_CustomisableLadder_C.GetTopLadderRungTransform");
ABP_CustomisableLadder_C_GetTopLadderRungTransform_Params params;
UObject::ProcessEvent(fn, ¶ms);
return params.ReturnValue;
}
// Function BP_CustomisableLadder.BP_CustomisableLadder_C.Get World Loc at Height Along Z
// (Public, HasOutParms, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// float Relative_Z (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector Return_Value (Parm, OutParm, ZeroConstructor, IsPlainOldData)
void ABP_CustomisableLadder_C::Get_World_Loc_at_Height_Along_Z(float Relative_Z, struct FVector* Return_Value)
{
static auto fn = UObject::FindObject<UFunction>("Function BP_CustomisableLadder.BP_CustomisableLadder_C.Get World Loc at Height Along Z");
ABP_CustomisableLadder_C_Get_World_Loc_at_Height_Along_Z_Params params;
params.Relative_Z = Relative_Z;
UObject::ProcessEvent(fn, ¶ms);
if (Return_Value != nullptr)
*Return_Value = params.Return_Value;
}
// Function BP_CustomisableLadder.BP_CustomisableLadder_C.SetupSpline
// (Public, HasOutParms, BlueprintCallable, BlueprintEvent)
// Parameters:
// class USplineComponent* Spline_Component (Parm, ZeroConstructor, IsPlainOldData)
// TArray<struct FVector> Positions (Parm, OutParm, ZeroConstructor, ReferenceParm)
void ABP_CustomisableLadder_C::SetupSpline(class USplineComponent* Spline_Component, TArray<struct FVector>* Positions)
{
static auto fn = UObject::FindObject<UFunction>("Function BP_CustomisableLadder.BP_CustomisableLadder_C.SetupSpline");
ABP_CustomisableLadder_C_SetupSpline_Params params;
params.Spline_Component = Spline_Component;
UObject::ProcessEvent(fn, ¶ms);
if (Positions != nullptr)
*Positions = params.Positions;
}
// Function BP_CustomisableLadder.BP_CustomisableLadder_C.UserConstructionScript
// (Event, Public, BlueprintCallable, BlueprintEvent)
void ABP_CustomisableLadder_C::UserConstructionScript()
{
static auto fn = UObject::FindObject<UFunction>("Function BP_CustomisableLadder.BP_CustomisableLadder_C.UserConstructionScript");
ABP_CustomisableLadder_C_UserConstructionScript_Params params;
UObject::ProcessEvent(fn, ¶ms);
}
// Function BP_CustomisableLadder.BP_CustomisableLadder_C.ReceiveBeginPlay
// (Event, Public, BlueprintEvent)
void ABP_CustomisableLadder_C::ReceiveBeginPlay()
{
static auto fn = UObject::FindObject<UFunction>("Function BP_CustomisableLadder.BP_CustomisableLadder_C.ReceiveBeginPlay");
ABP_CustomisableLadder_C_ReceiveBeginPlay_Params params;
UObject::ProcessEvent(fn, ¶ms);
}
// Function BP_CustomisableLadder.BP_CustomisableLadder_C.ExecuteUbergraph_BP_CustomisableLadder
// ()
// Parameters:
// int EntryPoint (Parm, ZeroConstructor, IsPlainOldData)
void ABP_CustomisableLadder_C::ExecuteUbergraph_BP_CustomisableLadder(int EntryPoint)
{
static auto fn = UObject::FindObject<UFunction>("Function BP_CustomisableLadder.BP_CustomisableLadder_C.ExecuteUbergraph_BP_CustomisableLadder");
ABP_CustomisableLadder_C_ExecuteUbergraph_BP_CustomisableLadder_Params params;
params.EntryPoint = EntryPoint;
UObject::ProcessEvent(fn, ¶ms);
}
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"zp2kshield@gmail.com"
] | zp2kshield@gmail.com |
928598a20abbf1d4a85cd2aafd2a70c8f3ebb2c3 | 36357bbe859f79d48f9313442ccb39e78f25b347 | /modules/drivers/radar/rocket_radar/driver/system-radar-software/engine/scp-src/eng-api/uhmath.h | 55558e486cda46d6842fbbe201dea29eb5ecd386 | [
"Apache-2.0"
] | permissive | MaxLin86/apollo | 75c8a94d90daa14759c0bb0eae3085638bb9b6b5 | fae1adf277c8d2b75e42119c5d52cbd1c6fb95c7 | refs/heads/main | 2023-03-28T18:22:36.161004 | 2021-03-08T07:53:25 | 2021-03-08T07:53:25 | 345,560,672 | 1 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 6,779 | h | #ifndef SRS_HDR_UHMATH_H
#define SRS_HDR_UHMATH_H 1
// START_SOFTWARE_LICENSE_NOTICE
// -------------------------------------------------------------------------------------------------------------------
// Copyright (C) 2016-2019 Uhnder, Inc. All rights reserved.
// This Software is the property of Uhnder, Inc. (Uhnder) and is Proprietary and Confidential. It has been provided
// under license for solely use in evaluating and/or developing code for Uhnder products. Any use of the Software to
// develop code for a product not manufactured by or for Uhnder is prohibited. Unauthorized use of this Software is
// strictly prohibited.
// Restricted Rights Legend: Use, Duplication, or Disclosure by the Government is Subject to Restrictions as Set
// Forth in Paragraph (c)(1)(ii) of the Rights in Technical Data and Computer Software Clause at DFARS 252.227-7013.
// THIS PROGRAM IS PROVIDED UNDER THE TERMS OF THE UHNDER END-USER LICENSE AGREEMENT (EULA). THE PROGRAM MAY ONLY
// BE USED IN A MANNER EXPLICITLY SPECIFIED IN THE EULA, WHICH INCLUDES LIMITATIONS ON COPYING, MODIFYING,
// REDISTRIBUTION AND WARRANTIES. PROVIDING AFFIRMATIVE CLICK-THROUGH CONSENT TO THE EULA IS A REQUIRED PRECONDITION
// TO YOUR USE OF THE PROGRAM. YOU MAY OBTAIN A COPY OF THE EULA FROM WWW.UHNDER.COM. UNAUTHORIZED USE OF THIS
// PROGRAM IS STRICTLY PROHIBITED.
// THIS SOFTWARE IS PROVIDED "AS IS". NO WARRANTIES ARE GIVEN, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING
// WARRANTIES OR MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE. RECIPIENT SHALL HAVE
// THE SOLE RESPONSIBILITY FOR THE ADEQUATE PROTECTION AND BACK-UP OF ITS DATA USED IN CONNECTION WITH THIS SOFTWARE.
// IN NO EVENT WILL UHNDER BE LIABLE FOR ANY CONSEQUENTIAL DAMAGES WHATSOEVER, INCLUDING LOSS OF DATA OR USE, LOST
// PROFITS OR ANY INCIDENTAL OR SPECIAL DAMAGES, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
// SOFTWARE, WHETHER IN ACTION OF CONTRACT OR TORT, INCLUDING NEGLIGENCE. UHNDER FURTHER DISCLAIMS ANY LIABILITY
// WHATSOEVER FOR INFRINGEMENT OF ANY INTELLECTUAL PROPERTY RIGHTS OF ANY THIRD PARTY.
// -------------------------------------------------------------------------------------------------------------------
// END_SOFTWARE_LICENSE_NOTICE
#include "modules/drivers/radar/rocket_radar/driver/system-radar-software/env-uhnder/coredefs/uhnder-common.h"
#include "modules/drivers/radar/rocket_radar/driver/system-radar-software/engine/common/eng-api/uhtypes.h"
#include "modules/drivers/radar/rocket_radar/driver/system-radar-software/env-uhnder/coredefs/uhmathtypes.h"
SRS_DECLARE_NAMESPACE()
static UHINLINE void fmaxabs(FLOAT* max, FLOAT val)
{
FLOAT aval = uh_fabsf(val);
if (aval > *max)
{
*max = aval;
}
}
static UHINLINE uint32_t uh_uintmin(uint32_t val_a, uint32_t val_b)
{
if (val_a < val_b)
{
return val_a;
}
else
{
return val_b;
}
}
static UHINLINE uint32_t uh_uintmax(uint32_t val_a, uint32_t val_b)
{
if (val_a > val_b)
{
return val_a;
}
else
{
return val_b;
}
}
static UHINLINE FLOAT deg2rad(FLOAT a) { return a * M_PI / 180.0F; }
static UHINLINE FLOAT rad2deg(FLOAT a) { return a / M_PI * 180.0F; }
static UHINLINE FLOAT db2mag(FLOAT db) { return powf(10.0F, db * 0.05F); } // use * 0.05 instead of / 20.0 for speed
static UHINLINE FLOAT mag2db(FLOAT f) { return 20.0F * log10f(f); }
static UHINLINE FLOAT rfa_to_db(FLOAT rfa, size_t num_cells) { return mag2db(uh_sqrtf(-2 * logf(float(double(rfa) / num_cells)))); }
static UHINLINE int32_t uh_lroundf(FLOAT f)
{
return (f < 0) ? (-(int32_t)(-(f) + 0.5F)) : ((int32_t)((f) + 0.5F));
}
static UHINLINE uint16_t f2qu16(FLOAT f, INT frac_bit)
{
FLOAT v = f * (1 << frac_bit) + 0.5F;
return (uint16_t)(v < 0.0F ? 0 : v > 65535.0F ? 65535.0F : v);
}
static UHINLINE int16_t f2q16(FLOAT f, INT frac_bit)
{
FLOAT round = f < 0 ? -0.5F : 0.5F;
FLOAT v = f * (1 << frac_bit) + round;
return (int16_t)(v < -32768.0F ? -32768.0F : v > 32767.0F ? 32767.0F : v);
}
static UHINLINE uint32_t f2qu32(FLOAT f, INT frac_bit)
{
FLOAT v = f * (1 << frac_bit) + 0.5F;
return (uint32_t)(v < 0.0F ? 0.0F : v > 4294967295.0F ? 4294967295.0F : v);
}
static UHINLINE int32_t f2q32(FLOAT f, INT frac_bit)
{
FLOAT round = f < 0 ? -0.5F : 0.5F;
FLOAT v = f * (1 << frac_bit) + round;
return (int32_t)(v < -2147483648.0F ? -2147483648.0F : v > 2147483647.0F ? 2147483647.0F : v);
}
template <class T> static UHINLINE FLOAT q2f(T v, INT frac_bit)
{
return (FLOAT)v / (1 << frac_bit);
}
static UHINLINE bool linear_interpolate_array( // Returns: true upon success, false upon failure (x not in valid range)
FLOAT &y_interp, // Output: Interpolated Y value, if successful, else zero
FLOAT x, // Input: Fractional X index into Y vector ( 0 <= x <= y_len-1 )
FLOAT *y, // Input: Y vector
int32_t y_len) // Input: Number of entries in Y vector
{
y_interp = 0.0F;
if ((x < 0.0F) || (x > ((FLOAT)y_len - 1.0F)))
{
return false;
}
FLOAT x1 = uh_floorf(x);
int32_t x1_int = (int32_t)x1;
if ((x1_int < 0) || (x1_int > (y_len - 1)))
{
return false;
}
FLOAT frac = x - x1;
FLOAT y1 = y[x1_int];
if (x1_int == (y_len - 1))
{
y_interp = y1;
return true;
}
FLOAT y2 = y[x1_int + 1];
y_interp = y1 + (frac * (y2 - y1));
return true;
}
static UHINLINE void quadratic_interpolate(FLOAT &y, FLOAT &x, FLOAT yl, FLOAT yc, FLOAT yu)
{
if ((yl > yc) && (yl > yu))
{
y = yl;
x = -1.0F;
return;
}
if (yu > yc)
{
y = yu;
x = 1.0F;
return;
}
// X coordinates
FLOAT xl = -1.0F;
FLOAT xc = 0.0F;
FLOAT xu = 1.0F;
// Quadratic interpolation
FLOAT yucxuc = (yu - yc) / (xu - xc);
FLOAT d2 = (yucxuc - (yl - yc) / (xl - xc)) * 2.0F / (xu - xl);
FLOAT d1 = yucxuc - (d2 * (xu - xc) * 0.5F);
if (d2 == 0.0F)
{
x = xc;
y = yc;
}
else
{
x = xc - (d1 / d2);
y = yc + (d1 * ((x - xc) * 0.5F));
}
}
static UHINLINE void quadratic_interpolate_db(cfloat &y, FLOAT &x, cfloat a, cfloat b, cfloat c)
{
// Values in db
FLOAT yl = mag2db(a.abs());
FLOAT yc = mag2db(b.abs());
FLOAT yu = mag2db(c.abs());
FLOAT y1;
quadratic_interpolate(y1, x, yl, yc, yu);
y = db2mag(y1);
}
SRS_CLOSE_NAMESPACE()
#endif // SRS_HDR_UHMATH_H
| [
"maxlin86@foxmail.com"
] | maxlin86@foxmail.com |
43006a72f6fc26439daaf67d775b61b77a0d8fa9 | e12e16efbe58992d5dfe5e81544ee64c61f1f8e0 | /integration_tests/source/3-offsets.cpp | abc311de2054d22794c2b3d1e2e535a48ea44fd6 | [] | no_license | tbennun/dawn2dace | 1da9c2d4251d8b7d8e6b9225fc059c47bea7080d | a0d427b1d3d741a7a97dbc1cd9088b781a8d0a13 | refs/heads/master | 2020-05-20T05:58:43.086563 | 2019-08-21T12:29:10 | 2019-08-21T12:29:10 | 185,419,592 | 0 | 0 | null | 2019-05-07T14:33:38 | 2019-05-07T14:33:38 | null | UTF-8 | C++ | false | false | 219 | cpp | #include "gridtools/clang_dsl.hpp"
using namespace gridtools::clang;
stencil test {
storage a, b;
Do {
vertical_region(k_start, k_end) {
// copy stencil
a = b[i + 1, j - 1] + b[i - 1];
}
}
}; | [
"twicki@ethz.ch"
] | twicki@ethz.ch |
73cb7c00de9e4d7e037969d6cb13ffe074e0e835 | 48bbc4386f073e3f9b2f9a6aae16cd3551ae0f0f | /trunk/src/AL/ConfigManager.cpp | 5a88f1affcbe8126d7c944d508b1e286ecc809ce | [] | no_license | JackyPyb/RAS | 98d042b3e75d395170ecec8b9c245123a2f6327e | 9378268a4e7d8737af0e0f60b52241d151cba53a | refs/heads/master | 2020-04-30T10:31:54.816025 | 2015-03-27T08:10:57 | 2015-03-27T08:10:57 | 32,208,596 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,466 | cpp | #include "ConfigManager.h"
#include "common/xml/XMLConfig.h"
#include "common/util/util.h"
using util::conv::conv;
ConfigManager::ConfigManager():
m_connectIP(""),
m_connectPort(0),
m_frameworkID(0),
m_imageLable(""),
m_moduleName(""),
m_locationFilePath(""),
m_ncIP(""),
m_cpuNum(0.0),
m_cpuMemSize(0),
m_listenNum(0)
{
}
ConfigManager::~ConfigManager()
{
}
int ConfigManager::configWithXML(const char *configFileName)
{
XMLConfig *pXML = new XMLConfig(configFileName);
string connectIP, connectPort, frameworkID, imageLable,
moduleName, locationFilePath, ncIP, cpuNum,
cpuMemSize, listenNum;
int ret;
//connectIP
ret = pXML->getFirstNodeValue("/CONFIG/CONNECT_IP", connectIP);
if(ret < 0)
{
delete pXML;
return ret;
}
m_connectIP = connectIP;
//connectPort
ret = pXML->getFirstNodeValue("/CONFIG/CONNECT_PORT", connectPort);
if(ret < 0)
{
delete pXML;
return ret;
}
m_connectPort = conv<unsigned short, string>(connectPort);
//frameworkID
ret = pXML->getFirstNodeValue("/CONFIG/FRAMEWORK_ID", frameworkID);
if(ret < 0)
{
delete pXML;
return ret;
}
m_frameworkID = conv<uint32_t, string>(frameworkID);
//imageLable
ret = pXML->getFirstNodeValue("/CONFIG/IMAGE_LABLE", imageLable);
if(ret < 0)
{
delete pXML;
return ret;
}
m_imageLable = imageLable;
//moduleName
ret = pXML->getFirstNodeValue("/CONFIG/MODULE_NAME", moduleName);
if(ret < 0)
{
delete pXML;
return ret;
}
m_moduleName = moduleName;
//locationFilePath
ret = pXML->getFirstNodeValue("/CONFIG/LOCATION_FILE_PATH",
locationFilePath);
if(ret < 0)
{
delete pXML;
return ret;
}
m_locationFilePath = locationFilePath;
//ncIP
ret = pXML->getFirstNodeValue("/CONFIG/NC_IP", ncIP);
if(ret < 0)
{
delete pXML;
return ret;
}
m_ncIP = ncIP;
//cpuNum
ret = pXML->getFirstNodeValue("/CONFIG/CPU_NUM", cpuNum);
if(ret < 0)
{
delete pXML;
return ret;
}
m_cpuNum = conv<double, string>(cpuNum);
//cpuMemSize
ret = pXML->getFirstNodeValue("/CONFIG/CPU_MEM_SIZE", cpuMemSize);
if(ret < 0)
{
delete pXML;
return ret;
}
m_cpuMemSize = conv<uint32_t, string>(cpuMemSize);
//listenNum
ret = pXML->getFirstNodeValue("/CONFIG/LISTEN_NUM", listenNum);
if(ret < 0)
{
delete pXML;
return ret;
}
m_listenNum = conv<uint32_t, string>(listenNum);
delete pXML;
return ret;
}
string ConfigManager::getConnectIP() const
{
return m_connectIP;
}
unsigned short ConfigManager::getConnectPort() const
{
return m_connectPort;
}
uint32_t ConfigManager::getFrameworkID() const
{
return m_frameworkID;
}
string ConfigManager::getImageLable() const
{
return m_imageLable;
}
string ConfigManager::getModuleName() const
{
return m_moduleName;
}
string ConfigManager::getLocationFilePath() const
{
return m_locationFilePath;
}
string ConfigManager::getNCIP() const
{
return m_ncIP;
}
double ConfigManager::getCPUNum() const
{
return m_cpuNum;
}
uint32_t ConfigManager::getCPUMemSize() const
{
return m_cpuMemSize;
}
uint32_t ConfigManager::getListenNum() const
{
return m_listenNum;
}
| [
"641186889@qq.com"
] | 641186889@qq.com |
44c790f88a81bfc27eaa7f9b817da1c7a8794d5c | ac140a854c180f0c6c0ff0f35518c18e32a43758 | /ModernCpp/SubParagraph_5_6_3.cpp | 2ec81b2b8f14dcc833e0d0944b1ec55dbbea5a27 | [] | no_license | klasing/MnistExample | 53bd4e6316b513889acd77a5549082863c643435 | 720479f6768c15fa6e63fafd415b5a2bcff3dfa9 | refs/heads/master | 2020-04-22T00:29:18.102857 | 2019-06-30T18:41:17 | 2019-06-30T18:41:17 | 169,981,063 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 128 | cpp | #include "pch.h"
inline void subParagraph_5_6_3() {
cout << "Spacing and Tabs" << endl;
cout << "----------------" << endl;
} | [
"klasing1959@gmail.com"
] | klasing1959@gmail.com |
cbb20a6ad1842e297982a55d68a7c824e4b12fec | abb5f5cec0d009fabbf72734254cac5a0a4b3a9c | /DiscreteRods/ThreadConstrained.h | f2412db4ab9c2bb48875bd0705e5102e68d116fc | [] | no_license | alexlee-gk/surgical | 692ebc6295002ea44cdb86bc846730c446a48784 | 9c4739100aaa612aa2fb476515e651666533b3df | refs/heads/master | 2021-01-16T22:49:43.863602 | 2011-10-17T09:20:09 | 2011-10-17T09:20:09 | 1,873,553 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,550 | h | #include <stdlib.h>
#include <algorithm>
#ifdef MAC
#include <OpenGL/gl.h>
#include <GLUT/glut.h>
#include <GL/gle.h>
#else
#include <GL/gl.h>
#include <GL/glut.h>
#include <GL/gle.h>
#endif
#include <iostream>
#include <fstream>
#include <Eigen/Core>
#include <Eigen/Geometry>
#include <math.h>
#include "thread_discrete.h"
#define LIMITED_DISPLACEMENT true
#define MAX_DISPLACEMENT 1 //(0.49*THREAD_RADIUS)
#define MAX_ANGLE_CHANGE (0.05*M_PI)
// import most common Eigen types
USING_PART_OF_NAMESPACE_EIGEN
class ThreadConstrained {
public:
ThreadConstrained(int vertices_num);
int numVertices() { return num_vertices; }
const double rest_length() const { return threads.front()->rest_length(); }
void get_thread_data(vector<Vector3d> &absolute_points);
void get_thread_data(vector<Vector3d> &absolute_points, vector<double> &absolute_twist_angles);
void get_thread_data(vector<Vector3d> &absolute_points, vector<double> &absolute_twist_angles, vector<Matrix3d> &absolute_material_frames);
void get_thread_data(vector<Vector3d> &absolute_points, vector<Matrix3d> &absolute_material_frames);
// parameters have to be of the right size, i.e. threads.size()+1
void getConstrainedTransforms(vector<Vector3d> &positions, vector<Matrix3d> &rotations);
void setConstrainedTransforms(vector<Vector3d> positions, vector<Matrix3d> rotations);
void getAllTransforms(vector<Vector3d> &positions, vector<Matrix3d> &rotations);
void setAllTransforms(vector<Vector3d> positions, vector<Matrix3d> rotations);
// parameters have to be of the right size.
void getConstrainedNormals(vector<Vector3d> &normals);
void getConstrainedVerticesNums(vector<int> &vertices_num);
void getConstrainedVertices(vector<Vector3d> &constrained_vertices);
void getFreeVerticesNums(vector<int> &vertices_nums);
void getFreeVertices(vector<Vector3d> &free_vertices);
void getOperableFreeVertices(vector<int> &free_vertices_num);
void getOperableVertices(vector<int> &operable_vertices_num, vector<bool> &constrained_or_free);
Vector3d start_pos();
Vector3d end_pos();
Matrix3d start_rot();
Matrix3d end_rot();
void set_coeffs_normalized(double bend_coeff, double twist_coeff, double grav_coeff);
void set_coeffs_normalized(const Matrix2d& bend_coeff, double twist_coeff, double grav_coeff);
void minimize_energy();
void updateConstraints (vector<Vector3d> poss, vector<Matrix3d> rots);
void addConstraint (int absolute_vertex_num);
void removeConstraint (int absolute_vertex_num);
// Returns the number of the vertex that is nearest to pos. The chosen vertex have to be a free operable vertex.
int nearestVertex(Vector3d pos);
Vector3d position(int absolute_vertex_num);
Matrix3d rotation(int absolute_vertex_num);
private:
int num_vertices;
vector<Thread*> threads;
double zero_angle;
vector<Matrix3d> rot_diff;
vector<Matrix3d> rot_offset;
vector<Vector3d> last_pos;
vector<Matrix3d> last_rot;
vector<int> constrained_vertices_nums;
void intermediateRotation(Matrix3d &inter_rot, Matrix3d end_rot, Matrix3d start_rot);
// Splits the thread threads[thread_num] into two threads, which are stored at threads[thread_num] and threads[thread_num+1]. Threads in threads that are stored after thread_num now have a new thread_num which is one unit more than before. The split is done at vertex vertex of thread[thread_num]
void splitThread(int thread_num, int vertex_num);
// Merges the threads threads[thread_num] and threads[thread_num+1] into one thread, which is stored at threads[thread_num]. Threads in threads that are stored after thread_num+1 now have a new thread_num which is one unit less than before.
void mergeThread(int thread_num);
// Returns the thread number that owns the absolute_vertex number. absolute_vertex must not be a constrained vertex
int threadOwner(int absolute_vertex_num);
// Returns the local vertex number (i.e. vertex number within a thread), given the absolute vertex number (i.e. vertex number within all vertices).
int localVertex(int absolute_vertex_num);
};
// Invalidates (sets to -1) the elements of v at indices 1. Indices are specified by constraintsNums. Indices in constraintsNums have to be in the range of v.
void invalidateAroundConstraintsNums(vector<int> &v, vector<int> constraintsNums);
// Invalidates (sets to -1) the elements of v at indices i. Indices i are specified by constraintsNums. Indices in constraintsNums have to be in the range of v.
void invalidateConstraintsNums(vector<int> &v, vector<int> constraintsNums);
template<typename T>
void mapAdd (vector<T> &v, T num);
// Last element of v1 and first element of v2 are equal to v[index].
template<typename T>
void splitVector (vector<T> &v1, vector<T> &v2, vector<T> v, int index);
// Last element of v1 is discarded since it is assumed to be the same as the first element of v2.
template<typename T>
void mergeVector (vector<T> &v, vector<T> v1, vector<T> v2);
// Last element of a vector in vectors is discarded since it is assumed to be the same as the first element of the consecutive vector in vectors. The last vector in vectors is the exception.
template<typename T>
void mergeMultipleVector(vector<T> &v, vector<vector<T> > vectors);
// Returns the position where the element was inserted.
int insertSorted (vector<int> &v, int e);
//Returns the position where the element was removed. Element to remove has to be in vector.
int removeSorted (vector<int> &v, int e);
//Returns the position of the element to be found.
int find(vector<int> v, int e);
| [
"alex@slave444.(none)"
] | alex@slave444.(none) |
acf1366df106e580f8c61ce0dc8fc70ea9b1ab3f | 6ced41da926682548df646099662e79d7a6022c5 | /aws-cpp-sdk-lakeformation/include/aws/lakeformation/model/DeleteDataCellsFilterResult.h | 1d0f9d55ed8a9552cfd74ccfe2869a76449a0e16 | [
"Apache-2.0",
"MIT",
"JSON"
] | permissive | irods/aws-sdk-cpp | 139104843de529f615defa4f6b8e20bc95a6be05 | 2c7fb1a048c96713a28b730e1f48096bd231e932 | refs/heads/main | 2023-07-25T12:12:04.363757 | 2022-08-26T15:33:31 | 2022-08-26T15:33:31 | 141,315,346 | 0 | 1 | Apache-2.0 | 2022-08-26T17:45:09 | 2018-07-17T16:24:06 | C++ | UTF-8 | C++ | false | false | 810 | h | /**
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
* SPDX-License-Identifier: Apache-2.0.
*/
#pragma once
#include <aws/lakeformation/LakeFormation_EXPORTS.h>
namespace Aws
{
template<typename RESULT_TYPE>
class AmazonWebServiceResult;
namespace Utils
{
namespace Json
{
class JsonValue;
} // namespace Json
} // namespace Utils
namespace LakeFormation
{
namespace Model
{
class AWS_LAKEFORMATION_API DeleteDataCellsFilterResult
{
public:
DeleteDataCellsFilterResult();
DeleteDataCellsFilterResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
DeleteDataCellsFilterResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
};
} // namespace Model
} // namespace LakeFormation
} // namespace Aws
| [
"aws-sdk-cpp-automation@github.com"
] | aws-sdk-cpp-automation@github.com |
968af9e52df0733a010e19c4e0f3aa6d70ae07d7 | 64e06f70e6cdf2684ae0934e3edd53992db436a1 | /include/lib/interface/IDay.hpp | 065bbf22f137239baef346874a4ca1fe4d926a7c | [] | no_license | vglad/AdventOfCode_Framework_CPP | 9c4aa1ad1704d28de0a2729b0143bd9d55a69289 | ca10a04ceef308a20d3944e9346ca7c74794eb0b | refs/heads/master | 2020-09-21T22:52:43.404844 | 2019-12-13T21:12:26 | 2019-12-13T21:12:26 | 224,961,508 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 345 | hpp | #pragma once
namespace AoC {
class IDay {
public:
virtual void print_header() noexcept = 0;
virtual void print_results() noexcept = 0;
virtual void calculate_all() noexcept = 0;
virtual void calculate_part1() = 0;
virtual void calculate_part2() = 0;
virtual ~IDay() = default;
};
} | [
"vgladun@gmail.com"
] | vgladun@gmail.com |
b25910d1628a01f5c583c09e6251a0b4750d521d | e2c37739e3832dfd63725c5d25cca86fdc04f89f | /week15/code/MultimediaFile.hpp | 3a066bb8e7738a0a257f430552e806314fa0934b | [] | no_license | lyubolp/OOP-SI-2021 | bad9229d269f0b462dbb16c44c0667b3dd9622c4 | 4afc1671a414bee7bb1d1c57511cfa870f8ef4ce | refs/heads/main | 2023-05-27T10:33:11.952723 | 2021-06-11T16:17:25 | 2021-06-11T16:17:25 | 341,111,944 | 5 | 4 | null | null | null | null | UTF-8 | C++ | false | false | 904 | hpp | //
// Created by lyubo on 3.06.21 г..
//
#ifndef CODE_MULTIMEDIAFILE_HPP
#define CODE_MULTIMEDIAFILE_HPP
#include <string>
#include <iostream>
//const, const&, unsigned, () with parameters - 4pts
class MultimediaFile { //20pts
public:
MultimediaFile();
MultimediaFile(const std::string& name, const std::string& extension, const unsigned size);
std::string get_name() const; //1pts
std::string get_extension() const; //1pts
unsigned get_size() const; //1pts
void set_name(const std::string& new_name); //1pts
void set_extension(const std::string& new_extension); //1pts
void set_size(const unsigned new_size); //1pts
virtual MultimediaFile* clone() const = 0;
virtual void play() const; //5pts
virtual ~MultimediaFile() = default; //5pts
private:
std::string name;
std::string extension;
unsigned size;
};
#endif //CODE_MULTIMEDIAFILE_HPP
| [
"lyubo.karev@gmail.com"
] | lyubo.karev@gmail.com |
929b82336368473ed024f87f8ad970bd252ee7a3 | 7670dcac34ec0f528482216292392496c0e2705b | /projects/Resource/code/Shader.h | 55c015c79d807d735d40dd3e04640ecf9d1ba460 | [
"MIT"
] | permissive | Nechrito/s0009d-lab-env | c5a3ba224b8665d6ce38245819027876510ad61b | 61599401536205c344654ef2a270a010df0e2254 | refs/heads/master | 2023-01-10T00:16:38.692203 | 2020-11-04T16:47:18 | 2020-11-04T16:47:18 | 309,981,183 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,734 | h | // Copyright © 2020 Philip Lindh
// All rights reserved
#pragma once
#include "core/app.h"
#include <string>
#include <Vector3.h>
#include <Matrix4x4.h>
#include <unordered_map>
struct ShaderSources
{
std::string VertexSource;
std::string FragmentSource;
};
class Shader
{
public:
unsigned int Id;
Shader() = default;
explicit Shader(const char* shaderPath);
void Bind() const { glUseProgram(Id); }
static void UnBind() { glUseProgram(0); }
void SetValue(const std::string& name, const Matrix4x4& mat, const bool transpose = true) { glUniformMatrix4fv(GetLocation(name), 1, transpose, mat.Ptr()); }
void SetValue(const std::string& name, const double value) { glUniform1f(GetLocation(name), static_cast<float>(value)); } // Cannot load doubles to shader as it uses float
void SetValue(const std::string& name, Vector3 value) { glUniform3fv(GetLocation(name), 1, &value[0]); }
void SetValue(const std::string& name, const int value) { glUniform1i(GetLocation(name), value); }
void SetValue(const std::string& name, const float value) { glUniform1f(GetLocation(name), value); }
void SetValue(const std::string& name, const bool value) { glUniform1i(GetLocation(name), value); }
~Shader() = default;
private:
std::string path;
std::unordered_map<std::string, int> cache;
// load
ShaderSources Parse(const char* shaderPath) const;
void LoadShader(const char* shaderPath);
static unsigned int LinkShaders(unsigned int type, const std::string& source);
// error
void CheckCompileErrors(unsigned int shader, const std::string& alias) const;
void CheckLinkErrors() const;
// fetch from cache
int GetLocation(const std::string& name);
};
| [
"philip.lindh98@hotmail.com"
] | philip.lindh98@hotmail.com |
367a0173a6485faf7fd476c69bed74f7c8ed525a | 3b60585a87d959809fa1552e4fa22f6b612f136c | /src/LegitVulkan/RenderPassCache.h | 0a98f3ea7355d1a6e641335a68ce84bf79cd26cb | [
"MIT"
] | permissive | MomoDeve/LegitEngine | c0aa07f3943caa8d9aba79d4006d5231cb82ef5d | fd6a388a4a987f387edee3e3e89a6c1b9e9d0ba5 | refs/heads/master | 2023-05-14T10:47:53.597949 | 2021-05-23T20:55:57 | 2021-05-23T20:55:57 | 370,144,413 | 0 | 0 | MIT | 2021-05-23T19:50:59 | 2021-05-23T19:50:58 | null | UTF-8 | C++ | false | false | 4,779 | h | #pragma once
#include <map>
#include "RenderPass.h"
namespace legit
{
class RenderPassCache
{
public:
RenderPassCache(vk::Device _logicalDevice) : logicalDevice(_logicalDevice)
{
}
struct RenderPassKey
{
RenderPassKey()
{
}
std::vector<legit::RenderPass::AttachmentDesc> colorAttachmentDescs;
legit::RenderPass::AttachmentDesc depthAttachmentDesc;
bool operator < (const RenderPassKey &other) const
{
return std::tie(colorAttachmentDescs, depthAttachmentDesc) < std::tie(other.colorAttachmentDescs, other.depthAttachmentDesc);
}
};
legit::RenderPass *GetRenderPass(const RenderPassKey &key)
{
auto &renderPass = renderPassCache[key];
if (!renderPass)
{
renderPass = std::unique_ptr<legit::RenderPass>(new legit::RenderPass(logicalDevice, key.colorAttachmentDescs, key.depthAttachmentDesc));
}
return renderPass.get();
}
private:
std::map<RenderPassKey, std::unique_ptr<legit::RenderPass>> renderPassCache;
vk::Device logicalDevice;
};
class FramebufferCache
{
public:
struct PassInfo
{
legit::Framebuffer *framebuffer;
legit::RenderPass *renderPass;
};
struct Attachment
{
legit::ImageView *imageView;
vk::ClearValue clearValue;
};
PassInfo BeginPass(vk::CommandBuffer commandBuffer, const std::vector<Attachment> colorAttachments, Attachment *depthAttachment, legit::RenderPass *renderPass, vk::Extent2D renderAreaExtent)
{
PassInfo passInfo;
FramebufferKey framebufferKey;
std::vector<vk::ClearValue> clearValues;
size_t attachmentsUsed = 0;
for (auto attachment : colorAttachments)
{
clearValues.push_back(attachment.clearValue);
framebufferKey.colorAttachmentViews[attachmentsUsed++] = attachment.imageView;
}
if (depthAttachment)
{
framebufferKey.depthAttachmentView = depthAttachment->imageView;
clearValues.push_back(depthAttachment->clearValue);
}
passInfo.renderPass = renderPass;
framebufferKey.extent = renderAreaExtent;
framebufferKey.renderPass = renderPass->GetHandle();
legit::Framebuffer *framebuffer = GetFramebuffer(framebufferKey);
passInfo.framebuffer = framebuffer;
vk::Rect2D rect = vk::Rect2D(vk::Offset2D(), renderAreaExtent);
auto passBeginInfo = vk::RenderPassBeginInfo()
.setRenderPass(renderPass->GetHandle())
.setFramebuffer(framebuffer->GetHandle())
.setRenderArea(rect)
.setClearValueCount(uint32_t(clearValues.size()))
.setPClearValues(clearValues.data());
commandBuffer.beginRenderPass(passBeginInfo, vk::SubpassContents::eInline);
auto viewport = vk::Viewport()
.setWidth(float(renderAreaExtent.width))
.setHeight(float(renderAreaExtent.height))
.setMinDepth(0.0f)
.setMaxDepth(1.0f);
commandBuffer.setViewport(0, { viewport });
commandBuffer.setScissor(0, { vk::Rect2D(vk::Offset2D(), renderAreaExtent) });
return passInfo;
}
void EndPass(vk::CommandBuffer commandBuffer)
{
commandBuffer.endRenderPass();
}
FramebufferCache(vk::Device _logicalDevice) : logicalDevice(_logicalDevice)
{
}
private:
struct FramebufferKey
{
FramebufferKey()
{
std::fill(colorAttachmentViews.begin(), colorAttachmentViews.end(), nullptr);
depthAttachmentView = nullptr;
renderPass = nullptr;
}
std::array<const legit::ImageView *, 8> colorAttachmentViews;
const legit::ImageView *depthAttachmentView;
vk::Extent2D extent;
vk::RenderPass renderPass;
bool operator < (const FramebufferKey &other) const
{
return std::tie(colorAttachmentViews, depthAttachmentView, extent.width, extent.height) < std::tie(other.colorAttachmentViews, other.depthAttachmentView, other.extent.width, other.extent.height);
}
};
legit::Framebuffer *GetFramebuffer(FramebufferKey key)
{
auto &framebuffer = framebufferCache[key];
if (!framebuffer)
{
std::vector<const legit::ImageView *> imageViews;
for (auto imageView : key.colorAttachmentViews)
{
if (imageView)
imageViews.push_back(imageView);
}
if (key.depthAttachmentView)
imageViews.push_back(key.depthAttachmentView);
framebuffer = std::unique_ptr<legit::Framebuffer>(new legit::Framebuffer(logicalDevice, imageViews, key.extent, key.renderPass));
}
return framebuffer.get();
}
std::map<FramebufferKey, std::unique_ptr<legit::Framebuffer>> framebufferCache;
vk::Device logicalDevice;
};
} | [
"donxenapo@gmail.com"
] | donxenapo@gmail.com |
daa9c414b327ebfb3c174b5da12f684e35c25b6b | 88a40203ebdbf2810a21688fb84a3f56d2ebb1b3 | /cc/library/ray_tracing/occ_grid_builder.cu.cc | 7dd9b89d46442ec55346ead9d09cc8ec9dd6d4b4 | [] | no_license | aushani/flsf | 2ae356338f08f2ba48a499fadb3eb91d6c01f66f | a1782b3accffa4ebb5f231e76a6e1d958d16b714 | refs/heads/master | 2020-03-28T13:08:19.554199 | 2018-08-23T21:47:15 | 2018-08-23T21:47:15 | 148,369,543 | 4 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,025 | cc | // Adapted from dascar
#include "library/ray_tracing/occ_grid_builder.h"
#include <iostream>
#include <boost/assert.hpp>
#include <thrust/device_ptr.h>
#include "library/ray_tracing/occ_grid_location.h"
#include "library/ray_tracing/device_data.cu.h"
#include "library/timer/timer.h"
namespace tr = library::timer;
namespace library {
namespace ray_tracing {
OccGridBuilder::OccGridBuilder(int max_observations, float resolution, float max_range)
: max_observations_(max_observations),
resolution_(resolution),
device_data_(new DeviceData(resolution, max_range, max_observations)) {
}
OccGridBuilder::~OccGridBuilder() {
}
size_t OccGridBuilder::ProcessData(const std::vector<Eigen::Vector3f> &hits) {
// First, we need to send the data to the GPU device
device_data_->CopyData(hits);
// Now run ray tracing on the GPU device
device_data_->RunKernel();
return device_data_->ReduceLogOdds();
}
OccGrid OccGridBuilder::GenerateOccGrid(const std::vector<Eigen::Vector3f> &hits) {
//library::timer::Timer t;
BOOST_ASSERT(hits.size() <= max_observations_);
// Check for empty data
if (hits.size() == 0) {
std::vector<Location> location_vector;
std::vector<float> lo_vector;
return OccGrid(location_vector, lo_vector, resolution_);
}
size_t num_updates = ProcessData(hits);
// Copy result from GPU device to host
//t.Start();
std::vector<Location> location_vector(num_updates);
std::vector<float> lo_vector(num_updates);
cudaMemcpy(location_vector.data(), device_data_->locations_reduced.GetRawPointer(), sizeof(Location) * num_updates, cudaMemcpyDeviceToHost);
cudaMemcpy(lo_vector.data(), device_data_->log_odds_updates_reduced.GetRawPointer(), sizeof(float) * num_updates, cudaMemcpyDeviceToHost);
cudaError_t err = cudaDeviceSynchronize();
BOOST_ASSERT(err == cudaSuccess);
//printf("\tTook %5.3f to copy to host\n", t.GetMs());
return OccGrid(location_vector, lo_vector, resolution_);
}
} // namespace ray_tracing
} // namespace library
| [
"aushani@gmail.com"
] | aushani@gmail.com |
d371c22fa6662d20696cb24410c6349ade0001a8 | 04df0a0f2837c06d47ca6ced95969c61b4357386 | /catkin_ws/src/world_mapper/sketch/libraries/ros_lib/loki_base_node/BusUInt16Set.h | 36f854e354955d0d7245f9c5fa264e15827e0f2c | [] | no_license | basharbme/RealityVirtualVirturalizer | 82fae9d8dada920ce3cf226b77dd8f0a61f359ac | f783c981554f27beee258d720962a61dd298c3a5 | refs/heads/master | 2022-09-19T06:30:09.326876 | 2020-06-01T06:55:11 | 2020-06-01T06:55:11 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,836 | h | #ifndef _ROS_SERVICE_BusUInt16Set_h
#define _ROS_SERVICE_BusUInt16Set_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace loki_base_node
{
static const char BUSUINT16SET[] = "loki_base_node/BusUInt16Set";
class BusUInt16SetRequest : public ros::Msg
{
public:
typedef int16_t _address_type;
_address_type address;
typedef int8_t _command_type;
_command_type command;
typedef uint16_t _value_type;
_value_type value;
typedef int8_t _retries_type;
_retries_type retries;
typedef int8_t _priority_type;
_priority_type priority;
BusUInt16SetRequest():
address(0),
command(0),
value(0),
retries(0),
priority(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int16_t real;
uint16_t base;
} u_address;
u_address.real = this->address;
*(outbuffer + offset + 0) = (u_address.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_address.base >> (8 * 1)) & 0xFF;
offset += sizeof(this->address);
union {
int8_t real;
uint8_t base;
} u_command;
u_command.real = this->command;
*(outbuffer + offset + 0) = (u_command.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->command);
*(outbuffer + offset + 0) = (this->value >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->value >> (8 * 1)) & 0xFF;
offset += sizeof(this->value);
union {
int8_t real;
uint8_t base;
} u_retries;
u_retries.real = this->retries;
*(outbuffer + offset + 0) = (u_retries.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->retries);
union {
int8_t real;
uint8_t base;
} u_priority;
u_priority.real = this->priority;
*(outbuffer + offset + 0) = (u_priority.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->priority);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int16_t real;
uint16_t base;
} u_address;
u_address.base = 0;
u_address.base |= ((uint16_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_address.base |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->address = u_address.real;
offset += sizeof(this->address);
union {
int8_t real;
uint8_t base;
} u_command;
u_command.base = 0;
u_command.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->command = u_command.real;
offset += sizeof(this->command);
this->value = ((uint16_t) (*(inbuffer + offset)));
this->value |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
offset += sizeof(this->value);
union {
int8_t real;
uint8_t base;
} u_retries;
u_retries.base = 0;
u_retries.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->retries = u_retries.real;
offset += sizeof(this->retries);
union {
int8_t real;
uint8_t base;
} u_priority;
u_priority.base = 0;
u_priority.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->priority = u_priority.real;
offset += sizeof(this->priority);
return offset;
}
const char * getType(){ return BUSUINT16SET; };
const char * getMD5(){ return "e850399cb2d469aaedcebeeb76987c53"; };
};
class BusUInt16SetResponse : public ros::Msg
{
public:
typedef int8_t _status_type;
_status_type status;
BusUInt16SetResponse():
status(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_status;
u_status.real = this->status;
*(outbuffer + offset + 0) = (u_status.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->status);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_status;
u_status.base = 0;
u_status.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->status = u_status.real;
offset += sizeof(this->status);
return offset;
}
const char * getType(){ return BUSUINT16SET; };
const char * getMD5(){ return "581cc55c12abfc219e446416014f6d0e"; };
};
class BusUInt16Set {
public:
typedef BusUInt16SetRequest Request;
typedef BusUInt16SetResponse Response;
};
}
#endif
| [
"aytimothy@aytimothy.xyz"
] | aytimothy@aytimothy.xyz |
8cf5d9e8a44ea53679863a71b89c094a0876cb02 | 5102892f18f44b02b340cea85f220982eea18435 | /NewFramework/ItemsManager.cpp | 2ec249a1b56f82f92c93c9dfbd084a9615d79f70 | [
"MIT"
] | permissive | lhthang1998/Megaman_X3_DirectX | b87ee477ac596954122e1aa838e3aa6242127632 | 2c695fefad81c37a7872cc79c78d0de3ff6db9ca | refs/heads/master | 2021-10-10T11:07:38.695966 | 2019-01-10T03:38:01 | 2019-01-10T03:38:01 | 164,980,874 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 790 | cpp | #include "ItemsManager.h"
std::vector<HP*> ItemsManager::HPItemsList;
ItemsManager::ItemsManager()
{
}
ItemsManager::~ItemsManager()
{
for (int i = 0; i < HPItemsList.size(); i++) {
delete HPItemsList[i];
}
}
void ItemsManager::DropItem(HP* item) {
HPItemsList.push_back(item);
}
void ItemsManager::DropHPItem(int x, int y) {
HPItemsList.push_back(new HP(x, y));
}
void ItemsManager::UpdateItems() {
for (int i = 0; i < HPItemsList.size(); i++) {
if (HPItemsList[i]->isDisappeared) {
delete HPItemsList[i];
HPItemsList.erase(HPItemsList.begin() + i);
i--;
}
else {
HPItemsList[i]->Update();
}
}
//GAMELOG("HP: %d", HPItemsList.size());
}
void ItemsManager::RenderItems() {
for (int i = 0; i < HPItemsList.size(); i++) {
HPItemsList[i]->Render();
}
} | [
"lhthang.1998@gmail.com"
] | lhthang.1998@gmail.com |
4acc274b654fa572c1bf5f8cc7455f981d1313be | 7a5dbfc55d2fcd43e90e14ebe3fe3fa4705a162a | /Quasics2021Code/MaeTester2022/src/main/cpp/commands/DelayForTime.cpp | 54338737ef2cc61aa1973bf395a56d3d0890a315 | [
"BSD-3-Clause"
] | permissive | quasics/quasics-frc-sw-2015 | c71194921a3f0930bc16ae96952577ff029f8542 | 83aa34f475e5060e31ddf12186b48cb68430acc6 | refs/heads/master | 2023-08-23T07:13:23.194240 | 2023-08-17T23:19:51 | 2023-08-17T23:19:51 | 43,209,473 | 7 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 610 | cpp | // Copyright (c) FIRST and other WPILib contributors.
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
#include "commands/DelayForTime.h"
DelayForTime::DelayForTime(units::second_t time) : time(time) {
// There are no subsystem dependencies for this command.
}
// Called when the command is initially scheduled.
void DelayForTime::Initialize() {
stopWatch.Reset();
stopWatch.Start();
}
// Returns true when the command should end.
bool DelayForTime::IsFinished() {
return stopWatch.HasElapsed(time);
}
| [
"mjhealy@users.noreply.github.com"
] | mjhealy@users.noreply.github.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.