hexsha
stringlengths 40
40
| size
int64 7
1.05M
| ext
stringclasses 13
values | lang
stringclasses 1
value | max_stars_repo_path
stringlengths 4
269
| max_stars_repo_name
stringlengths 5
109
| max_stars_repo_head_hexsha
stringlengths 40
40
| max_stars_repo_licenses
listlengths 1
9
| max_stars_count
int64 1
191k
⌀ | max_stars_repo_stars_event_min_datetime
stringlengths 24
24
⌀ | max_stars_repo_stars_event_max_datetime
stringlengths 24
24
⌀ | max_issues_repo_path
stringlengths 4
269
| max_issues_repo_name
stringlengths 5
116
| max_issues_repo_head_hexsha
stringlengths 40
40
| max_issues_repo_licenses
listlengths 1
9
| max_issues_count
int64 1
48.5k
⌀ | max_issues_repo_issues_event_min_datetime
stringlengths 24
24
⌀ | max_issues_repo_issues_event_max_datetime
stringlengths 24
24
⌀ | max_forks_repo_path
stringlengths 4
269
| max_forks_repo_name
stringlengths 5
116
| max_forks_repo_head_hexsha
stringlengths 40
40
| max_forks_repo_licenses
listlengths 1
9
| max_forks_count
int64 1
105k
⌀ | max_forks_repo_forks_event_min_datetime
stringlengths 24
24
⌀ | max_forks_repo_forks_event_max_datetime
stringlengths 24
24
⌀ | content
stringlengths 7
1.05M
| avg_line_length
float64 1.21
330k
| max_line_length
int64 6
990k
| alphanum_fraction
float64 0.01
0.99
| author_id
stringlengths 2
40
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
c55dabbeed85720cfa30e1c218a6f46416add238
| 1,976
|
cpp
|
C++
|
aws-cpp-sdk-nimble/source/model/CreateStreamingSessionRequest.cpp
|
perfectrecall/aws-sdk-cpp
|
fb8cbebf2fd62720b65aeff841ad2950e73d8ebd
|
[
"Apache-2.0"
] | 1
|
2022-02-12T08:09:30.000Z
|
2022-02-12T08:09:30.000Z
|
aws-cpp-sdk-nimble/source/model/CreateStreamingSessionRequest.cpp
|
perfectrecall/aws-sdk-cpp
|
fb8cbebf2fd62720b65aeff841ad2950e73d8ebd
|
[
"Apache-2.0"
] | 1
|
2021-10-14T16:57:00.000Z
|
2021-10-18T10:47:24.000Z
|
aws-cpp-sdk-nimble/source/model/CreateStreamingSessionRequest.cpp
|
ravindra-wagh/aws-sdk-cpp
|
7d5ff01b3c3b872f31ca98fb4ce868cd01e97696
|
[
"Apache-2.0"
] | 1
|
2021-11-09T11:58:03.000Z
|
2021-11-09T11:58:03.000Z
|
/**
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
* SPDX-License-Identifier: Apache-2.0.
*/
#include <aws/nimble/model/CreateStreamingSessionRequest.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/core/utils/memory/stl/AWSStringStream.h>
#include <utility>
using namespace Aws::NimbleStudio::Model;
using namespace Aws::Utils::Json;
using namespace Aws::Utils;
CreateStreamingSessionRequest::CreateStreamingSessionRequest() :
m_clientToken(Aws::Utils::UUID::RandomUUID()),
m_clientTokenHasBeenSet(true),
m_ec2InstanceType(StreamingInstanceType::NOT_SET),
m_ec2InstanceTypeHasBeenSet(false),
m_launchProfileIdHasBeenSet(false),
m_ownedByHasBeenSet(false),
m_streamingImageIdHasBeenSet(false),
m_studioIdHasBeenSet(false),
m_tagsHasBeenSet(false)
{
}
Aws::String CreateStreamingSessionRequest::SerializePayload() const
{
JsonValue payload;
if(m_ec2InstanceTypeHasBeenSet)
{
payload.WithString("ec2InstanceType", StreamingInstanceTypeMapper::GetNameForStreamingInstanceType(m_ec2InstanceType));
}
if(m_launchProfileIdHasBeenSet)
{
payload.WithString("launchProfileId", m_launchProfileId);
}
if(m_ownedByHasBeenSet)
{
payload.WithString("ownedBy", m_ownedBy);
}
if(m_streamingImageIdHasBeenSet)
{
payload.WithString("streamingImageId", m_streamingImageId);
}
if(m_tagsHasBeenSet)
{
JsonValue tagsJsonMap;
for(auto& tagsItem : m_tags)
{
tagsJsonMap.WithString(tagsItem.first, tagsItem.second);
}
payload.WithObject("tags", std::move(tagsJsonMap));
}
return payload.View().WriteReadable();
}
Aws::Http::HeaderValueCollection CreateStreamingSessionRequest::GetRequestSpecificHeaders() const
{
Aws::Http::HeaderValueCollection headers;
Aws::StringStream ss;
if(m_clientTokenHasBeenSet)
{
ss << m_clientToken;
headers.emplace("x-amz-client-token", ss.str());
ss.str("");
}
return headers;
}
| 22.454545
| 122
| 0.745951
|
perfectrecall
|
c5650825bfa7f67d76aa71a25606738165d66a41
| 4,125
|
cpp
|
C++
|
KFPlugin/KFBasicDatabase/KFBasicDatabaseMongo.cpp
|
282951387/KFrame
|
5d6e953f7cc312321c36632715259394ca67144c
|
[
"Apache-2.0"
] | 1
|
2021-04-26T09:31:32.000Z
|
2021-04-26T09:31:32.000Z
|
KFPlugin/KFBasicDatabase/KFBasicDatabaseMongo.cpp
|
282951387/KFrame
|
5d6e953f7cc312321c36632715259394ca67144c
|
[
"Apache-2.0"
] | null | null | null |
KFPlugin/KFBasicDatabase/KFBasicDatabaseMongo.cpp
|
282951387/KFrame
|
5d6e953f7cc312321c36632715259394ca67144c
|
[
"Apache-2.0"
] | null | null | null |
#include "KFBasicDatabaseMongo.hpp"
#include "KFProtocol/KFProtocol.h"
namespace KFrame
{
#define __BASIC_TABLE_NAME__ __STRING__( basic )
#define __BASIC_MONGO_DRIVER__ _kf_mongo->Create( __STRING__( basic ) )
void KFBasicDatabaseMongo::UpdateBasicIntValue( uint64 playerid, uint64 serverid, const StringUInt64& values )
{
auto mongodriver = __BASIC_MONGO_DRIVER__;
KFDBValue dbvalue;
for ( auto& iter : values )
{
dbvalue.AddValue( iter.first, iter.second );
}
mongodriver->Insert( __BASIC_TABLE_NAME__, playerid, dbvalue );
}
void KFBasicDatabaseMongo::UpdateBasicStrValue( uint64 playerid, uint64 serverid, const StringMap& values )
{
auto mongodriver = __BASIC_MONGO_DRIVER__;
KFDBValue dbvalue;
for ( auto& iter : values )
{
dbvalue.AddValue( iter.first, iter.second );
}
mongodriver->Insert( __BASIC_TABLE_NAME__, playerid, dbvalue );
}
void KFBasicDatabaseMongo::ClearBasicServerId( uint64 serverid )
{
auto mongodriver = __BASIC_MONGO_DRIVER__;
KFMongoSelector kfselector;
kfselector._document.AddExpression( __STRING__( serverid ), MongoKeyword::_eq, serverid );
mongodriver->Insert( __BASIC_TABLE_NAME__, __STRING__( serverid ), 0u, kfselector );
}
uint64 KFBasicDatabaseMongo::QueryBasicServerId( uint64 playerid )
{
return QueryBasicIntValue( playerid, __STRING__( serverid ) );
}
uint32 KFBasicDatabaseMongo::QueryBasicAttribute( uint64 playerid, StringMap& values )
{
auto mongodriver = __BASIC_MONGO_DRIVER__;
auto kfresult = mongodriver->QueryRecord( __BASIC_TABLE_NAME__, playerid );
if ( !kfresult->IsOk() )
{
return KFMsg::PublicDatabaseBusy;
}
__DBVALUE_TO_MAP__( kfresult->_value, values );
return KFMsg::Ok;
}
std::string KFBasicDatabaseMongo::FormatNameTable( uint32 zoneid )
{
return __FORMAT__( "{}:{}", __STRING__( playername ), zoneid );
}
uint32 KFBasicDatabaseMongo::SetPlayerName( uint32 zoneid, uint64 playerid, const std::string& oldname, const std::string& newname )
{
auto mongodriver = __BASIC_MONGO_DRIVER__;
auto nametable = FormatNameTable( zoneid );
auto kfplayerid = mongodriver->QueryUInt64( nametable, newname, __STRING__( playerid ) );
if ( !kfplayerid->IsOk() )
{
return KFMsg::NameDatabaseBusy;
}
// 如果不存在, 设置新名字
if ( kfplayerid->_value == _invalid_int )
{
// 保存名字
auto result = mongodriver->Insert( nametable, newname, __STRING__( playerid ), playerid );
if ( !result )
{
return KFMsg::NameDatabaseBusy;
}
// 删除旧的名字关联
if ( !oldname.empty() )
{
mongodriver->Delete( nametable, oldname );
}
}
else if ( kfplayerid->_value != playerid )
{
// 存在, 并且不是设定者
return KFMsg::NameAlreadyExist;
}
return KFMsg::NameSetOk;
}
uint64 KFBasicDatabaseMongo::QueryBasicPlayerid( const std::string& playername, uint32 zoneid )
{
auto mongodriver = __BASIC_MONGO_DRIVER__;
auto nametable = FormatNameTable( zoneid );
auto kfplayerid = mongodriver->QueryUInt64( nametable, playername, __STRING__( playerid ) );
return kfplayerid->_value;
}
uint64 KFBasicDatabaseMongo::QueryBasicIntValue( uint64 playerid, const std::string& dataname )
{
auto mongodriver = __BASIC_MONGO_DRIVER__;
auto kfresult = mongodriver->QueryUInt64( __BASIC_TABLE_NAME__, playerid, dataname );
return kfresult->_value;
}
std::string KFBasicDatabaseMongo::QueryBasicStrValue( uint64 playerid, const std::string& dataname )
{
auto mongodriver = __BASIC_MONGO_DRIVER__;
auto kfresult = mongodriver->QueryString( __BASIC_TABLE_NAME__, playerid, dataname );
return kfresult->_value;
}
}
| 33.536585
| 136
| 0.640727
|
282951387
|
c5698af1c6870f00442bf4f672c635fc3ea44c40
| 571
|
hpp
|
C++
|
library/ATF/std___String_base.hpp
|
lemkova/Yorozuya
|
f445d800078d9aba5de28f122cedfa03f26a38e4
|
[
"MIT"
] | 29
|
2017-07-01T23:08:31.000Z
|
2022-02-19T10:22:45.000Z
|
library/ATF/std___String_base.hpp
|
kotopes/Yorozuya
|
605c97d3a627a8f6545cc09f2a1b0a8afdedd33a
|
[
"MIT"
] | 90
|
2017-10-18T21:24:51.000Z
|
2019-06-06T02:30:33.000Z
|
library/ATF/std___String_base.hpp
|
kotopes/Yorozuya
|
605c97d3a627a8f6545cc09f2a1b0a8afdedd33a
|
[
"MIT"
] | 44
|
2017-12-19T08:02:59.000Z
|
2022-02-24T23:15:01.000Z
|
// This file auto generated by plugin for ida pro. Generated code only for x64. Please, dont change manually
#pragma once
#include <common/common.h>
#include <std___Container_base.hpp>
START_ATF_NAMESPACE
namespace std
{
struct _String_base : _Container_base
{
public:
_String_base(struct _String_base* arg_0);
int64_t ctor__String_base(struct _String_base* arg_0);
};
static_assert(ATF::checkSize<std::_String_base, 8>(), "std::_String_base");
}; // end namespace std
END_ATF_NAMESPACE
| 28.55
| 108
| 0.674256
|
lemkova
|
c56fae0047c497dec32cb86dab3b806b552c1686
| 475
|
cpp
|
C++
|
src/polynomial.cpp
|
NChechulin/spline-interpolation
|
34333b885c435d5dfd1ab892a9cc8a79e016c448
|
[
"MIT"
] | 1
|
2021-04-26T14:15:20.000Z
|
2021-04-26T14:15:20.000Z
|
src/polynomial.cpp
|
NChechulin/spline-interpolation
|
34333b885c435d5dfd1ab892a9cc8a79e016c448
|
[
"MIT"
] | null | null | null |
src/polynomial.cpp
|
NChechulin/spline-interpolation
|
34333b885c435d5dfd1ab892a9cc8a79e016c448
|
[
"MIT"
] | null | null | null |
#include "polynomial.h"
#include <vector>
#include <cmath>
Polynomial::Polynomial() : a(0), b(0), c(0), d(0) {}
Polynomial::Polynomial(double a, double b, double c, double d)
: a(a), b(b), c(c), d(d) {}
double Polynomial::GetValue(double x) const {
return a * std::pow(x, 3) + b * std::pow(x, 2) + c * x + d;
}
Polynomial Polynomial::GetCoefficientsFromVector(std::vector<double>::iterator from) {
return {*(from + 0), *(from + 1), *(from + 2), *(from + 3)};
}
| 27.941176
| 86
| 0.606316
|
NChechulin
|
c572bf5ec488bdb44c56a3952413f066e95d87cd
| 3,348
|
cc
|
C++
|
test/syscalls/linux/mincore.cc
|
kimmkumsook/gvisor
|
c611dbc5a7399922588e3fd99b22bda19f684afe
|
[
"Apache-2.0"
] | 1
|
2019-05-28T03:18:37.000Z
|
2019-05-28T03:18:37.000Z
|
test/syscalls/linux/mincore.cc
|
kimmkumsook/gvisor
|
c611dbc5a7399922588e3fd99b22bda19f684afe
|
[
"Apache-2.0"
] | null | null | null |
test/syscalls/linux/mincore.cc
|
kimmkumsook/gvisor
|
c611dbc5a7399922588e3fd99b22bda19f684afe
|
[
"Apache-2.0"
] | 1
|
2019-07-17T12:28:43.000Z
|
2019-07-17T12:28:43.000Z
|
// Copyright 2018 Google LLC
//
// 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 <errno.h>
#include <stdint.h>
#include <string.h>
#include <sys/mman.h>
#include <unistd.h>
#include <algorithm>
#include <vector>
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "test/util/memory_util.h"
#include "test/util/posix_error.h"
#include "test/util/test_util.h"
namespace gvisor {
namespace testing {
namespace {
size_t CountSetLSBs(std::vector<unsigned char> const& vec) {
return std::count_if(begin(vec), end(vec),
[](unsigned char c) { return (c & 1) != 0; });
}
TEST(MincoreTest, DirtyAnonPagesAreResident) {
constexpr size_t kTestPageCount = 10;
auto const kTestMappingBytes = kTestPageCount * kPageSize;
auto m = ASSERT_NO_ERRNO_AND_VALUE(
MmapAnon(kTestMappingBytes, PROT_READ | PROT_WRITE, MAP_PRIVATE));
memset(m.ptr(), 0, m.len());
std::vector<unsigned char> vec(kTestPageCount, 0);
ASSERT_THAT(mincore(m.ptr(), kTestMappingBytes, vec.data()),
SyscallSucceeds());
EXPECT_EQ(kTestPageCount, CountSetLSBs(vec));
}
TEST(MincoreTest, UnalignedAddressFails) {
// Map and touch two pages, then try to mincore the second half of the first
// page + the first half of the second page. Both pages are mapped, but
// mincore should return EINVAL due to the misaligned start address.
constexpr size_t kTestPageCount = 2;
auto const kTestMappingBytes = kTestPageCount * kPageSize;
auto m = ASSERT_NO_ERRNO_AND_VALUE(
MmapAnon(kTestMappingBytes, PROT_READ | PROT_WRITE, MAP_PRIVATE));
memset(m.ptr(), 0, m.len());
std::vector<unsigned char> vec(kTestPageCount, 0);
EXPECT_THAT(mincore(reinterpret_cast<void*>(m.addr() + kPageSize / 2),
kPageSize, vec.data()),
SyscallFailsWithErrno(EINVAL));
}
TEST(MincoreTest, UnalignedLengthSucceedsAndIsRoundedUp) {
// Map and touch two pages, then try to mincore the first page + the first
// half of the second page. mincore should silently round up the length to
// include both pages.
constexpr size_t kTestPageCount = 2;
auto const kTestMappingBytes = kTestPageCount * kPageSize;
auto m = ASSERT_NO_ERRNO_AND_VALUE(
MmapAnon(kTestMappingBytes, PROT_READ | PROT_WRITE, MAP_PRIVATE));
memset(m.ptr(), 0, m.len());
std::vector<unsigned char> vec(kTestPageCount, 0);
ASSERT_THAT(mincore(m.ptr(), kPageSize + kPageSize / 2, vec.data()),
SyscallSucceeds());
EXPECT_EQ(kTestPageCount, CountSetLSBs(vec));
}
TEST(MincoreTest, ZeroLengthSucceedsAndAllowsAnyVecBelowTaskSize) {
EXPECT_THAT(mincore(nullptr, 0, nullptr), SyscallSucceeds());
}
TEST(MincoreTest, InvalidLengthFails) {
EXPECT_THAT(mincore(nullptr, -1, nullptr), SyscallFailsWithErrno(ENOMEM));
}
} // namespace
} // namespace testing
} // namespace gvisor
| 34.515464
| 78
| 0.718937
|
kimmkumsook
|
c579af2f4913efa2b0f0e2db85ba751c2c94eb6a
| 182
|
cpp
|
C++
|
main.cpp
|
JokerShao/utilityclasses
|
cf1a73bc3e5681b1a31b1184e979ca4b1fb062b5
|
[
"MIT"
] | null | null | null |
main.cpp
|
JokerShao/utilityclasses
|
cf1a73bc3e5681b1a31b1184e979ca4b1fb062b5
|
[
"MIT"
] | null | null | null |
main.cpp
|
JokerShao/utilityclasses
|
cf1a73bc3e5681b1a31b1184e979ca4b1fb062b5
|
[
"MIT"
] | null | null | null |
#if 1
#include <iostream>
#include <string>
int main()
{
double aa = 1.23456788;
std::cout << std::to_string(aa) << "\n";
std::cout << "Hello World!\n";
return 0;
}
#endif
| 10.705882
| 41
| 0.587912
|
JokerShao
|
c57cd5a194e96ff1c94b9f813df2beea50b8e028
| 248
|
cpp
|
C++
|
Flow3D/Sandbox/src/Sandbox.cpp
|
florianvoelkers/Flow3D
|
017d2f321f943dfecc360bec9fc6f17c77ffde68
|
[
"MIT"
] | 2
|
2020-05-09T10:06:00.000Z
|
2021-03-10T00:10:41.000Z
|
Flow3D/Sandbox/src/Sandbox.cpp
|
florianvoelkers/Flow3D
|
017d2f321f943dfecc360bec9fc6f17c77ffde68
|
[
"MIT"
] | 1
|
2022-03-04T09:17:15.000Z
|
2022-03-04T09:17:15.000Z
|
Flow3D/Sandbox/src/Sandbox.cpp
|
florianvoelkers/Flow3D
|
017d2f321f943dfecc360bec9fc6f17c77ffde68
|
[
"MIT"
] | 2
|
2020-02-17T00:43:03.000Z
|
2020-11-26T11:55:19.000Z
|
#include "Flow3D.hpp"
class Sandbox : public Application
{
public:
Sandbox()
{
FLOW_CLIENT_INFO("Welcome to the Sandbox Application of the Flow3D Engine!");
}
~Sandbox()
{
}
};
Application* CreateApplication()
{
return new Sandbox();
}
| 12.4
| 79
| 0.693548
|
florianvoelkers
|
c5804f2d931366e2e392b9054ffef46000f8cbd5
| 1,509
|
hpp
|
C++
|
source/Snoopy/X86/Enums.hpp
|
ttcctt/GAME
|
982ad68a65f17f3926d713283f73ac858b6820e0
|
[
"Unlicense"
] | 158
|
2015-02-16T20:32:09.000Z
|
2022-03-24T04:11:07.000Z
|
source/Snoopy/X86/Enums.hpp
|
Maqentaer/YoloMouse
|
48415f1517591e0445b44e73d05f61d3e35b41f2
|
[
"Unlicense"
] | 22
|
2015-03-03T23:40:54.000Z
|
2021-11-14T06:28:25.000Z
|
source/Snoopy/X86/Enums.hpp
|
Maqentaer/YoloMouse
|
48415f1517591e0445b44e73d05f61d3e35b41f2
|
[
"Unlicense"
] | 48
|
2015-06-12T17:50:39.000Z
|
2022-03-21T20:59:29.000Z
|
#pragma once
#include <Snoopy/Root.hpp>
namespace Snoopy { namespace x86
{
// x86 register ids
//-------------------------------------------------------------------------
enum RegisterId
{
REGISTER_AX = 0,
REGISTER_CX = 1,
REGISTER_DX = 2,
REGISTER_BX = 3,
REGISTER_SP = 4,
REGISTER_BP = 5,
REGISTER_SI = 6,
REGISTER_DI = 7,
REGISTER_R8 = 100,
REGISTER_R9 = 101,
REGISTER_R10 = 102,
REGISTER_R11 = 103,
REGISTER_R12 = 104,
REGISTER_R13 = 105,
REGISTER_R14 = 106,
REGISTER_R15 = 107,
REGISTER_BASIC_COUNT = 8,
REGISTER_EXT_COUNT = 8,
REGISTER_EXT_DIV = 100,
};
// x86 op codes
//-------------------------------------------------------------------------
enum OpCodeId
{
OP_NOP = 0x90,
OP_CALL_REG = 0xd0,
OP_CALL_REL = 0xe8,
OP_JMP_REG = 0xe0,
OP_JMP_REL = 0xe9,
OP_PUSH_REG = 0x50,
OP_POP_REG = 0x58,
OP_MOV_REG_IMM = 0xb8,
OP_MOV_REG_REG = 0x8b,
OP_ARG_MOV_REG_REG = 0xc0,
OP_PREFIX_MOV_64 = 0x48,
OP_PREFIX_CALL_REG = 0xFF,
OP_PREFIX_JMP_REG = 0xFF,
OP_PREFIX_PUSH_64 = 0x41,
OP_PREFIX_POP_64 = 0x41,
};
}}
| 26.017241
| 80
| 0.423459
|
ttcctt
|
c58879f63907bf93e1d5ed6d41800be472bd3714
| 998
|
cpp
|
C++
|
一星題/10235/10235.cpp
|
LuckyPigeon/CPE_Previous_Questions
|
14005407c52922dea28e861e8f591d74da3c3df5
|
[
"MIT"
] | 26
|
2020-10-08T02:44:20.000Z
|
2022-03-25T09:59:31.000Z
|
一星題/10235/10235.cpp
|
LuckyPigeon/CPE_Previous_Questions
|
14005407c52922dea28e861e8f591d74da3c3df5
|
[
"MIT"
] | 61
|
2020-10-08T17:03:53.000Z
|
2021-06-17T01:05:51.000Z
|
一星題/10235/10235.cpp
|
LuckyPigeon/CPE_Previous_Questions
|
14005407c52922dea28e861e8f591d74da3c3df5
|
[
"MIT"
] | 27
|
2020-10-04T05:30:23.000Z
|
2021-08-21T15:39:58.000Z
|
#include <iostream>
#include <iostream>
#include <cstdio>
using namespace std;
const int LIMIT = 1000000;
int reverse( int a )
{
int b = 0;
while( a != 0 ) // 讓 b 存入 a 的最小位後,並且在每次存入前讓質乘以 10 ,以讓數字反轉
{
b *= 10;
b += a%10;
a /= 10;
}
return b;
}
int main()
{
bool composite[LIMIT+5] = {true, true}; // 宣告 composite 陣列來紀錄是否為合數
for( int i = 2; i <= LIMIT ; ++i )
{
if( !composite[i] ) // 如果 i 不是合數 , 則去尋找它的倍數,並且把它的倍數紀錄為合數
{
for( int j = i+i ; j <= LIMIT ; j += i )
{
composite[j] = true;
}
}
}
int N;
while( scanf("%d", &N) != EOF ) // while 輸入測資 N
{
if( composite[N] ) // 如果 N 是合數,則輸出 is not prime
{
cout << N << " is not prime." << endl;
continue;
}
int reverseN = reverse(N); // 反轉 N 的質,並存入 reverseN
if( reverseN!=N && !composite[reverseN] ) // 如果反轉後的 reverseN 與反轉前的 N 不相等,並且 reverseN 為質數,則輸出 is emirp
cout << N << " is emirp." << endl;
else // 否則輸出 is prime
cout << N << " is prime." << endl;
}
return 0;
}
| 21.695652
| 104
| 0.544088
|
LuckyPigeon
|
c58b51b96f3d4c02c7c38de92887498fb6d9046e
| 10,390
|
cc
|
C++
|
src/pycomp/PythonSymdiffCommands.cc
|
weatherhead99/symdiff
|
ba21034fcffcc0fb84e1922549bb969f556c7741
|
[
"Apache-2.0"
] | 8
|
2016-06-02T17:07:44.000Z
|
2021-03-13T16:21:54.000Z
|
src/pycomp/PythonSymdiffCommands.cc
|
weatherhead99/symdiff
|
ba21034fcffcc0fb84e1922549bb969f556c7741
|
[
"Apache-2.0"
] | 4
|
2018-03-04T20:32:01.000Z
|
2020-01-15T15:42:41.000Z
|
src/pycomp/PythonSymdiffCommands.cc
|
devsim/symdiff
|
1f25961214c25c5142279ec771db3c378637c950
|
[
"Apache-2.0"
] | 7
|
2015-10-28T17:24:05.000Z
|
2021-03-13T16:22:01.000Z
|
/***
Copyright 2012 Devsim LLC
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.
***/
/* removes Python_d.lib from any contention */
//#undef _DEBUG
#ifdef _WIN32
/* remove warning on windows for function we do not use */
#define HAVE_ROUND
#endif
#include "Python.h"
#include "import.h"
#include "EquationFunctions.hh"
#include "Context.hh"
#include "SubExpr.hh"
#include "ProcessModelOrder.hh"
#include "ProcessOrderedTable.hh"
#include "EngineAPI.hh"
#include <vector>
#include <string>
#include <sstream>
namespace {
PyObject *symdiff_exception = nullptr;
};
namespace {
struct module_state {
module_state() : error(nullptr) {};
PyObject *error;
};
#if PY_MAJOR_VERSION >= 3
#define GETSTATE(m) ((struct module_state*)PyModule_GetState(m))
#else
#define GETSTATE(m) (&_state)
static struct module_state _state;
#endif
}
/// Visual C++ does not allow c++ return values in extern "C"
/// There will be a python error unless there is only 1 argument
static dsHelper::ret_pair GetStringArgument(PyObject *args)
{
dsHelper::ret_pair result;
result.first = false;
const char *fromPython;
if (PyArg_Parse(args, "(s)", &fromPython))
{
result.first = true;
result.second.string_ = fromPython;
}
else
{
result.first = false;
}
return result;
}
typedef std::vector<std::string> StringVector_t;
static bool HasZeroArguments(PyObject *args)
{
bool ret = false;
const char *fromPython;
if (PyArg_Parse(args, "()", &fromPython))
{
ret = true;
}
return ret;
}
static PyObject *returnNone()
{
Py_INCREF(Py_None);
PyObject *returnObj = Py_None;
return returnObj;
}
static PyObject *returnString(const std::string &s)
{
return Py_BuildValue("s", s.c_str());
}
static PyObject *returnLong(size_t i)
{
return PyLong_FromSsize_t(i);
}
static PyObject *returnTupleLong(const std::vector<size_t> &index)
{
PyObject *returnObj = PyTuple_New(index.size());
PyObject *subobj;
for (size_t i = 0; i < index.size(); ++i)
{
subobj = returnLong(index[i]);
PyTuple_SetItem(returnObj, i, subobj);
Py_INCREF(subobj);
}
return returnObj;
}
static bool GetStringArguments(PyObject *args, StringVector_t &result)
{
bool ret = true;
Py_ssize_t len = PyTuple_Size(args);
result.resize(0);
result.reserve(len);
for (Py_ssize_t i = 0; i < len; ++i)
{
PyObject *item = PyTuple_GetItem(args, i);
const char *fromPython;
if (PyArg_Parse(item, "s", &fromPython))
{
const std::string &tres = fromPython;
result.push_back(tres);
}
else
{
ret = false;
break;
}
}
return ret;
}
static void SetErrorString(const std::string &errorString)
{
if (!errorString.empty())
{
std::ostringstream os;
os << "While calling symdiff interpreter\n";
std::string temp_string = os.str() + errorString;
PyErr_SetString(symdiff_exception, temp_string.c_str());
}
}
/**
Takes one argument, which is the command to evaluate
*/
static PyObject *
symdiffCmd(PyObject *, PyObject *args)
{
PyObject *returnObj = nullptr;
std::string errorString;
dsHelper::ret_pair tret = GetStringArgument(args);
if (tret.first)
{
dsHelper::ret_pair result;
result.first = false;
result = dsHelper::SymdiffEval(tret.second.string_);
if (!result.first)
{
errorString += result.second.string_;
}
else
{
returnObj = returnString(result.second.string_);
}
}
SetErrorString(errorString);
return returnObj;
}
static PyObject *
symdiffTableCmd(PyObject *, PyObject *args)
{
PyObject *returnObj = nullptr;
std::string errorString;
dsHelper::ret_pair tret = GetStringArgument(args);
if (tret.first)
{
dsHelper::ret_pair result;
result.first = false;
result = dsHelper::SymdiffEval(tret.second.string_);
if (!result.first)
{
errorString += result.second.string_;
}
else
{
ProcessOrderedTable pot;
pot.run(result.second.eqptr_);
// returnObj = returnString(result.second.string_);
OrderedTable_t table = pot.GetOrderedTable();
if (table.empty())
{
returnObj = returnNone();
}
else
{
returnObj = PyTuple_New(table.size());
for (size_t i = 0; i < table.size(); ++i)
{
const OrderedTableData &data = table[i];
PyObject *rowobj = PyTuple_New(5);
const std::string &name = EngineAPI::getName(data.ptr_);
const std::string &type = EngineAPI::getType(data.ptr_);
const std::string &value = data.value_;
const std::vector<size_t> &indexes = data.indexes_;
const std::vector<size_t> &references = data.references_;
PyObject *subobj;
subobj = returnString(name);
Py_INCREF(subobj);
PyTuple_SetItem(rowobj, 0, subobj);
subobj = returnString(type);
Py_INCREF(subobj);
PyTuple_SetItem(rowobj, 1, subobj);
subobj = returnTupleLong(indexes);
Py_INCREF(subobj);
PyTuple_SetItem(rowobj, 2, subobj);
subobj = returnTupleLong(references);
Py_INCREF(subobj);
PyTuple_SetItem(rowobj, 3, subobj);
subobj = returnString(value);
Py_INCREF(subobj);
PyTuple_SetItem(rowobj, 4, subobj);
Py_INCREF(rowobj);
PyTuple_SetItem(returnObj, i, rowobj);
}
}
}
}
SetErrorString(errorString);
return returnObj;
}
static PyObject *
modelListCmd(PyObject *, PyObject *args)
{
PyObject *returnObj = nullptr;
if (HasZeroArguments(args))
{
const ModelMap_t &model_list = Context::GetInstance().GetModelMap();
if (model_list.empty())
{
//// Return none
returnObj = returnNone();
}
else
{
returnObj = PyTuple_New(model_list.size());
Py_ssize_t i = 0;
for (ModelMap_t::const_iterator it = model_list.begin(); it != model_list.end(); ++it)
{
const std::string &model_name = (it->first);
PyObject *subobj = returnString(model_name);
Py_INCREF(subobj);
PyTuple_SetItem(returnObj, i, subobj);
++i;
}
}
}
return returnObj;
}
static PyObject *
subexpressionCmd(PyObject *, PyObject *args)
{
PyObject *returnObj = nullptr;
std::string errorString;
dsHelper::ret_pair result;
result.first = false;
if (HasZeroArguments(args))
{
SubExpr subexpr;
ModelMap_t &model_list = Context::GetInstance().GetModelMap();
subexpr.CreateSubexpressions(model_list);
errorString = subexpr.GetErrorString();
returnObj = returnNone();
}
SetErrorString(errorString);
return returnObj;
}
static PyObject *
removeZerosCmd(PyObject *, PyObject *args)
{
PyObject *returnObj = nullptr;
if (HasZeroArguments(args))
{
SubExpr subexpr;
ModelMap_t &model_list = Context::GetInstance().GetModelMap();
subexpr.RemoveZeros(model_list);
returnObj = returnNone();
}
return returnObj;
}
static PyObject *
orderedListCmd(PyObject *, PyObject *args)
{
std::string errorString;
PyObject *returnObj = nullptr;
StringVector_t model_vector_in;
if (GetStringArguments(args, model_vector_in))
{
ProcessModelOrder process;
const ModelMap_t &model_list = Context::GetInstance().GetModelMap();
const ModelNameVector_t &model_vector_out = process.GetModelVector(model_list, model_vector_in);
errorString = process.GetErrorString();
if (errorString.empty())
{
if (!model_vector_out.empty())
{
returnObj = PyTuple_New(model_vector_out.size());
Py_ssize_t i = 0;
for (ModelNameVector_t::const_iterator it = model_vector_out.begin(); it != model_vector_out.end(); ++it)
{
const std::string &model_name = *it;
PyObject *subobj = returnString(model_name);
Py_INCREF(subobj);
PyTuple_SetItem(returnObj, i, subobj);
++i;
}
}
else
{
returnObj = returnNone();
}
}
}
SetErrorString(errorString);
return returnObj;
}
static struct PyMethodDef symdiff_methods[] = {
{"symdiff", symdiffCmd, METH_VARARGS},
{"symdiff_table", symdiffTableCmd, METH_VARARGS},
{"model_list", modelListCmd, METH_VARARGS},
{"subexpression", subexpressionCmd, METH_VARARGS},
{"remove_zeros", removeZerosCmd, METH_VARARGS},
{"ordered_list", orderedListCmd, METH_VARARGS},
{nullptr, nullptr, 0}
};
extern "C" {
//http://docs.python.org/2/extending/extending.html
#if PY_MAJOR_VERSION >= 3
static int symdiff_traverse(PyObject *m, visitproc visit, void *arg) {
Py_VISIT(GETSTATE(m)->error);
return 0;
}
static int symdiff_clear(PyObject *m) {
Py_CLEAR(GETSTATE(m)->error);
return 0;
}
static struct PyModuleDef moduledef = {
PyModuleDef_HEAD_INIT,
"symdiff_py3",
nullptr,
sizeof(struct module_state),
symdiff_methods,
nullptr,
symdiff_traverse,
symdiff_clear,
nullptr
};
#define INITERROR return nullptr
DLL_PUBLIC PyObject *PyInit_symdiff_py3(void)
#else
#define INITERROR return
void DLL_PUBLIC initsymdiff_py2()
#endif
{
#if PY_MAJOR_VERSION >= 3
PyObject *m = PyModule_Create(&moduledef);
#else
PyObject *m = Py_InitModule("symdiff_py2", symdiff_methods);
#endif
if (m == nullptr)
{
INITERROR;
}
symdiff_exception = PyErr_NewException(const_cast<char *>("symdiff.SymdiffError"), nullptr, nullptr);
Py_INCREF(symdiff_exception);
PyModule_AddObject(m, "SymdiffError", symdiff_exception);
//https://www.python.org/dev/peps/pep-0396/
PyDict_SetItemString(PyModule_GetDict(m), "__version__", PyUnicode_FromString(SYMDIFF_VERSION_STRING));
#if PY_MAJOR_VERSION >=3
return m;
#endif
}
}
#if 0
static struct _inittab symdiffinittab[] =
{
{(char *)"symdiff", initsymdiff},
{(char *)nullptr, nullptr}
};
#endif
| 23.295964
| 113
| 0.664293
|
weatherhead99
|
c59350605a9dc39cfcb19c4be58ec462b7185c42
| 237
|
cpp
|
C++
|
srcs/server/io/bsd/queuehost.cpp
|
romi-project/RomiServerAlpha
|
51bc65e9b1feed1b43ab852dbee78bdf58609f23
|
[
"MIT"
] | null | null | null |
srcs/server/io/bsd/queuehost.cpp
|
romi-project/RomiServerAlpha
|
51bc65e9b1feed1b43ab852dbee78bdf58609f23
|
[
"MIT"
] | null | null | null |
srcs/server/io/bsd/queuehost.cpp
|
romi-project/RomiServerAlpha
|
51bc65e9b1feed1b43ab852dbee78bdf58609f23
|
[
"MIT"
] | null | null | null |
// The Romi Project
//
// @ File : queuehost.cpp
// @ Author : Tensiya(T2SU)
// @ Email : tsi@romi-project.net
// @ Since : 2022-03-18 15:23:05
//
#include "std.hpp"
#include "defines.hpp"
#include "server/io/bsd/queuehost.hpp"
| 19.75
| 38
| 0.624473
|
romi-project
|
c5989877959ff19f78aca76c05a3c3affd94af61
| 8,090
|
cpp
|
C++
|
src/main/resources/catalogs/socs/zynqps8/software/programs_pmu/pmu_monitor/src/interrupts/interrupt_handlers.cpp
|
DeanoC/overlord
|
e023083e117d89f7b8ea245f1277aa96098d2b06
|
[
"MIT"
] | null | null | null |
src/main/resources/catalogs/socs/zynqps8/software/programs_pmu/pmu_monitor/src/interrupts/interrupt_handlers.cpp
|
DeanoC/overlord
|
e023083e117d89f7b8ea245f1277aa96098d2b06
|
[
"MIT"
] | null | null | null |
src/main/resources/catalogs/socs/zynqps8/software/programs_pmu/pmu_monitor/src/interrupts/interrupt_handlers.cpp
|
DeanoC/overlord
|
e023083e117d89f7b8ea245f1277aa96098d2b06
|
[
"MIT"
] | null | null | null |
#include "core/core.h"
#include "hw/reg_access.h"
#include "hw/memory_map.h"
#include "hw_regs/pmu/pmu_iomodule.h"
#include "hw_regs/pmu/pmu_lmb_bram.h"
#include "hw_regs/ipi.h"
#include "dbg/raw_print.h"
#include "interrupt_handlers.hpp"
#include "../rom_extensions.h"
#include "../os/ipi3_os_server.hpp"
#include "gic_proxy.hpp"
void IPI0_Handler(Interrupts::Name irq_name) {
uint32_t isr = HW_REG_GET(IPI, PMU_0_ISR);
// write to clear to inform IPI PMU buffer is free to use now
HW_REG_SET(IPI, PMU_0_ISR, isr);
// debug_printf ("IPI0_Handler 0x%lx\n", isr);
RomServiceTable[REN_IPI0]();
}
void IPI3_Handler(Interrupts::Name irq_name) {
uint32_t isr = HW_REG_GET(IPI, PMU_3_ISR);
// raw_debug_printf ("irq_name 0x%x IPI3_Handler 0x%lx\n", irq_name, isr);
for (uint32_t name = 0x80000000U; name != 0; name >>= 1) {
if ((isr & name) == 0) {
continue;
}
IPI3_OsServer::Handler((IPI_Channel) name);
}
// write to clear interrupt
HW_REG_SET(IPI, PMU_3_ISR, isr);
}
void CorrectableECCErrors_Handler(Interrupts::Name irq_name) {
// write to clear status bit
HW_REG_SET_BIT(PMU_LMB_BRAM, ECC_STATUS, CE);
}
void GPI0_Handler(Interrupts::Name irq_name) {
uint32_t gpi0 = HW_REG_GET(PMU_IOMODULE, GPI0);
// TODO use find first bit
for (uint32_t name = 0x80000000U; name != 0; name >>= 1) {
if ((gpi0 & name) == 0) continue;
raw_debug_printf("GPI0_Handler 0x%lx\n", name);
switch (name) {
case PMU_IOMODULE_GPI0_RFT_ECC_FATAL_ERR: break;
case PMU_IOMODULE_GPI0_RFT_VOTER_ERR: break;
case PMU_IOMODULE_GPI0_RFT_COMPARE_ERR_23: break;
case PMU_IOMODULE_GPI0_RFT_COMPARE_ERR_13: break;
case PMU_IOMODULE_GPI0_RFT_COMPARE_ERR_12: break;
case PMU_IOMODULE_GPI0_RFT_LS_MISMATCH_23_B: break;
case PMU_IOMODULE_GPI0_RFT_LS_MISMATCH_13_B: break;
case PMU_IOMODULE_GPI0_RFT_LS_MISMATCH_12_B: break;
case PMU_IOMODULE_GPI0_RFT_MISMATCH_STATE: break;
case PMU_IOMODULE_GPI0_RFT_MISMATCH_CPU: break;
case PMU_IOMODULE_GPI0_RFT_SLEEP_RESET: break;
case PMU_IOMODULE_GPI0_RFT_LS_MISMATCH_23_A: break;
case PMU_IOMODULE_GPI0_RFT_LS_MISMATCH_13_A: break;
case PMU_IOMODULE_GPI0_RFT_LS_MISMATCH_12_A: break;
case PMU_IOMODULE_GPI0_NFT_ECC_FATAL_ERR: break;
case PMU_IOMODULE_GPI0_NFT_VOTER_ERR: break;
case PMU_IOMODULE_GPI0_NFT_COMPARE_ERR_23: break;
case PMU_IOMODULE_GPI0_NFT_COMPARE_ERR_13: break;
case PMU_IOMODULE_GPI0_NFT_COMPARE_ERR_12: break;
case PMU_IOMODULE_GPI0_NFT_LS_MISMATCH_23_B: break;
case PMU_IOMODULE_GPI0_NFT_LS_MISMATCH_13_B: break;
case PMU_IOMODULE_GPI0_NFT_LS_MISMATCH_12_B: break;
case PMU_IOMODULE_GPI0_NFT_MISMATCH_STATE: break;
case PMU_IOMODULE_GPI0_NFT_MISMATCH_CPU: break;
case PMU_IOMODULE_GPI0_NFT_SLEEP_RESET: break;
case PMU_IOMODULE_GPI0_NFT_LS_MISMATCH_23_A: break;
case PMU_IOMODULE_GPI0_NFT_LS_MISMATCH_13_A: break;
case PMU_IOMODULE_GPI0_NFT_LS_MISMATCH_12_A: break;
default: break;
}
}
}
void GPI1_Handler(Interrupts::Name irq_name) {
uint32_t gpi1 = HW_REG_GET(PMU_IOMODULE, GPI1);
// raw_debug_printf("GPI1 0x%lx\n", HW_REG_GET(PMU_IOMODULE, GPI1));
// TODO use find first bit
for (uint32_t name = 0x80000000U; name != 0; name >>= 1) {
if ((gpi1 & name) == 0) continue;
switch (name) {
case PMU_IOMODULE_GPI1_APB_AIB_ERROR: RomServiceTable[REN_APBAIBERR]();
break;
case PMU_IOMODULE_GPI1_AXI_AIB_ERROR: RomServiceTable[REN_AXIAIBERR]();
break;
case PMU_IOMODULE_GPI1_ERROR_2: RomServiceTable[REN_ERROR2]();
break;
case PMU_IOMODULE_GPI1_ERROR_1: RomServiceTable[REN_ERROR1]();
break;
case PMU_IOMODULE_GPI1_ACPU_3_DBG_PWRUP: RomServiceTable[REN_ACPU3DBGPWRUP]();
break;
case PMU_IOMODULE_GPI1_ACPU_2_DBG_PWRUP: RomServiceTable[REN_ACPU2DBGPWRUP]();
break;
case PMU_IOMODULE_GPI1_ACPU_1_DBG_PWRUP: RomServiceTable[REN_ACPU1DBGPWRUP]();
break;
case PMU_IOMODULE_GPI1_ACPU_0_DBG_PWRUP: RomServiceTable[REN_ACPU0DBGPWRUP]();
break;
case PMU_IOMODULE_GPI1_FPD_WAKE_GIC_PROXY:
GIC_Proxy(); break;
case PMU_IOMODULE_GPI1_MIO_WAKE_5: RomServiceTable[REN_MIO5WAKE]();
break;
case PMU_IOMODULE_GPI1_MIO_WAKE_4: RomServiceTable[REN_MIO4WAKE]();
break;
case PMU_IOMODULE_GPI1_MIO_WAKE_3: RomServiceTable[REN_MIO3WAKE]();
break;
case PMU_IOMODULE_GPI1_MIO_WAKE_2: RomServiceTable[REN_MIO2WAKE]();
break;
case PMU_IOMODULE_GPI1_MIO_WAKE_1: RomServiceTable[REN_MIO1WAKE]();
break;
case PMU_IOMODULE_GPI1_MIO_WAKE_0: RomServiceTable[REN_MIO0WAKE]();
break;
case PMU_IOMODULE_GPI1_DAP_RPU_WAKE: RomServiceTable[REN_DAPRPUWAKE]();
break;
case PMU_IOMODULE_GPI1_DAP_FPD_WAKE: RomServiceTable[REN_DAPFPDWAKE]();
break;
case PMU_IOMODULE_GPI1_USB_1_WAKE: RomServiceTable[REN_USB1WAKE]();
break;
case PMU_IOMODULE_GPI1_USB_0_WAKE: RomServiceTable[REN_USB0WAKE]();
break;
case PMU_IOMODULE_GPI1_R5_1_WAKE: RomServiceTable[REN_R5F1WAKE]();
break;
case PMU_IOMODULE_GPI1_R5_0_WAKE: RomServiceTable[REN_R5F0WAKE]();
break;
case PMU_IOMODULE_GPI1_ACPU_3_WAKE: RomServiceTable[REN_ACPU3WAKE]();
break;
case PMU_IOMODULE_GPI1_ACPU_2_WAKE: RomServiceTable[REN_ACPU2WAKE]();
break;
case PMU_IOMODULE_GPI1_ACPU_1_WAKE: RomServiceTable[REN_ACPU1WAKE]();
break;
case PMU_IOMODULE_GPI1_ACPU_0_WAKE: RomServiceTable[REN_ACPU0WAKE]();
break;
default: break;
}
}
// raw_debug_printf("GPI1 0x%lx\n", HW_REG_GET(PMU_IOMODULE, GPI1));
}
void GPI2_Handler(Interrupts::Name irq_name) {
uint32_t gpi2 = HW_REG_GET(PMU_IOMODULE, GPI2);
// TODO use find first bit
for (uint32_t name = 0x80000000U; name != 0; name >>= 1) {
if ((gpi2 & name) == 0) {
continue;
}
raw_debug_printf("GPI2_Handler 0x%lx\n", name);
switch (name) {
case PMU_IOMODULE_GPI2_ACPU_0_SLEEP: RomServiceTable[REN_ACPU0SLEEP]();
break;
case PMU_IOMODULE_GPI2_ACPU_1_SLEEP: RomServiceTable[REN_ACPU1SLEEP]();
break;
case PMU_IOMODULE_GPI2_ACPU_2_SLEEP: RomServiceTable[REN_ACPU2SLEEP]();
break;
case PMU_IOMODULE_GPI2_ACPU_3_SLEEP: RomServiceTable[REN_ACPU3SLEEP]();
break;
case PMU_IOMODULE_GPI2_R5_0_SLEEP: RomServiceTable[REN_R5F0SLEEP]();
break;
case PMU_IOMODULE_GPI2_R5_1_SLEEP: RomServiceTable[REN_R5F1SLEEP]();
break;
case PMU_IOMODULE_GPI2_DBG_RCPU0_RST_REQ: RomServiceTable[REN_RCPU0_DBG_RST]();
break;
case PMU_IOMODULE_GPI2_DBG_RCPU1_RST_REQ: RomServiceTable[REN_RCPU1_DBG_RST]();
break;
case PMU_IOMODULE_GPI2_CP_ACPU0_RST_REQ: RomServiceTable[REN_ACPU0_CP_RST]();
break;
case PMU_IOMODULE_GPI2_CP_ACPU1_RST_REQ: RomServiceTable[REN_ACPU1_CP_RST]();
break;
case PMU_IOMODULE_GPI2_CP_ACPU2_RST_REQ: RomServiceTable[REN_ACPU2_CP_RST]();
break;
case PMU_IOMODULE_GPI2_CP_ACPU3_RST_REQ: RomServiceTable[REN_ACPU3_CP_RST]();
break;
case PMU_IOMODULE_GPI2_DBG_ACPU0_RST_REQ: RomServiceTable[REN_ACPU0_DBG_RST]();
break;
case PMU_IOMODULE_GPI2_DBG_ACPU1_RST_REQ: RomServiceTable[REN_ACPU1_DBG_RST]();
break;
case PMU_IOMODULE_GPI2_DBG_ACPU2_RST_REQ: RomServiceTable[REN_ACPU2_DBG_RST]();
break;
case PMU_IOMODULE_GPI2_DBG_ACPU3_RST_REQ: RomServiceTable[REN_ACPU3_DBG_RST]();
break;
case PMU_IOMODULE_GPI2_VCC_AUX_DISCONNECT: RomServiceTable[REN_VCCAUX_DISCONNECT]();
break;
case PMU_IOMODULE_GPI2_VCC_INT_DISCONNECT: RomServiceTable[REN_VCCINT_DISCONNECT]();
break;
case PMU_IOMODULE_GPI2_VCC_INT_FP_DISCONNECT: RomServiceTable[REN_VCCINTFP_DISCONNECT]();
break;
default: break;
}
}
}
void GPI3_Handler(Interrupts::Name irq_name) {
uint32_t gpi3 = HW_REG_GET(PMU_IOMODULE, GPI3);
// TODO use find first bit
for (uint32_t name = 0x80000000U; name != 0; name >>= 1) {
if ((gpi3 & name) == 0) {
continue;
}
raw_debug_printf("GPI3_Handler 0x%lx\n", name);
switch (name) {
default: break;
}
}
}
void RTCAlarms_Handler(Interrupts::Name irq_name) {
}
void RTCSeconds_Handler(Interrupts::Name irq_name) {
static bool tick = true;
if(tick) {
raw_debug_print("tick\n");
tick = false;
} else {
raw_debug_print("tock\n");
tick = true;
}
}
| 34.425532
| 92
| 0.766749
|
DeanoC
|
c59dc90ef8659becd50137e3cfd1feebe3e0256b
| 869
|
cpp
|
C++
|
projects/engine/src/rendering/renderer.cpp
|
zCubed3/Tilt
|
e9c68b96eb8dea47b70ba734bc2ef4cffc30a2af
|
[
"MIT"
] | null | null | null |
projects/engine/src/rendering/renderer.cpp
|
zCubed3/Tilt
|
e9c68b96eb8dea47b70ba734bc2ef4cffc30a2af
|
[
"MIT"
] | null | null | null |
projects/engine/src/rendering/renderer.cpp
|
zCubed3/Tilt
|
e9c68b96eb8dea47b70ba734bc2ef4cffc30a2af
|
[
"MIT"
] | null | null | null |
#include <rendering/renderer.hpp>
#include <stdexcept>
Renderer::Renderer(RI_Impl *ri) {
if (ri == nullptr)
throw std::runtime_error("RI_Impl was null!");
this->ri = ri;
}
//
// Start
//
#include <GLFW/glfw3.h>
void Renderer::Start() {
ri->setup_Initial();
ri->setup_BeforeWindowCreate();
// TODO: Allow user to change window parameters in config
glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
window = glfwCreateWindow(800, 600, "Tilt", nullptr, nullptr);
ri->setup_AfterWindowCreate(window);
ri->imgui_Setup(window);
}
//
// Rendering
//
void Renderer::BeginRender() {
ri->draw_Clear();
}
void Renderer::EndRender() {
}
//
// ImGui rendering
//
void Renderer::BeginImGui() {
ri->imgui_Begin();
}
void Renderer::EndImGui() {
ri->imgui_End();
}
void Renderer::Present() {
ri->draw_Present(window);
}
| 16.092593
| 66
| 0.649022
|
zCubed3
|
c5ac3cd8e6a0fe97944f3ae0fe570786d058e944
| 1,011
|
hpp
|
C++
|
gearoenix/dx11/buffer/gx-dx11-buf-mesh.hpp
|
Hossein-Noroozpour/gearoenix
|
c8fa8b8946c03c013dad568d6d7a97d81097c051
|
[
"BSD-Source-Code"
] | 35
|
2018-01-07T02:34:38.000Z
|
2022-02-09T05:19:03.000Z
|
gearoenix/dx11/buffer/gx-dx11-buf-mesh.hpp
|
Hossein-Noroozpour/gearoenix
|
c8fa8b8946c03c013dad568d6d7a97d81097c051
|
[
"BSD-Source-Code"
] | 111
|
2017-09-20T09:12:36.000Z
|
2020-12-27T12:52:03.000Z
|
gearoenix/dx11/buffer/gx-dx11-buf-mesh.hpp
|
Hossein-Noroozpour/gearoenix
|
c8fa8b8946c03c013dad568d6d7a97d81097c051
|
[
"BSD-Source-Code"
] | 5
|
2020-02-11T11:17:37.000Z
|
2021-01-08T17:55:43.000Z
|
#ifndef GEAROENIX_DX11_BUFFER_MESH_HPP
#define GEAROENIX_DX11_BUFFER_MESH_HPP
#include "../../core/gx-cr-build-configuration.hpp"
#ifdef GX_USE_DIRECTX11
#include "../../core/sync/gx-cr-sync-end-caller.hpp"
#include "../../render/buffer/gx-rnd-buf-mesh.hpp"
#include <d3d11.h>
namespace gearoenix {
namespace dx11 {
class Engine;
namespace buffer {
class Mesh : public render::buffer::Mesh {
public:
private:
ID3D11Buffer* vb = nullptr;
ID3D11Buffer* ib = nullptr;
unsigned int ic = 0;
const unsigned int stride;
public:
Mesh(
unsigned int vertex_elements_count,
system::stream::Stream* format, Engine* e,
core::sync::EndCaller<core::sync::EndCallerIgnore> c);
~Mesh();
void bind();
void draw();
};
} // namespace buffer
} // namespace dx11
} // namespace gearoenix
#endif
#endif // GEAROENIX_DX11_BUFFER_MESH_HPP
| 29.735294
| 70
| 0.603363
|
Hossein-Noroozpour
|
c5b032aeb1916e2632a9eb4b88fe684035e55c49
| 24,118
|
cpp
|
C++
|
0.55.402/common/CCryptBase.cpp
|
Jhobean/Source-Archive
|
ab24ba44ffd34c329accedb980699e94c196fceb
|
[
"Apache-2.0"
] | 2
|
2020-12-22T17:03:14.000Z
|
2021-07-31T23:59:05.000Z
|
0.55.402/common/CCryptBase.cpp
|
Jhobean/Source-Archive
|
ab24ba44ffd34c329accedb980699e94c196fceb
|
[
"Apache-2.0"
] | null | null | null |
0.55.402/common/CCryptBase.cpp
|
Jhobean/Source-Archive
|
ab24ba44ffd34c329accedb980699e94c196fceb
|
[
"Apache-2.0"
] | 4
|
2021-04-21T19:43:48.000Z
|
2021-10-07T00:38:23.000Z
|
//
// CCryptBase.cpp
// Copyright Menace Software (www.menasoft.com).
// Common for client and server.
//
#ifdef GRAY_AGENT
#include "../grayagent/stdafx.h"
#include "../grayagent/grayagent.h"
#else
#include "graycom.h"
#include "graymul.h"
#include "grayproto.h"
#endif
////////////////////////////////////////////////////////////////////
bool CCryptBase::SetClientVerEnum( int iVer )
{
switch ( iVer )
{
case 0x0: // This turns off crypt for sphereclient.
break;
// VER=3.0.0a // 03/20/2001 @ 02cd30, sep = 81f2
// VER=3.0.0c // 04/04/2001 @
case 1:
iVer = 0x300007;
case 0x300000:
case 0x300001:
case 0x300003:
case 0x300007:
m_MasterHi = 0x2d93a5fd;
m_MasterLo = 0xa3dd527f;
break;
// VER=2.0.3 // 10/17/2000 @ 0c0ed8, sep = 81f2
case 2:
iVer = 0x200030;
case 0x200030:
m_MasterHi = 0x2dbbb7cd;
m_MasterLo = 0xa3c95e7f;
break;
case 3:
iVer = 0x400010;
case 0x400010: // 4.0.1
m_MasterHi = 0x2E2BA7ED;
m_MasterLo = 0xA2017E7F ;
case 4:
iVer = 0x400000;
case 0x400000: // 4.0.0
m_MasterHi = 0x2E13A5FD;
m_MasterLo = 0xA21D527F;
break;
case 5:
iVer = 0x300080;
case 0x300080: // 3.0.8
m_MasterHi = 0x2C53257D;
m_MasterLo = 0xA33F527F;
break;
case 6:
iVer = 0x300070;
case 0x300070: // 3.0.7
m_MasterHi = 0x2C1BC78D;
m_MasterLo = 0xA31BFE7F;
break;
case 7:
iVer = 0x300060;
case 0x300060: // 3.0.6
m_MasterHi = 0x2CC3ED9D;
m_MasterLo = 0xA374227F;
break;
case 8:
iVer = 0x300050;
case 0x300050: // 3.0.5d
m_MasterHi = 0x2C8B97AD;
m_MasterLo = 0xA350DE7F;
break;
case 9:
iVer = 0x300040;
case 0x300040: // 3.0.4
m_MasterHi = 0x2D7385BD;
m_MasterLo = 0xA3AD127F;
break;
case 10:
iVer = 0x300030;
case 0x300030: // 3.0.3
m_MasterHi = 0x2D3BB7CD;
m_MasterLo = 0xA3895E7F;
break;
// VER=3.0.2b
case 11:
case 0x300020:
case 0x300022: // 06/12/2001 @ 02cef0
iVer = 0x300011;
m_MasterHi = 0x2DE3ADDD;
m_MasterLo = 0xA3E5227F;
break;
// VER=3.0.1a
case 12:
case 0x300010:
case 0x300011: // 05/15/2001 @ 02d140,
iVer = 0x300011;
m_MasterHi = 0x2DABA7ED;
m_MasterLo = 0xA3C17E7F;
break;
// VER=2.0.8k // 03/10/2001 @ 02ce30, sep = 81f2
case 13:
iVer = 0x20008b;
case 0x200080:
case 0x20008b:
m_MasterHi = 0x2cd3257d;
m_MasterLo = 0xa37f527f;
break;
// VER=2.0.7 // 02/13/2001 @ 02cb39, sep = 81f2
case 14:
iVer = 0x200070;
case 0x200070:
m_MasterHi = 0x2c9bc78d;
m_MasterLo = 0xa35bfe7f;
break;
// VER=2.0.6c // 01/28/2001 @ 02c720, sep = 81f2
case 15:
iVer = 0x200060;
case 0x200060:
m_MasterHi = 0x2c43ed9d;
m_MasterLo = 0xa334227f;
break;
// VER=2.0.4 // 12/28/2000 @ 025bd0, sep = 81f2
case 16:
iVer = 0x200040;
case 0x200040:
m_MasterHi = 0x2df385bd;
m_MasterLo = 0xa3ed127f;
break;
// VER=2.0.2 // 9/29/2000 @ 0c0837,
case 17:
iVer = 0x200020;
case 0x200020:
m_MasterHi = 0x2d63addd;
m_MasterLo = 0xa3a5227f;
break;
// VER=2.0.1 // 9/27/2000 @ 0c0aa7,0c0aad
case 18:
iVer = 0x200010;
case 0x200010:
m_MasterHi = 0x2d2ba7ed;
m_MasterLo = 0xa3817e7f;
break;
// VER=2.0.0 // 4/19/2000 by UOX team
case 19:
iVer = 0x200005;
case 0x200005: // VER=2.0.0e = 6/27/2000 @ 0bd657 and 0bd65d
case 0x200004:
case 0x200003: // VER=2.0.0c
m_MasterHi = 0x2d13a5fd;
m_MasterLo = 0xa39d527f;
break;
case 20:
iVer = 0x200002;
case 0x200002: // VER=2.0.0b
case 0x200001:
case 0x200000: // VER=2.0.0 = 4/17/2000
m_MasterHi = 0x2d13a5fd;
m_MasterLo = 0xa39d527f;
break;
// VER=1.26.4 // 1/27/2000 by Westy
case 21:
iVer = 0x126040;
case 0x126040: // VER=1.26.4 = 1/27/00 by Westy
m_MasterHi = 0x32750719;
m_MasterLo = 0x0a2d100b;
break;
// VER=1.26.3 // 1/18/2000 by Westy and Beosil (beosil@mcb.at)
case 22:
iVer = 0x126030;
case 0x126030: // VER=1.26.3 = 1/18/00 by Westy and Beosil (beosil@mcb.at)
m_MasterHi = 0x323d3569;
m_MasterLo = 0x0a095c0b;
break;
// VER=1.26.2 // 11/23/99 by Westy and Beosil (beosil@mcb.at)
case 23:
iVer = 0x126020;
case 0x126020: // 11/23/99 by Westy and Beosil (beosil@mcb.at)
m_MasterHi = 0x32e52f79;
m_MasterLo = 0x0a65200b;
break;
// VER=1.26.1 // 09/09/99 by Westy and Beosil (beosil@mcb.at)
case 24:
iVer = 0x126010;
case 0x126010: // 09/09/99 by Westy and Beosil (beosil@mcb.at)
m_MasterHi = 0x32ad2549;
m_MasterLo = 0x0a417c0b;
break;
// VER=1.26.0 // 08/35/99 by Westy and Beosil (beosil@mcb.at)
case 25:
iVer = 0x126000;
case 0x126000: // 08/35/99 by Westy and Beosil (beosil@mcb.at)
m_MasterHi = 0x32952759;
m_MasterLo = 0x0a5d500b;
break;
// VER=1.25.37 // 03/18/99 by Westy and Beosil (beosil@mcb.at)
case 26:
iVer = 0x125370;
case 0x125370: // 03/18/99 by Westy and Beosil (beosil@mcb.at)
m_MasterHi = 0x378757DC;
m_MasterLo = 0x0595DCC6;
break;
// VER=1.25.36 // 12/1/98 by Beosil (beosil@mcb.at)
#define CLIKEY_12536_HI1 0x387fc5cc
#define CLIKEY_12536_HI2 0x35ce9581
#define CLIKEY_12536_HI3 0x07afcc37
#define CLIKEY_12536_LO1 0x021510c6
#define CLIKEY_12536_LO2 0x4c3a1353
#define CLIKEY_12536_LO3 0x16ef783f
case 27:
iVer = 0x125360;
case 0x125360: // 12/1/98 by Beosil (beosil@mcb.at)
// Special multi key.
m_MasterHi = CLIKEY_12536_HI1;
m_MasterLo = CLIKEY_12536_LO1;
break;
// VER=1.25.35 // Released on the T2A CD.
case 28:
iVer = 0x125350;
case 0x125350: // Released on the T2A CD.
m_MasterHi = 0x383477BC;
m_MasterLo = 0x02345CC6;
break;
// VER=1.25.34
case 0x125340:
m_MasterHi = 0x38ECEDAC;
m_MasterLo = 0x025720C6;
break;
// VER=1.25.33
case 0x125330:
m_MasterHi = 0x38A5679C;
m_MasterLo = 0x02767CC6;
break;
// VER=1.25.32
case 0x125320:
m_MasterHi = 0x389DE58C;
m_MasterLo = 0x026950C6;
break;
// VER=1.25.31
case 0x125310:
m_MasterHi = 0x395A647C;
m_MasterLo = 0x0297BCC6;
break;
default:
if ( ! m_fIgnition )
{
m_iClientVersion = -1;
return( false );
}
}
m_iClientVersion = iVer;
if ( m_fInit ) // must re-init if we are changing the crypt code.
{
Init();
}
return( true );
}
void CCryptBase::Init( DWORD dwIP )
{
// Generate the decrypt key based on the ip we get from the client.
// The client will use the key of 127.0.0.1 randomly with it's real ip for no good reason.
m_fInit = true;
m_seed = dwIP; // 0x7f00001 = 127.0.0.1
if ( ! m_seed ) // Don't bother with encryption. (new client)
{
m_iClientVersion = 0;
}
else
{
m_CryptMaskLo = (((~m_seed) ^ 0x00001357) << 16) | ((( m_seed) ^ 0xffffaaaa) & 0x0000ffff);
m_CryptMaskHi = ((( m_seed) ^ 0x43210000) >> 16) | (((~m_seed) ^ 0xabcdffff) & 0xffff0000);
}
}
TCHAR* CCryptBase::WriteClientVer( TCHAR * pszVersion ) const
{
int iClientVersion = GetClientVer();
int iLen = sprintf( pszVersion, _TEXT( "%s%x.%x.%x" ),
GetClientIgnition() ? "I" : "",
iClientVersion/0x100000,
(iClientVersion/0x1000)%0x100,
(iClientVersion/0x10)%0x100 );
if ( iClientVersion & 0x0f )
{
pszVersion[iLen++] = ( iClientVersion & 0x0f ) + 'a' - 1;
pszVersion[iLen] = '\0';
}
return( pszVersion );
}
bool CCryptBase::SetClientVer( LPCTSTR pszVersion )
{
// They have this annoying habit of putting letters at the end of the version string.
// 2.0.0d for example.
if ( pszVersion == NULL || *pszVersion == '\0' )
return false;
SetClientIgnition( false );
int iVer = 0;
int iPoint = 0;
int iDigPoint = 0;
for ( int i=0; true; i++ )
{
TCHAR ch = pszVersion[i];
if ( isdigit(ch))
{
iVer *= 0x10;
iVer += ( ch - '0' );
iDigPoint ++;
continue;
}
if ( iPoint )
{
if ( iDigPoint == 0 )
{
iVer *= 0x100;
}
else if ( iDigPoint == 1 )
{
int iTmp = iVer & 0x0f;
iVer &= ~0x0f;
iVer *= 0x10;
iVer += iTmp;
}
}
else
{
if ( i == 0 && tolower(ch) == 'i' )
{
SetClientIgnition( true );
continue;
}
}
if ( ch == '.' )
{
if ( ++iPoint > 2 )
{
iVer *= 0x10;
break;
}
iDigPoint = 0;
continue;
}
if ( ! iPoint && ! isalpha(ch))
{
iVer *= 0x10;
break;
}
while ( iPoint< 2 )
{
iVer *= 0x100;
iPoint++;
}
// last char digit slot.
iVer *= 0x10;
if ( isalpha(ch))
{
iVer += ( tolower(ch) - 'a' ) + 1;
}
break;
}
m_fInit = false;
if ( ! SetClientVerEnum( iVer ))
{
DEBUG_ERR(( "Unsupported ClientVersion '%s'. Use Ignition?\n", pszVersion ));
return( false );
}
return( true );
}
void CCryptBase::Decrypt( BYTE * pOutput, const BYTE * pInput, int iLen )
{
// In previous versions (<12600) decrypt and encrypt are the same.
ASSERT( m_fInit );
if ( ! m_fIgnition )
{
// Old fashioned rotary crypt stuff.
if ( GetClientVer() >= 0x125370 )
{
for ( int i=0; i<iLen; i++ )
{
pOutput[i] = pInput[i] ^ (BYTE) m_CryptMaskLo;
DWORD MaskLo = m_CryptMaskLo;
DWORD MaskHi = m_CryptMaskHi;
m_CryptMaskLo = ((MaskLo >> 1) | (MaskHi << 31)) ^ m_MasterLo;
MaskHi = ((MaskHi >> 1) | (MaskLo << 31)) ^ m_MasterHi;
m_CryptMaskHi = ((MaskHi >> 1) | (MaskLo << 31)) ^ m_MasterHi;
}
return;
}
if ( GetClientVer() == 0x125360 )
{
for ( int i=0; i<iLen; i++ )
{
pOutput[i] = pInput[i] ^ (BYTE) m_CryptMaskLo;
DWORD MaskLo = m_CryptMaskLo;
DWORD MaskHi = m_CryptMaskHi;
m_CryptMaskHi =
(m_MasterHi >> ((5 * MaskHi * MaskHi) & 0xff))
+ (MaskHi * m_MasterHi)
+ (MaskLo * MaskLo * CLIKEY_12536_HI2)
+ CLIKEY_12536_HI3;
m_CryptMaskLo =
(m_MasterLo >> ((3 * MaskLo * MaskLo) & 0xff))
+ (MaskLo * m_MasterLo)
- (m_CryptMaskHi * m_CryptMaskHi * CLIKEY_12536_LO2)
+ CLIKEY_12536_LO3;
}
return;
}
if ( GetClientVer() ) // GRAY_CLIENT_VER <= 0x125350
{
for ( int i=0; i<iLen; i++ )
{
pOutput[i] = pInput[i] ^ (BYTE) m_CryptMaskLo;
DWORD MaskLo = m_CryptMaskLo;
DWORD MaskHi = m_CryptMaskHi;
m_CryptMaskLo = ((MaskLo >> 1) | (MaskHi << 31)) ^ m_MasterLo;
m_CryptMaskHi = ((MaskHi >> 1) | (MaskLo << 31)) ^ m_MasterHi;
}
return;
}
}
if ( pOutput != pInput )
{
memcpy( pOutput, pInput, iLen );
}
}
void CCryptBase::Encrypt( BYTE * pOutput, const BYTE * pInput, int iLen )
{
Decrypt( pOutput, pInput, iLen );
}
CCryptBase::CCryptBase()
{
m_fInit = false;
m_fIgnition = false;
SetClientVerEnum(1); // default version.
}
//////////////////////////////////////////
#if 0
const WORD g_Packet_Lengths[XCMD_QTY] =
{
// @010e700 in 2.0.0
// if it's == 0xFFFF then it's variable len, or >= 08000
// else it's fixed to what ever the value is.
0x0068, //XCMD_Create
0x0005, //
0x0007, //XCMD_Walk
0xFFFF, //XCMD_Talk
0x0002, //
0x0005, //XCMD_Attack
0x0005, //XCMD_DClick
0x0007, //XCMD_ItemPickupReq
0x000E, //XCMD_ItemDropReq
0x0005, //XCMD_Click
0x000B, //
0x010A, //
0xFFFF, //
0x0003, //
0xFFFF, //
0x003D, //
0x00D7, // 0x10
0xFFFF, //XCMD_Status
0xFFFF, //XCMD_ExtCmd
0x000A, //XCMD_ItemEquipReq
0x0006, //XCMD_GMToolMsg
0x0009, //XCMD_Follow
0x0001, //
0xFFFF, //
0xFFFF, //
0xFFFF, //
0xFFFF, //XCMD_Put
0x0025, //XCMD_Start
0xFFFF, //XCMD_Speak
0x0005, //XCMD_Remove
0x0004, //
0x0008, //
0x0013, //XCMD_View
0x0008, //XCMD_WalkCancel
0x0003, //XCMD_WalkAck
0x001A, //XCMD_DragAnim
0x0007, //XCMD_ContOpen
0x0014, //XCMD_ContAdd
0x0005, //XCMD_Kick
0x0002, //XCMD_DragCancel
0x0005, //XCMD_ClearSquare
0x0001, //XCMD_Unk29
0x0005, //
0x0002, //
0x0002, //XCMD_DeathMenu
0x0011, //
0x000F, //XCMD_ItemEquip
0x000A, //XCMD_Fight
0x0005, // 0x30
0x0001, //
0x0002, //
0x0002, //XCMD_Pause
0x000A, //XCMD_CharStatReq
0x028D, //
0xFFFF, //
0x0008, //
0x0007, //XCMD_PathFind
0x0009, //XCMD_ChangeGroup
0xFFFF, //XCMD_Skill
0xFFFF, //XCMD_VendorBuy
0xFFFF, //XCMD_Content
0x0002, //XCMD_Unk3d
0x0025, //
0xFFFF, //
0x00C9, // 0x40
0xFFFF, //
0xFFFF, //
0x0229, //
0x02C9, //
0x0005, //
0xFFFF, //
0x000B, //
0x0049, //
0x005D, //
0x0005, //
0x0009, //
0xFFFF, //
0xFFFF, //
0x0006, //XCMD_LightPoint
0x0002, //XCMD_Light
0xFFFF, // 0x50
0xFFFF, //
0xFFFF, //
0x0002, //XCMD_IdleWarn
0x000C, //XCMD_Sound
0x0001, //XCMD_ReDrawAll
0x000B, //XCMD_MapEdit
0x006E, //
0x006A, //
0xFFFF, //
0xFFFF, //
0x0004, //XCMD_Time
0x0002, //
0x0049, //XCMD_CharPlay
0xFFFF, //
0x0031, //
0x0005, // 0x60
0x0009, //
0x000F, //
0x000D, //
0x0001, //
0x0004, //XCMD_Weather
0xFFFF, //XCMD_BookPage
0x0015, //
0xFFFF, //
0xFFFF, //XCMD_Options
0x0003, //
0x0009, //
0x0013, //XCMD_Target
0x0003, //XCMD_PlayMusic
0x000E, //XCMD_CharAction
0xFFFF, //XCMD_SecureTrade
0x001C, //XCMD_Effect
0xFFFF, //XCMD_BBoard
0x0005, //XCMD_War
0x0002, //XCMD_Ping
0xFFFF, //XCMD_VendOpenBuy
0x0023, //XCMD_CharName
0x0010, //XCMD_ZoneChange
0x0011, //XCMD_CharMove
0xFFFF, //XCMD_Char
0x0009, //
0xFFFF, //
0x0002, //
0xFFFF, //XCMD_MenuItems
0x000D, //XCMD_MenuChoice
0x0002, //
0xFFFF, //
0x003E, //XCMD_ServersReq
0xFFFF, //XCMD_CharList3
0x0002, //XCMD_LogBad
0x0027, //XCMD_CharDelete
0x0045, //
0x0002, //XCMD_DeleteBad
0xFFFF, //XCMD_CharList2
0xFFFF, //
0x0042, //XCMD_PaperDoll
0xFFFF, //XCMD_CorpEquip
0xFFFF, //
0xFFFF, //XCMD_GumpTextDisp
0x000B, //XCMD_Relay
0xFFFF, //
0xFFFF, //
0xFFFF, //
0x0013, //XCMD_MapDisplay
0x0041, //XCMD_CharListReq
0xFFFF, //
0x0063, //XCMD_BookOpen
0xFFFF, //
0x0009, //XCMD_DyeVat
0xFFFF, //
0x0002, //XCMD_WalkForce
0xFFFF, //
0x001A, //XCMD_TargetMulti
0xFFFF, //XCMD_Prompt
0x0102, //XCMD_HelpPage
0x0135, //
0x0033, //
0xFFFF, //XCMD_VendOpenSell
0xFFFF, //XCMD_VendorSell
0x0003, //XCMD_ServerSelect
0x0009, //XCMD_StatChngStr
0x0009, //XCMD_StatChngInt
0x0009, //XCMD_StatChngDex
0x0095, //XCMD_Spy
0xFFFF, //XCMD_Web
0xFFFF, //XCMD_Scroll
0x0004, //XCMD_TipReq
0xFFFF, //XCMD_ServerList
0xFFFF, //XCMD_CharList
0x0005, //XCMD_AttackOK
0xFFFF, //XCMD_GumpInputBox
0xFFFF, //XCMD_GumpText
0xFFFF, //XCMD_TalkUNICODE
0xFFFF, //XCMD_SpeakUNICODE
0x000D, //XCMD_CharDeath
0xFFFF, //XCMD_GumpDialog
0xFFFF, //XCMD_GumpButton
0xFFFF, //XCMD_ChatReq
0xFFFF, //XCMD_ChatText
0xFFFF, //XCMD_TargetItems
0x0040, //XCMD_Chat
0x0009, //XCMD_ToolTipReq
0xFFFF, //XCMD_ToolTip
0xFFFF, //XCMD_CharProfile
0x0003, //XCMD_Features
0x0006, //XCMD_Arrow
0x0009, //XCMD_MailMsg
0x0003, //XCMD_Unk_bc
0xFFFF, //XCMD_ClientVersion
0xFFFF, //be
0xFFFF, //XCMD_ExtData
0x0024,
0xFFFF, //XCMD_SpeakTable
0xFFFF,
0xFFFF,
0x0006, //c4
};
#else
const WORD g_Packet_Lengths[XCMD_QTY] =
{
// @ in 3.0.0a
// if it's == 0xFFFF then it's variable len, or >= 08000
// else it's fixed to what ever the value is.
0x0068,
0x0005,
0x0007,
0xFFFF,
0x0002,
0x0005,
0x0005,
0x0007,
0x000e,
0x0005,
0x000b,
0x010a,
0xFFFF,
0x0003,
0xFFFF,
0x003d,
0x00d7,
0xFFFF,
0xFFFF,
0x000a,
0x0006,
0x0009,
0x0001,
0xFFFF,
0xFFFF,
0xFFFF,
0xFFFF,
0x0025,
0xFFFF,
0x0005,
0x0004,
0x0008,
0x0013,
0x0008,
0x0003,
0x001a,
0x0007,
0x0014,
0x0005,
0x0002,
0x0005,
0x0001,
0x0005,
0x0002,
0x0002,
0x0011,
0x000f,
0x000a,
0x0005,
0x0001,
0x0002,
0x0002,
0x000a,
0x028d,
0xFFFF,
0x0008,
0x0007,
0x0009,
0xFFFF,
0xFFFF,
0xFFFF,
0x0002,
0x0025,
0xFFFF,
0x00c9,
0xFFFF,
0xFFFF,
0x0229,
0x02c9,
0x0005,
0xFFFF,
0x000b,
0x0049,
0x005d,
0x0005,
0x0009,
0xFFFF,
0xFFFF,
0x0006,
0x0002,
0xFFFF,
0xFFFF,
0xFFFF,
0x0002,
0x000c,
0x0001,
0x000b,
0x006e,
0x006a,
0xFFFF,
0xFFFF,
0x0004,
0x0002,
0x0049,
0xFFFF,
0x0031,
0x0005,
0x0009,
0x000f,
0x000d,
0x0001,
0x0004,
0xFFFF,
0x0015,
0xFFFF,
0xFFFF,
0x0003,
0x0009,
0x0013,
0x0003,
0x000e,
0xFFFF,
0x001c,
0xFFFF,
0x0005,
0x0002,
0xFFFF,
0x0023,
0x0010,
0x0011,
0xFFFF,
0x0009,
0xFFFF,
0x0002,
0xFFFF,
0x000d,
0x0002,
0xFFFF,
0x003e,
0xFFFF,
0x0002,
0x0027,
0x0045,
0x0002,
0xFFFF,
0xFFFF,
0x0042,
0xFFFF,
0xFFFF,
0xFFFF,
0x000b,
0xFFFF,
0xFFFF,
0xFFFF,
0x0013,
0x0041,
0xFFFF,
0x0063,
0xFFFF,
0x0009,
0xFFFF,
0x0002,
0xFFFF,
0x001a,
0xFFFF,
0x0102,
0x0135,
0x0033,
0xFFFF,
0xFFFF,
0x0003,
0x0009,
0x0009,
0x0009,
0x0095,
0xFFFF,
0xFFFF,
0x0004,
0xFFFF,
0xFFFF,
0x0005,
0xFFFF,
0xFFFF,
0xFFFF,
0xFFFF,
0x000d,
0xFFFF,
0xFFFF,
0xFFFF,
0xFFFF,
0xFFFF,
0x0040,
0x0009,
0xFFFF,
0xFFFF,
0x0003,
0x0006,
0x0009,
0x0003,
0xFFFF,
0xFFFF,
0xFFFF,
0x0024, // XCMD_EffectEx
0xFFFF, // XCMD_SpeakTable
0xFFFF,
0xFFFF,
0x0006,
0xFFFF, // 0x00cb,
0xFFFF, // 0x0001,
0x0031, // XCMD_EffectParticle
0x0002, // 0x0002
0xFFFF, // 0x0006
0xFFFF, // 0x0006
0xFFFF, // 0x0007
0xFFFF, // 0xFFFF
0xFFFF,
0xFFFF,
0xFFFF,
0xFFFF, // XCMD_ConfigFile
0x0002, // XCMD_LogoutStatus
0x0037, // 0xd2
0xFFFF, // 0xd3
0xFFFF, // 0xd4
0xFFFF, // 0xd5
0xFFFF, // 0xd6
0xFFFF, // 0xd7
0xFFFF, // 0xd9
};
#endif
/////////////////////////
// -CCompressTree
void CCompressTree::CompressXOR( BYTE * pData, int iLen, DWORD & dwIndex ) // static
{
// Only used in Ver 2.0.4 and above.
static const BYTE sm_bData[] = { 0x05, 0x92, 0x66, 0x23, 0x67, 0x14, 0xE3, 0x62, 0xDC, 0x60, 0x8C, 0xD6, 0xFE, 0x7C, 0x25, 0x69 };
// @ 04264A5 in 2.0.4
DWORD dwTmpIndex = dwIndex;
for ( int i=0; i<iLen; i++ )
{
pData[i] ^= sm_bData[dwTmpIndex & 0x0f];
dwTmpIndex++;
}
dwIndex = dwTmpIndex;
}
const WORD CCompressTree::sm_xCompress_Base[COMPRESS_TREE_SIZE] = // static
{
// The "golden" key for (0.0.0.0)
// lowest 4 bits is the length. other source uses 2 int's per WORD here.
// @ 014b389 in 2.0.3
// @ 010a3d8 in 2.0.4
0x0002, 0x01f5, 0x0226, 0x0347, 0x0757, 0x0286, 0x03b6, 0x0327,
0x0e08, 0x0628, 0x0567, 0x0798, 0x19d9, 0x0978, 0x02a6, 0x0577,
0x0718, 0x05b8, 0x1cc9, 0x0a78, 0x0257, 0x04f7, 0x0668, 0x07d8,
0x1919, 0x1ce9, 0x03f7, 0x0909, 0x0598, 0x07b8, 0x0918, 0x0c68,
0x02d6, 0x1869, 0x06f8, 0x0939, 0x1cca, 0x05a8, 0x1aea, 0x1c0a,
0x1489, 0x14a9, 0x0829, 0x19fa, 0x1719, 0x1209, 0x0e79, 0x1f3a,
0x14b9, 0x1009, 0x1909, 0x0136, 0x1619, 0x1259, 0x1339, 0x1959,
0x1739, 0x1ca9, 0x0869, 0x1e99, 0x0db9, 0x1ec9, 0x08b9, 0x0859,
0x00a5, 0x0968, 0x09c8, 0x1c39, 0x19c9, 0x08f9, 0x18f9, 0x0919,
0x0879, 0x0c69, 0x1779, 0x0899, 0x0d69, 0x08c9, 0x1ee9, 0x1eb9,
0x0849, 0x1649, 0x1759, 0x1cd9, 0x05e8, 0x0889, 0x12b9, 0x1729,
0x10a9, 0x08d9, 0x13a9, 0x11c9, 0x1e1a, 0x1e0a, 0x1879, 0x1dca,
0x1dfa, 0x0747, 0x19f9, 0x08d8, 0x0e48, 0x0797, 0x0ea9, 0x0e19,
0x0408, 0x0417, 0x10b9, 0x0b09, 0x06a8, 0x0c18, 0x0717, 0x0787,
0x0b18, 0x14c9, 0x0437, 0x0768, 0x0667, 0x04d7, 0x08a9, 0x02f6,
0x0c98, 0x0ce9, 0x1499, 0x1609, 0x1baa, 0x19ea, 0x39fa, 0x0e59,
0x1949, 0x1849, 0x1269, 0x0307, 0x06c8, 0x1219, 0x1e89, 0x1c1a,
0x11da, 0x163a, 0x385a, 0x3dba, 0x17da, 0x106a, 0x397a, 0x24ea,
0x02e7, 0x0988, 0x33ca, 0x32ea, 0x1e9a, 0x0bf9, 0x3dfa, 0x1dda,
0x32da, 0x2eda, 0x30ba, 0x107a, 0x2e8a, 0x3dea, 0x125a, 0x1e8a,
0x0e99, 0x1cda, 0x1b5a, 0x1659, 0x232a, 0x2e1a, 0x3aeb, 0x3c6b,
0x3e2b, 0x205a, 0x29aa, 0x248a, 0x2cda, 0x23ba, 0x3c5b, 0x251a,
0x2e9a, 0x252a, 0x1ea9, 0x3a0b, 0x391b, 0x23ca, 0x392b, 0x3d5b,
0x233a, 0x2cca, 0x390b, 0x1bba, 0x3a1b, 0x3c4b, 0x211a, 0x203a,
0x12a9, 0x231a, 0x3e0b, 0x29ba, 0x3d7b, 0x202a, 0x3adb, 0x213a,
0x253a, 0x32ca, 0x23da, 0x23fa, 0x32fa, 0x11ca, 0x384a, 0x31ca,
0x17ca, 0x30aa, 0x2e0a, 0x276a, 0x250a, 0x3e3b, 0x396a, 0x18fa,
0x204a, 0x206a, 0x230a, 0x265a, 0x212a, 0x23ea, 0x3acb, 0x393b,
0x3e1b, 0x1dea, 0x3d6b, 0x31da, 0x3e5b, 0x3e4b, 0x207a, 0x3c7b,
0x277a, 0x3d4b, 0x0c08, 0x162a, 0x3daa, 0x124a, 0x1b4a, 0x264a,
0x33da, 0x1d1a, 0x1afa, 0x39ea, 0x24fa, 0x373b, 0x249a, 0x372b,
0x1679, 0x210a, 0x23aa, 0x1b8a, 0x3afb, 0x18ea, 0x2eca, 0x0627,
0x00d4 // terminator
} ;
bool CCompressTree::AddBranch( int Value, WORD wCode, int iBits )
{
// adds a hex value related to it's binary compression code to the decompression tree.
if ( ! iBits )
return false;
CCompressBranch *pCur=&m_Root;
WORD wMask = 1 << (iBits-1);
// loop through each bit in the bitfield
for ( ;wMask; wMask >>= 1 )
{
// if a compression value read in conflicts with an existing
// compression value, the table is invalid. Exit program.
if ( pCur->m_Value >= 0 )
{
// if you get here, this means that a new compression value is mutually exclusive
// with another value. I.E. both 1101 and 110100 cannot exist in a tree because
// any decompression routine will stop as soon as it reads 1101
ASSERT(0);
return false;
}
if ( wCode & wMask )
{ // if the bit is a 1
// make a new branch if we need to
if ( pCur->m_pOne == NULL )
{
pCur->m_pOne = new CCompressBranch;
ASSERT(pCur->m_pOne);
}
pCur = pCur->m_pOne; // traverse to the (possibly new) branch
}
else
{ // if the bit is a 0
// make a new branch if we need to
if ( pCur->m_pZero == NULL )
{
pCur->m_pZero = new CCompressBranch;
ASSERT(pCur->m_pZero);
}
pCur = pCur->m_pZero; // traverse to the (possibly new) branch
}
}
// if the end of this bitvalue is within an existing bitvalue's path
// the table is in error. I.E. 111 is within 11101's path
if ( pCur->m_pOne != NULL || pCur->m_pZero != NULL )
{
ASSERT(0);
return( false );
}
// an entry already exists with this binary value
else if (pCur->m_Value>=0)
{
if (((BYTE)pCur->m_Value)!=Value)
{
// if they are not the same, the table is in error
ASSERT(0);
return( false );
}
}
else
{
// set the read in hex value at this compression location
pCur->m_Value=Value;
}
return( true );
}
int CCompressTree::Decode( BYTE * pOutput, const BYTE * pInput, int inpsize )
{
// RETURN:
// valid output length. m_iDecodeIndex may be larger.
// 0 = not big enough for a logical packet.
ASSERT( m_Root.IsLoaded() );
int outIndex = m_iDecodeIndex;
int outValidIndex = 0;
for ( int inpIndex=0; inpIndex<inpsize; inpIndex++ )
{
BYTE ch = pInput[inpIndex];
BYTE Mask = 0x80;
for ( int i=0;i<8;i++)
{
if ( ch & Mask )
m_pDecodeCur=m_pDecodeCur->m_pOne;
else
m_pDecodeCur=m_pDecodeCur->m_pZero;
if ( m_pDecodeCur == NULL )
{
// This data stream is JUNK!
Reset();
return( -1 ); // this should not happen !
}
if (m_pDecodeCur->m_Value>=0)
{
if ( m_pDecodeCur->m_Value > 0xFF )
{
// End of a logical packet. (process it)
Reset();
outValidIndex = outIndex;
break; // rest of byte should be padded out. so skip it.
}
pOutput[outIndex++] = m_pDecodeCur->m_Value;
m_pDecodeCur = &m_Root;
}
Mask >>= 1;
}
}
m_iDecodeIndex = outIndex - outValidIndex; // continue from here next time.
return( outValidIndex ); // not done yet.
}
bool CCompressTree::Load()
{
if ( ! IsLoaded())
{
Reset();
for ( int i=0; i<COMPRESS_TREE_SIZE; i++ )
{
WORD wCode = sm_xCompress_Base[i];
int iBits = wCode & 0xF;
wCode >>= 4;
if ( ! AddBranch( i, wCode, iBits ))
return( false );
}
}
return( true );
}
int CCompressTree::Encode( BYTE * pOutput, const BYTE * pInput, int inplen ) // static
{
int iLen=0;
int bitidx=0; // Offset in output byte (xOutVal)
BYTE xOutVal=0; // Don't bother to init this. It will just roll off all junk anyhow.
for ( int i=0; i <= inplen; i++ )
{
WORD value = sm_xCompress_Base[ ( i == inplen ) ? (COMPRESS_TREE_SIZE-1) : pInput[i] ];
int nBits = value & 0xF;
value >>= 4;
while ( nBits-- )
{
xOutVal <<= 1;
xOutVal |= (value >> nBits) & 0x1;
if ( ++bitidx == 8)
{
bitidx = 0;
pOutput[iLen++] = xOutVal;
}
}
}
if (bitidx) // flush odd bits.
{
pOutput[iLen++] = xOutVal << (8-bitidx);
}
return( iLen );
}
| 20.89948
| 131
| 0.632391
|
Jhobean
|
c5b2a9fb24346bd217f180e5d53b38e7b25c73b0
| 1,907
|
hpp
|
C++
|
include/masker_util/masker_util_node.hpp
|
1487quantum/masker_ros
|
16416aefce417742fadf97a9932c4d8efbcc5c67
|
[
"MIT"
] | null | null | null |
include/masker_util/masker_util_node.hpp
|
1487quantum/masker_ros
|
16416aefce417742fadf97a9932c4d8efbcc5c67
|
[
"MIT"
] | null | null | null |
include/masker_util/masker_util_node.hpp
|
1487quantum/masker_ros
|
16416aefce417742fadf97a9932c4d8efbcc5c67
|
[
"MIT"
] | null | null | null |
#include <ros/ros.h>
#include <geometry_msgs/Point.h>
#include <image_transport/image_transport.h>
#include <cv_bridge/cv_bridge.h>
#include <dynamic_reconfigure/server.h>
#include <camera_info_manager/camera_info_manager.h>
#include "opencv2/core.hpp"
#include "masker_util/maskerConfig.h"
/*
* A ROS package for image masking & cropping utility for fisheye / wide-angle / omnidirectional image.
* masker_util.hpp
*
* __ _ _ ___ ______ ____ _
* /_ | || | / _ \____ / __ \ | |
* | | || || (_) | / / | | |_ _ __ _ _ __ | |_ _ _ _ __ ___
* | |__ _> _ < / /| | | | | | |/ _` | '_ \| __| | | | '_ ` _ \
* | | | || (_) |/ / | |__| | |_| | (_| | | | | |_| |_| | | | | | |
* |_| |_| \___//_/ \___\_\\__,_|\__,_|_| |_|\__|\__,_|_| |_| |_|
*
* Copyright (C) 2020 1487Quantum
*
*
* Licensed under the MIT License.
*
*/
class masker_util_node {
public:
masker_util_node(const ros::NodeHandle& nh_);
bool init(); //Init
// === CALLBACK & PUBLISHER ===
void dr_callback(const masker_util::maskerConfig& config, const uint32_t& level);
void imgCallback(const sensor_msgs::ImageConstPtr& imgp, const sensor_msgs::CameraInfoConstPtr& cam_info); //Image Input callback
private:
std::string topic_out; //Output topic name
ros::NodeHandle nh; //Node handle
// Pub/Sub
image_transport::Publisher imgPub;
ros::Publisher pub_info_camera;
image_transport::CameraSubscriber imgSub;
//Dynamic reconfig
dynamic_reconfigure::Server<masker_util::maskerConfig> msk_server;
dynamic_reconfigure::Server<masker_util::maskerConfig>::CallbackType msk_cb;
//Params
bool setMask{ true };
int cirRad{ 720 };
cv::Point cOffset; //Circle offset from img center: x < 0 is left, y < 0 is up]
cv::Point borderOffset; //Border offset from circle
};
| 34.672727
| 133
| 0.611432
|
1487quantum
|
c5b3b42cd160ddd3d90a9c8c6b6de14c19b6aaee
| 1,856
|
cpp
|
C++
|
samples/snippets/cpp/VS_Snippets_Remoting/EnterpriseServicesObjectPoolingAttribute/cpp/class1.cpp
|
hamarb123/dotnet-api-docs
|
6aeb55784944a2f1f5e773b657791cbd73a92dd4
|
[
"CC-BY-4.0",
"MIT"
] | 421
|
2018-04-01T01:57:50.000Z
|
2022-03-28T15:24:42.000Z
|
samples/snippets/cpp/VS_Snippets_Remoting/EnterpriseServicesObjectPoolingAttribute/cpp/class1.cpp
|
hamarb123/dotnet-api-docs
|
6aeb55784944a2f1f5e773b657791cbd73a92dd4
|
[
"CC-BY-4.0",
"MIT"
] | 5,797
|
2018-04-02T21:12:23.000Z
|
2022-03-31T23:54:38.000Z
|
samples/snippets/cpp/VS_Snippets_Remoting/EnterpriseServicesObjectPoolingAttribute/cpp/class1.cpp
|
hamarb123/dotnet-api-docs
|
6aeb55784944a2f1f5e773b657791cbd73a92dd4
|
[
"CC-BY-4.0",
"MIT"
] | 1,482
|
2018-03-31T11:26:20.000Z
|
2022-03-30T22:36:45.000Z
|
// <snippet0>
#using <System.EnterpriseServices.dll>
using namespace System;
using namespace System::EnterpriseServices;
// References:
// System.EnterpriseServices
// <snippet1>
[ObjectPooling(true)]
public ref class ObjectPoolingAttributeCtorBool : public ServicedComponent
{
};
// </snippet1>
// <snippet2>
[ObjectPooling(true, 1, 10)]
public ref class ObjectPoolingAttributeCtorBoolIntInt :
public ServicedComponent
{
};
// </snippet2>
// <snippet3>
[ObjectPooling(1, 10)]
public ref class ObjectPoolingAttributeCtorIntInt : public ServicedComponent
{
};
// </snippet3>
// <snippet4>
[ObjectPooling(false)]
public ref class ObjectPoolingAttributeEnabled : public ServicedComponent
{
public:
void EnabledExample()
{
// Get the ObjectPoolingAttribute applied to the class.
ObjectPoolingAttribute^ attribute =
(ObjectPoolingAttribute^)Attribute::GetCustomAttribute(
this->GetType(),
ObjectPoolingAttribute::typeid,
false);
// Display the current value of the attribute's Enabled property.
Console::WriteLine("ObjectPoolingAttribute.Enabled: {0}",
attribute->Enabled);
// Set the Enabled property value of the attribute.
attribute->Enabled = true;
// Display the new value of the attribute's Enabled property.
Console::WriteLine("ObjectPoolingAttribute.Enabled: {0}",
attribute->Enabled);
}
};
// </snippet4>
// </snippet0>
// Test client.
int main()
{
// Create a new instance of each example class.
ObjectPoolingAttributeEnabled^ enabledExample =
gcnew ObjectPoolingAttributeEnabled();
// Demonstrate the ObjectPoolingAttribute properties.
enabledExample->EnabledExample();
};
| 25.424658
| 77
| 0.663254
|
hamarb123
|
c5c6edf0f3f3eb796f48afa68786588ac5eb428d
| 915
|
cpp
|
C++
|
src/lib/user.cpp
|
hanilr/management-system
|
c796b1a016f507309c987170345a868b4a0abfb9
|
[
"MIT"
] | null | null | null |
src/lib/user.cpp
|
hanilr/management-system
|
c796b1a016f507309c987170345a868b4a0abfb9
|
[
"MIT"
] | null | null | null |
src/lib/user.cpp
|
hanilr/management-system
|
c796b1a016f507309c987170345a868b4a0abfb9
|
[
"MIT"
] | null | null | null |
// USER SECTION (USER)
#include <iostream>
#include "file.hpp"
std::string fetch_value(std::string user_name, std::string user_pass)
{
std::string full_path = "data/" + user_name + "/" + user_pass + ".txt";
std::string temp_value = rfile(full_path);
return temp_value;
} // CHECK ISSUES WITH "std::string var = fetch_value()"
void change_value(std::string user_name, std::string user_pass, std::string value)
{
std::string full_path = "data/" + user_name + "/" + user_pass + ".txt";
dfile(full_path);
wfile(full_path, value);
}
void freeze_account(std::string user_name)
{
std::string full_path = "data/" + user_name + "/log.txt";
wlog(full_path, "account has been frozen");
}
void unfreeze_account(std::string user_name)
{
std::string full_path = "data/" + user_name + "/log.txt";
wlog(full_path, "account has been unfreeze");
}
| 25.416667
| 83
| 0.642623
|
hanilr
|
c5c938b0564f1fa77f331f93522ee68928cae4c8
| 1,579
|
cpp
|
C++
|
codes/HDU/hdu4937.cpp
|
JeraKrs/ACM
|
edcd61ec6764b8cd804bf1538dfde53d0ff572b5
|
[
"Apache-2.0"
] | null | null | null |
codes/HDU/hdu4937.cpp
|
JeraKrs/ACM
|
edcd61ec6764b8cd804bf1538dfde53d0ff572b5
|
[
"Apache-2.0"
] | null | null | null |
codes/HDU/hdu4937.cpp
|
JeraKrs/ACM
|
edcd61ec6764b8cd804bf1538dfde53d0ff572b5
|
[
"Apache-2.0"
] | null | null | null |
#include <cstdio>
#include <cstring>
#include <ctime>
#include <cstdlib>
#include <set>
#include <algorithm>
using namespace std;
typedef long long ll;
const int maxn = 1e6;
ll N;
int np, vis[maxn+5], prime[maxn+5];
set<ll> ans;
int c, cnt[maxn+5];
ll nowbase, fact[maxn+5];
void prime_table (int n) {
np = 0;
memset(vis, 0, sizeof(vis));
for (int i = 2; i <= n; i++) {
if (vis[i])
continue;
prime[np++] = i;
for (int j = 2 * i; j <= n; j += i)
vis[j] = 1;
}
}
void div_factor (ll n) {
c = 0;
for (int i = 0; i < np && n >= prime[i]; i++) {
if (n % prime[i] == 0) {
cnt[c] = 0;
fact[c] = prime[i];;
while (n % prime[i] == 0) {
n /= prime[i];
cnt[c]++;
}
c++;
}
}
if (n != 1) {
fact[c] = n;
cnt[c++] = 1;
}
}
bool judge (ll n, ll base) {
if (base <= nowbase)
return false;
while (n) {
if (n%base < 3 || n%base > 6)
return false;
n /= base;
}
ans.insert(base);
return true;
}
void dfs (int d, ll s, ll u) {
judge(u/s, s);
if (d == c)
return;
for (int i = 0; i <= cnt[d]; i++) {
dfs (d+1, s, u);
s *= fact[d];
}
}
void solve (ll n) {
if (n <= 0)
return;
div_factor(n);
dfs(0, 1, n);
}
int main () {
prime_table(maxn);
int cas;
scanf("%d", &cas);
for (int kcas = 1; kcas <= cas; kcas++) {
//scanf("%lld", &N);
scanf("%I64d", &N);
printf("Case #%d: ", kcas);
if (N >= 3 && N <= 6)
printf("-1\n");
else {
ans.clear();
for (int i = 3; i <= 6; i++) {
nowbase = i;
solve(N-i);
}
int ret = ans.size();
printf("%d\n", ret);
}
}
return 0;
}
| 13.495726
| 48
| 0.485117
|
JeraKrs
|
c5d2a73320d1345942e0b813d023a2b6005bf6b4
| 2,522
|
cpp
|
C++
|
bindings/python/src/OpenSpaceToolkitCorePy/FileSystem/Path.cpp
|
open-space-collective/library-core
|
0b031edb403e2d657d02761b07dd4b35680fcafc
|
[
"Apache-2.0"
] | 8
|
2018-06-13T06:50:34.000Z
|
2019-07-15T03:36:50.000Z
|
bindings/python/src/OpenSpaceToolkitCorePy/FileSystem/Path.cpp
|
open-space-collective/library-core
|
0b031edb403e2d657d02761b07dd4b35680fcafc
|
[
"Apache-2.0"
] | 37
|
2018-06-12T07:42:38.000Z
|
2020-01-05T01:13:27.000Z
|
bindings/python/src/OpenSpaceToolkitCorePy/FileSystem/Path.cpp
|
open-space-collective/library-core
|
0b031edb403e2d657d02761b07dd4b35680fcafc
|
[
"Apache-2.0"
] | 2
|
2020-03-05T18:17:24.000Z
|
2020-04-07T18:18:24.000Z
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @project Open Space Toolkit ▸ Core
/// @file bindings/python/src/OpenSpaceToolkitCorePy/FileSystem/Path.cpp
/// @author Lucas Brémond <lucas@loftorbital.com>
/// @license Apache License 2.0
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <OpenSpaceToolkit/Core/FileSystem/Path.hpp>
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
inline void OpenSpaceToolkitCorePy_FileSystem_Path ( pybind11::module& aModule )
{
using namespace pybind11 ;
using ostk::core::fs::Path ;
class_<Path>(aModule, "Path")
// Define init method using pybind11 "init" convenience method
// No init here
// Define methods
.def(self == self)
.def(self != self)
.def(self + self)
.def(self += self)
// .def("__str__", +[] (const ostk::core::fs::Path& aPath) -> str { return aPath.toString() ; })
// .def("__repr__", +[] (const ostk::core::fs::Path& aPath) -> str { return aPath.toString() ; })
.def("__str__", &(shiftToString<Path>))
.def("__repr__", &(shiftToString<Path>))
.def("is_defined", &Path::isDefined)
.def("is_absolute", &Path::isAbsolute)
.def("is_relative", &Path::isRelative)
.def("get_parent_path", &Path::getParentPath)
.def("get_last_element", &Path::getLastElement)
.def("get_normalized_path", &Path::getNormalizedPath)
.def("get_absolute_path", &Path::getAbsolutePath, "aBasePath"_a = Path::Current())
// .def("get_relative_path_to", &Path::getRelativePathTo)
.def("to_string", &Path::toString)
// Define static methods
.def_static("undefined", &Path::Undefined)
.def_static("root", &Path::Root)
.def_static("current", &Path::Current)
.def_static("parse", &Path::Parse)
// .def_static("strings", &Path::Strings)
;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
| 42.033333
| 161
| 0.430214
|
open-space-collective
|
c5d3ea2a0c64978ee2cc2cd145951a829afd3ce1
| 396
|
hpp
|
C++
|
src/common/token.hpp
|
Wassasin/splicpp
|
b88bf8ec18985bc6ee5a8ccb952f413f23d74c5a
|
[
"Beerware"
] | 2
|
2019-04-09T01:04:36.000Z
|
2019-05-12T06:17:03.000Z
|
src/common/token.hpp
|
Wassasin/splicpp
|
b88bf8ec18985bc6ee5a8ccb952f413f23d74c5a
|
[
"Beerware"
] | null | null | null |
src/common/token.hpp
|
Wassasin/splicpp
|
b88bf8ec18985bc6ee5a8ccb952f413f23d74c5a
|
[
"Beerware"
] | null | null | null |
#ifndef TOKEN_H
#define TOKEN_H
#include <string>
#include "typedefs.hpp"
#include "sloc.hpp"
namespace splicpp
{
struct token
{
stid type;
uint pos, length, line;
token(stid type, uint pos, uint length, uint line)
: type(type)
, pos(pos)
, length(length)
, line(line)
{}
std::string as_string(const std::string source) const;
sloc as_sloc() const;
};
}
#endif
| 13.655172
| 56
| 0.65404
|
Wassasin
|
c5d4032901abf19b9e9d89e1999c11fa61c2fe3c
| 543
|
hpp
|
C++
|
library/ATF/_post_result_zoclInfo.hpp
|
lemkova/Yorozuya
|
f445d800078d9aba5de28f122cedfa03f26a38e4
|
[
"MIT"
] | 29
|
2017-07-01T23:08:31.000Z
|
2022-02-19T10:22:45.000Z
|
library/ATF/_post_result_zoclInfo.hpp
|
kotopes/Yorozuya
|
605c97d3a627a8f6545cc09f2a1b0a8afdedd33a
|
[
"MIT"
] | 90
|
2017-10-18T21:24:51.000Z
|
2019-06-06T02:30:33.000Z
|
library/ATF/_post_result_zoclInfo.hpp
|
kotopes/Yorozuya
|
605c97d3a627a8f6545cc09f2a1b0a8afdedd33a
|
[
"MIT"
] | 44
|
2017-12-19T08:02:59.000Z
|
2022-02-24T23:15:01.000Z
|
// This file auto generated by plugin for ida pro. Generated code only for x64. Please, dont change manually
#pragma once
#include <common/common.h>
#include <_post_result_zocl.hpp>
START_ATF_NAMESPACE
namespace Info
{
using _post_result_zoclctor__post_result_zocl2_ptr = void (WINAPIV*)(struct _post_result_zocl*);
using _post_result_zoclctor__post_result_zocl2_clbk = void (WINAPIV*)(struct _post_result_zocl*, _post_result_zoclctor__post_result_zocl2_ptr);
}; // end namespace Info
END_ATF_NAMESPACE
| 33.9375
| 151
| 0.769797
|
lemkova
|
c5d7bf2bf70798d0d517af8aff2b7bda0158034a
| 748
|
cpp
|
C++
|
[77] Combinations/77.combinations.cpp
|
Coolzyh/Leetcode
|
4abf685501427be0ce36b83016c4fa774cdf1a1a
|
[
"MIT"
] | null | null | null |
[77] Combinations/77.combinations.cpp
|
Coolzyh/Leetcode
|
4abf685501427be0ce36b83016c4fa774cdf1a1a
|
[
"MIT"
] | null | null | null |
[77] Combinations/77.combinations.cpp
|
Coolzyh/Leetcode
|
4abf685501427be0ce36b83016c4fa774cdf1a1a
|
[
"MIT"
] | null | null | null |
/*
* @lc app=leetcode id=77 lang=cpp
*
* [77] Combinations
*/
// @lc code=start
class Solution {
public:
vector<vector<int>> combine(int n, int k) {
vector<vector<int>> res;
vector<int> temp_list;
dfs(1, n, k, temp_list, res);
return res;
}
void dfs(int start, int n, int k, vector<int>& temp_list, vector<vector<int>>& res) {
if (k == 0) {
res.push_back(temp_list);
return;
}
// for (int i = start; i <= n; i++) {
// we can change n to n-k+1
for (int i = start; i <= n-k+1; i++) {
temp_list.push_back(i);
dfs(i+1, n, k-1, temp_list, res);
temp_list.pop_back();
}
}
};
// @lc code=end
| 22.666667
| 89
| 0.487968
|
Coolzyh
|
c5dc0c8ce8d6cd0c69cff08e5f3d717158015e9b
| 2,219
|
cpp
|
C++
|
17-BinaryImageProcessing/07_blobDetection.cpp
|
vladcuevas/OpenCV-Labs-Linux
|
6e19a60555074b846c5c9dd2225a9eb064376325
|
[
"MIT"
] | null | null | null |
17-BinaryImageProcessing/07_blobDetection.cpp
|
vladcuevas/OpenCV-Labs-Linux
|
6e19a60555074b846c5c9dd2225a9eb064376325
|
[
"MIT"
] | null | null | null |
17-BinaryImageProcessing/07_blobDetection.cpp
|
vladcuevas/OpenCV-Labs-Linux
|
6e19a60555074b846c5c9dd2225a9eb064376325
|
[
"MIT"
] | null | null | null |
#include <iostream>
#include <opencv2/opencv.hpp>
#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
#include <time.h>
#include "dataPath.hpp"
using namespace std;
using namespace cv;
int main(){
// Read image
Mat img = imread(DATA_PATH + "images/blob_detection.jpg", IMREAD_GRAYSCALE);
// Set up detector with default parameters
Ptr<SimpleBlobDetector> detector = SimpleBlobDetector::create();
std::vector<KeyPoint> keypoints;
detector->detect(img,keypoints);
// Mark blobs using image annotation concepts we have studied so far
int x,y;
int radius;
double diameter;
cvtColor(img, img, COLOR_GRAY2BGR);
for (int i=0; i < keypoints.size(); i++){
KeyPoint k = keypoints[i];
Point keyPt;
keyPt = k.pt;
x=(int)keyPt.x;
y=(int)keyPt.y;
// Mark center in BLACK
circle(img,Point(x,y),5,Scalar(255,0,0),-1);
// Get radius of coin
diameter = k.size;
radius = (int)diameter/2.0;
// Mark blob in GREEN
circle(img, Point(x,y),radius,Scalar(0,255,0),2);
}
imshow("Image",img);
waitKey(0);
// Setup SimpleBlobDetector parameters.
SimpleBlobDetector::Params params;
// Change thresholds
params.minThreshold = 10;
params.maxThreshold = 200;
// Filter by Area.
params.filterByArea = true;
params.minArea = 1500;
// Filter by Circularity
params.filterByCircularity = true;
params.minCircularity = 0.1;
// Filter by Convexity
params.filterByConvexity = true;
params.minConvexity = 0.87;
// Filter by Inertia
params.filterByInertia = true;
params.minInertiaRatio = 0.01;
detector = SimpleBlobDetector::create(params);
img = imread(DATA_PATH + "images/blob_detection.jpg", IMREAD_GRAYSCALE);
detector->detect(img, keypoints);
// Mark blobs using image annotation concepts we have studied so far
cvtColor(img, img, COLOR_GRAY2BGR);
for (int i=0; i < keypoints.size(); i++){
KeyPoint k = keypoints[i];
Point keyPt;
keyPt = k.pt;
x=(int)keyPt.x;
y=(int)keyPt.y;
// Mark center in BLACK
circle(img,Point(x,y),5,Scalar(255,0,0),-1);
// Get radius of coin
diameter = k.size;
radius = (int)diameter/2.0;
// Mark blob in GREEN
circle(img, Point(x,y),radius,Scalar(0,255,0),2);
}
imshow("Image",img);
waitKey(0);
return 0;
}
| 23.114583
| 76
| 0.694457
|
vladcuevas
|
c5dc2c6608faadbccdea8e0081cd3874ff9e5d94
| 3,132
|
hpp
|
C++
|
include/cert-ledger/cert-ledger.hpp
|
UCLA-IRL/cert-ledger
|
3de87488d852648a8ad67a9bc1797a05c8221c6d
|
[
"Apache-2.0"
] | null | null | null |
include/cert-ledger/cert-ledger.hpp
|
UCLA-IRL/cert-ledger
|
3de87488d852648a8ad67a9bc1797a05c8221c6d
|
[
"Apache-2.0"
] | null | null | null |
include/cert-ledger/cert-ledger.hpp
|
UCLA-IRL/cert-ledger
|
3de87488d852648a8ad67a9bc1797a05c8221c6d
|
[
"Apache-2.0"
] | null | null | null |
#ifndef CERT_LEDGER_CERT_LEDGER_H_
#define CERT_LEDGER_CERT_LEDGER_H_
#include "record.hpp"
#include "config.hpp"
#include "return-code.hpp"
#include "backend.hpp"
#include <ndn-svs/svsync.hpp>
#include <ndn-cxx/security/key-chain.hpp>
#include <ndn-cxx/face.hpp>
#include <ndn-cxx/util/scheduler.hpp>
#include <ndn-cxx/util/io.hpp>
#include <stack>
#include <random>
#include <utility>
using namespace ndn;
namespace cert_ledger {
class CertLedger {
public:
/**
* Initialize a CertLedger instance from the config.
* @p config, input, the configuration of multicast prefix, peer prefix, and settings of Dledger behavior
* @p keychain, input, the local NDN keychain instance
* @p face, input, the localhost NDN face to send/receive NDN packets.
*/
CertLedger(const Config &config, security::KeyChain &keychain, Face &network, std::shared_ptr<ndn::security::Validator> m_recordValidator);
virtual ~CertLedger();
/**
* Create a new record to the CertLedger.
* @p record, input, a record instance which contains the record payload
*/
virtual ReturnCode
createRecord(Record &record);
/**
* Get an existing record from the CertLedger.
* @p recordName, input, the name of the record, which is an NDN full name (i.e., containing ImplicitSha256DigestComponent component)
*/
virtual optional<Record>
getRecord(const Name &contentName) const;
/**
* Check whether the record exists in the CertLedger.
* @p recordName, input, the name of the record, which is an NDN full name (i.e., containing ImplicitSha256DigestComponent component)
*/
virtual bool
hasRecord(const Name &contentName) const;
/**
* list the record exists in the CertLedger.
* @p recordName, input, the name of the record, which is an NDN name prefix.
*/
virtual std::list<Name>
listRecord(const Name &prefix) const;
const Name& getPeerPrefix() const;
void setOnRecordCallback(std::function<void(const Record&)> callback) {
m_onRecordCallback = std::move(callback);
}
private:
void onUpdate(const std::vector<ndn::svs::MissingDataInfo>& info);
void addRecordToDAG(const Record& record);
static ndn::svs::SecurityOptions getSecurityOption(KeyChain& keychain, shared_ptr<ndn::security::Validator> recordValidator, Name peerPrefix);
void verifyPreviousRecord(const Record& record);
void shuffleAndAddPrev(Record &record, std::vector<Name>& recordList);
protected:
const Config m_config;
Backend m_backend;
security::KeyChain &m_keychain;
svs::SVSync m_dagSync;
std::shared_ptr<ndn::security::Validator> m_recordValidator;
std::function<void(const Record&)> m_onRecordCallback;
std::vector<Name> m_lastNames; //TODO change to tailing record first
unsigned int m_lastNameTops;
std::set<Name> m_tailingRecords;
std::set<Name> m_noPrevRecords; // TODO persistence at node failure
std::multimap<Name, Name> m_waitingReferencedRecords;
std::mt19937_64 m_randomEngine;
};
} // namespace cert-ledger
#endif // CERT_LEDGER_CERT_LEDGER_H_
| 31.959184
| 146
| 0.715837
|
UCLA-IRL
|
c5dce8516d491b8b3167854abc358ac00da4c052
| 4,889
|
cpp
|
C++
|
Source/Graphics/MaterialCollection.cpp
|
igorsegallafa/delta3d
|
1c8e2c0a8bab3e378afcef8718a5175fa62f2bf3
|
[
"MIT"
] | 7
|
2021-09-01T13:07:14.000Z
|
2022-03-23T17:23:17.000Z
|
Source/Graphics/MaterialCollection.cpp
|
igorsegallafa/Delta3D
|
1c8e2c0a8bab3e378afcef8718a5175fa62f2bf3
|
[
"MIT"
] | null | null | null |
Source/Graphics/MaterialCollection.cpp
|
igorsegallafa/Delta3D
|
1c8e2c0a8bab3e378afcef8718a5175fa62f2bf3
|
[
"MIT"
] | 2
|
2022-01-20T14:53:19.000Z
|
2022-03-23T17:18:22.000Z
|
#include "PrecompiledHeader.h"
#include "MaterialCollection.h"
#include "Material.h"
#include "Texture.h"
namespace Delta3D::Graphics
{
MaterialCollection::MaterialCollection() :
GraphicsImpl(),
header( -1 ),
materials( nullptr ),
materialsCount( 0 ),
materialType( 0 ),
name()
{
}
MaterialCollection::MaterialCollection( const std::string& name_ ) :
GraphicsImpl(),
header( -1 ),
materials( nullptr ),
materialsCount( 0 ),
materialType( 0 ),
name( name_ )
{
}
MaterialCollection::MaterialCollection( int materialsCount_ ) :
GraphicsImpl(),
header( -1 ),
materialsCount( 0 ),
materialType( 0 ),
name()
{
materials = new Material[materialsCount_];
memset( materials, 0, sizeof( Material )* materialsCount_ );
}
MaterialCollection::~MaterialCollection()
{
if( materials )
{
delete[] materials;
materials = nullptr;
}
}
int MaterialCollection::CreateMaterial( std::string textureFilePath, bool twoSided, bool shading, int blendType, bool useColorKey )
{
if( materials == nullptr )
return -1;
Material* material = &materials[materialsCount];
auto texture = graphics->GetTextureFactory()->Create( textureFilePath, false, useColorKey );
if( texture )
material->textures.push_back( texture );
material->useCount = 1;
material->shading = shading;
material->twoSided = twoSided;
material->type = 0;
material->textureStageState[0] = 0;
material->textureTransform[0] = Material::TextureTransform::None;
material->hasOpacityMap = false;
material->diffuseColor.a = 0;
material->colorTransform = 0;
material->isAnimated = false;
material->blendType = blendType;
material->useCount++;
return materialsCount++;
}
void MaterialCollection::AddTexture( int materialID, std::string textureFilePath )
{
auto texture = graphics->GetTextureFactory()->Create( textureFilePath, false, false );
if( texture )
if( materials )
materials[materialID].textures.push_back( texture );
}
void MaterialCollection::AddAnimatedTexture( Material* material, std::vector<std::string> textureList, int blendType, bool autoAnimate )
{
for( const auto& textureName : textureList )
material->animatedTextures.push_back( graphics->GetTextureFactory()->Create( textureName, false, false ) );
material->hasOpacityMap = FALSE;
material->diffuseColor.a = 0;
material->frameTotal = textureList.size() - 1;
material->frameSpeed = 6;
material->colorTransform = 0;
material->isAnimated = true;
material->blendType = blendType;
if( autoAnimate )
material->animationFrame = 0x100;
else
material->animationFrame = 0;
material->useCount++;
}
int MaterialCollection::SetFrame( Material* material, int frame )
{
int retValue = material->animationFrame;
material->animationFrame = frame;
return retValue;
}
Material* MaterialCollection::GetMaterialByTexture( std::string textureName )
{
if( materials )
{
for( int i = 0; i < materialsCount; i++ )
{
Material* material = materials + i;
if( material->useCount )
{
//Looking for normal textures first
for( auto& texture : material->textures )
if( _strcmpi( texture->FilePath().c_str(), textureName.c_str() ) == 0 )
return material;
//Looking for animated textures
for( auto& animTexture : material->animatedTextures )
if( _strcmpi( animTexture->FilePath().c_str(), textureName.c_str() ) == 0 )
return material;
}
}
}
return nullptr;
}
void MaterialCollection::SetBlendingMaterial( Material* material, bool useBlendingMap )
{
if( materials )
for( int i = 0; i < materialsCount; i++ )
materials[i].SetBlendingMaterial( material, useBlendingMap );
}
bool MaterialCollection::Build( FILE* file, bool skinned, bool loadTextures, bool useVertexColor, unsigned int mipMapsDefault, bool temporaryTextures, bool use3D )
{
if( file )
{
fread( &header, sizeof( materialType ) + offsetof( MaterialCollection, materialType ) - offsetof( MaterialCollection, header ), 1, file );
fseek( file, 72, SEEK_CUR );
//Allocate Materials
materials = new Material[materialsCount];
//Read Each Material
for( int i = 0; i < materialsCount; i++ )
materials[i].Build( file, skinned, loadTextures, useVertexColor, mipMapsDefault, temporaryTextures, use3D );
return true;
}
return false;
}
bool MaterialCollection::Load( const std::string& filePath, bool use3D )
{
filesystem::path p( filePath );
if( p.has_filename() )
{
std::ifstream file( filePath );
if( file.is_open() )
{
std::string line;
unsigned int materialID = 0;
while( std::getline( file, line ) )
{
//Check if this material exists on XML Format
if( filesystem::exists( line ) && filesystem::is_regular_file( line ) )
if( line.find( "NoTexture") == std::string::npos )
if( materials )
materials[materialID].Load( line, use3D );
materialID++;
}
file.close();
return true;
}
}
return false;
}
}
| 24.445
| 163
| 0.703007
|
igorsegallafa
|
c5de1da0f2086ed71fcbd5fade42a524374987d2
| 7,419
|
cpp
|
C++
|
codemp/botlib/be_aas_routealt.cpp
|
xScooper/Makermod
|
ccf9e10f441503d7b12094168c542a3696ceb314
|
[
"MIT"
] | 11
|
2015-09-27T22:53:26.000Z
|
2021-12-25T05:04:12.000Z
|
codemp/botlib/be_aas_routealt.cpp
|
xScooper/Makermod
|
ccf9e10f441503d7b12094168c542a3696ceb314
|
[
"MIT"
] | 1
|
2016-02-14T14:28:39.000Z
|
2017-01-11T13:03:39.000Z
|
codemp/botlib/be_aas_routealt.cpp
|
xScooper/Makermod
|
ccf9e10f441503d7b12094168c542a3696ceb314
|
[
"MIT"
] | 11
|
2015-10-19T15:37:24.000Z
|
2022-02-07T05:00:20.000Z
|
/*****************************************************************************
* name: be_aas_routealt.c
*
* desc: AAS
*
* $Archive: /MissionPack/code/botlib/be_aas_routealt.c $
* $Author: Zaphod $
* $Revision: 5 $
* $Modtime: 11/22/00 8:47a $
* $Date: 11/22/00 8:55a $
*
*****************************************************************************/
#include "../game/q_shared.h"
#include "l_utils.h"
#include "l_memory.h"
#include "l_log.h"
#include "l_script.h"
#include "l_precomp.h"
#include "l_struct.h"
#include "aasfile.h"
#include "../game/botlib.h"
#include "../game/be_aas.h"
#include "be_aas_funcs.h"
#include "be_interface.h"
#include "be_aas_def.h"
#define ENABLE_ALTROUTING
//#define ALTROUTE_DEBUG
typedef struct midrangearea_s
{
int valid;
unsigned short starttime;
unsigned short goaltime;
} midrangearea_t;
midrangearea_t *midrangeareas;
int *clusterareas;
int numclusterareas;
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void AAS_AltRoutingFloodCluster_r(int areanum)
{
int i, otherareanum;
aas_area_t *area;
aas_face_t *face;
//add the current area to the areas of the current cluster
clusterareas[numclusterareas] = areanum;
numclusterareas++;
//remove the area from the mid range areas
midrangeareas[areanum].valid = qfalse;
//flood to other areas through the faces of this area
area = &aasworld.areas[areanum];
for (i = 0; i < area->numfaces; i++)
{
face = &aasworld.faces[abs(aasworld.faceindex[area->firstface + i])];
//get the area at the other side of the face
if (face->frontarea == areanum) otherareanum = face->backarea;
else otherareanum = face->frontarea;
//if there is an area at the other side of this face
if (!otherareanum) continue;
//if the other area is not a midrange area
if (!midrangeareas[otherareanum].valid) continue;
//
AAS_AltRoutingFloodCluster_r(otherareanum);
} //end for
} //end of the function AAS_AltRoutingFloodCluster_r
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int AAS_AlternativeRouteGoals(vec3_t start, int startareanum, vec3_t goal, int goalareanum, int travelflags,
aas_altroutegoal_t *altroutegoals, int maxaltroutegoals,
int type)
{
#ifndef ENABLE_ALTROUTING
return 0;
#else
int i, j, bestareanum;
int numaltroutegoals, nummidrangeareas;
int starttime, goaltime, goaltraveltime;
float dist, bestdist;
vec3_t mid, dir;
#ifdef ALTROUTE_DEBUG
int startmillisecs;
startmillisecs = Sys_MilliSeconds();
#endif
if (!startareanum || !goalareanum)
return 0;
//travel time towards the goal area
goaltraveltime = AAS_AreaTravelTimeToGoalArea(startareanum, start, goalareanum, travelflags);
//clear the midrange areas
Com_Memset(midrangeareas, 0, aasworld.numareas * sizeof(midrangearea_t));
numaltroutegoals = 0;
//
nummidrangeareas = 0;
//
for (i = 1; i < aasworld.numareas; i++)
{
//
if (!(type & ALTROUTEGOAL_ALL))
{
if (!(type & ALTROUTEGOAL_CLUSTERPORTALS && (aasworld.areasettings[i].contents & AREACONTENTS_CLUSTERPORTAL)))
{
if (!(type & ALTROUTEGOAL_VIEWPORTALS && (aasworld.areasettings[i].contents & AREACONTENTS_VIEWPORTAL)))
{
continue;
} //end if
} //end if
} //end if
//if the area has no reachabilities
if (!AAS_AreaReachability(i)) continue;
//tavel time from the area to the start area
starttime = AAS_AreaTravelTimeToGoalArea(startareanum, start, i, travelflags);
if (!starttime) continue;
//if the travel time from the start to the area is greater than the shortest goal travel time
if (starttime > (float) 1.1 * goaltraveltime) continue;
//travel time from the area to the goal area
goaltime = AAS_AreaTravelTimeToGoalArea(i, NULL, goalareanum, travelflags);
if (!goaltime) continue;
//if the travel time from the area to the goal is greater than the shortest goal travel time
if (goaltime > (float) 0.8 * goaltraveltime) continue;
//this is a mid range area
midrangeareas[i].valid = qtrue;
midrangeareas[i].starttime = starttime;
midrangeareas[i].goaltime = goaltime;
Log_Write("%d midrange area %d", nummidrangeareas, i);
nummidrangeareas++;
} //end for
//
for (i = 1; i < aasworld.numareas; i++)
{
if (!midrangeareas[i].valid) continue;
//get the areas in one cluster
numclusterareas = 0;
AAS_AltRoutingFloodCluster_r(i);
//now we've got a cluster with areas through which an alternative route could go
//get the 'center' of the cluster
VectorClear(mid);
for (j = 0; j < numclusterareas; j++)
{
VectorAdd(mid, aasworld.areas[clusterareas[j]].center, mid);
} //end for
VectorScale(mid, 1.0 / numclusterareas, mid);
//get the area closest to the center of the cluster
bestdist = 999999;
bestareanum = 0;
for (j = 0; j < numclusterareas; j++)
{
VectorSubtract(mid, aasworld.areas[clusterareas[j]].center, dir);
dist = VectorLength(dir);
if (dist < bestdist)
{
bestdist = dist;
bestareanum = clusterareas[j];
} //end if
} //end for
//now we've got an area for an alternative route
//FIXME: add alternative goal origin
VectorCopy(aasworld.areas[bestareanum].center, altroutegoals[numaltroutegoals].origin);
altroutegoals[numaltroutegoals].areanum = bestareanum;
altroutegoals[numaltroutegoals].starttraveltime = midrangeareas[bestareanum].starttime;
altroutegoals[numaltroutegoals].goaltraveltime = midrangeareas[bestareanum].goaltime;
altroutegoals[numaltroutegoals].extratraveltime =
(midrangeareas[bestareanum].starttime + midrangeareas[bestareanum].goaltime) -
goaltraveltime;
numaltroutegoals++;
//
#ifdef ALTROUTE_DEBUG
AAS_ShowAreaPolygons(bestareanum, 1, qtrue);
#endif
//don't return more than the maximum alternative route goals
if (numaltroutegoals >= maxaltroutegoals) break;
} //end for
#ifdef ALTROUTE_DEBUG
botimport.Print(PRT_MESSAGE, "alternative route goals in %d msec\n", Sys_MilliSeconds() - startmillisecs);
#endif
return numaltroutegoals;
#endif
} //end of the function AAS_AlternativeRouteGoals
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void AAS_InitAlternativeRouting(void)
{
#ifdef ENABLE_ALTROUTING
if (midrangeareas) FreeMemory(midrangeareas);
midrangeareas = (midrangearea_t *) GetMemory(aasworld.numareas * sizeof(midrangearea_t));
if (clusterareas) FreeMemory(clusterareas);
clusterareas = (int *) GetMemory(aasworld.numareas * sizeof(int));
#endif
} //end of the function AAS_InitAlternativeRouting
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void AAS_ShutdownAlternativeRouting(void)
{
#ifdef ENABLE_ALTROUTING
if (midrangeareas) FreeMemory(midrangeareas);
midrangeareas = NULL;
if (clusterareas) FreeMemory(clusterareas);
clusterareas = NULL;
numclusterareas = 0;
#endif
} //end of the function AAS_ShutdownAlternativeRouting
| 33.120536
| 113
| 0.64874
|
xScooper
|
c5e3189dad6b3008ece4f025a87edef25a0697e9
| 855
|
cpp
|
C++
|
leetcode/top_interview_questions/easy/strings/4.cpp
|
bvbasavaraju/competitive_programming
|
a82ffc1b639588a84f4273b44285d57cdc2f4b11
|
[
"Apache-2.0"
] | 1
|
2020-05-05T13:06:51.000Z
|
2020-05-05T13:06:51.000Z
|
leetcode/top_interview_questions/easy/strings/4.cpp
|
bvbasavaraju/competitive_programming
|
a82ffc1b639588a84f4273b44285d57cdc2f4b11
|
[
"Apache-2.0"
] | null | null | null |
leetcode/top_interview_questions/easy/strings/4.cpp
|
bvbasavaraju/competitive_programming
|
a82ffc1b639588a84f4273b44285d57cdc2f4b11
|
[
"Apache-2.0"
] | null | null | null |
#include <iostream>
using namespace std;
/*
Q: Valid Anagram
Given two strings s and t , write a function to determine if t is an anagram of s.
Example 1:
Input: s = "anagram", t = "nagaram"
Output: true
Example 2:
Input: s = "rat", t = "car"
Output: false
Note:
You may assume the string contains only lowercase alphabets.
Follow up:
What if the inputs contain unicode characters? How would you adapt your solution to such case?
*/
class Solution
{
public:
bool isAnagram(string s, string t)
{
vector<int> s_count(26, 0);
vector<int> t_count(26, 0);
int ls = s.size();
int lt = t.size();
for(int i = 0; i < ls; ++i)
{
s_count[s[i] - 'a']++;
}
for(int i = 0; i < lt; ++i)
{
t_count[t[i] - 'a']++;
}
return (s_count == t_count);
}
};
| 18.191489
| 98
| 0.568421
|
bvbasavaraju
|
c5e8b979e26d0de935772968c5a2a2b53e78187f
| 285
|
hpp
|
C++
|
src/threads/renderer_settings.hpp
|
tanaka141/c10t
|
3cc0ac4cdb7f09767d16632539db747be8a3eb21
|
[
"BSD-3-Clause"
] | 48
|
2015-01-27T15:18:23.000Z
|
2022-02-12T16:26:18.000Z
|
src/threads/renderer_settings.hpp
|
tanaka141/c10t
|
3cc0ac4cdb7f09767d16632539db747be8a3eb21
|
[
"BSD-3-Clause"
] | 17
|
2015-12-16T04:26:12.000Z
|
2022-02-09T07:52:19.000Z
|
src/threads/renderer_settings.hpp
|
tanaka141/c10t
|
3cc0ac4cdb7f09767d16632539db747be8a3eb21
|
[
"BSD-3-Clause"
] | 14
|
2015-01-16T00:15:44.000Z
|
2022-03-21T08:36:02.000Z
|
#ifndef _THREADS_RENDERER_SETTINGS_HPP
#define _THREADS_RENDERER_SETTINGS_HPP
#include <boost/filesystem.hpp>
namespace fs = boost::filesystem;
struct renderer_settings {
bool cache_use;
fs::path cache_dir;
bool cache_compress;
};
#endif /* _THREADS_RENDERER_SETTINGS_HPP */
| 19
| 43
| 0.796491
|
tanaka141
|
c5eae63153ab6343e9801c4319241e04c5cda212
| 1,902
|
hpp
|
C++
|
packages/message_generators/FlatscanGenerator.hpp
|
stereoboy/isaac_sdk_20191213
|
73c863254e626c8d498870189fbfb20be4e10fb3
|
[
"FSFAP"
] | 1
|
2020-04-14T13:55:16.000Z
|
2020-04-14T13:55:16.000Z
|
packages/message_generators/FlatscanGenerator.hpp
|
stereoboy/isaac_sdk_20191213
|
73c863254e626c8d498870189fbfb20be4e10fb3
|
[
"FSFAP"
] | 4
|
2020-09-25T22:34:29.000Z
|
2022-02-09T23:45:12.000Z
|
packages/message_generators/FlatscanGenerator.hpp
|
stereoboy/isaac_sdk_20191213
|
73c863254e626c8d498870189fbfb20be4e10fb3
|
[
"FSFAP"
] | 1
|
2020-07-02T11:51:17.000Z
|
2020-07-02T11:51:17.000Z
|
/*
Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.
NVIDIA CORPORATION and its licensors retain all intellectual property
and proprietary rights in and to this software, related documentation
and any modifications thereto. Any use, reproduction, disclosure or
distribution of this software and related documentation without an express
license agreement from NVIDIA CORPORATION is strictly prohibited.
*/
#pragma once
#include "engine/alice/alice_codelet.hpp"
#include "messages/messages.hpp"
namespace isaac {
namespace message_generators {
// FlatscanGenerator publishes a FlatscanProto periodically.
// Angles are parameterized. Ranges can be optionally randomized by adding an alice::Random
// component to the same node and setting a range_standard_deviation.
class FlatscanGenerator : public alice::Codelet {
public:
void start() override;
void tick() override;
// Outgoing "flat" range scan
ISAAC_PROTO_TX(FlatscanProto, flatscan);
// Beams with a range smaller than or equal to this distance are considered to have returned an
// invalid measurement.
ISAAC_PARAM(double, invalid_range_threshold, 0.2);
// Beams with a range larger than or equal to this distance are considered to not have hit an
// obstacle within the maximum possible range of the sensor.
ISAAC_PARAM(double, out_of_range_threshold, 100.0);
// Number of beams in outgoing message
ISAAC_PARAM(int, beam_count, 1800);
// Azimuth angle range for the beams
ISAAC_PARAM(Vector2d, angles_range, Vector2d(0.0, TwoPi<double>));
// Mean value for the ranges.
ISAAC_PARAM(double, range_mean, 20.0);
// Standard deviation for the range values. Requires an alice::Random component in the same node.
ISAAC_PARAM(double, range_standard_deviation);
};
} // namespace message_generators
} // namespace isaac
ISAAC_ALICE_REGISTER_CODELET(isaac::message_generators::FlatscanGenerator);
| 38.816327
| 99
| 0.783912
|
stereoboy
|
c5ef293c6737b7ef0fcc774ea2711c391220c919
| 344
|
hpp
|
C++
|
christmas_class/higher_order.hpp
|
Nicholas42/Cpp-Bits-and-Pieces
|
bb0cd359d07187319aa7717788dfb5445df0c66f
|
[
"CC0-1.0"
] | null | null | null |
christmas_class/higher_order.hpp
|
Nicholas42/Cpp-Bits-and-Pieces
|
bb0cd359d07187319aa7717788dfb5445df0c66f
|
[
"CC0-1.0"
] | null | null | null |
christmas_class/higher_order.hpp
|
Nicholas42/Cpp-Bits-and-Pieces
|
bb0cd359d07187319aa7717788dfb5445df0c66f
|
[
"CC0-1.0"
] | null | null | null |
template<class Ret, class LHS, class RHS>
struct lazy_evaluation {
lazy_evaluation (Ret (*f) (LHS, RHS), const LHS& l, const RHS& r) : func(f), lhs(l), rhs(r)
{}
Ret operator()() {
return func(lhs, rhs);
}
private:
Ret (*func) (LHS, RHS);
LHS lhs;
RHS rhs;
};
int add(int i, int j) {
return i + j;
}
| 17.2
| 95
| 0.552326
|
Nicholas42
|
c5fc9a53824ca2a48670c0d96a1bb004209a776c
| 1,103
|
cpp
|
C++
|
Coding/C prgs/Queue.cpp
|
Phantom586/My_Codes
|
900c4e5e95ab833e4f78f1594e3b25178a74f1a7
|
[
"MIT"
] | null | null | null |
Coding/C prgs/Queue.cpp
|
Phantom586/My_Codes
|
900c4e5e95ab833e4f78f1594e3b25178a74f1a7
|
[
"MIT"
] | null | null | null |
Coding/C prgs/Queue.cpp
|
Phantom586/My_Codes
|
900c4e5e95ab833e4f78f1594e3b25178a74f1a7
|
[
"MIT"
] | null | null | null |
#include<stdio.h>
#include<conio.h>
#include<conio.h>
int front=-1,rear=-1;
int arr[10];
int max=10;
void Insert(){
if(rear==max){
printf("\nQueue Full");
printf("\n%d %d",front,rear);
}
else if(front==rear){
front=-1;
rear=0;
scanf("%d",&arr[rear]);
}
else{
rear++;
scanf("%d",&arr[rear]);
printf("\n%d %d",front,rear);
}
}
void Delete(){
if(front==rear){
printf("\nQueue Empty");
front=-1;
rear=-1;
printf("\n%d %d",front,rear);
}
else{
front++;
arr[front]=0;
printf("\n%d %d",front,rear);
}
}
void display(){
for(int i=(front+1);i<=rear;i++)
printf("%d",arr[i]);
}
main(){
char ch1;
do{
int ch;
printf("\nSelect Operation :");
printf("\nPress 1 for Inserting an Element :");
printf("\nPress 2 for Deleting an Element :");
scanf("%d",&ch);
if(ch==1){
Insert();
printf("\nQueue After Insertion is :");
display();
}
else if(ch==2){
Delete();
printf("\nQueue After Deletion is :");
display();
}
fflush(stdin);
printf("\nContinue : Y or N");
ch1=getchar();
}while(ch1=='y'||ch1=='Y');
printf("\n%d %d",front,rear);
}
| 17.234375
| 49
| 0.566636
|
Phantom586
|
6801d3b848fe98e1ed33905302550464b9d7e869
| 3,428
|
cpp
|
C++
|
Molecularity/UI/UI.cpp
|
kyle-robinson/directx-game
|
ff5964a6edd3241b703409976f27d68205b9ddd3
|
[
"CC-BY-4.0"
] | 1
|
2021-06-14T22:44:01.000Z
|
2021-06-14T22:44:01.000Z
|
Molecularity/UI/UI.cpp
|
kyle-robinson/directx-game
|
ff5964a6edd3241b703409976f27d68205b9ddd3
|
[
"CC-BY-4.0"
] | null | null | null |
Molecularity/UI/UI.cpp
|
kyle-robinson/directx-game
|
ff5964a6edd3241b703409976f27d68205b9ddd3
|
[
"CC-BY-4.0"
] | 1
|
2021-06-04T12:44:06.000Z
|
2021-06-04T12:44:06.000Z
|
#include "stdafx.h"
#include "UI.h"
UI::~UI()
{
}
void UI::Initialize(ID3D11Device* device, ID3D11DeviceContext* contex, ConstantBuffer<CB_VS_matrix_2D>* cb_vs_matrix_2d, std::shared_ptr<Fonts> fonts)
{
FontsList = fonts;
_Device = device;
_Contex = contex;
_cb_vs_matrix_2d = cb_vs_matrix_2d;
}
//convert from unsigned char to understandble string fromat
string UI::ConvertFromUnsignedCharToString(unsigned char input)
{
string text;
switch (input)
{
//other keys
case VK_RETURN:
text = "Return";
break;
case VK_SPACE:
text = "Space";
break;
case VK_SHIFT:
case VK_LSHIFT:
case VK_RSHIFT:
text = "Shift";
break;
case VK_CONTROL:
text = "Ctrl";
break;
//alt
case VK_MENU:
text = "alt";
break;
case VK_PAUSE:
text = "Pause";
break;
case VK_ESCAPE:
text = "ESC";
break;
case VK_CAPITAL:
text = "CAPS LOCK";
break;
case VK_BACK:
text = "BACKSPACE";
break;
case VK_TAB:
text = "Tab";
break;
//page up
case VK_PRIOR:
text = "page Up";
break;
//page down
case VK_NEXT:
text = "page Down";
break;
case VK_END:
text = "End";
case VK_HOME:
text = "Home";
break;
case VK_SELECT:
text = "Select";
break;
case VK_INSERT:
text = "Ins";
break;
case VK_DELETE:
text = "Del";
break;
case VK_HELP:
text = "Help";
break;
case VK_SCROLL:
text = "Scr Lock";
break;
case VK_CLEAR:
text = "Clear";
break;
//arrow keys
case VK_UP:
text = "Up Arrow";
break;
case VK_DOWN:
text = "Down Arrow";
break;
case VK_LEFT:
text = "Left Arrow";
break;
case VK_RIGHT:
text = "Right Arrow";
break;
//F keys
case VK_F1:
text = "F1";
break;
case VK_F2:
text = "F2";
break;
case VK_F3:
text = "F3";
break;
case VK_F4:
text = "F4";
break;
case VK_F5:
text = "F5";
break;
case VK_F6:
text = "F6";
break;
case VK_F7:
text = "F7";
break;
case VK_F8:
text = "F8";
break;
case VK_F9:
text = "F9";
break;
case VK_F10:
text = "F10";
break;
case VK_F11:
text = "F11";
break;
case VK_F12:
text = "F12";
break;
//numpad
case VK_NUMLOCK:
text = "Numlock";
break;
case VK_NUMPAD0:
text = "Numpad 0";
break;
case VK_NUMPAD1:
text = "Numpad 1";
break;
case VK_NUMPAD2:
text = "Numpad 2";
break;
case VK_NUMPAD3:
text = "Numpad 3";
break;
case VK_NUMPAD4:
text = "Numpad 4";
break;
case VK_NUMPAD5:
text = "Numpad 5";
break;
case VK_NUMPAD6:
text = "Numpad 6";
break;
case VK_NUMPAD7:
text = "Numpad 7";
break;
case VK_NUMPAD8:
text = "Numpad 8";
break;
case VK_NUMPAD9:
text = "Numpad 9";
break;
//math keys
case VK_MULTIPLY:
text = "*";
break;
case VK_ADD:
text = "+";
break;
case VK_SEPARATOR:
text = "";
break;
case VK_SUBTRACT:
text = "-";
break;
case VK_DECIMAL:
text = ".";
break;
case VK_DIVIDE:
text = "/";
break;
//number key codes
//Braket left
case 219:
text = "[";
break;
//Braket right
case 221:
text = "]";
break;
case 222:
text = "#";
break;
case 186:
text = ";";
break;
case 192:
text = "'";
case 188:
text = ",";
break;
case 187:
text = "=";
break;
case 223:
text = "`";
break;
case 220:
text = "\\";
break;
case 191:
text = "/";
break;
case 190:
text = ".";
break;
//all other keys
default:
text = input;
break;
}
return text;
}
| 11.166124
| 150
| 0.590432
|
kyle-robinson
|
6801e5fd089f1dec58ac286ae62f69a1de8444b4
| 10,748
|
cc
|
C++
|
Engine/addons/particles/affectors/particleColorAffectorSerialization.cc
|
BikkyS/DreamEngine
|
47da4e22c65188c72f44591f6a96505d8ba5f5f3
|
[
"MIT"
] | 26
|
2015-01-15T12:57:40.000Z
|
2022-02-16T10:07:12.000Z
|
Engine/addons/particles/affectors/particleColorAffectorSerialization.cc
|
BikkyS/DreamEngine
|
47da4e22c65188c72f44591f6a96505d8ba5f5f3
|
[
"MIT"
] | null | null | null |
Engine/addons/particles/affectors/particleColorAffectorSerialization.cc
|
BikkyS/DreamEngine
|
47da4e22c65188c72f44591f6a96505d8ba5f5f3
|
[
"MIT"
] | 17
|
2015-02-18T07:51:31.000Z
|
2020-06-01T01:10:12.000Z
|
/****************************************************************************
Copyright (c) 2011-2013,WebJet Business Division,CYOU
http://www.genesis-3d.com.cn
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
****************************************************************************/
#include "stdneb.h"
#include "particles/affectors/particleColorAffector.h"
namespace Particles
{
using namespace Serialization;
const static char* s_ColorCount = "ColorCount";
const static char* s_ColorKey = "ColorKey";
const static char* s_ColorValue = "ColorValue";
const static char* s_TimeAlpha = "TimeAlpha";
const static char* s_MinAlpha = "MinAlpha";
const static char* s_MaxAlpha = "MaxAlpha";
const static char* s_AlphaCount = "AlphaCount";
const static char* s_AlphaValue = "AlphaValue";
const static char* s_ColorRandom = "ColorRandom";
const static char* s_ColorControlType = "ColorControlType";
extern const char* s_KeyFrameCount;
extern const char* s_CurveKey;
extern const char* s_CurveValue;
class ColorAffectorSerialization
{
public:
//------------------------------------------------------------------------
void Load( ColorAffector* obj, SVersion ver, SerializeReader* pReader )
{
if ( 1 == ver )
{
Load_1(obj, pReader);
return;
}
else if(2 == ver)
{
Load_2(obj, pReader);
return;
}
else if(3 == ver)
{
Load_3(obj,pReader);
return;
}
else if(4 == ver)
{
Load_4(obj,pReader);
return;
}
else if(5 == ver)
{
Load_5(obj,pReader);
return;
}
else if(6 == ver)
{
Load_6(obj,pReader);
return;
}
else if(7 == ver)
{
Load_7(obj,pReader);
return;
}
n_error(" %s Load unknown version.\n", obj->GetClassName().AsCharPtr() );
}
//------------------------------------------------------------------------
void Load_7(ColorAffector* obj, SerializeReader* pReader)
{
int mColorControlType;
pReader->SerializeInt(s_ColorControlType, mColorControlType );
obj->SetColorContrlType((ColorContrlType)mColorControlType);
_serializeLoadMinMaxCurve(pReader,*obj->getMinMaxCurve(Affector_ColorR),"colorR",s_CurveKey);
_serializeLoadMinMaxCurve(pReader,*obj->getMinMaxCurve(Affector_ColorG),"colorG",s_CurveKey);
_serializeLoadMinMaxCurve(pReader,*obj->getMinMaxCurve(Affector_ColorB),"colorB",s_CurveKey);
_serializeLoadMinMaxCurve(pReader,*obj->getMinMaxCurve(Affector_ColorA),"colorA",s_CurveKey);
}
//------------------------------------------------------------------------
void Load_6(ColorAffector* obj, SerializeReader* pReader)
{
int mColorControlType;
pReader->SerializeInt(s_ColorControlType, mColorControlType );
obj->SetColorContrlType((ColorContrlType)mColorControlType);
_serializeLoadMinMaxCurveOld(pReader,*obj->getMinMaxCurve(Affector_ColorR),"colorR",s_CurveKey);
_serializeLoadMinMaxCurveOld(pReader,*obj->getMinMaxCurve(Affector_ColorG),"colorG",s_CurveKey);
_serializeLoadMinMaxCurveOld(pReader,*obj->getMinMaxCurve(Affector_ColorB),"colorB",s_CurveKey);
_serializeLoadMinMaxCurveOld(pReader,*obj->getMinMaxCurve(Affector_ColorA),"colorA",s_CurveKey);
}
//------------------------------------------------------------------------
void Load_5(ColorAffector* obj, SerializeReader* pReader)
{
bool colorRandom;
pReader->SerializeBool(s_ColorRandom,colorRandom);
if(colorRandom)
{
obj->getMinMaxCurve(Affector_ColorR)->SetCurveState(Math::MinMaxCurve::TwoCurves);
obj->getMinMaxCurve(Affector_ColorG)->SetCurveState(Math::MinMaxCurve::TwoCurves);
obj->getMinMaxCurve(Affector_ColorB)->SetCurveState(Math::MinMaxCurve::TwoCurves);
obj->getMinMaxCurve(Affector_ColorA)->SetCurveState(Math::MinMaxCurve::TwoCurves);
}
else
{
obj->getMinMaxCurve(Affector_ColorR)->SetCurveState(Math::MinMaxCurve::Curve);
obj->getMinMaxCurve(Affector_ColorG)->SetCurveState(Math::MinMaxCurve::Curve);
obj->getMinMaxCurve(Affector_ColorB)->SetCurveState(Math::MinMaxCurve::Curve);
obj->getMinMaxCurve(Affector_ColorA)->SetCurveState(Math::MinMaxCurve::Curve);
}
Load_4(obj,pReader);
}
//------------------------------------------------------------------------
void Load_3(ColorAffector* obj, SerializeReader* pReader)
{
SizeT colorcount;
pReader->SerializeInt(s_ColorCount, colorcount );
for ( IndexT index = 0; index < colorcount; ++index )
{
Math::scalar colorkey;
Math::float4 colorvalue;
pReader->SerializeFloat(s_ColorKey, colorkey);
pReader->SerializeFloat4(s_ColorValue, colorvalue );
}
bool timeAlpha;
pReader->SerializeBool(s_TimeAlpha,timeAlpha);
float minAlpha;
pReader->SerializeFloat(s_MinAlpha,minAlpha);
float maxAlpha;
pReader->SerializeFloat(s_MaxAlpha,maxAlpha);
SizeT alphaCount;
pReader->SerializeInt(s_AlphaCount,alphaCount);
for ( IndexT index = 0; index < alphaCount; ++index )
{
float alpha;
pReader->SerializeFloat(s_AlphaValue,alpha);
}
}
//------------------------------------------------------------------------
void Load_2(ColorAffector* obj, SerializeReader* pReader)
{
SizeT colorcount;
pReader->SerializeInt(s_ColorCount, colorcount );
for ( IndexT index = 0; index < colorcount; ++index )
{
Math::scalar colorkey;
Math::float4 colorvalue;
pReader->SerializeFloat(s_ColorKey, colorkey);
pReader->SerializeFloat4(s_ColorValue, colorvalue );
}
bool timeAlpha;
pReader->SerializeBool(s_TimeAlpha,timeAlpha);
float minAlpha;
pReader->SerializeFloat(s_MinAlpha,minAlpha);
float maxAlpha;
pReader->SerializeFloat(s_MaxAlpha,maxAlpha);
}
//------------------------------------------------------------------------
void Load_1(ColorAffector* obj, SerializeReader* pReader)
{
SizeT colorcount;
pReader->SerializeInt(s_ColorCount, colorcount );
for ( IndexT index = 0; index < colorcount; ++index )
{
Math::scalar colorkey;
Math::float4 colorvalue;
pReader->SerializeFloat(s_ColorKey, colorkey);
pReader->SerializeFloat4(s_ColorValue, colorvalue );
}
}
//------------------------------------------------------------------------
void Load_4(ColorAffector* obj, SerializeReader* pReader)
{
int mColorControlType;
pReader->SerializeInt(s_ColorControlType, mColorControlType );
obj->SetColorContrlType((ColorContrlType)mColorControlType);
Util::Array<Math::float2> keyframelist1;
Util::Array<Math::float2> keyframelist2;
Math::MinMaxCurve* curve = obj->getMinMaxCurve(Affector_ColorR);
_serializeLoadCurveOld(pReader, keyframelist1, "colorRMin", s_CurveKey);
_serializeLoadCurveOld(pReader, keyframelist2, "colorRMax", s_CurveKey);
_setCurveOld(keyframelist1,keyframelist2,curve);
curve = obj->getMinMaxCurve(Affector_ColorG);
_serializeLoadCurveOld(pReader, keyframelist1, "colorGMin", s_CurveKey);
_serializeLoadCurveOld(pReader, keyframelist2, "colorGMax", s_CurveKey);
_setCurveOld(keyframelist1,keyframelist2,curve);
curve = obj->getMinMaxCurve(Affector_ColorB);
_serializeLoadCurveOld(pReader, keyframelist1, "colorBMin", s_CurveKey);
_serializeLoadCurveOld(pReader, keyframelist2, "colorBMax", s_CurveKey);
_setCurveOld(keyframelist1,keyframelist2,curve);
curve = obj->getMinMaxCurve(Affector_ColorA);
_serializeLoadCurveOld(pReader, keyframelist1, "colorAMin", s_CurveKey);
_serializeLoadCurveOld(pReader, keyframelist2, "colorAMax", s_CurveKey);
_setCurveOld(keyframelist1,keyframelist2,curve);
}
//------------------------------------------------------------------------
void Save( const ColorAffector* obj, SerializeWriter* pWriter )
{
pWriter->SerializeInt(s_ColorControlType, (int)obj->GetColorContrlType() );
_serializeSaveMinMaxCurve(pWriter,*((ColorAffector* )obj)->getMinMaxCurve(Affector_ColorR),"colorR",s_CurveKey);
_serializeSaveMinMaxCurve(pWriter,*((ColorAffector* )obj)->getMinMaxCurve(Affector_ColorG),"colorG",s_CurveKey);
_serializeSaveMinMaxCurve(pWriter,*((ColorAffector* )obj)->getMinMaxCurve(Affector_ColorB),"colorB",s_CurveKey);
_serializeSaveMinMaxCurve(pWriter,*((ColorAffector* )obj)->getMinMaxCurve(Affector_ColorA),"colorA",s_CurveKey);
}
};
//------------------------------------------------------------------------
// @ISerialization::GetVersion. when change storage, must add SerializeVersion count
SVersion ColorAffector::GetVersion() const
{
return 7; // the current version is 7
}
//------------------------------------------------------------------------
// @ISerialization::Load
void ColorAffector::Load( SVersion ver, SerializeReader* pReader, const Serialization::SerializationArgs* args )
{
pReader->SerializeSuper<Super>(this, args);
ColorAffectorSerialization Serialize;
Serialize.Load( this, ver, pReader );
}
//------------------------------------------------------------------------
// @ISerialization::Save
void ColorAffector::Save( SerializeWriter* pWriter ) const
{
pWriter->SerializeSuper<Super>(this);
ColorAffectorSerialization Serialize;
Serialize.Save( this, pWriter );
}
//------------------------------------------------------------------------
void ColorAffector::CopyFrom( const ParticleAffectorPtr& target )
{
Super::CopyFrom( target );
n_assert( target->GetRtti() == this->GetRtti() );
GPtr<ColorAffector> source = target.downcast<ColorAffector>();
SetColorContrlType(source->GetColorContrlType());
_serializeCopyMinMaxCurve(source->mMinMaxColorR,this->mMinMaxColorR);
_serializeCopyMinMaxCurve(source->mMinMaxColorG,this->mMinMaxColorG);
_serializeCopyMinMaxCurve(source->mMinMaxColorB,this->mMinMaxColorB);
_serializeCopyMinMaxCurve(source->mMinMaxColorA,this->mMinMaxColorA);
}
}
| 37.319444
| 115
| 0.670543
|
BikkyS
|
68048afabed63b3d36a764b738cdeaae5b1c4342
| 1,468
|
cc
|
C++
|
Core/src/UserInfo.cc
|
frankencode/CoreComponents
|
4c66d7ff9fc5be19222906ba89ba0e98951179de
|
[
"Zlib"
] | 1
|
2019-07-29T04:07:29.000Z
|
2019-07-29T04:07:29.000Z
|
Core/src/UserInfo.cc
|
frankencode/CoreComponents
|
4c66d7ff9fc5be19222906ba89ba0e98951179de
|
[
"Zlib"
] | null | null | null |
Core/src/UserInfo.cc
|
frankencode/CoreComponents
|
4c66d7ff9fc5be19222906ba89ba0e98951179de
|
[
"Zlib"
] | 1
|
2020-03-04T17:13:04.000Z
|
2020-03-04T17:13:04.000Z
|
/*
* Copyright (C) 2020 Frank Mertens.
*
* Distribution and use is allowed under the terms of the zlib license
* (see cc/LICENSE-zlib).
*
*/
#include <cc/UserInfo>
#include <sys/types.h>
#include <unistd.h> // sysconf
#include <pwd.h>
namespace cc {
UserInfo::State::State(const struct passwd &info):
id{static_cast<int>(info.pw_uid)},
groupId{static_cast<int>(info.pw_gid)},
loginName{info.pw_name},
fullName{info.pw_gecos},
home{info.pw_dir},
shell{info.pw_shell}
{
if (fullName.startsWith(',') || fullName.endsWith(',')) {
fullName = loginName.copy();
fullName[0] = toUpper(fullName[0]);
}
}
UserInfo::UserInfo(int id)
{
int bufSize = sysconf(_SC_GETPW_R_SIZE_MAX);
if (bufSize == -1) CC_SYSTEM_DEBUG_ERROR(errno);
String buf = String::allocate(bufSize);
struct passwd space;
struct passwd *info = nullptr;
int ret = ::getpwuid_r(id, &space, buf, +buf, &info);
if (ret != 0) CC_SYSTEM_DEBUG_ERROR(ret);
if (info) Object::me = new State{*info};
}
UserInfo::UserInfo(const String &name)
{
int bufSize = sysconf(_SC_GETPW_R_SIZE_MAX);
if (bufSize == -1) CC_SYSTEM_DEBUG_ERROR(errno);
String buf = String::allocate(bufSize);
struct passwd space;
struct passwd *info = nullptr;
int ret = ::getpwnam_r(name, &space, buf, +buf, &info);
if (ret != 0) CC_SYSTEM_RESOURCE_ERROR(ret, name);
if (info) Object::me = new State{*info};
}
} // namespace cc
| 26.690909
| 70
| 0.65327
|
frankencode
|
680925e6ac8db11ac6761902255bf37562e55573
| 3,983
|
cc
|
C++
|
core/src/bbdo/input_buffer.cc
|
sdelafond/centreon-broker
|
21178d98ed8a061ca71317d23c2026dbc4edaca2
|
[
"Apache-2.0"
] | null | null | null |
core/src/bbdo/input_buffer.cc
|
sdelafond/centreon-broker
|
21178d98ed8a061ca71317d23c2026dbc4edaca2
|
[
"Apache-2.0"
] | null | null | null |
core/src/bbdo/input_buffer.cc
|
sdelafond/centreon-broker
|
21178d98ed8a061ca71317d23c2026dbc4edaca2
|
[
"Apache-2.0"
] | null | null | null |
/*
** Copyright 2017 Centreon
**
** 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.
**
** For more information : contact@centreon.com
*/
#include "com/centreon/broker/bbdo/input_buffer.hh"
#include "com/centreon/broker/exceptions/msg.hh"
using namespace com::centreon::broker;
using namespace com::centreon::broker::bbdo;
/**
* Default constructor.
*/
input_buffer::input_buffer() : _first_offset(0), _size(0) {}
/**
* Copy constructor.
*
* @param[in] other Object to copy.
*/
input_buffer::input_buffer(input_buffer const& other) {
_internal_copy(other);
}
/**
* Destructor.
*/
input_buffer::~input_buffer() {}
/**
* Assignment operator.
*
* @param[in] other Object to copy.
*
* @return This object.
*/
input_buffer& input_buffer::operator=(input_buffer const& other) {
if (this != &other)
_internal_copy(other);
return (*this);
}
/**
* Append data to buffer.
*
* @param[in] d Data.
*/
void input_buffer::append(std::shared_ptr<io::raw> const& d) {
if (d && d->size()) {
if (_data.empty())
_first_offset = 0;
_data.push_back(d);
_size += d->size();
}
}
/**
* Erase bytes from beginning of buffer.
*
* @param[in] bytes Number of bytes to discard.
*/
void input_buffer::erase(int bytes) {
// Adjust size.
_size -= bytes;
if (_size < 0)
_size = 0;
while (bytes && !_data.empty()) {
// If the number of bytes available in first object is less than
// the number of bytes to erase, pop first object.
int available(_data.front()->size() - _first_offset);
if (bytes >= available) {
_data.pop_front();
_first_offset = 0;
bytes -= available;
}
// Otherwise current object still has available data.
else {
_first_offset += bytes;
bytes = 0;
}
}
return ;
}
/**
* Extract data from buffer.
*
* @param[out] output Output buffer.
* @param[in] offset Start position.
* @param[in] size Number of bytes to extract.
*/
void input_buffer::extract(std::string& output, int offset, int size) {
// Find initial position.
std::list<std::shared_ptr<io::raw> >::const_iterator
it(_data.begin()), end(_data.end());
int it_offset(_first_offset);
for (int remaining(offset); it != end; ++it, it_offset = 0) {
int available((*it)->size() - it_offset);
if (remaining < available) {
it_offset += remaining;
break ;
}
else
remaining -= available;
}
// Extract data.
int remaining(size);
for (; remaining && (it != end); ++it, it_offset = 0) {
int to_extract((*it)->size() - it_offset);
if (to_extract > remaining)
to_extract = remaining;
output.append((*it)->constData() + it_offset, to_extract);
remaining -= to_extract;
}
// Check that extraction was successful.
if (remaining)
throw (exceptions::msg() << "BBDO: cannot extract " << size
<< " bytes at offset " << offset
<< " from input buffer, only "
<< _size << " bytes available: this is likely a software bug"
<< " that you should report to Centreon Broker developers");
return ;
}
/**
* Get buffer size.
*
* @return Buffer size in bytes.
*/
int input_buffer::size() const {
return (_size);
}
/**
* Copy internal data members.
*
* @param[in] other Object to copy.
*/
void input_buffer::_internal_copy(input_buffer const& other) {
_data = other._data;
_first_offset = other._first_offset;
_size = other._size;
return ;
}
| 24.435583
| 75
| 0.639719
|
sdelafond
|
680cc66d53a00574450fc94f766acd5cb5b0d021
| 3,706
|
cpp
|
C++
|
src/LightSystem.cpp
|
imerr/SFMLEngine
|
0f1569f5ba8bf092e3c32827d159c10aa9463725
|
[
"MIT"
] | 4
|
2016-12-10T05:03:30.000Z
|
2017-10-16T08:40:16.000Z
|
src/LightSystem.cpp
|
imermcmaps/SFMLEngine
|
0f1569f5ba8bf092e3c32827d159c10aa9463725
|
[
"MIT"
] | 5
|
2015-03-21T08:47:59.000Z
|
2015-03-21T15:55:37.000Z
|
src/LightSystem.cpp
|
imermcmaps/SFMLEngine
|
0f1569f5ba8bf092e3c32827d159c10aa9463725
|
[
"MIT"
] | 1
|
2017-12-05T05:10:56.000Z
|
2017-12-05T05:10:56.000Z
|
/*
* File: LightSystem.cpp
* Author: iMer
*
* Created on 17. August 2014, 10:39
*/
#include "LightSystem.hpp"
#include "Scene.hpp"
#include "Game.hpp"
#include <iostream>
namespace engine {
void applyShader(const sf::Shader& shader, sf::RenderTarget& output) {
sf::Vector2f outputSize(static_cast<float>(output.getSize().x),
static_cast<float>(output.getSize().y));
sf::VertexArray vertices(sf::TrianglesStrip, 4);
vertices[0] = sf::Vertex(sf::Vector2f(0, 0), sf::Vector2f(0, 1));
vertices[1] = sf::Vertex(sf::Vector2f(outputSize.x, 0), sf::Vector2f(1, 1));
vertices[2] = sf::Vertex(sf::Vector2f(0, outputSize.y), sf::Vector2f(0, 0));
vertices[3] = sf::Vertex(sf::Vector2f(outputSize), sf::Vector2f(1, 0));
sf::RenderStates states;
states.shader = &shader;
states.blendMode = sf::BlendNone;
output.draw(vertices, states);
}
LightSystem::LightSystem(Scene* scene) : m_scene(scene), m_ambientColor(sf::Color::White), m_needsUpdate(true),
m_enabled(true) {
#ifndef DISABLE_LIGHTING
if (!sf::Shader::isAvailable()) {
std::cerr << "Shaders are not available" << std::endl;
m_available = false;
} else {
m_available = true;
m_blurShader.loadFromFile("assets/shader/fullpass.vert", "assets/shader/blur.frag");
}
auto size = m_scene->GetGame()->GetWindow()->getView().getSize();
m_buffer.create(static_cast<unsigned int>(size.x), static_cast<unsigned int>(size.y));
m_pingPongBuffer.create(static_cast<unsigned int>(size.x), static_cast<unsigned int>(size.y));
m_buffer.setActive(false);
m_pingPongBuffer.setActive(false);
#else
m_enabled = false;
#endif
}
LightSystem::~LightSystem() {
}
bool LightSystem::update(sf::Time interval) {
m_needsUpdate = true;
return false;
}
void LightSystem::draw(sf::RenderTarget& target, sf::RenderStates states) {
if (!m_enabled) {
return;
}
std::lock_guard<std::recursive_mutex> lg(m_drawLock);
sf::Sprite s;
if (m_needsUpdate) {
m_needsUpdate = false;
m_buffer.clear(m_ambientColor);
states.blendMode = sf::BlendAdd;
std::for_each(m_lights.begin(), m_lights.end(), [this, &states](Light* light) {
light->DrawLight(m_buffer, states);
});
m_buffer.display();
if (m_available) {
auto textureSize = m_buffer.getSize();
for (size_t i = 0; i < blurPasses; i++) {
m_blurShader.setParameter("offsetFactor", sf::Vector2f(0.0f, 2.f / textureSize.y));
m_blurShader.setParameter("source", m_buffer.getTexture());
applyShader(m_blurShader, m_pingPongBuffer);
m_blurShader.setParameter("offsetFactor", sf::Vector2f(2.0f / textureSize.x, 0.0f));
m_blurShader.setParameter("source", m_pingPongBuffer.getTexture());
applyShader(m_blurShader, m_buffer);
m_buffer.display();
}
}
}
sf::Transformable tr;
auto window = m_scene->GetGame()->GetWindow();
tr.setPosition(window->getView().getCenter().x - (window->getView().getSize().x / 2),
window->getView().getCenter().y - (window->getView().getSize().y / 2));
states.transform *= tr.getTransform();
states.blendMode = sf::BlendMultiply;
s.setTexture(m_buffer.getTexture());
target.draw(s, states);
}
void LightSystem::SetAmbientColor(sf::Color ambientColor) {
m_ambientColor = ambientColor;
}
sf::Color LightSystem::GetAmbientColor() const {
return m_ambientColor;
}
void LightSystem::SetEnabled(bool enabled) {
m_enabled = enabled;
}
bool LightSystem::IsEnabled() const {
return m_enabled;
}
void LightSystem::AddLight(Light* light) {
m_lights.push_back(light);
}
void LightSystem::RemoveLight(Light* light) {
// bleh
std::lock_guard<std::recursive_mutex> lg(m_drawLock);
m_lights.remove(light);
}
}
| 30.130081
| 112
| 0.688883
|
imerr
|
680dcfcde0297cd0a3f685f7057915b6bf0e7930
| 1,997
|
cpp
|
C++
|
B_car/src/BalanceCar.cpp
|
fangshirui/uno
|
dd7d75594f55274c34883c19a14542b4bab30b55
|
[
"MIT"
] | 2
|
2019-11-21T04:42:12.000Z
|
2020-09-14T02:11:37.000Z
|
B_car/src/BalanceCar.cpp
|
fangshirui/uno
|
dd7d75594f55274c34883c19a14542b4bab30b55
|
[
"MIT"
] | null | null | null |
B_car/src/BalanceCar.cpp
|
fangshirui/uno
|
dd7d75594f55274c34883c19a14542b4bab30b55
|
[
"MIT"
] | null | null | null |
/*
* @Author: FangShiRui
* @Date: 2019-08-10 09:11:06
* @LastEditors: FangShiRui
* @LastEditTime: 2020-07-16 10:16:57
* @Description: 平衡车pid 输出 pwm 计算
*/
#include "BalanceCar.h"
void BalanceCar::get_angleout(double kp, double ki, double kd, float angle, float gyro_x)
{
angleoutput = kp * angle + kd * gyro_x;
}
void BalanceCar::get_speedout(double kps, double kis, double kds, double p0)
{
double speeds = (pulseleft + pulseright) * 1.0;
pulseright = pulseleft = 0; //每次进行速度pi计算，都会给脉冲数置零，也即每隔40ms
//* 一阶互补滤波
speeds_filterold *= 0.7;
double speeds_filter = speeds_filterold + speeds * 0.3;
speeds_filterold = speeds_filter;
// 位置量即所有周期（40ms）速度量的累加
positions += speeds_filter;
// 位置量幅值限制
positions = constrain(positions, -3550, 3550);
speedoutput = kis * (p0 - positions) + kps * (p0 - speeds_filter);
}
void BalanceCar::get_pwm(float angle, float angle6, int R_IN1, int R_IN2, int L_IN1, int L_IN2, int R_PWM, int L_PWM)
{
pwm_r = angleoutput - speedoutput; //右侧电机控制量
pwm_l = angleoutput - speedoutput; //左侧电机控制量
//设置幅值限制
if (pwm_r > 255)
pwm_r = 255;
if (pwm_r < -255)
pwm_r = -255;
if (pwm_l > 255)
pwm_l = 255;
if (pwm_l < -255)
pwm_l = -255;
//设置停转俯仰角和停转翻转角
if (angle > 30 || angle < -30 || angle6 < -10 || angle6 > 10) {
pwm_r = 0;
pwm_l = 0;
}
if (pwm_r >= 0) {
digitalWrite(R_IN2, 0);
digitalWrite(R_IN1, 1);
analogWrite(R_PWM, pwm_r);
} else {
digitalWrite(R_IN2, 1);
digitalWrite(R_IN1, 0);
analogWrite(R_PWM, -pwm_r);
}
if (pwm_l >= 0) {
digitalWrite(L_IN2, 0);
digitalWrite(L_IN1, 1);
analogWrite(L_PWM, pwm_l);
} else {
digitalWrite(L_IN2, 1);
digitalWrite(L_IN1, 0);
analogWrite(L_PWM, -pwm_l);
}
}
void BalanceCar::go_forward()
{
positions -= 250;
}
void BalanceCar::go_back()
{
positions += 250;
}
| 23.22093
| 117
| 0.598398
|
fangshirui
|
680fa1e997c61d0f5845d1958fb5e1b1dfafc071
| 6,236
|
cpp
|
C++
|
metaspritegen.cpp
|
pubby/lunarlim
|
71a3412e02a3909bd2cd39d00a861a37e02fe8fa
|
[
"CC-BY-4.0"
] | null | null | null |
metaspritegen.cpp
|
pubby/lunarlim
|
71a3412e02a3909bd2cd39d00a861a37e02fe8fa
|
[
"CC-BY-4.0"
] | null | null | null |
metaspritegen.cpp
|
pubby/lunarlim
|
71a3412e02a3909bd2cd39d00a861a37e02fe8fa
|
[
"CC-BY-4.0"
] | null | null | null |
#include <cstdlib>
#include <cstdio>
#include <fstream>
#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
//pchar_animation_lo_table:
struct sprite_t
{
int x_off;
int y_off;
int pattern;
int attributes;
};
std::uint32_t sprite_byte(sprite_t sprite)
{
unsigned char const x = sprite.x_off;
unsigned char const y = sprite.y_off;
unsigned char const p = sprite.pattern;
unsigned char const a = sprite.attributes;
return x | (y << 8) | (p << 16) | (a << 24);
}
bool operator==(sprite_t lhs, sprite_t rhs)
{
return sprite_byte(lhs) == sprite_byte(rhs);
}
bool operator<(sprite_t lhs, sprite_t rhs)
{
return sprite_byte(lhs) < sprite_byte(rhs);
}
using metasprite_t = std::vector<sprite_t>;
struct animation_t
{
char const* name;
int width;
int height;
int flags;
std::vector<metasprite_t> frames;
};
unsigned char HFLIP = 1 << 6;
unsigned char VFLIP = 1 << 7;
constexpr unsigned char PATTERN(unsigned char x)
{
return x;
}
static std::vector<animation_t> const animations =
{
{ "explosion", 24, 24, 0, {
{
{ 0, 0, PATTERN(0x65), 0 },
{ 0, 8, PATTERN(0x75), 0 },
{ 0, 16, PATTERN(0x65), VFLIP },
{ 8, 0, PATTERN(0x66), 0 },
{ 8, 16, PATTERN(0x66), VFLIP },
{ 16, 0, PATTERN(0x65), HFLIP },
{ 16, 8, PATTERN(0x75), HFLIP },
{ 16, 16, PATTERN(0x65), HFLIP | VFLIP },
},
{
{ 0, 0, PATTERN(0x63), 0 },
{ 0, 8, PATTERN(0x73), 0 },
{ 0, 16, PATTERN(0x63), VFLIP },
{ 8, 0, PATTERN(0x64), 0 },
{ 8, 16, PATTERN(0x64), VFLIP },
{ 16, 0, PATTERN(0x63), HFLIP },
{ 16, 8, PATTERN(0x73), HFLIP },
{ 16, 16, PATTERN(0x63), HFLIP | VFLIP },
},
{
{ 0, 0, PATTERN(0x61), 0 },
{ 0, 8, PATTERN(0x71), 0 },
{ 0, 16, PATTERN(0x61), VFLIP },
{ 8, 0, PATTERN(0x62), 0 },
{ 8, 8, PATTERN(0x72), 0 },
{ 8, 16, PATTERN(0x62), VFLIP },
{ 16, 0, PATTERN(0x61), HFLIP },
{ 16, 8, PATTERN(0x71), HFLIP },
{ 16, 16, PATTERN(0x61), HFLIP | VFLIP },
},
{
{ 4, 4, PATTERN(0x60), 0 },
{ 4, 12, PATTERN(0x70), 0 },
{ 12, 4, PATTERN(0x60), HFLIP },
{ 12, 12, PATTERN(0x70), HFLIP },
},
}},
};
int get_width(std::vector<sprite_t> const& sprites)
{
int x_max = 0;
for(sprite_t sprite : sprites)
if(sprite.x_off > x_max)
x_max = sprite.x_off;
return x_max + 8;
}
int get_height(std::vector<sprite_t> const& sprites)
{
int y_max = 0;
for(sprite_t sprite : sprites)
if(sprite.y_off > y_max)
y_max = sprite.y_off;
return y_max + 8;
}
std::vector<sprite_t> hmirror(std::vector<sprite_t> sprites, int width)
{
for(sprite_t& sprite : sprites)
{
sprite.x_off = width - sprite.x_off - 8;
sprite.attributes ^= HFLIP;
}
return sprites;
}
std::vector<sprite_t> hmirror(std::vector<sprite_t> sprites)
{
return hmirror(sprites, get_width(sprites));
}
int main(int argc, char** argv)
{
if(argc != 2)
{
std::fprintf(stderr, "usage: %s [outfile]\n", argv[0]);
return EXIT_FAILURE;
}
FILE* fp = std::fopen(argv[1], "w");
if(!fp)
{
std::fprintf(stderr, "can't open file %s\n", argv[1]);
return EXIT_FAILURE;
}
std::fprintf(fp, ".scope metasprite\n");
/*
out << "metasprite_lo_table:\n";
for(std::size_t i = 0; i != explosion_metasprites.frames.size(); ++i)
out << ".byt .lobyte(metasprite_" << i << ")\n";
out << "metasprite_hi_table:\n";
for(std::size_t i = 0; i != explosion_metasprites.frames.size(); ++i)
out << ".byt .hibyte(metasprite_" << i << ")\n";
out << '\n';
*/
std::map<metasprite_t, unsigned> frame_map;
unsigned next_frame_id = 0;
for(animation_t const& animation : animations)
{
std::fprintf(fp, "%s:\n", animation.name);
for(metasprite_t frame : animation.frames)
{
auto it = frame_map.find(frame);
if(it == frame_map.end())
it = frame_map.emplace(frame, next_frame_id++).first;
std::fprintf(fp, ".addr m%i\n", it->second);
if(animation.flags & HFLIP)
{
frame = hmirror(frame, animation.width);
auto it = frame_map.find(frame);
if(it == frame_map.end())
it = frame_map.emplace(frame, next_frame_id++).first;
std::fprintf(fp, ".addr m%i\n", it->second);
}
}
}
std::fprintf(fp, "\n");
std::vector<std::pair<unsigned, metasprite_t> > sorted_frames;
for(auto&& pair : frame_map)
sorted_frames.push_back(std::make_pair(pair.second, pair.first));
std::sort(sorted_frames.begin(), sorted_frames.end());
for(auto&& pair : sorted_frames)
{
std::fprintf(fp, "m%i:\n", pair.first);
std::fprintf(fp, ".byt %lu\n", pair.second.size() * 4);
for(sprite_t sprite : pair.second)
{
std::fprintf(fp, ".byt $%02x, $%02x, $%02x, $%02x\n",
sprite.attributes,
sprite.pattern,
(unsigned char)sprite.x_off,
(unsigned char)sprite.y_off);
}
}
std::fprintf(fp, ".endscope\n");
std::fclose(fp);
/*
for(std::size_t i = 0; i != explosion_metasprites.frames.size(); ++i)
{
auto const& metasprite = explosion_metasprites.frames[i];
out << "metasprite_" << i << ":\n";
if(metasprite.empty())
continue;
out << ".byt " << metasprite.size() * 4 << '\n';
for(sprite_t sprite : metasprite)
{
out << ".byt ";
out << (int)sprite.attributes << ", ";
out << (int)sprite.pattern << ", ";
out << (int)sprite.x_off << ", ";
out << (int)sprite.y_off << '\n';
}
}
*/
}
| 26.87931
| 73
| 0.514432
|
pubby
|
681994dc50f63f6a760fc905da62e7e43a92c045
| 968
|
cpp
|
C++
|
AtCoder/ABC/ABC-017/SolveD.cpp
|
MonadicDavidHuang/CompetitiveProgramming
|
b5b6f39a1be05d257f8ea8e504dd910cc624b153
|
[
"MIT"
] | null | null | null |
AtCoder/ABC/ABC-017/SolveD.cpp
|
MonadicDavidHuang/CompetitiveProgramming
|
b5b6f39a1be05d257f8ea8e504dd910cc624b153
|
[
"MIT"
] | null | null | null |
AtCoder/ABC/ABC-017/SolveD.cpp
|
MonadicDavidHuang/CompetitiveProgramming
|
b5b6f39a1be05d257f8ea8e504dd910cc624b153
|
[
"MIT"
] | null | null | null |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
const int MAX = (int)(1e5 + 5);
const ll INF = (ll)(1e10 + 5);
const int MAX_N = (int)(1e5 + 5);
const ll MOD = (ll)(1e9 + 7);
int n, m;
int f[MAX_N];
ll score[MAX_N];
ll ans;
int main(void) {
// Here your code !
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", &(f[i]));
}
f[0] = -1;
unordered_map<int, int> app_r;
unordered_map<int, int> app_l;
score[0] = 1;
score[1] = 1;
app_r[f[0]] += 1;
app_r[f[1]] += 1;
app_l[f[0]] += 1;
int left = 0;
ll sum = score[0] + score[1];
for (int i = 2; i <= n + 1; ++i) {
app_r[f[i]] += 1;
while ((app_r[f[i]] - app_l[f[i]]) >= 2) {
sum -= score[left];
sum %= MOD;
if (sum < 0) sum += MOD;
left += 1;
app_l[f[left]] += 1;
}
score[i] = sum;
sum += score[i];
sum %= MOD;
}
ans = score[n];
printf("%lld\n", ans);
return 0;
}
| 14.028986
| 46
| 0.472107
|
MonadicDavidHuang
|
681bdb21191e659b28d3696902ceb166bfede81d
| 1,066
|
cpp
|
C++
|
include/h3api/H3AdventureMap/H3MapTreeOfKnowledge.cpp
|
Patrulek/H3API
|
91f10de37c6b86f3160706c1fdf4792f927e9952
|
[
"MIT"
] | 14
|
2020-09-07T21:49:26.000Z
|
2021-11-29T18:09:41.000Z
|
include/h3api/H3AdventureMap/H3MapTreeOfKnowledge.cpp
|
Day-of-Reckoning/H3API
|
a82d3069ec7d5127b13528608d5350d2b80d57be
|
[
"MIT"
] | 2
|
2021-02-12T15:52:31.000Z
|
2021-02-12T16:21:24.000Z
|
include/h3api/H3AdventureMap/H3MapTreeOfKnowledge.cpp
|
Day-of-Reckoning/H3API
|
a82d3069ec7d5127b13528608d5350d2b80d57be
|
[
"MIT"
] | 8
|
2021-02-12T15:52:41.000Z
|
2022-01-31T15:28:10.000Z
|
//////////////////////////////////////////////////////////////////////
// //
// Created by RoseKavalier: //
// rosekavalierhc@gmail.com //
// Created or last updated on: 2021-02-02 //
// ***You may use or distribute these files freely //
// so long as this notice remains present.*** //
// //
//////////////////////////////////////////////////////////////////////
#include "h3api/H3AdventureMap/H3MapTreeOfKnowledge.hpp"
namespace h3
{
_H3API_ H3PlayersBitfield H3MapitemTreeOfKnowledge::GetVisiters()
{
return H3PlayersBitfield(visited);
}
_H3API_ VOID H3MapitemTreeOfKnowledge::SetVisited(const H3PlayersBitfield& players)
{
visited = players.bits;
}
_H3API_ H3MapitemTreeOfKnowledge::eType H3MapitemTreeOfKnowledge::GetType()
{
return eType(type);
}
} /* namespace h3 */
| 38.071429
| 84
| 0.446529
|
Patrulek
|
6820dbb6499e577d45513c196b19c3a900850540
| 3,068
|
cpp
|
C++
|
random-chase.cpp
|
afborchert/pointer-chasing
|
226c000d7b1905acffc380809b6d606059859555
|
[
"MIT"
] | 58
|
2017-04-10T21:08:33.000Z
|
2022-03-30T13:42:38.000Z
|
random-chase.cpp
|
afborchert/pointer-chasing
|
226c000d7b1905acffc380809b6d606059859555
|
[
"MIT"
] | null | null | null |
random-chase.cpp
|
afborchert/pointer-chasing
|
226c000d7b1905acffc380809b6d606059859555
|
[
"MIT"
] | 16
|
2017-05-15T21:25:58.000Z
|
2022-03-07T16:08:09.000Z
|
/*
Copyright (c) 2016, 2018 Andreas F. Borchert
All rights reserved.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
/* utility to measure cache and memory read access times */
#include <algorithm>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <printf.hpp> /* see https://github.com/afborchert/fmt */
#include "chase-pointers.hpp"
#include "uniform-int-distribution.hpp"
/* create a cyclic pointer chain that covers all words
in a memory section of the given size in a randomized order */
void** create_random_chain(std::size_t size) {
std::size_t len = size / sizeof(void*);
void** memory = new void*[len];
UniformIntDistribution uniform;
// shuffle indices
size_t* indices = new std::size_t[len];
for (std::size_t i = 0; i < len; ++i) {
indices[i] = i;
}
for (std::size_t i = 0; i < len-1; ++i) {
std::size_t j = i + uniform.draw(len - i);
if (i != j) {
std::swap(indices[i], indices[j]);
}
}
// fill memory with pointer references
for (std::size_t i = 1; i < len; ++i) {
memory[indices[i-1]] = (void*) &memory[indices[i]];
}
memory[indices[len-1]] = (void*) &memory[indices[0]];
delete[] indices;
return memory;
}
unsigned int log2(std::size_t val) {
unsigned int count = 0;
while (val >>= 1) {
++count;
}
return count;
}
#ifndef MIN_SIZE
#define MIN_SIZE 1024
#endif
#ifndef MAX_SIZE
#define MAX_SIZE 1024 * 1024 * 128
#endif
#ifndef GRANULARITY
#define GRANULARITY (1u)
#endif
int main() {
fmt::printf(" memsize time in ns\n");
for (std::size_t memsize = MIN_SIZE; memsize <= MAX_SIZE;
memsize += (std::size_t{1} <<
(std::max(GRANULARITY, log2(memsize))-GRANULARITY))) {
void** memory = create_random_chain(memsize);
std::size_t count = std::max(memsize * 16, std::size_t{1}<<30);
double t = chase_pointers(memory, count);
delete[] memory;
double ns = t * 1000000000 / count;
fmt::printf(" %9u %10.5lf\n", memsize, ns); std::cout.flush();
}
}
| 32.294737
| 72
| 0.67601
|
afborchert
|
68225da83c7555336e5a771c06835a945d66161d
| 24,261
|
cpp
|
C++
|
src/image/dds.cpp
|
dream-overflow/o3d
|
087ab870cc0fd9091974bb826e25c23903a1dde0
|
[
"FSFAP"
] | 2
|
2019-06-22T23:29:44.000Z
|
2019-07-07T18:34:04.000Z
|
src/image/dds.cpp
|
dream-overflow/o3d
|
087ab870cc0fd9091974bb826e25c23903a1dde0
|
[
"FSFAP"
] | null | null | null |
src/image/dds.cpp
|
dream-overflow/o3d
|
087ab870cc0fd9091974bb826e25c23903a1dde0
|
[
"FSFAP"
] | null | null | null |
/**
* @file dds.cpp
* @brief
* @author Frederic SCHERMA (frederic.scherma@dreamoverflow.org)
* @date 2005-08-02
* @copyright Copyright (c) 2001-2017 Dream Overflow. All rights reserved.
* @details
*/
#include "o3d/image/precompiled.h"
#include "o3d/image/dds.h"
#include "o3d/core/filemanager.h"
#include "o3d/core/debug.h"
using namespace o3d;
// Constructor
Dds::Dds(const String& filename) :
m_size(0),
m_Format(PF_RGBA_8),
m_PrimHeight(0),
m_PrimWidth(0),
m_Depth(0),
m_bpp(0),
m_pData(nullptr),
m_NumMipMap(0),
m_cubemap(False),
m_volume(False),
m_compressed(False),
m_CurrentMipMap(0),
m_CurrentDepth(0),
m_CurrentSide(ImgFormat::LEFT_SIDE),
m_Offset(0)
{
load(filename);
}
Dds::Dds(InStream &is) :
m_size(0),
m_Format(PF_RGBA_8),
m_PrimHeight(0),
m_PrimWidth(0),
m_Depth(0),
m_bpp(0),
m_pData(nullptr),
m_NumMipMap(0),
m_cubemap(False),
m_volume(False),
m_compressed(False),
m_CurrentMipMap(0),
m_CurrentDepth(0),
m_CurrentSide(ImgFormat::LEFT_SIDE),
m_Offset(0)
{
load(is);
}
// Copy constructor
Dds::Dds(const Dds &dup) :
m_size(dup.m_size),
m_Format(dup.m_Format),
m_PrimHeight(dup.m_PrimHeight),
m_PrimWidth(dup.m_PrimWidth),
m_Depth(dup.m_Depth),
m_bpp(dup.m_bpp),
m_pData(nullptr),
m_NumMipMap(dup.m_NumMipMap),
m_cubemap(dup.m_cubemap),
m_volume(dup.m_volume),
m_compressed(dup.m_compressed),
m_CurrentMipMap(dup.m_CurrentMipMap),
m_CurrentDepth(dup.m_CurrentDepth),
m_CurrentSide(dup.m_CurrentSide),
m_Offset(dup.m_Offset)
{
if (dup.m_pData)
{
m_pData = new UInt8[dup.m_size];
memcpy(m_pData,dup.m_pData,dup.m_size);
}
}
// Destructor
Dds::~Dds()
{
destroy();
}
// destroy all content
void Dds::destroy()
{
m_CurrentSide = ImgFormat::LEFT_SIDE;
m_CurrentMipMap =
m_NumMipMap =
m_size =
m_CurrentDepth =
m_PrimHeight =
m_PrimWidth =
m_Depth =
m_Offset = 0;
m_Format = PF_RGBA_8;
m_volume = m_cubemap = m_compressed = False;
deleteArray(m_pData);
}
// get info for size,data...
void Dds::getInfo(
UInt32 &size,
UInt32 &width,
UInt32 &height,
UInt8* &data)
{
// compute picture sizes
width = o3d::max((UInt32)1,(m_PrimWidth >> m_CurrentMipMap));
height = o3d::max((UInt32)1,(m_PrimHeight >> m_CurrentMipMap));
// compute image size
// DXT1 RGBA (result in 4bpp)
if ((m_Format == PF_RGB_DXT1) || (m_Format == PF_RGBA_DXT1))
{
size = (o3d::max((UInt32)1,(width >> 2)) * o3d::max((UInt32)1,(height >> 2))) << 3;
}
// dxt3 and 5 format (result in 4bpp), 3dc format (result in 3bpp)
else if ((m_Format == PF_RGBA_DXT3) || (m_Format == PF_RGBA_DXT5))
{
size = (o3d::max((UInt32)1,(width >> 2)) * o3d::max((UInt32)1,(height >> 2))) << 4;
}
// non compressed format
else
{
size = width * height * (m_bpp >> 3);
}
// compute the picture data offset
UInt32 Offset = 0;
UInt32 i;
// Move the data ptr to the asked cube-map side. Z+ is the first so there is no offset.
if (m_cubemap && m_CurrentSide)
{
UInt32 imageSize = 0;
switch (m_Format)
{
case PF_RED_8:
// 8 bits
if (m_NumMipMap)
{
for (i = 0 ; i < m_NumMipMap ; ++i)
imageSize += o3d::max((UInt32)1,(m_PrimWidth >> i)) *
o3d::max((UInt32)1,(m_PrimHeight >> i));
}
else
{
imageSize = m_PrimWidth * m_PrimHeight;
}
break;
case PF_RG_8:
//case GL_RGB5_A1:
//case GL_RGB5:
//case GL_RGBA4:
// 16 bits
if (m_NumMipMap)
{
for (i = 0 ; i < m_NumMipMap ; ++i)
imageSize += ( o3d::max((UInt32)1,(m_PrimWidth >> i)) *
o3d::max((UInt32)1,(m_PrimHeight >> i))) * 2;
}
else
{
imageSize = m_PrimWidth * m_PrimHeight * 2;
}
break;
case PF_RGB_8:
// 24 bits
if (m_NumMipMap)
{
for (i = 0 ; i < m_NumMipMap ; ++i)
imageSize += ( o3d::max((UInt32)1,(m_PrimWidth >> i)) *
o3d::max((UInt32)1,(m_PrimHeight >> i))) * 3;
}
else
{
imageSize = m_PrimWidth * m_PrimHeight * 3;
}
break;
case PF_RGBA_8:
// 32 bits
if (m_NumMipMap)
{
for (i = 0 ; i < m_NumMipMap ; ++i)
imageSize += ( o3d::max((UInt32)1,(m_PrimWidth >> i)) *
o3d::max((UInt32)1,(m_PrimHeight >> i))) * 4;
}
else
{
imageSize = m_PrimWidth * m_PrimHeight * 4;
}
break;
case PF_RGB_DXT1:
case PF_RGBA_DXT1:
// 8 bits block
if (m_NumMipMap)
{
for (i = 0 ; i < m_NumMipMap ; ++i)
imageSize += ( o3d::max((UInt32)1,(m_PrimWidth >> (i+2))) *
o3d::max((UInt32)1,(m_PrimHeight >> (i+2)))) << 3;
}
else
{
imageSize = ( o3d::max((UInt32)1,(m_PrimWidth >> 2)) *
o3d::max((UInt32)1,(m_PrimHeight >> 2))) << 3;
}
break;
case PF_RGBA_DXT3:
case PF_RGBA_DXT5:
// 16 bits block
if (m_NumMipMap)
{
for (i = 0 ; i < m_NumMipMap ; ++i)
imageSize += ( o3d::max((UInt32)1,(m_PrimWidth >> (i+2))) *
o3d::max((UInt32)1,(m_PrimHeight >> (i+2)))) << 4;
}
else
{
imageSize = ( o3d::max((UInt32)1,(m_PrimWidth >> 2)) *
o3d::max((UInt32)1,(m_PrimHeight >> 2))) << 4;
}
break;
default:
O3D_ERROR(E_InvalidFormat("Pixel format"));
break;
}
// On la taille en octets d'une image complete avec tous ses niveaux de mip map
// Il nous reste donc a sauter les cubemaps ou depthmaps non desirés
Offset += imageSize * UInt32(m_CurrentSide);
}
// Move the data ptr to the asked mipmap lvl. Level 0 is the first so there is no offset.
if (m_NumMipMap && m_CurrentMipMap)
{
UInt32 skipSize = 0;
switch (m_Format)
{
case PF_RED_8:
// 8 bits
for (i = 0 ; i < m_CurrentMipMap ; i++)
skipSize += o3d::max((UInt32)1,(m_PrimWidth >> i)) *
o3d::max((UInt32)1,(m_PrimHeight >> i)) *
o3d::max((UInt32)1,(m_Depth >> i));
break;
case PF_RG_8:
//case GL_RGB5_A1:
//case GL_RGB5:
//case GL_RGBA4:
// 16 bits
for (i = 0 ; i < m_CurrentMipMap ; i++)
skipSize += o3d::max((UInt32)1,(m_PrimWidth >> i)) *
o3d::max((UInt32)1,(m_PrimHeight >> i)) *
o3d::max((UInt32)1,(m_Depth >> i)) * 2;
break;
case PF_RGB_8:
// 24 bits
for (i = 0 ; i < m_CurrentMipMap ; i++)
skipSize += o3d::max((UInt32)1,(m_PrimWidth >> i)) *
o3d::max((UInt32)1,(m_PrimHeight >> i)) *
o3d::max((UInt32)1,(m_Depth >> i)) * 3;
break;
case PF_RGBA_8:
// 32 bits
for (i = 0 ; i < m_CurrentMipMap ; i++)
skipSize += o3d::max((UInt32)1,(m_PrimWidth >> i)) *
o3d::max((UInt32)1,(m_PrimHeight >> i)) *
o3d::max((UInt32)1,(m_Depth >> i)) * 4;
break;
case PF_RGB_DXT1:
case PF_RGBA_DXT1:
// 8 bytes block
for (i = 0 ; i < m_CurrentMipMap ; i++)
skipSize += ( o3d::max((UInt32)1,(m_PrimWidth >> (i+2))) *
o3d::max((UInt32)1,(m_PrimHeight >> (i+2))) *
o3d::max((UInt32)1,(m_Depth >> (i+2)))) << 3;
break;
case PF_RGBA_DXT3:
case PF_RGBA_DXT5:
// 16 bytes block
for (i = 0 ; i < m_CurrentMipMap ; i++)
skipSize += ( o3d::max((UInt32)1,(m_PrimWidth >> (i+2))) *
o3d::max((UInt32)1,(m_PrimHeight >> (i+2))) *
o3d::max((UInt32)1,(m_Depth >> (i+2)))) << 4;
break;
default:
O3D_ERROR(E_InvalidFormat("Pixel format"));
break;
}
Offset += skipSize;
}
data = m_pData + Offset;
m_Offset = Offset;
}
//---------------------------------------------------------------------------------------
//! @class DDSPixelFormat
//---------------------------------------------------------------------------------------
class DDSPixelFormat
{
public:
enum DDS
{
DDPF_ALPHAPIXELS = 0x00000001,
DDPF_FOURCC = 0x00000004,
DDPF_RGB = 0x00000040
};
enum DXTFORMAT
{
NONE = 0,
DXT1 = 1,
DXT2 = 2,
DXT3 = 3,
DXT4 = 4,
DXT5 = 5
};
// members --------------------------------------------------------------------------
Bool alpha;
Bool fourcc;
Bool rgb;
DXTFORMAT dxt; // DTX compression format
UInt32 rgbformat; // this is the total number of bits in the format. Should include
// DDPF_RGB in this case. This value is usually 16, 24, or 32.
// For A8R8G8B8, this value would be 32.
UInt32 rgbmask[3];// For RGB formats, these three fields contain the masks for the
// red, green, and blue channels. For A8R8G8B8, these values would be
// 0x00ff0000, 0x0000ff00, and 0x000000ff respectively.
UInt32 alphamask; // For RGB formats, this contains the mask for the alpha channel, if any.
// it should include DDPF_ALPHAPIXELS in this case. For A8R8G8B8, this value
// would be 0xff000000.
// ----------------------------------------------------------------------------------
Bool readFromFile(InStream &is)
{
// struct size
UInt32 size;
is >> size;
if (size != 32)
return False;
// flags
UInt32 flag;
is >> flag;
if ((flag & DDPF_ALPHAPIXELS) == DDPF_ALPHAPIXELS)
alpha = True;
else
alpha = False;
if ((flag & DDPF_FOURCC) == DDPF_FOURCC)
fourcc = True;
else
fourcc = False;
if ((flag & DDPF_RGB) == DDPF_RGB)
rgb = True;
else
rgb = False;
// dxt format (if fourcc)
UInt8 dxtstr[4];
is.read(dxtstr, 4);
dxt = NONE;
if ((dxtstr[0] == 'D') && (dxtstr[1] == 'X') && (dxtstr[2] == 'T'))
{
if (dxtstr[3] == '1') dxt = DXT1;
if (dxtstr[3] == '2') dxt = DXT2;
if (dxtstr[3] == '3') dxt = DXT3;
if (dxtstr[3] == '4') dxt = DXT4;
if (dxtstr[3] == '5') dxt = DXT5;
}
else if ((dxtstr[0] == 'R') && (dxtstr[1] == 'X') && (dxtstr[2] == 'G') && (dxtstr[3] == 'B'))
{
dxt = DXT5;
}
// dtx without DDPF_FOURCC flag
if (!fourcc && dxt)
return False;
// rgb format (for uncompressed)
is >> rgbformat;
// rgbformat without DDPF_FOURCC flag
if (!dxt && !rgb && rgbformat)
return False;
// R,G,B mask
is.read(rgbmask, 3);
// alpha bit mask
is >> alphamask;
// alphamask without DDPF_ALPHAPIXELS flag
if (!alpha && alphamask)
return False;
return True;
}
Bool writeToFile(OutStream &os) const
{
// don't write
return False;
}
};
//---------------------------------------------------------------------------------------
//! @class SurfaceFormatHeader
//---------------------------------------------------------------------------------------
class SurfaceFormatHeader
{
public:
enum DDSD
{
DDSD_CAPS = 0x00000001,
DDSD_HEIGHT = 0x00000002,
DDSD_WIDTH = 0x00000004,
DDSD_PITCH = 0x00000008,
DDSD_PIXELFORMAT = 0x00001000,
DDSD_MIPMAPCOUNT = 0x00020000,
DDSD_LINEARSIZE = 0x00080000,
DDSD_DEPTH = 0x00800000
};
enum CAPS1
{
DDSCAPS_COMPLEX = 0x00000008,
DDSCAPS_TEXTURE = 0x00001000,
DDSCAPS_MIPMAP = 0x00400000
};
enum CAPS2
{
DDSCAPS2_CUBEMAP = 0x00000200,
DDSCAPS2_CUBEMAP_POSITIVEX = 0x00000400,
DDSCAPS2_CUBEMAP_NEGATIVEX = 0x00000800,
DDSCAPS2_CUBEMAP_POSITIVEY = 0x00001000,
DDSCAPS2_CUBEMAP_NEGATIVEY = 0x00002000,
DDSCAPS2_CUBEMAP_POSITIVEZ = 0x00004000,
DDSCAPS2_CUBEMAP_NEGATIVEZ = 0x00008000,
DDSCAPS2_VOLUME = 0x00200000
};
private:
UInt32 defaultFlag;
public:
// constructor
SurfaceFormatHeader() : defaultFlag(DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT) {}
// members --------------------------------------------------------------------------
DDSPixelFormat pixelformat;
Bool compressed;
Bool volumetexture;
Bool mipmap;
Bool cubemap;
UInt32 height,width; // main picture size
UInt32 pitchorlinearsize; // for compressed (DDSD_LINEARSIZE) this is the total picture size
// for uncompressed (DDSD_PITCH) this is the size of a scaline
UInt32 depth; // for volume textures (DDSD_DEPTH) this is the depth of the volume
UInt32 mipmapcount; // for items with mipmap levels (DDSD_MIPMAPCOUNT) this is the total
// number of levels in the mipmap chain of the main image
// ----------------------------------------------------------------------------------
Bool readFromFile(InStream &is)
{
// struct size
UInt32 size;
is >> size;
if (size != 124)
return False;
// flags
UInt32 flag;
is >> flag;
if ((flag & defaultFlag) != defaultFlag)
return False;
// compressed or uncompressed data
if ((flag & DDSD_LINEARSIZE) == DDSD_LINEARSIZE) compressed = True;
else if ((flag & DDSD_PITCH) == DDSD_PITCH) compressed = False;
else return False;
// volume texture ?
if ((flag & DDSD_DEPTH) == DDSD_DEPTH) volumetexture = True;
else volumetexture = False;
// is mipmap ?
if ((flag & DDSD_MIPMAPCOUNT) == DDSD_MIPMAPCOUNT) mipmap = True;
else mipmap = False;
// main picture size and pitchorlinearsize
is >> height
>> width
>> pitchorlinearsize
>> depth
>> mipmapcount;
// reseverd (11 DWORD)
UInt32 reserved[11];
is.read(reserved, 11);
// pixel format structure
if (!pixelformat.readFromFile(is))
return False;
// capabilities structure 1
UInt32 caps1;
is >> caps1;
// need always DDSCAPS_TEXTURE
if ((caps1 & DDSCAPS_TEXTURE) != DDSCAPS_TEXTURE)
return False;
// if DDSCAPS_MIPMAP then mipmapcount must be not 0
if (((caps1 & DDSCAPS_MIPMAP) == DDSCAPS_MIPMAP) && !mipmapcount)
return False;
// capabilities structure 2
UInt32 caps2;
is >> caps2;
// is cubemap ?
if ((caps2 & DDSCAPS2_CUBEMAP) == DDSCAPS2_CUBEMAP)
cubemap = True;
else cubemap = False;
// if DDSCAPS_COMPLEX and not volumetexture or not mipmap
if ((((caps1 & DDSCAPS_COMPLEX) == DDSCAPS_COMPLEX) && !volumetexture && !mipmapcount && !cubemap))
return False;
// DDSCAPS2_VOLUME withouth volumetexture
if (((caps2 & DDSCAPS2_VOLUME) == DDSCAPS2_VOLUME) && !volumetexture)
return False;
// check if there is the 6 side of the cubemap
if (cubemap)
{
if ((caps2 & DDSCAPS2_CUBEMAP_POSITIVEX) != DDSCAPS2_CUBEMAP_POSITIVEX)
cubemap = False;
if ((caps2 & DDSCAPS2_CUBEMAP_NEGATIVEX) != DDSCAPS2_CUBEMAP_NEGATIVEX)
cubemap = False;
if ((caps2 & DDSCAPS2_CUBEMAP_POSITIVEY) != DDSCAPS2_CUBEMAP_POSITIVEY)
cubemap = False;
if ((caps2 & DDSCAPS2_CUBEMAP_NEGATIVEY) != DDSCAPS2_CUBEMAP_NEGATIVEY)
cubemap = False;
if ((caps2 & DDSCAPS2_CUBEMAP_POSITIVEZ) != DDSCAPS2_CUBEMAP_POSITIVEZ)
cubemap = False;
if ((caps2 & DDSCAPS2_CUBEMAP_NEGATIVEZ) != DDSCAPS2_CUBEMAP_NEGATIVEZ)
cubemap = False;
}
// reserved 2+1 DWORD
is.read(reserved, 3);
return True;
}
Bool writeToFile(OutStream &os) const
{
// don't write
return False;
}
};
// Read a DDS file
Bool Dds::load(const String& filename)
{
InStream *is = FileManager::instance()->openInStream(filename);
Bool ret = load(*is);
deletePtr(is);
return ret;
}
Bool Dds::load(InStream &is)
{
// UInt8 magicValue[4+1] = { "DDS " };
UInt8 magicCheck[4];
SurfaceFormatHeader surfaceFormatHeader;
// check MagicValue
is.read(magicCheck, 4);
if ((magicCheck[0] != 'D') || (magicCheck[1] != 'D') || (magicCheck[2] != 'S') || (magicCheck[3] != ' '))
O3D_ERROR(E_InvalidFormat("Invalid DDS token"));
// read Surface Format Header
if (!surfaceFormatHeader.readFromFile(is))
O3D_ERROR(E_InvalidFormat("Invalid DDS header"));
// OpenGL texture format
// compressed ?
if (surfaceFormatHeader.pixelformat.dxt != DDSPixelFormat::NONE)
{
if (surfaceFormatHeader.pixelformat.dxt == DDSPixelFormat::DXT1)
{
if (surfaceFormatHeader.pixelformat.alpha)
m_Format = PF_RGBA_DXT1;
else
m_Format = PF_RGB_DXT1;
}
else if ((surfaceFormatHeader.pixelformat.dxt == DDSPixelFormat::DXT2) ||
(surfaceFormatHeader.pixelformat.dxt == DDSPixelFormat::DXT4))
{
O3D_ERROR(E_InvalidFormat("Unsupported surface format"));
}
else if (surfaceFormatHeader.pixelformat.dxt == DDSPixelFormat::DXT3)
m_Format = PF_RGBA_DXT3;
else if (surfaceFormatHeader.pixelformat.dxt == DDSPixelFormat::DXT5)
m_Format = PF_RGBA_DXT5;
}
// 8,16,24,32 bit non compressed ?
else if (surfaceFormatHeader.pixelformat.rgb)
{
switch (surfaceFormatHeader.pixelformat.rgbformat)
{
case 8:
// alpha 8 only
if ((surfaceFormatHeader.pixelformat.rgbmask[0] == 0) &&
(surfaceFormatHeader.pixelformat.rgbmask[1] == 0) &&
(surfaceFormatHeader.pixelformat.rgbmask[2] == 0) &&
(surfaceFormatHeader.pixelformat.alphamask == 0xff) &&
surfaceFormatHeader.pixelformat.alpha)
m_Format = PF_RED_8;
// luminance 8 only
else if ((surfaceFormatHeader.pixelformat.rgbmask[0] == 0xff) &&
(surfaceFormatHeader.pixelformat.rgbmask[1] == 0) &&
(surfaceFormatHeader.pixelformat.rgbmask[2] == 0))
m_Format = PF_RED_8;
else
O3D_ERROR(E_InvalidFormat("Invalid surface format"));
break;
case 16:
if (surfaceFormatHeader.pixelformat.alpha)
{
// luminance alpha 16
if ((surfaceFormatHeader.pixelformat.rgbmask[0] == 0xff00) &&
(surfaceFormatHeader.pixelformat.rgbmask[1] == 0) &&
(surfaceFormatHeader.pixelformat.rgbmask[2] == 0) &&
(surfaceFormatHeader.pixelformat.alphamask == 0xff))
m_Format = PF_RG_8;
// RGB5 A1
/*else if ((surfaceFormatHeader.pixelformat.rgbmask[0] == 0x7C00) &&
(surfaceFormatHeader.pixelformat.rgbmask[1] == 0x3E0) &&
(surfaceFormatHeader.pixelformat.rgbmask[2] == 0x1F) &&
(surfaceFormatHeader.pixelformat.alphamask == 0x8000))
m_Format = GL_RGB5_A1;
// RGBA4
else if ((surfaceFormatHeader.pixelformat.rgbmask[0] == 0xF00) &&
(surfaceFormatHeader.pixelformat.rgbmask[1] == 0xF0) &&
(surfaceFormatHeader.pixelformat.rgbmask[2] == 0xF) &&
(surfaceFormatHeader.pixelformat.alphamask == 0xF000))
m_Format = GL_RGBA4;*/
else
O3D_ERROR(E_InvalidFormat("Invalid surface format"));
}
else
{
// RGB5
/*if ((surfaceFormatHeader.pixelformat.rgbmask[0] == 0x7C00) &&
(surfaceFormatHeader.pixelformat.rgbmask[1] == 0x3E0) &&
(surfaceFormatHeader.pixelformat.rgbmask[2] == 0x1F))
m_Format = GL_RGB5;
else*/
O3D_ERROR(E_InvalidFormat("Invalid surface format"));
}
break;
case 24:
// RGB8
if (!surfaceFormatHeader.pixelformat.alpha &&
(surfaceFormatHeader.pixelformat.rgbmask[0] == 0xFF0000) &&
(surfaceFormatHeader.pixelformat.rgbmask[1] == 0xFF00) &&
(surfaceFormatHeader.pixelformat.rgbmask[2] == 0xFF))
m_Format = PF_RGB_8;
else
O3D_ERROR(E_InvalidFormat("Invalid surface format"));
break;
case 32:
// RGBA8
if (surfaceFormatHeader.pixelformat.alpha &&
(surfaceFormatHeader.pixelformat.rgbmask[0] == 0xFF0000) &&
(surfaceFormatHeader.pixelformat.rgbmask[1] == 0xFF00) &&
(surfaceFormatHeader.pixelformat.rgbmask[2] == 0xFF) &&
(surfaceFormatHeader.pixelformat.alphamask == 0xFF000000))
m_Format = PF_RGBA_8;
else
O3D_ERROR(E_InvalidFormat("Invalid surface format"));
break;
}
}
else
{
O3D_ERROR(E_InvalidFormat("Invalid surface format"));
}
m_PrimHeight = surfaceFormatHeader.height;
m_PrimWidth = surfaceFormatHeader.width;
m_Depth = surfaceFormatHeader.depth;
m_bpp = surfaceFormatHeader.pixelformat.rgbformat;
m_volume = surfaceFormatHeader.volumetexture;
m_cubemap = surfaceFormatHeader.cubemap;
m_compressed = surfaceFormatHeader.compressed;
m_NumMipMap = surfaceFormatHeader.mipmapcount - 1;
// compute size of all texture(s) data(s)
UInt32 tempSize = 0;
m_size = 0;
for (UInt32 i = 0;
i < (surfaceFormatHeader.mipmapcount > 0 ? surfaceFormatHeader.mipmapcount : 1);
++i)
{
// dxt 1 format
if ((m_Format == PF_RGB_DXT1) || (m_Format == PF_RGBA_DXT1))
{
tempSize = (o3d::max((UInt32)1,(m_PrimWidth >> (i+2))) *
o3d::max((UInt32)1,(m_PrimHeight >> (i+2))) *
o3d::max((UInt32)1,(m_Depth >> (i+2)))) << 3;
m_size += tempSize;
}
// dxt3 and 5 format
else if ((m_Format == PF_RGBA_DXT3) || (m_Format == PF_RGBA_DXT5))
{
tempSize = (o3d::max((UInt32)1,(m_PrimWidth >> (i+2))) *
o3d::max((UInt32)1,(m_PrimHeight >> (i+2))) *
o3d::max((UInt32)1,(m_Depth >> (i+2)))) << 4;
m_size += tempSize;
}
// non compressed format
else
{
m_size += (o3d::max((UInt32)1,(m_PrimWidth >> i)) *
o3d::max((UInt32)1,(m_PrimHeight >> i)) *
o3d::max((UInt32)1,(m_Depth >> i))) *
(surfaceFormatHeader.pixelformat.rgbformat >> 3);
}
}
if (surfaceFormatHeader.cubemap)
m_size *= 6;
// read data
m_pData = new UInt8[m_size];
if (!m_pData)
O3D_ERROR(E_InvalidAllocation("m_pData is null"));
is.read(m_pData, m_size);
// swap 16,24 and 32 non compressed mode
if ((surfaceFormatHeader.pixelformat.rgbformat > 8) &&
(surfaceFormatHeader.pixelformat.dxt == DDSPixelFormat::NONE))
{
UInt32 i;
UInt8 Swap;
switch (m_Format)
{
case PF_RG_8:
// AL to LA
for (i = 0 ; i < m_size ; i += 2)
{
Swap = m_pData[i]; // (A)
m_pData[i] = m_pData[i+1]; // L
m_pData[i+1] = Swap; // A
}
break;
case PF_RGB_8:
// BGR to RGB
for (i = 0 ; i < m_size ; i += 3)
{
Swap = m_pData[i]; // (B)
m_pData[i] = m_pData[i+2]; // R
m_pData[i+2] = Swap; // B
}
break;
case PF_RGBA_8:
// BGRA to RGBA
for (i = 0 ; i < m_size ; i += 4)
{
Swap = m_pData[i]; // (B)
m_pData[i] = m_pData[i+2]; // R
m_pData[i+2] = Swap; // B
}
break;
default:
O3D_ERROR(E_InvalidFormat("Invalid surface format header"));
break;
}
}
return True;
}
//---------------------------------------------------------------------------------------
// DdsImg
//---------------------------------------------------------------------------------------
// Copy constructor
DdsImg::DdsImg(const DdsImg &dup) :
ImgFormat(),
m_pDds(nullptr)
{
if (dup.m_pDds)
{
m_pDds = new Dds(*dup.m_pDds);
m_pDds->getInfo(m_size,m_width,m_height,m_data);
m_state = True;
}
else
m_state = False;
}
Bool DdsImg::checkFormat(InStream &is)
{
// UInt8 MagicValue[4+1] = { "DDS " };
UInt8 magicCheck[4];
// check MagicValue
is.read(magicCheck, 4);
is.seek(-4);
if ((magicCheck[0] != 'D') || (magicCheck[1] != 'D') || (magicCheck[2] != 'S') || (magicCheck[3] != ' ')) {
return False;
}
return True;
}
void DdsImg::destroy()
{
ImgFormat::destroy();
deletePtr(m_pDds);
}
Bool DdsImg::load(InStream &is)
{
m_pDds = new Dds;
if (m_pDds->load(is))
{
m_pDds->getInfo(m_size, m_width ,m_height, m_data);
return True;
}
return False;
}
Bool DdsImg::load(InStream &is, PixelFormat pixelFormat)
{
//switch (pixelFormat)
//{
// default:
O3D_ERROR(E_InvalidParameter("Unsupported convert format"));
return False;
//}
}
Bool DdsImg::save(OutStream &os, PixelFormat pixelFormat)
{
O3D_ERROR(E_InvalidOperation("Not yet implemented"));
return False;
}
Bool DdsImg::isComplex() const
{
return (m_pDds->isMipMap() || m_pDds->isCubeMap() || m_pDds->isVolumeTexture());
}
Bool DdsImg::isCompressed() const
{
return m_pDds->isCompressed();
}
PixelFormat DdsImg::getPixelFormat() const
{
return m_pDds->getPixelFormat();
}
Bool DdsImg::isMipMap() const
{
return m_pDds->isMipMap();
}
Bool DdsImg::isCubeMap() const
{
return m_pDds->isCubeMap();
}
Bool DdsImg::isVolumeTexture() const
{
return m_pDds->isVolumeTexture();
}
UInt32 DdsImg::getNumMipMapLvl() const
{
return m_pDds->getNumMipMapLvl();
}
UInt32 DdsImg::getNumDepthLayer() const
{
return m_pDds->getNumDepthLayer();;
}
Bool DdsImg::bindMipMapLvl(UInt32 lvl)
{
Bool ret = m_pDds->bindMipMapLvl(lvl);
if (ret)
m_pDds->getInfo(m_size,m_width,m_height,m_data);
return ret;
}
void DdsImg::bindCubeMapSide(ImgFormat::CubeMapSide side)
{
m_pDds->bindCubeMapSide(side);
m_pDds->getInfo(m_size,m_width,m_height,m_data);
}
Bool DdsImg::bindVolumeLayer(UInt32 layer)
{
Bool ret = m_pDds->bindVolumeLayer(layer);
if (ret)
m_pDds->getInfo(m_size,m_width,m_height,m_data);
return ret;
}
UInt32 DdsImg::getCurrentMipMapLvl() const
{
return m_pDds->getCurrentMipMapLvl();
}
UInt32 DdsImg::getCurrentCubeMapSide() const
{
return m_pDds->getCurrentCubeMapSide();
}
UInt32 DdsImg::getCurrentDepthLayer() const
{
return m_pDds->getCurrentDepthLayer();
}
| 24.068452
| 111
| 0.613536
|
dream-overflow
|
682b6ea77127634ad0b633ebf2b5d51cef9e1c7b
| 11,722
|
cpp
|
C++
|
src/application/test/suits/app_test_parser_arguments.cpp
|
lpea/cppinclude
|
dc126c6057d2fe30569e6e86f66d2c8eebb50212
|
[
"MIT"
] | 177
|
2020-08-24T19:20:35.000Z
|
2022-03-27T01:58:04.000Z
|
src/application/test/suits/app_test_parser_arguments.cpp
|
lpea/cppinclude
|
dc126c6057d2fe30569e6e86f66d2c8eebb50212
|
[
"MIT"
] | 15
|
2020-08-30T17:59:42.000Z
|
2022-01-12T11:14:10.000Z
|
src/application/test/suits/app_test_parser_arguments.cpp
|
lpea/cppinclude
|
dc126c6057d2fe30569e6e86f66d2c8eebb50212
|
[
"MIT"
] | 11
|
2020-09-17T23:31:10.000Z
|
2022-03-04T13:15:21.000Z
|
#include "application/test/fixtures/app_test_parser_fixture.hpp"
#include <boost/test/unit_test.hpp>
#include <optional>
#include <std_fs>
#include <string>
/*------------------------------------------------------------------------------
TEST PLAN:
1. Argument with value
2. Argument only with default value
3. Argument with value and default value
4. Unrecognized argument
5. Help
6. Value with "
7. Value with '
8. Several arguments
9. Check exist argument
10. Array
10.1 simple
10.2 with default value
10.3 values with ' and ""
11. Int
12. Bool
13. Path
14. Paths
------------------------------------------------------------------------------*/
namespace application::test
{
//------------------------------------------------------------------------------
// clazy:excludeall=non-pod-global-static
// NOLINTNEXTLINE(fuchsia-statically-constructed-objects,cert-err58-cpp)
BOOST_FIXTURE_TEST_SUITE( ParserArgumentsTets, ParserArgumentsFixture )
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE( t1_argument_with_value )
{
// Init
const std::string argumentName = "dir";
const std::string argumentDescription;
const std::string argumentValue = "test_dir";
const std::string argumentDefaultValue;
const std::string argument = "--" + argumentName + "=" + argumentValue;
addArgument( argumentName, argumentDescription, argumentDefaultValue );
// Run
parseArguments( { argument } );
// Check
auto valueOpt = getArgumentStringValue( argumentName );
BOOST_REQUIRE( valueOpt.has_value() );
BOOST_CHECK_EQUAL( argumentValue, *valueOpt );
}
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE( t2_argument_with_only_default_value )
{
// Init
const std::string argumentName = "dir";
const std::string argumentDescription;
const std::string argumentDefaultValue = "test_dir";
addArgument( argumentName, argumentDescription, argumentDefaultValue );
// Run
parseArguments( { "" } );
// Check
auto valueOpt = getArgumentStringValue( argumentName );
BOOST_REQUIRE( !valueOpt.has_value() );
}
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE( t3_argument_with_value_and_default_value )
{
// Init
const std::string argumentName = "dir";
const std::string argumentDescription;
const std::string argumentDefaultValue = "test_dir";
const std::string argumentValue = "new_dir";
const std::string argument = "--" + argumentName + "=" + argumentValue;
addArgument( argumentName, argumentDescription, argumentDefaultValue );
// Run
parseArguments( { argument } );
// Check
auto valueOpt = getArgumentStringValue( argumentName );
BOOST_REQUIRE( valueOpt.has_value() );
BOOST_CHECK_EQUAL( argumentValue, *valueOpt );
}
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE( t4_unrecognized_argument )
{
// Init
const std::string argumentName = "dir";
const std::string argumentDescription;
const std::string argumentValue = "new_dir";
const std::string argument = "--" + argumentName + "=" + argumentValue;
// Run
BOOST_CHECK_THROW( parseArguments( { argument } ), std::logic_error );
}
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE( t5_help )
{
// Init
const std::string argumentName = "dir";
const std::string argumentDescription = "Test dir";
const std::string argumentDefaultValue = "test_dir";
const std::string argumentValue = "new_dir";
const std::string argument = "--" + argumentName + "=" + argumentValue;
addArgument( argumentName, argumentDescription, argumentDefaultValue );
// Run
BOOST_CHECK_EQUAL(
getHelpString(), "\n"
"Usage:\n"
" [OPTION...]\n"
"\n"
" --dir=arg Test dir (default: test_dir)\n" );
}
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE( t6_value_with_quotation_mark )
{
// Init
const std::string argumentName = "dir";
const std::string argumentDescription;
const std::string argumentValue = "new_dir";
const std::string argumentDefaultValue;
const std::string argument =
"--" + argumentName + "=\"" + argumentValue + "\"";
addArgument( argumentName, argumentDescription, argumentDefaultValue );
// Run
parseArguments( { argument } );
// Check
// Check
auto valueOpt = getArgumentStringValue( argumentName );
BOOST_REQUIRE( valueOpt.has_value() );
BOOST_CHECK_EQUAL( argumentValue, *valueOpt );
}
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE( t7_value_with_apostrophe )
{
// Init
const std::string argumentName = "dir";
const std::string argumentDescription;
const std::string argumentValue = "new_dir";
const std::string argumentDefaultValue;
const std::string argument =
"--" + argumentName + "='" + argumentValue + "'";
addArgument( argumentName, argumentDescription, argumentDefaultValue );
// Run
parseArguments( { argument } );
// Check
auto valueOpt = getArgumentStringValue( argumentName );
BOOST_REQUIRE( valueOpt.has_value() );
BOOST_CHECK_EQUAL( argumentValue, *valueOpt );
}
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE( t8_several_arguments )
{
// Init
const std::string argumentNewName = "new";
const std::string argumentNewDescription;
const std::string argumentNewValue = "new_dir";
const std::string argumentNewDefaultValue;
const std::string argumentNew =
"--" + argumentNewName + "=" + argumentNewValue;
const std::string argumentOldName = "old";
const std::string argumentOldDescription;
const std::string argumentOldValue = "old_dir";
const std::string argumentOldDefaultValue;
const std::string argumentOld =
"--" + argumentOldName + "=" + argumentOldValue;
addArgument(
argumentNewName, argumentNewDescription, argumentNewDefaultValue );
addArgument(
argumentOldName, argumentOldDescription, argumentOldDefaultValue );
// Run
parseArguments( { argumentNew, argumentOld } );
// Check
auto valueNewOpt = getArgumentStringValue( argumentNewName );
BOOST_REQUIRE( valueNewOpt.has_value() );
BOOST_CHECK_EQUAL( argumentNewValue, *valueNewOpt );
auto valueOldOpt = getArgumentStringValue( argumentOldName );
BOOST_REQUIRE( valueOldOpt.has_value() );
BOOST_CHECK_EQUAL( argumentOldValue, *valueOldOpt );
}
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE( t9_check_exist_argument )
{
// Init
const std::string argumentName = "help";
const std::string argumentDescription;
const std::string argument = "--" + argumentName;
addArgument( argumentName, argumentDescription );
// Run
parseArguments( { argument } );
// Check
BOOST_CHECK( isExistArgument( argumentName ) );
}
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE( t10_1_array_simple )
{
// Init
const std::string argumentName = "array";
const std::string argumentDescription;
const std::string argumentValue = "a,b,c";
const Strings argumentDefaultValues{};
addArgument( argumentName, argumentDescription, argumentDefaultValues );
const std::string argument = "--" + argumentName + "=" + argumentValue;
// Run
parseArguments( { argument } );
// Check
auto valueOpt = getArgumentStringsValue( argumentName );
BOOST_REQUIRE( valueOpt.has_value() );
BOOST_CHECK_EQUAL( argumentValue, *valueOpt );
}
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE( t10_2_array_with_default_value )
{
// Init
const std::string argumentName = "array";
const std::string argumentDescription;
const Strings argumentDefaultValues{ "a", "b", "c" };
addArgument( argumentName, argumentDescription, argumentDefaultValues );
const std::string argument;
// Run
parseArguments( { argument } );
// Check
auto valueOpt = getArgumentStringValue( argumentName );
BOOST_REQUIRE( !valueOpt.has_value() );
}
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE( t10_3_array_with_quotes )
{
// Init
const std::string argumentName = "array";
const std::string argumentDescription;
const std::string argumentValue = "'a',\"b\",c";
const Strings argumentDefaultValues{};
addArgument( argumentName, argumentDescription, argumentDefaultValues );
const std::string argument = "--" + argumentName + "=" + argumentValue;
// Run
parseArguments( { argument } );
// Check
auto valueOpt = getArgumentStringsValue( argumentName );
BOOST_REQUIRE( valueOpt.has_value() );
BOOST_CHECK_EQUAL( "a,b,c", *valueOpt );
}
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE( t11_int )
{
// Init
const std::string argumentName = "number";
const std::string argumentDescription;
const int argumentValue = 42;
const int argumentDefaultValue = 1;
const std::string argument =
"--" + argumentName + "=" + std::to_string( argumentValue );
addArgument( argumentName, argumentDescription, argumentDefaultValue );
// Run
parseArguments( { argument } );
// Check
auto valueOpt = getArgumentIntValue( argumentName );
BOOST_REQUIRE( valueOpt.has_value() );
BOOST_CHECK_EQUAL( argumentValue, *valueOpt );
}
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE( t12_bool )
{
// Init
const std::string argumentName = "skip";
const std::string argumentDescription;
const bool argumentValue = true;
const bool argumentDefaultValue = false;
const std::string argument =
"--" + argumentName + "=" + ( argumentValue ? "true" : "false" );
addArgument( argumentName, argumentDescription, argumentDefaultValue );
// Run
parseArguments( { argument } );
// Check
auto valueOpt = getArgumentBoolValue( argumentName );
BOOST_REQUIRE( valueOpt.has_value() );
BOOST_CHECK_EQUAL( argumentValue, *valueOpt );
}
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE( t13_path )
{
// Init
const std::string argumentName = "number";
const std::string argumentDescription;
const Path argumentValue{ "/dir" };
const std::string argumentValueStr{ argumentValue.string() };
const Path argumentDefaultValue{ "/usr" };
const std::string argument = "--" + argumentName + "=" + argumentValueStr;
addArgument( argumentName, argumentDescription, argumentDefaultValue );
// Run
parseArguments( { argument } );
// Check
auto valueOpt = getArgumentPathValue( argumentName );
BOOST_REQUIRE( valueOpt.has_value() );
BOOST_CHECK_EQUAL( argumentValueStr, *valueOpt );
}
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE( t14_paths )
{
// Init
const std::string argumentName = "number";
const std::string argumentDescription;
const Paths argumentValues{ "/dir1", "/dir2", "/dir3" };
const std::string argumentValueStr{ toString( argumentValues ) };
const Paths argumentDefaultValues{ "/usr1", "/usr2", "/usr3" };
const std::string argument = "--" + argumentName + "=" + argumentValueStr;
addArgument( argumentName, argumentDescription, argumentDefaultValues );
// Run
parseArguments( { argument } );
// Check
auto valueOpt = getArgumentPathsValue( argumentName );
BOOST_REQUIRE( valueOpt.has_value() );
BOOST_CHECK_EQUAL( argumentValueStr, *valueOpt );
}
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_SUITE_END()
//------------------------------------------------------------------------------
}
| 27.071594
| 80
| 0.628306
|
lpea
|
682dae4039bb24fc9f6dfbabb7ddccd09fc665b5
| 1,381
|
cpp
|
C++
|
Law_Of_Structure/3.10/BFS.cpp
|
luochonghai/BeautyOfProgramming
|
7eacfbf74f1a7eb655f09b4d0f3df9a0a791148f
|
[
"CECILL-B"
] | null | null | null |
Law_Of_Structure/3.10/BFS.cpp
|
luochonghai/BeautyOfProgramming
|
7eacfbf74f1a7eb655f09b4d0f3df9a0a791148f
|
[
"CECILL-B"
] | null | null | null |
Law_Of_Structure/3.10/BFS.cpp
|
luochonghai/BeautyOfProgramming
|
7eacfbf74f1a7eb655f09b4d0f3df9a0a791148f
|
[
"CECILL-B"
] | null | null | null |
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {//可以尝试用非递归的方式来实现。
public:
vector<vector<int>> levelOrder(TreeNode* root)
{
vector<vector<int>>result;
if(!root)
return result;
queue<TreeNode*> temp_level;
temp_level.push(root);
int old_num = 1,new_num = 0,levels = 0,sig_levels = 0;
while(old_num--)
{
TreeNode* temp_node = temp_level.front();
temp_level.pop();
if(sig_levels == 0)
{
sig_levels = 1;
result.push_back(vector<int>{temp_node->val});
}
else
result[levels].push_back(temp_node->val);
if(temp_node->left != NULL)
{
temp_level.push(temp_node->left);
new_num++;
}
if(temp_node->right != NULL)
{
temp_level.push(temp_node->right);
new_num++;
}
if(old_num == 0)
{
levels++;
sig_levels = 0;
old_num = new_num;
new_num = 0;
}
}
return result;
}
};
| 26.557692
| 62
| 0.446054
|
luochonghai
|
682db1513dafdd908c3fdcf8dd567edd2d0d5912
| 17,105
|
cpp
|
C++
|
main.cpp
|
jieatcoderrect/jit_vectorize
|
b20d4b1c64d96d4e42bf618f0c4c66c1f9d5476e
|
[
"Apache-2.0"
] | 2
|
2020-05-04T06:02:23.000Z
|
2020-05-04T13:12:54.000Z
|
main.cpp
|
jieatcoderrect/jit_vectorize
|
b20d4b1c64d96d4e42bf618f0c4c66c1f9d5476e
|
[
"Apache-2.0"
] | null | null | null |
main.cpp
|
jieatcoderrect/jit_vectorize
|
b20d4b1c64d96d4e42bf618f0c4c66c1f9d5476e
|
[
"Apache-2.0"
] | null | null | null |
#include <iostream>
#include <utility>
#include <vector>
#include <map>
#include <cstdlib>
#include <memory>
#include <cstring>
const uint32_t BATCHES = 100000;
/**
* Memory management rules
* 1. use new/delete
* 2. who own who release
*/
/************************************************************************
*
* PRITIMITIVE
*
**************************************************************************/
uint32_t map_add_int32_col_int32_col(uint32_t n, int32_t *res, int32_t *col1, int32_t *col2, uint32_t *sel) {
if (sel == nullptr) {
for (uint32_t i = 0; i < n; i++)
res[i] = col1[i] + col2[i];
}
else {
for (uint32_t i = 0; i < n; i++)
res[i] = col1[sel[i]] + col2[sel[i]];
}
return n;
}
uint32_t map_sub_int32_col_int32_col(uint32_t n, int32_t *res, int32_t *col1, int32_t *col2, uint32_t *sel) {
if (sel == nullptr) {
for (uint32_t i = 0; i < n; i++)
res[i] = col1[i] - col2[i];
}
else {
for (uint32_t i = 0; i < n; i++)
res[i] = col1[sel[i]] - col2[sel[i]];
}
return n;
}
uint32_t map_mul_int32_col_int32_col(uint32_t n, int32_t *res, int32_t *col1, int32_t *col2, uint32_t *sel) {
if (sel == nullptr) {
for (uint32_t i = 0; i < n; i++)
res[i] = col1[i] * col2[i];
}
else {
for (uint32_t i = 0; i < n; i++)
res[i] = col1[sel[i]] * col2[sel[i]];
}
return n;
}
uint32_t map_add_int32_val_int32_col(uint32_t n, int32_t *res, int32_t val, int32_t *col2, uint32_t *sel) {
if (sel == nullptr) {
for (uint32_t i = 0; i < n; i++)
res[i] = val + col2[i];
}
else {
for (uint32_t i = 0; i < n; i++)
res[i] = val + col2[sel[i]];
}
return n;
}
uint32_t map_sub_int32_val_int32_col(uint32_t n, int32_t *res, int32_t val, int32_t *col2, uint32_t *sel) {
if (sel == nullptr) {
for (uint32_t i = 0; i < n; i++)
res[i] = val - col2[i];
}
else {
for (uint32_t i = 0; i < n; i++)
res[i] = val - col2[sel[i]];
}
return n;
}
uint32_t map_mul_int32_val_int32_col(uint32_t n, int32_t *res, int32_t val, int32_t *col2, uint32_t *sel) {
if (sel == nullptr) {
for (uint32_t i = 0; i < n; i++)
res[i] = val * col2[i];
}
else {
for (uint32_t i = 0; i < n; i++)
res[i] = val * col2[sel[i]];
}
return n;
}
/************************************************************************
*
* DAG NODES
*
**************************************************************************/
#define CHILD_TYPE_COL 1
#define CHILD_TYPE_VAL 2
#define CHILD_TYPE_DAG 3
struct DbVector {
uint32_t n;
int32_t *col;
DbVector(uint32_t n, int32_t *col) :
n(n), col(col) {}
DbVector(uint32_t n) : n(n) {
col = new int32_t[n];
}
DbVector(const DbVector& vec) : n(vec.n), col(nullptr){
col = new int32_t[n];
memcpy(col, vec.col, sizeof(uint32_t)*n);
}
~DbVector() {
delete col;
}
};
class DAGNode {
public:
DAGNode() = default;
virtual ~DAGNode() = default;
virtual uint32_t compute(DbVector** res) = 0;
virtual int getLeftChildType() = 0;
virtual int getRightChildType() = 0;
virtual void setLeftVector(DbVector* v) {
throw std::invalid_argument("not support");
}
virtual void setRightVector(DbVector* v) {
throw std::invalid_argument("not support");
}
virtual std::string getLeftChildColName() {
throw std::invalid_argument("not support");
}
virtual std::string getRightChildColName() {
throw std::invalid_argument("not support");
}
virtual DAGNode* getLeftChildDagNode() {
throw std::invalid_argument("not support");
}
virtual DAGNode* getRightChildDagNode() {
throw std::invalid_argument("not support");
}
};
#define OP_ADD 1
#define OP_SUB 2
#define OP_MUL 3
class ValColDAGNode : public DAGNode {
private:
int op_;
uint32_t (*primitive)(uint32_t n, int32_t *res, int32_t val, int32_t *col2, uint32_t *sel);
int32_t left_val_;
DAGNode *right_;
std::string col_name_;
DbVector *right_vec_;
private:
void assignPrimitive_() {
switch (op_)
{
case OP_ADD:
primitive = map_add_int32_val_int32_col;
break;
case OP_MUL:
primitive = map_mul_int32_val_int32_col;
break;
case OP_SUB:
primitive = map_sub_int32_val_int32_col;
break;
default:
throw std::invalid_argument("Unkonwn op");
}
}
public:
ValColDAGNode(int op, int32_t left_val, DAGNode *right) :
op_(op), right_(right), col_name_(""), left_val_(left_val), right_vec_(nullptr) {
assignPrimitive_();
}
ValColDAGNode(int op, int32_t left_val, std::string col_name) :
op_(op), left_val_(left_val), right_(nullptr), col_name_(std::move(col_name)), right_vec_(nullptr) {
assignPrimitive_();
}
virtual ~ValColDAGNode() {
delete right_;
delete right_vec_;
}
int getLeftChildType() final {
return CHILD_TYPE_VAL;
}
int getRightChildType() final {
if (right_ != nullptr)
return CHILD_TYPE_DAG;
return CHILD_TYPE_COL;
}
void setRightVector(DbVector* v) final {
delete right_vec_;
right_vec_ = v;
}
std::string getRightChildColName() final {
return col_name_;
}
DAGNode* getRightChildDagNode() final {
return right_;
}
uint32_t compute(DbVector** res) final {
*res = new DbVector(right_vec_->n);
return primitive(right_vec_->n, (*res)->col, left_val_, right_vec_->col, nullptr);
}
};
class ColColDAGNode : public DAGNode {
private:
int op_;
uint32_t (*primitive)(uint32_t n, int32_t *res, int32_t *col1, int32_t *col2, uint32_t *sel);
DAGNode *right_;
std::string right_col_name_;
DAGNode *left_;
std::string left_col_name_;
DbVector* left_vec_;
DbVector* right_vec_;
private:
void assignPrimitive_() {
switch (op_)
{
case OP_ADD:
primitive = map_add_int32_col_int32_col;
break;
case OP_MUL:
primitive = map_mul_int32_col_int32_col;
break;
case OP_SUB:
primitive = map_sub_int32_col_int32_col;
break;
default:
throw std::invalid_argument("Unkonwn op");
}
}
public:
ColColDAGNode(int op, DAGNode* left, DAGNode* right) :
op_(op), right_(right), left_(left), left_vec_(nullptr), right_vec_(nullptr) {
assignPrimitive_();
}
ColColDAGNode(int op, std::string left_col_name, DAGNode* right) :
op_(op), left_col_name_(std::move(left_col_name)), right_(right), left_(nullptr), left_vec_(nullptr), right_vec_(nullptr) {
assignPrimitive_();
}
ColColDAGNode(int op, DAGNode* left, std::string right_col_name) :
op_(op), left_(left), right_(nullptr), right_col_name_(std::move(right_col_name)), left_vec_(nullptr), right_vec_(nullptr) {
assignPrimitive_();
}
ColColDAGNode(int op, std::string left_col_name, std::string right_col_name) :
op_(op), left_col_name_(std::move(left_col_name)), right_col_name_(std::move(right_col_name)), left_(nullptr), right_(nullptr), left_vec_(nullptr), right_vec_(nullptr) {
assignPrimitive_();
}
virtual ~ColColDAGNode() {
delete left_;
delete right_;
delete left_vec_;
delete right_vec_;
}
int getLeftChildType() final {
if (left_ != nullptr)
return CHILD_TYPE_DAG;
return CHILD_TYPE_COL;
}
int getRightChildType() final {
if (right_ != nullptr)
return CHILD_TYPE_DAG;
return CHILD_TYPE_COL;
}
void setLeftVector(DbVector* v) final {
delete left_vec_;
left_vec_ = v;
}
void setRightVector(DbVector* v) final {
delete right_vec_;
right_vec_ = v;
}
std::string getLeftChildColName() final {
return left_col_name_;
}
std::string getRightChildColName() final {
return right_col_name_;
}
DAGNode* getLeftChildDagNode() final {
return left_;
}
virtual DAGNode* getRightChildDagNode() {
return right_;
}
uint32_t compute(DbVector** res) {
*res = new DbVector(left_vec_->n);
return primitive(left_vec_->n, (*res)->col, left_vec_->col, right_vec_->col, nullptr);
}
};
/************************************************************************
*
* OPERATORS
*
**************************************************************************/
struct BatchResult {
std::map<std::string, DbVector*> data;
BatchResult(const std::vector<std::string>& col_names, uint32_t n) {
for (const auto& name : col_names) {
DbVector* v = new DbVector(n);
data[name] = v;
}
}
BatchResult() : data() {
}
~BatchResult() {
for (auto& elem : data) {
delete elem.second;
}
}
void add(const std::string& col_name, DbVector* vec) {
data[col_name] = vec;
}
DbVector* getCol(const std::string& col_name) {
return data[col_name];
}
uint32_t getn() {
const auto& itr = data.begin();
return itr->second->n;
}
void print() {
std::vector<std::string> col_names{};
for (const auto& elem : data) {
col_names.push_back(elem.first);
std::cout << elem.first << "\t\t";
}
std::cout << "\n=========================================================\n";
uint32_t n = data[col_names[0]]->n;
for (uint32_t i = 0; i < n ; i++) {
for (const auto& key : col_names) {
DbVector* v = data[key];
int32_t val;
val = v->col[i];
std::cout << val << "\t\t";
}
std::cout << "\n";
}
}
};
class BaseOperator {
public:
BaseOperator() = default;
virtual ~BaseOperator() = default;
virtual void open() {
throw std::invalid_argument("Not supported");
}
virtual void close() {
throw std::invalid_argument("Not supported");
}
virtual BatchResult* next() {
throw std::invalid_argument("Not supported");
}
};
/**
* 这个简单的project operator把scan operator的所有列经过计算后得到一个
* 唯一的列。
*/
class ProjectOperator : public BaseOperator {
private:
BaseOperator* next_;
DAGNode* expr_;
std::string col_name_;
public:
ProjectOperator(BaseOperator *next, std::string col_name, DAGNode* expr) :
next_(next), expr_(expr), col_name_(std::move(col_name)) {
}
~ProjectOperator() final {
delete next_;
delete expr_;
}
void open() {
next_->open();
}
void close() {
next_->close();
}
BatchResult* next() {
std::unique_ptr<BatchResult> br(next_->next());
if (br == nullptr)
return nullptr;
DbVector* vec = nullptr;
evaluateExpr_(&vec, expr_, br.get());
BatchResult* rs = new BatchResult();
rs->add(col_name_, vec);
return rs;
}
private:
// evaluate the expression -
uint32_t evaluateExpr_(DbVector** res, DAGNode *expr, BatchResult* input) {
uint32_t n = input->getn();
DbVector *lres = nullptr, *rres = nullptr;
DAGNode *tmp_node = nullptr;
DbVector *tmp_vec = nullptr;
switch (expr->getLeftChildType())
{
case CHILD_TYPE_VAL:
break;
case CHILD_TYPE_DAG:
tmp_node = expr->getLeftChildDagNode();
evaluateExpr_(&lres, tmp_node, input);
break;
case CHILD_TYPE_COL:
tmp_vec = input->getCol(expr->getLeftChildColName());
lres = new DbVector(*tmp_vec);
break;
}
if (lres != nullptr)
expr->setLeftVector(lres);
switch (expr->getRightChildType())
{
case CHILD_TYPE_VAL:
break;
case CHILD_TYPE_COL:
tmp_vec = input->getCol(expr->getRightChildColName());
rres = new DbVector(*tmp_vec);
break;
case CHILD_TYPE_DAG:
DAGNode* tmp_node = expr->getRightChildDagNode();
evaluateExpr_(&rres, tmp_node, input);
break;
}
if (rres != nullptr)
expr->setRightVector(rres);
return expr->compute(res);
}
};
class CompiledProjectOperator : public BaseOperator {
private:
BaseOperator* next_;
std::string col_name_;
public:
CompiledProjectOperator(BaseOperator *next, std::string col_name) :
next_(next), col_name_(std::move(col_name)) {
}
~CompiledProjectOperator() final {
delete next_;
}
void open() {
next_->open();
}
void close() {
next_->close();
}
BatchResult* next() {
std::unique_ptr<BatchResult> br(next_->next());
if (br == nullptr)
return nullptr;
DbVector* vec = nullptr;
evaluateExpr_(&vec, br.get());
BatchResult* rs = new BatchResult();
rs->add(col_name_, vec);
return rs;
}
private:
// evaluate the expression - extprice * (1 - discount) * (1 + tax)
uint32_t evaluateExpr_(DbVector** res, BatchResult* input) {
uint32_t n = input->getn();
int32_t *extprice = input->getCol("extprice")->col;
int32_t *discount = input->getCol("discount")->col;
int32_t *tax = input->getCol("tax")->col;
*res = new DbVector(n);
int32_t *r = (*res)->col;
for (uint32_t i = 0; i < n; i++) {
r[i] = extprice[i] * (1 - discount[i]) * (1 + tax[i]);
}
return n;
}
};
class ScanOperator : public BaseOperator {
private:
uint32_t num_of_batches_;
std::vector<std::string> columns_;
public:
ScanOperator(uint32_t num_of_batches, const std::vector<std::string>& columns) :
num_of_batches_(num_of_batches),
columns_(columns)
{}
~ScanOperator() final = default;
void open() final {
// do nothing
}
void close() final {
// do nothing
}
BatchResult* next() final {
if (num_of_batches_ == 0)
return nullptr;
uint32_t n = 1000;
BatchResult *br = new BatchResult(columns_, n);
// fill each col using a random numbers
for (const auto& name : columns_) {
DbVector* v = br->data[name];
/*
for (uint32_t i = 0; i < n; i++) {
v->col[i] = (int32_t)rand();
}
*/
}
num_of_batches_--;
// printf("%d batch\n", BATCHES-num_of_batches_);
return br;
}
};
/************************************************************************
*
* Query compiler
*
**************************************************************************/
class QueryPlan {
private:
BaseOperator *head_;
public:
QueryPlan(BaseOperator *head) : head_(head) {
}
~QueryPlan() = default;
void open() {
head_->open();
}
void close() {
head_->close();
}
void printResultSet() {
BatchResult *rs = nullptr;
while (true) {
rs = head_->next();
if (rs == nullptr)
break;
// rs->print();
delete rs;
}
}
};
QueryPlan *compileQuery() {
std::vector<std::string> col_names{"extprice", "discount", "tax"};
ScanOperator *scan_op = new ScanOperator(BATCHES, col_names);
ValColDAGNode *oneMinusDiscount = new ValColDAGNode(OP_SUB, 1, "discount");
ColColDAGNode *extpriceMul = new ColColDAGNode(OP_MUL, "extprice", oneMinusDiscount);
ValColDAGNode *oneAddTax = new ValColDAGNode(OP_ADD, 1, "tax");
ColColDAGNode *mul = new ColColDAGNode(OP_MUL, extpriceMul, oneAddTax);
ProjectOperator *proj_op = new ProjectOperator(scan_op, "bonus", mul);
return new QueryPlan(proj_op);
}
QueryPlan *compileQueryWithJit() {
std::vector<std::string> col_names{"extprice", "discount", "tax"};
ScanOperator *scan_op = new ScanOperator(BATCHES, col_names);
CompiledProjectOperator *proj_op = new CompiledProjectOperator(scan_op, "bonus");
return new QueryPlan(proj_op);
}
int main(int argc, char*argv[]) {
QueryPlan *query_plan = compileQuery();
// QueryPlan *query_plan = compileQueryWithJit();
query_plan->open();
query_plan->printResultSet();
query_plan->close();
delete query_plan;
}
| 23.82312
| 177
| 0.543467
|
jieatcoderrect
|
682eaf43c4a649053bfc051ea2362b98837e2ae0
| 1,867
|
hpp
|
C++
|
include/misc.hpp
|
dkaramit/comET
|
dbbb66d5839d6d6d0fd45a32e49fb07b988ddf48
|
[
"MIT"
] | null | null | null |
include/misc.hpp
|
dkaramit/comET
|
dbbb66d5839d6d6d0fd45a32e49fb07b988ddf48
|
[
"MIT"
] | null | null | null |
include/misc.hpp
|
dkaramit/comET
|
dbbb66d5839d6d6d0fd45a32e49fb07b988ddf48
|
[
"MIT"
] | null | null | null |
#ifndef MISC_head
#define MISC_head
namespace comET{
using unInt = unsigned int;
template<bool C, typename T1, typename T2>
struct IF{using type=T1;};
template<typename T1, typename T2>
struct IF<false,T1,T2>{using type=T2;};
// enable_if::type is only defined if B==true. So, if we ask for enable_if<false,T>::type we should get
// a compiler error, unless it is used in the context of SFINAE.
template<bool B, typename T=void> struct enable_if {};
template<typename T> struct enable_if<true, T> { using type=T; };
//this chooses the largest numerical type used in the expression
// (eg numType == double if the two expressions have leftHand::numType=int and leftHand::numType=double)
template<typename leftHand,typename rightHand, typename dummy=void>
struct largestType{
using numType = typename IF<(sizeof(typename leftHand::numType) >= sizeof(typename rightHand::numType)),
typename leftHand::numType, typename rightHand::numType>::type;
};
template<typename Expr, typename LD>
struct largestType<Expr, LD,
typename enable_if<std::is_arithmetic<LD>::value && (! std::is_arithmetic<Expr>::value), void >::type>{
using numType = typename IF<(sizeof(typename Expr::numType) >= sizeof(LD)),
typename Expr::numType, LD>::type;
};
template<typename LD, typename Expr>
struct largestType<LD, Expr,
typename enable_if<std::is_arithmetic<LD>::value && (! std::is_arithmetic<Expr>::value), void >::type>{
using numType = typename IF<(sizeof(typename Expr::numType) >= sizeof(LD)),
typename Expr::numType, LD>::type;
};
template<typename LD1, typename LD2>
struct largestType<LD1, LD2,
typename enable_if<std::is_arithmetic<LD1>::value && std::is_arithmetic<LD2>::value, void >::type>{
using numType = typename IF<sizeof(LD1) >= sizeof(LD2), LD1, LD2>::type;
};
};
#endif
| 33.339286
| 109
| 0.70541
|
dkaramit
|
682ec7b77fa3d0ff1f81ee4bb06ef7e51e41f46e
| 24,873
|
inl
|
C++
|
include/mathos/vmvector_sse.inl
|
napina/mathos
|
c29bf3d2b9e191d4b3644b49f1d014cbaa787706
|
[
"MIT"
] | 1
|
2021-03-31T13:14:54.000Z
|
2021-03-31T13:14:54.000Z
|
include/mathos/vmvector_sse.inl
|
napina/mathos
|
c29bf3d2b9e191d4b3644b49f1d014cbaa787706
|
[
"MIT"
] | null | null | null |
include/mathos/vmvector_sse.inl
|
napina/mathos
|
c29bf3d2b9e191d4b3644b49f1d014cbaa787706
|
[
"MIT"
] | null | null | null |
/*=============================================================================
Copyright (c) 2010 Ville Ruusutie
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.
=============================================================================*/
#pragma once
#ifndef mathos_vmvector_sse_inl
#define mathos_vmvector_sse_inl
namespace mathos {
namespace vm {
namespace internal {
template<int Count> struct Shift {};
template<> struct Shift<1>
{
__forceinline static vmvec Left(vmvecFastParam v1, vmvecFastParam v2)
{
const __m128 a = _mm_move_ss(v1, v2);
return _mm_shuffle_ps(a, a, _MM_SHUFFLE(0,3,2,1));
}
};
template<> struct Shift<2>
{
__forceinline static vmvec Left(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_shuffle_ps(v1, v2, _MM_SHUFFLE(1,0,3,2));
}
};
template<> struct Shift<3>
{
__forceinline static vmvec Left(vmvecFastParam v1, vmvecFastParam v2)
{
const __m128 a = _mm_shuffle_ps(v1, v2, _MM_SHUFFLE(0,0,0,3));
const __m128 b = _mm_shuffle_ps(a, a, _MM_SHUFFLE(0,0,2,0));
return _mm_shuffle_ps(b, v2, _MM_SHUFFLE(0,1,1,2));
}
};
} // end of internal
#define vm_insert(a, b, selectX, selectY, selectZ, selectW)\
_mm_shuffle_ps(\
_mm_shuffle_ps(\
_mm_shuffle_ps(a, b, _MM_SHUFFLE(1,0,1,0)),\
_mm_shuffle_ps(a, b, _MM_SHUFFLE(1,0,1,0)),\
_MM_SHUFFLE(0, 0, ((selectY) ? 3 : 1), ((selectX) ? 2 : 0))),\
_mm_shuffle_ps(\
_mm_shuffle_ps(a, b, _MM_SHUFFLE(3,2,3,2)),\
_mm_shuffle_ps(a, b, _MM_SHUFFLE(3,2,3,2)),\
_MM_SHUFFLE(((selectW) ? 3 : 1), ((selectZ) ? 2 : 0), 0, 0)),\
_MM_SHUFFLE(3,2,1,0))
#define vm_shiftLeft(a, b, elements)\
mathos::vm::internal::Shift<elements>::Left(a, b)
#define vm_rotateLeft(v, elements)\
_mm_shuffle_ps(v, v, _MM_SHUFFLE((elements+3&3),((elements+2)&3),((elements+1)&3),((elements+0)&3)))
#define vm_rotateRight(v, elements)\
vm_rotateLeft(v, 4 - elements)
#define vm_swizzle(v, e0, e1, e2, e3)\
_mm_shuffle_ps(v, v, _MM_SHUFFLE(e3, e2, e1, e0))
//-----------------------------------------------------------------------------
__forceinline vmvec make(float x, float y, float z, float w)
{
return _mm_set_ps(w, z, y, x);
}
__forceinline vmvec makeInt(uint32_t x, uint32_t y, uint32_t z, uint32_t w)
{
__m128i V = _mm_set_epi32(w, z, y, x);
return reinterpret_cast<__m128 *>(&V)[0];
}
__forceinline vmvec splatZero()
{
return _mm_setzero_ps();
}
__forceinline vmvec splatOne()
{
static const vmvec r = {1.0f, 1.0f, 1.0f, 1.0f};
return r;
}
__forceinline vmvec splatSignMask()
{
static const vmmask mask = {0x80000000, 0x80000000, 0x80000000, 0x80000000};
return mask.v;
// __m128i v = _mm_set1_epi32(0x80000000);
// return reinterpret_cast<__m128*>(&v)[0];
}
__forceinline vmvec splatMask(uint32_t mask)
{
__m128i v = _mm_set1_epi32(mask);
return reinterpret_cast<__m128*>(&v)[0];
}
__forceinline vmvec splatX(vmvecFastParam v)
{
return _mm_shuffle_ps(v, v, _MM_SHUFFLE(0,0,0,0));
}
__forceinline vmvec splatY(vmvecFastParam v)
{
return _mm_shuffle_ps(v, v, _MM_SHUFFLE(1,1,1,1));
}
__forceinline vmvec splatZ(vmvecFastParam v)
{
return _mm_shuffle_ps(v, v, _MM_SHUFFLE(2,2,2,2));
}
__forceinline vmvec splatW(vmvecFastParam v)
{
return _mm_shuffle_ps(v, v, _MM_SHUFFLE(3,3,3,3));
}
__forceinline vmvec replicate(float f)
{
return _mm_set_ps1(f);
}
__forceinline vmvec select(vmvecFastParam v1, vmvecFastParam v2, vmvecFastParam control)
{
const __m128 tmp1 = _mm_andnot_ps(control, v1);
const __m128 tmp2 = _mm_and_ps(v2, control);
return _mm_or_ps(tmp1, tmp2);
}
__forceinline vmvec permute(vmvecFastParam v1, vmvecFastParam v2, uint32_t e0, uint32_t e1, uint32_t e2, uint32_t e3)
{
// TODO optimize
vmvec a[2];
a[0] = v1;
a[1] = v2;
float* f = (float*)(&a[0]);
return make(f[e0 & 7], f[e1 & 7], f[e2 & 7], f[e3 & 7]);
};
__forceinline vmvec permute(vmvecFastParam v1, vmvecFastParam v2, vmvecFastParam control)
{
// TODO optimize
vmvec a[2];
a[0] = v1;
a[1] = v2;
float* f = (float*)(&a[0]);
return make(f[control.m128_u32[0] & 7], f[control.m128_u32[1] & 7], f[control.m128_u32[2] & 7], f[control.m128_u32[3] & 7]);
}
__forceinline vmvec permuteXYZA(vmvecFastParam v1, vmvecFastParam v2)
{
return vm_shiftLeft(vm_rotateRight(v1, 1), v2, 1);
}
__forceinline vmvec mergeXY(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_unpacklo_ps(v1, v2);
}
__forceinline vmvec mergeZW(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_unpackhi_ps(v1, v2);
}
//-----------------------------------------------------------------------------
__forceinline vmvec abs4(vmvecFastParam v)
{
__m128 r = _mm_setzero_ps();
r = _mm_sub_ps(r, v);
return _mm_max_ps(r, v);
}
__forceinline vmvec neg4(vmvecFastParam v)
{
const __m128 zero = _mm_setzero_ps();
return _mm_sub_ps(zero, v);
}
__forceinline vmvec min4(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_min_ps(v1, v2);
}
__forceinline vmvec max4(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_max_ps(v1, v2);
}
__forceinline vmvec fract4(vmvecFastParam v)
{
return sub4(v, truncate4(v));
}
__forceinline vmvec round4(vmvecFastParam v)
{
static const vmmask signMask = {0x80000000, 0x80000000, 0x80000000, 0x80000000};
static const __m128 half = {0.5f, 0.5f, 0.5f, 0.5f};
const __m128 s = _mm_and_ps(v, signMask.v);
const __m128 a = _mm_or_ps(half, s);
const __m128 b = _mm_add_ps(v, a);
return _mm_cvtepi32_ps(_mm_cvttps_epi32(b));
}
__forceinline vmvec floor4(vmvecFastParam v)
{
static const vmmask oneHalfMinusEpsilon = {0x3EFFFFFD, 0x3EFFFFFD, 0x3EFFFFFD, 0x3EFFFFFD};
const __m128 r = _mm_sub_ps(v, oneHalfMinusEpsilon.v);
const __m128i i = _mm_cvtps_epi32(r);
return _mm_cvtepi32_ps(i);
}
__forceinline vmvec ceil4(vmvecFastParam v)
{
static const vmmask oneHalfMinusEpsilon = {0x3EFFFFFD, 0x3EFFFFFD, 0x3EFFFFFD, 0x3EFFFFFD};
const __m128 r = _mm_add_ps(v, oneHalfMinusEpsilon.v);
const __m128i i = _mm_cvtps_epi32(r);
return _mm_cvtepi32_ps(i);
}
__forceinline vmvec truncate4(vmvecFastParam v)
{
return _mm_cvtepi32_ps(_mm_cvttps_epi32(v));
}
__forceinline vmvec clamp4(vmvecFastParam v, vmvecFastParam min, vmvecFastParam max)
{
return _mm_min_ps(_mm_max_ps(min, v), max);
}
__forceinline vmvec saturate4(vmvecFastParam v)
{
#if 1
const __m128 zerof = _mm_sub_ps(v, v);
return clamp4(v, zerof, splatOne());
#else
return _mm_min_ps(_mm_max_ps(v, g_XMZero), g_XMOne);
#endif
}
//-----------------------------------------------------------------------------
__forceinline vmvec add4(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_add_ps(v1, v2);
}
__forceinline vmvec sub4(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_sub_ps(v1, v2);
}
__forceinline vmvec mul4(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_mul_ps(v1, v2);
}
__forceinline vmvec mulAdd4(vmvecFastParam v1, vmvecFastParam v2, vmvecFastParam v3)
{
return _mm_add_ps(_mm_mul_ps(v1, v2), v3);
}
__forceinline vmvec negMulSub4(vmvecFastParam v1, vmvecFastParam v2, vmvecFastParam v3)
{
return _mm_sub_ps(v3, _mm_mul_ps(v1, v2));
}
__forceinline vmvec div4(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_div_ps(v1, v2);
}
__forceinline vmvec divEst4(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_mul_ps(v1, _mm_rcp_ps(v2));
}
__forceinline vmvec sqrt4(vmvecFastParam v)
{
static const __m128 half = {0.5f, 0.5f, 0.5f, 0.5f};
// fast estimate with newton-raphson
// a = rsqrt(v)
// b = rcp(a)
// q = b - (b * b - v) * a * 0.5f
const __m128 a = _mm_rsqrt_ps(v);
const __m128 b = _mm_rcp_ps(a);
const __m128 zerof = _mm_xor_ps(v, v);
const __m128 mask = _mm_cmpeq_ps(v, zerof);
const __m128 c = _mm_mul_ps(b, b);
const __m128 d = _mm_mul_ps(a, half);
const __m128 e = _mm_sub_ps(c, v);
const __m128 f = _mm_mul_ps(e, d);
return select(_mm_sub_ps(b, f), zerof, mask);
}
__forceinline vmvec sqrtEst4(vmvecFastParam v)
{
return _mm_mul_ps(v, _mm_rsqrt_ps(v));
}
__forceinline vmvec reciprocalSqrt4(vmvecFastParam v)
{
static const __m128 half = {0.5f, 0.5f, 0.5f, 0.5f};
static const __m128 three = {3.0f, 3.0f, 3.0f, 3.0f};
// fast estimate with newton-raphson
// r = rsqrt(v)
// q = r * ((3.0f - r * r * x) * 0.5f);
const __m128 r = _mm_rsqrt_ps(v);
const __m128 a = _mm_sub_ps(three, _mm_mul_ps( _mm_mul_ps(v, r), r));
const __m128 b = _mm_mul_ps(half, r);
return _mm_mul_ps(a, b);
}
__forceinline vmvec reciprocalSqrtEst4(vmvecFastParam v)
{
return _mm_rsqrt_ps(v);
}
__forceinline vmvec reciprocal4(vmvecFastParam v)
{
static const __m128 one = {1.0f, 1.0f, 1.0f, 1.0f};
// fast estimate with newton-raphson
// r = rcp(v)
// r = r + r * (1.0f - (r * v));
const __m128 r = _mm_rcp_ps(v);
const __m128 a = _mm_sub_ps(one, _mm_mul_ps(r, v));
const __m128 b = _mm_mul_ps(a, r);
return _mm_add_ps(b, r);
}
__forceinline vmvec reciprocalEst4(vmvecFastParam v)
{
return _mm_rcp_ps(v);
}
#define _PS_CONST(Name, Val)\
static const __m128 _ps_##Name = { Val, Val, Val, Val }
#define _PI32_CONST(Name, Val)\
static const vmmask _pi32_##Name = { Val, Val, Val, Val }
__forceinline vmvec sin4(vmvecFastParam v)
{
// Original code made by Julien Pommier. http://gruntthepeon.free.fr/ssemath/
_PI32_CONST(sign_mask, 0x80000000);
_PI32_CONST(inv_sign_mask, ~0x80000000);
_PS_CONST(minus_cephes_DP1, -0.78515625f);
_PS_CONST(minus_cephes_DP2, -2.4187564849853515625e-4f);
_PS_CONST(minus_cephes_DP3, -3.77489497744594108e-8f);
_PS_CONST(sincof_p0, -1.9515295891E-4f);
_PS_CONST(sincof_p1, 8.3321608736E-3f);
_PS_CONST(sincof_p2, -1.6666654611E-1f);
_PS_CONST(coscof_p0, 2.443315711809948E-005f);
_PS_CONST(coscof_p1, -1.388731625493765E-003f);
_PS_CONST(coscof_p2, 4.166664568298827E-002f);
_PS_CONST(cephes_FOPI, 1.27323954473516f);
_PS_CONST(1 , 1.0f);
_PS_CONST(0p5, 0.5f);
_PI32_CONST(1, 1u);
_PI32_CONST(inv1, ~1u);
_PI32_CONST(2, 2u);
_PI32_CONST(4, 4u);
__m128 xmm1, xmm2 = _mm_setzero_ps(), xmm3, sign_bit, y;
__m128i emm0, emm2;
__m128 x = v;
sign_bit = x;
/* take the absolute value */
x = _mm_and_ps(x, _pi32_inv_sign_mask.v);
/* extract the sign bit (upper one) */
sign_bit = _mm_and_ps(sign_bit, _pi32_sign_mask.v);
/* scale by 4/Pi */
y = _mm_mul_ps(x, _ps_cephes_FOPI);
/* store the integer part of y in mm0 */
emm2 = _mm_cvttps_epi32(y);
/* j=(j+1) & (~1) (see the cephes sources) */
emm2 = _mm_add_epi32(emm2, _pi32_1.vi);
emm2 = _mm_and_si128(emm2, _pi32_inv1.vi);
y = _mm_cvtepi32_ps(emm2);
/* get the swap sign flag */
emm0 = _mm_and_si128(emm2, _pi32_4.vi);
emm0 = _mm_slli_epi32(emm0, 29);
/* get the polynom selection mask
there is one polynom for 0 <= x <= Pi/4
and another one for Pi/4<x<=Pi/2
Both branches will be computed.
*/
emm2 = _mm_and_si128(emm2, _pi32_2.vi);
emm2 = _mm_cmpeq_epi32(emm2, _mm_setzero_si128());
__m128 swap_sign_bit = _mm_castsi128_ps(emm0);
__m128 poly_mask = _mm_castsi128_ps(emm2);
sign_bit = _mm_xor_ps(sign_bit, swap_sign_bit);
/* The magic pass: "Extended precision modular arithmetic"
x = ((x - y * DP1) - y * DP2) - y * DP3; */
xmm1 = _ps_minus_cephes_DP1;
xmm2 = _ps_minus_cephes_DP2;
xmm3 = _ps_minus_cephes_DP3;
xmm1 = _mm_mul_ps(y, xmm1);
xmm2 = _mm_mul_ps(y, xmm2);
xmm3 = _mm_mul_ps(y, xmm3);
x = _mm_add_ps(x, xmm1);
x = _mm_add_ps(x, xmm2);
x = _mm_add_ps(x, xmm3);
/* Evaluate the first polynom (0 <= x <= Pi/4) */
y = _ps_coscof_p0;
__m128 z = _mm_mul_ps(x,x);
y = _mm_mul_ps(y, z);
y = _mm_add_ps(y, _ps_coscof_p1);
y = _mm_mul_ps(y, z);
y = _mm_add_ps(y, _ps_coscof_p2);
y = _mm_mul_ps(y, z);
y = _mm_mul_ps(y, z);
__m128 tmp = _mm_mul_ps(z, _ps_0p5);
y = _mm_sub_ps(y, tmp);
y = _mm_add_ps(y, _ps_1);
// Evaluate the second polynom (Pi/4 <= x <= 0)
__m128 y2 = _ps_sincof_p0;
y2 = _mm_mul_ps(y2, z);
y2 = _mm_add_ps(y2, _ps_sincof_p1);
y2 = _mm_mul_ps(y2, z);
y2 = _mm_add_ps(y2, _ps_sincof_p2);
y2 = _mm_mul_ps(y2, z);
y2 = _mm_mul_ps(y2, x);
y2 = _mm_add_ps(y2, x);
// select the correct result from the two polynoms
xmm3 = poly_mask;
y2 = _mm_and_ps(xmm3, y2); //, xmm3);
y = _mm_andnot_ps(xmm3, y);
y = _mm_add_ps(y,y2);
// update the sign
y = _mm_xor_ps(y, sign_bit);
return y;
}
__forceinline vmvec cos4(vmvecFastParam v)
{
// Original code made by Julien Pommier. http://gruntthepeon.free.fr/ssemath/
_PI32_CONST(inv_sign_mask, ~0x80000000);
_PS_CONST(minus_cephes_DP1, -0.78515625f);
_PS_CONST(minus_cephes_DP2, -2.4187564849853515625e-4f);
_PS_CONST(minus_cephes_DP3, -3.77489497744594108e-8f);
_PS_CONST(sincof_p0, -1.9515295891E-4f);
_PS_CONST(sincof_p1, 8.3321608736E-3f);
_PS_CONST(sincof_p2, -1.6666654611E-1f);
_PS_CONST(coscof_p0, 2.443315711809948E-005f);
_PS_CONST(coscof_p1, -1.388731625493765E-003f);
_PS_CONST(coscof_p2, 4.166664568298827E-002f);
_PS_CONST(cephes_FOPI, 1.27323954473516f);
_PS_CONST(1 , 1.0f);
_PS_CONST(0p5, 0.5f);
_PI32_CONST(1, 1u);
_PI32_CONST(inv1, ~1u);
_PI32_CONST(2, 2u);
_PI32_CONST(4, 4u);
__m128 xmm1, xmm2 = _mm_setzero_ps(), xmm3, y;
__m128i emm0, emm2;
/* take the absolute value */
__m128 x = _mm_and_ps(v, _pi32_inv_sign_mask.v);
/* scale by 4/Pi */
y = _mm_mul_ps(x, _ps_cephes_FOPI);
/* store the integer part of y in mm0 */
emm2 = _mm_cvttps_epi32(y);
/* j=(j+1) & (~1) (see the cephes sources) */
emm2 = _mm_add_epi32(emm2, _pi32_1.vi);
emm2 = _mm_and_si128(emm2, _pi32_inv1.vi);
y = _mm_cvtepi32_ps(emm2);
emm2 = _mm_sub_epi32(emm2, _pi32_2.vi);
/* get the swap sign flag */
emm0 = _mm_andnot_si128(emm2, _pi32_4.vi);
emm0 = _mm_slli_epi32(emm0, 29);
/* get the polynom selection mask */
emm2 = _mm_and_si128(emm2, _pi32_2.vi);
emm2 = _mm_cmpeq_epi32(emm2, _mm_setzero_si128());
__m128 sign_bit = _mm_castsi128_ps(emm0);
__m128 poly_mask = _mm_castsi128_ps(emm2);
/* The magic pass: "Extended precision modular arithmetic"
x = ((x - y * DP1) - y * DP2) - y * DP3; */
xmm1 = _ps_minus_cephes_DP1;
xmm2 = _ps_minus_cephes_DP2;
xmm3 = _ps_minus_cephes_DP3;
xmm1 = _mm_mul_ps(y, xmm1);
xmm2 = _mm_mul_ps(y, xmm2);
xmm3 = _mm_mul_ps(y, xmm3);
x = _mm_add_ps(x, xmm1);
x = _mm_add_ps(x, xmm2);
x = _mm_add_ps(x, xmm3);
// Evaluate the first polynom (0 <= x <= Pi/4)
y = _ps_coscof_p0;
__m128 z = _mm_mul_ps(x,x);
y = _mm_mul_ps(y, z);
y = _mm_add_ps(y, _ps_coscof_p1);
y = _mm_mul_ps(y, z);
y = _mm_add_ps(y, _ps_coscof_p2);
y = _mm_mul_ps(y, z);
y = _mm_mul_ps(y, z);
__m128 tmp = _mm_mul_ps(z, _ps_0p5);
y = _mm_sub_ps(y, tmp);
y = _mm_add_ps(y, _ps_1);
// Evaluate the second polynom (Pi/4 <= x <= 0)
__m128 y2 = _ps_sincof_p0;
y2 = _mm_mul_ps(y2, z);
y2 = _mm_add_ps(y2, _ps_sincof_p1);
y2 = _mm_mul_ps(y2, z);
y2 = _mm_add_ps(y2, _ps_sincof_p2);
y2 = _mm_mul_ps(y2, z);
y2 = _mm_mul_ps(y2, x);
y2 = _mm_add_ps(y2, x);
// select the correct result from the two polynoms
xmm3 = poly_mask;
y2 = _mm_and_ps(xmm3, y2); //, xmm3);
y = _mm_andnot_ps(xmm3, y);
y = _mm_add_ps(y,y2);
// update the sign
y = _mm_xor_ps(y, sign_bit);
return y;
}
#undef _PS_CONST
#undef _PI32_CONST
#undef _PS_CONST_TYPE
__forceinline vmvec sinZeroHalfPI4(vmvecFastParam a)
{
static const __m128 sin_c0 = {-2.39e-08f, -2.39e-08f, -2.39e-08f, -2.39e-08f};
static const __m128 sin_c1 = {2.7526e-06f, 2.7526e-06f, 2.7526e-06f, 2.7526e-06f};
static const __m128 sin_c2 = {-1.98409e-04f, -1.98409e-04f, -1.98409e-04f, -1.98409e-04f};
static const __m128 sin_c3 = {8.3333315e-03f, 8.3333315e-03f, 8.3333315e-03f, 8.3333315e-03f};
static const __m128 sin_c4 = {-1.666666664e-01f, -1.666666664e-01f, -1.666666664e-01f, -1.666666664e-01f};
static const __m128 one = {1.0f, 1.0f, 1.0f, 1.0f};
__m128 s, t;
s = _mm_mul_ps(a, a);
t = _mm_add_ps(_mm_mul_ps(sin_c0, s), sin_c1);
t = _mm_add_ps(_mm_mul_ps(t, s), sin_c2);
t = _mm_add_ps(_mm_mul_ps(t, s), sin_c3);
t = _mm_add_ps(_mm_mul_ps(t, s), sin_c4);
t = _mm_add_ps(_mm_mul_ps(t, s), one);
return _mm_mul_ps(t, a);
}
__forceinline vmvec atanPositive4(vmvecFastParam y, vmvecFastParam x)
{
static const __m128 atan_c0 = { 0.0028662257f, 0.0028662257f, 0.0028662257f, 0.0028662257f};
static const __m128 atan_c1 = {-0.0161657367f, -0.0161657367f, -0.0161657367f, -0.0161657367f};
static const __m128 atan_c2 = { 0.0429096138f, 0.0429096138f, 0.0429096138f, 0.0429096138f};
static const __m128 atan_c3 = {-0.0752896400f, -0.0752896400f, -0.0752896400f, -0.0752896400f};
static const __m128 atan_c4 = { 0.1065626393f, 0.1065626393f, 0.1065626393f, 0.1065626393f};
static const __m128 atan_c5 = {-0.1420889944f, -0.1420889944f, -0.1420889944f, -0.1420889944f};
static const __m128 atan_c6 = { 0.1999355085f, 0.1999355085f, 0.1999355085f, 0.1999355085f};
static const __m128 atan_c7 = {-0.3333314528f, -0.3333314528f, -0.3333314528f, -0.3333314528f};
static const __m128 halfpi = {1.57079633f, 1.57079633f, 1.57079633f, 1.57079633f};
static const __m128 one = {1.0f, 1.0f, 1.0f, 1.0f};
static const vmmask signMask = {0x80000000, 0x80000000, 0x80000000, 0x80000000};
const __m128 minv = _mm_min_ps(x, y);
const __m128 maxv = _mm_max_ps(x, y);
const __m128 cmp = _mm_cmpeq_ps(y, maxv);
// reciprocal with newton-raphson
// r = rcp(maxv)
// r = minv * ((r + r) - ((maxv * r) * r))
const __m128 r = _mm_rcp_ps(maxv);
const __m128 ra = _mm_mul_ps(_mm_mul_ps(maxv, r), r);
const __m128 rb = _mm_sub_ps(_mm_add_ps(r, r), ra);
const __m128 rc = _mm_mul_ps(minv, rb);
const __m128 a = _mm_xor_ps(rc, _mm_and_ps(cmp, signMask.v)); // (y>x) ? (-x/y) : (y/x)
const __m128 d = _mm_and_ps(cmp, halfpi); // (y>x) ? (pi/2) : 0
__m128 s, t;
s = _mm_mul_ps(a, a);
t = _mm_add_ps(_mm_mul_ps(atan_c0, s), atan_c1);
t = _mm_add_ps(_mm_mul_ps(t, s), atan_c2);
t = _mm_add_ps(_mm_mul_ps(t, s), atan_c3);
t = _mm_add_ps(_mm_mul_ps(t, s), atan_c4);
t = _mm_add_ps(_mm_mul_ps(t, s), atan_c5);
t = _mm_add_ps(_mm_mul_ps(t, s), atan_c6);
t = _mm_add_ps(_mm_mul_ps(t, s), atan_c7);
t = _mm_add_ps(_mm_mul_ps(t, s), one);
return _mm_add_ps(_mm_mul_ps(t, a), d);
}
//-----------------------------------------------------------------------------
__forceinline vmvec isNaN(vmvecFastParam v)
{
const __m128i infinity = _mm_set1_epi32(0x7F800000);
const __m128i nanTest = _mm_set1_epi32(0x007FFFFF);
__m128i vTempInf = _mm_and_si128(reinterpret_cast<const __m128i*>(&v)[0], infinity);
__m128i vTempNan = _mm_and_si128(reinterpret_cast<const __m128i*>(&v)[0], nanTest);
vTempInf = _mm_cmpeq_epi32(vTempInf, infinity);
vTempNan = _mm_cmpeq_epi32(vTempNan, _mm_xor_si128(vTempNan,vTempNan));
vTempNan = _mm_andnot_si128(vTempNan, vTempInf);
return reinterpret_cast<const __m128*>(&vTempNan)[0];
}
__forceinline vmvec isEqual(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_cmpeq_ps(v1, v2);
}
__forceinline vmvec isNotEqual(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_cmpneq_ps(v1, v2);
}
__forceinline vmvec isGreater(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_cmpgt_ps(v1, v2);
}
__forceinline vmvec isGreaterOrEqual(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_cmpge_ps(v1, v2);
}
__forceinline vmvec isLess(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_cmplt_ps(v1, v2);
}
__forceinline vmvec isLessOrEqual(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_cmple_ps(v1, v2);
}
__forceinline vmvec isInBounds(vmvecFastParam v, vmvecFastParam bounds)
{
const __m128 n = neg4(bounds);
const __m128 a = _mm_cmple_ps(v, bounds);
const __m128 b = _mm_cmple_ps(n, v);
return _mm_and_ps(a, b);
}
__forceinline uint32_t allEqual(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_movemask_ps(_mm_cmpeq_ps(v1, v2)) == 0xf;
}
__forceinline uint32_t allLess(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_movemask_ps(_mm_cmplt_ps(v1, v2)) == 0xf;
}
__forceinline uint32_t allLessOrEqual(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_movemask_ps(_mm_cmple_ps(v1, v2)) == 0xf;
}
__forceinline uint32_t allGreater(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_movemask_ps(_mm_cmpgt_ps(v1, v2)) == 0xf;
}
__forceinline uint32_t allGreaterOrEqual(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_movemask_ps(_mm_cmpge_ps(v1, v2)) == 0xf;
}
__forceinline uint32_t anyEqual(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_movemask_ps(_mm_cmpeq_ps(v1, v2)) != 0;
}
__forceinline uint32_t anyLess(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_movemask_ps(_mm_cmplt_ps(v1, v2)) != 0;
}
__forceinline uint32_t anyLessOrEqual(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_movemask_ps(_mm_cmple_ps(v1, v2)) != 0;
}
__forceinline uint32_t anyGreater(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_movemask_ps(_mm_cmpgt_ps(v1, v2)) != 0;
}
__forceinline uint32_t anyGreaterOrEqual(vmvecFastParam v1, vmvecFastParam v2)
{
return _mm_movemask_ps(_mm_cmpge_ps(v1, v2)) != 0;
}
__forceinline uint32_t allSame(vmvecFastParam v)
{
return _mm_movemask_ps(_mm_cmpeq_ps(v, _mm_shuffle_ps(v, v, _MM_SHUFFLE(0,0,0,0)))) == 0xf;
}
//-----------------------------------------------------------------------------
__forceinline vmvec randomSeed()
{
static const vmmask defaultSeed = {
0x10D63AF1, // 16087^2
0x60B7A437, // 16087^3
0xB87E16E1, // 16087^4
0x5E100DC7 // 16087^5
};
return defaultSeed.v;
}
__forceinline vmvec random01(vmvec& seed)
{
// (((seed * 16807) & 0x007fffff) | 0x3f800000) - 1.0f
const __m128i magic = _mm_set1_epi32(16807);
const __m128i andMask = _mm_set1_epi32(0x007fffff);
const __m128i orMask = _mm_set1_epi32(0x3f800000);
__m128i s = reinterpret_cast<__m128i*>(&seed)[0];
s = _mm_mul_epu32(s, magic);
s = _mm_or_si128(_mm_and_si128(s, andMask), orMask);
seed = reinterpret_cast<__m128*>(&s)[0];
return _mm_sub_ps(seed, splatOne());
}
__forceinline vmvec randomSigned(vmvec& seed)
{
// (((seed * 16807) & 0x007fffff) | 0x40000000) - 3.0f
const __m128i magic = _mm_set1_epi32(16807);
const __m128i andMask = _mm_set1_epi32(0x007fffff);
const __m128i orMask = _mm_set1_epi32(0x40000000);
__m128i s = reinterpret_cast<__m128i*>(&seed)[0];
s = _mm_mul_epu32(s, magic);
s = _mm_or_si128(_mm_and_si128(s, andMask), orMask);
seed = reinterpret_cast<__m128*>(&s)[0];
return _mm_sub_ps(seed, replicate(3.0f));
}
__forceinline vmvec randomNormal(vmvec& seed)
{
return normalize3(randomSigned(seed));
}
__forceinline vmvec randomQuat(vmvec& seed)
{
// use precomputed angle
static const __m128 sin = {0.841470985f, 0.841470985f, 0.841470985f, 0.0f};
static const __m128 cos = {0.0f, 0.0f, 0.0f, 0.540302306f};
vmvec axis = randomNormal(seed);
__m128 r = _mm_mul_ps(axis, sin);
return _mm_add_ps(r, cos);
}
//-----------------------------------------------------------------------------
} // end of vm
} // end of matho
#endif
| 31.169173
| 128
| 0.662043
|
napina
|
683553fab88f23208a8c889422e9d7676a4c30e5
| 951
|
cpp
|
C++
|
lib/netdata/fragments_npc.cpp
|
siilky/catomania
|
cb3a05cbef523d16b8929b390e190e0cd5924ee9
|
[
"MIT"
] | 1
|
2021-02-05T23:20:07.000Z
|
2021-02-05T23:20:07.000Z
|
lib/netdata/fragments_npc.cpp
|
siilky/catomania
|
cb3a05cbef523d16b8929b390e190e0cd5924ee9
|
[
"MIT"
] | null | null | null |
lib/netdata/fragments_npc.cpp
|
siilky/catomania
|
cb3a05cbef523d16b8929b390e190e0cd5924ee9
|
[
"MIT"
] | null | null | null |
#include "stdafx.h"
#include "common.h"
#include "utils.h"
#include "netdata/fragments_npc.h"
namespace clientdata
{
bool identifyFragmentNpcInteract(const barray & dataStream, barray::const_iterator & curPos, unsigned int *id)
{
size_t bytesLeft = dataStream.end() - curPos;
if (bytesLeft < 8)
{
return false;
}
*id = getDWORD_r(curPos);
bytesLeft -= 4;
unsigned length = getDWORD_r(curPos);
bytesLeft -= 4;
if (bytesLeft < length)
{
return false;
}
return true;
}
static const fragmentCollection_t client_fragments[] =
{
COLLECTION_ELEMENT(BattleChallengeMap),
COLLECTION_ELEMENT(RequestTask),
COLLECTION_END
};
FragmentFactory fragmentNpcInteractFactory(identifyFragmentNpcInteract, client_fragments, fragment_static_ctor<FragmentBase>);
} // namespace
| 22.116279
| 130
| 0.623554
|
siilky
|
6835d2fb78cd744a9f6352c3165bf8282535a8fe
| 3,726
|
cpp
|
C++
|
src/common/ThreadPool.cpp
|
klx99/Elastos.Service.CarrierGroup
|
a1922402af66308178f048352ab6038f4c2d848b
|
[
"MIT"
] | null | null | null |
src/common/ThreadPool.cpp
|
klx99/Elastos.Service.CarrierGroup
|
a1922402af66308178f048352ab6038f4c2d848b
|
[
"MIT"
] | null | null | null |
src/common/ThreadPool.cpp
|
klx99/Elastos.Service.CarrierGroup
|
a1922402af66308178f048352ab6038f4c2d848b
|
[
"MIT"
] | null | null | null |
//
// ThreadPool.cpp
//
// Created by mengxk on 19/03/16.
// Copyright © 2016 mengxk. All rights reserved.
//
#include "ThreadPool.hpp"
#include "Log.hpp"
namespace elastos {
/***********************************************/
/***** static variables initialize *************/
/***********************************************/
/***********************************************/
/***** static function implement ***************/
/***********************************************/
/***********************************************/
/***** class public function implement ********/
/***********************************************/
ThreadPool::ThreadPool(const std::string& threadName, size_t threadCnt)
: mThreadName(threadName)
, mThreadPool(threadCnt)
, mMutex()
, mCondition()
, mTaskQueue()
, mQuit(false)
{
Log::D(Log::TAG, "%s name:%s count:%d", FORMAT_METHOD, threadName.c_str(), threadCnt);
for(size_t idx = 0; idx < mThreadPool.size(); idx++) {
mThreadPool[idx] = std::thread(&ThreadPool::processTaskQueue, this);
}
}
ThreadPool::~ThreadPool()
{
Log::D(Log::TAG, "%s name:%s", FORMAT_METHOD, mThreadName.c_str());
std::unique_lock<std::mutex> lock(mMutex);
mQuit = true;
auto empty = std::queue<Task>();
std::swap(mTaskQueue, empty); // mTaskQueue.clear();
lock.unlock();
mCondition.notify_all();
// Wait for threads to finish before we exit
for(size_t idx = 0; idx < mThreadPool.size(); idx++) {
auto& it = mThreadPool[idx];
if(it.joinable()) {
Log::D(Log::TAG, "%s Joining thread %d until completion. tid=%d:%d",
FORMAT_METHOD, idx, it.get_id(), std::this_thread::get_id());
it.join();
Log::D(Log::TAG, "%s Joined thread.", FORMAT_METHOD);
}
}
mThreadPool.clear();
}
int ThreadPool::sleepMS(long milliSecond)
{
auto interval = 100; // ms
auto elapsed = 0;
do {
auto remains = milliSecond - elapsed;
auto needsleep = interval < remains ? interval : remains;
std::this_thread::sleep_for(std::chrono::milliseconds(needsleep));
elapsed += needsleep;
if(mQuit == true) {
return -1;
}
} while (elapsed < milliSecond);
return 0;
}
void ThreadPool::post(const Task& task)
{
if(mQuit == true) {
return;
}
std::unique_lock<std::mutex> lock(mMutex);
mTaskQueue.push(task);
// Manual unlocking is done before notifying, to avoid waking up
// the waiting thread only to block again (see notify_one for details)
lock.unlock();
mCondition.notify_all();
}
void ThreadPool::post(Task&& task)
{
if(mQuit == true) {
return;
}
std::unique_lock<std::mutex> lock(mMutex);
mTaskQueue.push(std::move(task));
// Manual unlocking is done before notifying, to avoid waking up
// the waiting thread only to block again (see notify_one for details)
lock.unlock();
mCondition.notify_all();
}
/***********************************************/
/***** class protected function implement *****/
/***********************************************/
/***********************************************/
/***** class private function implement *******/
/***********************************************/
void ThreadPool::processTaskQueue(void)
{
std::unique_lock<std::mutex> lock(mMutex);
do {
//Wait until we have data or a quit signal
mCondition.wait(lock, [this]{
return (mTaskQueue.size() || mQuit);
});
//after wait, we own the lock
if(!mQuit && mTaskQueue.size())
{
auto task = std::move(mTaskQueue.front());
mTaskQueue.pop();
//unlock now that we're done messing with the queue
lock.unlock();
task();
lock.lock();
}
} while (!mQuit);
Log::D(Log::TAG, "%s name:%s exit.", FORMAT_METHOD, mThreadName.c_str());
}
} // namespace elastos
| 25.006711
| 90
| 0.556629
|
klx99
|
6836a3e5919d02c7b1e61d0a1bf53fc1e43759bb
| 1,162
|
cpp
|
C++
|
source/GLRenderer/shaders/HeavyShaders.cpp
|
GPUPeople/cuRE
|
ccba6a29bba4445300cbb630befe57e31f0d80cb
|
[
"MIT"
] | 55
|
2018-07-11T23:40:06.000Z
|
2022-03-18T05:34:44.000Z
|
source/GLRenderer/shaders/HeavyShaders.cpp
|
GPUPeople/cuRE
|
ccba6a29bba4445300cbb630befe57e31f0d80cb
|
[
"MIT"
] | 1
|
2018-09-10T09:57:47.000Z
|
2018-09-10T09:57:47.000Z
|
source/GLRenderer/shaders/HeavyShaders.cpp
|
GPUPeople/cuRE
|
ccba6a29bba4445300cbb630befe57e31f0d80cb
|
[
"MIT"
] | 13
|
2018-08-16T17:00:36.000Z
|
2022-01-17T08:33:57.000Z
|
#include "../config.h"
#include "HeavyShaders.h"
extern const char heavy_vertex_vs[];
extern const char heavy_vertex_fs[];
extern const char heavy_vertex_interlocked_fs[];
extern const char heavy_fragment_vs[];
extern const char heavy_fragment_fs[];
extern const char heavy_fragment_interlocked_fs[];
namespace GLRenderer
{
HeavyVertexShader::HeavyVertexShader()
{
auto vs = GL::compileVertexShader(heavy_vertex_vs);
auto fs = GL::compileFragmentShader(FRAGMENT_SHADER_INTERLOCK ? heavy_vertex_interlocked_fs : heavy_vertex_fs);
glAttachShader(prog, vs);
glAttachShader(prog, fs);
GL::linkProgram(prog);
}
void HeavyVertexShader::draw(const ::Geometry* geometry) const
{
glUseProgram(prog);
geometry->draw();
}
HeavyFragmentShader::HeavyFragmentShader()
{
auto vs = GL::compileVertexShader(heavy_fragment_vs);
auto fs = GL::compileFragmentShader(FRAGMENT_SHADER_INTERLOCK ? heavy_fragment_interlocked_fs : heavy_fragment_fs);
glAttachShader(prog, vs);
glAttachShader(prog, fs);
GL::linkProgram(prog);
}
void HeavyFragmentShader::draw(const ::Geometry* geometry) const
{
glUseProgram(prog);
geometry->draw();
}
}
| 24.208333
| 117
| 0.766781
|
GPUPeople
|
6839cfa938370f80aef5a0151b9548fc625761e6
| 330
|
cpp
|
C++
|
MistThread/Input/MouseState.cpp
|
Neko81795/CBREngine
|
3ea100f09110d55fcbcadb23c246d47ed46c5121
|
[
"CC-BY-4.0",
"MIT"
] | 2
|
2015-08-30T00:26:45.000Z
|
2015-11-13T05:58:30.000Z
|
MistThread/Input/MouseState.cpp
|
Neko81795/CBREngine
|
3ea100f09110d55fcbcadb23c246d47ed46c5121
|
[
"CC-BY-4.0",
"MIT"
] | 1
|
2015-11-25T06:28:13.000Z
|
2015-11-25T06:30:32.000Z
|
MistThread/Input/MouseState.cpp
|
Neko81795/CBREngine
|
3ea100f09110d55fcbcadb23c246d47ed46c5121
|
[
"CC-BY-4.0",
"MIT"
] | null | null | null |
#include "MouseState.h"
namespace MistThread
{
namespace Input
{
Vector2 MouseState::PositionInGameWorld(const Vector2& camera, float cameraZ, Vector2 windowCenter, float zLayer) const
{
float addscale = 1 / (-(zLayer + cameraZ) / 30);
return ((Position - windowCenter) / addscale) + camera;
}
}
}
| 22
| 123
| 0.669697
|
Neko81795
|
683e981a35cb41df3c0405940fe8f12d4f7b0817
| 5,412
|
cpp
|
C++
|
game/src/Map/Map.cpp
|
jblacklock/Infinite-Resignation
|
ee968fa296633ae2bac9dd3581b1a7aefcf0a9fb
|
[
"MIT"
] | null | null | null |
game/src/Map/Map.cpp
|
jblacklock/Infinite-Resignation
|
ee968fa296633ae2bac9dd3581b1a7aefcf0a9fb
|
[
"MIT"
] | null | null | null |
game/src/Map/Map.cpp
|
jblacklock/Infinite-Resignation
|
ee968fa296633ae2bac9dd3581b1a7aefcf0a9fb
|
[
"MIT"
] | null | null | null |
#include "Map/Map.h"
#include <fstream>
#include <stdio.h>
#include <string>
#include <iostream>
#include "Map/TileFactory.h"
#include "components/Components.h"
#include "PlayerCharacter.h"
using namespace std;
SDL_Event e;
Map::Map(int mapID, int Rows, int Columns)
{
int rows = Rows;
int columns = Columns;
std::string mapNumber = std::to_string(mapID);
std::string txtFileToRead = "assets/maps/mapNumber" + mapNumber + ".txt";
ifstream myfile(txtFileToRead);
///what did the below line do?
//Tile myArray[Rows*Columns];
int tileCount = 0;
int i=0,j=0;
while (!myfile.eof())
{
int x=50;
int y=50;
int w=50;
int h=50;
int type;
myfile >> type;
///this value being const might be a problem later
char* tileName;
int weight;
std::string temporaryString;
std::string s = std::to_string(type);
temporaryString = "assets/images/" + s + "tile.png";
tileName = &temporaryString[0];
x *= i;
y *= j;
tileCount++;
if(i==columns-1)
{
i=0;
j++;
}
else
i++;
Tile currentTile;
weight = 1;
if ( type == 111 || type >= 113 && type <= 120 || type >= 133 && type <= 138 || type >= 198 && type <= 202 || type ==204 || type >= 216 && type <= 228 || type >= 231 && type <= 235)
{
weight = 2000;
}
currentTile.init(tileName, x, y, w, h, weight);
tiles.push_back(currentTile);
}
}
//Map::~Map()
//{
//dtor
//}
void Map::render()
{
std::list<Tile>::iterator it;
for(it = tiles.begin(); it!=tiles.end(); ++it)
{
it->render();
}
}
void Map::resetListener()
{
canMoveDown=false;
canMoveLeft=false;
canMoveRight=false;
canMoveUp= false;
}
void Map::eventHandle()
{
///to be implemented
///if((x<10)||(x>490)||(y<10)||(y>490))
///change the x and y of all the tiles in the map
if(WindowProperty::event.type == SDL_KEYDOWN)
{
resetListener();
switch(WindowProperty::event.key.keysym.sym)
{
case SDLK_w:
{
std::list<Tile>::iterator it;
for(it = tiles.begin(); it!=tiles.end(); ++it)
{
int t = it->getComponent<TransformComponent>().position.y;
if(t<0)
{
canMoveUp = true;
break;
}
}
if(canMoveUp ==true )
{
moveTilesUp(1);
}
}
break;
case SDLK_a:
{
std::list<Tile>::iterator it;
for(it = tiles.begin(); it!=tiles.end(); ++it)
{
int t = it->getComponent<TransformComponent>().position.x;
if(t<0)
{
canMoveLeft = true;
break;
}
}
if(canMoveLeft ==true )
{
moveTilesLeft(1);
}
}
break;
case SDLK_s:
{
std::list<Tile>::iterator it;
for(it = tiles.begin(); it!=tiles.end(); ++it)
{
int t = it->getComponent<TransformComponent>().position.y;
if(t>450)
{
canMoveDown = true;
break;
}
}
if(canMoveDown == true )
{
moveTilesDown(1);
}
}
break;
case SDLK_d:
{
std::list<Tile>::iterator it;
for(it = tiles.begin(); it!=tiles.end(); ++it)
{
int t = it->getComponent<TransformComponent>().position.x;
if(t>450)
{
canMoveRight = true;
break;
}
}
if(canMoveRight == true )
{
moveTilesRight(1);
}
}
break;
}
}
}
void Map::updateTile()
{
std::list<Tile>::iterator it;
for(it = tiles.begin(); it!=tiles.end(); ++it)
{
it->update();
}
}
void Map::moveTilesUp(int distanceUp)
{
std::list<Tile>::iterator it;
for(it = tiles.begin(); it!=tiles.end(); ++it)
{
int height= it->getH();
it->setY(distanceUp*(height));
}
}
void Map::moveTilesDown(int distanceDown)
{
std::list<Tile>::iterator it;
std::vector<PlayerCharacter>::iterator pit;
for(it = tiles.begin(); it!=tiles.end(); ++it)
{
int height= it->getH();
it->setY(distanceDown*(-height));
}
//the commented out code below is what I want to do
//for(pit = goodGuys.begin(); pit!=goodGuys.end(); pit++)
//{
// int height = pit.getComponent<Transformer>().position.x;
//pit.setCoordinates();
//}
}
void Map::moveTilesRight(int distanceRight)
{
std::list<Tile>::iterator it;
for(it = tiles.begin(); it!=tiles.end(); ++it)
{
int width= it->getW();
it->setX(distanceRight*(-width));
}
}
void Map::moveTilesLeft(int distanceLeft)
{
std::list<Tile>::iterator it;
for(it = tiles.begin(); it!=tiles.end(); ++it)
{
int width= it->getW();
it->setX(distanceLeft*(width));
}
}
| 22.739496
| 189
| 0.470806
|
jblacklock
|
96984babce454b33141e1d919d72e72967f795b7
| 1,054
|
cpp
|
C++
|
artifact/storm/src/storm/storage/prism/ClockVariable.cpp
|
glatteis/tacas21-artifact
|
30b4f522bd3bdb4bebccbfae93f19851084a3db5
|
[
"MIT"
] | null | null | null |
artifact/storm/src/storm/storage/prism/ClockVariable.cpp
|
glatteis/tacas21-artifact
|
30b4f522bd3bdb4bebccbfae93f19851084a3db5
|
[
"MIT"
] | null | null | null |
artifact/storm/src/storm/storage/prism/ClockVariable.cpp
|
glatteis/tacas21-artifact
|
30b4f522bd3bdb4bebccbfae93f19851084a3db5
|
[
"MIT"
] | 1
|
2022-02-05T12:39:53.000Z
|
2022-02-05T12:39:53.000Z
|
#include "storm/storage/prism/ClockVariable.h"
#include "storm/storage/expressions/ExpressionManager.h"
#include "storm/utility/constants.h"
namespace storm {
namespace prism {
ClockVariable::ClockVariable(storm::expressions::Variable const& variable, bool observable, std::string const& filename, uint_fast64_t lineNumber) : Variable(variable, variable.getManager().rational(storm::utility::zero<storm::RationalNumber>()), observable, filename, lineNumber) {
// Nothing to do here.
}
void ClockVariable::createMissingInitialValue() {
if (!this->hasInitialValue()) {
this->setInitialValueExpression(this->getExpressionVariable().getManager().rational(storm::utility::zero<storm::RationalNumber>()));
}
}
std::ostream& operator<<(std::ostream& stream, ClockVariable const& variable) {
stream << variable.getName() << ": clock" << ";";
return stream;
}
} // namespace prism
} // namespace storm
| 42.16
| 290
| 0.64611
|
glatteis
|
96a5504d934a0b79251e7a209eb0b669eaff9b21
| 42,694
|
cpp
|
C++
|
external/glbinding-2.1.1/source/glbinding/source/gl/types.cpp
|
Arduqq/computer-graphics
|
dbf3f8ad223eac28eba11ee22c06a3893dd38416
|
[
"MIT"
] | 18
|
2016-09-03T05:12:25.000Z
|
2022-02-23T15:52:33.000Z
|
external/glbinding-2.1.1/source/glbinding/source/gl/types.cpp
|
Arduqq/computer-graphics
|
dbf3f8ad223eac28eba11ee22c06a3893dd38416
|
[
"MIT"
] | 1
|
2016-05-04T09:06:29.000Z
|
2016-05-04T09:06:29.000Z
|
external/glbinding-2.1.1/source/glbinding/source/gl/types.cpp
|
Arduqq/computer-graphics
|
dbf3f8ad223eac28eba11ee22c06a3893dd38416
|
[
"MIT"
] | 7
|
2016-04-20T13:58:50.000Z
|
2018-07-09T15:47:26.000Z
|
#include <glbinding/gl/types.h>
#include <glbinding/Meta.h>
#include <bitset>
#include <sstream>
template <typename T>
std::string bitfieldString(T value)
{
std::bitset<sizeof(gl::GLbitfield) * 8> bits(static_cast<gl::GLbitfield>(value));
std::stringstream ss;
bool first = true;
for (size_t i = 0; i < sizeof(gl::GLbitfield) * 8; ++i)
{
if (!bits.test(i))
continue;
if (first)
{
first = false;
}
else
{
ss << " | ";
}
const gl::GLbitfield bit = 1 << i;
const auto identifier = glbinding::Meta::getString(static_cast<T>(bit));
if (identifier.empty())
{
ss << "1 << " << i;
}
else
{
ss << identifier;
}
}
return ss.str();
}
namespace gl
{
std::ostream & operator<<(std::ostream & stream, const GLextension & value)
{
stream << glbinding::Meta::getString(value);
return stream;
}
} // namespace gl
namespace gl
{
std::ostream & operator<<(std::ostream & stream, const GLenum & value)
{
stream << glbinding::Meta::getString(value);
return stream;
}
} // namespace gl
namespace gl
{
GLenum operator+(const GLenum & a, std::underlying_type<GLenum>::type b)
{
return static_cast<GLenum>(static_cast<std::underlying_type<GLenum>::type>(a) + b);
}
GLenum operator-(const GLenum & a, std::underlying_type<GLenum>::type b)
{
return static_cast<GLenum>(static_cast<std::underlying_type<GLenum>::type>(a) - b);
}
} // namespace gl
namespace gl
{
bool operator==(const GLenum & a, std::underlying_type<GLenum>::type b)
{
return static_cast<std::underlying_type<GLenum>::type>(a) == b;
}
bool operator!=(const GLenum & a, std::underlying_type<GLenum>::type b)
{
return static_cast<std::underlying_type<GLenum>::type>(a) != b;
}
bool operator<(const GLenum & a, std::underlying_type<GLenum>::type b)
{
return static_cast<std::underlying_type<GLenum>::type>(a) < b;
}
bool operator<=(const GLenum & a, std::underlying_type<GLenum>::type b)
{
return static_cast<std::underlying_type<GLenum>::type>(a) <= b;
}
bool operator>(const GLenum & a, std::underlying_type<GLenum>::type b)
{
return static_cast<std::underlying_type<GLenum>::type>(a) > b;
}
bool operator>=(const GLenum & a, std::underlying_type<GLenum>::type b)
{
return static_cast<std::underlying_type<GLenum>::type>(a) >= b;
}
bool operator==(std::underlying_type<GLenum>::type a, const GLenum & b)
{
return a == static_cast<std::underlying_type<GLenum>::type>(b);
}
bool operator!=(std::underlying_type<GLenum>::type a, const GLenum & b)
{
return a != static_cast<std::underlying_type<GLenum>::type>(b);
}
bool operator<(std::underlying_type<GLenum>::type a, const GLenum & b)
{
return a < static_cast<std::underlying_type<GLenum>::type>(b);
}
bool operator<=(std::underlying_type<GLenum>::type a, const GLenum & b)
{
return a <= static_cast<std::underlying_type<GLenum>::type>(b);
}
bool operator>(std::underlying_type<GLenum>::type a, const GLenum & b)
{
return a > static_cast<std::underlying_type<GLenum>::type>(b);
}
bool operator>=(std::underlying_type<GLenum>::type a, const GLenum & b)
{
return a >= static_cast<std::underlying_type<GLenum>::type>(b);
}
} // namespace gl
namespace gl
{
std::ostream & operator<<(std::ostream & stream, const GLboolean & value)
{
stream << glbinding::Meta::getString(value);
return stream;
}
} // namespace gl
namespace gl
{
std::ostream & operator<<(std::ostream & stream, const AttribMask & value)
{
stream << bitfieldString<AttribMask>(value);
return stream;
}
} // namespace gl
namespace gl
{
AttribMask operator|(const AttribMask & a, const AttribMask & b)
{
return static_cast<AttribMask>(static_cast<std::underlying_type<AttribMask>::type>(a) | static_cast<std::underlying_type<AttribMask>::type>(b));
}
AttribMask & operator|=(AttribMask & a, const AttribMask & b)
{
a = static_cast<AttribMask>(static_cast<std::underlying_type<AttribMask>::type>(a) | static_cast<std::underlying_type<AttribMask>::type>(b));
return a;
}
AttribMask operator&(const AttribMask & a, const AttribMask & b)
{
return static_cast<AttribMask>(static_cast<std::underlying_type<AttribMask>::type>(a) & static_cast<std::underlying_type<AttribMask>::type>(b));
}
AttribMask & operator&=(AttribMask & a, const AttribMask & b)
{
a = static_cast<AttribMask>(static_cast<std::underlying_type<AttribMask>::type>(a) & static_cast<std::underlying_type<AttribMask>::type>(b));
return a;
}
AttribMask operator^(const AttribMask & a, const AttribMask & b)
{
return static_cast<AttribMask>(static_cast<std::underlying_type<AttribMask>::type>(a) ^ static_cast<std::underlying_type<AttribMask>::type>(b));
}
AttribMask & operator^=(AttribMask & a, const AttribMask & b)
{
a = static_cast<AttribMask>(static_cast<std::underlying_type<AttribMask>::type>(a) ^ static_cast<std::underlying_type<AttribMask>::type>(b));
return a;
}
} // namespace gl
namespace gl
{
std::ostream & operator<<(std::ostream & stream, const ClearBufferMask & value)
{
stream << bitfieldString<ClearBufferMask>(value);
return stream;
}
} // namespace gl
namespace gl
{
ClearBufferMask operator|(const ClearBufferMask & a, const ClearBufferMask & b)
{
return static_cast<ClearBufferMask>(static_cast<std::underlying_type<ClearBufferMask>::type>(a) | static_cast<std::underlying_type<ClearBufferMask>::type>(b));
}
ClearBufferMask & operator|=(ClearBufferMask & a, const ClearBufferMask & b)
{
a = static_cast<ClearBufferMask>(static_cast<std::underlying_type<ClearBufferMask>::type>(a) | static_cast<std::underlying_type<ClearBufferMask>::type>(b));
return a;
}
ClearBufferMask operator&(const ClearBufferMask & a, const ClearBufferMask & b)
{
return static_cast<ClearBufferMask>(static_cast<std::underlying_type<ClearBufferMask>::type>(a) & static_cast<std::underlying_type<ClearBufferMask>::type>(b));
}
ClearBufferMask & operator&=(ClearBufferMask & a, const ClearBufferMask & b)
{
a = static_cast<ClearBufferMask>(static_cast<std::underlying_type<ClearBufferMask>::type>(a) & static_cast<std::underlying_type<ClearBufferMask>::type>(b));
return a;
}
ClearBufferMask operator^(const ClearBufferMask & a, const ClearBufferMask & b)
{
return static_cast<ClearBufferMask>(static_cast<std::underlying_type<ClearBufferMask>::type>(a) ^ static_cast<std::underlying_type<ClearBufferMask>::type>(b));
}
ClearBufferMask & operator^=(ClearBufferMask & a, const ClearBufferMask & b)
{
a = static_cast<ClearBufferMask>(static_cast<std::underlying_type<ClearBufferMask>::type>(a) ^ static_cast<std::underlying_type<ClearBufferMask>::type>(b));
return a;
}
} // namespace gl
namespace gl
{
std::ostream & operator<<(std::ostream & stream, const ClientAttribMask & value)
{
stream << bitfieldString<ClientAttribMask>(value);
return stream;
}
} // namespace gl
namespace gl
{
ClientAttribMask operator|(const ClientAttribMask & a, const ClientAttribMask & b)
{
return static_cast<ClientAttribMask>(static_cast<std::underlying_type<ClientAttribMask>::type>(a) | static_cast<std::underlying_type<ClientAttribMask>::type>(b));
}
ClientAttribMask & operator|=(ClientAttribMask & a, const ClientAttribMask & b)
{
a = static_cast<ClientAttribMask>(static_cast<std::underlying_type<ClientAttribMask>::type>(a) | static_cast<std::underlying_type<ClientAttribMask>::type>(b));
return a;
}
ClientAttribMask operator&(const ClientAttribMask & a, const ClientAttribMask & b)
{
return static_cast<ClientAttribMask>(static_cast<std::underlying_type<ClientAttribMask>::type>(a) & static_cast<std::underlying_type<ClientAttribMask>::type>(b));
}
ClientAttribMask & operator&=(ClientAttribMask & a, const ClientAttribMask & b)
{
a = static_cast<ClientAttribMask>(static_cast<std::underlying_type<ClientAttribMask>::type>(a) & static_cast<std::underlying_type<ClientAttribMask>::type>(b));
return a;
}
ClientAttribMask operator^(const ClientAttribMask & a, const ClientAttribMask & b)
{
return static_cast<ClientAttribMask>(static_cast<std::underlying_type<ClientAttribMask>::type>(a) ^ static_cast<std::underlying_type<ClientAttribMask>::type>(b));
}
ClientAttribMask & operator^=(ClientAttribMask & a, const ClientAttribMask & b)
{
a = static_cast<ClientAttribMask>(static_cast<std::underlying_type<ClientAttribMask>::type>(a) ^ static_cast<std::underlying_type<ClientAttribMask>::type>(b));
return a;
}
} // namespace gl
namespace gl
{
std::ostream & operator<<(std::ostream & stream, const ContextFlagMask & value)
{
stream << bitfieldString<ContextFlagMask>(value);
return stream;
}
} // namespace gl
namespace gl
{
ContextFlagMask operator|(const ContextFlagMask & a, const ContextFlagMask & b)
{
return static_cast<ContextFlagMask>(static_cast<std::underlying_type<ContextFlagMask>::type>(a) | static_cast<std::underlying_type<ContextFlagMask>::type>(b));
}
ContextFlagMask & operator|=(ContextFlagMask & a, const ContextFlagMask & b)
{
a = static_cast<ContextFlagMask>(static_cast<std::underlying_type<ContextFlagMask>::type>(a) | static_cast<std::underlying_type<ContextFlagMask>::type>(b));
return a;
}
ContextFlagMask operator&(const ContextFlagMask & a, const ContextFlagMask & b)
{
return static_cast<ContextFlagMask>(static_cast<std::underlying_type<ContextFlagMask>::type>(a) & static_cast<std::underlying_type<ContextFlagMask>::type>(b));
}
ContextFlagMask & operator&=(ContextFlagMask & a, const ContextFlagMask & b)
{
a = static_cast<ContextFlagMask>(static_cast<std::underlying_type<ContextFlagMask>::type>(a) & static_cast<std::underlying_type<ContextFlagMask>::type>(b));
return a;
}
ContextFlagMask operator^(const ContextFlagMask & a, const ContextFlagMask & b)
{
return static_cast<ContextFlagMask>(static_cast<std::underlying_type<ContextFlagMask>::type>(a) ^ static_cast<std::underlying_type<ContextFlagMask>::type>(b));
}
ContextFlagMask & operator^=(ContextFlagMask & a, const ContextFlagMask & b)
{
a = static_cast<ContextFlagMask>(static_cast<std::underlying_type<ContextFlagMask>::type>(a) ^ static_cast<std::underlying_type<ContextFlagMask>::type>(b));
return a;
}
} // namespace gl
namespace gl
{
std::ostream & operator<<(std::ostream & stream, const ContextProfileMask & value)
{
stream << bitfieldString<ContextProfileMask>(value);
return stream;
}
} // namespace gl
namespace gl
{
ContextProfileMask operator|(const ContextProfileMask & a, const ContextProfileMask & b)
{
return static_cast<ContextProfileMask>(static_cast<std::underlying_type<ContextProfileMask>::type>(a) | static_cast<std::underlying_type<ContextProfileMask>::type>(b));
}
ContextProfileMask & operator|=(ContextProfileMask & a, const ContextProfileMask & b)
{
a = static_cast<ContextProfileMask>(static_cast<std::underlying_type<ContextProfileMask>::type>(a) | static_cast<std::underlying_type<ContextProfileMask>::type>(b));
return a;
}
ContextProfileMask operator&(const ContextProfileMask & a, const ContextProfileMask & b)
{
return static_cast<ContextProfileMask>(static_cast<std::underlying_type<ContextProfileMask>::type>(a) & static_cast<std::underlying_type<ContextProfileMask>::type>(b));
}
ContextProfileMask & operator&=(ContextProfileMask & a, const ContextProfileMask & b)
{
a = static_cast<ContextProfileMask>(static_cast<std::underlying_type<ContextProfileMask>::type>(a) & static_cast<std::underlying_type<ContextProfileMask>::type>(b));
return a;
}
ContextProfileMask operator^(const ContextProfileMask & a, const ContextProfileMask & b)
{
return static_cast<ContextProfileMask>(static_cast<std::underlying_type<ContextProfileMask>::type>(a) ^ static_cast<std::underlying_type<ContextProfileMask>::type>(b));
}
ContextProfileMask & operator^=(ContextProfileMask & a, const ContextProfileMask & b)
{
a = static_cast<ContextProfileMask>(static_cast<std::underlying_type<ContextProfileMask>::type>(a) ^ static_cast<std::underlying_type<ContextProfileMask>::type>(b));
return a;
}
} // namespace gl
namespace gl
{
std::ostream & operator<<(std::ostream & stream, const FfdMaskSGIX & value)
{
stream << bitfieldString<FfdMaskSGIX>(value);
return stream;
}
} // namespace gl
namespace gl
{
FfdMaskSGIX operator|(const FfdMaskSGIX & a, const FfdMaskSGIX & b)
{
return static_cast<FfdMaskSGIX>(static_cast<std::underlying_type<FfdMaskSGIX>::type>(a) | static_cast<std::underlying_type<FfdMaskSGIX>::type>(b));
}
FfdMaskSGIX & operator|=(FfdMaskSGIX & a, const FfdMaskSGIX & b)
{
a = static_cast<FfdMaskSGIX>(static_cast<std::underlying_type<FfdMaskSGIX>::type>(a) | static_cast<std::underlying_type<FfdMaskSGIX>::type>(b));
return a;
}
FfdMaskSGIX operator&(const FfdMaskSGIX & a, const FfdMaskSGIX & b)
{
return static_cast<FfdMaskSGIX>(static_cast<std::underlying_type<FfdMaskSGIX>::type>(a) & static_cast<std::underlying_type<FfdMaskSGIX>::type>(b));
}
FfdMaskSGIX & operator&=(FfdMaskSGIX & a, const FfdMaskSGIX & b)
{
a = static_cast<FfdMaskSGIX>(static_cast<std::underlying_type<FfdMaskSGIX>::type>(a) & static_cast<std::underlying_type<FfdMaskSGIX>::type>(b));
return a;
}
FfdMaskSGIX operator^(const FfdMaskSGIX & a, const FfdMaskSGIX & b)
{
return static_cast<FfdMaskSGIX>(static_cast<std::underlying_type<FfdMaskSGIX>::type>(a) ^ static_cast<std::underlying_type<FfdMaskSGIX>::type>(b));
}
FfdMaskSGIX & operator^=(FfdMaskSGIX & a, const FfdMaskSGIX & b)
{
a = static_cast<FfdMaskSGIX>(static_cast<std::underlying_type<FfdMaskSGIX>::type>(a) ^ static_cast<std::underlying_type<FfdMaskSGIX>::type>(b));
return a;
}
} // namespace gl
namespace gl
{
std::ostream & operator<<(std::ostream & stream, const FragmentShaderColorModMaskATI & value)
{
stream << bitfieldString<FragmentShaderColorModMaskATI>(value);
return stream;
}
} // namespace gl
namespace gl
{
FragmentShaderColorModMaskATI operator|(const FragmentShaderColorModMaskATI & a, const FragmentShaderColorModMaskATI & b)
{
return static_cast<FragmentShaderColorModMaskATI>(static_cast<std::underlying_type<FragmentShaderColorModMaskATI>::type>(a) | static_cast<std::underlying_type<FragmentShaderColorModMaskATI>::type>(b));
}
FragmentShaderColorModMaskATI & operator|=(FragmentShaderColorModMaskATI & a, const FragmentShaderColorModMaskATI & b)
{
a = static_cast<FragmentShaderColorModMaskATI>(static_cast<std::underlying_type<FragmentShaderColorModMaskATI>::type>(a) | static_cast<std::underlying_type<FragmentShaderColorModMaskATI>::type>(b));
return a;
}
FragmentShaderColorModMaskATI operator&(const FragmentShaderColorModMaskATI & a, const FragmentShaderColorModMaskATI & b)
{
return static_cast<FragmentShaderColorModMaskATI>(static_cast<std::underlying_type<FragmentShaderColorModMaskATI>::type>(a) & static_cast<std::underlying_type<FragmentShaderColorModMaskATI>::type>(b));
}
FragmentShaderColorModMaskATI & operator&=(FragmentShaderColorModMaskATI & a, const FragmentShaderColorModMaskATI & b)
{
a = static_cast<FragmentShaderColorModMaskATI>(static_cast<std::underlying_type<FragmentShaderColorModMaskATI>::type>(a) & static_cast<std::underlying_type<FragmentShaderColorModMaskATI>::type>(b));
return a;
}
FragmentShaderColorModMaskATI operator^(const FragmentShaderColorModMaskATI & a, const FragmentShaderColorModMaskATI & b)
{
return static_cast<FragmentShaderColorModMaskATI>(static_cast<std::underlying_type<FragmentShaderColorModMaskATI>::type>(a) ^ static_cast<std::underlying_type<FragmentShaderColorModMaskATI>::type>(b));
}
FragmentShaderColorModMaskATI & operator^=(FragmentShaderColorModMaskATI & a, const FragmentShaderColorModMaskATI & b)
{
a = static_cast<FragmentShaderColorModMaskATI>(static_cast<std::underlying_type<FragmentShaderColorModMaskATI>::type>(a) ^ static_cast<std::underlying_type<FragmentShaderColorModMaskATI>::type>(b));
return a;
}
} // namespace gl
namespace gl
{
std::ostream & operator<<(std::ostream & stream, const FragmentShaderDestMaskATI & value)
{
stream << bitfieldString<FragmentShaderDestMaskATI>(value);
return stream;
}
} // namespace gl
namespace gl
{
FragmentShaderDestMaskATI operator|(const FragmentShaderDestMaskATI & a, const FragmentShaderDestMaskATI & b)
{
return static_cast<FragmentShaderDestMaskATI>(static_cast<std::underlying_type<FragmentShaderDestMaskATI>::type>(a) | static_cast<std::underlying_type<FragmentShaderDestMaskATI>::type>(b));
}
FragmentShaderDestMaskATI & operator|=(FragmentShaderDestMaskATI & a, const FragmentShaderDestMaskATI & b)
{
a = static_cast<FragmentShaderDestMaskATI>(static_cast<std::underlying_type<FragmentShaderDestMaskATI>::type>(a) | static_cast<std::underlying_type<FragmentShaderDestMaskATI>::type>(b));
return a;
}
FragmentShaderDestMaskATI operator&(const FragmentShaderDestMaskATI & a, const FragmentShaderDestMaskATI & b)
{
return static_cast<FragmentShaderDestMaskATI>(static_cast<std::underlying_type<FragmentShaderDestMaskATI>::type>(a) & static_cast<std::underlying_type<FragmentShaderDestMaskATI>::type>(b));
}
FragmentShaderDestMaskATI & operator&=(FragmentShaderDestMaskATI & a, const FragmentShaderDestMaskATI & b)
{
a = static_cast<FragmentShaderDestMaskATI>(static_cast<std::underlying_type<FragmentShaderDestMaskATI>::type>(a) & static_cast<std::underlying_type<FragmentShaderDestMaskATI>::type>(b));
return a;
}
FragmentShaderDestMaskATI operator^(const FragmentShaderDestMaskATI & a, const FragmentShaderDestMaskATI & b)
{
return static_cast<FragmentShaderDestMaskATI>(static_cast<std::underlying_type<FragmentShaderDestMaskATI>::type>(a) ^ static_cast<std::underlying_type<FragmentShaderDestMaskATI>::type>(b));
}
FragmentShaderDestMaskATI & operator^=(FragmentShaderDestMaskATI & a, const FragmentShaderDestMaskATI & b)
{
a = static_cast<FragmentShaderDestMaskATI>(static_cast<std::underlying_type<FragmentShaderDestMaskATI>::type>(a) ^ static_cast<std::underlying_type<FragmentShaderDestMaskATI>::type>(b));
return a;
}
} // namespace gl
namespace gl
{
std::ostream & operator<<(std::ostream & stream, const FragmentShaderDestModMaskATI & value)
{
stream << bitfieldString<FragmentShaderDestModMaskATI>(value);
return stream;
}
} // namespace gl
namespace gl
{
FragmentShaderDestModMaskATI operator|(const FragmentShaderDestModMaskATI & a, const FragmentShaderDestModMaskATI & b)
{
return static_cast<FragmentShaderDestModMaskATI>(static_cast<std::underlying_type<FragmentShaderDestModMaskATI>::type>(a) | static_cast<std::underlying_type<FragmentShaderDestModMaskATI>::type>(b));
}
FragmentShaderDestModMaskATI & operator|=(FragmentShaderDestModMaskATI & a, const FragmentShaderDestModMaskATI & b)
{
a = static_cast<FragmentShaderDestModMaskATI>(static_cast<std::underlying_type<FragmentShaderDestModMaskATI>::type>(a) | static_cast<std::underlying_type<FragmentShaderDestModMaskATI>::type>(b));
return a;
}
FragmentShaderDestModMaskATI operator&(const FragmentShaderDestModMaskATI & a, const FragmentShaderDestModMaskATI & b)
{
return static_cast<FragmentShaderDestModMaskATI>(static_cast<std::underlying_type<FragmentShaderDestModMaskATI>::type>(a) & static_cast<std::underlying_type<FragmentShaderDestModMaskATI>::type>(b));
}
FragmentShaderDestModMaskATI & operator&=(FragmentShaderDestModMaskATI & a, const FragmentShaderDestModMaskATI & b)
{
a = static_cast<FragmentShaderDestModMaskATI>(static_cast<std::underlying_type<FragmentShaderDestModMaskATI>::type>(a) & static_cast<std::underlying_type<FragmentShaderDestModMaskATI>::type>(b));
return a;
}
FragmentShaderDestModMaskATI operator^(const FragmentShaderDestModMaskATI & a, const FragmentShaderDestModMaskATI & b)
{
return static_cast<FragmentShaderDestModMaskATI>(static_cast<std::underlying_type<FragmentShaderDestModMaskATI>::type>(a) ^ static_cast<std::underlying_type<FragmentShaderDestModMaskATI>::type>(b));
}
FragmentShaderDestModMaskATI & operator^=(FragmentShaderDestModMaskATI & a, const FragmentShaderDestModMaskATI & b)
{
a = static_cast<FragmentShaderDestModMaskATI>(static_cast<std::underlying_type<FragmentShaderDestModMaskATI>::type>(a) ^ static_cast<std::underlying_type<FragmentShaderDestModMaskATI>::type>(b));
return a;
}
} // namespace gl
namespace gl
{
std::ostream & operator<<(std::ostream & stream, const MapBufferUsageMask & value)
{
stream << bitfieldString<MapBufferUsageMask>(value);
return stream;
}
} // namespace gl
namespace gl
{
MapBufferUsageMask operator|(const MapBufferUsageMask & a, const MapBufferUsageMask & b)
{
return static_cast<MapBufferUsageMask>(static_cast<std::underlying_type<MapBufferUsageMask>::type>(a) | static_cast<std::underlying_type<MapBufferUsageMask>::type>(b));
}
MapBufferUsageMask & operator|=(MapBufferUsageMask & a, const MapBufferUsageMask & b)
{
a = static_cast<MapBufferUsageMask>(static_cast<std::underlying_type<MapBufferUsageMask>::type>(a) | static_cast<std::underlying_type<MapBufferUsageMask>::type>(b));
return a;
}
MapBufferUsageMask operator&(const MapBufferUsageMask & a, const MapBufferUsageMask & b)
{
return static_cast<MapBufferUsageMask>(static_cast<std::underlying_type<MapBufferUsageMask>::type>(a) & static_cast<std::underlying_type<MapBufferUsageMask>::type>(b));
}
MapBufferUsageMask & operator&=(MapBufferUsageMask & a, const MapBufferUsageMask & b)
{
a = static_cast<MapBufferUsageMask>(static_cast<std::underlying_type<MapBufferUsageMask>::type>(a) & static_cast<std::underlying_type<MapBufferUsageMask>::type>(b));
return a;
}
MapBufferUsageMask operator^(const MapBufferUsageMask & a, const MapBufferUsageMask & b)
{
return static_cast<MapBufferUsageMask>(static_cast<std::underlying_type<MapBufferUsageMask>::type>(a) ^ static_cast<std::underlying_type<MapBufferUsageMask>::type>(b));
}
MapBufferUsageMask & operator^=(MapBufferUsageMask & a, const MapBufferUsageMask & b)
{
a = static_cast<MapBufferUsageMask>(static_cast<std::underlying_type<MapBufferUsageMask>::type>(a) ^ static_cast<std::underlying_type<MapBufferUsageMask>::type>(b));
return a;
}
} // namespace gl
namespace gl
{
std::ostream & operator<<(std::ostream & stream, const MemoryBarrierMask & value)
{
stream << bitfieldString<MemoryBarrierMask>(value);
return stream;
}
} // namespace gl
namespace gl
{
MemoryBarrierMask operator|(const MemoryBarrierMask & a, const MemoryBarrierMask & b)
{
return static_cast<MemoryBarrierMask>(static_cast<std::underlying_type<MemoryBarrierMask>::type>(a) | static_cast<std::underlying_type<MemoryBarrierMask>::type>(b));
}
MemoryBarrierMask & operator|=(MemoryBarrierMask & a, const MemoryBarrierMask & b)
{
a = static_cast<MemoryBarrierMask>(static_cast<std::underlying_type<MemoryBarrierMask>::type>(a) | static_cast<std::underlying_type<MemoryBarrierMask>::type>(b));
return a;
}
MemoryBarrierMask operator&(const MemoryBarrierMask & a, const MemoryBarrierMask & b)
{
return static_cast<MemoryBarrierMask>(static_cast<std::underlying_type<MemoryBarrierMask>::type>(a) & static_cast<std::underlying_type<MemoryBarrierMask>::type>(b));
}
MemoryBarrierMask & operator&=(MemoryBarrierMask & a, const MemoryBarrierMask & b)
{
a = static_cast<MemoryBarrierMask>(static_cast<std::underlying_type<MemoryBarrierMask>::type>(a) & static_cast<std::underlying_type<MemoryBarrierMask>::type>(b));
return a;
}
MemoryBarrierMask operator^(const MemoryBarrierMask & a, const MemoryBarrierMask & b)
{
return static_cast<MemoryBarrierMask>(static_cast<std::underlying_type<MemoryBarrierMask>::type>(a) ^ static_cast<std::underlying_type<MemoryBarrierMask>::type>(b));
}
MemoryBarrierMask & operator^=(MemoryBarrierMask & a, const MemoryBarrierMask & b)
{
a = static_cast<MemoryBarrierMask>(static_cast<std::underlying_type<MemoryBarrierMask>::type>(a) ^ static_cast<std::underlying_type<MemoryBarrierMask>::type>(b));
return a;
}
} // namespace gl
namespace gl
{
std::ostream & operator<<(std::ostream & stream, const PathRenderingMaskNV & value)
{
stream << bitfieldString<PathRenderingMaskNV>(value);
return stream;
}
} // namespace gl
namespace gl
{
PathRenderingMaskNV operator|(const PathRenderingMaskNV & a, const PathRenderingMaskNV & b)
{
return static_cast<PathRenderingMaskNV>(static_cast<std::underlying_type<PathRenderingMaskNV>::type>(a) | static_cast<std::underlying_type<PathRenderingMaskNV>::type>(b));
}
PathRenderingMaskNV & operator|=(PathRenderingMaskNV & a, const PathRenderingMaskNV & b)
{
a = static_cast<PathRenderingMaskNV>(static_cast<std::underlying_type<PathRenderingMaskNV>::type>(a) | static_cast<std::underlying_type<PathRenderingMaskNV>::type>(b));
return a;
}
PathRenderingMaskNV operator&(const PathRenderingMaskNV & a, const PathRenderingMaskNV & b)
{
return static_cast<PathRenderingMaskNV>(static_cast<std::underlying_type<PathRenderingMaskNV>::type>(a) & static_cast<std::underlying_type<PathRenderingMaskNV>::type>(b));
}
PathRenderingMaskNV & operator&=(PathRenderingMaskNV & a, const PathRenderingMaskNV & b)
{
a = static_cast<PathRenderingMaskNV>(static_cast<std::underlying_type<PathRenderingMaskNV>::type>(a) & static_cast<std::underlying_type<PathRenderingMaskNV>::type>(b));
return a;
}
PathRenderingMaskNV operator^(const PathRenderingMaskNV & a, const PathRenderingMaskNV & b)
{
return static_cast<PathRenderingMaskNV>(static_cast<std::underlying_type<PathRenderingMaskNV>::type>(a) ^ static_cast<std::underlying_type<PathRenderingMaskNV>::type>(b));
}
PathRenderingMaskNV & operator^=(PathRenderingMaskNV & a, const PathRenderingMaskNV & b)
{
a = static_cast<PathRenderingMaskNV>(static_cast<std::underlying_type<PathRenderingMaskNV>::type>(a) ^ static_cast<std::underlying_type<PathRenderingMaskNV>::type>(b));
return a;
}
} // namespace gl
namespace gl
{
std::ostream & operator<<(std::ostream & stream, const PerformanceQueryCapsMaskINTEL & value)
{
stream << bitfieldString<PerformanceQueryCapsMaskINTEL>(value);
return stream;
}
} // namespace gl
namespace gl
{
PerformanceQueryCapsMaskINTEL operator|(const PerformanceQueryCapsMaskINTEL & a, const PerformanceQueryCapsMaskINTEL & b)
{
return static_cast<PerformanceQueryCapsMaskINTEL>(static_cast<std::underlying_type<PerformanceQueryCapsMaskINTEL>::type>(a) | static_cast<std::underlying_type<PerformanceQueryCapsMaskINTEL>::type>(b));
}
PerformanceQueryCapsMaskINTEL & operator|=(PerformanceQueryCapsMaskINTEL & a, const PerformanceQueryCapsMaskINTEL & b)
{
a = static_cast<PerformanceQueryCapsMaskINTEL>(static_cast<std::underlying_type<PerformanceQueryCapsMaskINTEL>::type>(a) | static_cast<std::underlying_type<PerformanceQueryCapsMaskINTEL>::type>(b));
return a;
}
PerformanceQueryCapsMaskINTEL operator&(const PerformanceQueryCapsMaskINTEL & a, const PerformanceQueryCapsMaskINTEL & b)
{
return static_cast<PerformanceQueryCapsMaskINTEL>(static_cast<std::underlying_type<PerformanceQueryCapsMaskINTEL>::type>(a) & static_cast<std::underlying_type<PerformanceQueryCapsMaskINTEL>::type>(b));
}
PerformanceQueryCapsMaskINTEL & operator&=(PerformanceQueryCapsMaskINTEL & a, const PerformanceQueryCapsMaskINTEL & b)
{
a = static_cast<PerformanceQueryCapsMaskINTEL>(static_cast<std::underlying_type<PerformanceQueryCapsMaskINTEL>::type>(a) & static_cast<std::underlying_type<PerformanceQueryCapsMaskINTEL>::type>(b));
return a;
}
PerformanceQueryCapsMaskINTEL operator^(const PerformanceQueryCapsMaskINTEL & a, const PerformanceQueryCapsMaskINTEL & b)
{
return static_cast<PerformanceQueryCapsMaskINTEL>(static_cast<std::underlying_type<PerformanceQueryCapsMaskINTEL>::type>(a) ^ static_cast<std::underlying_type<PerformanceQueryCapsMaskINTEL>::type>(b));
}
PerformanceQueryCapsMaskINTEL & operator^=(PerformanceQueryCapsMaskINTEL & a, const PerformanceQueryCapsMaskINTEL & b)
{
a = static_cast<PerformanceQueryCapsMaskINTEL>(static_cast<std::underlying_type<PerformanceQueryCapsMaskINTEL>::type>(a) ^ static_cast<std::underlying_type<PerformanceQueryCapsMaskINTEL>::type>(b));
return a;
}
} // namespace gl
namespace gl
{
std::ostream & operator<<(std::ostream & stream, const SyncObjectMask & value)
{
stream << bitfieldString<SyncObjectMask>(value);
return stream;
}
} // namespace gl
namespace gl
{
SyncObjectMask operator|(const SyncObjectMask & a, const SyncObjectMask & b)
{
return static_cast<SyncObjectMask>(static_cast<std::underlying_type<SyncObjectMask>::type>(a) | static_cast<std::underlying_type<SyncObjectMask>::type>(b));
}
SyncObjectMask & operator|=(SyncObjectMask & a, const SyncObjectMask & b)
{
a = static_cast<SyncObjectMask>(static_cast<std::underlying_type<SyncObjectMask>::type>(a) | static_cast<std::underlying_type<SyncObjectMask>::type>(b));
return a;
}
SyncObjectMask operator&(const SyncObjectMask & a, const SyncObjectMask & b)
{
return static_cast<SyncObjectMask>(static_cast<std::underlying_type<SyncObjectMask>::type>(a) & static_cast<std::underlying_type<SyncObjectMask>::type>(b));
}
SyncObjectMask & operator&=(SyncObjectMask & a, const SyncObjectMask & b)
{
a = static_cast<SyncObjectMask>(static_cast<std::underlying_type<SyncObjectMask>::type>(a) & static_cast<std::underlying_type<SyncObjectMask>::type>(b));
return a;
}
SyncObjectMask operator^(const SyncObjectMask & a, const SyncObjectMask & b)
{
return static_cast<SyncObjectMask>(static_cast<std::underlying_type<SyncObjectMask>::type>(a) ^ static_cast<std::underlying_type<SyncObjectMask>::type>(b));
}
SyncObjectMask & operator^=(SyncObjectMask & a, const SyncObjectMask & b)
{
a = static_cast<SyncObjectMask>(static_cast<std::underlying_type<SyncObjectMask>::type>(a) ^ static_cast<std::underlying_type<SyncObjectMask>::type>(b));
return a;
}
} // namespace gl
namespace gl
{
std::ostream & operator<<(std::ostream & stream, const TextureStorageMaskAMD & value)
{
stream << bitfieldString<TextureStorageMaskAMD>(value);
return stream;
}
} // namespace gl
namespace gl
{
TextureStorageMaskAMD operator|(const TextureStorageMaskAMD & a, const TextureStorageMaskAMD & b)
{
return static_cast<TextureStorageMaskAMD>(static_cast<std::underlying_type<TextureStorageMaskAMD>::type>(a) | static_cast<std::underlying_type<TextureStorageMaskAMD>::type>(b));
}
TextureStorageMaskAMD & operator|=(TextureStorageMaskAMD & a, const TextureStorageMaskAMD & b)
{
a = static_cast<TextureStorageMaskAMD>(static_cast<std::underlying_type<TextureStorageMaskAMD>::type>(a) | static_cast<std::underlying_type<TextureStorageMaskAMD>::type>(b));
return a;
}
TextureStorageMaskAMD operator&(const TextureStorageMaskAMD & a, const TextureStorageMaskAMD & b)
{
return static_cast<TextureStorageMaskAMD>(static_cast<std::underlying_type<TextureStorageMaskAMD>::type>(a) & static_cast<std::underlying_type<TextureStorageMaskAMD>::type>(b));
}
TextureStorageMaskAMD & operator&=(TextureStorageMaskAMD & a, const TextureStorageMaskAMD & b)
{
a = static_cast<TextureStorageMaskAMD>(static_cast<std::underlying_type<TextureStorageMaskAMD>::type>(a) & static_cast<std::underlying_type<TextureStorageMaskAMD>::type>(b));
return a;
}
TextureStorageMaskAMD operator^(const TextureStorageMaskAMD & a, const TextureStorageMaskAMD & b)
{
return static_cast<TextureStorageMaskAMD>(static_cast<std::underlying_type<TextureStorageMaskAMD>::type>(a) ^ static_cast<std::underlying_type<TextureStorageMaskAMD>::type>(b));
}
TextureStorageMaskAMD & operator^=(TextureStorageMaskAMD & a, const TextureStorageMaskAMD & b)
{
a = static_cast<TextureStorageMaskAMD>(static_cast<std::underlying_type<TextureStorageMaskAMD>::type>(a) ^ static_cast<std::underlying_type<TextureStorageMaskAMD>::type>(b));
return a;
}
} // namespace gl
namespace gl
{
std::ostream & operator<<(std::ostream & stream, const UseProgramStageMask & value)
{
stream << bitfieldString<UseProgramStageMask>(value);
return stream;
}
} // namespace gl
namespace gl
{
UseProgramStageMask operator|(const UseProgramStageMask & a, const UseProgramStageMask & b)
{
return static_cast<UseProgramStageMask>(static_cast<std::underlying_type<UseProgramStageMask>::type>(a) | static_cast<std::underlying_type<UseProgramStageMask>::type>(b));
}
UseProgramStageMask & operator|=(UseProgramStageMask & a, const UseProgramStageMask & b)
{
a = static_cast<UseProgramStageMask>(static_cast<std::underlying_type<UseProgramStageMask>::type>(a) | static_cast<std::underlying_type<UseProgramStageMask>::type>(b));
return a;
}
UseProgramStageMask operator&(const UseProgramStageMask & a, const UseProgramStageMask & b)
{
return static_cast<UseProgramStageMask>(static_cast<std::underlying_type<UseProgramStageMask>::type>(a) & static_cast<std::underlying_type<UseProgramStageMask>::type>(b));
}
UseProgramStageMask & operator&=(UseProgramStageMask & a, const UseProgramStageMask & b)
{
a = static_cast<UseProgramStageMask>(static_cast<std::underlying_type<UseProgramStageMask>::type>(a) & static_cast<std::underlying_type<UseProgramStageMask>::type>(b));
return a;
}
UseProgramStageMask operator^(const UseProgramStageMask & a, const UseProgramStageMask & b)
{
return static_cast<UseProgramStageMask>(static_cast<std::underlying_type<UseProgramStageMask>::type>(a) ^ static_cast<std::underlying_type<UseProgramStageMask>::type>(b));
}
UseProgramStageMask & operator^=(UseProgramStageMask & a, const UseProgramStageMask & b)
{
a = static_cast<UseProgramStageMask>(static_cast<std::underlying_type<UseProgramStageMask>::type>(a) ^ static_cast<std::underlying_type<UseProgramStageMask>::type>(b));
return a;
}
} // namespace gl
namespace gl
{
std::ostream & operator<<(std::ostream & stream, const VertexHintsMaskPGI & value)
{
stream << bitfieldString<VertexHintsMaskPGI>(value);
return stream;
}
} // namespace gl
namespace gl
{
VertexHintsMaskPGI operator|(const VertexHintsMaskPGI & a, const VertexHintsMaskPGI & b)
{
return static_cast<VertexHintsMaskPGI>(static_cast<std::underlying_type<VertexHintsMaskPGI>::type>(a) | static_cast<std::underlying_type<VertexHintsMaskPGI>::type>(b));
}
VertexHintsMaskPGI & operator|=(VertexHintsMaskPGI & a, const VertexHintsMaskPGI & b)
{
a = static_cast<VertexHintsMaskPGI>(static_cast<std::underlying_type<VertexHintsMaskPGI>::type>(a) | static_cast<std::underlying_type<VertexHintsMaskPGI>::type>(b));
return a;
}
VertexHintsMaskPGI operator&(const VertexHintsMaskPGI & a, const VertexHintsMaskPGI & b)
{
return static_cast<VertexHintsMaskPGI>(static_cast<std::underlying_type<VertexHintsMaskPGI>::type>(a) & static_cast<std::underlying_type<VertexHintsMaskPGI>::type>(b));
}
VertexHintsMaskPGI & operator&=(VertexHintsMaskPGI & a, const VertexHintsMaskPGI & b)
{
a = static_cast<VertexHintsMaskPGI>(static_cast<std::underlying_type<VertexHintsMaskPGI>::type>(a) & static_cast<std::underlying_type<VertexHintsMaskPGI>::type>(b));
return a;
}
VertexHintsMaskPGI operator^(const VertexHintsMaskPGI & a, const VertexHintsMaskPGI & b)
{
return static_cast<VertexHintsMaskPGI>(static_cast<std::underlying_type<VertexHintsMaskPGI>::type>(a) ^ static_cast<std::underlying_type<VertexHintsMaskPGI>::type>(b));
}
VertexHintsMaskPGI & operator^=(VertexHintsMaskPGI & a, const VertexHintsMaskPGI & b)
{
a = static_cast<VertexHintsMaskPGI>(static_cast<std::underlying_type<VertexHintsMaskPGI>::type>(a) ^ static_cast<std::underlying_type<VertexHintsMaskPGI>::type>(b));
return a;
}
} // namespace gl
namespace gl
{
std::ostream & operator<<(std::ostream & stream, const UnusedMask & value)
{
stream << bitfieldString<UnusedMask>(value);
return stream;
}
} // namespace gl
namespace gl
{
UnusedMask operator|(const UnusedMask & a, const UnusedMask & b)
{
return static_cast<UnusedMask>(static_cast<std::underlying_type<UnusedMask>::type>(a) | static_cast<std::underlying_type<UnusedMask>::type>(b));
}
UnusedMask & operator|=(UnusedMask & a, const UnusedMask & b)
{
a = static_cast<UnusedMask>(static_cast<std::underlying_type<UnusedMask>::type>(a) | static_cast<std::underlying_type<UnusedMask>::type>(b));
return a;
}
UnusedMask operator&(const UnusedMask & a, const UnusedMask & b)
{
return static_cast<UnusedMask>(static_cast<std::underlying_type<UnusedMask>::type>(a) & static_cast<std::underlying_type<UnusedMask>::type>(b));
}
UnusedMask & operator&=(UnusedMask & a, const UnusedMask & b)
{
a = static_cast<UnusedMask>(static_cast<std::underlying_type<UnusedMask>::type>(a) & static_cast<std::underlying_type<UnusedMask>::type>(b));
return a;
}
UnusedMask operator^(const UnusedMask & a, const UnusedMask & b)
{
return static_cast<UnusedMask>(static_cast<std::underlying_type<UnusedMask>::type>(a) ^ static_cast<std::underlying_type<UnusedMask>::type>(b));
}
UnusedMask & operator^=(UnusedMask & a, const UnusedMask & b)
{
a = static_cast<UnusedMask>(static_cast<std::underlying_type<UnusedMask>::type>(a) ^ static_cast<std::underlying_type<UnusedMask>::type>(b));
return a;
}
} // namespace gl
namespace gl
{
std::ostream & operator<<(std::ostream & stream, const BufferAccessMask & value)
{
stream << bitfieldString<BufferAccessMask>(value);
return stream;
}
} // namespace gl
namespace gl
{
BufferAccessMask operator|(const BufferAccessMask & a, const BufferAccessMask & b)
{
return static_cast<BufferAccessMask>(static_cast<std::underlying_type<BufferAccessMask>::type>(a) | static_cast<std::underlying_type<BufferAccessMask>::type>(b));
}
BufferAccessMask & operator|=(BufferAccessMask & a, const BufferAccessMask & b)
{
a = static_cast<BufferAccessMask>(static_cast<std::underlying_type<BufferAccessMask>::type>(a) | static_cast<std::underlying_type<BufferAccessMask>::type>(b));
return a;
}
BufferAccessMask operator&(const BufferAccessMask & a, const BufferAccessMask & b)
{
return static_cast<BufferAccessMask>(static_cast<std::underlying_type<BufferAccessMask>::type>(a) & static_cast<std::underlying_type<BufferAccessMask>::type>(b));
}
BufferAccessMask & operator&=(BufferAccessMask & a, const BufferAccessMask & b)
{
a = static_cast<BufferAccessMask>(static_cast<std::underlying_type<BufferAccessMask>::type>(a) & static_cast<std::underlying_type<BufferAccessMask>::type>(b));
return a;
}
BufferAccessMask operator^(const BufferAccessMask & a, const BufferAccessMask & b)
{
return static_cast<BufferAccessMask>(static_cast<std::underlying_type<BufferAccessMask>::type>(a) ^ static_cast<std::underlying_type<BufferAccessMask>::type>(b));
}
BufferAccessMask & operator^=(BufferAccessMask & a, const BufferAccessMask & b)
{
a = static_cast<BufferAccessMask>(static_cast<std::underlying_type<BufferAccessMask>::type>(a) ^ static_cast<std::underlying_type<BufferAccessMask>::type>(b));
return a;
}
} // namespace gl
namespace gl
{
std::ostream & operator<<(std::ostream & stream, const BufferStorageMask & value)
{
stream << bitfieldString<BufferStorageMask>(value);
return stream;
}
} // namespace gl
namespace gl
{
BufferStorageMask operator|(const BufferStorageMask & a, const BufferStorageMask & b)
{
return static_cast<BufferStorageMask>(static_cast<std::underlying_type<BufferStorageMask>::type>(a) | static_cast<std::underlying_type<BufferStorageMask>::type>(b));
}
BufferStorageMask & operator|=(BufferStorageMask & a, const BufferStorageMask & b)
{
a = static_cast<BufferStorageMask>(static_cast<std::underlying_type<BufferStorageMask>::type>(a) | static_cast<std::underlying_type<BufferStorageMask>::type>(b));
return a;
}
BufferStorageMask operator&(const BufferStorageMask & a, const BufferStorageMask & b)
{
return static_cast<BufferStorageMask>(static_cast<std::underlying_type<BufferStorageMask>::type>(a) & static_cast<std::underlying_type<BufferStorageMask>::type>(b));
}
BufferStorageMask & operator&=(BufferStorageMask & a, const BufferStorageMask & b)
{
a = static_cast<BufferStorageMask>(static_cast<std::underlying_type<BufferStorageMask>::type>(a) & static_cast<std::underlying_type<BufferStorageMask>::type>(b));
return a;
}
BufferStorageMask operator^(const BufferStorageMask & a, const BufferStorageMask & b)
{
return static_cast<BufferStorageMask>(static_cast<std::underlying_type<BufferStorageMask>::type>(a) ^ static_cast<std::underlying_type<BufferStorageMask>::type>(b));
}
BufferStorageMask & operator^=(BufferStorageMask & a, const BufferStorageMask & b)
{
a = static_cast<BufferStorageMask>(static_cast<std::underlying_type<BufferStorageMask>::type>(a) ^ static_cast<std::underlying_type<BufferStorageMask>::type>(b));
return a;
}
} // namespace gl
namespace gl
{
std::ostream & operator<<(std::ostream & stream, const PathFontStyle & value)
{
stream << bitfieldString<PathFontStyle>(value);
return stream;
}
} // namespace gl
namespace gl
{
PathFontStyle operator|(const PathFontStyle & a, const PathFontStyle & b)
{
return static_cast<PathFontStyle>(static_cast<std::underlying_type<PathFontStyle>::type>(a) | static_cast<std::underlying_type<PathFontStyle>::type>(b));
}
PathFontStyle & operator|=(PathFontStyle & a, const PathFontStyle & b)
{
a = static_cast<PathFontStyle>(static_cast<std::underlying_type<PathFontStyle>::type>(a) | static_cast<std::underlying_type<PathFontStyle>::type>(b));
return a;
}
PathFontStyle operator&(const PathFontStyle & a, const PathFontStyle & b)
{
return static_cast<PathFontStyle>(static_cast<std::underlying_type<PathFontStyle>::type>(a) & static_cast<std::underlying_type<PathFontStyle>::type>(b));
}
PathFontStyle & operator&=(PathFontStyle & a, const PathFontStyle & b)
{
a = static_cast<PathFontStyle>(static_cast<std::underlying_type<PathFontStyle>::type>(a) & static_cast<std::underlying_type<PathFontStyle>::type>(b));
return a;
}
PathFontStyle operator^(const PathFontStyle & a, const PathFontStyle & b)
{
return static_cast<PathFontStyle>(static_cast<std::underlying_type<PathFontStyle>::type>(a) ^ static_cast<std::underlying_type<PathFontStyle>::type>(b));
}
PathFontStyle & operator^=(PathFontStyle & a, const PathFontStyle & b)
{
a = static_cast<PathFontStyle>(static_cast<std::underlying_type<PathFontStyle>::type>(a) ^ static_cast<std::underlying_type<PathFontStyle>::type>(b));
return a;
}
} // namespace gl
| 31.140773
| 205
| 0.756055
|
Arduqq
|
96a86fabfde93c47e61335d95a8801e4a6146f31
| 6,820
|
cpp
|
C++
|
plugins/VCard/testplugin.cpp
|
dusong7/eudora-win
|
850a6619e6b0d5abc770bca8eb5f3b9001b7ccd2
|
[
"BSD-3-Clause-Clear"
] | 10
|
2018-05-23T10:43:48.000Z
|
2021-12-02T17:59:48.000Z
|
plugins/VCard/testplugin.cpp
|
ivanagui2/hermesmail-code
|
34387722d5364163c71b577fc508b567de56c5f6
|
[
"BSD-3-Clause-Clear"
] | 1
|
2019-03-19T03:56:36.000Z
|
2021-05-26T18:36:03.000Z
|
plugins/VCard/testplugin.cpp
|
ivanagui2/hermesmail-code
|
34387722d5364163c71b577fc508b567de56c5f6
|
[
"BSD-3-Clause-Clear"
] | 11
|
2018-05-23T10:43:53.000Z
|
2021-12-27T15:42:58.000Z
|
// testplugin.cpp : Defines the initialization routines for the DLL.
//
#include "stdafx.h"
#include <fstream.h>
#include "testplugin.h"
#include "ems-win.h"
#include "SettingsDialog.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
//
// Note!
//
// If this DLL is dynamically linked against the MFC
// DLLs, any functions exported from this DLL which
// call into MFC must have the AFX_MANAGE_STATE macro
// added at the very beginning of the function.
//
// For example:
//
// extern "C" BOOL PASCAL EXPORT ExportedFunction()
// {
// AFX_MANAGE_STATE(AfxGetStaticModuleState());
// // normal function body here
// }
//
// It is very important that this macro appear in each
// function, prior to any calls into MFC. This means that
// it must appear as the first statement within the
// function, even before any object variable declarations
// as their constructors may generate calls into the MFC
// DLL.
//
// Please see MFC Technical Notes 33 and 58 for additional
// details.
//
/////////////////////////////////////////////////////////////////////////////
// CTestpluginApp
BEGIN_MESSAGE_MAP(CTestpluginApp, CWinApp)
//{{AFX_MSG_MAP(CTestpluginApp)
// NOTE - the ClassWizard will add and remove mapping macros here.
// DO NOT EDIT what you see in these blocks of generated code!
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CTestpluginApp construction
CTestpluginApp::CTestpluginApp()
{
// TODO: add construction code here,
// Place all significant initialization in InitInstance
}
/////////////////////////////////////////////////////////////////////////////
// The one and only CTestpluginApp object
CTestpluginApp theApp;
BOOL CTestpluginApp::InitInstance()
{
m_OurIcon = LoadIcon(IDI_VCARD);
m_MessagePlugin = new CMessagePlug(this);
return TRUE;
}
extern "C" long WINAPI ems_plugin_version(short FAR* version)
{
*version = 4;
return EMSR_OK;
}
// Douglas Adam's Email address is: dna@tdv.com
extern "C" long WINAPI ems_plugin_init(void **globals, short APIVersion, emsMailConfigP MConfig, emsPluginInfoP pinfo)
{
pinfo->numTrans =2;
pinfo->numSpecials =0;
pinfo->desc = new char[strlen(_T("VCard Access Plugin v1.0")) + 1];
strcpy(pinfo->desc, _T("VCard Access Plugin v1.0"));
pinfo->id = 30;
CTestpluginApp* TheApp;
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
TheApp = (CTestpluginApp*)AfxGetApp();
pinfo->icon = &TheApp->m_OurIcon;
}
TheApp->m_EudoraFuncs.EnumAB = (*(emsEnumAddressBooks )MConfig->callBacks->EMSEnumAddressBooksCB);
TheApp->m_EudoraFuncs.AddNNToAB = (*(emsAddABEntry )MConfig->callBacks->EMSEnumAddressBooksCB);
TheApp->m_INIFilename = new char[strlen(MConfig->configDir) + strlen(_T("\\EudVCard.ini")) +1];
strcpy(TheApp->m_INIFilename, MConfig->configDir);
strcat(TheApp->m_INIFilename, _T("\\EudVCard.ini"));
if (AfxIsValidAddress( (void*)TheApp->m_EudoraFuncs.EnumAB, 1, FALSE) != 1 ||
AfxIsValidAddress( (void*)TheApp->m_EudoraFuncs.AddNNToAB, 1, FALSE) != 1 )
return EMSR_UNKNOWN_FAIL;
return EMSR_OK;
}
extern "C" long WINAPI ems_translator_info(void *globals, emsTranslatorP tinfo)
{
CTestpluginApp* TheApp;
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
TheApp = (CTestpluginApp*)AfxGetApp();
tinfo->icon = &TheApp->m_OurIcon; //&TheApp->m_MessagePlugin->m_Icon;
}
if (tinfo->id == 1)
{
tinfo->type = EMST_TEXT_FORMAT;
tinfo->flags = EMSF_ON_ARRIVAL | EMSF_ON_DISPLAY;
tinfo->desc = new char[strlen(_T("VCard Processing Plugin"))+1];
strcpy(tinfo->desc, _T("VCard Processing Plugin"));
}
else if (tinfo->id == 2)
{
tinfo->type = EMST_LANGUAGE;
tinfo->flags = EMSF_ON_REQUEST;
tinfo->desc = new char[strlen(_T("Import This VCard"))+1];
strcpy(tinfo->desc, _T("Import This VCard"));
}
else
return EMSR_UNKNOWN_FAIL;
return EMSR_OK;
}
extern "C" long WINAPI ems_can_translate(void *globals, emsTranslatorP tinfo, emsDataFileP inTransData, emsResultStatusP result)
{
if (inTransData->context == EMSF_ON_ARRIVAL)
{
if (strcmp(inTransData->info->type, _T("text")) == 0)
{
if ( (stricmp(inTransData->info->subType, _T("x-vcard")) == 0) ||
(stricmp(inTransData->info->subType, _T("vcard")) == 0) ) // In case it gets made a standard subtype...
{
return EMSR_NOT_NOW;
}
else
return EMSR_CANT_TRANS;
}
else
return EMSR_CANT_TRANS;
result->error = NULL;
result->code = 0;
}
else if (inTransData->context == EMSF_ON_DISPLAY)
{
return EMSR_NOW;
}
else if (inTransData->context == EMSF_ON_REQUEST)
{
int a=2;
return EMSR_NOW;
}
else
return EMSR_UNKNOWN_FAIL;
}
VCEntry *ScanVCard(char *Filename)
{
ifstream * foo = new ifstream(Filename);
char *newstring = new char[512];
bool done = false;
while (!done)
{
foo->getline(newstring, 99);
if (newstring[0] == 0)
done = true;
else
{
sscanf
}
}
// FILE *foo = fopen( Filename, _T("r"));
// char *newstring = new char[100];
// int a = fscanf( foo, "%s\\r\\n", newstring);
return NULL;
}
extern "C" long WINAPI ems_translate_file(void *globals, emsTranslatorP tinfo, emsDataFileP inTransData, emsProgress progress, emsDataFileP outfile, emsResultStatusP result)
{
if (inTransData->context == EMSF_ON_DISPLAY && tinfo->id == 1)
{
if (strcmp(inTransData->info->type, _T("text")) == 0)
{
if ( (stricmp(inTransData->info->subType, _T("x-vcard")) == 0) ||
(stricmp(inTransData->info->subType, _T("vcard")) == 0) ) // In case it gets made a standard subtype...
{
VCEntry *Entries = ScanVCard(inTransData->fileName);
if (!Entries)
return EMSR_NO_ENTRY;
}
else
return EMSR_CANT_TRANS;
}
else
return EMSR_CANT_TRANS;
result->error = NULL;
result->code = 0;
return EMSR_OK;
}
else if (inTransData->context == EMSF_ON_REQUEST && tinfo->id == 2)
{
return EMSR_OK;
}
else
return EMSR_CANT_TRANS;
}
extern "C" long WINAPI ems_plugin_config(void *globals, emsMailConfigP MailConfig)
{
CWnd* pSettingsPanel = CWnd::GetForegroundWindow( );
HGLOBAL TheDialog;
HMODULE hModule = GetModuleHandle(NULL);
CTestpluginApp* TheApp;
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
TheApp = (CTestpluginApp*)AfxGetApp();
}
if (!TheApp->m_ShowingSettingsPanel)
{
hModule = GetModuleHandle(_T("testplugin"));
HRSRC blah = FindResource( hModule, (char *)IDD_SETTINGS, RT_DIALOG);
TheDialog = LoadResource( hModule, blah);
TheApp->m_Settings = new CSettingsDialog();
TheApp->m_Settings->m_MainApp = TheApp;
TheApp->m_Settings->CreateIndirect( TheDialog, pSettingsPanel);
TheApp->m_Settings->ShowWindow(SW_SHOW);
TheApp->m_ShowingSettingsPanel = true;
}
else
{
TheApp->m_Settings->SetFocus();
}
return EMSR_OK;
}
| 24.532374
| 173
| 0.677713
|
dusong7
|
96ae558bb0dadc072b180f5da1f28f9a865f25f2
| 729
|
cpp
|
C++
|
chapter1/account_balance.cpp
|
hsgrewal/learning-Cpp
|
c4da6d13a658b2254ab858ddf6beffe75a9fc1ba
|
[
"MIT"
] | null | null | null |
chapter1/account_balance.cpp
|
hsgrewal/learning-Cpp
|
c4da6d13a658b2254ab858ddf6beffe75a9fc1ba
|
[
"MIT"
] | null | null | null |
chapter1/account_balance.cpp
|
hsgrewal/learning-Cpp
|
c4da6d13a658b2254ab858ddf6beffe75a9fc1ba
|
[
"MIT"
] | null | null | null |
// This program calculates the current balance in a bank account
#include <iostream>
using namespace std;
int main()
{
double balance, deposits, withdrawals;
// Get starting balance
cout << "Enter starting balance: $";
cin >> balance;
// Get total dollar amount of deposits
cout << "Enter total dollar amount of deposits: $";
cin >> deposits;
// Get total dollar amount of withdrawls
cout << "Enter total dollar amount of withdrawls: $";
cin >> withdrawals;
// Calculate current balance
balance += deposits;
balance -= withdrawals;
// Display current balance of bank account
cout << "Current balance of the bank account is $" << balance << ".\n";
return 0;
}
| 25.137931
| 75
| 0.654321
|
hsgrewal
|
96b02d6f15005d09c138dbdc838ddce0b22196ad
| 2,367
|
cpp
|
C++
|
v6/src/platform/opengl/opengl-vertex-array.cpp
|
MemoryChips/v6-game-engine
|
b7a6c09dbce34621f4c7045ed2b2319d2ce3413d
|
[
"MIT"
] | null | null | null |
v6/src/platform/opengl/opengl-vertex-array.cpp
|
MemoryChips/v6-game-engine
|
b7a6c09dbce34621f4c7045ed2b2319d2ce3413d
|
[
"MIT"
] | null | null | null |
v6/src/platform/opengl/opengl-vertex-array.cpp
|
MemoryChips/v6-game-engine
|
b7a6c09dbce34621f4c7045ed2b2319d2ce3413d
|
[
"MIT"
] | null | null | null |
#include "opengl-vertex-array.h"
#include "instrumentor.h"
#include "log.h"
#include <glad/glad.h>
namespace v6 {
static GLenum ShaderDataTypeToOpenGLBaseType(ShaderDataType type) {
switch (type) {
case ShaderDataType::Float:
return GL_FLOAT;
case ShaderDataType::Float2:
return GL_FLOAT;
case ShaderDataType::Float3:
return GL_FLOAT;
case ShaderDataType::Float4:
return GL_FLOAT;
case ShaderDataType::Mat3:
return GL_FLOAT;
case ShaderDataType::Mat4:
return GL_FLOAT;
case ShaderDataType::Int:
return GL_INT;
case ShaderDataType::Int2:
return GL_INT;
case ShaderDataType::Int3:
return GL_INT;
case ShaderDataType::Int4:
return GL_INT;
case ShaderDataType::Bool:
return GL_BOOL;
case ShaderDataType::None:
LOG_ERROR("Shader type of None being used for opengl data type");
return GL_INVALID_ENUM;
}
V6_CORE_ASSERT(false, "Unknown ShaderDataType!");
return 0;
}
OpenGLVertexArray::OpenGLVertexArray() {
V6_PROFILE_FUNCTION();
glCreateVertexArrays(1, &m_RendererID);
}
OpenGLVertexArray::~OpenGLVertexArray() {
V6_PROFILE_FUNCTION();
glDeleteVertexArrays(1, &m_RendererID);
}
void OpenGLVertexArray::Bind() const {
V6_PROFILE_FUNCTION();
glBindVertexArray(m_RendererID);
}
void OpenGLVertexArray::Unbind() const {
V6_PROFILE_FUNCTION();
glBindVertexArray(0);
}
void OpenGLVertexArray::AddVertexBuffer(const Ref<VertexBuffer> &vertexBuffer) {
V6_PROFILE_FUNCTION();
V6_CORE_ASSERT(vertexBuffer->GetLayout().GetElements().size(),
"Vertex Buffer has no layout!");
glBindVertexArray(m_RendererID);
vertexBuffer->Bind();
const auto &layout = vertexBuffer->GetLayout();
for (const auto &element : layout) {
glEnableVertexAttribArray(vertexBufferIndex);
glVertexAttribPointer(vertexBufferIndex, element.GetComponentCount(),
ShaderDataTypeToOpenGLBaseType(element.type),
element.normalized ? GL_TRUE : GL_FALSE,
layout.GetStride(), (const void *)element.offset);
vertexBufferIndex++;
}
m_VertexBuffers.push_back(vertexBuffer);
}
void OpenGLVertexArray::SetIndexBuffer(const Ref<IndexBuffer> &indexBuffer) {
V6_PROFILE_FUNCTION();
glBindVertexArray(m_RendererID);
indexBuffer->Bind();
m_IndexBuffer = indexBuffer;
}
} // namespace v6
| 26.010989
| 80
| 0.719054
|
MemoryChips
|
96b090b016fa19c863d5e0a8a916bf09941f34e0
| 15,411
|
cpp
|
C++
|
src/x/events/e_vio.cpp
|
jpl-x/x_events
|
e9d0b6e578f045eb7b57acadf75b77d8a323f51d
|
[
"Apache-2.0"
] | null | null | null |
src/x/events/e_vio.cpp
|
jpl-x/x_events
|
e9d0b6e578f045eb7b57acadf75b77d8a323f51d
|
[
"Apache-2.0"
] | null | null | null |
src/x/events/e_vio.cpp
|
jpl-x/x_events
|
e9d0b6e578f045eb7b57acadf75b77d8a323f51d
|
[
"Apache-2.0"
] | null | null | null |
/*
* Copyright 2020 California Institute of Technology (“Caltech”)
*
* 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 <x/events/e_vio.h>
#include <x/vio/tools.h>
#include <x/vision/types.h>
#include <iostream>
// if Boost was compiled with BOOST_NO_EXCEPTIONS defined, it expects a user
// defined trow_exception function, so define a dummy here, if this is the case
#include <exception>
#include <utility>
using namespace x;
namespace boost
{
#ifdef BOOST_NO_EXCEPTIONS
void throw_exception(std::exception const & e) {}; // user defined
#endif
}
EVIO::EVIO(XVioPerformanceLoggerPtr xvio_perf_logger)
: ekf_(std::make_shared<Ekf>(vio_updater_))
, xvio_perf_logger_(std::move(xvio_perf_logger))
{
// Initialize with invalid last range measurement
// todo: Replace -1 with -min_delay
x::RangeMeasurement no_measurement_range;
no_measurement_range.timestamp = -1;
last_range_measurement_ = no_measurement_range;
// Initialize with invalid last sun angle measurement
// todo: Replace -1 with -min_delay
x::SunAngleMeasurement no_measurement_sun;
no_measurement_sun.timestamp = -1;
last_angle_measurement_ = no_measurement_sun;
}
bool EVIO::isInitialized() const {
return ekf_->getInitStatus() == InitStatus::kInitialized;
}
void EVIO::setUp(const x::Params& params) {
const x::Camera cam(params.cam_fx, params.cam_fy, params.cam_cx, params.cam_cy, params.cam_distortion_model,
params.cam_distortion_parameters, params.img_width, params.img_height);
const x::Tracker tracker(cam, params.fast_detection_delta, params.non_max_supp, params.block_half_length,
params.margin, params.n_feat_min, params.outlier_method, params.outlier_param1,
params.outlier_param2);
// Compute minimum MSCKF baseline in normal plane (square-pixel assumption)
msckf_baseline_n_ = params.msckf_baseline / (params.img_width * params.cam_fx);
// Set up tracker and track manager
const TrackManager track_manager(cam, msckf_baseline_n_, xvio_perf_logger_);
params_ = params;
camera_ = cam;
tracker_ = tracker;
track_manager_ = track_manager;
// Set up VIO state manager
const int n_poses_state = params.n_poses_max;
const int n_features_state = params.n_slam_features_max;
const StateManager state_manager(n_poses_state, n_features_state);
state_manager_ = state_manager;
// Gravity
Vector3 g = params_.g;
// IMU noise
x::ImuNoise imu_noise;
imu_noise.n_w = params.n_w;
imu_noise.n_bw = params.n_bw;
imu_noise.n_a = params.n_a;
imu_noise.n_ba = params.n_ba;
// Updater setup
x::MatchList matches; // unused empty match list since it's image callback
TiledImage img;
vio_updater_ = VioUpdater(tracker_,
state_manager_,
track_manager_,
params_.sigma_img,
params_.sigma_range,
params_.rho_0,
params_.sigma_rho_0,
params_.min_track_length,
params_.iekf_iter);
// EKF setup
const State default_state = State(n_poses_state, n_features_state);
ekf_->set(vio_updater_,
g,
imu_noise,
params_.state_buffer_size,
default_state,
params.a_m_max,
params_.delta_seq_imu,
params_.state_buffer_time_margin);
x::EventAccumulator event_accumulator(params_.n_events_max, params_.event_accumulation_method, params_.img_width, params_.img_height, ekf_);
event_accumulator_ = event_accumulator;
}
void EVIO::setLastRangeMeasurement(x::RangeMeasurement range_measurement) {
last_range_measurement_ = range_measurement;
}
void EVIO::setLastSunAngleMeasurement(x::SunAngleMeasurement angle_measurement) {
last_angle_measurement_ = angle_measurement;
}
State EVIO::processImageMeasurement(double timestamp,
const unsigned int seq,
TiledImage& match_img,
TiledImage& feature_img) {
// Time correction
const double timestamp_corrected = timestamp + params_.time_offset;
// Pass measurement data to updater
MatchList empty_list; // TODO(jeff) get rid of image callback and process match
// list from a separate tracker module.
VioMeasurement measurement(timestamp_corrected,
seq,
empty_list,
match_img,
last_range_measurement_,
last_angle_measurement_);
vio_updater_.setMeasurement(measurement);
// Process update measurement with xEKF
State updated_state = ekf_->processUpdateMeasurement();
// Set state timestamp to original image timestamp for ID purposes in output.
// We don't do that if that state is invalid, since the timestamp also carries
// the invalid signature.
if(updated_state.getTime() != kInvalid)
updated_state.setTime(timestamp);
// Populate GUI image outputs
match_img = vio_updater_.getMatchImage();
feature_img = vio_updater_.getFeatureImage();
return updated_state;
}
State EVIO::processMatchesMeasurement(double timestamp,
const unsigned int seq,
const std::vector<double>& match_vector,
TiledImage& match_img,
TiledImage& feature_img) {
// Time correction
const double timestamp_corrected = timestamp + params_.time_offset;
// Import matches (except for first measurement, since the previous needs to
// enter the sliding window)
x::MatchList matches;
if (vio_updater_.state_manager_.poseSize())
matches = importMatches(match_vector, seq, match_img);
// Compute 2D image coordinates of the LRF impact point on the ground
x::Feature lrf_img_pt;
lrf_img_pt.setXDist(320.5);
lrf_img_pt.setYDist(240.5);
camera_.undistortFeature(lrf_img_pt);
last_range_measurement_.img_pt = lrf_img_pt;
last_range_measurement_.img_pt_n = camera_.normalize(lrf_img_pt);
// Pass measurement data to updater
VioMeasurement measurement(timestamp_corrected,
seq,
matches,
feature_img,
last_range_measurement_,
last_angle_measurement_);
vio_updater_.setMeasurement(measurement);
// Process update measurement with xEKF
State updated_state = ekf_->processUpdateMeasurement();
// Set state timestamp to original image timestamp for ID purposes in output.
// We don't do that if that state is invalid, since the timestamp carries the
// invalid signature.
if(updated_state.getTime() != kInvalid)
updated_state.setTime(timestamp);
// Populate GUI image outputs
match_img = match_img;
feature_img = vio_updater_.getFeatureImage();
return updated_state;
}
State EVIO::processEventsMeasurement(const x::EventArray::ConstPtr &events_ptr,
TiledImage& match_img, TiledImage& feature_img)
{
#ifdef DEBUG
std::cout << events_ptr->events.size() << " events at timestamp "
<< events_ptr->events.front().ts << " received in e-xVIO class."
<< std::endl;
#endif
bool trigger_update = event_accumulator_.storeEventsInBuffer(events_ptr, params_);
if (!trigger_update) return State();
double image_time;
bool event_image_ready = false;
// Initialize plain image to plot features on
cv::Mat event_img(params_.img_height,
params_.img_width,
CV_32FC1,
cv::Scalar(0.0));
if(params_.event_accumulation_method == 0)
{
event_image_ready = event_accumulator_.renderTimeSurface(event_img, image_time, params_);
} else {
event_image_ready = event_accumulator_.processEventBuffer(event_img, image_time, params_, camera_);
}
if (!event_image_ready) return State();
event_img.convertTo(event_img, CV_8U, 255.0/params_.event_norm_factor);
/* Image callback functions. */
TiledImage tiled_event_img = TiledImage(event_img, image_time, events_ptr->seq,
params_.n_tiles_h,
params_.n_tiles_w,
params_.max_feat_per_tile);
// Time correction
const double timestamp_corrected = image_time + params_.time_offset;
// Pass measurement data to updater
MatchList empty_list; // TODO(jeff): get rid of image callback and process match
// list from a separate tracker module.
VioMeasurement measurement(timestamp_corrected,
events_ptr->seq,
empty_list,
tiled_event_img,
last_range_measurement_,
last_angle_measurement_);
vio_updater_.setMeasurement(measurement);
// Process update measurement with xEKF
State updated_state = ekf_->processUpdateMeasurement();
// Set state timestamp to original image timestamp for ID purposes in output.
// We don't do that if that state is invalid, since the timestamp also carries
// the invalid signature.
if(updated_state.getTime() != kInvalid)
updated_state.setTime(image_time);
match_img = vio_updater_.getMatchImage();
feature_img = vio_updater_.getFeatureImage();
// cvtColor(event_img, event_img, cv::COLOR_GRAY2RGB);
// feature_img = event_img;
return updated_state;
}
/** Calls the state manager to compute the cartesian coordinates of the SLAM features.
*/
std::vector<Eigen::Vector3d>
EVIO::computeSLAMCartesianFeaturesForState(
const State& state) {
return vio_updater_.state_manager_.computeSLAMCartesianFeaturesForState(state);
}
void EVIO::initAtTime(double now) {
ekf_->lock();
vio_updater_.track_manager_.clear();
vio_updater_.state_manager_.clear();
// Initial IMU measurement (specific force, velocity)
Vector3 a_m, w_m;
a_m = -params_.g;//a_m << 0.0, 0.0, 9.81;
w_m << 0.0, 0.0, 0.0;
// Initial time cannot be 0, which may happen when using simulated Clock time
// before the first message has been received.
const double timestamp =
now > 0.0 ? now : std::numeric_limits<double>::epsilon();
//////////////////////////////// xEKF INIT ///////////////////////////////////
// Initial vision state estimates and uncertainties are all zero
const size_t n_poses_state = params_.n_poses_max;
const size_t n_features_state = params_.n_slam_features_max;
const Matrix p_array = Matrix::Zero(n_poses_state * 3, 1);
const Matrix q_array = Matrix::Zero(n_poses_state * 4, 1);
const Matrix f_array = Matrix::Zero(n_features_state * 3, 1);
const Eigen::VectorXd sigma_p_array = Eigen::VectorXd::Zero(n_poses_state * 3);
const Eigen::VectorXd sigma_q_array = Eigen::VectorXd::Zero(n_poses_state * 3);
const Eigen::VectorXd sigma_f_array = Eigen::VectorXd::Zero(n_features_state * 3);
// Construct initial covariance matrix
const size_t n_err = kSizeCoreErr + n_poses_state * 6 + n_features_state * 3;
Eigen::VectorXd sigma_diag(n_err);
sigma_diag << params_.sigma_dp,
params_.sigma_dv,
params_.sigma_dtheta * M_PI / 180.0,
params_.sigma_dbw * M_PI / 180.0,
params_.sigma_dba,
sigma_p_array, sigma_q_array, sigma_f_array;
const Eigen::VectorXd cov_diag = sigma_diag.array() * sigma_diag.array();
const Matrix cov = cov_diag.asDiagonal();
// Construct initial state
const unsigned int dummy_seq = 0;
State init_state(timestamp,
dummy_seq,
params_.p,
params_.v,
params_.q,
params_.b_w,
params_.b_a,
p_array,
q_array,
f_array,
cov,
params_.q_ic,
params_.p_ic,
w_m,
a_m);
// Try to initialize the filter with initial state input
try {
ekf_->initializeFromState(init_state);
} catch (std::runtime_error& e) {
std::cerr << "bad input: " << e.what() << std::endl;
} catch (init_bfr_mismatch) {
std::cerr << "init_bfr_mismatch: the size of dynamic arrays in the "
"initialization state match must match the size allocated in "
"the buffered states." << std::endl;
}
ekf_->unlock();
}
/** \brief Gets 3D coordinates of MSCKF inliers and outliers.
*
* These are computed in the Measurement class instance.
*/
void EVIO::getMsckfFeatures(x::Vector3dArray& inliers,
x::Vector3dArray& outliers) {
inliers = vio_updater_.getMsckfInliers();
outliers = vio_updater_.getMsckfOutliers();
}
State EVIO::processImu(const double timestamp,
const unsigned int seq,
const Vector3& w_m,
const Vector3& a_m) {
return ekf_->processImu(timestamp, seq, w_m, a_m);
}
x::MatchList EVIO::importMatches(const std::vector<double>& match_vector,
const unsigned int seq,
x::TiledImage& img_plot) const {
// 9N match vector structure:
// 0: time_prev
// 1: x_dist_prev
// 2: y_dist_prev
// 3: time_curr
// 4: x_dist_curr
// 5: x_dist_curr
// 6,7,8: 3D coordinate of feature
// Number of matches in the input vector
assert(match_vector.size() % 9 == 0);
const unsigned int n_matches = match_vector.size() / 9;
// Declare new lists
x::MatchList matches(n_matches);
// Store the match vector into a match list
for (unsigned int i = 0; i < n_matches; ++i)
{
// Undistortion
const double x_dist_prev = match_vector[9 * i + 1];
const double y_dist_prev = match_vector[9 * i + 2];
const double x_dist_curr = match_vector[9 * i + 4];
const double y_dist_curr = match_vector[9 * i + 5];
// Features and match initializations
x::Feature previous_feature(match_vector[9 * i] + params_.time_offset, seq - 1, 0.0, 0.0, x_dist_prev,
y_dist_prev);
camera_.undistortFeature(previous_feature);
x::Feature current_feature(match_vector[9 * i + 3] + params_.time_offset, seq, 0.0, 0.0, x_dist_curr,
y_dist_curr);
camera_.undistortFeature(current_feature);
x::Match current_match;
current_match.previous = previous_feature;
current_match.current = current_feature;
// Add match to list
matches[i] = current_match;
}
// Publish matches to GUI
x::Tracker::plotMatches(matches, img_plot);
return matches;
}
| 35.756381
| 142
| 0.654597
|
jpl-x
|
96b3ee5b65bc8a6ebd0dc484669d8c56007717de
| 3,417
|
cpp
|
C++
|
raygame/Actor.cpp
|
jasPerSh122902/GameFrameworkCPP
|
8b9cea376b8f084e869aa2cf68b68e7b8931af6b
|
[
"MIT"
] | null | null | null |
raygame/Actor.cpp
|
jasPerSh122902/GameFrameworkCPP
|
8b9cea376b8f084e869aa2cf68b68e7b8931af6b
|
[
"MIT"
] | null | null | null |
raygame/Actor.cpp
|
jasPerSh122902/GameFrameworkCPP
|
8b9cea376b8f084e869aa2cf68b68e7b8931af6b
|
[
"MIT"
] | null | null | null |
#include "Actor.h"
#include "Transform2D.h"
#include <string.h>
#include "Collider.h"
#include "Componet.h"
Actor::Actor()
{
m_transform = new Transform2D(this);
}
Actor::~Actor()
{
delete m_transform;
}
Actor::Actor(float x, float y, const char* name = "Actor")
{
//Initialze default values
m_transform = new Transform2D(this);
m_transform->setLocalPosition({ x,y });
m_name = name;
}
void Actor::start()
{
m_started = true;
}
Componet* Actor::addComponent(Componet* actor_componet)
{
//returns null if this componet has an owner already
Actor* owner = actor_componet->getOwner();
if (owner)
return nullptr;
actor_componet->assignOwner(this);
//Create a new array with a size one greater than our old array
Componet** tempArray = new Componet * [m_componetsCount + 1];
//Copy the values form the old array to the new array
for (int i = 0; i < m_componetsCount; i++)
{
tempArray[i] = m_componet[i];
}
//Set the last value in the new array
tempArray[m_componetsCount] = actor_componet;
if (m_componetsCount > 1)
delete[] m_componet;
else if (m_componetsCount == 1)
delete m_componet;
m_componet = tempArray;
//increments the counter
m_componetsCount++;
//returns the pointer
return actor_componet;
}
bool Actor::removeComponent(Componet* componet)
{
if (!componet)
return false;
bool componentRemoved = false;
//Create a new array with a size one less than our old array
Componet** newArray = new Componet * [m_componetsCount - 1];
//Create variable to access tempArray index
int j = 0;
//Copy values from the old array to the new array
for (int i = 0; i < m_componetsCount; i++)
{
if (componet != m_componet[i])
{
newArray[j] = m_componet[i];
j++;
}
else
componentRemoved = true;
}
//checks to see if The removed is true...
if (componentRemoved)
{
delete[] m_componet;
//...sets the old array to the new array
m_componet = newArray;
m_componetsCount--;//decrements the counter.
//deletes the componet
delete(componet);
}
delete[] newArray;
//Return whether or not the removal was successful
return componentRemoved;
}
void Actor::update(float deltaTime)
{
for (int i = 0; i < m_componetsCount; i++)
{
if (m_componet[i]->getStarted())
m_componet[i]->start();
m_componet[i]->update(deltaTime);
}
}
void Actor::draw()
{
for (int i = 0; i < m_componetsCount; i++)
m_componet[i]->draw();
}
void Actor::end()
{
m_started = false;
for (int i = 0; i < m_componetsCount; i++)
m_componet[i]->end();
}
void Actor::onCollision(Actor* other)
{
for (int i = 0; i < m_componetsCount; i++)
m_componet[i]->oncollison(other);
}
void Actor::onDestroy()
{
for (int i = 0; i < m_componetsCount; i++)
m_componet[i]->onDistroy();
//Removes this actor from its parent if it has one
if (getTransform()->getParent())
getTransform()->getParent()->removeChild(getTransform());
}
bool Actor::checkForCollision(Actor* other)
{
//Call check collision if there is a collider attached to this actor
if (m_collider)
return m_collider->checkCollision(other);
return false;
}
| 23.40411
| 72
| 0.622769
|
jasPerSh122902
|
96cd19a8d7cad6b6b4f1bcd6756d00fd152119fe
| 1,133
|
cpp
|
C++
|
draw-case-study.cpp
|
zhaolu996/KPCS
|
ccefc9139e76f885539c61aaa8f7db598936553e
|
[
"MIT"
] | null | null | null |
draw-case-study.cpp
|
zhaolu996/KPCS
|
ccefc9139e76f885539c61aaa8f7db598936553e
|
[
"MIT"
] | null | null | null |
draw-case-study.cpp
|
zhaolu996/KPCS
|
ccefc9139e76f885539c61aaa8f7db598936553e
|
[
"MIT"
] | null | null | null |
#include "Snap.h"
// Demo drawing of graph with nodes labeled with text
void DrawGVizDemo() {
PUNGraph UNGraph1;
const char * flnm = "../plot/casestudy/data/case1/case_edges.txt";
const char * DIRNAME = "../plot/casestudy";
UNGraph1 = TSnap::LoadEdgeList<PUNGraph>(flnm,0, 1);
TStrV LNames; // gvlDot, gvlNeato, gvlTwopi, gvlCirco
LNames.Add("Dot");
LNames.Add("Neato");
LNames.Add("Twopi");
LNames.Add("Circo");
TStrV Exts;
Exts.Add("ps");
Exts.Add("gif");
Exts.Add("png");
for (int i = 0; i < LNames.Len(); i++) {
for (int e = 0; e < Exts.Len(); e++) {
// Baseline file is already created (use as benchmark)
TStr FNameDemo = TStr::Fmt("%s/demo_%s.%s", DIRNAME,
LNames[i].CStr(), Exts[e].CStr());
// Remove test graph if it already exists
remove(FNameDemo.CStr());
// Draw new graph
TSnap::DrawGViz(UNGraph1, TGVizLayout(i), FNameDemo, LNames[i], true);
printf("Drawing graph '%s'\n", FNameDemo.CStr());
}
}
}
int main(int argc, char* argv[]) {
DrawGVizDemo();
}
| 25.75
| 78
| 0.574581
|
zhaolu996
|
96cecc1a7809e2db5cfc97f8d794a064fb6c752f
| 5,567
|
cpp
|
C++
|
src/common/Channel.cpp
|
nforro/chatterino2
|
e9868fdd84bd5799b9689fc9d7ee4abed792ecec
|
[
"MIT"
] | null | null | null |
src/common/Channel.cpp
|
nforro/chatterino2
|
e9868fdd84bd5799b9689fc9d7ee4abed792ecec
|
[
"MIT"
] | null | null | null |
src/common/Channel.cpp
|
nforro/chatterino2
|
e9868fdd84bd5799b9689fc9d7ee4abed792ecec
|
[
"MIT"
] | null | null | null |
#include "common/Channel.hpp"
#include "Application.hpp"
#include "debug/Log.hpp"
#include "messages/Message.hpp"
#include "singletons/EmoteManager.hpp"
#include "singletons/IrcManager.hpp"
#include "singletons/LoggingManager.hpp"
#include "singletons/WindowManager.hpp"
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonValue>
#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QNetworkRequest>
namespace chatterino {
Channel::Channel(const QString &_name, Type _type)
: name(_name)
, completionModel(this->name)
, type(_type)
{
this->clearCompletionModelTimer = new QTimer;
QObject::connect(this->clearCompletionModelTimer, &QTimer::timeout, [this]() {
this->completionModel.ClearExpiredStrings(); //
});
this->clearCompletionModelTimer->start(60 * 1000);
}
Channel::~Channel()
{
this->destroyed.invoke();
this->clearCompletionModelTimer->stop();
this->clearCompletionModelTimer->deleteLater();
}
Channel::Type Channel::getType() const
{
return this->type;
}
bool Channel::isTwitchChannel() const
{
return this->type >= Twitch && this->type < TwitchEnd;
}
bool Channel::isEmpty() const
{
return this->name.isEmpty();
}
chatterino::LimitedQueueSnapshot<chatterino::MessagePtr> Channel::getMessageSnapshot()
{
return this->messages.getSnapshot();
}
void Channel::addMessage(MessagePtr message)
{
auto app = getApp();
MessagePtr deleted;
const QString &username = message->loginName;
if (!username.isEmpty()) {
// TODO: Add recent chatters display name. This should maybe be a setting
this->addRecentChatter(message);
}
// FOURTF: change this when adding more providers
if (this->isTwitchChannel()) {
app->logging->addMessage(this->name, message);
}
if (this->messages.pushBack(message, deleted)) {
this->messageRemovedFromStart.invoke(deleted);
}
this->messageAppended.invoke(message);
}
void Channel::addOrReplaceTimeout(chatterino::MessagePtr message)
{
LimitedQueueSnapshot<MessagePtr> snapshot = this->getMessageSnapshot();
int snapshotLength = snapshot.getLength();
int end = std::max(0, snapshotLength - 20);
bool addMessage = true;
QTime minimumTime = QTime::currentTime().addSecs(-5);
for (int i = snapshotLength - 1; i >= end; --i) {
auto &s = snapshot[i];
qDebug() << s->parseTime << minimumTime;
if (s->parseTime < minimumTime) {
break;
}
if (s->flags.HasFlag(Message::Untimeout) && s->timeoutUser == message->timeoutUser) {
break;
}
if (s->flags.HasFlag(Message::Timeout) && s->timeoutUser == message->timeoutUser) {
if (message->flags.HasFlag(Message::PubSub) && !s->flags.HasFlag(Message::PubSub)) {
this->replaceMessage(s, message);
addMessage = false;
break;
}
if (!message->flags.HasFlag(Message::PubSub) && s->flags.HasFlag(Message::PubSub)) {
addMessage = false;
break;
}
int count = s->count + 1;
chatterino::MessagePtr replacement(Message::createSystemMessage(
message->searchText + QString(" (") + QString::number(count) + " times)"));
replacement->timeoutUser = message->timeoutUser;
replacement->count = count;
replacement->flags = message->flags;
this->replaceMessage(s, replacement);
return;
}
}
// disable the messages from the user
for (int i = 0; i < snapshotLength; i++) {
auto &s = snapshot[i];
if ((s->flags & (Message::Timeout | Message::Untimeout)) == 0 &&
s->loginName == message->timeoutUser) {
s->flags.EnableFlag(Message::Disabled);
}
}
if (addMessage) {
this->addMessage(message);
}
// XXX: Might need the following line
// WindowManager::getInstance().repaintVisibleChatWidgets(this);
}
void Channel::disableAllMessages()
{
LimitedQueueSnapshot<MessagePtr> snapshot = this->getMessageSnapshot();
int snapshotLength = snapshot.getLength();
for (int i = 0; i < snapshotLength; i++) {
auto &s = snapshot[i];
if (s->flags & Message::System || s->flags & Message::Timeout) {
continue;
}
s->flags.EnableFlag(Message::Disabled);
}
}
void Channel::addMessagesAtStart(std::vector<chatterino::MessagePtr> &_messages)
{
std::vector<chatterino::MessagePtr> addedMessages = this->messages.pushFront(_messages);
if (addedMessages.size() != 0) {
this->messagesAddedAtStart.invoke(addedMessages);
}
}
void Channel::replaceMessage(chatterino::MessagePtr message, chatterino::MessagePtr replacement)
{
int index = this->messages.replaceItem(message, replacement);
if (index >= 0) {
this->messageReplaced.invoke((size_t)index, replacement);
}
}
void Channel::addRecentChatter(const std::shared_ptr<chatterino::Message> &message)
{
// Do nothing by default
}
bool Channel::canSendMessage() const
{
return false;
}
void Channel::sendMessage(const QString &message)
{
}
bool Channel::isMod() const
{
return false;
}
bool Channel::isBroadcaster() const
{
return false;
}
std::shared_ptr<Channel> Channel::getEmpty()
{
static std::shared_ptr<Channel> channel(new Channel("", None));
return channel;
}
void Channel::onConnected()
{
}
} // namespace chatterino
| 25.536697
| 96
| 0.643614
|
nforro
|
96d03aa05a8661f24f81ccdddab5fd93d82b318b
| 270
|
cpp
|
C++
|
code/min_edge_cover.cpp
|
raynoldng/icpc_notebook
|
aef047bb441998411a1f89078634c93a6fa5b5c1
|
[
"MIT"
] | 1
|
2021-08-10T15:08:35.000Z
|
2021-08-10T15:08:35.000Z
|
code/min_edge_cover.cpp
|
raynoldng/icpc_notebook
|
aef047bb441998411a1f89078634c93a6fa5b5c1
|
[
"MIT"
] | null | null | null |
code/min_edge_cover.cpp
|
raynoldng/icpc_notebook
|
aef047bb441998411a1f89078634c93a6fa5b5c1
|
[
"MIT"
] | 1
|
2020-10-29T01:38:59.000Z
|
2020-10-29T01:38:59.000Z
|
/*
If a minimum edge cover contains C edges, and a maximum
matching contains M edges, then C + M = jV j. To obtain
the edge cover, start with a maximum matching, and then,
for every vertex not matched, just select some edge incident
upon it and add it to the edge set
*/
| 38.571429
| 60
| 0.751852
|
raynoldng
|
96d305be44fe905043816a241ef23cf504b27ce7
| 1,237
|
cpp
|
C++
|
dataset/test/modification/1480_all/38/transformation_1.cpp
|
Karina5005/Plagiarism
|
ce11f72ba21a754ca84a27e5f26a31a19d6cb6fb
|
[
"MIT"
] | 3
|
2022-02-15T00:29:39.000Z
|
2022-03-15T08:36:44.000Z
|
dataset/test/modification/1480_all/38/transformation_1.cpp
|
Kira5005-code/Plagiarism
|
ce11f72ba21a754ca84a27e5f26a31a19d6cb6fb
|
[
"MIT"
] | null | null | null |
dataset/test/modification/1480_all/38/transformation_1.cpp
|
Kira5005-code/Plagiarism
|
ce11f72ba21a754ca84a27e5f26a31a19d6cb6fb
|
[
"MIT"
] | null | null | null |
#include <iomanip>
#include <iostream>
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int main();
int main() {
int z = 1;
cin >> z;
if (5 > 3) cout << "new code";for ( ; z--; )
/* 'for' inside */
{
std::string lo_ym;
cin >> lo_ym;
int j = lo_ym.length();
{
int hc_q = 0;
if (5 > 3) cout << "new code";for ( ; hc_q < j; )
/* 'for' inside */
{
/* 'if' begin */
if (!(lo_ym[hc_q] == 'a')) /* 'if' inside */
{
lo_ym[hc_q] = 'a';
} else {
lo_ym[hc_q] = 'b';
}
hc_q = hc_q + 2;
}}
{
int rul_bd = 1;
if (5 > 3) cout << "new code";for ( ; rul_bd < j; )
/* 'for' inside */
{
/* 'if' begin */
if (!(lo_ym[rul_bd] == 'z')) /* 'if' inside */
{
lo_ym[rul_bd] = 'z';
} else {
lo_ym[rul_bd] = 'y';
}
rul_bd = rul_bd + 2;
}}
cout << lo_ym << endl;
}
return 0;
}
| 23.339623
| 64
| 0.322555
|
Karina5005
|
96dce5d5758a81c4b34e55ac794b9264a0eafaeb
| 2,039
|
cpp
|
C++
|
addons/xmlgui/framework/Controls.cpp
|
eraly5555/Hub
|
e890f841f16988c642cf6390fa31c3c5ae82773d
|
[
"MIT"
] | 2
|
2015-12-01T16:33:43.000Z
|
2016-04-07T03:43:32.000Z
|
addons/xmlgui/framework/Controls.cpp
|
eraly5555/Hub
|
e890f841f16988c642cf6390fa31c3c5ae82773d
|
[
"MIT"
] | null | null | null |
addons/xmlgui/framework/Controls.cpp
|
eraly5555/Hub
|
e890f841f16988c642cf6390fa31c3c5ae82773d
|
[
"MIT"
] | 3
|
2020-02-17T14:36:18.000Z
|
2021-08-09T12:02:59.000Z
|
/**
* Controls.cpp
* emptyExample
*
* Created by Marek Bereza on 20/06/2011.
*
*/
#include "Instantiator.h"
#include "Gui.h"
#include "Slider.h"
#include "PushButton.h"
#include "Menu.h"
#include "MenuItem.h"
#include "MenuBar.h"
#include "ColorPicker.h"
#include "Knob.h"
#include "Toggle.h"
#include "Contour.h"
#include "VU.h"
#include "Meter.h"
#include "Keyboard.h"
#include "Panner.h"
#include "SegmentedControl.h"
#include "Title.h"
#include "Slider2D.h"
#include "Drawable.h"
#include "List.h"
#include "DoubleField.h"
#include "TextField.h"
#include "Text.h"
#include "FloatField.h"
#include "FPSCounter.h"
#include "IntField.h"
#include "Grid.h"
#include "FileField.h"
#include "Pane.h"
#define REGISTER_CONTROL(A, B) addControlConstructor(ControlInstantiator<A>, B);
void xmlgui::Instantiator::registerControls() {
REGISTER_CONTROL(Control, "control");
REGISTER_CONTROL(Container, "container");
REGISTER_CONTROL(Pane, "pane");
REGISTER_CONTROL(PushButton, "pushbutton");
REGISTER_CONTROL(Slider, "slider");
// REGISTER_CONTROL(ColorPicker, "colorpicker");
REGISTER_CONTROL(Knob, "knob");
REGISTER_CONTROL(Toggle, "toggle");
REGISTER_CONTROL(Contour, "contour");
REGISTER_CONTROL(Keyboard, "keyboard");
REGISTER_CONTROL(VU, "vu");
REGISTER_CONTROL(Meter, "meter");
REGISTER_CONTROL(Panner, "panner");
REGISTER_CONTROL(SegmentedControl, "segmented");
REGISTER_CONTROL(Title, "title");
REGISTER_CONTROL(Slider2D, "slider2d");
REGISTER_CONTROL(Drawable, "drawable");
REGISTER_CONTROL(List, "list");
REGISTER_CONTROL(DoubleField, "doublefield");
REGISTER_CONTROL(TextField, "textfield");
REGISTER_CONTROL(Text, "text");
REGISTER_CONTROL(FloatField, "floatfield");
REGISTER_CONTROL(FPSCounter, "fps");
REGISTER_CONTROL(IntField, "intfield");
REGISTER_CONTROL(FileField, "file");
REGISTER_CONTROL(Grid, "grid");
// menu stuff for gui editor
REGISTER_CONTROL(Menu, "menu");
REGISTER_CONTROL(MenuBar, "menubar");
REGISTER_CONTROL(MenuItem, "menuitem");
}
| 24.27381
| 80
| 0.727808
|
eraly5555
|
96e6de186e1b24147bb6d7321a571e05b57fee2c
| 2,665
|
cpp
|
C++
|
test/Plugins/plugin_load_test_10.cpp
|
opensocsysarch/CoreGen
|
204e03b8b4a0d23cf8f955ed99af5de7fa07569e
|
[
"Apache-2.0"
] | 6
|
2019-08-15T23:11:49.000Z
|
2021-12-17T18:28:37.000Z
|
test/Plugins/plugin_load_test_10.cpp
|
rkabrick/CoreGen
|
e456763d6b669370b9a17d92552516ebc2887ddf
|
[
"Apache-2.0"
] | 245
|
2018-10-23T12:52:09.000Z
|
2022-03-31T20:16:04.000Z
|
test/Plugins/plugin_load_test_10.cpp
|
rkabrick/CoreGen
|
e456763d6b669370b9a17d92552516ebc2887ddf
|
[
"Apache-2.0"
] | 5
|
2019-10-15T15:01:04.000Z
|
2022-02-18T17:09:12.000Z
|
//
// _PLUGIN_LOAD_TEST_10_CPP
//
// Copyright (C) 2017-2020 Tactical Computing Laboratories, LLC
// All Rights Reserved
// contact@tactcomplabs.com
//
// See LICENSE in the top level directory for licensing details
//
//
#include <iostream>
#include "CoreGen/CoreGenBackend/CoreGenBackend.h"
std::string PROJNAME = "TEST10";
std::string PROJROOT = "./";
std::string ARCHROOT = "./";
int main( int argc, char **argv ){
CoreGenBackend *CG = new CoreGenBackend(PROJNAME,
PROJROOT,
ARCHROOT);
if( !CG ){
std::cout << "ERROR : FAILED TO CREATE COREGEN OBJECT" << std::endl;
return -10;
}
std::string PLUGIN = std::string(argv[1]);
if( !CG->LoadPlugin(PLUGIN) ){
std::cout << "ERROR : FAILED TO LOAD PLUGIN : " << PLUGIN << std::endl;
delete CG;
return -1;
}
CoreGenPlugin *P = CG->GetPlugin("SamplePlugin");
if( !P ){
std::cout << "ERROR : FAILED TO RETRIEVE PLUGIN POINTER : " << PLUGIN << std::endl;
delete CG;
return -1;
}
std::string PName = P->GetPluginName();
if( PName.length() == 0 ){
std::cout << "ERROR : FAILED TO RETRIEVE PLUGIN NAME : " << PLUGIN << std::endl;
delete CG;
return -1;
}
unsigned NF = P->GetNumFeatures();
if( NF == 0 ){
std::cout << "ERROR : FAILED TO RETRIEVE THE NUMBER OF FEATURES : " << PLUGIN << std::endl;
delete CG;
return -1;
}
for( unsigned i=0; i<NF; i++ ){
std::string FName = P->GetFeatureName(i);
std::cout << "Found feature : " << FName << std::endl;
CGFeatureType FType = P->GetFeatureType(i);
std::string FTypeName;
switch( FType ){
case CGFUnsigned:
FTypeName = "Unsigned";
break;
case CGFUin32t:
FTypeName = "Uint32t";
break;
case CGFInt32t:
FTypeName = "Int32t";
break;
case CGFUint64t:
FTypeName = "Uint64t";
break;
case CGFInt64t:
FTypeName = "Int64t";
break;
case CGFFloat:
FTypeName = "Float";
break;
case CGFDouble:
FTypeName = "Double";
break;
case CGFString:
FTypeName = "String";
break;
case CGFBool:
FTypeName = "Bool";
break;
case CGFUnknown:
default:
FTypeName = "UNKNOWN";
break;
}
std::cout << "Found feature type : " << FTypeName << std::endl;
}
std::cout << "PLUGIN NAME = " << PName << " WITH " << NF << " FEATURES" << std::endl;
if( !CG->ReleasePlugin("SamplePlugin") ){
std::cout << "ERROR : FAILED TO RELEASE PLUGIN : " << PLUGIN << std::endl;
delete CG;
return -1;
}
delete CG;
return 0;
}
| 24.227273
| 95
| 0.56773
|
opensocsysarch
|
96e6e2d5e63f992afb364eea28ec0b4ccf053e30
| 192
|
hpp
|
C++
|
pomdog/input/button_state.hpp
|
mogemimi/pomdog
|
6dc6244d018f70d42e61c6118535cf94a9ee0618
|
[
"MIT"
] | 163
|
2015-03-16T08:42:32.000Z
|
2022-01-11T21:40:22.000Z
|
pomdog/input/button_state.hpp
|
mogemimi/pomdog
|
6dc6244d018f70d42e61c6118535cf94a9ee0618
|
[
"MIT"
] | 17
|
2015-04-12T20:57:50.000Z
|
2020-10-10T10:51:45.000Z
|
pomdog/input/button_state.hpp
|
mogemimi/pomdog
|
6dc6244d018f70d42e61c6118535cf94a9ee0618
|
[
"MIT"
] | 21
|
2015-04-12T20:45:11.000Z
|
2022-01-14T20:50:16.000Z
|
// Copyright mogemimi. Distributed under the MIT license.
#pragma once
namespace pomdog {
enum class ButtonState : bool {
Released = false,
Pressed = true
};
} // namespace pomdog
| 14.769231
| 57
| 0.697917
|
mogemimi
|
96e94936c2a0c303711b74230f3d6d8a9e225ce6
| 4,737
|
cpp
|
C++
|
blastermaster/Grid/Grid.cpp
|
ndmnhat/blastermaster
|
8937b738fe6d1667d0456c495a05b76106cd29ec
|
[
"MIT"
] | 1
|
2022-02-21T08:11:52.000Z
|
2022-02-21T08:11:52.000Z
|
blastermaster/Grid/Grid.cpp
|
ndmnhat/blastermaster
|
8937b738fe6d1667d0456c495a05b76106cd29ec
|
[
"MIT"
] | null | null | null |
blastermaster/Grid/Grid.cpp
|
ndmnhat/blastermaster
|
8937b738fe6d1667d0456c495a05b76106cd29ec
|
[
"MIT"
] | 1
|
2022-02-27T07:55:15.000Z
|
2022-02-27T07:55:15.000Z
|
#include "Grid.h"
#include "..\Utils\Utils.h"
CGrid* CGrid::_instance = NULL;
void CGrid::addObject(LPGAMEOBJECT object)
{
if (object == NULL)
return;
float left, right, top, bottom;
object->GetBoundingBox(left, top, right, bottom);
int firstRow = top / GRID_CELL_HEIGHT;
int lastRow = bottom / GRID_CELL_HEIGHT;
int firstColumn = left / GRID_CELL_WIDTH;
int lastColumn = right / GRID_CELL_WIDTH;
for (int i = lastRow; i <= firstRow; ++i)
{
for (int j = firstColumn; j <= lastColumn; ++j)
{
//DebugOut(L"%d , %d , %d\n", object->type, i, j);
Cell[i][j].push_back(object);
}
}
}
void CGrid::removeObject(LPGAMEOBJECT object)
{
float left, right, top, bottom;
object->GetBoundingBox(left, top, right, bottom);
int firstRow = top / GRID_CELL_HEIGHT + 1;
int lastRow = bottom / GRID_CELL_HEIGHT - 1;
int firstColumn = left / GRID_CELL_WIDTH - 1;
int lastColumn = right / GRID_CELL_WIDTH + 1;
for (int CellRowIndex = lastRow; CellRowIndex <= firstRow; ++CellRowIndex)
{
for (int CellColumnIndex = firstColumn; CellColumnIndex <= lastColumn; ++CellColumnIndex)
{
for (int i = 0; i < Cell[CellRowIndex][CellColumnIndex].size(); ++i)
{
Cell[CellRowIndex][CellColumnIndex].erase(std::remove(Cell[CellRowIndex][CellColumnIndex].begin(), Cell[CellRowIndex][CellColumnIndex].end(), object), Cell[CellRowIndex][CellColumnIndex].end());
}
}
}
}
void CGrid::safeRemoveObject(LPGAMEOBJECT object)
{
int firstRow = 0;
int lastRow = Cell.size()-1;
int firstColumn = 0;
int lastColumn;
for (int CellRowIndex = firstRow; CellRowIndex <= lastRow; ++CellRowIndex)
{
lastColumn = Cell[CellRowIndex].size()-1;
for (int CellColumnIndex = firstColumn; CellColumnIndex <= lastColumn; ++CellColumnIndex)
{
for (int i = 0; i < Cell[CellRowIndex][CellColumnIndex].size(); ++i)
{
Cell[CellRowIndex][CellColumnIndex].erase(std::remove(Cell[CellRowIndex][CellColumnIndex].begin(), Cell[CellRowIndex][CellColumnIndex].end(), object), Cell[CellRowIndex][CellColumnIndex].end());
}
}
}
}
void CGrid::updateObjects(vector<LPGAMEOBJECT> objects)
{
for (int i = 0; i < objects.size(); ++i)
{
removeObject(objects[i]);
if (objects[i]->isDestroyed == true)
{
SAFE_DELETE(objects[i]);
return;
}
addObject(objects[i]);
}
}
void CGrid::clearGrid()
{
_instance = NULL;
}
vector<LPGAMEOBJECT> CGrid::getAllObjects(int MapWidth, int MapHeight)
{
vector<LPGAMEOBJECT> objects;
int firstRow = 0;
int lastRow = MapHeight / GRID_CELL_HEIGHT;
int firstColumn = 0;
int lastColumn = MapWidth / GRID_CELL_WIDTH;
for (int CellRowIndex = firstRow; CellRowIndex <= lastRow; ++CellRowIndex)
{
//lastColumn = Cell[CellRowIndex].size();
for (int CellColumnIndex = firstColumn; CellColumnIndex <= lastColumn; ++CellColumnIndex)
{
for (int i = 0; i < Cell[CellRowIndex][CellColumnIndex].size(); ++i)
{
if(Cell[CellRowIndex][CellColumnIndex].at(i)!=NULL)
objects.push_back(Cell[CellRowIndex][CellColumnIndex].at(i));
}
}
}
return objects;
}
vector<LPGAMEOBJECT> CGrid::ObjectsToRender()
{
CCamera* cam = CCamera::GetInstance();
int firstRow = cam->GetPosition().y / GRID_CELL_HEIGHT;
int firstColumn = cam->GetPosition().x / GRID_CELL_WIDTH;
int lastRow = firstRow - ceil((double)WINDOW_HEIGHT / GRID_CELL_HEIGHT);
int lastColumn = firstColumn + ceil((double)WINDOW_WIDTH / GRID_CELL_WIDTH);
vector<LPGAMEOBJECT> objects;
WallImageInCam.clear();
for (int i = lastRow; i <= firstRow; ++i)
{
for (int j = firstColumn; j <= lastColumn; ++j)
{
for (auto& GameObject : Cell[i][j])
{
if (GameObject->isInCam == false && GameObject->isEnabled)
{
if (GameObject->type == TYPE_WALLIMAGE)
WallImageInCam.push_back((CWallImage*)GameObject);
objects.push_back(GameObject);
GameObject->isInCam = true;
}
}
}
}
for (auto& GameObject : objects)
{
GameObject->isInCam = false;
}
return objects;
}
vector<LPGAMEOBJECT> CGrid::ObjectsInCam(CCamera* cam)
{
int firstRow = cam->GetPosition().y / GRID_CELL_HEIGHT;
int firstColumn = cam->GetPosition().x / GRID_CELL_WIDTH;
int lastRow = firstRow - ceil((double)WINDOW_HEIGHT / GRID_CELL_HEIGHT);
int lastColumn = firstColumn + ceil((double)WINDOW_WIDTH / GRID_CELL_WIDTH);
vector<LPGAMEOBJECT> objects;
WallImageInCam.clear();
for (int i = lastRow; i <= firstRow; ++i)
{
for (int j = firstColumn; j <= lastColumn; ++j)
{
for (auto& GameObject : Cell[i][j])
{
if (GameObject->isInCam == false && GameObject->isEnabled && GameObject->isFreezing == false)
{
objects.push_back(GameObject);
GameObject->isInCam = true;
}
}
}
}
for (auto& GameObject : objects)
{
GameObject->isInCam = false;
}
return objects;
}
| 27.540698
| 198
| 0.686299
|
ndmnhat
|
96fce5bbcfc1243d9921683899fbc3590ca34b77
| 9,362
|
cpp
|
C++
|
src/connectionhandler.cpp
|
smr-llc/wooten-server
|
b6b347d3b7547e26883838f71e28726154ea6809
|
[
"MIT"
] | null | null | null |
src/connectionhandler.cpp
|
smr-llc/wooten-server
|
b6b347d3b7547e26883838f71e28726154ea6809
|
[
"MIT"
] | null | null | null |
src/connectionhandler.cpp
|
smr-llc/wooten-server
|
b6b347d3b7547e26883838f71e28726154ea6809
|
[
"MIT"
] | 1
|
2021-03-29T20:19:06.000Z
|
2021-03-29T20:19:06.000Z
|
#include "connectionhandler.h"
#include <unistd.h>
#include <string.h>
#include <iostream>
#include <random>
#include <poll.h>
#include <sys/time.h>
#include <signal.h>
ConnectionHandler::ConnectionHandler(int sock, struct sockaddr_in addr, std::shared_ptr<PacketHandler> pktHandler) :
m_sock(sock),
m_addr(addr),
m_terminate(false),
m_done(false),
m_hasActivity(false),
m_pktHandler(pktHandler)
{
static const char letters[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
std::random_device dev;
std::mt19937 rng(dev());
std::uniform_int_distribution<std::mt19937::result_type> dist(0, sizeof(letters) - 2);
for (int i = 0; i < 6; i++)
{
this->m_connId.push_back(letters[dist(rng)]);
}
memset((char *) &m_udpAddr, 0, sizeof(struct sockaddr_in));
m_udpAddr.sin_family = AF_INET;
m_udpAddr.sin_addr.s_addr = htonl(INADDR_ANY);
memset(&m_joinedData, 0, sizeof(JoinedData));
}
ConnectionHandler::~ConnectionHandler() {
m_terminate = true;
if (m_thread.get()) {
m_thread->join();
}
std::cout << "Closing connection with " << addrStr() << "...\n";
close(m_sock);
}
ConnectionHandler* ConnectionHandler::create(int sock, struct sockaddr_in addr, std::shared_ptr<PacketHandler> pktHandler, in_port_t udpPort) {
auto handler = new ConnectionHandler(sock, addr, pktHandler);
handler->m_udpAddr.sin_port = udpPort;
memset((char *) &addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = udpPort;
addr.sin_addr.s_addr = htonl(INADDR_ANY);
if (handler->initializeNatMapping() != 0) {
delete handler;
return nullptr;
}
handler->m_thread = std::make_unique<std::thread>(&ConnectionHandler::handlerLoop, handler);
return handler;
}
std::string ConnectionHandler::connId() const
{
return m_connId;
}
struct sockaddr_in ConnectionHandler::addr() const {
return m_addr;
}
std::string ConnectionHandler::addrStr() const {
return inet_ntoa(m_addr.sin_addr);
}
bool ConnectionHandler::done() const {
return m_done;
}
void ConnectionHandler::setSid(std::string sid) {
m_sid = sid;
}
void ConnectionHandler::setSession(std::string sid, const JoinData &joinData) {
setSid(sid);
m_joinedData.privatePort = joinData.privatePort;
m_joinedData.privateAddr = joinData.privateAddr;
memcpy(m_joinedData.connId, m_connId.c_str(), 6);
}
const JoinedData* ConnectionHandler::joinedData() const {
return &m_joinedData;
}
int ConnectionHandler::initializeNatMapping() {
int sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (sock == -1)
{
std::cerr << "ERROR: Failed to create UDP receive socket for NAT mapping, got errno " << errno << "\n";
return -1;
}
struct timeval tv;
tv.tv_sec = 2;
tv.tv_usec = 0;
if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) < 0) {
std::cerr << "ERROR: Failed to set timeout for UDP receive socket for NAT mapping\n";
close(sock);
return -1;
}
int enableReuse = 1;
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &enableReuse, sizeof(int)) < 0) {
std::cerr << "FATAL: failed to set port re-use on UDP socket! errno: " << errno << "\n";
close(sock);
return -1;
}
if( bind(sock, (struct sockaddr*)&m_udpAddr, sizeof(struct sockaddr_in) ) == -1)
{
std::cerr << "ERROR: Failed to bind UDP receive socket for NAT mapping, got errno " << errno << "\n";
close(sock);
return -1;
}
ConnPkt pkt;
struct sockaddr_in peerAddr;
socklen_t peerAddrLen = sizeof(peerAddr);
while (true) {
int nBytes = recvfrom(sock, &pkt, sizeof(ConnPkt), 0, (struct sockaddr *) &peerAddr, &peerAddrLen);
if (nBytes < 0) {
std::cerr << "ERROR: Failed to read client UDP message, got errno " << errno << "\n";
close(sock);
return -1;
}
if (nBytes != sizeof(ConnPkt)) {
std::cerr << "WARN: Invalid client UDP message size " << nBytes << "\n";
continue;
}
if (peerAddr.sin_addr.s_addr != m_addr.sin_addr.s_addr) {
std::cerr << "WARN: Client UDP message from unexpected IP " << inet_ntoa(peerAddr.sin_addr) << " (waiting for " << addrStr() << ")\n";
continue;
}
std::cout << "INFO: Public address and port established for connection: " << addrStr() << ":" << ntohs(peerAddr.sin_port) << "\n";
m_joinedData.publicPort = peerAddr.sin_port;
m_joinedData.publicAddr = m_addr.sin_addr;
close(sock);
return sendNatHolepunch();
}
}
void ConnectionHandler::handlerLoop() {
ConnPkt pkt;
std::string sAddr = addrStr();
sigset_t sigMask;
sigemptyset(&sigMask);
sigaddset(&sigMask, SIGINT);
sigaddset(&sigMask, SIGQUIT);
sigaddset(&sigMask, SIGHUP);
struct pollfd pSock;
pSock.fd = m_sock;
pSock.events = POLLIN;
int timeOutSeconds = 20;
struct timespec timeOut;
timeOut.tv_sec = timeOutSeconds;
timeOut.tv_nsec = 0;
while (!m_terminate) {
m_hasActivity = false;
int pollResult = ppoll(&pSock, 1, &timeOut, &sigMask);
if (pollResult == -1) {
std::cerr << "Polling client " << sAddr << " failed, errno: " << errno;
break;
}
else if (pollResult == 0) {
if (m_hasActivity) {
continue;
}
std::cout << "Client " << sAddr << " timed out (no activity for " << timeOutSeconds << " seconds)\n";
break;
}
if (pSock.revents & POLLHUP) {
std::cout << "Client " << sAddr << " closed connection...\n";
break;
}
else if (pSock.revents & POLLERR) {
std::cerr << "FATAL: Unexpected POLLERR from client " << sAddr << "\n";
break;
}
else if (pSock.revents & POLLNVAL) {
std::cerr << "FATAL: Unexpected POLLNVAL from client " << sAddr << "\n";
break;
}
memset(&pkt, 0, sizeof(ConnPkt));
int nBytes = read(m_sock, (char*)&pkt, sizeof(ConnPkt));
if (nBytes < 1)
{
std::cerr << "Unexpected error reading from connection with " << sAddr << ". errno " << errno << "\n";
break;
}
if (nBytes != sizeof(ConnPkt)) {
continue;
}
if (pkt.magic != MAGIC) {
continue;
}
bool close = false;
auto result = m_pktHandler->handle(this, pkt, close);
if (close) {
break;
}
if (result.get()) {
m_pktHandler = result;
}
}
m_done = true;
}
int ConnectionHandler::sendErr(uint8_t type) {
m_hasActivity = true;
std::lock_guard<std::mutex> guard(m_writeMutex);
ConnPkt errPkt;
memset(&errPkt, 0, sizeof(ConnPkt));
errPkt.magic = MAGIC;
errPkt.type = type;
int res = send(m_sock, &errPkt, sizeof(ConnPkt), 0);
if (res == -1) {
std::cerr << "Failed to send err " << type << " to " << addrStr() << ", got errno " << errno << "\n";
}
return res;
}
int ConnectionHandler::sendResponse(uint8_t type, const void *data, size_t dataLen) {
m_hasActivity = true;
std::lock_guard<std::mutex> guard(m_writeMutex);
ConnPkt pkt;
memset(&pkt, 0, sizeof(ConnPkt));
pkt.magic = MAGIC;
pkt.version = CONN_PKT_VERSION;
pkt.type = type;
memcpy(pkt.sid, m_sid.c_str(), 4);
memcpy(pkt.connId, m_connId.c_str(), 6);
if (data) {
memcpy(pkt.data, data, dataLen);
}
int res = send(m_sock, &pkt, sizeof(ConnPkt), 0);
if (res == -1) {
std::cerr << "Failed to send response " << type << " to " << addrStr() << ", got errno " << errno << "\n";
}
return res;
}
int ConnectionHandler::sendNatHolepunch() {
int sock = socket(AF_INET, SOCK_DGRAM | SOCK_NONBLOCK, IPPROTO_UDP);
if (sock == -1)
{
std::cerr << "Failed to create outgoing udp socket for NAT holepunch!\n";
return 1;
}
int enableReuse = 1;
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &enableReuse, sizeof(int)) < 0) {
std::cerr << "FATAL: failed to set port re-use on UDP socket for NAT holepunch! errno: " << errno << "\n";
close(sock);
return 1;
}
if( bind(sock, (struct sockaddr*)&m_udpAddr, sizeof(struct sockaddr_in) ) == -1)
{
std::cerr << "ERROR: Failed to bind UDP send socket for NAT holepunch, got errno " << errno << "\n";
close(sock);
return 1;
}
struct sockaddr_in peerAddr;
socklen_t peerAddrLen = sizeof(peerAddr);
memset((char *) &peerAddr, 0, peerAddrLen);
peerAddr.sin_family = AF_INET;
peerAddr.sin_port = m_joinedData.publicPort;
memcpy(&peerAddr.sin_addr, &m_joinedData.publicAddr, sizeof(struct in_addr));
ConnPkt pkt;
memset(&pkt, 0, sizeof(ConnPkt));
pkt.magic = MAGIC;
pkt.version = CONN_PKT_VERSION;
pkt.type = PTYPE_HOLEPUNCH;
memcpy(pkt.sid, m_sid.c_str(), 4);
memcpy(pkt.connId, m_connId.c_str(), 6);
ssize_t nBytes = sendto(sock,
(char*)&pkt,
sizeof(ConnPkt),
0,
(struct sockaddr *) &peerAddr,
peerAddrLen);
if (nBytes < 0) {
std::cerr << "Failed to send NAT holepunch, got errno " << errno << "\n";
return -1;
}
return 0;
}
| 29.440252
| 146
| 0.600192
|
smr-llc
|
96fe7428b9c5c0596039e7a4bec9b4357d7ccc58
| 486
|
cpp
|
C++
|
src/dynfu/utils/frame.cpp
|
chenguowen/dynfu
|
5991e43144e9b3a95005c820f87900a6b21c7826
|
[
"BSD-3-Clause"
] | 34
|
2018-10-10T05:56:53.000Z
|
2022-03-02T09:17:05.000Z
|
src/dynfu/utils/frame.cpp
|
chenguowen/dynfu
|
5991e43144e9b3a95005c820f87900a6b21c7826
|
[
"BSD-3-Clause"
] | 1
|
2019-04-29T12:29:22.000Z
|
2019-05-14T15:33:12.000Z
|
src/dynfu/utils/frame.cpp
|
chenguowen/dynfu
|
5991e43144e9b3a95005c820f87900a6b21c7826
|
[
"BSD-3-Clause"
] | 11
|
2018-08-13T02:27:29.000Z
|
2021-12-02T06:43:18.000Z
|
#include <dynfu/utils/frame.hpp>
dynfu::Frame::Frame(int id, pcl::PointCloud<pcl::PointXYZ> vertices, pcl::PointCloud<pcl::Normal> normals) {
this->id = id;
this->vertices = vertices;
this->normals = normals;
}
dynfu::Frame::~Frame() = default;
int dynfu::Frame::getId() { return this->id; }
pcl::PointCloud<pcl::PointXYZ>& dynfu::Frame::getVertices() { return this->vertices; }
pcl::PointCloud<pcl::Normal>& dynfu::Frame::getNormals() { return this->normals; }
| 30.375
| 108
| 0.670782
|
chenguowen
|
8c00288b8cc922285f05f098368cccbd504dfec8
| 42,484
|
cpp
|
C++
|
Matrix.cpp
|
Mountiko/LinearSolvers
|
ffb4e18adc64951f730f9d1d5254ca55efc5d7ed
|
[
"MIT"
] | 3
|
2020-07-29T10:45:32.000Z
|
2022-02-03T02:32:59.000Z
|
Matrix.cpp
|
Mountiko/LinearSolvers
|
ffb4e18adc64951f730f9d1d5254ca55efc5d7ed
|
[
"MIT"
] | null | null | null |
Matrix.cpp
|
Mountiko/LinearSolvers
|
ffb4e18adc64951f730f9d1d5254ca55efc5d7ed
|
[
"MIT"
] | 5
|
2020-08-04T14:44:17.000Z
|
2021-12-11T04:28:47.000Z
|
#include <iostream>
#include <typeinfo>
#include <cmath>
#include "Matrix.h"
using namespace std;
// Constructor - using an initialisation list here
template<class T>
Matrix<T>::Matrix(int rows, int cols, bool preallocate):\
rows(rows), cols(cols), size_of_values(rows * cols), preallocate(preallocate)
{
// If we want to handle memory ourselves
if (this->preallocate)
{
// Must remember to delete this in the destructor
this->values.reset(new T[size_of_values]);
}
}
// Constructor - now just setting the value of our double pointer
template<class T>
Matrix<T>::Matrix(int rows, int cols, T *values_ptr):\
rows(rows), cols(cols), size_of_values(rows * cols)
{
this->values.reset(values_ptr);
}
// destructor
template<class T>
Matrix<T>::~Matrix()
{}
// fills matrix values with random numbers
// between 0 and 100.
template<class T>
void Matrix<T>::fillRandom()
{
for (int i = 0; i < this->rows * this->cols; i++)
{
this->values[i] = (T)(rand()%101 + 0);
}
}
// fills matrix with zeros
template<class T>
void Matrix<T>::fillZeros()
{
T val = (T)0;
for (int i = 0; i < this->rows * this->cols; i++)
{
this->values[i] = val;
}
}
// fills matrix with ones
template<class T>
void Matrix<T>::fillOnes()
{
T val = (T)1;
for (int i = 0; i < this->rows * this->cols; i++)
{
this->values[i] = val;
}
}
// make an identity matrix
template<class T>
void Matrix<T>::makeIdentity()
{
if (rows != cols)
{
cout << "A non-square matrix is made identity matrix. \
Matrix will be filled with zeros and have values of one \
at the diagonal starting at top-left corner of matrix." << endl;
}
T zero = (T)0;
T one = (T)1;
for (int i = 0; i < this->rows; i++)
{
for (int j = 0; j < this->cols; j++)
{
if (i == j)
{
this->values[i * this->cols + j] = one;
}
else
{
this->values[i * this->cols + j] = zero;
}
}
}
}
template<class T>
void Matrix<T>::generateSPD(int type)
{
// check if entry matrix is squared
if (this->rows != this->cols)
{
cout << "Matrix needs to have the dimensions n x n" << endl;
return;
}
// start switch statement to define which type if matrix to do
switch (type)
{
case 1: // dense matrix with high density filled with integers
{
for (int i = 0; i < this->rows; i++)
{
for (int j = 0; j < this->cols; j++)
{
if (i < j)
{
// set random values for strictly upper triangle
this->values[i * this->cols + j] = this->rows - \
(rand() % this->rows + 0);
}
else if (j < i)
{
// set lower triangle as the upper on to achive symmetry
this->values[i * this->cols + j] = \
this->values[j * this->cols + i];
}
else
{
// set diagonal a random value guaranteed to be greater
// than the sum of the rest of elements in ith row
this->values[i * this->cols + j] = this->rows * \
this->cols * 2 - \
(rand() % (this->rows*this->cols) + 0);
}
}
}
break;
}
case 2: // dense matrix with high density filled with doubles
{
for (int i = 0; i < this->rows; i++)
{
for (int j = 0; j < this->cols; j++)
{
if (i < j)
{
// set random double values for strictly upper triangle
double val = (rand() % (this->rows * this->cols) + 0);
this->values[i * this->cols + j] = val / this->rows;
}
else if (j < i)
{
// set lower triangle as the upper on to achive symmetry
this->values[i * this->cols + j] = \
this->values[j * this->cols + i];
}
else
{
// set diagonal a random value guaranteed to be greater
// than the sum of the rest of elements in ith row
this->values[i * this->cols + j] = \
this->rows * this->cols * 2 -\
(rand() % (this->rows*this->cols) + 0);
}
}
}
break;
}
case 3: // dense matrix where only the diagonal is populated
{
for (int i = 0; i < this->rows; i++)
{
for (int j = 0; j < this->cols; j++)
{
if (i == j)
{
// set diagonal values to random numbers
// (that though depend on the size of the matrix)
this->values[i * this->cols + j] =\
this->rows * this->cols * 1.5 -\
(rand() % (this->rows*this->cols) + 0);
}
}
}
break;
}
case 4: // dense matrix where only the tri-diagonal is populated
{
for (int i = 0; i < this->rows; i++)
{
for (int j = 0; j < this->cols; j++)
{
if (i == j)
{
// set diagonal values to random numbers
// (that though depend on the size of the matrix)
this->values[i * this->cols + j] =\
this->rows * this->cols * 1.5 -\
(rand() % (this->rows*this->cols) + 0);
}
else if (j - i == 1)
{
// set closest upper off diagonal to random values
// between 0 and the amount of rows
// to guarantee SPD
this->values[i * this->cols + j] = this->rows -\
(rand() % (this->rows) + 0);
}
else if (i - j == 1)
{
// make symmetry by copying values over to the lower triangle
this->values[i * this->cols + j] =\
this->values[j * this->cols + i];
}
}
}
break;
}
case 5: // dense matrix where only the penta-diagonal is populated
{
for (int i = 0; i < this->rows; i++)
{
for (int j = 0; j < this->cols; j++)
{
if (i == j)
{
// set diagonal values to random numbers
// (that though depend on the size of the matrix)
this->values[i * this->cols + j] =\
this->rows * this->cols * 1.5 -\
(rand() % (this->rows*this->cols) + 0);
}
else if (j - i == 1 || j - i == 2)
{
// set closest two upper off diagonals to random values
// between 0 and the amount of rows
// to guarantee SPD
this->values[i * this->cols + j] = this->rows -\
(rand() % (this->rows) + 0);
}
else if (i - j == 1 || i - j == 2)
{
// make symmetry by copying values over to the lower triangle
this->values[i * this->cols + j] =\
this->values[j * this->cols + i];
}
}
}
break;
}
case 6: // dense matrix: diagonals populated: -5, -3, 0, 3, 5
{
for (int i = 0; i < this->rows; i++)
{
for (int j = 0; j < this->cols; j++)
{
if (i == j)
{
// set diagonal values to random numbers
// (that though depend on the size of the matrix)
this->values[i * this->cols + j] =\
this->rows * this->cols * 1.5 -\
(rand() % (this->rows*this->cols) + 0);
}
else if (j - i == 3 || j - i == 5)
{
// set closest third and fifth upper off diagonals to random values
// between 0 and the amount of rows
// to guarantee SPD
this->values[i * this->cols + j] = this->rows -\
(rand() % (this->rows) + 0);
}
else if (i - j == 3 || i - j == 5)
{
// make symmetry by copying values over to the lower triangle
this->values[i * this->cols + j] =\
this->values[j * this->cols + i];
}
}
}
break;
}
default:
cout << "generateSPD: Type inserted does not exist!!!" << endl;
break;
}
}
// Just print out the values in our values array
template<class T>
void Matrix<T>::printValues()
{
std::cout << "Printing values" << std::endl;
for (int i = 0; i< this->size_of_values; i++)
{
std::cout << this->values[i] << " ";
}
std::cout << std::endl;
}
// Explicitly print out the values in values array as if they are a matrix
template<class T>
void Matrix<T>::printMatrix()
{
std::cout << "Printing matrix" << std::endl;
// looping through rows of matrix
for (int j = 0; j< this->rows; j++)
{
std::cout << std::endl;
// looping through each element inside a row of the matrix
for (int i = 0; i< this->cols; i++)
{
// We have explicitly used a row-major ordering here
std::cout << this->values[i + j * this->cols] << " ";
}
}
std::cout << std::endl;
}
// transpose function
template<class T>
void Matrix<T>::transpose (Matrix<T> &x)
{
// check if intput matrix is squared
if (this->cols != x.rows || this->rows != x.cols)
{
cerr << "Dimensions don't match" << endl;
return;
}
// switch the position of each element with its symmetric partner
for( int i=0; i < this->rows; ++i)
{
for(int j=0; j < this->cols; ++j)
{
x.values[j * x.cols + i] = this->values[i * x.rows + j];
}
}
}
//Makes the sum of the matrix
template<class T>
void Matrix<T>::matSum(T &sum)
{
sum = (T)0;
for (int i = 0; i < this->rows * this->cols; i++)
{
sum += this->values[i];
}
}
// calculates the trace of a matrix
template<class T>
void Matrix<T>::trace(T &trc)
{
if (this->cols != this->rows)
{
cerr << "matrix must be square matrix" << endl;
return;
}
trc = (T)0;
cerr << "THIS IS HOW FAR I GOT" << endl;
// create identity matrix
unique_ptr<Matrix<T>> identity(new Matrix<T>(this->rows, this->cols, true));
identity->makeIdentity();
unique_ptr<Matrix<T>> trace_mat(new Matrix<T>(this->rows, this->cols, true));
for (int i = 0; i < this->rows * this->cols; i++)
{
trace_mat->values[i] = identity->values[i] * this->values[i];
}
trace_mat->matSum(trc);
}
template<class T>
int Matrix<T>::countNonZeros()
{
int nnzs = 0;
for (int i = 0; i < this->rows * this->cols; i++)
{
if (this->values[i] != 0)
{
nnzs++;
}
}
return nnzs;
}
/* Function to calculate and store inverse
with inverse(M) = adj(M)/det(M) formula
returns error if the matrix is singular */
template<class T>
bool Matrix<T>::inverse (Matrix<T> &inverse)
{
// check if matrix is squared
// if not throw error
if (this->cols != this->rows)
{
cerr << "Only square matrices are invertible" << endl;
return false;
}
int N = this->rows;
// Find determinant of M[][]
double det = this->determinant(N);
if (det == 0)
{
cout << "Inverse of a matrix exists only if the matrix is non-singular";
return false;
}
// call Adjugate
unique_ptr<Matrix<T>> adj(new Matrix<T>(N, N, true));
this->adjugate(*adj);
// Finding inverse using formula
for (int i=0; i<N; i++)
for (int j=0; j<N; j++)
inverse.values[i* this->rows + j] = adj->values[i * adj->rows + j]/det;
return true;
}
/* Applying a "checkerboard" of minuses to the "Matrix of Minors".
In other words, we need to change the sign of alternate cells
Function to get cofactor of M in temp
where n is current dimension of M matrix */
template<class T>
void Matrix<T>::coFactor (Matrix<T> &temp, int l, int k, int n)
{
int i = 0, j = 0;
// Looping thru each element of the matrix
for (int row = 0; row < n; row++)
{
for (int col = 0; col < n; col++)
{
// Copying into temporary matrix only those element
// which are not in given row and column
if (row != l && col != k)
{
temp.values[i * temp.rows + j] = \
this->values[row * this->rows + col];
j++;
// Row is filled so
if (j == n - 1)
{
j = 0; //reset coloumn index
i++; // increase row index
}
}
}
}
}
// Recursive function for finding determinant of matrix.
template<class T>
double Matrix<T>::determinant (int n)
{
double D = 0; // Result initialised
// For 1x1 matrix, contains a single element
if (n == 1)
return this->values[0];
unique_ptr<Matrix<T>> temp(new Matrix<T>(n, n, true)); // Store cofactors
double sign = 1.0; // Store sign multiplier
// Iterate for each element of first row
for (int z = 0; z < n; z++)
{
// Getting Cofactor of M[0][z]
this->coFactor(*temp, 0, z, n);
double det = temp->determinant(n-1);
//temp->printMatrix();
D += sign * this->values[z] * det;
// Alternating signs
sign = -sign;
}
return D;
}
// Function to get Adjugate of M[N][N] in adj[N][N].
template<class T>
void Matrix<T>::adjugate (Matrix<T> &adj)
{
int N = this->rows;
// For 1x1 matrix, contains a single element
if (N == 1)
{
adj.values[0] = 1;
return;
}
// temp is used to store cofactors of M[][]
int sign = 1;
unique_ptr<Matrix<T>> temp(new Matrix<T>(N, N, true)); // Store cofactors
for (int i=0; i<N; i++)
{
for (int j=0; j<N; j++)
{
// Get cofactor of M[i][j]
this->coFactor(*temp, i, j, N);
// If sum of row and column indexes is even,
// sign of adj[j][i] is positive
sign = ((i+j)%2==0)? 1: -1;
// transpose of the cofactor matrix, i.e interchanging rows and columns
adj.values[j * this->cols + i] = (sign)*(temp->determinant(N-1));
}
}
}
// compute the upper triangle reduced matrix given vector b
template<class T>
void Matrix<T>::upper_triangle(T* b, Matrix<T> &out_mat, T* &x)
{
// check if the matrix is a square matrix
// must be square
if (this->rows != this->cols) {
std::cerr << "Matrix is not square!" << std::endl;
}
// set our output matrix to this matrix
for (int i = 0; i < this->rows * this->cols; i++)
{
out_mat.values[i] = this->values[i];
}
// set the output vector to the input matrix
for (int i = 0; i < this->rows; i++) x[i] = b[i];
double s = 0.0; // define constant
for (int k = 0; k < (this->rows)-1; k++)
{
for (int i = k+1; i < this->rows; i++)
{
// set constant value
s = out_mat.values[i * this->rows + k] /\
out_mat.values[k * this->rows + k];
for (int j = k; j < this->rows; j++)
{
// update output matrix
out_mat.values[i * this->rows + j] =\
out_mat.values[i * this->rows + j] -\
s * out_mat.values[k * this->rows + j];
}
// update output vector
x[i] = x[i] - s * x[k];
}
}
}
// Back Substitution on the system Ax = b
// Returns x, the solution
template<class T>
void Matrix<T>::back_substitution(T* b, T* &x)
{
double s;
// set output vector to 0
for (int i = 0; i < this->rows; i++) x[i] = 0;
// iterate over rows
for (int i = (this->rows)-1; i > -1; i--)
{
// set constant
s = 0.0;
// iterate over columns
for (int j = i+1; j < this->cols; j++)
{
// update constant value
s += this->values[i * this->rows + j] * x[j];
}
// update the output matrix
x[i] = (b[i] - s)/this->values[i * this->rows + i];
}
}
// Forward Substitution on the system Ax = b
// Returns x, the solution
template<class T>
void Matrix<T>::for_substitution(T* b, T* &x)
{
double s;
// set output vector to 0
for (int i = 0; i < this->rows; i++) x[i] = 0.0;
// iterate over rows
for (int i = 0; i < this->rows; i++) {
s = 0.0; // set constant
for (int j = 0; j < i; j++) {
// update constant
s += this->values[i * this->rows + j] * x[j];
}
// update output vector
x[i] = (b[i] - s)/this->values[i * this->rows + i];
}
}
// N×N matrix A, assume that an LU decomposition exists.
//I am using Doolittle's method as it provides an alternative way to factor
//A into an LU decomposition without going through the hassle of Gaussian Elimination.
// A=LU
//where L is an n×n lower triangular matrix whose main diagonal consists of 1s
//and where U is an n×n upper triangular matrix)
//Reference: http://mathonline.wikidot.com/the-algorithm-for-doolittle-s-method-for-lu-decompositions
template<class T>
void Matrix<T>::luDecomposition(Matrix<T> &lower, Matrix<T> &upper){
int N = this->rows;
//initiliase Matrix
for (int i=0; i<N*N; i++){
lower.values[i] = 0;
upper.values[i] = 0;
}
for (int i = 0; i < N; i++) {
// Lower Triangular
for (int k = i; k < N; k++) {
if (i == k)
lower.values[i*N+i] = 1; // Diagonals as 1
else {
double sum = 0;
// sum of L(k,j) * U(j, i)
for (int j = 0; j < i; j++)
sum += (lower.values[k*N+j] * upper.values[j*N+i]);
// evaluate lower
lower.values[k*N+i] =\
(this->values[k*N+i] - sum) / upper.values[i*N+i];
}
// Upper Triangular
for (int k = i; k < N; k++)
{
double sum = 0;
// sum of L(i,j) * U(j,k)
for (int j = 0; j < i; j++)
{
sum += (lower.values[i*N + j] * upper.values[j*N+k]);
}
// evaluate upper
upper.values[i*N + k] = this->values[i * N + k] - sum;
}
}
}
}
// Do matrix vector multiplication
// x = A(this) * b
template<class T>
void Matrix<T>::matVecMult(T* &b, T* x)
{
// initialize output vector to 0s
for (int i = 0; i < this->rows; i++)
{
x[i] = 0;
}
// iterate over rows and coloumns
for (int j = 0; j < this->rows; j++)
{
for (int i = 0; i < this->cols; i++)
{
x[j] += this->values[j * this->cols + i] * b[i];
}
}
}
// Do matrix matrix multiplication
// output = this * mat_right
template<class T>
void Matrix<T>::matMatMult(Matrix<T> &B, Matrix<T> &X)
{
// Check our dimensions match
if (this->cols != B.rows)
{
std::cerr << "Input dimensions for matrices don't match" << std::endl;
return;
}
// Check if our output matrix has had space allocated to it
if (X.values != nullptr)
{
// Check our dimensions match
if (this->rows != X.rows || B.cols != X.cols)
{
cerr << "Input dimensions for output matrix doesn't match output" << endl;
return;
}
}
// The output hasn't been preallocated, so we are going to do that
else
{
X.values.reset(new T[this->rows * B.cols]);
}
// Set values to zero before hand
for (int i = 0; i < X.size_of_values; i++)
{
X.values[i] = 0;
}
for(int i = 0; i < this->rows; i++)
{
for(int k = 0; k < this->cols; k++)
{
for(int j = 0; j < B.cols; j++)
{
X.values[i * X.cols + j] += this->values[i * this->cols + k] *\
B.values[k * B.cols + j];
}
}
}
}
/////////////////LINEAR SOLVERS\\\\\\\\\\\\\\\\\\
// linear solver by calculating the inverse of a matrix and
// then multiplying it with a vector to get the solution
template<class T>
void Matrix<T>::linear_solver_inv(T* &b, T* x)
{
// create temporary matrix to store the inverse
unique_ptr<Matrix<T>> temp(new Matrix<T>(this->rows, this->cols, true));
// calculate the inverse
this->inverse(*temp);
// get the solution by multiplying the inverse with the input vector
temp->matVecMult(b, x);
}
// Gaussian Elimination
template<class T>
void Matrix<T>::gaussian_elim(T* b, T* &x)
{
// create a temporary matrix and vector to store the intermediate steps
unique_ptr<Matrix<T>> temp_mat(new Matrix<T>(this->rows, this->cols, true));
T* temp_vec = new T[this->rows];
// get the upper triangle form of our input matrix
this->upper_triangle(b, *temp_mat, temp_vec);
// do back-substitution to get the solution vector
temp_mat->back_substitution(temp_vec, x);
delete[] temp_vec;
return;
}
// LU decomposition solver
template<class T>
void Matrix<T>::luSolve(T* b, T* &x)
{
unique_ptr<Matrix<T>> upper(new Matrix<T>(this->rows, this->cols, true));
unique_ptr<Matrix<T>> lower(new Matrix<T>(this->rows, this->cols, true));
T* temp_vec = new T[this->rows];
this->luDecomposition(*lower, *upper);
lower->for_substitution(b, temp_vec);
upper->back_substitution(temp_vec, x);
delete[] temp_vec;
return;
}
// the algorithm for this function is found on:
// https://en.wikipedia.org/wiki/Conjugate_gradient_method
template<class T>
void Matrix<T>::conjugateGradient(T* b, T* x, double atol)
{
// set default initial guess
for (int i = 0; i < this->cols; i++)
{
x[i] = (T)1;
}
// declare some array pointers that we ll need in the algorithm
T* r_k = new T[this->rows];
T* x_A = new T[this->cols];
T* p_k = new T[this->rows];
// make the matVecMult to get the initial residual
this->matVecMult(x, x_A);
// declare initial residual
double tot_rk = 0;
// compute initial residual
for (int i = 0; i < this->rows; i++)
{
r_k[i] = b[i] - x_A[i]; // local residual
tot_rk += r_k[i] * r_k[i]; // norm of residual
p_k[i] = r_k[i]; // initiate p0
}
tot_rk = sqrt(tot_rk); // norm of initial residual
// decclare alpha and beta
// as variables in stack since only singular double
double alpha_k;
double beta_k;
// initiate count
int count = 0;
// start iterating the algorithm
while (tot_rk >= atol)
{
// update counter
count++;
// initiate p_A as the product of pk and this->matrix
double* p_A = new double[this->rows];
this->matVecMult(p_k, p_A);
// initiate array pointers denominator and counter
// for computing alpha
double r_dot = 0;
double p_Ap = 0;
// get denominator and counter
for (int i = 0; i < this->rows; i++)
{
r_dot += r_k[i] * r_k[i];
p_Ap += p_k[i] * p_A[i];
}
// compute alpha
alpha_k = r_dot / p_Ap;
// getting x_k+1 and r_k+1
// initiate array pointer to store rk+1
double* r_k_nxt = new double[this->rows];
// use the same loop to compute new result of kth iteration
// and rk+1
for (int i = 0; i < this->rows; i++)
{
x[i] += alpha_k * p_k[i];
r_k_nxt[i] = r_k[i] - alpha_k * p_A[i];
}
// set residual variable to zero
tot_rk = 0;
// initialte denominator and counter
// to compute beta
double beta_top = 0;
double beta_bot = 0;
for (int i = 0; i < this->rows; i++)
{
// compute residual and beta rate in same loop
tot_rk += pow(r_k_nxt[i], 2);
beta_top += r_k_nxt[i] * r_k_nxt[i];
beta_bot += r_k[i] * r_k[i];
}
// compu6te beta
beta_k = beta_top / beta_bot;
// take sqrt of residual to get the norm
tot_rk = sqrt(tot_rk);
// compute pk and pass rk+1 to rk memory in same loop
for (int i = 0; i < this->rows; i++)
{
p_k[i] = r_k_nxt[i] + beta_k * p_k[i];
r_k[i] = r_k_nxt[i];
}
// print some nice stuff at the frequency you wish
// change the integer after the % operator to change
// the frequency of printing
/*
if (count % 1 == 0)
{
cout << "Iteration: " << count << endl;
cout << "Residual: " << tot_rk << endl;
cout << "alpha: " << alpha_k << endl;
cout << "beta: " << beta_k << endl;
for (int i = 0; i < this->cols; i++)
{
cout << x[i] << endl;
}
}
cout << endl;
*/
delete[] p_A;
delete[] r_k_nxt;
// set limit of iterations for convergence
if (count == 10000)
{
cout << "CG is not convergence,";
cout << "be sure that the matrix is Symetric Positive Definite" << endl;
break;
}
}
// print some nice shit at the end
cout << "Total iteration; " << count << endl;
cout << "Total Residual: " << tot_rk << endl;
delete[] r_k;
delete[] x_A;
delete[] p_k;
}
// the algorithm for this function is found on:
// https://en.wikipedia.org/wiki/Successive_over-relaxation
template<class T>
void Matrix<T>::SOR(T *b, T *x, double omega, double atol)
{
// check if omega is set well
if (omega <= 0 || omega >= 2)
{
cout << "Error: 0 < omega < 1" << endl;
return;
}
// set default initial guess
for (int i = 0; i < this->cols; i++)
{
x[i] = (T)1;
}
// initiate array pointers to store A*x
// and rk
T* x_A = new T[this->cols];
T* r_k = new T[this->rows];
// compute A*x
this->matVecMult(x, x_A);
// initiate a variable for the residual
double tot_rk = 0;
// compute residual as vector norm
for (int i = 0; i < this->rows; i++)
{
r_k[i] = b[i] - x_A[i];
tot_rk += r_k[i] * r_k[i];
}
tot_rk = sqrt(tot_rk); // sqrt to complete vector norm
// initiate count
int count = 0;
// and the algorithm iterations start
while (tot_rk >= atol)
{
// loop through rows and cols
for (int i = 0; i < this->rows; i++)
{
double sigma = 0; // reset sigma to zero to re-compute it
for (int j = 0; j < this->cols; j++)
{
// recomputing sigma
// only adding terms outside the diagonal
if (i != j)
{
sigma += this->values[i * this->cols + j] * x[j];
}
}
// computing ith value of result for current interation
x[i] = (1 - omega) * x[i] +\
(omega / this->values[i * this->cols + i]) * (b[i] - sigma);
}
// reset residual
tot_rk = 0;
// compute A*x
this->matVecMult(x, x_A);
// compute total residual using vector norm
for (int i = 0; i < this->rows; i++)
{
// res = b - Ax
r_k[i] = b[i] - x_A[i];
tot_rk += r_k[i] * r_k[i];
}
tot_rk = sqrt(tot_rk); // sqrt to complete vector norm
// update count
count++;
// break at maximum
if (count == 10000)
{
cout << "SOR is not converging!!!" << endl;
break;
}
/*
// print some cool stuff
cout << "Iteration: " << count << endl;
cout << "Residual: " << tot_rk << endl;
cout << "x:" << endl;
for (int i = 0; i < this->rows; i++)
{
cout << x[i] << endl;
}*/
}
// print some cool stuff at the end
cout << "Total iteration; " << count << endl;
cout << "Total Residual: " << tot_rk << endl;
delete[] x_A;
delete[] r_k;
}
// the algorithm for this function is found on:
// https://en.wikipedia.org/wiki/Chebyshev_iteration#cite_note-2
template<class T>
void Matrix<T>::chebyshevIter(T* b, T* &x, T lMin, T lMax, double atol)
{
// initialize constants to be used in the algorithm
double d = (lMax + lMin)/2;
double c = (lMax - lMin)/2;
// initialize our x and set it to our guess
T* x0 = new T[this->cols];
for (int i = 0; i < this->cols; i++)
{
x0[i] = (T)1;
}
// define output vector
T* r = new T[this->cols];
// r = b - A * x
this->matVecMult(b, r);
for (int i = 0; i < this->cols; i++)
{
r[i] = b[i] - r[i];
}
// initialize arrays for the iterative algorithm
T* p = new T[this->cols];
int i = 0;
double alpha;
double beta;
double norm = atol * 2;
while (norm >= atol)
{
if (i==0) { // initial iteration
// set p to r
for (int j = 0; j < this->rows; j++) {
p[j] = r[j];
}
alpha = 1.0/d; // define alpha
} else if (i == 1) { // second iteration
beta = (1/2) * pow((c * alpha), 2); // beta = (1/2) * (c*alpha)^2
alpha = 1/(d - beta/alpha);
// p = r + beta * p
for (int j = 0; j < this->rows; j++){
p[j] = r[j] + beta * p[j];
}
} else { // the rest
beta = pow(c*alpha/2, 2); // beta = (c*alpha/2)^2
alpha = 1/(d - beta/alpha);
// p = r + beta * p
for (int j = 0; j < this->rows; j++) {
p[j] = r[j] + beta*p[j];
}
}
// x = x + alpha * p
for (int j = 0; j < this->rows ; j++) {
x0[j] = x0[j] + alpha * p[j];
}
// r = b - A*x;
// calculate the norm of r
this->matVecMult(x0, r);
norm = 0.0;
for (int j = 0; j < this->rows; j++) {
r[j] = b[j] - r[j];
norm += pow(r[j], 2);
}
norm = sqrt(norm);
// max iterations check
if (i == 10000) break;
i++; // iterate
}
cout << "Total iteration; " << i << endl;
cout << "Total Residual: " << norm << endl;
// output result
for (int j = 0; j < this->rows; j++) {
x[j] = x0[j];
}
delete[] r;
delete[] p;
delete[] x0;
}
// the algorithm for this function is found on:
// https://en.wikipedia.org/wiki/Conjugate_gradient_method
template <class T>
void Matrix<T>::multiConjugateGradient(const Matrix<T> *B, Matrix<T> *X,\
const double atol)
{
// check if dimensions of all matrices are right to
// be able to solve all linear systems
if (this->cols != X->rows || this->rows != B->rows || X->cols != B->cols)
{
cout << "Dimensions are not right!!!" << endl;
return;
}
// set default initial guess
for (int i = 0; i < X->cols * X->rows; i++)
{
X->values[i] = (T)1;
}
// initiate some matrices we need during the algorithm
auto* r_k = new Matrix<T>(B->rows, B->cols, true);
auto* p_k = new Matrix<T>(B->rows, B->cols, true);
auto* x_A = new Matrix<T>(B->rows, B->cols, true);
// precompute the matrix product A*x
this->matMatMult(*X, *x_A);
// initiate variable for residual
// residual is the matrix norm 2
double tot_rk = 0;
for (int i = 0; i < B->rows * B->cols; i++)
{
r_k->values[i] = B->values[i] - x_A->values[i]; // compute local residual
tot_rk += r_k->values[i] * r_k->values[i]; // get the square of local res
p_k->values[i] = r_k->values[i]; // initiate p0
}
// get the sqrt to complete norm
tot_rk = sqrt(tot_rk);
// initiate arrays for alpah and beta
double* alpha_k = new double[B->cols];
double* beta_k = new double[B->cols];
// initiate count
int count = 0;
// start iterating the algorithm
while (tot_rk >= atol)
{
// update counter
count++;
// initiate matrix for A p matrix product and do the computation
auto* p_A = new Matrix<T>(B->rows, B->cols, true);
this->matMatMult(*p_k, *p_A);
// initiate array pointers for dot product of rk and p*A*p
double* r_dot = new double[r_k->cols];
double* p_Ap = new double[p_k->cols];
// set all allocated memory to zero
for (int i = 0; i < B->cols; i++)
{
r_dot[i] = 0;
p_Ap[i] = 0;
alpha_k[i] = 0;
beta_k[i] = 0;
}
// first getting denominator (dotproduct of rk)
// and counter (p A p)
for (int i = 0; i < B->rows; i++)
{
for (int j = 0; j < B->cols; j++)
{
r_dot[j] +=\
r_k->values[i * B->cols + j] * r_k->values[i * B->cols + j];
p_Ap[j] +=\
p_k->values[i * B->cols + j] * p_A->values[i * B->cols + j];
}
}
// then computing values for alpha
// each value is assigned to one vector inside p_k matrix
for (int j = 0; j < B->cols; j++)
{
alpha_k[j] = r_dot[j] / p_Ap[j];
}
// initiate matrix to store rk+1
auto* r_k_nxt = new Matrix<T>(r_k->rows, r_k->cols, true);
// compute the result for current iteration
// and also the rk+1
for (int i = 0; i < X->rows; i++)
{
for (int j = 0; j < X->cols; j++)
{
X->values[i * X->cols + j] +=\
alpha_k[j] * p_k->values[i * X->cols + j];
r_k_nxt->values[i * X->cols + j] =\
r_k->values[i * X->cols + j] -\
alpha_k[j] * p_A->values[i * X->cols + j];
}
}
// set initial residual to zero to re-compute it
tot_rk = 0;
// initiate array pointers to store
// denominator and counter to compute beta
double* beta_top = new double[B->cols];
double* beta_bot = new double[B->cols];
// and set all allocated memory to zero
for (int i = 0; i < B->cols; i++)
{
beta_top[i] = 0;
beta_bot[i] = 0;
}
// making sure to take all the dot-product
// of the individual vectors inside the
// r_k / r_k+1 matrices
for (int i = 0; i < B->rows; i++)
{
for (int j = 0; j < B->cols; j++)
{
tot_rk += pow(r_k_nxt->values[i * B->cols + j], 2);
beta_top[j] += r_k_nxt->values[i * B->cols + j] *\
r_k_nxt->values[i * B->cols + j];
beta_bot[j] += r_k->values[i * B->cols + j] *\
r_k->values[i * B->cols + j];
}
}
tot_rk = sqrt(tot_rk); // sqrt to complete the matrix norm
// compute beta with previously computed beta_top and beta_bot
for (int j = 0; j < B->cols; j++)
{
beta_k[j] = beta_top[j] / beta_bot[j];
}
// compute p_k+1
for (int i = 0; i < B->rows; i++)
{
for (int j = 0; j < B->cols; j++)
{
p_k->values[i * B->cols + j] =\
r_k_nxt->values[i * B->cols + j] +\
beta_k[j] * p_k->values[i * B->cols + j];
}
}
// update r_k
for (int i = 0; i < B->rows * B->cols; i++)
{
r_k->values[i] = r_k_nxt->values[i];
}
/*
// print some nice stuff
if (count % 1 == 0)
{
cout << endl << "Iteration: " << count << endl;
cout << "Residual: " << tot_rk << endl;
for (int i = 0; i < b.cols; i++)
{
cout << "alpha, beta: ";
cout << alpha_k[i] << " " << beta_k[i] << endl;
}
x.printMatrix();
cout << endl;
}*/
delete[] r_dot;
delete[] p_Ap;
delete p_A;
delete r_k_nxt;
delete[] beta_bot;
delete[] beta_top;
// break if maximum number of iteration is reached
if (count == 10000)
{
cout << "No convergence,";
cout << "be sure that the matrix is Symetric Positive Definite" << endl;
break;
}
}
// print some more nice shit at the end
cout << "Total iteration; " << count << endl;
cout << "Total Residual: " << tot_rk << endl;
delete x_A;
delete r_k;
delete p_k;
delete[] alpha_k;
delete[] beta_k;
}
// the algorithm for this function is found on:
// https://en.wikipedia.org/wiki/Successive_over-relaxation
template<class T>
void Matrix<T>::multiSOR(const Matrix<T> *B, Matrix<T> *X, const double omega, const double atol)
{
// check if omega is set well
if (omega <= 0 || omega >= 2)
{
cout << "Error: 0 < omega < 1" << endl;
return;
}
// check if dimensions of all matrices are right to
// be able to solve all linear systems
if (this->cols != X->rows || this->rows != B->rows || X->cols != B->cols)
{
cout << "Dimensions are not right!!!" << endl;
return;
}
// set default initial guess
for (int i = 0; i < X->cols * X->rows; i++)
{
X->values[i] = (T)1;
}
// initiate Matrix pointers to store A*x
// and rk
auto* r_k = new Matrix<T>(B->rows, B->cols, true);
auto* x_A = new Matrix<T>(B->rows, B->cols, true);
// precompute the matrix product A*x
this->matMatMult(*X, *x_A);
// initiate variable for residual
// residual is the matrix norm 2
double tot_rk = 0;
for (int i = 0; i < B->rows * B->cols; i++)
{
r_k->values[i] = B->values[i] - x_A->values[i]; // compute local residual
tot_rk += r_k->values[i] * r_k->values[i]; // get the square of local res
}
// get the sqrt to complete norm
tot_rk = sqrt(tot_rk);
// initiate count
int count = 0;
// and the algorithm iterations start
while (tot_rk >= atol)
{
// loop through rows and cols
for (int i = 0; i < this->rows; i++)
{
double* sigma = new double[this->cols];
// reset sigma to zero to re-compute it
for (int k = 0; k < X->cols; k++)
{
sigma[k] = 0;
}
for (int j = 0; j < this->cols; j++)
{
for (int k = 0; k < X->cols; k++)
{
// recomputing sigma
// only adding terms outside the diagonal
if (i != j)
{
sigma[k] += this->values[i * this->cols + j] *\
X->values[i * this->cols + k];
}
}
}
// computing ith value of result for current interation
for (int k = 0; k < X->cols; k++)
{
X->values[i * X->cols + k] = \
(1 - omega) * X->values[i * X->cols + k] +\
(omega / this->values[i * this->cols + i]) *\
(B->values[i * X->cols + k] - sigma[k]);
}
delete[] sigma;
}
// reset residual
tot_rk = 0;
// compute A*x
this->matMatMult(*X, *x_A);
// compute total residual using vector norm
for (int i = 0; i < B->rows * B->cols; i++)
{
// res = B - Ax
// compute local residual
r_k->values[i] = B->values[i] - x_A->values[i];
// get the square of local res
tot_rk += r_k->values[i] * r_k->values[i];
}
// get the sqrt to complete norm
tot_rk = sqrt(tot_rk);
// update count
count++;
// break at maximum
if (count == 10000)
{
cout << "multiSOR is not converging!!!" << endl;
break;
}
/* // print some cool stuff
cout << "Iteration: " << count << endl;
cout << "Residual: " << tot_rk << endl;
cout << "x:" << endl;
for (int i = 0; i < x->rows; i++)
{
for (int j = 0; j < x->cols; j++)
{
cout << x->values[i * x->cols + j] << " ";
}
cout << endl;
}
*/
}
// print some cool shit at the end
cout << "Total iteration; " << count << endl;
cout << "Total Residual: " << tot_rk << endl;
delete x_A;
delete r_k;
}
| 29.709091
| 101
| 0.468765
|
Mountiko
|
8c01635bc1c48bd03201b08d74340bc7293d6ca4
| 5,217
|
cpp
|
C++
|
Source/AjaMediaEditor/Private/Customizations/AjaMediaTimecodeReferenceCustomization.cpp
|
ue4plugins/AjaMedia
|
d7147e4affc2820d36d942ff28f5a5abae5acbd1
|
[
"MIT"
] | 3
|
2019-10-09T16:05:34.000Z
|
2020-08-28T12:43:26.000Z
|
Source/AjaMediaEditor/Private/Customizations/AjaMediaTimecodeReferenceCustomization.cpp
|
ue4plugins/AjaMedia
|
d7147e4affc2820d36d942ff28f5a5abae5acbd1
|
[
"MIT"
] | null | null | null |
Source/AjaMediaEditor/Private/Customizations/AjaMediaTimecodeReferenceCustomization.cpp
|
ue4plugins/AjaMedia
|
d7147e4affc2820d36d942ff28f5a5abae5acbd1
|
[
"MIT"
] | 2
|
2019-11-18T00:43:25.000Z
|
2020-09-18T03:39:36.000Z
|
// Copyright 1998-2019 Epic Games, Inc. All Rights Reserved.
#include "Customizations/AjaMediaTimecodeReferenceCustomization.h"
#include "AjaDeviceProvider.h"
#include "CommonFrameRates.h"
#include "DetailWidgetRow.h"
#include "DetailCategoryBuilder.h"
#include "DetailLayoutBuilder.h"
#include "Framework/Application/SlateApplication.h"
#include "MediaIOPermutationsSelectorBuilder.h"
#include "ObjectEditorUtils.h"
#include "Widgets/Input/SComboButton.h"
#include "Widgets/Text/STextBlock.h"
#include "Widgets/SBoxPanel.h"
#include "Widgets/SMediaPermutationsSelector.h"
#include "Widgets/SNullWidget.h"
#include "Widgets/SWindow.h"
#define LOCTEXT_NAMESPACE "AjaMediaTimecodeReferenceCustomization"
namespace AjaMediaTimecodeReferenceCustomization
{
static const FName NAME_DeviceIndex("DeviceIndex");
static const FName NAME_LtcIndex("ReferenceLtcIndex");
static const FName NAME_FrameRate("ReferenceFrameRate");
struct FMediaTimecodePermutationsSelectorBuilder
{
static bool IdenticalProperty(FName ColumnName, const FAjaMediaTimecodeReference& Left, const FAjaMediaTimecodeReference& Right)
{
if (ColumnName == NAME_DeviceIndex) return Left.Device.DeviceIdentifier == Right.Device.DeviceIdentifier;
if (ColumnName == NAME_LtcIndex) return Left.LtcIndex == Right.LtcIndex;
if (ColumnName == NAME_FrameRate) return Left.LtcFrameRate == Right.LtcFrameRate;
check(false);
return false;
}
static bool Less(FName ColumnName, const FAjaMediaTimecodeReference& Left, const FAjaMediaTimecodeReference& Right)
{
if (ColumnName == NAME_DeviceIndex) return Left.Device.DeviceIdentifier < Right.Device.DeviceIdentifier;
if (ColumnName == NAME_LtcIndex) return Left.LtcIndex < Right.LtcIndex;
if (ColumnName == NAME_FrameRate) return Left.LtcFrameRate.AsDecimal() < Right.LtcFrameRate.AsDecimal();
check(false);
return false;
}
static FText GetLabel(FName ColumnName, const FAjaMediaTimecodeReference& Item)
{
if (ColumnName == NAME_DeviceIndex) return FText::FromName(Item.Device.DeviceName);
if (ColumnName == NAME_LtcIndex) return FText::AsNumber(Item.LtcIndex);
if (ColumnName == NAME_FrameRate) return Item.LtcFrameRate.ToPrettyText();
check(false);
return FText::GetEmpty();
}
static FText GetTooltip(FName ColumnName, const FAjaMediaTimecodeReference& Item)
{
if (ColumnName == NAME_DeviceIndex) return FText::FromString(FString::Printf(TEXT("%s as index: %d"), *Item.Device.DeviceName.ToString(), Item.Device.DeviceIdentifier));
if (ColumnName == NAME_LtcIndex) return LOCTEXT("ReferenceLtcIndexTooltip", "The LTC index to read from the reference pin.");
if (ColumnName == NAME_FrameRate)
{
if (const FCommonFrameRateInfo* Found = FCommonFrameRates::Find(Item.LtcFrameRate))
{
return Found->Description;
}
return Item.LtcFrameRate.ToPrettyText();
}
check(false);
return FText::GetEmpty();
}
};
}
TAttribute<FText> FAjaMediaTimecodeReferenceCustomization::GetContentText()
{
FAjaMediaTimecodeReference* Value = GetPropertyValueFromPropertyHandle<FAjaMediaTimecodeReference>();
return MakeAttributeLambda([=] { return Value->ToText(); });
}
TSharedRef<SWidget> FAjaMediaTimecodeReferenceCustomization::HandleSourceComboButtonMenuContent()
{
PermutationSelector.Reset();
SelectedConfiguration = *GetPropertyValueFromPropertyHandle<FAjaMediaTimecodeReference>();
TArray<FAjaMediaTimecodeReference> MediaConfigurations = FAjaDeviceProvider().GetTimecodeReferences();
if (MediaConfigurations.Num() == 0)
{
return SNew(STextBlock)
.Text(LOCTEXT("NoConfigurationFound", "No configuration found"));
}
using TSelection = SMediaPermutationsSelector<FAjaMediaTimecodeReference, AjaMediaTimecodeReferenceCustomization::FMediaTimecodePermutationsSelectorBuilder>;
TSharedRef<TSelection> Selector = SNew(TSelection)
.PermutationsSource(MoveTemp(MediaConfigurations))
.SelectedPermutation(SelectedConfiguration)
.OnSelectionChanged(this, &FAjaMediaTimecodeReferenceCustomization::OnSelectionChanged)
.OnButtonClicked(this, &FAjaMediaTimecodeReferenceCustomization::OnButtonClicked)
+ TSelection::Column(AjaMediaTimecodeReferenceCustomization::NAME_DeviceIndex)
.Label(LOCTEXT("DeviceLabel", "Device"))
+ TSelection::Column(AjaMediaTimecodeReferenceCustomization::NAME_LtcIndex)
.Label(LOCTEXT("LtcIndexLabel", "LTC Index"))
+ TSelection::Column(AjaMediaTimecodeReferenceCustomization::NAME_FrameRate)
.Label(LOCTEXT("FrameRateLabel", "Frame Rate"));
PermutationSelector = Selector;
return Selector;
}
void FAjaMediaTimecodeReferenceCustomization::OnSelectionChanged(FAjaMediaTimecodeReference SelectedItem)
{
SelectedConfiguration = SelectedItem;
}
FReply FAjaMediaTimecodeReferenceCustomization::OnButtonClicked() const
{
AssignValue(SelectedConfiguration);
TSharedPtr<SWidget> SharedPermutationSelector = PermutationSelector.Pin();
if (SharedPermutationSelector.IsValid())
{
TSharedRef<SWindow> ParentContextMenuWindow = FSlateApplication::Get().FindWidgetWindow(SharedPermutationSelector.ToSharedRef()).ToSharedRef();
FSlateApplication::Get().RequestDestroyWindow(ParentContextMenuWindow);
}
return FReply::Handled();
}
#undef LOCTEXT_NAMESPACE
| 39.522727
| 172
| 0.797968
|
ue4plugins
|
8c02ee6e7f8209a9cbb128bd793491c07123ba65
| 2,343
|
hpp
|
C++
|
lib/winss/path_mutex.hpp
|
taylorb-microsoft/winss
|
ede93f84a5d9585502db5190f2ec6365858f695a
|
[
"Apache-2.0"
] | 52
|
2017-01-05T23:39:38.000Z
|
2020-06-04T03:00:11.000Z
|
lib/winss/path_mutex.hpp
|
morganstanley/winss
|
ede93f84a5d9585502db5190f2ec6365858f695a
|
[
"Apache-2.0"
] | 24
|
2017-01-05T05:07:34.000Z
|
2018-03-09T00:50:58.000Z
|
lib/winss/path_mutex.hpp
|
morganstanley/winss
|
ede93f84a5d9585502db5190f2ec6365858f695a
|
[
"Apache-2.0"
] | 7
|
2016-12-27T20:55:20.000Z
|
2018-03-09T00:32:19.000Z
|
/*
* Copyright 2016-2017 Morgan Stanley
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef LIB_WINSS_PATH_MUTEX_HPP_
#define LIB_WINSS_PATH_MUTEX_HPP_
#include <windows.h>
#include <filesystem>
#include <string>
namespace fs = std::experimental::filesystem;
namespace winss {
/**
* A global mutex where the key is derived from a file path and service name.
*/
class PathMutex {
protected:
std::string mutex_name; /**< The service name. */
HANDLE lock = nullptr; /**< A handle to the Windows mutex. */
PathMutex() {} /**< Hide the default constructor. */
public:
/**
* Create a path mutex with a path and a name.
*
* \param path The path under lock.
* \param name The name of the service.
*/
PathMutex(fs::path path, std::string name);
PathMutex(const PathMutex&) = delete; /**< No copy. */
PathMutex(PathMutex&&) = delete; /**< No move. */
/**
* Attempts to get the mutex.
*
* \return True if getting the mutex was successful otherwise false.
*/
virtual bool Lock();
/**
* Checks if the lock will fail or not.
*
* \return True if getting the mutex will be successful otherwise false.
*/
virtual bool CanLock() const;
/**
* Checks if this instance owns the lock.
*
* \return True if this instance owns the lock otherwise false.
*/
virtual bool HasLock() const;
/**
* Gets the name of the service.
*
* \return The name of the service.
*/
virtual const std::string& GetName() const;
PathMutex& operator=(const PathMutex&) = delete; /**< No copy. */
PathMutex& operator=(PathMutex&&) = delete; /**< No move. */
virtual ~PathMutex(); /**< Default destructor. */
};
} // namespace winss
#endif // LIB_WINSS_PATH_MUTEX_HPP_
| 27.564706
| 77
| 0.649595
|
taylorb-microsoft
|
22c82ef44310e1ea6020188d36e266daecba58f2
| 4,889
|
cpp
|
C++
|
MSCKF/main.cpp
|
michael-fonder/fonder_thesis-2016
|
59631865169857f935a52ffd89a07243fe00e7d1
|
[
"MIT"
] | 26
|
2016-09-22T08:41:10.000Z
|
2022-02-17T02:49:45.000Z
|
MSCKF/main.cpp
|
michael-fonder/fonder_thesis-2016
|
59631865169857f935a52ffd89a07243fe00e7d1
|
[
"MIT"
] | 4
|
2016-09-06T11:25:16.000Z
|
2018-05-31T12:29:50.000Z
|
MSCKF/main.cpp
|
michael-fonder/fonder_thesis-2016
|
59631865169857f935a52ffd89a07243fe00e7d1
|
[
"MIT"
] | 19
|
2016-08-30T07:17:51.000Z
|
2018-11-08T07:29:18.000Z
|
/**
* Author : Michael Fonder
* Year : 2016
**/
#include <iostream>
#include <sstream>
#include <time.h>
#include <stdio.h>
#include <stdint.h>
#include <math.h>
#include <Eigen/Dense>
#include <Eigen/QR>
#include <Eigen/Dense>
#include <Eigen/Eigen>
#include <Eigen/Sparse>
#include <unordered_map>
#include <unordered_set>
#include <set>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/video/video.hpp>
#include "dynamicVectorContainer.hpp"
#include "dynamicVectorReference.hpp"
#include "imuState.hpp"
#include "MSCKF.hpp"
#ifndef _CRT_SECURE_NO_WARNINGS
# define _CRT_SECURE_NO_WARNINGS
#endif
using namespace cv;
using namespace std;
int main(int argc, char* argv[])
{
FileStorage fs;
Mat distCoeffs;
Mat cameraMatrix;
//******************************************************************************
string filename = "distCoeffs";
fs.open(filename+".yml", FileStorage::READ);
fs[filename] >> distCoeffs;
filename = "cameraMatrix";
fs.open(filename+".yml", FileStorage::READ);
fs[filename] >> cameraMatrix;
filename = "featurePos";
fs.open(filename+".yml", FileStorage::READ);
Mat featurePos;
fs[filename] >> featurePos;
cout <<featurePos << endl;
filename = "data";
fs.open(filename+".yml", FileStorage::READ);
Mat data;
fs[filename] >> data;
cout << filename+".yml" << endl;
data = data.t();
Mat ba, bg, IMU_noise, p_CI, q_CI, MSCKF_params, init_uncertainty;
filename = "parameters";
fs.open(filename+".yml", FileStorage::READ);
fs["ba"] >> ba;
fs["bg"] >> bg;
fs["IMU_noise"] >> IMU_noise;
fs["init_uncertainty"] >> init_uncertainty;
fs["p_CI"] >> p_CI;
fs["q_CI"] >> q_CI;
fs["MSCKF_params"] >> MSCKF_params;
cout << filename+".yml" << endl;
cout << ba << bg << IMU_noise << p_CI << q_CI << MSCKF_params << endl;
Measurement newMeasurement;
IMUstate imustate;
cout << "datatestbegin *********************************" << endl;
VideoCapture capture("flight_cut.avi"); // attempt to open it as a video file or image sequence
// VideoCapture capture("test_syn.avi"); // attempt to open it as a video file or image sequence
if (!capture.isOpened()){ // returns true if video capturing has been initialized already
cerr << "Failed to open the video file or image sequence...\n" << endl;
return 1;
}
Mat frame;
bool finished = false;
size_t timeIMU=0, timeVideo=0;
MSCKF filter;
filter.trueFeaturesPos = featurePos;
filter.camera.distCoeffs = distCoeffs;
filter.camera.intrisic = cameraMatrix;
filter.setCameraParams(p_CI, q_CI);
filter.setFilterParams(MSCKF_params);
ba.copyTo(filter.imustate->ba);
bg.copyTo(filter.imustate->bg);
filter.imustate->setQ(IMU_noise);
filter.imustate->resetCovar(init_uncertainty);
capture >> frame;
Mat log_p = Mat::zeros(1,6,CV_32FC1);
Mat local = Mat::zeros(1,6,CV_32FC1);
Mat log_q = Mat::zeros(1,7,CV_32FC1);
Mat localq = Mat::zeros(1,7,CV_32FC1);
while(!finished)
{
capture >> frame;
if (frame.empty())
{
finished = true;
continue;
}
// if(timeVideo > 150)
// break;
while(float(timeIMU)*0.01 <= float(timeVideo)/30)
{
// data.rowRange(6,9).col(timeIMU).copyTo(filter.truePos);
// data.rowRange(9,13).col(timeIMU).copyTo(filter.trueQuat);
data.rowRange(0,3).col(timeIMU).copyTo(newMeasurement.a_I);
//newMeasurement.a_I.row(0) *= -1;
data.rowRange(3,6).col(timeIMU).copyTo(newMeasurement.omega);
//newMeasurement.omega.rowRange(0,2)*=-1.0;
filter.propagateIMUStateAndCovar(newMeasurement, float(timeIMU)*0.01);
local.colRange(0,3) = filter.imustate->p_G.t();
local.at<float>(0,3) = filter.imustate->covar.at<float>(12,12);
local.at<float>(0,4) = filter.imustate->covar.at<float>(13,13);
local.at<float>(0,5) = filter.imustate->covar.at<float>(14,14);
log_p.push_back(local);
localq.colRange(0,4) = filter.imustate->q_IG.t();
localq.at<float>(0,4) = filter.imustate->covar.at<float>(0,0);
localq.at<float>(0,5) = filter.imustate->covar.at<float>(1,1);
localq.at<float>(0,6) = filter.imustate->covar.at<float>(2,2);
log_q.push_back(localq);
++timeIMU;
}
cvtColor(frame, frame, CV_BGR2GRAY);
if(!(timeVideo%2))
{
cout << "augment " << timeVideo << endl;
filter.augmentState(frame, float(timeVideo)/30);
cout << "correct " << timeVideo << endl;
filter.update();
}
++timeVideo;
FileStorage logFilep("log_p.yml", FileStorage::WRITE);
logFilep << "log_p" << log_p;
FileStorage logFileq("log_q.yml", FileStorage::WRITE);
logFileq << "log_q" << log_q;
FileStorage covar_IMU("covar_IMU.yml", FileStorage::WRITE);
covar_IMU << "covar_IMU" << filter.imustate->covar;
cout << "Estimated attitude : " << filter.getOrientation().t() << endl;
cout << "Estimated position : " << filter.getPosition().t() << endl;
}
cout << filter.getPosition() << endl;
return 0;
}
| 28.097701
| 96
| 0.662508
|
michael-fonder
|
22c8d95d29f3ea36be36b7a7b2ab2de711502728
| 34,115
|
cpp
|
C++
|
src/map/map_solver_project_between.cpp
|
ptrmu/camsim
|
2d79bf2eff32a33aca81cc205cb9256937abcbed
|
[
"BSD-3-Clause"
] | 1
|
2020-12-12T16:51:58.000Z
|
2020-12-12T16:51:58.000Z
|
src/map/map_solver_project_between.cpp
|
ptrmu/camsim
|
2d79bf2eff32a33aca81cc205cb9256937abcbed
|
[
"BSD-3-Clause"
] | null | null | null |
src/map/map_solver_project_between.cpp
|
ptrmu/camsim
|
2d79bf2eff32a33aca81cc205cb9256937abcbed
|
[
"BSD-3-Clause"
] | null | null | null |
#include "map_run.hpp"
#include "map_solver_runner.hpp"
#include <gtsam/geometry/Cal3DS2.h>
#include <gtsam/geometry/PinholeCamera.h>
#include <gtsam/nonlinear/DoglegOptimizer.h>
#include <gtsam/nonlinear/ISAM2.h>
#include <gtsam/nonlinear/LevenbergMarquardtOptimizer.h>
#include <gtsam/slam/BetweenFactor.h>
#include <opencv2/opencv.hpp>
namespace camsim
{
// ==============================================================================
// ConvertPoints class
// ==============================================================================
struct ConvertPoints
{
template<class TPoint>
static TPoint to_point(const gtsam::Point2 &point2)
{
return TPoint{point2.x(),
point2.y()};
}
template<class TPoint>
static TPoint to_point(const gtsam::Point3 &point3)
{
return TPoint{point3.x(),
point3.y(),
point3.z()};
}
template<class TPointOut, class TPointIn>
static std::vector<TPointOut> points_to_points(const std::vector<TPointIn> &points_in)
{
std::vector<TPointOut> points_out;
for (auto &point_in : points_in) {
points_out.emplace_back(to_point<TPointOut>(point_in));
}
return points_out;
}
};
// ==============================================================================
// ProjectBetweenFactor class
// ==============================================================================
class ProjectBetweenFactor : public gtsam::NoiseModelFactor2<gtsam::Pose3, gtsam::Pose3>
{
const gtsam::Cal3DS2 &cal3ds2_;
const gtsam::Point3 junction_f_board_;
const gtsam::Point2 junction_f_image_;
public:
ProjectBetweenFactor(gtsam::Point2 corner_f_image,
const gtsam::SharedNoiseModel &model,
gtsam::Key marker_key,
gtsam::Point3 corner_f_marker,
gtsam::Key camera_key,
const gtsam::Cal3DS2 &cal3ds2) :
NoiseModelFactor2<gtsam::Pose3, gtsam::Pose3>(model, marker_key, camera_key),
cal3ds2_{cal3ds2},
junction_f_board_(std::move(corner_f_marker)),
junction_f_image_(std::move(corner_f_image))
{}
/// evaluate the error
gtsam::Vector evaluateError(const gtsam::Pose3 &marker_f_world,
const gtsam::Pose3 &camera_f_world,
boost::optional<gtsam::Matrix &> H1,
boost::optional<gtsam::Matrix &> H2) const override
{
// (Hp1 || Hp2) ? boost::optional<Matrix&>(D_hx_1P2) : boost::none)
gtsam::Matrix36 d_point3_wrt_pose3;
gtsam::Matrix26 d_point2_wrt_pose3;
gtsam::Matrix23 d_point2_wrt_point3;
// Transform the point from the Marker frame to the World frame
gtsam::Point3 point_f_world = marker_f_world.transformFrom(
junction_f_board_,
H1 ? gtsam::OptionalJacobian<3, 6>(d_point3_wrt_pose3) : boost::none);
// Project this point to the camera's image frame. Catch and return a default
// value on a CheiralityException.
auto camera = gtsam::PinholeCamera<gtsam::Cal3DS2>{camera_f_world, cal3ds2_};
try {
gtsam::Point2 point_f_image = camera.project(
point_f_world,
H2 ? gtsam::OptionalJacobian<2, 6>(d_point2_wrt_pose3) : boost::none,
H1 ? gtsam::OptionalJacobian<2, 3>(d_point2_wrt_point3) : boost::none);
// Return the Jacobian for each input
if (H1) {
*H1 = d_point2_wrt_point3 * d_point3_wrt_pose3;
}
if (H2) {
*H2 = d_point2_wrt_pose3;
}
// Return the error.
return point_f_image - junction_f_image_;
} catch (gtsam::CheiralityException &e) {
}
if (H1) *H1 = gtsam::Matrix::Zero(2, 6);
if (H2) *H2 = gtsam::Matrix::Zero(2, 6);
return gtsam::Vector2{2.0 * cal3ds2_.px(), 2.0 * cal3ds2_.py()};
}
};
// ==============================================================================
// SolverProjectBetween class
// ==============================================================================
class SolverProjectBetween
{
SolverRunner &sr_;
bool initial_with_truth_;
const boost::shared_ptr<gtsam::Cal3DS2> shared_calibration_;
gtsam::NonlinearFactorGraph graph_{};
gtsam::Values initial_{};
std::vector<std::uint64_t> camera_idxs_{};
#if 0
PoseWithCovariance calc_marker_f_world(const std::vector<gtsam::Point2> &corners_f_image,
const gtsam::Pose3 &marker_f_world_initial,
const gtsam::Pose3 &camera_f_world_initial)
{
gtsam::NonlinearFactorGraph graph{};
gtsam::Values initial{};
// Set up the prior for the marker pose
static auto priorModel = gtsam::noiseModel::Constrained::MixedSigmas(gtsam::Z_6x1);
graph.emplace_shared<gtsam::PriorFactor<gtsam::Pose3> >(CameraModel::default_key(),
camera_f_world_initial,
priorModel);
initial.insert(CameraModel::default_key(), camera_f_world_initial);
// Add factors to the graph
for (size_t j = 0; j < corners_f_image.size(); j += 1) {
graph.emplace_shared<ProjectBetweenFactor>(corners_f_image[j],
sr_.point2_noise_,
MarkerModel::default_key(),
sr_.model_.markers_.corners_f_marker_[j],
CameraModel::default_key(),
*shared_calibration_);
}
// Add the initial estimate for the camera poses
initial.insert(MarkerModel::default_key(), marker_f_world_initial);
// Optimize the graph using Levenberg-Marquardt
auto params = gtsam::LevenbergMarquardtParams();
params.setRelativeErrorTol(1e-8);
params.setAbsoluteErrorTol(1e-8);
auto result = gtsam::LevenbergMarquardtOptimizer(graph, initial, params).optimize();
// std::cout << "initial error = " << graph.error(initial) << std::endl;
// std::cout << "final error = " << graph.error(result) << std::endl;
// return the result
auto marginals_ptr{sr_.get_marginals(graph, result)};
return PoseWithCovariance::Extract(result, marginals_ptr.get(), MarkerModel::default_key());
}
PoseWithCovariance calc_camera_f_world(const std::vector<gtsam::Point2> &corners_f_image,
const gtsam::Pose3 &marker_f_world_initial,
const gtsam::Pose3 &camera_f_world_initial)
{
gtsam::NonlinearFactorGraph graph{};
gtsam::Values initial{};
// Set up the prior for the marker pose
static auto priorModel = gtsam::noiseModel::Constrained::MixedSigmas(gtsam::Z_6x1);
graph.emplace_shared<gtsam::PriorFactor<gtsam::Pose3> >(MarkerModel::default_key(),
marker_f_world_initial,
priorModel);
initial.insert(MarkerModel::default_key(), marker_f_world_initial);
// Add factors to the graph
for (size_t j = 0; j < corners_f_image.size(); j += 1) {
graph.emplace_shared<ProjectBetweenFactor>(corners_f_image[j],
sr_.point2_noise_,
MarkerModel::default_key(),
sr_.model_.markers_.corners_f_marker_[j],
CameraModel::default_key(),
*shared_calibration_);
}
// Add the initial estimate for the camera poses
initial.insert(CameraModel::default_key(), camera_f_world_initial);
// Optimize the graph using Levenberg-Marquardt
auto params = gtsam::LevenbergMarquardtParams();
params.setRelativeErrorTol(1e-8);
params.setAbsoluteErrorTol(1e-8);
auto result = gtsam::LevenbergMarquardtOptimizer(graph, initial, params).optimize();
// std::cout << "initial error = " << graph.error(initial) << std::endl;
// std::cout << "final error = " << graph.error(result) << std::endl;
// return the result
auto marginals_ptr{sr_.get_marginals(graph, result)};
return PoseWithCovariance::Extract(result, marginals_ptr.get(), CameraModel::default_key());
}
#endif
void display_results()
{
// These objects get copy constructed and will sometimes get destructed without
// being "solved". Not quite sure why the RVO doesn't prevent this but it might
// be because the object is passed by the operator() member and not by the
// class itself.
if (graph_.size() < 2) {
return;
}
auto params = gtsam::LevenbergMarquardtParams();
params.setVerbosityLM("TERMINATION");
params.setVerbosity("TERMINATION");
params.setMaxIterations(1000);
params.setRelativeErrorTol(1e-8);
params.setAbsoluteErrorTol(1e-8);
if (!initial_with_truth_) {
std::cout << std::endl << "Solve with noisy initial estimates" << std::endl;
auto result = gtsam::LevenbergMarquardtOptimizer(graph_, initial_, params).optimize();
std::cout << "Frame " << sr_.frames_processed_ << ": " << std::endl;
std::cout << "initial error = " << graph_.error(initial_) << std::endl;
std::cout << "final error = " << graph_.error(result) << std::endl;
auto marginals_slam_ptr{sr_.get_marginals(graph_, result)};
for (auto m : result.filter(gtsam::Symbol::ChrTest('m'))) {
sr_.display_results(PoseWithCovariance::Extract(result, marginals_slam_ptr.get(), m.key));
}
} else {
// Solve this with perfect initial values
gtsam::Values initial;
for (auto camera_idx : camera_idxs_) {
auto &camera{sr_.model_.cameras_.cameras_[camera_idx]};
initial.insert(camera.key_, camera.camera_f_world_);
}
for (auto &marker : sr_.model_.markers_.markers_) {
initial.insert(marker.key_, marker.marker_f_world_);
}
std::cout << std::endl << "Solve with perfect initial estimates" << std::endl;
auto result = gtsam::LevenbergMarquardtOptimizer(graph_, initial, params).optimize();
std::cout << "initial error = " << graph_.error(initial) << std::endl;
std::cout << "final error = " << graph_.error(result) << std::endl;
auto marginals_slam_ptr = sr_.get_marginals(graph_, result);
for (auto m : result.filter(gtsam::Symbol::ChrTest('m'))) {
sr_.display_results(PoseWithCovariance::Extract(result, marginals_slam_ptr.get(), m.key));
}
}
}
public:
explicit SolverProjectBetween(SolverRunner &sr, bool initial_with_truth) :
sr_{sr}, initial_with_truth_{initial_with_truth},
shared_calibration_{boost::make_shared<gtsam::Cal3DS2>(
sr_.model_.cameras_.calibration_.fx(),
sr_.model_.cameras_.calibration_.fy(),
sr_.model_.cameras_.calibration_.skew(),
sr_.model_.cameras_.calibration_.px(),
sr_.model_.cameras_.calibration_.py(),
sr_.model_.cameras_.calibration_.k1(),
sr_.model_.cameras_.calibration_.k2(),
sr_.model_.cameras_.calibration_.p1(),
sr_.model_.cameras_.calibration_.p2())}
{
sr_.add_marker_0_prior(graph_, initial_);
}
~SolverProjectBetween()
{
display_results();
}
#if 0
void operator()(const CameraModel &camera,
const std::vector<MarkerModelRef> &marker_refs)
{
auto camera_key{camera.key_};
for (auto &marker_ref : marker_refs) {
auto marker_key{marker_ref.get().key_};
auto marker_f_world_initial = sr_.get_perturbed_marker_f_world(marker_ref);
auto camera_f_world_initial = sr_.get_perturbed_camera_f_world(camera);
// The marker corners as seen in the image.
auto corners_f_image = sr_.get_corners_f_images(camera, marker_ref);
auto camera_f_world = calc_camera_f_world(corners_f_image,
marker_ref.get().marker_f_world_,
camera_f_world_initial);
auto marker_f_world = calc_marker_f_world(corners_f_image,
marker_f_world_initial,
camera.camera_f_world_);
std::cout << "Camera "
<< PoseWithCovariance::to_str(camera_f_world.pose_) << " "
<< PoseWithCovariance::to_str(camera.camera_f_world_) << std::endl;
std::cout << "Marker "
<< PoseWithCovariance::to_str(marker_f_world.pose_) << " "
<< PoseWithCovariance::to_str(marker_ref.get().marker_f_world_) << std::endl;
}
#else
void operator()(const FrameData &fd)
{
auto camera_key{fd.camera_.key_};
// Add the initial estimate for the camera pose
initial_.insert(camera_key, fd.camera_f_world_perturbed_);
camera_idxs_.push_back(fd.camera_.index());
for (auto &marker_data : fd.marker_datas_) {
auto marker_key{marker_data.marker_.key_};
// The marker corners as seen in the image.
auto &corners_f_image = marker_data.corners_f_image_perturbed_;
// Add factors to the graph
for (size_t j = 0; j < corners_f_image.size(); j += 1) {
graph_.emplace_shared<ProjectBetweenFactor>(corners_f_image[j],
sr_.point2_noise_,
marker_key,
sr_.model_.markers_.corners_f_marker_[j],
camera_key,
*shared_calibration_);
}
// Add the initial estimate for the marker pose
if (!initial_.exists(marker_key)) {
initial_.insert(marker_key, marker_data.marker_f_world_perturbed_);
}
}
#endif
}
};
// ==============================================================================
// SolverProjectBetweenRepeated class
// ==============================================================================
class SolverProjectBetweenRepeated
{
SolverRunner &sr_;
const boost::shared_ptr<gtsam::Cal3DS2> shared_calibration_;
gtsam::NonlinearFactorGraph graph_{};
gtsam::Values initial_{};
gtsam::Values results_{};
void display_results()
{
// These objects get copy constructed and will sometimes get destructed without
// being "solved". Not quite sure why the RVO doesn't prevent this but it might
// be because the object is passed by the operator() member and not by the
// class itself.
if (graph_.size() < 2) {
return;
}
auto params = gtsam::LevenbergMarquardtParams();
params.setVerbosityLM("TERMINATION");
params.setVerbosity("TERMINATION");
params.setRelativeErrorTol(1e-8);
params.setAbsoluteErrorTol(1e-8);
auto result = gtsam::LevenbergMarquardtOptimizer(graph_, initial_, params).optimize();
std::cout << "Frame " << sr_.frames_processed_ << ": " << std::endl;
std::cout << "initial error = " << graph_.error(initial_) << std::endl;
std::cout << "final error = " << graph_.error(result) << std::endl;
auto marginals_slam_ptr{sr_.get_marginals(graph_, result)};
for (auto m : result.filter(gtsam::Symbol::ChrTest('m'))) {
sr_.display_results(PoseWithCovariance::Extract(result, marginals_slam_ptr.get(), m.key));
}
}
public:
explicit SolverProjectBetweenRepeated(SolverRunner &sr) :
sr_{sr}, shared_calibration_{boost::make_shared<gtsam::Cal3DS2>(
sr_.model_.cameras_.calibration_.fx(),
sr_.model_.cameras_.calibration_.fy(),
sr_.model_.cameras_.calibration_.skew(),
sr_.model_.cameras_.calibration_.px(),
sr_.model_.cameras_.calibration_.py(),
sr_.model_.cameras_.calibration_.k1(),
sr_.model_.cameras_.calibration_.k2(),
sr_.model_.cameras_.calibration_.p1(),
sr_.model_.cameras_.calibration_.p2())}
{
sr_.add_marker_0_prior(graph_, initial_);
}
~SolverProjectBetweenRepeated()
{
display_results();
}
void operator()(const FrameData &fd)
{
auto camera_key{fd.camera_.key_};
// Add the initial estimate for the camera pose
initial_.insert(camera_key, fd.camera_f_world_perturbed_);
for (auto &marker_data : fd.marker_datas_) {
auto marker_key{marker_data.marker_.key_};
// The marker corners as seen in the image.
auto &corners_f_image = marker_data.corners_f_image_perturbed_;
// Add factors to the graph
for (size_t j = 0; j < corners_f_image.size(); j += 1) {
graph_.emplace_shared<ProjectBetweenFactor>(corners_f_image[j],
sr_.point2_noise_,
marker_key,
sr_.model_.markers_.corners_f_marker_[j],
camera_key,
*shared_calibration_);
}
// Add the initial estimate for the marker pose
if (!initial_.exists(marker_key)) {
initial_.insert(marker_key, marker_data.marker_f_world_perturbed_);
}
}
#if 1
auto params = gtsam::LevenbergMarquardtParams();
// params.setVerbosityLM("TERMINATION");
// params.setVerbosity("TERMINATION");
params.setRelativeErrorTol(1e-8);
params.setAbsoluteErrorTol(1e-8);
auto results_ = gtsam::LevenbergMarquardtOptimizer(graph_, initial_, params).optimize();
std::cout << "Frame " << sr_.frames_processed_ << ": ";
// std::cout << "initial error = " << graph_.error(initial_) << std::endl;
std::cout << "final error = " << graph_.error(results_) << std::endl;
#else
auto params = gtsam::DoglegParams();
//// params.setVerbosityDL("VERBOSE");
// params.setVerbosity("TERMINATION");
params.setRelativeErrorTol(1e-8);
params.setAbsoluteErrorTol(1e-8);
results_ = gtsam::DoglegOptimizer(graph_, initial_, params).optimize();
std::cout << "Frame " << sr_.frames_processed_ << ": ";
// std::cout << "initial error = " << graph_.error(initial_) << std::endl;
std::cout << "final error = " << graph_.error(results_) << std::endl;
#endif
initial_ = results_;
}
};
// ==============================================================================
// SolverProjectBetweenIsam class
// ==============================================================================
class SolverProjectBetweenIsam
{
SolverRunner &sr_;
const boost::shared_ptr<gtsam::Cal3DS2> shared_calibration_;
gtsam::ISAM2 isam_{get_isam2_params()};
std::map<std::uint64_t, std::uint64_t> marker_seen_counts_{};
static gtsam::ISAM2Params get_isam2_params()
{
gtsam::ISAM2DoglegParams dogleg_params{};
gtsam::ISAM2Params params;
// params.optimizationParams = dogleg_params;
params.factorization = gtsam::ISAM2Params::QR;
params.relinearizeThreshold = 0.01;
params.relinearizeSkip = 1;
return params;
}
void display_results()
{
// These objects get copy constructed and will sometimes get destructed without
// being "solved". Not quite sure why the RVO doesn't prevent this but it might
// be because the object is passed by the operator() member and not by the
// class itself.
if (isam_.empty()) {
return;
}
gtsam::Values bestEstimate = isam_.calculateBestEstimate();
std::cout << "****************************************************" << std::endl;
std::cout << "Frame " << sr_.frames_processed_ << ": " << std::endl;
for (auto m : bestEstimate.filter(gtsam::Symbol::ChrTest('m'))) {
gtsam::Pose3::Jacobian marginal_covariance;
try {
marginal_covariance = isam_.marginalCovariance(m.key);
} catch (gtsam::IndeterminantLinearSystemException &ex) {
marginal_covariance.setZero();
}
sr_.display_results(PoseWithCovariance(m.key, m.value.cast<gtsam::Pose3>(),
marginal_covariance));
}
}
public:
explicit SolverProjectBetweenIsam(SolverRunner &sr) :
sr_{sr}, shared_calibration_{boost::make_shared<gtsam::Cal3DS2>(
sr_.model_.cameras_.calibration_.fx(),
sr_.model_.cameras_.calibration_.fy(),
sr_.model_.cameras_.calibration_.skew(),
sr_.model_.cameras_.calibration_.px(),
sr_.model_.cameras_.calibration_.py(),
sr_.model_.cameras_.calibration_.k1(),
sr_.model_.cameras_.calibration_.k2(),
sr_.model_.cameras_.calibration_.p1(),
sr_.model_.cameras_.calibration_.p2())}
{}
~SolverProjectBetweenIsam()
{
display_results();
}
void operator()(const FrameData &fd)
{
gtsam::NonlinearFactorGraph graph{};
gtsam::Values initial{};
if (sr_.frames_processed_ == 0) {
sr_.add_marker_0_prior(graph, initial);
}
auto camera_key{fd.camera_.key_};
// Add the initial estimate for the camera pose
initial.insert(camera_key, fd.camera_f_world_perturbed_);
for (auto &marker_data : fd.marker_datas_) {
auto marker_key{marker_data.marker_.key_};
// The marker corners as seen in the image.
auto &corners_f_image = marker_data.corners_f_image_perturbed_;
// Add factors to the graph
for (size_t j = 0; j < corners_f_image.size(); j += 1) {
graph.emplace_shared<ProjectBetweenFactor>(corners_f_image[j],
sr_.point2_noise_,
marker_key,
sr_.model_.markers_.corners_f_marker_[j],
camera_key,
*shared_calibration_);
}
// update the marker seen counts
auto pair = marker_seen_counts_.find(marker_key);
if (pair == marker_seen_counts_.end()) {
marker_seen_counts_.insert(std::pair<std::uint64_t, std::uint64_t>{marker_key, 1});
} else {
pair->second += 1;
}
// Add the initial marker value estimate only if this marker has not been seen.
if (pair == marker_seen_counts_.end() && !initial.exists(marker_key)) {
std::cout << "Adding marker " << marker_data.marker_.index()
<< " at frame " << sr_.frames_processed_ + 1 << std::endl;
initial.insert(marker_key, marker_data.marker_f_world_perturbed_);
}
}
// Update iSAM with the new factors
isam_.update(graph, initial);
isam_.update();
}
};
// ==============================================================================
// SolverProjectBetweenOpencv class
// ==============================================================================
class SolverProjectBetweenOpencv
{
SolverRunner &sr_;
const gtsam::Cal3DS2 &cal_;
const boost::shared_ptr<gtsam::Cal3DS2> shared_calibration_;
cv::Mat cv_camera_matrix_;
cv::Mat cv_dist_coeffs_;
std::vector<cv::Point3d> cv_corners_f_marker_;
gtsam::ISAM2 isam_{get_isam2_params()};
std::map<std::uint64_t, std::uint64_t> marker_seen_counts_{};
static gtsam::ISAM2Params get_isam2_params()
{
gtsam::ISAM2Params params;
params.factorization = gtsam::ISAM2Params::QR;
params.relinearizeThreshold = 0.01;
params.relinearizeSkip = 1;
return params;
}
PoseWithCovariance cv_calc_camera_f_marker(const std::vector<gtsam::Point2> &corners_f_image)
{
cv::Vec3d rvec, tvec;
auto cv_corners_f_image{ConvertPoints::points_to_points<cv::Point2d, gtsam::Point2>(corners_f_image)};
// Solve for pose
cv::solvePnP(cv_corners_f_marker_, cv_corners_f_image,
cv_camera_matrix_, cv_dist_coeffs_,
rvec, tvec);
// Convert the result to gtsam world
gtsam::Point3 t(tvec[0], tvec[1], tvec[2]);
cv::Mat rmat;
cv::Rodrigues(rvec, rmat);
gtsam::Matrix3 m;
for (int row = 0; row < 3; row++) {
for (int col = 0; col < 3; col++) {
m(row, col) = rmat.at<double>(row, col); // Row- vs. column-major order
}
}
// return the result. Invert the transform to get camera_f_marker instead of marker_f_camera
return PoseWithCovariance{CameraModel::default_key(), gtsam::Pose3{gtsam::Rot3{m}, t}.inverse(), gtsam::Z_6x6};
}
void add_project_between_factors(gtsam::NonlinearFactorGraph &graph,
gtsam::Key camera_key,
const std::vector<MarkerData> &marker_datas,
std::function<bool(bool, const MarkerData &)> do_add_func)
{
for (auto &marker_data : marker_datas) {
auto marker_key{marker_data.marker_.key_};
// Look for the marker_seen_count record for this marker.
auto pair = marker_seen_counts_.find(marker_key);
// Check that we should add the measurement for this marker.
if (do_add_func(pair != marker_seen_counts_.end(), marker_data)) {
// The marker corners as seen in the image.
auto &corners_f_image = marker_data.corners_f_image_perturbed_;
// Add factors to the graph
for (size_t j = 0; j < corners_f_image.size(); j += 1) {
graph.emplace_shared<ProjectBetweenFactor>(corners_f_image[j],
sr_.point2_noise_,
marker_key,
sr_.model_.markers_.corners_f_marker_[j],
camera_key,
*shared_calibration_);
}
// update the marker seen counts
if (pair == marker_seen_counts_.end()) {
marker_seen_counts_.insert(std::pair<std::uint64_t, std::uint64_t>{marker_key, 1});
} else {
pair->second += 1;
}
}
}
}
std::uint64_t good_marker_seen_counts_{0};
bool good_marker_is_fixed_{false};
const MarkerData *good_marker_data_{nullptr};
void good_marker_start()
{
good_marker_seen_counts_ = 0;
good_marker_is_fixed_ = false;
good_marker_data_ = nullptr;
}
void good_marker_check(const MarkerData &marker_data)
{
if (good_marker_is_fixed_) {
return;
}
// The zero'th marker is the fixed marker and it will always be best
if (marker_data.marker_.key_ == sr_.model_.markers_.markers_[0].key_) {
good_marker_is_fixed_ = true;
good_marker_data_ = &marker_data;
return;
}
// Otherwise the best marker is the one that has been seen the most.
auto pair = marker_seen_counts_.find(marker_data.marker_.key_);
assert(pair != marker_seen_counts_.end()); // This should always be found
if (pair->second > good_marker_seen_counts_) {
good_marker_data_ = &marker_data;
good_marker_seen_counts_ = pair->second;
}
}
const MarkerData *good_marker()
{
return good_marker_data_;
}
void display_results()
{
// These objects get copy constructed and will sometimes get destructed without
// being "solved". Not quite sure why the RVO doesn't prevent this but it might
// be because the object is passed by the operator() member and not by the
// class itself.
if (isam_.size() < 2) {
return;
}
gtsam::Values bestEstimate = isam_.calculateBestEstimate();
std::cout << "****************************************************" << std::endl;
std::cout << "Frame " << sr_.frames_processed_ << ": " << std::endl;
for (auto m : bestEstimate.filter(gtsam::Symbol::ChrTest('m'))) {
gtsam::Pose3::Jacobian marginal_covariance;
try {
marginal_covariance = isam_.marginalCovariance(m.key);
} catch (gtsam::IndeterminantLinearSystemException &ex) {
marginal_covariance.setZero();
}
sr_.display_results(PoseWithCovariance(m.key, m.value.cast<gtsam::Pose3>(),
marginal_covariance));
}
}
public:
explicit SolverProjectBetweenOpencv(SolverRunner &sr) :
sr_{sr}, cal_{sr_.model_.cameras_.calibration_},
shared_calibration_{boost::make_shared<gtsam::Cal3DS2>(
cal_.fx(), cal_.fy(), cal_.skew(),
cal_.px(), cal_.py(),
cal_.k1(), cal_.k2(),
cal_.p1(), cal_.p2())},
cv_camera_matrix_{(cv::Mat_<double>(3, 3)
<< cal_.fx(), cal_.skew(), cal_.px(),
0, cal_.fy(), cal_.py(),
0, 0, 1)},
cv_dist_coeffs_{(cv::Mat_<double>(4, 1)
<< cal_.k1(), cal_.k2(),
cal_.p1(), cal_.p2())},
cv_corners_f_marker_{
ConvertPoints::points_to_points<cv::Point3d, gtsam::Point3>(sr_.model_.markers_.corners_f_marker_)}
{
// Initialize the isam with the fixed prior
gtsam::NonlinearFactorGraph graph{};
gtsam::Values initial{};
// Add the fixed marker to the graph.
sr_.add_marker_0_prior(graph, initial);
marker_seen_counts_.insert(std::pair<std::uint64_t, std::uint64_t>{sr_.model_.markers_.markers_[0].key_, 1});
isam_.update(graph, initial);
}
~SolverProjectBetweenOpencv()
{
display_results();
}
void operator()(const FrameData &fd)
{
auto camera_key{fd.camera_.key_};
bool unknown_exist{false};
{ // First pass through the markers for those that have been seen already
gtsam::NonlinearFactorGraph graph{};
gtsam::Values initial{};
// Prepare for the best marker search.
good_marker_start();
auto do_func = [this, &unknown_exist](bool known_marker, const MarkerData &marker_data) -> bool
{
if (known_marker) {
good_marker_check(marker_data);
} else {
unknown_exist = true;
}
return known_marker;
};
add_project_between_factors(graph, camera_key, fd.marker_datas_, do_func);
// If there is no good marker (if there are no known markers) then just return.
if (good_marker() == nullptr) {
return;
}
// Find the camera pose relative to a good marker using the image points
auto cv_camera_f_best_marker = cv_calc_camera_f_marker(good_marker()->corners_f_image_);
// Get the latest estimate of the good marker location from the isam solver
auto best_marker_f_world = isam_.calculateEstimate<gtsam::Pose3>(good_marker()->marker_.key_);
// Calculate the good estimate of camera_f_world and set as the initial value.
auto camera_f_world_good = best_marker_f_world * cv_camera_f_best_marker.pose_.inverse();
initial.insert(camera_key, camera_f_world_good);
// Update iSAM with the factors for known markers.
isam_.update(graph, initial);
isam_.update();
}
if (unknown_exist) {
// Second pass through the markers for those that have not been seen yet
gtsam::NonlinearFactorGraph graph{};
gtsam::Values initial{};
// Get the latest estimate of the camera location
auto camera_f_world_latest = isam_.calculateEstimate<gtsam::Pose3>(camera_key);
auto do_func = [this, &initial, camera_f_world_latest](bool known_marker,
const MarkerData &marker_data) -> bool
{
if (!known_marker && !initial.exists(marker_data.marker_.key_)) {
auto cv_camera_f_marker = cv_calc_camera_f_marker(marker_data.corners_f_image_);
auto marker_f_world = camera_f_world_latest * cv_camera_f_marker.pose_.inverse();
initial.insert(marker_data.marker_.key_, marker_f_world);
std::cout << "Added marker " << marker_data.marker_.index()
<< " at frame " << sr_.frames_processed_ + 1 << " "
<< PoseWithCovariance::to_str(marker_f_world) << std::endl;
}
return !known_marker;
};
add_project_between_factors(graph, camera_key, fd.marker_datas_, do_func);
// Update iSAM with the new factors to unknown markers
isam_.update(graph, initial);
isam_.update();
}
}
};
std::function<void(const FrameData &)>
solver_project_between_factory(SolverRunner &sr, bool initial_with_truth)
{
return SolverProjectBetween(sr, initial_with_truth);
}
std::function<void(const FrameData &)>
solver_project_between_repeated_factory(SolverRunner &sr)
{
return SolverProjectBetweenRepeated(sr);
}
std::function<void(const FrameData &)>
solver_project_between_isam_factory(SolverRunner &sr)
{
return SolverProjectBetweenIsam(sr);
}
std::function<void(const FrameData &)>
solver_project_between_opencv_factory(SolverRunner &sr)
{
return SolverProjectBetweenOpencv(sr);
}
}
| 38.548023
| 117
| 0.584904
|
ptrmu
|
22ce77d65cf91f2ddb5ab0b8ab45d169dd3b3d71
| 506
|
hpp
|
C++
|
plugins/openal/include/sge/openal/funcs/alc_create_context.hpp
|
cpreh/spacegameengine
|
313a1c34160b42a5135f8223ffaa3a31bc075a01
|
[
"BSL-1.0"
] | 2
|
2016-01-27T13:18:14.000Z
|
2018-05-11T01:11:32.000Z
|
plugins/openal/include/sge/openal/funcs/alc_create_context.hpp
|
cpreh/spacegameengine
|
313a1c34160b42a5135f8223ffaa3a31bc075a01
|
[
"BSL-1.0"
] | null | null | null |
plugins/openal/include/sge/openal/funcs/alc_create_context.hpp
|
cpreh/spacegameengine
|
313a1c34160b42a5135f8223ffaa3a31bc075a01
|
[
"BSL-1.0"
] | 3
|
2018-05-11T01:11:34.000Z
|
2021-04-24T19:47:45.000Z
|
// Copyright Carl Philipp Reh 2006 - 2019.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef SGE_OPENAL_FUNCS_ALC_CREATE_CONTEXT_HPP_INCLUDED
#define SGE_OPENAL_FUNCS_ALC_CREATE_CONTEXT_HPP_INCLUDED
#include <sge/openal/alc.hpp>
#include <fcppt/reference_fwd.hpp>
namespace sge::openal::funcs
{
ALCcontext *alc_create_context(fcppt::reference<ALCdevice>);
}
#endif
| 25.3
| 61
| 0.762846
|
cpreh
|
22d0192686fdc48a6c6af68d71821f0a2e92e02a
| 2,901
|
cpp
|
C++
|
aws-cpp-sdk-wellarchitected/source/model/ChoiceReason.cpp
|
perfectrecall/aws-sdk-cpp
|
fb8cbebf2fd62720b65aeff841ad2950e73d8ebd
|
[
"Apache-2.0"
] | 1
|
2022-02-10T08:06:54.000Z
|
2022-02-10T08:06:54.000Z
|
aws-cpp-sdk-wellarchitected/source/model/ChoiceReason.cpp
|
perfectrecall/aws-sdk-cpp
|
fb8cbebf2fd62720b65aeff841ad2950e73d8ebd
|
[
"Apache-2.0"
] | 1
|
2022-01-03T23:59:37.000Z
|
2022-01-03T23:59:37.000Z
|
aws-cpp-sdk-wellarchitected/source/model/ChoiceReason.cpp
|
ravindra-wagh/aws-sdk-cpp
|
7d5ff01b3c3b872f31ca98fb4ce868cd01e97696
|
[
"Apache-2.0"
] | 1
|
2022-02-28T21:36:42.000Z
|
2022-02-28T21:36:42.000Z
|
/**
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
* SPDX-License-Identifier: Apache-2.0.
*/
#include <aws/wellarchitected/model/ChoiceReason.h>
#include <aws/core/utils/HashingUtils.h>
#include <aws/core/Globals.h>
#include <aws/core/utils/EnumParseOverflowContainer.h>
using namespace Aws::Utils;
namespace Aws
{
namespace WellArchitected
{
namespace Model
{
namespace ChoiceReasonMapper
{
static const int OUT_OF_SCOPE_HASH = HashingUtils::HashString("OUT_OF_SCOPE");
static const int BUSINESS_PRIORITIES_HASH = HashingUtils::HashString("BUSINESS_PRIORITIES");
static const int ARCHITECTURE_CONSTRAINTS_HASH = HashingUtils::HashString("ARCHITECTURE_CONSTRAINTS");
static const int OTHER_HASH = HashingUtils::HashString("OTHER");
static const int NONE_HASH = HashingUtils::HashString("NONE");
ChoiceReason GetChoiceReasonForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == OUT_OF_SCOPE_HASH)
{
return ChoiceReason::OUT_OF_SCOPE;
}
else if (hashCode == BUSINESS_PRIORITIES_HASH)
{
return ChoiceReason::BUSINESS_PRIORITIES;
}
else if (hashCode == ARCHITECTURE_CONSTRAINTS_HASH)
{
return ChoiceReason::ARCHITECTURE_CONSTRAINTS;
}
else if (hashCode == OTHER_HASH)
{
return ChoiceReason::OTHER;
}
else if (hashCode == NONE_HASH)
{
return ChoiceReason::NONE;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<ChoiceReason>(hashCode);
}
return ChoiceReason::NOT_SET;
}
Aws::String GetNameForChoiceReason(ChoiceReason enumValue)
{
switch(enumValue)
{
case ChoiceReason::OUT_OF_SCOPE:
return "OUT_OF_SCOPE";
case ChoiceReason::BUSINESS_PRIORITIES:
return "BUSINESS_PRIORITIES";
case ChoiceReason::ARCHITECTURE_CONSTRAINTS:
return "ARCHITECTURE_CONSTRAINTS";
case ChoiceReason::OTHER:
return "OTHER";
case ChoiceReason::NONE:
return "NONE";
default:
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
}
return {};
}
}
} // namespace ChoiceReasonMapper
} // namespace Model
} // namespace WellArchitected
} // namespace Aws
| 31.532609
| 110
| 0.620131
|
perfectrecall
|
22d0cf59a1f45904ce07d85ef5fc846416d07704
| 1,534
|
cpp
|
C++
|
EU4toV2/Source/EU4World/Regions/Area.cpp
|
Nyarukocqc/EU4toVic2
|
8cbe79e3e4b1fa8c35064a1f13a1674b0e87306d
|
[
"MIT"
] | 2
|
2020-01-02T16:07:51.000Z
|
2020-01-12T17:55:13.000Z
|
EU4toV2/Source/EU4World/Regions/Area.cpp
|
Nyarukocqc/EU4toVic2
|
8cbe79e3e4b1fa8c35064a1f13a1674b0e87306d
|
[
"MIT"
] | 3
|
2020-01-12T19:44:56.000Z
|
2020-01-17T05:40:41.000Z
|
EU4toV2/Source/EU4World/Regions/Area.cpp
|
Nyarukocqc/EU4toVic2
|
8cbe79e3e4b1fa8c35064a1f13a1674b0e87306d
|
[
"MIT"
] | 1
|
2020-01-12T17:55:40.000Z
|
2020-01-12T17:55:40.000Z
|
/*Copyright (c) 2019 The Paradox Game Converters Project
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.*/
#include "Area.h"
#include "Log.h"
#include <fstream>
#include <functional>
EU4::area::area(std::istream& theStream)
{
registerKeyword(std::regex("color"), [this](const std::string & colorToken, std::istream & areaFile)
{
commonItems::Color newColor(areaFile);
}
);
registerKeyword(std::regex("[0-9]+"), [this](const std::string & number, std::istream & theStream) {
provinces.insert(std::stoi(number));
});
parseStream(theStream);
}
| 35.674419
| 101
| 0.767275
|
Nyarukocqc
|
22d5384f06ffddfb287bfb0791453e7f3f570e19
| 386
|
cpp
|
C++
|
src/os/real_os_functions.cpp
|
juruen/cavalieri
|
c3451579193fc8f081b6228ae295b463a0fd23bd
|
[
"MIT"
] | 54
|
2015-01-14T21:11:56.000Z
|
2021-06-27T13:29:40.000Z
|
src/os/real_os_functions.cpp
|
juruen/cavalieri
|
c3451579193fc8f081b6228ae295b463a0fd23bd
|
[
"MIT"
] | null | null | null |
src/os/real_os_functions.cpp
|
juruen/cavalieri
|
c3451579193fc8f081b6228ae295b463a0fd23bd
|
[
"MIT"
] | 10
|
2015-07-15T05:09:34.000Z
|
2019-01-10T07:32:02.000Z
|
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <real_os_functions.h>
ssize_t real_os_functions::recv(int fd, void *buf, size_t len, int flags) {
return ::recv(fd, buf, len, flags);
}
ssize_t real_os_functions::write(int fd, void *buf, size_t count) {
return ::write(fd, buf, count);
}
real_os_functions real_os;
os_functions g_os_functions(real_os);
| 24.125
| 75
| 0.73057
|
juruen
|
22d697183637dd0983153f1e99655ce18452c836
| 14,005
|
cpp
|
C++
|
src/ledger_rest.cpp
|
chadvoegele/ledger-rest
|
23a920a57964c9f7e987c5d2d9f72eba3dc89c1e
|
[
"BSD-3-Clause"
] | null | null | null |
src/ledger_rest.cpp
|
chadvoegele/ledger-rest
|
23a920a57964c9f7e987c5d2d9f72eba3dc89c1e
|
[
"BSD-3-Clause"
] | null | null | null |
src/ledger_rest.cpp
|
chadvoegele/ledger-rest
|
23a920a57964c9f7e987c5d2d9f72eba3dc89c1e
|
[
"BSD-3-Clause"
] | null | null | null |
//
// Copyright (c) 2015-2020 Chad Voegele
// 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.
// * The name of Chad Voegele may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
#include <unordered_map>
#include <sstream>
#include <stdexcept>
#include <fstream>
#include "ledger_rest.h"
#include "uri_parser.h"
#include "json_parser.h"
namespace ledger_rest {
typedef ledger_rest::post_result post_result;
ledger_rest::ledger_rest(ledger_rest_args& args, logger& logger)
: ledger_file(args.get_ledger_file_path()), lr_logger(logger), is_file_loaded(false), http_prefix(args.get_ledger_rest_prefix()) {
}
template<typename T>
std::string ledger_rest::to_string(const std::list<T>& v) {
std::stringstream s;
s << '[';
bool first = true;
for (const auto& e : v) {
if (first) {
s << e;
first = false;
} else {
s << ',' << e;
}
}
s << ']';
return s.str();
}
std::list<post_result> ledger_rest::run_register(
std::list<std::string> args, std::list<std::string> query) {
try {
return run_register_or_throw(args, query);
} catch (const std::exception& e) {
lr_logger.log(5, e.what());
lr_logger.log(5, to_string(args));
lr_logger.log(5, to_string(query));
} catch (...) {
lr_logger.log(5, "Unknown error while respond to request:");
lr_logger.log(5, to_string(args));
lr_logger.log(5, to_string(query));
}
std::list<post_result> empty;
return empty;
}
std::list<post_result> ledger_rest::run_register_or_throw(
std::list<std::string> args, std::list<std::string> query) {
ledger::report_t report(*session_ptr);
ledger::scope_t::default_scope = &report;
args = ledger::process_arguments(args, report);
report.normalize_options("register");
ledger::call_scope_t query_args(report);
for(std::string str : query) {
query_args.push_back(ledger::string_value(str));
}
if (query_args.size() > 0)
report.parse_query_args(query_args.value(), "#r");
post_capturer* capturer = new post_capturer();
boost::shared_ptr<ledger::item_handler<ledger::post_t> > post_capturer_ptr(capturer);
report.posts_report(post_capturer_ptr);
std::list<post_result> results(capturer->get_post_results());
return results;
}
std::string ledger_rest::to_json(post_result posts) {
std::stringstream ss;
ss << setiosflags(std::ios_base::fixed);
ss << std::setprecision(2);
ss << "{";
ss << "\"amount\" : ";
ss << posts.amount;
ss << ", ";
ss << "\"total\" : ";
ss << posts.total;
ss << ", ";
ss << "\"date\" : ";
ss << "\"" << boost::gregorian::to_iso_extended_string(posts.date) << "\"";
ss << ", ";
ss << "\"payee\" : ";
ss << "\"" << posts.payee << "\"";
ss << ", ";
ss << "\"account_name\" : ";
ss << "\"" << posts.account_name << "\"";
ss << "}";
std::string json = ss.str();
return json;
}
template<typename T>
std::string ledger_rest::to_json(std::list<T> x, std::function<std::string(T)> to_json) {
std::stringstream ss;
ss << "[";
typename std::list<T>::const_iterator iter;
for (iter = x.cbegin(); iter != x.end(); iter++) {
if (iter == x.cbegin()) {
ss << to_json(*iter);
} else {
ss << ", ";
ss << to_json(*iter);
}
}
ss << "]";
std::string json = ss.str();
return json;
}
std::string ledger_rest::to_json(std::list<post_result> posts) {
std::string (*to_json_ptr)(post_result) = to_json;
std::function<std::string(post_result)> to_json_fn = to_json_ptr;
std::string json(to_json(posts, to_json_fn));
return json;
}
std::string ledger_rest::to_json(std::list<std::string> accounts) {
std::function<std::string(std::string)> to_json_fn
= [](std::string s) { return std::string("\"") + s + std::string("\""); };
std::string json(to_json(accounts, to_json_fn));
return json;
}
std::string ledger_rest::to_json(std::list<std::list<post_result>> results) {
std::list<std::string> intermediate_json;
for (auto iter = results.cbegin(); iter != results.cend(); iter++) {
intermediate_json.push_back(to_json(*iter));
}
std::function<std::string(std::string)> to_json_fn
= [](std::string s) { return s; };
std::string json(to_json(intermediate_json, to_json_fn));
return json;
}
std::list<std::string> ledger_rest::get_accounts() {
std::list<std::string> args;
return get_balance_accounts(args);
}
std::list<std::string> ledger_rest::get_balance_accounts(std::list<std::string> args) {
ledger::report_t report(*session_ptr);
ledger::scope_t::default_scope = &report;
ledger::process_arguments(args, report);
report.normalize_options("balance");
ledger::call_scope_t query_args(report);
report.parse_query_args(query_args.value(), "#b");
account_capturer* capturer = new account_capturer();
boost::shared_ptr<ledger::item_handler<ledger::account_t> > account_capturer_ptr(capturer);
report.accounts_report(account_capturer_ptr);
std::list<std::string> results(capturer->get_account_results());
return results;
}
http::response ledger_rest::respond(http::request request) {
http::response bad_response(http::status_code::BAD_REQUEST, std::string(""),
std::map<std::string, std::string>());
// Don't reload eagerly because:
// 1) If journal edits are made rapidly, reloads will be excessive
// 2) Dropbox sync inotify events are hard to follow
// This does introduce some latency on first HTTP request.
if (!is_file_loaded) {
reset_journal();
}
if (is_file_loaded) {
try {
return respond_or_throw(request);
} catch (const std::exception& e) {
lr_logger.log(5, e.what());
lr_logger.log(5, request.to_string());
} catch (...) {
lr_logger.log(5, "Unknown error while respond to request:");
lr_logger.log(5, request.to_string());
}
}
return bad_response;
}
http::response ledger_rest::respond_or_throw(http::request request) {
std::function<http::response(http::status_code)> build_fail = [](http::status_code code) {
http::response res(code, std::string(""),
std::map<std::string, std::string>());
return res;
};
std::function<http::response(std::string)> build_ok = [](std::string s) {
http::response res(http::status_code::OK,
s, std::map<std::string, std::string>());
return res;
};
if (request.method != std::string("GET") &&
request.method != std::string("POST")) {
return build_fail(http::status_code::METHOD_NOT_ALLOWED);
}
std::list<std::string> uri_parts
= ::ledger_rest::split_string(request.url, "/");
std::unordered_map<std::string, std::list<std::string>> uri_args
= ::ledger_rest::mapify_uri_args(request.uri_args);
std::list<std::string> register_request;
std::list<std::string> accounts_request;
if (http_prefix.size() > 0) {
register_request = {"", http_prefix, "report", "register"};
accounts_request = {"", http_prefix, "accounts"};
} else {
register_request = {"", "report", "register"};
accounts_request = {"", "accounts"};
}
if (uri_parts == register_request) {
if (request.method == std::string("GET")) {
if (uri_args.find("query") != uri_args.end()) {
std::list<std::string> args;
if (uri_args.find("args") != uri_args.end()) {
args = uri_args[std::string("args")];
} else {
args = {};
}
std::list<std::string> query = uri_args[std::string("query")];
std::list<post_result> reg(ledger_rest::run_register(args, query));
http::response res = build_ok(to_json(reg));
return res;
} else {
return build_fail(http::status_code::BAD_REQUEST);
}
} else if (request.method == std::string("POST")) {
std::list<std::unordered_map<std::string, std::list<std::string>>> parsed_json =
::ledger_rest::parse_register_request_json(request.upload_data);
std::list<std::list<post_result>> results;
for (auto iter = parsed_json.cbegin(); iter != parsed_json.end(); iter++) {
std::unordered_map<std::string, std::list<std::string>> req = *iter;
std::list<std::string> args = req[std::string("args")];
std::list<std::string> query = req[std::string("query")];
std::list<post_result> reg(ledger_rest::run_register(args, query));
results.push_back(reg);
}
std::string responses_json = to_json(results);
http::response res = build_ok(responses_json);
return res;
} else {
return build_fail(http::status_code::METHOD_NOT_ALLOWED);
}
} else if (request.method == std::string("GET") &&
uri_parts == accounts_request) {
std::list<std::string> accounts(ledger_rest::get_accounts());
http::response res = build_ok(to_json(accounts));
return res;
} else
lr_logger.log(5, "Url not found: " + request.url + " for method: " + request.method);
return build_fail(http::status_code::NOT_FOUND);
}
void ledger_rest::reset_journal() {
try {
reset_journal_or_throw();
} catch (...) {
lr_logger.log(5, "Unable to load ledger file");
is_file_loaded = false;
}
}
void ledger_rest::reset_journal_or_throw() {
session_ptr = std::make_shared<ledger::session_t>();
ledger::set_session_context(session_ptr.get());
ledger::scope_t::default_scope = &empty_scope;
ledger::scope_t::empty_scope = &empty_scope;
session_ptr->read_journal(ledger_file);
is_file_loaded = true;
lr_logger.log(7, "Reloaded ledger file.");
}
void ledger_rest::lazy_reload_journal() {
is_file_loaded = false;
}
std::list<std::string> ledger_rest::get_journal_include_files() {
std::string include_directive("!include ");
std::ifstream ledger_stream(ledger_file, std::ios::in);
std::list<std::string> include_files;
std::string line;
if (ledger_stream.is_open()) {
while (getline(ledger_stream, line)) {
if (line.find(include_directive) == 0) {
std::string include_file = line.substr(include_directive.length());
auto last_slash = ledger_file.find_last_of('/');
// Assume POSIX for absolute path check
if (include_file.at(0) != '/' && last_slash != std::string::npos) {
include_files.push_back(ledger_file.substr(0, 1+last_slash) + include_file);
} else {
include_files.push_back(include_file);
}
}
}
}
return include_files;
}
ledger::value_t ledger_rest::post_capturer::get_total(ledger::post_t& post)
{
if (post.has_xdata() && !post.xdata().total.is_null()) {
return post.xdata().total;
} else if (post.amount.is_null()) {
return 0L;
} else {
return post.amount;
}
}
ledger::value_t ledger_rest::post_capturer::get_amount(ledger::post_t& post)
{
if (post.has_xdata() && post.xdata().has_flags(POST_EXT_COMPOUND)) {
auto value = post.xdata().compound_value;
if (value.value()) {
return value.value();
} else {
return value;
}
} else if (post.amount.is_null()) {
return 0L;
} else {
return post.amount;
}
}
void ledger_rest::post_capturer::operator()(ledger::post_t& post) {
post_result r;
r.amount = get_amount(post).to_amount().to_double();
r.total = get_total(post).value().to_amount().to_double();
r.date = post.xact->date();
ledger::account_t& account(*post.reported_account());
r.account_name = account.fullname();
r.payee = post.payee();
result_capture.push_back(r);
}
std::list<post_result> ledger_rest::post_capturer::get_post_results() {
return result_capture;
}
void ledger_rest::post_capturer::clear() {
result_capture.clear();
ledger::item_handler<ledger::post_t>::clear();
}
void ledger_rest::account_capturer::operator()(ledger::account_t& account) {
if (account.has_xdata()) {
std::string account_name = account.partial_name(true);
result_capture.push_back(account_name);
}
}
void ledger_rest::account_capturer::clear() {
result_capture.clear();
item_handler<ledger::account_t>::clear();
}
std::list<std::string> ledger_rest::account_capturer::get_account_results() {
return result_capture;
}
}
| 32.344111
| 134
| 0.637558
|
chadvoegele
|
22e40f50415059d8cb00e4a6d4e8bdd3c2c127d3
| 4,226
|
cpp
|
C++
|
lib/OneWireHub/src/BAE910.cpp
|
tbuz/ArduinoSensorKit
|
e088fb1a8bd6316664b9fe5354ebc0e2d158b3d0
|
[
"MIT"
] | null | null | null |
lib/OneWireHub/src/BAE910.cpp
|
tbuz/ArduinoSensorKit
|
e088fb1a8bd6316664b9fe5354ebc0e2d158b3d0
|
[
"MIT"
] | null | null | null |
lib/OneWireHub/src/BAE910.cpp
|
tbuz/ArduinoSensorKit
|
e088fb1a8bd6316664b9fe5354ebc0e2d158b3d0
|
[
"MIT"
] | null | null | null |
#include "BAE910.h"
BAE910::BAE910(uint8_t ID1, uint8_t ID2, uint8_t ID3, uint8_t ID4, uint8_t ID5, uint8_t ID6, uint8_t ID7) : OneWireItem(ID1, ID2, ID3, ID4, ID5, ID6, ID7)
{
static_assert(sizeof(memory) < 256, "Implementation does not cover the whole address-space");
extCommand(0xBB); // clear memory
};
void BAE910::extCommand(const uint8_t ecmd, const uint8_t payload_len)
{
if (payload_len >= sizeof (memory)) return;
if (payload_len >= sizeof (scratchpad)) return;
// reserved: // TODO: this is untested and just a good guess
if (ecmd == 0xBB) // 0xBB Erase Firmware
{
memset(&memory.bytes[0], static_cast<uint8_t>(0x00), sizeof(memory.bytes));
}
else if (ecmd == 0xBA) // 0xBA Flash Firmware
{
for (uint8_t i = payload_len; i < sizeof(memory); --i)
{
memory.bytes[0x7F - i] = scratchpad[i];
}
}
};
void BAE910::duty(OneWireHub * const hub)
{
uint8_t cmd, ta1, ta2, len, ecmd; // command, targetAdress, length and extended command
uint16_t crc = 0;
if (hub->recv(&cmd,1,crc)) return;
switch (cmd)
{
case 0x11: // READ VERSION
if (hub->send(&BAE910_SW_VER,1,crc)) return;
if (hub->send(&BAE910_BOOTSTRAP_VER,1,crc)) return;
crc = ~crc;
if (hub->send(reinterpret_cast<uint8_t *>(&crc),2)) return;
break;
case 0x12: // READ TYPE
if (hub->send(&BAE910_DEVICE_TYPE,1,crc)) return;
if (hub->send(&BAE910_CHIP_TYPE,1,crc)) return;
crc = ~crc;
if (hub->send(reinterpret_cast<uint8_t *>(&crc),2)) return;
break;
case 0x13: // EXTENDED COMMAND
if (hub->recv(&ecmd,1,crc)) return;
if (hub->recv(&len ,1,crc)) return;
if (len > BAE910_SCRATCHPAD_SIZE)
{
hub->raiseSlaveError(cmd);
return;
}
if (hub->recv(scratchpad,len,crc)) return;
crc = ~crc;
if (hub->send(reinterpret_cast<uint8_t *>(&crc),2)) return;
// verify answer from master, then execute command
if (hub->recv(&ta1 ,1)) return;
if (ta1 == 0xBC) extCommand(ecmd, len);
break;
case 0x14: // READ MEMORY
if (hub->recv(&ta1,1,crc)) return;
if (hub->recv(&ta2,1,crc)) return;
if (hub->recv(&len,1,crc)) return;
if ((ta1 + len > 0x80) || (ta2 > 0))
{
hub->raiseSlaveError(cmd);
return;
}
// reverse byte order
for (uint8_t i = 0; i < len; ++i)
{
if (hub->send(&memory.bytes[0x7F - ta1 - i],1,crc)) return;
}
crc = ~crc;
if (hub->send(reinterpret_cast<uint8_t *>(&crc),2)) return;
break;
case 0x15: // WRITE MEMORY
if (hub->recv(&ta1,1,crc)) return;
if (hub->recv(&ta2,1,crc)) return;
if (hub->recv(&len,1,crc)) return;
if ((len > BAE910_SCRATCHPAD_SIZE) || (ta1 + len > 0x80) || (ta2 > 0))
{
hub->raiseSlaveError(cmd);
return;
}
if (hub->recv(scratchpad,len,crc)) return;
crc = ~crc;
if (hub->send(reinterpret_cast<uint8_t *>(&crc),2)) return;
// verify answer from master, then copy memory
if (hub->recv(&ta1 ,1)) return;
if (ta1 == 0xBC)
{
while (len-- > 0) // reverse byte order
{
memory.bytes[0x7F - ta1 - len] = scratchpad[len];
};
};
break;
case 0x16: // ERASE EEPROM PAGE (not needed/implemented yet)
default:
hub->raiseSlaveError(cmd);
};
};
| 33.808
| 154
| 0.467108
|
tbuz
|
22e7c639a01f7ca69290b817352fa476b9bbfc25
| 844
|
cpp
|
C++
|
LuoguCodes/UVA10976.cpp
|
Anguei/OI-Codes
|
0ef271e9af0619d4c236e314cd6d8708d356536a
|
[
"MIT"
] | null | null | null |
LuoguCodes/UVA10976.cpp
|
Anguei/OI-Codes
|
0ef271e9af0619d4c236e314cd6d8708d356536a
|
[
"MIT"
] | null | null | null |
LuoguCodes/UVA10976.cpp
|
Anguei/OI-Codes
|
0ef271e9af0619d4c236e314cd6d8708d356536a
|
[
"MIT"
] | null | null | null |
#include <cmath>
#include <cctype>
#include <cstdio>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <string>
#include <vector>
#include <numeric>
#include <iostream>
#include <algorithm>
#define ll long long
#define int long long
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#ifdef yyfLocal
#define dbg(x) std::clog << #x" = " << (x) << std::endl
#else
#define dbg(x) x
#endif
signed main() {
std::ios::sync_with_stdio(false); std::cin.tie(nullptr); std::cout.tie(nullptr);
int k;
while (std::cin >> k) {
std::vector<std::pair<int, int>> ans;
rep(y, k + 1, (k << 1)) if (k * y % (y - k) == 0) ans.push_back(std::make_pair(k * y / (y - k), y));
std::cout << ans.size() << std::endl;
for (const auto &i : ans) std::cout << "1/" << k << " = 1/" << i.first << " + 1/" << i.second << std::endl;
}
}
| 27.225806
| 109
| 0.582938
|
Anguei
|
22efb683fd7069a9d93944999dbd73a4ab245808
| 2,684
|
hpp
|
C++
|
src/openmpt/sounddevice/SoundDeviceRtAudio.hpp
|
sagamusix/openmpt
|
6d56d9a31d99c7f9a1f024d3deeb69006117e55c
|
[
"BSD-3-Clause"
] | 8
|
2019-05-28T20:02:50.000Z
|
2021-10-12T23:34:02.000Z
|
src/openmpt/sounddevice/SoundDeviceRtAudio.hpp
|
sagamusix/openmpt
|
6d56d9a31d99c7f9a1f024d3deeb69006117e55c
|
[
"BSD-3-Clause"
] | null | null | null |
src/openmpt/sounddevice/SoundDeviceRtAudio.hpp
|
sagamusix/openmpt
|
6d56d9a31d99c7f9a1f024d3deeb69006117e55c
|
[
"BSD-3-Clause"
] | 1
|
2019-12-25T01:02:00.000Z
|
2019-12-25T01:02:00.000Z
|
/* SPDX-License-Identifier: BSD-3-Clause */
/* SPDX-FileCopyrightText: OpenMPT Project Developers and Contributors */
#pragma once
#include "openmpt/all/BuildSettings.hpp"
#include "SoundDeviceBase.hpp"
#include "openmpt/base/Types.hpp"
#include "openmpt/logging/Logger.hpp"
#include <atomic>
#include <memory>
#include <vector>
#ifdef MPT_WITH_RTAUDIO
#if MPT_COMPILER_MSVC
#pragma warning(push)
#pragma warning(disable : 4244) // conversion from 'int' to 'unsigned char', possible loss of data
#endif
#include <RtAudio.h>
#if MPT_COMPILER_MSVC
#pragma warning(pop)
#endif
#endif // MPT_WITH_RTAUDIO
OPENMPT_NAMESPACE_BEGIN
namespace SoundDevice
{
#ifdef MPT_WITH_RTAUDIO
class CRtAudioDevice : public SoundDevice::Base
{
protected:
std::unique_ptr<RtAudio> m_RtAudio;
RtAudio::StreamParameters m_InputStreamParameters;
RtAudio::StreamParameters m_OutputStreamParameters;
unsigned int m_FramesPerChunk;
RtAudio::StreamOptions m_StreamOptions;
void *m_CurrentFrameBufferOutput;
void *m_CurrentFrameBufferInput;
unsigned int m_CurrentFrameBufferCount;
double m_CurrentStreamTime;
std::atomic<uint32> m_StatisticLatencyFrames;
std::atomic<uint32> m_StatisticPeriodFrames;
public:
CRtAudioDevice(ILogger &logger, SoundDevice::Info info, SoundDevice::SysInfo sysInfo);
~CRtAudioDevice();
public:
bool InternalOpen();
bool InternalClose();
void InternalFillAudioBuffer();
bool InternalStart();
void InternalStop();
bool InternalIsOpen() const { return m_RtAudio && m_RtAudio->isStreamOpen(); }
bool InternalHasGetStreamPosition() const { return true; }
int64 InternalGetStreamPositionFrames() const;
SoundDevice::BufferAttributes InternalGetEffectiveBufferAttributes() const;
SoundDevice::Statistics GetStatistics() const;
SoundDevice::Caps InternalGetDeviceCaps();
SoundDevice::DynamicCaps GetDeviceDynamicCaps(const std::vector<uint32> &baseSampleRates);
private:
void SendError(const RtAudioError &e);
void AudioCallback(void *outputBuffer, void *inputBuffer, unsigned int nFrames, double streamTime, RtAudioStreamStatus status);
static int RtAudioCallback(void *outputBuffer, void *inputBuffer, unsigned int nFrames, double streamTime, RtAudioStreamStatus status, void *userData);
static RtAudio::Api GetApi(SoundDevice::Info info);
static unsigned int GetDevice(SoundDevice::Info info);
public:
static std::unique_ptr<SoundDevice::BackendInitializer> BackendInitializer() { return std::make_unique<SoundDevice::BackendInitializer>(); }
static std::vector<SoundDevice::Info> EnumerateDevices(ILogger &logger, SoundDevice::SysInfo sysInfo);
};
#endif // MPT_WITH_RTAUDIO
} // namespace SoundDevice
OPENMPT_NAMESPACE_END
| 27.387755
| 152
| 0.797317
|
sagamusix
|
22f7ba52c62a55b05a4459aa4249b02970560923
| 17,606
|
cpp
|
C++
|
VKTexture2D.cpp
|
TheBearProject/bearvulkan
|
ea16b0fb4c99246b91088ea196e3448c8a8d680a
|
[
"MIT"
] | 3
|
2020-07-03T14:32:09.000Z
|
2020-11-20T12:59:07.000Z
|
VKTexture2D.cpp
|
TheBearProject/bearvulkan
|
ea16b0fb4c99246b91088ea196e3448c8a8d680a
|
[
"MIT"
] | null | null | null |
VKTexture2D.cpp
|
TheBearProject/bearvulkan
|
ea16b0fb4c99246b91088ea196e3448c8a8d680a
|
[
"MIT"
] | 2
|
2020-04-24T20:19:21.000Z
|
2020-07-03T14:32:12.000Z
|
#include "VKPCH.h"
size_t Texture2DCounter = 0;
VKTexture2D::VKTexture2D(size_t width, size_t height, size_t mips, size_t count, BearTexturePixelFormat pixel_format, BearTextureUsage type_usage, void* data)
{
Texture2DCounter++;
m_Format = pixel_format;
m_TextureUsage = type_usage;
m_TextureType = BearTextureType::Default;
switch (m_TextureUsage)
{
case BearTextureUsage::Static:
case BearTextureUsage::Dynamic:
case BearTextureUsage::Stating:
ImageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
break;
case BearTextureUsage::Storage:
ImageLayout = VK_IMAGE_LAYOUT_GENERAL;
break;
default:
break;
}
bAllowUAV = m_TextureUsage == BearTextureUsage::Storage;
{
bear_fill(ImageCreateInfo);
ImageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
ImageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
ImageCreateInfo.extent.width =static_cast<uint32_t>( width);
ImageCreateInfo.extent.height = static_cast<uint32_t>(height);
ImageCreateInfo.arrayLayers = static_cast<uint32_t>(count);;
ImageCreateInfo.mipLevels = static_cast<uint32_t>(mips);
ImageCreateInfo.extent.depth = 1;
ImageCreateInfo.format = VKFactory::Translation(pixel_format);
ImageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
ImageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
switch (m_TextureUsage)
{
case BearTextureUsage::Stating:
ImageCreateInfo.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
break;
case BearTextureUsage::Storage:
ImageCreateInfo.usage = VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
break;
default:
ImageCreateInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
break;
}
ImageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
ImageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
V_CHK(vkCreateImage(Factory->Device, &ImageCreateInfo, nullptr, &Image));
VkMemoryRequirements MemoryRequirement;
vkGetImageMemoryRequirements(Factory->Device, Image, &MemoryRequirement);
VkMemoryAllocateInfo MemoryAllocateInfo = {};
MemoryAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
MemoryAllocateInfo.allocationSize = MemoryRequirement.size;
MemoryAllocateInfo.memoryTypeIndex = FindMemoryType(Factory->PhysicalDevice,MemoryRequirement.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
V_CHK(vkAllocateMemory(Factory->Device, &MemoryAllocateInfo, nullptr, &ImageMemory));
vkBindImageMemory(Factory->Device, Image, ImageMemory, 0);
}
{
VkImageViewCreateInfo ViewCreateInfo = {};
ViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
ViewCreateInfo.image = Image;
ViewCreateInfo.viewType = count>1? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D;
ViewCreateInfo.format = VKFactory::Translation(pixel_format);
ViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
ViewCreateInfo.subresourceRange.baseMipLevel = 0;
ViewCreateInfo.subresourceRange.levelCount = static_cast<uint32_t>(mips);
ViewCreateInfo.subresourceRange.baseArrayLayer = 0;
ViewCreateInfo.subresourceRange.layerCount = static_cast<uint32_t>(count);
V_CHK(vkCreateImageView(Factory->Device, &ViewCreateInfo, nullptr, &SRVImageView));
if (bAllowUAV)
{
UAVImageViews.resize(mips);
ViewCreateInfo.subresourceRange.levelCount = 1;
for (size_t i = 0; i < mips; i++)
{
ViewCreateInfo.subresourceRange.baseMipLevel =static_cast<uint32_t>( i);
V_CHK(vkCreateImageView(Factory->Device, &ViewCreateInfo, nullptr, &UAVImageViews[i]));
}
}
}
TransitionImageLayout(0, Image, ImageCreateInfo.format, VK_IMAGE_LAYOUT_UNDEFINED, ImageLayout, ImageCreateInfo.mipLevels, ImageCreateInfo.arrayLayers,0);
m_Buffer = 0;
switch (m_TextureUsage)
{
case BearTextureUsage::Dynamic:
case BearTextureUsage::Stating:
AllocBuffer();
break;
}
if (data)
{
BEAR_CHECK(!bAllowUAV);
auto ptr = reinterpret_cast<uint8*>(data);
for (size_t x = 0; x < count; x++)
for (size_t y = 0; y < mips; y++)
{
size_t size = BearTextureUtils::GetSizeDepth(BearTextureUtils::GetMip(width, y), BearTextureUtils::GetMip(height, y), m_Format);
memcpy(Lock(y, x), ptr, size);
Unlock();
ptr += size;
}
}
}
VKTexture2D::VKTexture2D(size_t width, size_t height, BearRenderTargetFormat format)
{
Texture2DCounter++;
m_RTVFormat = format;
m_Buffer = 0;
m_TextureUsage = BearTextureUsage::Static;
m_TextureType = BearTextureType::RenderTarget;
ZeroMemory(&ImageCreateInfo,sizeof(VkImageCreateInfo));
ImageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
ImageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
ImageCreateInfo.extent.width = static_cast<uint32_t>(width);
ImageCreateInfo.extent.height = static_cast<uint32_t>(height);
ImageCreateInfo.extent.depth = static_cast<uint32_t>(1);;
ImageCreateInfo.mipLevels = static_cast<uint32_t>(1);
ImageCreateInfo.arrayLayers = 1;
ImageCreateInfo.format = VKFactory::Translation(m_RTVFormat);
ImageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
ImageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
ImageCreateInfo.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_SAMPLED_BIT| VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
ImageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
ImageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
V_CHK(vkCreateImage(Factory->Device, &ImageCreateInfo, nullptr, &Image));
VkMemoryRequirements MemoryRequirement;
vkGetImageMemoryRequirements(Factory->Device, Image, &MemoryRequirement);
VkMemoryAllocateInfo MemoryAllocateInfo = {};
MemoryAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
MemoryAllocateInfo.allocationSize = MemoryRequirement.size;
MemoryAllocateInfo.memoryTypeIndex = FindMemoryType(Factory->PhysicalDevice, MemoryRequirement.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
V_CHK(vkAllocateMemory(Factory->Device, &MemoryAllocateInfo, nullptr, &ImageMemory));
vkBindImageMemory(Factory->Device, Image, ImageMemory, 0);
{
VkImageViewCreateInfo ViewCreateInfo = {};
ViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
ViewCreateInfo.image = Image;
ViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D ;
ViewCreateInfo.format = VKFactory::Translation(m_RTVFormat);
ViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
ViewCreateInfo.subresourceRange.baseMipLevel = 0;
ViewCreateInfo.subresourceRange.levelCount = static_cast<uint32_t>(1);
ViewCreateInfo.subresourceRange.baseArrayLayer = 0;
ViewCreateInfo.subresourceRange.layerCount = static_cast<uint32_t>(1);
V_CHK(vkCreateImageView(Factory->Device, &ViewCreateInfo, nullptr, &SRVImageView));
}
TransitionImageLayout(0, Image, ImageCreateInfo.format, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, ImageCreateInfo.mipLevels, ImageCreateInfo.arrayLayers,0);
}
VKTexture2D::VKTexture2D(size_t width, size_t height, BearDepthStencilFormat format)
{
Texture2DCounter++;
m_DSVFormat = format;
m_Buffer = 0;
m_TextureUsage = BearTextureUsage::Static;
m_TextureType = BearTextureType::DepthStencil;
ZeroMemory(&ImageCreateInfo, sizeof(VkImageCreateInfo));
ImageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
ImageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
ImageCreateInfo.extent.width = static_cast<uint32_t>(width);
ImageCreateInfo.extent.height = static_cast<uint32_t>(height);
ImageCreateInfo.extent.depth = static_cast<uint32_t>(1);;
ImageCreateInfo.mipLevels = static_cast<uint32_t>(1);
ImageCreateInfo.arrayLayers = 1;
ImageCreateInfo.format = VKFactory::Translation(m_DSVFormat);
ImageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
ImageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
ImageCreateInfo.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
ImageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
ImageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
V_CHK(vkCreateImage(Factory->Device, &ImageCreateInfo, nullptr, &Image));
VkMemoryRequirements MemoryRequirement;
vkGetImageMemoryRequirements(Factory->Device, Image, &MemoryRequirement);
VkMemoryAllocateInfo MemoryAllocateInfo = {};
MemoryAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
MemoryAllocateInfo.allocationSize = MemoryRequirement.size;
MemoryAllocateInfo.memoryTypeIndex = FindMemoryType(Factory->PhysicalDevice, MemoryRequirement.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
V_CHK(vkAllocateMemory(Factory->Device, &MemoryAllocateInfo, nullptr, &ImageMemory));
vkBindImageMemory(Factory->Device, Image, ImageMemory, 0);
SRVImageView = 0;
{
VkImageViewCreateInfo ViewCreateInfo = {};
ViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
ViewCreateInfo.image = Image;
ViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
ViewCreateInfo.format = VKFactory::Translation(m_DSVFormat);
ViewCreateInfo.components.r = VK_COMPONENT_SWIZZLE_R;
ViewCreateInfo.components.g = VK_COMPONENT_SWIZZLE_G;
ViewCreateInfo.components.b = VK_COMPONENT_SWIZZLE_B;
ViewCreateInfo.components.a = VK_COMPONENT_SWIZZLE_A;
switch (m_DSVFormat)
{
case BearDepthStencilFormat::Depth16:
case BearDepthStencilFormat::Depth32F:
ViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT ;
break;
default:
ViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
break;
}
ViewCreateInfo.subresourceRange.baseMipLevel = 0;
ViewCreateInfo.subresourceRange.levelCount = static_cast<uint32_t>(1);
ViewCreateInfo.subresourceRange.baseArrayLayer = 0;
ViewCreateInfo.subresourceRange.layerCount = static_cast<uint32_t>(1);
V_CHK(vkCreateImageView(Factory->Device, &ViewCreateInfo, nullptr, &SRVImageView));
}
TransitionImageLayout(0, Image, ImageCreateInfo.format, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, ImageCreateInfo.mipLevels, ImageCreateInfo.arrayLayers, 0);
}
void VKTexture2D::SetAsSRV(VkWriteDescriptorSet* heap, size_t offset)
{
BEAR_CHECK(SRVImageView);
DescriptorImageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
DescriptorImageInfo.imageView = SRVImageView;
DescriptorImageInfo.sampler = Factory->DefaultSampler;
heap->descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
heap->pImageInfo = &DescriptorImageInfo;
}
void VKTexture2D::SetAsUAV(VkWriteDescriptorSet* heap, size_t offset)
{
BEAR_CHECK(UAVImageViews[offset]);
BEAR_CHECK(bAllowUAV);
DescriptorImageInfo.imageLayout = VK_IMAGE_LAYOUT_GENERAL;
DescriptorImageInfo.imageView = UAVImageViews[offset];
DescriptorImageInfo.sampler = Factory->DefaultSampler;
heap->descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
heap->pImageInfo = &DescriptorImageInfo;
}
void VKTexture2D::LockUAV(VkCommandBuffer command_line)
{
BEAR_CHECK(bAllowUAV);
TransitionImageLayout(command_line, Image, ImageCreateInfo.format, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, ImageCreateInfo.mipLevels, ImageCreateInfo.arrayLayers, 0);
}
void VKTexture2D::UnlockUAV(VkCommandBuffer command_line)
{
BEAR_CHECK(bAllowUAV);
TransitionImageLayout(command_line, Image, ImageCreateInfo.format, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, ImageCreateInfo.mipLevels, ImageCreateInfo.arrayLayers, 0);
}
void* VKTexture2D::QueryInterface(int type)
{
switch (type)
{
case VKQ_ShaderResource:
return reinterpret_cast<void*>(static_cast<VKShaderResource*>(this));
case VKQ_UnorderedAccess:
return reinterpret_cast<void*>(static_cast<VKUnorderedAccess*>(this));
default:
return nullptr;
}
}
VKTexture2D::~VKTexture2D()
{
Texture2DCounter--;
if (SRVImageView)
{
vkDestroyImageView(Factory->Device, SRVImageView, nullptr);
}
for (auto& i : UAVImageViews)
{
vkDestroyImageView(Factory->Device, i, nullptr);
}
vkDestroyImage(Factory->Device, Image, nullptr);
vkFreeMemory(Factory->Device, ImageMemory, nullptr);
switch (m_TextureUsage)
{
case BearTextureUsage::Dynamic:
case BearTextureUsage::Stating:
FreeBuffer();
break;
}
}
BearTextureType VKTexture2D::GetType()
{
return m_TextureType;
}
void* VKTexture2D::Lock(size_t mip, size_t depth)
{
BEAR_CHECK(!bAllowUAV);
m_Mip = mip;
m_Depth = depth;
if (bAllowUAV)return 0;
if (m_TextureType != BearTextureType::Default)return 0;
if (m_Buffer)Unlock();
switch (m_TextureUsage)
{
case BearTextureUsage::Static:
AllocBuffer();
break;
case BearTextureUsage::Dynamic:
break;
case BearTextureUsage::Stating:
Factory->LockCommandBuffer();
TransitionImageLayout(Factory->CommandBuffer, Image, VKFactory::Translation(m_Format), VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, ImageCreateInfo.mipLevels, ImageCreateInfo.arrayLayers, static_cast<uint32_t>(m_Depth));
CopyImageToBuffer(Factory->CommandBuffer, m_StagingBuffer, Image, ImageCreateInfo.extent.width, ImageCreateInfo.extent.height, static_cast<uint32_t>(m_Mip), static_cast<uint32_t>(m_Depth));
TransitionImageLayout(Factory->CommandBuffer, Image, VKFactory::Translation(m_Format), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, ImageCreateInfo.mipLevels, ImageCreateInfo.arrayLayers, static_cast<uint32_t>(m_Depth));
Factory->UnlockCommandBuffer();
break;
default:
break;
}
vkMapMemory(Factory->Device, m_StagingBufferMemory, 0, BearTextureUtils::GetSizeInMemory(BearTextureUtils::GetMip( ImageCreateInfo.extent.width,mip), BearTextureUtils::GetMip(ImageCreateInfo.extent.height, mip), ImageCreateInfo.mipLevels, m_Format), 0, &m_Buffer);
return m_Buffer;
}
void VKTexture2D::Unlock()
{
BEAR_CHECK(m_Buffer);
BEAR_CHECK(!bAllowUAV);
if (m_TextureType != BearTextureType::Default)return;
vkUnmapMemory(Factory->Device, m_StagingBufferMemory);
switch (m_TextureUsage)
{
case BearTextureUsage::Static:
Factory->LockCommandBuffer();
TransitionImageLayout(Factory->CommandBuffer, Image, VKFactory::Translation(m_Format), VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, ImageCreateInfo.mipLevels, ImageCreateInfo.arrayLayers, static_cast<uint32_t>(m_Depth));
CopyBufferToImage(Factory->CommandBuffer, m_StagingBuffer, Image, ImageCreateInfo.extent.width, ImageCreateInfo.extent.height, static_cast<uint32_t>(m_Mip), static_cast<uint32_t>(m_Depth));
TransitionImageLayout(Factory->CommandBuffer, Image, VKFactory::Translation(m_Format), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, ImageCreateInfo.mipLevels, ImageCreateInfo.arrayLayers, static_cast<uint32_t>(m_Depth));
Factory->UnlockCommandBuffer();
FreeBuffer();
break;
case BearTextureUsage::Dynamic:
Factory->LockCommandBuffer();
TransitionImageLayout(Factory->CommandBuffer, Image, VKFactory::Translation(m_Format), VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, ImageCreateInfo.mipLevels, ImageCreateInfo.arrayLayers, static_cast<uint32_t>(m_Depth));
CopyBufferToImage(Factory->CommandBuffer, m_StagingBuffer, Image, ImageCreateInfo.extent.width, ImageCreateInfo.extent.height, static_cast<uint32_t>(m_Mip), static_cast<uint32_t>(m_Depth));
TransitionImageLayout(Factory->CommandBuffer, Image, VKFactory::Translation(m_Format), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, ImageCreateInfo.mipLevels, ImageCreateInfo.arrayLayers, static_cast<uint32_t>(m_Depth));
Factory->UnlockCommandBuffer();
break;
case BearTextureUsage::Stating:
break;
default:
break;
}
m_Buffer = 0;
}
void VKTexture2D::AllocBuffer()
{
VkDeviceSize ImageSize = BearTextureUtils::GetSizeInMemory(ImageCreateInfo.extent.width, ImageCreateInfo.extent.height, ImageCreateInfo.mipLevels, m_Format) * ImageCreateInfo.arrayLayers;
CreateBuffer(Factory->PhysicalDevice, Factory->Device, ImageSize, m_TextureUsage == BearTextureUsage::Stating ? VK_BUFFER_USAGE_TRANSFER_DST_BIT : VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, m_StagingBuffer, m_StagingBufferMemory);
}
void VKTexture2D::FreeBuffer()
{
vkDestroyBuffer(Factory->Device, m_StagingBuffer, nullptr);
vkFreeMemory(Factory->Device, m_StagingBufferMemory, nullptr);
}
| 45.611399
| 301
| 0.748438
|
TheBearProject
|
fe00b0cced55d27fe65133ce53e13522f05088b9
| 996
|
cpp
|
C++
|
C++/Linux/test/lesson-6-1/main.cpp
|
DanyloSve/smartHouse
|
e716591827ccb605b023f0429211cc996404f351
|
[
"MIT"
] | null | null | null |
C++/Linux/test/lesson-6-1/main.cpp
|
DanyloSve/smartHouse
|
e716591827ccb605b023f0429211cc996404f351
|
[
"MIT"
] | null | null | null |
C++/Linux/test/lesson-6-1/main.cpp
|
DanyloSve/smartHouse
|
e716591827ccb605b023f0429211cc996404f351
|
[
"MIT"
] | null | null | null |
#include "mainwindow.h"
#include <QApplication>
#include <QWidget>
#include <QFrame>
#include <QGridLayout>
class Cursors : public QWidget
{
public :
Cursors(QWidget *parent = nullptr);
};
Cursors::Cursors(QWidget *parent) : QWidget(parent)
{
QFrame *frame1 = new QFrame(this);
frame1->setFrameStyle(QFrame::Box);
frame1->setCursor(Qt::WaitCursor);
QFrame *frame2 = new QFrame(this);
frame2->setFrameStyle(QFrame::Box);
frame2->setCursor(Qt::SizeAllCursor);
QFrame *frame3 = new QFrame(this);
frame3->setFrameStyle(QFrame::Box);
frame3->setCursor(Qt::PointingHandCursor);
QGridLayout *grid = new QGridLayout(this);
grid->addWidget(frame1, 0, 0);
grid->addWidget(frame2, 0, 1);
grid->addWidget(frame3, 0 ,3);
setLayout(grid);
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
Cursors window;
window.resize(350, 150);
window.setWindowTitle("Cursors");
window.show();
return a.exec();
}
| 20.75
| 53
| 0.664659
|
DanyloSve
|
fe0f46dc3e94734c7136e3db82f94ee72790e783
| 6,826
|
cpp
|
C++
|
manager/cluster_manager.cpp
|
FinalLevel/metis
|
6f0c8c2fc87954881fc243ed3dabfaaf1ee42dc2
|
[
"BSD-3-Clause"
] | 3
|
2015-03-28T06:01:04.000Z
|
2018-11-10T15:38:47.000Z
|
manager/cluster_manager.cpp
|
FinalLevel/metis
|
6f0c8c2fc87954881fc243ed3dabfaaf1ee42dc2
|
[
"BSD-3-Clause"
] | null | null | null |
manager/cluster_manager.cpp
|
FinalLevel/metis
|
6f0c8c2fc87954881fc243ed3dabfaaf1ee42dc2
|
[
"BSD-3-Clause"
] | 6
|
2015-02-25T02:38:23.000Z
|
2022-03-08T10:23:52.000Z
|
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2014 Final Level
// Author: Denys Misko <gdraal@gmail.com>
// Distributed under BSD (3-Clause) License (See
// accompanying file LICENSE)
//
// Description: Metis cluster control class implementation
///////////////////////////////////////////////////////////////////////////////
#include "cluster_manager.hpp"
#include "../metis_log.hpp"
#include "storage_cmd_event.hpp"
using namespace fl::metis;
namespace EManagerFlds
{
enum EManagerFlds
{
ID,
CMD_IP,
CMD_PORT,
STATUS,
};
};
const char * const MANAGER_SQL = "SELECT id, cmdIp, cmdPort, status FROM manager";
ManagerNode::ManagerNode(MysqlResult *res)
: _id(res->get<decltype(_id)>(EManagerFlds::ID)),
_ip(Socket::ip2Long(res->get(EManagerFlds::CMD_IP))),
_port(res->get<decltype(_port)>(EManagerFlds::CMD_PORT)),
_status(res->get<decltype(_status)>(EManagerFlds::STATUS))
{
}
bool ClusterManager::_loadManagers(Mysql &sql)
{
auto res = sql.query(MANAGER_SQL);
if (!res) {
log::Error::L("Cannot load information about manager nodes\n");
return false;
}
while (res->next()) {
TManagerNodePtr manager(new ManagerNode(res.get()));
_managers.insert(TManagerNodeMap::value_type(manager->id(), manager));
}
log::Info::L("Load %u managers\n", _managers.size());
return true;
}
namespace EStorageFlds
{
enum EStorageFlds
{
ID,
GROUPID,
IP,
PORT,
STATUS,
};
};
const char * const STORAGE_SQL = "SELECT id, groupID, ip, port, status FROM storage";
StorageNode::StorageNode(MysqlResult *res)
: _id(res->get<decltype(_id)>(EStorageFlds::ID)),
_groupID(res->get<decltype(_groupID)>(EStorageFlds::GROUPID)),
_ip(Socket::ip2Long(res->get(EStorageFlds::IP))),
_port(res->get<decltype(_port)>(EStorageFlds::PORT)),
_status(res->get<decltype(_status)>(EStorageFlds::STATUS)),
_weight(rand()), _leftSpace(0), _errors(0), _lastPingTime(0)
{
}
bool StorageNode::balanceStorage(StorageNode *a, StorageNode *b)
{
return a->_weight < b->_weight;
}
bool StorageNode::canPut(const TSize size) const
{
if ((_status & (ST_ACTIVE | ST_CAN_PUT | ST_DOWN)) == (ST_ACTIVE | ST_CAN_PUT))
return (size < _leftSpace);
else
return false;
}
void StorageNode::ping(StoragePingAnswer &storageAnswer)
{
_leftSpace = storageAnswer.leftSpace;
_errors = 0;
if (_status & ST_DOWN) {
_status &= (~ST_DOWN);
log::Warning::L("Storage %s:%u (%u) is UP\n", Socket::ip2String(_ip).c_str(), _port, _id);
}
_lastPingTime = EPollWorkerGroup::curTime.unix();
}
void StorageNode::error()
{
if (_errors >= MAX_ERRORS_BEFORE_DOWN) {
if (!(_status & ST_DOWN)) {
_status |= ST_DOWN;
log::Warning::L("Storage %s:%u (%u) is DOWN\n", Socket::ip2String(_ip).c_str(), _port, _id);
}
} else {
_errors++;
}
}
bool ClusterManager::_loadStorages(Mysql &sql)
{
auto res = sql.query(STORAGE_SQL);
if (!res) {
log::Error::L("Cannot load information about storage nodes\n");
return false;
}
while (res->next()) {
TStorageNodePtr storage(new StorageNode(res.get()));
_storages.insert(TStorageNodeMap::value_type(storage->id(), storage));
}
log::Info::L("Load %u storages\n", _storages.size());
return true;
}
bool ClusterManager::loadAll(Mysql &sql)
{
if (!_loadManagers(sql))
return false;
if (!_loadStorages(sql))
return false;
return true;
}
void ClusterManager::findStorages(TServerIDList &storageIds, TStorageList &storages)
{
AutoMutex autoSync(&_sync);
for (auto storageID = storageIds.begin(); storageID != storageIds.end(); storageID++) {
auto storage = _storages.find(*storageID);
if (storage == _storages.end()) {
log::Warning::L("Can't find storage %u\n", *storageID);
} else {
storages.push_back(storage->second.get());
}
}
}
TServerID ClusterManager::findFreeManager()
{
AutoMutex autoSync(&_sync);
TManagerList managers;
for (auto manager = _managers.begin(); manager != _managers.end(); manager++) {
if (manager->second->isFree()) {
managers.push_back(manager->second.get());
}
}
if (managers.empty())
return 0;
return managers[rand() % managers.size()]->id();
}
StorageNode *ClusterManager::findFreeStorage(const int64_t minLeftSpace, TStorageList &storages)
{
AutoMutex autoSync(&_sync);
TStorageList freeStorages;
for (auto storage = _storages.begin(); storage != _storages.end(); storage++) {
if (storage->second->canPut(minLeftSpace)) {
bool newGroup = true;
for (auto existsStorage = storages.begin(); existsStorage != storages.end(); existsStorage++) {
if ((*existsStorage)->groupID() == storage->second->groupID()) {
newGroup = false;
break;
}
}
if (!newGroup)
continue;
newGroup = true;
for (auto freeStorage = freeStorages.begin(); freeStorage != freeStorages.end(); freeStorage++) {
if ((*freeStorage)->groupID() == storage->second->groupID()) {
newGroup = false;
break;
}
}
if (newGroup)
freeStorages.push_back(storage->second.get());
}
}
if (freeStorages.empty())
return NULL;
std::sort(freeStorages.begin(), freeStorages.end(), StorageNode::balanceStorage);
return freeStorages.front();
}
bool ClusterManager::findFreeStorages(const size_t minimumCopies, TServerIDList &storageIDs, const int64_t minLeftSpace)
{
AutoMutex autoSync(&_sync);
TStorageList freeStorages;
for (auto storage = _storages.begin(); storage != _storages.end(); storage++) {
if (storage->second->canPut(minLeftSpace)) {
bool newGroup = true;
for (auto freeStorage = freeStorages.begin(); freeStorage != freeStorages.end(); freeStorage++) {
if ((*freeStorage)->groupID() == storage->second->groupID()) {
newGroup = false;
break;
}
}
if (newGroup)
freeStorages.push_back(storage->second.get());
}
}
if (freeStorages.size() < minimumCopies)
return false;
std::sort(freeStorages.begin(), freeStorages.end(), StorageNode::balanceStorage);
auto storage = freeStorages.begin();
for (size_t c = 0; c < minimumCopies; c++) {
storageIDs.push_back((*storage)->id());
storage++;
}
return true;
}
bool ClusterManager::startStoragesPinging(EPollWorkerThread *thread)
{
_storagesPinging = new StorageCMDPinging(this, thread);
return _storagesPinging->start();
}
TStorageList ClusterManager::storages()
{
TStorageList storagesVector;
for (auto s = _storages.begin(); s != _storages.end(); s++)
storagesVector.push_back(s->second.get());
return storagesVector;
}
ClusterManager::ClusterManager()
: _storagesPinging(NULL)
{
}
bool ClusterManager::isReady()
{
static const uint32_t PING_EXPERIES_TIME = 15;
auto lastPingTime = EPollWorkerGroup::curTime.unix() - PING_EXPERIES_TIME;
for (auto s = _storages.begin(); s != _storages.end(); s++) {
if (!s->second->isPinged(lastPingTime)) {
return false;
}
}
return true;
}
| 26.053435
| 120
| 0.675652
|
FinalLevel
|
fe14339e615e864ae9753d01f9818ca5beab5e6d
| 849
|
cpp
|
C++
|
CudaTracer2/main.cpp
|
bbtarzan12/CudaTracer2
|
89b6454bf84ef6b1300f84c6580c867cb8419ce3
|
[
"MIT"
] | null | null | null |
CudaTracer2/main.cpp
|
bbtarzan12/CudaTracer2
|
89b6454bf84ef6b1300f84c6580c867cb8419ce3
|
[
"MIT"
] | null | null | null |
CudaTracer2/main.cpp
|
bbtarzan12/CudaTracer2
|
89b6454bf84ef6b1300f84c6580c867cb8419ce3
|
[
"MIT"
] | null | null | null |
//#include "CPURenderer.h"
#include "CudaRenderer.h"
int main(int argc, char **argv)
{
unique_ptr<Renderer> renderer = make_unique<CudaRenderer>();
RendererOption rendererOption;
rendererOption.width = 1280/2;
rendererOption.height = 720/2;
CameraOption cameraOption;
cameraOption.width = rendererOption.width;
cameraOption.height = rendererOption.height;
cameraOption.position = vec3(-14.0694f, -0.301702f, 30.0197f);
cameraOption.fov = 70.0f;
cameraOption.nearPlane = 0.1f;
cameraOption.farPlane = 1000.0f;
cameraOption.moveSpeed = 25.0f;
cameraOption.mouseSpeed = 10.0f;
cameraOption.pitch = -13.8f;
cameraOption.yaw = 157.067f;
cameraOption.aperture = 0;
cameraOption.focalDistance = 0.1f;
renderer->Init(rendererOption);;
renderer->SetCamera(cameraOption);
renderer->Start();
// Cleanup
glfwTerminate();
return 0;
}
| 24.970588
| 63
| 0.750294
|
bbtarzan12
|
fe17e68b2ac452784e239bdaf4e6e0acef4e82cf
| 15,311
|
tpp
|
C++
|
src/imageio/itkdetails/ImageData.tpp
|
halfmvsq/histolozee
|
c624c0d7c3a70bcc0d6aac87b4f24677e064b6a5
|
[
"Apache-2.0"
] | null | null | null |
src/imageio/itkdetails/ImageData.tpp
|
halfmvsq/histolozee
|
c624c0d7c3a70bcc0d6aac87b4f24677e064b6a5
|
[
"Apache-2.0"
] | null | null | null |
src/imageio/itkdetails/ImageData.tpp
|
halfmvsq/histolozee
|
c624c0d7c3a70bcc0d6aac87b4f24677e064b6a5
|
[
"Apache-2.0"
] | null | null | null |
#include "itkdetails/ImageData.hpp" // for IDE
#include "itkdetails/ImageIOInfo.hpp"
#include "itkdetails/ImageReading.hpp"
#include "itkdetails/ImageUtility.hpp"
#include "util/HZeeException.hpp"
#include <exception>
#include <sstream>
#include <typeinfo>
#include <typeindex>
#include <unordered_map>
#include <vector> // for IDE
namespace itkdetails
{
template< typename ComponentType >
bool normalizeImageIntensities(
image3d::ImageBaseType::Pointer& imageBase,
const imageio::ComponentNormalizationPolicy& normalizationPolicy )
{
switch ( normalizationPolicy )
{
case imageio::ComponentNormalizationPolicy::SignedNormalizedFloating :
{
return utility::rescaleIntensities< ComponentType >( imageBase, -1.0, 1.0 );
}
case imageio::ComponentNormalizationPolicy::UnsignedNormalizedFloating :
{
return utility::rescaleIntensities< ComponentType >( imageBase, 0.0, 1.0 );
}
case imageio::ComponentNormalizationPolicy::None :
{
return true;
}
}
return false;
}
template< class ComponentType >
ImageData< ComponentType >::ImageData()
:
ImageBaseData(),
m_splitImagePtrs()
{}
template< class ComponentType >
ImageData< ComponentType >::ImageData(
std::vector< typename image3d::ImageType< ComponentType >::Pointer > splitImagePtrs,
io::ImageIoInfo ioInfo )
:
ImageBaseData( std::move( ioInfo ) ),
m_splitImagePtrs( std::move( splitImagePtrs ) )
{
// No need to call splitImageIntoComponents() here, since the split image components
// are passed in to the constructor
computePixelStatistics();
}
template< class ComponentType >
ImageData< ComponentType >::ImageData(
const io::ImageIoInfo& ioInfo,
const ComponentType& defaultValue )
{
if ( image3d::NDIM != ioInfo.m_spaceInfo.m_numDimensions )
{
std::ostringstream ss;
ss << "Unable to setup and construct ImageData object of dimension "
<< ioInfo.m_spaceInfo.m_numDimensions << std::ends;
throw std::invalid_argument( ss.str() );
}
using ImageType = image3d::ImageType< ComponentType >;
typename ImageType::IndexType start;
typename ImageType::SizeType size;
typename ImageType::SpacingType spacing;
typename ImageType::PointType origin;
typename ImageType::DirectionType directions;
for ( uint i = 0; i < image3d::NDIM; ++i )
{
start[i] = 0;
size[i] = ioInfo.m_spaceInfo.m_dimensions[i];
spacing[i] = ioInfo.m_spaceInfo.m_spacing[i];
origin[i] = ioInfo.m_spaceInfo.m_origin[i];
for ( uint j = 0; j < image3d::NDIM; ++j )
{
directions[i][j] = ioInfo.m_spaceInfo.m_directions[i][j];
}
}
typename ImageType::RegionType region;
region.SetSize( size );
region.SetIndex( start );
typename ImageType::Pointer image = ImageType::New();
image->SetRegions( region );
image->Allocate();
image->FillBuffer( defaultValue );
image->SetSpacing( spacing );
image->SetOrigin( origin );
image->SetDirection( directions );
m_imageBasePtr = static_cast< image3d::ImageBaseType::Pointer >( image );
m_imageIOInfo = ioInfo;
if ( ! setup() )
{
throw std::runtime_error( "Unable to setup and construct ImageData object" );
}
}
template< class ComponentType >
bool ImageData< ComponentType >::setup()
{
bool success = ( splitImageIntoComponents() && computePixelStatistics() );
return success;
}
template< class ComponentType >
bool ImageData< ComponentType >::loadFromImageFile(
const std::string& fileName,
const imageio::ComponentNormalizationPolicy& normalizationPolicy )
{
const ::itk::ImageIOBase::Pointer imageIO =
itkdetails::utility::createStandardImageIO( fileName.c_str() );
if ( imageIO.IsNull() )
{
std::cerr << "Error creating ImageIOBase." << std::endl;
return false;
}
if ( ! m_imageIOInfo.set( imageIO ) )
{
std::cerr << "Error setting imageIO information" << std::endl;
return false;
}
#if 0
/// @note This is only needed if the read component type SHOULD equal the image component type
const auto expectedComponentType = io::itkComponentTypeMap[
std::type_index( typeid( ComponentType ) ) ];
if ( expectedComponentType != m_imageIOInfo.m_componentInfo.m_componentType )
{
std::cerr << "Component type read from image '"
<< fileName << "' is not of type "
<< m_imageIOInfo.m_componentInfo.m_componentTypeString << std::endl;
return false;
}
#endif
m_imageBasePtr = reader::read< ComponentType >( imageIO );
if ( m_imageBasePtr.IsNull() )
{
std::cerr << "Error reading image '" << fileName << "'" << std::endl;
return false;
}
if ( ::itkdetails::image3d::NDIM != m_imageBasePtr->GetImageDimension() )
{
std::cerr << "Error reading image '" << fileName << "' as 3D volume" << std::endl;
m_imageBasePtr = ITK_NULLPTR;
return false;
}
const bool normalized = normalizeImageIntensities< ComponentType >(
m_imageBasePtr, normalizationPolicy );
if ( ! normalized )
{
// Failure during intensity normalization step
return false;
}
return setup();
}
template< class ComponentType >
bool ImageData< ComponentType >::loadFromDicomSeries(
const std::vector< std::string >& fileNames,
const imageio::ComponentNormalizationPolicy& normalizationPolicy )
{
if ( fileNames.empty() )
{
return false;
}
const ::itk::ImageIOBase::Pointer imageIO =
itkdetails::utility::dicom::createDicomImageIO( fileNames[0].c_str() );
if ( imageIO.IsNull() )
{
std::cerr << "Error creating GDCMImageIO." << std::endl;
return false;
}
if ( ! m_imageIOInfo.set( imageIO ) )
{
std::cerr << "Error setting imageIO information" << std::endl;
return false;
}
#if 0
/// @note This is only needed if the read component type SHOULD equal the image component type
const auto expectedComponentType = io::itkComponentTypeMap[
std::type_index( typeid( ComponentType ) ) ];
if ( expectedComponentType != m_imageIOInfo.m_componentInfo.m_componentType )
{
std::cerr << "Component type read from DICOM series image '"
<< fileNames[0] << "' is not of type "
<< m_imageIOInfo.m_componentInfo.m_componentTypeString << std::endl;
return false;
}
#endif
m_imageBasePtr = reader::read< ComponentType >( imageIO, fileNames );
if ( m_imageBasePtr.IsNull() )
{
std::cerr << "Error reading DICOM series starting with file '"
<< fileNames[0] << "'" << std::endl;
return false;
}
if ( ::itkdetails::image3d::NDIM != m_imageBasePtr->GetImageDimension() )
{
std::cerr << "Error reading DICOM series starting with file '"
<< fileNames[0] << "' as 3D volume" << std::endl;
m_imageBasePtr = ITK_NULLPTR;
return false;
}
const bool normalized = normalizeImageIntensities< ComponentType >(
m_imageBasePtr, normalizationPolicy );
if ( ! normalized )
{
// Failure during intensity normalization step
return false;
}
/// @internal Set the size and space information using itkImageBase directly,
/// since these may have been set incorrectly using itkImageIOBase
m_imageIOInfo.m_sizeInfo.set( m_imageBasePtr, imageIO->GetComponentSize() );
m_imageIOInfo.m_spaceInfo.set( m_imageBasePtr );
return setup();
}
template< class ComponentType >
const uint8_t* ImageData< ComponentType >::bufferPointer() const
{
if ( m_imageBasePtr.IsNotNull() )
{
return reinterpret_cast< const uint8_t* >(
( isVectorImage() )
? asITKVectorImage()->GetBufferPointer()
: asITKImage()->GetBufferPointer() );
}
else
{
return nullptr;
}
}
template< class ComponentType >
const uint8_t* ImageData< ComponentType >::bufferPointer(
const uint32_t componentIndex ) const
{
if ( componentIndex >= m_splitImagePtrs.size() )
{
return nullptr;
}
const auto& image = m_splitImagePtrs[ componentIndex ];
if ( image.IsNotNull() )
{
return reinterpret_cast< const uint8_t* >(
image->GetBufferPointer() );
}
else
{
return nullptr;
}
}
template< class ComponentType >
vtkSmartPointer< vtkImageData >
ImageData< ComponentType >::asVTKImageData(
const uint32_t componentIndex ) const
{
if ( componentIndex >= m_splitImagePtrs.size() )
{
return nullptr;
}
const auto& image = m_splitImagePtrs[ componentIndex ];
const vtkSmartPointer< vtkImageData > imageData =
utility::convertITKImageToVTKImageData< ComponentType >( image );
return imageData;
}
template< class ComponentType >
std::vector< vtkSmartPointer< vtkImageData > >
ImageData< ComponentType >::asVTKImageData() const
{
std::vector< vtkSmartPointer< vtkImageData > > data(
m_imageIOInfo.m_pixelInfo.m_numComponents );
for ( uint32_t i = 0; i < m_imageIOInfo.m_pixelInfo.m_numComponents; ++i )
{
data[i] = asVTKImageData( i );
}
return data;
}
template< class ComponentType >
bool ImageData< ComponentType >::getPixelAsDouble(
const uint32_t componentIndex,
uint32_t i, uint32_t j, uint32_t k,
double& value ) const
{
if ( componentIndex >= m_splitImagePtrs.size() )
{
std::ostringstream ss;
ss << "Attempting to access invalid image component " << componentIndex << std::ends;
throw std::runtime_error( ss.str() );
}
const auto& image = m_splitImagePtrs[ componentIndex ];
if ( ! image )
{
std::ostringstream ss;
ss << "Null image component " << componentIndex << std::ends;
throw std::runtime_error( ss.str() );
}
typename image3d::ImageType< ComponentType >::RegionType region =
image->GetLargestPossibleRegion();
typename image3d::ImageType< ComponentType >::IndexType index = {{ i, j, k }};
if ( region.IsInside( index ) )
{
value = static_cast<double>( image->GetPixel( index ) );
return true;
}
else
{
return false;
}
}
template< class ComponentType >
std::vector< typename image3d::ImageType< ComponentType >::Pointer >
ImageData< ComponentType >::asSplitITKImage() const
{
return m_splitImagePtrs;
}
template< class ComponentType >
typename image3d::ImageType< ComponentType >::Pointer
ImageData< ComponentType >::asITKImage() const
{
return utility::downcastImageBaseToImage< ComponentType, 3 >( m_imageBasePtr );
}
template< class ComponentType >
typename image3d::VectorImageType< ComponentType >::Pointer
ImageData< ComponentType >::asITKVectorImage() const
{
return utility::downcastImageBaseToVectorImage< ComponentType, 3 >( m_imageBasePtr );
}
/**
* @note Data of multi-component (vector) images gets duplicated by this function:
* one copy pointed to by base class' \c m_imageBasePtr;
* the other copy pointed to by this class' \c m_splitImagePtrs
*/
template< class ComponentType >
bool ImageData< ComponentType >::splitImageIntoComponents()
{
if ( isVectorImage() )
{
const typename image3d::VectorImageType< ComponentType >::Pointer
vectorImage = asITKVectorImage();
if ( vectorImage.IsNull() )
{
std::cerr << "Error obtaining vector image." << std::endl;
return false;
}
/// @internal Same as m_imageInfo.m_pixelInfo.m_numComponents:
const uint32_t numComponents = vectorImage->GetVectorLength();
m_splitImagePtrs.resize( numComponents );
for ( uint32_t i = 0; i < numComponents; ++i )
{
m_splitImagePtrs[i] = image3d::ImageType< ComponentType >::New();
m_splitImagePtrs[i]->CopyInformation( vectorImage );
m_splitImagePtrs[i]->SetRegions( vectorImage->GetBufferedRegion() );
m_splitImagePtrs[i]->Allocate();
ComponentType* source = vectorImage->GetBufferPointer() + i;
ComponentType* dest = m_splitImagePtrs[i]->GetBufferPointer();
const ComponentType* end = dest + numPixels();
/// @internal Copy pixels from component \c i of \c vectorImage (the source),
/// which are offset from each other by a stride of \c numComponents,
/// into pixels of the i'th split image (the destination)
while ( dest < end )
{
*dest = *source;
++dest;
source += numComponents;
}
}
}
else
{
const typename image3d::ImageType< ComponentType >::Pointer
image = asITKImage();
if ( image.IsNull() )
{
std::cerr << "Error obtaining image." << std::endl;
return false;
}
/// @internal Image has only one component
m_splitImagePtrs.resize( 1 );
m_splitImagePtrs[0] = image;
}
return true;
}
template< class ComponentType >
bool ImageData< ComponentType >::computePixelStatistics()
{
try
{
m_pixelStatistics.clear();
for ( const auto& image : m_splitImagePtrs )
{
auto stats = utility::computeImagePixelStatistics<
image3d::ImageType< ComponentType > >( image );
utility::PixelStatistics< double > cs;
cs.m_minimum = static_cast< double >( stats.m_minimum );
cs.m_maximum = static_cast< double >( stats.m_maximum );
cs.m_mean = stats.m_mean;
cs.m_stdDeviation = stats.m_stdDeviation;
cs.m_variance = stats.m_variance;
cs.m_sum = stats.m_sum;
cs.m_histogram = std::move( stats.m_histogram );
cs.m_quantiles = std::move( stats.m_quantiles );
m_pixelStatistics.push_back( cs );
}
return true;
}
catch ( const ::itk::ExceptionObject& e )
{
std::cerr << "Exception while computing image statistics: " << e.what() << std::endl;
return false;
}
catch ( ... )
{
std::cerr << "Exception while computing image statistics." << std::endl;
return false;
}
}
} // namespace itkdetails
#if 0
template<class TPixel, unsigned int VDim>
void
cloneImage()
{
// Simply make a copy of the input image on the stack
ImagePointer output = ImageType::New();
output->SetRegions(input->GetBufferedRegion());
output->SetSpacing(input->GetSpacing());
output->SetOrigin(input->GetOrigin());
output->SetDirection(input->GetDirection());
output->SetMetaDataDictionary(input->GetMetaDataDictionary());
output->Allocate();
size_t n = input->GetBufferedRegion().GetNumberOfPixels();
for(size_t i = 0; i < n; i++)
output->GetBufferPointer()[i] = input->GetBufferPointer()[i];
}
#endif
| 28.406308
| 98
| 0.631572
|
halfmvsq
|
fe1b6be7921d2184a4ff9e7e02334bad65bcee65
| 89,965
|
cc
|
C++
|
google/cloud/spanner/samples/samples.cc
|
antfitch/google-cloud-cpp-spanner
|
05a2e3ad3ee0ac96164013ce4d9cfce251059569
|
[
"Apache-2.0"
] | null | null | null |
google/cloud/spanner/samples/samples.cc
|
antfitch/google-cloud-cpp-spanner
|
05a2e3ad3ee0ac96164013ce4d9cfce251059569
|
[
"Apache-2.0"
] | null | null | null |
google/cloud/spanner/samples/samples.cc
|
antfitch/google-cloud-cpp-spanner
|
05a2e3ad3ee0ac96164013ce4d9cfce251059569
|
[
"Apache-2.0"
] | null | null | null |
// Copyright 2019 Google LLC
//
// 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.
//! [START spanner_quickstart]
#include "google/cloud/spanner/client.h"
//! [END spanner_quickstart]
#include "google/cloud/spanner/create_instance_request_builder.h"
#include "google/cloud/spanner/database_admin_client.h"
#include "google/cloud/spanner/instance_admin_client.h"
#include "google/cloud/spanner/row.h"
#include "google/cloud/spanner/testing/pick_random_instance.h"
#include "google/cloud/spanner/testing/random_database_name.h"
#include "google/cloud/spanner/testing/random_instance_name.h"
#include "google/cloud/spanner/update_instance_request_builder.h"
#include "google/cloud/internal/getenv.h"
#include "google/cloud/internal/random.h"
#include "google/cloud/optional.h"
#include <chrono>
#include <sstream>
#include <tuple>
#include <utility>
namespace {
//! [get-instance]
void GetInstance(google::cloud::spanner::InstanceAdminClient client,
std::string const& project_id,
std::string const& instance_id) {
google::cloud::spanner::Instance in(project_id, instance_id);
auto instance = client.GetInstance(in);
if (!instance) throw std::runtime_error(instance.status().message());
std::cout << "The instance " << instance->name()
<< " exists and its metadata is:\n"
<< instance->DebugString() << "\n";
}
//! [get-instance]
void GetInstanceCommand(std::vector<std::string> const& argv) {
if (argv.size() != 2) {
throw std::runtime_error("get-instance <project-id> <instance-id>");
}
google::cloud::spanner::InstanceAdminClient client(
google::cloud::spanner::MakeInstanceAdminConnection());
GetInstance(std::move(client), argv[0], argv[1]);
}
//! [create-instance]
void CreateInstance(google::cloud::spanner::InstanceAdminClient client,
std::string const& project_id,
std::string const& instance_id,
std::string const& display_name) {
using ::google::cloud::future;
using ::google::cloud::StatusOr;
google::cloud::spanner::Instance in(project_id, instance_id);
std::vector<std::string> instance_config_names = [client,
project_id]() mutable {
std::vector<std::string> names;
for (auto const& instance_config : client.ListInstanceConfigs(project_id)) {
if (!instance_config) break;
names.push_back(instance_config->name());
}
return names;
}();
if (instance_config_names.empty()) {
throw std::runtime_error("Can not retrieve the list of instance configs.");
}
// Use the name of the first element from the list of instance configs.
auto instance_config = instance_config_names[0];
future<StatusOr<google::spanner::admin::instance::v1::Instance>> f =
client.CreateInstance(
google::cloud::spanner::CreateInstanceRequestBuilder(in,
instance_config)
.SetDisplayName(display_name)
.SetNodeCount(1)
.SetLabels({{"label-key", "label-value"}})
.Build());
StatusOr<google::spanner::admin::instance::v1::Instance> instance = f.get();
if (!instance) {
throw std::runtime_error(instance.status().message());
}
std::cout << "Created instance [" << in << "]\n";
}
//! [create-instance]
void CreateInstanceCommand(std::vector<std::string> const& argv) {
if (argv.size() != 3) {
throw std::runtime_error(
"create-instance <project-id> <instance-id> <display_name>");
}
google::cloud::spanner::InstanceAdminClient client(
google::cloud::spanner::MakeInstanceAdminConnection());
CreateInstance(std::move(client), argv[0], argv[1], argv[2]);
}
//! [update-instance]
void UpdateInstance(google::cloud::spanner::InstanceAdminClient client,
std::string const& project_id,
std::string const& instance_id,
std::string const& new_display_name) {
using ::google::cloud::future;
using ::google::cloud::StatusOr;
google::cloud::spanner::Instance in(project_id, instance_id);
auto f = client.UpdateInstance(
google::cloud::spanner::UpdateInstanceRequestBuilder(in)
.SetDisplayName(new_display_name)
.Build());
auto instance = f.get();
if (!instance) {
throw std::runtime_error(instance.status().message());
}
std::cout << "Updated instance [" << in << "]\n";
}
//! [update-instance]
void UpdateInstanceCommand(std::vector<std::string> const& argv) {
if (argv.size() != 3) {
throw std::runtime_error(
"update-instance <project-id> <instance-id> <new_display_name>");
}
google::cloud::spanner::InstanceAdminClient client(
google::cloud::spanner::MakeInstanceAdminConnection());
UpdateInstance(std::move(client), argv[0], argv[1], argv[2]);
}
//! [delete-instance]
void DeleteInstance(google::cloud::spanner::InstanceAdminClient client,
std::string const& project_id,
std::string const& instance_id) {
google::cloud::spanner::Instance in(project_id, instance_id);
auto status = client.DeleteInstance(in);
if (!status.ok()) {
throw std::runtime_error(status.message());
}
std::cout << "Deleted instance [" << in << "]\n";
}
//! [delete-instance]
void DeleteInstanceCommand(std::vector<std::string> const& argv) {
if (argv.size() != 2) {
throw std::runtime_error("delete-instance <project-id> <instance-id>");
}
google::cloud::spanner::InstanceAdminClient client(
google::cloud::spanner::MakeInstanceAdminConnection());
DeleteInstance(std::move(client), argv[0], argv[1]);
}
//! [list-instance-configs]
void ListInstanceConfigs(google::cloud::spanner::InstanceAdminClient client,
std::string const& project_id) {
int count = 0;
for (auto const& instance_config : client.ListInstanceConfigs(project_id)) {
if (!instance_config) {
throw std::runtime_error(instance_config.status().message());
}
++count;
std::cout << "Instance config [" << count << "]:\n"
<< instance_config->DebugString() << "\n";
}
if (count == 0) {
std::cout << "No instance configs found in project " << project_id;
}
}
//! [list-instance-configs]
void ListInstanceConfigsCommand(std::vector<std::string> const& argv) {
if (argv.size() != 1) {
throw std::runtime_error("list-instance-configs <project-id>");
}
google::cloud::spanner::InstanceAdminClient client(
google::cloud::spanner::MakeInstanceAdminConnection());
ListInstanceConfigs(std::move(client), argv[0]);
}
//! [get-instance-config]
void GetInstanceConfig(google::cloud::spanner::InstanceAdminClient client,
std::string const& project_id,
std::string const& instance_config_name) {
auto instance_config = client.GetInstanceConfig(
"projects/" + project_id + "/instanceConfigs/" + instance_config_name);
if (!instance_config) {
throw std::runtime_error(instance_config.status().message());
}
std::cout << "The instanceConfig " << instance_config->name()
<< " exists and its metadata is:\n"
<< instance_config->DebugString() << "\n";
}
//! [get-instance-config]
void GetInstanceConfigCommand(std::vector<std::string> const& argv) {
if (argv.size() != 2) {
throw std::runtime_error(
"get-instance-config <project-id> <instance-config-name>");
}
google::cloud::spanner::InstanceAdminClient client(
google::cloud::spanner::MakeInstanceAdminConnection());
GetInstanceConfig(std::move(client), argv[0], argv[1]);
}
//! [list-instances]
void ListInstances(google::cloud::spanner::InstanceAdminClient client,
std::string const& project_id) {
int count = 0;
for (auto const& instance : client.ListInstances(project_id, "")) {
if (!instance) throw std::runtime_error(instance.status().message());
++count;
std::cout << "Instance [" << count << "]:\n"
<< instance->DebugString() << "\n";
}
if (count == 0) {
std::cout << "No instances found in project " << project_id;
}
}
//! [list-instances]
void ListInstancesCommand(std::vector<std::string> const& argv) {
if (argv.size() != 1) {
throw std::runtime_error("list-instances <project-id>");
}
google::cloud::spanner::InstanceAdminClient client(
google::cloud::spanner::MakeInstanceAdminConnection());
ListInstances(std::move(client), argv[0]);
}
//! [instance-get-iam-policy]
void InstanceGetIamPolicy(google::cloud::spanner::InstanceAdminClient client,
std::string const& project_id,
std::string const& instance_id) {
google::cloud::spanner::Instance in(project_id, instance_id);
auto actual = client.GetIamPolicy(in);
if (!actual) throw std::runtime_error(actual.status().message());
std::cout << "The IAM policy for instance " << instance_id << " is:\n"
<< actual->DebugString() << "\n";
}
//! [instance-get-iam-policy]
void InstanceGetIamPolicyCommand(std::vector<std::string> const& argv) {
if (argv.size() != 2) {
throw std::runtime_error(
"instance-get-iam-policy <project-id> <instance-id>");
}
google::cloud::spanner::InstanceAdminClient client(
google::cloud::spanner::MakeInstanceAdminConnection());
InstanceGetIamPolicy(std::move(client), argv[0], argv[1]);
}
//! [add-database-reader]
void AddDatabaseReader(google::cloud::spanner::InstanceAdminClient client,
std::string const& project_id,
std::string const& instance_id,
std::string const& new_reader) {
google::cloud::spanner::Instance in(project_id, instance_id);
auto result = client.SetIamPolicy(
in,
[&new_reader](google::iam::v1::Policy current)
-> google::cloud::optional<google::iam::v1::Policy> {
// Find (or create) the binding for "roles/spanner.databaseReader".
auto& binding = [¤t]() -> google::iam::v1::Binding& {
auto role_pos = std::find_if(
current.mutable_bindings()->begin(),
current.mutable_bindings()->end(),
[](google::iam::v1::Binding const& b) {
return b.role() == "roles/spanner.databaseReader" &&
!b.has_condition();
});
if (role_pos != current.mutable_bindings()->end()) {
return *role_pos;
}
auto& binding = *current.add_bindings();
binding.set_role("roles/spanner.databaseReader");
return binding;
}();
auto member_pos = std::find(binding.members().begin(),
binding.members().end(), new_reader);
if (member_pos != binding.members().end()) {
std::cout << "The entity " << new_reader
<< " is already a database reader:\n"
<< current.DebugString();
return {};
}
binding.add_members(new_reader);
return current;
});
if (!result) throw std::runtime_error(result.status().message());
std::cout << "Successfully added " << new_reader
<< " to the database reader role:\n"
<< result->DebugString() << "\n";
}
//! [add-database-reader]
void AddDatabaseReaderCommand(std::vector<std::string> const& argv) {
if (argv.size() != 3) {
throw std::runtime_error(
"add-database-reader <project-id> <instance-id> <new-reader>");
}
google::cloud::spanner::InstanceAdminClient client(
google::cloud::spanner::MakeInstanceAdminConnection());
AddDatabaseReader(std::move(client), argv[0], argv[1], argv[2]);
}
//! [remove-database-reader]
void RemoveDatabaseReader(google::cloud::spanner::InstanceAdminClient client,
std::string const& project_id,
std::string const& instance_id,
std::string const& reader) {
google::cloud::spanner::Instance in(project_id, instance_id);
auto result = client.SetIamPolicy(
in,
[&reader](google::iam::v1::Policy current)
-> google::cloud::optional<google::iam::v1::Policy> {
// Find the binding for "roles/spanner.databaseReader".
auto role_pos =
std::find_if(current.mutable_bindings()->begin(),
current.mutable_bindings()->end(),
[](google::iam::v1::Binding const& b) {
return b.role() == "roles/spanner.databaseReader" &&
!b.has_condition();
});
if (role_pos == current.mutable_bindings()->end()) {
std::cout << "Nothing to do as the roles/spanner.databaseReader role "
"is empty\n";
return {};
}
role_pos->mutable_members()->erase(
std::remove(role_pos->mutable_members()->begin(),
role_pos->mutable_members()->end(), reader),
role_pos->mutable_members()->end());
return current;
});
if (!result) throw std::runtime_error(result.status().message());
std::cout << "Successfully removed " << reader
<< " from the database reader role:\n"
<< result->DebugString() << "\n";
}
//! [remove-database-reader]
void RemoveDatabaseReaderCommand(std::vector<std::string> const& argv) {
if (argv.size() != 3) {
throw std::runtime_error(
"remove-database-reader <project-id> <instance-id> <existing-reader>");
}
google::cloud::spanner::InstanceAdminClient client(
google::cloud::spanner::MakeInstanceAdminConnection());
RemoveDatabaseReader(std::move(client), argv[0], argv[1], argv[2]);
}
//! [instance-test-iam-permissions]
void InstanceTestIamPermissions(
google::cloud::spanner::InstanceAdminClient client,
std::string const& project_id, std::string const& instance_id) {
google::cloud::spanner::Instance in(project_id, instance_id);
auto actual = client.TestIamPermissions(in, {"spanner.databases.list"});
if (!actual) throw std::runtime_error(actual.status().message());
char const* msg = actual->permissions().empty() ? "does not" : "does";
std::cout
<< "The caller " << msg
<< " have permission to list databases on the Cloud Spanner instance "
<< in.instance_id() << "\n";
}
//! [instance-test-iam-permissions]
void InstanceTestIamPermissionsCommand(std::vector<std::string> const& argv) {
if (argv.size() != 2) {
throw std::runtime_error(
"instance-test-iam-permissions <project-id> <instance-id>");
}
google::cloud::spanner::InstanceAdminClient client(
google::cloud::spanner::MakeInstanceAdminConnection());
InstanceTestIamPermissions(std::move(client), argv[0], argv[1]);
}
//! [create-database] [START spanner_create_database]
void CreateDatabase(google::cloud::spanner::DatabaseAdminClient client,
std::string const& project_id,
std::string const& instance_id,
std::string const& database_id) {
using ::google::cloud::future;
using ::google::cloud::StatusOr;
google::cloud::spanner::Database database(project_id, instance_id,
database_id);
future<StatusOr<google::spanner::admin::database::v1::Database>> f =
client.CreateDatabase(database, {R"""(
CREATE TABLE Singers (
SingerId INT64 NOT NULL,
FirstName STRING(1024),
LastName STRING(1024),
SingerInfo BYTES(MAX)
) PRIMARY KEY (SingerId))""",
R"""(
CREATE TABLE Albums (
SingerId INT64 NOT NULL,
AlbumId INT64 NOT NULL,
AlbumTitle STRING(MAX)
) PRIMARY KEY (SingerId, AlbumId),
INTERLEAVE IN PARENT Singers ON DELETE CASCADE)"""});
StatusOr<google::spanner::admin::database::v1::Database> db = f.get();
if (!db) {
throw std::runtime_error(db.status().message());
}
std::cout << "Created database [" << database << "]\n";
}
//! [create-database] [END spanner_create_database]
// [START spanner_create_table_with_timestamp_column]
void CreateTableWithTimestamp(
google::cloud::spanner::DatabaseAdminClient client,
std::string const& project_id, std::string const& instance_id,
std::string const& database_id) {
using ::google::cloud::future;
using ::google::cloud::StatusOr;
google::cloud::spanner::Database database(project_id, instance_id,
database_id);
future<
StatusOr<google::spanner::admin::database::v1::UpdateDatabaseDdlMetadata>>
f = client.UpdateDatabase(database, {R"""(
CREATE TABLE Performances (
SingerId INT64 NOT NULL,
VenueId INT64 NOT NULL,
EventDate Date,
Revenue INT64,
LastUpdateTime TIMESTAMP NOT NULL OPTIONS
(allow_commit_timestamp=true)
) PRIMARY KEY (SingerId, VenueId, EventDate),
INTERLEAVE IN PARENT Singers ON DELETE CASCADE)"""});
StatusOr<google::spanner::admin::database::v1::UpdateDatabaseDdlMetadata>
metadata = f.get();
if (!metadata) {
throw std::runtime_error(metadata.status().message());
}
std::cout << "`Performances` table created, new DDL:\n"
<< metadata->DebugString() << "\n";
}
// [END spanner_create_table_with_timestamp_column]
// [START spanner_create_index]
void AddIndex(google::cloud::spanner::DatabaseAdminClient client,
std::string const& project_id, std::string const& instance_id,
std::string const& database_id) {
using ::google::cloud::future;
using ::google::cloud::StatusOr;
google::cloud::spanner::Database database(project_id, instance_id,
database_id);
future<
StatusOr<google::spanner::admin::database::v1::UpdateDatabaseDdlMetadata>>
f = client.UpdateDatabase(
database, {"CREATE INDEX AlbumsByAlbumTitle ON Albums(AlbumTitle)"});
StatusOr<google::spanner::admin::database::v1::UpdateDatabaseDdlMetadata>
metadata = f.get();
if (!metadata) {
throw std::runtime_error(metadata.status().message());
}
std::cout << "`AlbumsByAlbumTitle` Index successfully added, new DDL:\n"
<< metadata->DebugString() << "\n";
}
// [END spanner_create_index]
//! [get-database]
void GetDatabase(google::cloud::spanner::DatabaseAdminClient client,
std::string const& project_id, std::string const& instance_id,
std::string const& database_id) {
namespace spanner = ::google::cloud::spanner;
auto database = client.GetDatabase(
spanner::Database(project_id, instance_id, database_id));
if (!database) throw std::runtime_error(database.status().message());
std::cout << "Database metadata is:\n" << database->DebugString() << "\n";
}
//! [get-database]
//! [get-database-ddl]
void GetDatabaseDdl(google::cloud::spanner::DatabaseAdminClient client,
std::string const& project_id,
std::string const& instance_id,
std::string const& database_id) {
namespace spanner = ::google::cloud::spanner;
auto database = client.GetDatabaseDdl(
spanner::Database(project_id, instance_id, database_id));
if (!database) throw std::runtime_error(database.status().message());
std::cout << "Database metadata is:\n" << database->DebugString() << "\n";
}
//! [get-database-ddl]
//! [update-database] [START spanner_add_column]
void AddColumn(google::cloud::spanner::DatabaseAdminClient client,
std::string const& project_id, std::string const& instance_id,
std::string const& database_id) {
using ::google::cloud::future;
using ::google::cloud::StatusOr;
google::cloud::spanner::Database database(project_id, instance_id,
database_id);
future<
StatusOr<google::spanner::admin::database::v1::UpdateDatabaseDdlMetadata>>
f = client.UpdateDatabase(
database, {"ALTER TABLE Albums ADD COLUMN MarketingBudget INT64"});
StatusOr<google::spanner::admin::database::v1::UpdateDatabaseDdlMetadata>
metadata = f.get();
if (!metadata) {
throw std::runtime_error(metadata.status().message());
}
std::cout << "Added MarketingBudget column\n";
}
//! [update-database] [END spanner_add_column]
// [START spanner_add_timestamp_column]
void AddTimestampColumn(google::cloud::spanner::DatabaseAdminClient client,
std::string const& project_id,
std::string const& instance_id,
std::string const& database_id) {
using ::google::cloud::future;
using ::google::cloud::StatusOr;
google::cloud::spanner::Database database(project_id, instance_id,
database_id);
future<
StatusOr<google::spanner::admin::database::v1::UpdateDatabaseDdlMetadata>>
f = client.UpdateDatabase(
database, {"ALTER TABLE Albums ADD COLUMN LastUpdateTime TIMESTAMP "
"OPTIONS (allow_commit_timestamp=true)"});
StatusOr<google::spanner::admin::database::v1::UpdateDatabaseDdlMetadata>
metadata = f.get();
if (!metadata) {
throw std::runtime_error(metadata.status().message());
}
std::cout << "Added LastUpdateTime column\n";
}
// [END spanner_add_timestamp_column]
// [START spanner_create_storing_index]
void AddStoringIndex(google::cloud::spanner::DatabaseAdminClient client,
std::string const& project_id,
std::string const& instance_id,
std::string const& database_id) {
using ::google::cloud::future;
using ::google::cloud::StatusOr;
google::cloud::spanner::Database database(project_id, instance_id,
database_id);
future<
StatusOr<google::spanner::admin::database::v1::UpdateDatabaseDdlMetadata>>
f = client.UpdateDatabase(database, {R"""(
CREATE INDEX AlbumsByAlbumTitle2 ON Albums(AlbumTitle)
STORING (MarketingBudget))"""});
StatusOr<google::spanner::admin::database::v1::UpdateDatabaseDdlMetadata>
metadata = f.get();
if (!metadata) {
throw std::runtime_error(metadata.status().message());
}
std::cout << "`AlbumsByAlbumTitle2` Index successfully added, new DDL:\n"
<< metadata->DebugString() << "\n";
}
// [END spanner_create_storing_index]
//! [list-databases]
void ListDatabases(google::cloud::spanner::DatabaseAdminClient client,
std::string const& project_id,
std::string const& instance_id) {
google::cloud::spanner::Instance in(project_id, instance_id);
int count = 0;
for (auto const& database : client.ListDatabases(in)) {
if (!database) throw std::runtime_error(database.status().message());
std::cout << "Database " << database->name() << " full metadata:\n"
<< database->DebugString() << "\n";
++count;
}
if (count == 0) {
std::cout << "No databases found in instance " << instance_id
<< " for project << " << project_id << "\n";
}
}
//! [list-databases]
void ListDatabasesCommand(std::vector<std::string> const& argv) {
if (argv.size() != 2) {
throw std::runtime_error("list-databases <project-id> <instance-id>");
}
google::cloud::spanner::DatabaseAdminClient client;
ListDatabases(std::move(client), argv[0], argv[1]);
}
//! [drop-database] [START spanner_drop_database]
void DropDatabase(google::cloud::spanner::DatabaseAdminClient client,
std::string const& project_id, std::string const& instance_id,
std::string const& database_id) {
google::cloud::spanner::Database database(project_id, instance_id,
database_id);
google::cloud::Status status = client.DropDatabase(database);
if (!status.ok()) {
throw std::runtime_error(status.message());
}
std::cout << "Database " << database << " successfully dropped\n";
}
//! [drop-database] [END spanner_drop_database]
//! [database-get-iam-policy]
void DatabaseGetIamPolicy(google::cloud::spanner::DatabaseAdminClient client,
std::string const& project_id,
std::string const& instance_id,
std::string const& database_id) {
google::cloud::spanner::Database database(project_id, instance_id,
database_id);
auto actual = client.GetIamPolicy(database);
if (!actual) throw std::runtime_error(actual.status().message());
std::cout << "The IAM policy for database " << database_id << " is:\n"
<< actual->DebugString() << "\n";
}
//! [database-get-iam-policy]
//! [add-database-reader-on-database]
void AddDatabaseReaderOnDatabase(
google::cloud::spanner::DatabaseAdminClient client,
std::string const& project_id, std::string const& instance_id,
std::string const& database_id, std::string const& new_reader) {
google::cloud::spanner::Database database(project_id, instance_id,
database_id);
auto current = client.GetIamPolicy(database);
if (!current) throw std::runtime_error(current.status().message());
// Find (or create) the binding for "roles/spanner.databaseReader".
auto& binding = [¤t]() -> google::iam::v1::Binding& {
auto role_pos =
std::find_if(current->mutable_bindings()->begin(),
current->mutable_bindings()->end(),
[](google::iam::v1::Binding const& b) {
return b.role() == "roles/spanner.databaseReader" &&
!b.has_condition();
});
if (role_pos != current->mutable_bindings()->end()) {
return *role_pos;
}
auto& binding = *current->add_bindings();
binding.set_role("roles/spanner.databaseReader");
return binding;
}();
auto member_pos =
std::find(binding.members().begin(), binding.members().end(), new_reader);
if (member_pos != binding.members().end()) {
std::cout << "The entity " << new_reader
<< " is already a database reader:\n"
<< current->DebugString();
return;
}
binding.add_members(new_reader);
auto result = client.SetIamPolicy(database, *std::move(current));
if (!result) throw std::runtime_error(result.status().message());
std::cout << "Successfully added " << new_reader
<< " to the database reader role:\n"
<< result->DebugString() << "\n";
}
//! [add-database-reader-on-database]
void AddDatabaseReaderOnDatabaseCommand(std::vector<std::string> const& argv) {
if (argv.size() != 4) {
throw std::runtime_error(
"add-database-reader-on-database <project-id> <instance-id>"
" <database-id> <new-reader>");
}
google::cloud::spanner::DatabaseAdminClient client(
google::cloud::spanner::MakeDatabaseAdminConnection());
AddDatabaseReaderOnDatabase(std::move(client), argv[0], argv[1], argv[2],
argv[3]);
}
//! [database-test-iam-permissions]
void DatabaseTestIamPermissions(
google::cloud::spanner::DatabaseAdminClient client,
std::string const& project_id, std::string const& instance_id,
std::string const& database_id, std::string const& permission) {
google::cloud::spanner::Database db(project_id, instance_id, database_id);
auto actual = client.TestIamPermissions(db, {permission});
if (!actual) throw std::runtime_error(actual.status().message());
char const* msg = actual->permissions().empty() ? "does not" : "does";
std::cout << "The caller " << msg << " have permission '" << permission
<< "' on the Cloud Spanner database " << db.database_id() << "\n";
}
//! [database-test-iam-permissions]
void DatabaseTestIamPermissionsCommand(std::vector<std::string> const& argv) {
if (argv.size() != 4) {
throw std::runtime_error(
"database-test-iam-permissions <project-id> <instance-id>"
" <database-id> <permission>");
}
google::cloud::spanner::DatabaseAdminClient client(
google::cloud::spanner::MakeDatabaseAdminConnection());
DatabaseTestIamPermissions(std::move(client), argv[0], argv[1], argv[2],
argv[3]);
}
//! [quickstart] [START spanner_quickstart]
void Quickstart(std::string const& project_id, std::string const& instance_id,
std::string const& database_id) {
namespace spanner = ::google::cloud::spanner;
spanner::Client client(spanner::MakeConnection(
spanner::Database(project_id, instance_id, database_id)));
auto rows =
client.ExecuteQuery(spanner::SqlStatement("SELECT 'Hello World'"));
using RowType = std::tuple<std::string>;
for (auto const& row : spanner::StreamOf<RowType>(rows)) {
if (!row) throw std::runtime_error(row.status().message());
std::cout << std::get<0>(*row) << "\n";
}
}
//! [quickstart] [END spanner_quickstart]
void QuickstartCommand(std::vector<std::string> const& argv) {
if (argv.size() != 3) {
throw std::runtime_error(
"quickstart <project-id> <instance-id> <database-id>");
}
Quickstart(argv[0], argv[1], argv[2]);
}
google::cloud::spanner::Client MakeSampleClient(
std::string const& project_id, std::string const& instance_id,
std::string const& database_id) {
namespace spanner = ::google::cloud::spanner;
return spanner::Client(spanner::MakeConnection(
spanner::Database(project_id, instance_id, database_id)));
}
//! [START spanner_insert_data]
void InsertData(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
using ::google::cloud::StatusOr;
auto insert_singers = spanner::InsertMutationBuilder(
"Singers", {"SingerId", "FirstName", "LastName"})
.EmplaceRow(1, "Marc", "Richards")
.EmplaceRow(2, "Catalina", "Smith")
.EmplaceRow(3, "Alice", "Trentor")
.EmplaceRow(4, "Lea", "Martin")
.EmplaceRow(5, "David", "Lomond")
.Build();
auto insert_albums = spanner::InsertMutationBuilder(
"Albums", {"SingerId", "AlbumId", "AlbumTitle"})
.EmplaceRow(1, 1, "Total Junk")
.EmplaceRow(1, 2, "Go, Go, Go")
.EmplaceRow(2, 1, "Green")
.EmplaceRow(2, 2, "Forever Hold Your Peace")
.EmplaceRow(2, 3, "Terrified")
.Build();
auto commit_result = client.Commit(
[&insert_singers, &insert_albums](spanner::Transaction const&) {
return spanner::Mutations{insert_singers, insert_albums};
});
if (!commit_result) {
throw std::runtime_error(commit_result.status().message());
}
std::cout << "Insert was successful [spanner_insert_data]\n";
}
//! [END spanner_insert_data]
//! [START spanner_update_data]
void UpdateData(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
using ::google::cloud::StatusOr;
auto commit_result = client.Commit([](spanner::Transaction const&) {
return spanner::Mutations{
spanner::UpdateMutationBuilder(
"Albums", {"SingerId", "AlbumId", "MarketingBudget"})
.EmplaceRow(1, 1, 100000)
.EmplaceRow(2, 2, 500000)
.Build()};
});
if (!commit_result) {
throw std::runtime_error(commit_result.status().message());
}
std::cout << "Update was successful [spanner_update_data]\n";
}
//! [END spanner_update_data]
//! [START spanner_delete_data]
void DeleteData(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
using ::google::cloud::StatusOr;
// Delete each of the albums by individual key, then delete all the singers
// using a key range.
auto delete_albums = spanner::DeleteMutationBuilder(
"Albums", spanner::KeySet()
.AddKey(spanner::MakeKey(1, 1))
.AddKey(spanner::MakeKey(1, 2))
.AddKey(spanner::MakeKey(2, 1))
.AddKey(spanner::MakeKey(2, 2))
.AddKey(spanner::MakeKey(2, 3)))
.Build();
auto delete_singers =
spanner::DeleteMutationBuilder(
"Singers", spanner::KeySet().AddRange(spanner::MakeKeyBoundClosed(1),
spanner::MakeKeyBoundClosed(5)))
.Build();
auto commit_result = client.Commit(
[&delete_albums, &delete_singers](spanner::Transaction const&) {
return spanner::Mutations{delete_albums, delete_singers};
});
if (!commit_result) {
throw std::runtime_error(commit_result.status().message());
}
std::cout << "Delete was successful [spanner_delete_data]\n";
}
//! [END spanner_update_data]
//! [START spanner_read_only_transaction]
void ReadOnlyTransaction(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
auto read_only = spanner::MakeReadOnlyTransaction();
spanner::SqlStatement select(
"SELECT SingerId, AlbumId, AlbumTitle FROM Albums");
using RowType = std::tuple<std::int64_t, std::int64_t, std::string>;
// Read#1.
auto rows1 = client.ExecuteQuery(read_only, select);
std::cout << "Read 1 results\n";
for (auto const& row : spanner::StreamOf<RowType>(rows1)) {
if (!row) {
throw std::runtime_error(row.status().message());
}
std::cout << "SingerId: " << std::get<0>(*row)
<< " AlbumId: " << std::get<1>(*row)
<< " AlbumTitle: " << std::get<2>(*row) << "\n";
}
// Read#2. Even if changes occur in-between the reads the transaction ensures
// that Read #1 and Read #2 return the same data.
auto rows2 = client.ExecuteQuery(read_only, select);
std::cout << "Read 2 results\n";
for (auto const& row : spanner::StreamOf<RowType>(rows2)) {
if (!row) {
throw std::runtime_error(row.status().message());
}
std::cout << "SingerId: " << std::get<0>(*row)
<< " AlbumId: " << std::get<1>(*row)
<< " AlbumTitle: " << std::get<2>(*row) << "\n";
}
}
//! [END spanner_read_only_transaction]
//! [START spanner_read_stale_data]
void ReadStaleData(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
auto opts = spanner::Transaction::ReadOnlyOptions(std::chrono::seconds(15));
auto read_only = spanner::MakeReadOnlyTransaction(opts);
spanner::SqlStatement select(
"SELECT SingerId, AlbumId, AlbumTitle FROM Albums");
using RowType = std::tuple<std::int64_t, std::int64_t, std::string>;
auto rows = client.ExecuteQuery(read_only, select);
for (auto const& row : spanner::StreamOf<RowType>(rows)) {
if (!row) {
throw std::runtime_error(row.status().message());
}
std::cout << "SingerId: " << std::get<0>(*row)
<< " AlbumId: " << std::get<1>(*row)
<< " AlbumTitle: " << std::get<2>(*row) << "\n";
}
}
//! [END spanner_read_stale_data]
//! [START spanner_batch_client]
void UsePartitionQuery(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
auto txn = spanner::MakeReadOnlyTransaction();
spanner::SqlStatement select(
"SELECT SingerId, FirstName, LastName FROM Singers");
using RowType = std::tuple<std::int64_t, std::string, std::string>;
auto partitions = client.PartitionQuery(std::move(txn), select, {});
if (!partitions) {
throw std::runtime_error(partitions.status().message());
}
int number_of_rows = 0;
for (auto const& partition : *partitions) {
auto rows = client.ExecuteQuery(partition);
for (auto const& row : spanner::StreamOf<RowType>(rows)) {
if (!row) {
throw std::runtime_error(row.status().message());
}
number_of_rows++;
}
}
std::cout << "Number of partitions: " << partitions->size() << "\n"
<< "Number of rows: " << number_of_rows << "\n";
std::cout << "Read completed for [spanner_batch_client]\n";
}
//! [END spanner_batch_client]
//! [START spanner_read_data_with_index]
void ReadDataWithIndex(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
spanner::ReadOptions read_options;
read_options.index_name = "AlbumsByAlbumTitle";
auto rows = client.Read("Albums", google::cloud::spanner::KeySet::All(),
{"AlbumId", "AlbumTitle"}, read_options);
using RowType = std::tuple<std::int64_t, std::string>;
for (auto const& row : spanner::StreamOf<RowType>(rows)) {
if (!row) throw std::runtime_error(row.status().message());
std::cout << "AlbumId: " << std::get<0>(*row) << "\t";
std::cout << "AlbumTitle: " << std::get<1>(*row) << "\n";
}
std::cout << "Read completed for [spanner_read_data_with_index]\n";
}
//! [END spanner_read_data_with_index]
//! [START spanner_query_data_with_new_column]
void QueryNewColumn(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
spanner::SqlStatement select(
"SELECT SingerId, AlbumId, MarketingBudget FROM Albums");
using RowType = std::tuple<std::int64_t, std::int64_t,
google::cloud::optional<std::int64_t>>;
auto rows = client.ExecuteQuery(std::move(select));
for (auto const& row : spanner::StreamOf<RowType>(rows)) {
if (!row) throw std::runtime_error(row.status().message());
std::cout << "SingerId: " << std::get<0>(*row) << "\t";
std::cout << "AlbumId: " << std::get<1>(*row) << "\t";
auto marketing_budget = std::get<2>(*row);
if (marketing_budget) {
std::cout << "MarketingBudget: " << marketing_budget.value() << "\n";
} else {
std::cout << "MarketingBudget: NULL\n";
}
}
std::cout << "Read completed for [spanner_read_data_with_new_column]\n";
}
//! [END spanner_query_data_with_new_column]
//! [START spanner_query_data_with_index]
void QueryUsingIndex(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
spanner::SqlStatement select(
"SELECT AlbumId, AlbumTitle, MarketingBudget"
" FROM Albums@{FORCE_INDEX=AlbumsByAlbumTitle}"
" WHERE AlbumTitle >= @start_title AND AlbumTitle < @end_title",
{{"start_title", spanner::Value("Aardvark")},
{"end_title", spanner::Value("Goo")}});
using RowType = std::tuple<std::int64_t, std::string,
google::cloud::optional<std::int64_t>>;
auto rows = client.ExecuteQuery(std::move(select));
for (auto const& row : spanner::StreamOf<RowType>(rows)) {
if (!row) throw std::runtime_error(row.status().message());
std::cout << "AlbumId: " << std::get<0>(*row) << "\t";
std::cout << "AlbumTitle: " << std::get<1>(*row) << "\t";
auto marketing_budget = std::get<2>(*row);
if (marketing_budget) {
std::cout << "MarketingBudget: " << marketing_budget.value() << "\n";
} else {
std::cout << "MarketingBudget: NULL\n";
}
}
std::cout << "Read completed for [spanner_query_data_with_index]\n";
}
//! [END spanner_query_data_with_index]
//! [START spanner_read_data_with_storing_index]
void ReadDataWithStoringIndex(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
spanner::ReadOptions read_options;
read_options.index_name = "AlbumsByAlbumTitle2";
auto rows =
client.Read("Albums", google::cloud::spanner::KeySet::All(),
{"AlbumId", "AlbumTitle", "MarketingBudget"}, read_options);
using RowType = std::tuple<std::int64_t, std::string,
google::cloud::optional<std::int64_t>>;
for (auto const& row : spanner::StreamOf<RowType>(rows)) {
if (!row) throw std::runtime_error(row.status().message());
std::cout << "AlbumId: " << std::get<0>(*row) << "\t";
std::cout << "AlbumTitle: " << std::get<1>(*row) << "\t";
auto marketing_budget = std::get<2>(*row);
if (marketing_budget) {
std::cout << "MarketingBudget: " << marketing_budget.value() << "\n";
} else {
std::cout << "MarketingBudget: NULL\n";
}
}
std::cout << "Read completed for [spanner_read_data_with_storing_index]\n";
}
//! [END spanner_read_data_with_storing_index]
//! [START spanner_read_write_transaction]
void ReadWriteTransaction(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
using ::google::cloud::StatusOr;
// A helper to read a single album MarketingBudget.
auto get_current_budget =
[](spanner::Client client, spanner::Transaction txn,
std::int64_t singer_id,
std::int64_t album_id) -> StatusOr<std::int64_t> {
auto key = spanner::KeySet().AddKey(spanner::MakeKey(singer_id, album_id));
auto rows = client.Read(std::move(txn), "Albums", std::move(key),
{"MarketingBudget"});
using RowType = std::tuple<std::int64_t>;
auto row = spanner::GetSingularRow(spanner::StreamOf<RowType>(rows));
// Return the error (as opposed to throwing an exception) because
// Commit() only retries on StatusCode::kAborted.
if (!row) return std::move(row).status();
return std::get<0>(*std::move(row));
// Throw an exception because this should terminate the transaction.
throw std::runtime_error("Key not found (" + std::to_string(singer_id) +
"," + std::to_string(album_id) + ")");
};
auto commit = client.Commit(
[&client, &get_current_budget](
spanner::Transaction const& txn) -> StatusOr<spanner::Mutations> {
auto b1 = get_current_budget(client, txn, 1, 1);
if (!b1) return std::move(b1).status();
auto b2 = get_current_budget(client, txn, 2, 2);
if (!b2) return std::move(b2).status();
std::int64_t transfer_amount = 200000;
return spanner::Mutations{
spanner::UpdateMutationBuilder(
"Albums", {"SingerId", "AlbumId", "MarketingBudget"})
.EmplaceRow(1, 1, *b1 + transfer_amount)
.EmplaceRow(2, 2, *b2 - transfer_amount)
.Build()};
});
if (!commit) throw std::runtime_error(commit.status().message());
std::cout << "Transfer was successful [spanner_read_write_transaction]\n";
}
//! [END spanner_read_write_transaction]
//! [START spanner_dml_standard_insert]
void DmlStandardInsert(google::cloud::spanner::Client client) {
using ::google::cloud::StatusOr;
namespace spanner = ::google::cloud::spanner;
auto commit_result = client.Commit(
[&client](spanner::Transaction txn) -> StatusOr<spanner::Mutations> {
auto insert = client.ExecuteDml(
std::move(txn),
spanner::SqlStatement(
"INSERT INTO Singers (SingerId, FirstName, LastName)"
" VALUES (10, 'Virginia', 'Watson')",
{}));
if (!insert) return insert.status();
return spanner::Mutations{};
});
if (!commit_result) {
throw std::runtime_error(commit_result.status().message());
}
std::cout << "Insert was successful [spanner_dml_standard_insert]\n";
}
//! [END spanner_dml_standard_insert]
//! [START spanner_dml_standard_update]
void DmlStandardUpdate(google::cloud::spanner::Client client) {
using ::google::cloud::StatusOr;
namespace spanner = ::google::cloud::spanner;
auto commit_result = client.Commit(
[&client](spanner::Transaction txn) -> StatusOr<spanner::Mutations> {
auto update = client.ExecuteDml(
std::move(txn),
spanner::SqlStatement(
"UPDATE Albums SET MarketingBudget = MarketingBudget * 2"
" WHERE SingerId = 1 AND AlbumId = 1",
{}));
if (!update) return update.status();
return spanner::Mutations{};
});
if (!commit_result) {
throw std::runtime_error(commit_result.status().message());
}
std::cout << "Update was successful [spanner_dml_standard_update]\n";
}
//! [END spanner_dml_standard_update]
// [START spanner_dml_standard_update_with_timestamp]
void DmlStandardUpdateWithTimestamp(google::cloud::spanner::Client client) {
using ::google::cloud::StatusOr;
namespace spanner = ::google::cloud::spanner;
auto commit_result = client.Commit(
[&client](spanner::Transaction txn) -> StatusOr<spanner::Mutations> {
auto update = client.ExecuteDml(
std::move(txn),
spanner::SqlStatement(
"UPDATE Albums SET LastUpdateTime = PENDING_COMMIT_TIMESTAMP() "
"WHERE SingerId = 1"));
if (!update) return update.status();
return spanner::Mutations{};
});
if (!commit_result) {
throw std::runtime_error(commit_result.status().message());
}
std::cout << "Update was successful "
<< "[spanner_dml_standard_update_with_timestamp]\n";
}
// [END spanner_dml_standard_update_with_timestamp]
//! [START spanner_dml_write_then_read]
void DmlWriteThenRead(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
using ::google::cloud::StatusOr;
auto commit_result = client.Commit(
[&client](spanner::Transaction txn) -> StatusOr<spanner::Mutations> {
auto insert = client.ExecuteDml(
txn, spanner::SqlStatement(
"INSERT INTO Singers (SingerId, FirstName, LastName)"
" VALUES (11, 'Timothy', 'Campbell')",
{}));
if (!insert) return insert.status();
// Read newly inserted record.
spanner::SqlStatement select(
"SELECT FirstName, LastName FROM Singers where SingerId = 11");
using RowType = std::tuple<std::string, std::string>;
auto rows = client.ExecuteQuery(std::move(txn), std::move(select));
for (auto const& row : spanner::StreamOf<RowType>(rows)) {
if (!row) return row.status();
std::cout << "FirstName: " << std::get<0>(*row) << "\t";
std::cout << "LastName: " << std::get<1>(*row) << "\n";
}
return spanner::Mutations{};
});
if (!commit_result) {
throw std::runtime_error(commit_result.status().message());
}
std::cout << "Write then read suceeded [spanner_dml_write_then_read]\n";
}
//! [END spanner_dml_write_then_read]
//! [START spanner_dml_standard_delete]
void DmlStandardDelete(google::cloud::spanner::Client client) {
using ::google::cloud::StatusOr;
namespace spanner = ::google::cloud::spanner;
auto commit_result = client.Commit([&client](spanner::Transaction txn)
-> StatusOr<spanner::Mutations> {
auto dele = client.ExecuteDml(
std::move(txn),
spanner::SqlStatement("DELETE FROM Singers WHERE FirstName = 'Alice'"));
if (!dele) return dele.status();
return spanner::Mutations{};
});
if (!commit_result) {
throw std::runtime_error(commit_result.status().message());
}
std::cout << "Delete was successful [spanner_dml_standard_delete]\n";
}
//! [END spanner_dml_standard_delete]
//! [execute-sql-partitioned] [START spanner_dml_partitioned_delete]
void DmlPartitionedDelete(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
auto result = client.ExecutePartitionedDml(
spanner::SqlStatement("DELETE FROM Singers WHERE SingerId > 10"));
if (!result) throw std::runtime_error(result.status().message());
std::cout << "Delete was successful [spanner_dml_partitioned_delete]\n";
}
//! [execute-sql-partitioned] [END spanner_dml_partitioned_delete]
//! [START spanner_dml_partitioned_update]
void DmlPartitionedUpdate(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
auto result = client.ExecutePartitionedDml(
spanner::SqlStatement("UPDATE Albums SET MarketingBudget = 100000"
" WHERE SingerId > 1"));
if (!result) throw std::runtime_error(result.status().message());
std::cout << "Update was successful [spanner_dml_partitioned_update]\n";
}
//! [END spanner_dml_partitioned_update]
//! [START spanner_dml_batch_update]
void DmlBatchUpdate(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
auto commit_result =
client.Commit([&client](spanner::Transaction const& txn)
-> google::cloud::StatusOr<spanner::Mutations> {
std::vector<spanner::SqlStatement> statements = {
spanner::SqlStatement("INSERT INTO Albums"
" (SingerId, AlbumId, AlbumTitle,"
" MarketingBudget)"
" VALUES (1, 3, 'Test Album Title', 10000)"),
spanner::SqlStatement("UPDATE Albums"
" SET MarketingBudget = MarketingBudget * 2"
" WHERE SingerId = 1 and AlbumId = 3")};
auto result = client.ExecuteBatchDml(txn, statements);
if (!result) return result.status();
for (std::size_t i = 0; i < result->stats.size(); ++i) {
std::cout << result->stats[i].row_count << " rows affected"
<< " for the statement " << (i + 1) << ".\n";
}
// Batch operations may have partial failures, in which case
// ExecuteBatchDml returns with success, but the application should
// verify that all statements completed successfully
if (!result->status.ok()) return result->status;
return spanner::Mutations{};
});
if (!commit_result) {
throw std::runtime_error(commit_result.status().message());
}
std::cout << "Update was successful [spanner_dml_batch_update]\n";
}
//! [END spanner_dml_batch_update]
//
//! [START spanner_dml_structs]
void DmlStructs(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
std::int64_t rows_modified = 0;
auto commit_result =
client.Commit([&client, &rows_modified](spanner::Transaction const& txn)
-> google::cloud::StatusOr<spanner::Mutations> {
auto singer_info = std::make_tuple("Marc", "Richards");
auto sql = spanner::SqlStatement(
"UPDATE Singers SET FirstName = 'Keith' WHERE "
"STRUCT<FirstName String, LastName String>(FirstName, LastName) "
"= @name",
{{"name", spanner::Value(std::move(singer_info))}});
auto dml_result = client.ExecuteDml(txn, std::move(sql));
if (!dml_result) return dml_result.status();
rows_modified = dml_result->RowsModified();
return spanner::Mutations{};
});
if (!commit_result) {
throw std::runtime_error(commit_result.status().message());
}
std::cout << rows_modified
<< " update was successful [spanner_dml_structs]\n";
}
//! [END spanner_dml_structs]
//! [START spanner_write_data_for_struct_queries]
void WriteDataForStructQueries(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
using ::google::cloud::StatusOr;
auto commit_result = client.Commit([](spanner::Transaction const&) {
return spanner::Mutations{
spanner::InsertMutationBuilder("Singers",
{"SingerId", "FirstName", "LastName"})
.EmplaceRow(6, "Elena", "Campbell")
.EmplaceRow(7, "Gabriel", "Wright")
.EmplaceRow(8, "Benjamin", "Martinez")
.EmplaceRow(9, "Hannah", "Harris")
.Build()};
});
if (!commit_result) {
throw std::runtime_error(commit_result.status().message());
}
std::cout << "Insert was successful "
<< "[spanner_write_data_for_struct_queries]\n";
}
//! [END spanner_write_data_for_struct_queries]
//! [START spanner_query_data]
void QueryData(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
spanner::SqlStatement select("SELECT SingerId, LastName FROM Singers");
using RowType = std::tuple<std::int64_t, std::string>;
auto rows = client.ExecuteQuery(std::move(select));
for (auto const& row : spanner::StreamOf<RowType>(rows)) {
if (!row) throw std::runtime_error(row.status().message());
std::cout << "SingerId: " << std::get<0>(*row) << "\t";
std::cout << "LastName: " << std::get<1>(*row) << "\n";
}
std::cout << "Query completed for [spanner_query_data]\n";
}
//! [END spanner_query_data]
//! [START spanner_dml_getting_started_insert]
void DmlGettingStartedInsert(google::cloud::spanner::Client client) {
using ::google::cloud::StatusOr;
namespace spanner = ::google::cloud::spanner;
auto commit_result = client.Commit(
[&client](spanner::Transaction txn) -> StatusOr<spanner::Mutations> {
auto insert = client.ExecuteDml(
std::move(txn),
spanner::SqlStatement(
"INSERT INTO Singers (SingerId, FirstName, LastName) VALUES"
" (12, 'Melissa', 'Garcia'),"
" (13, 'Russell', 'Morales'),"
" (14, 'Jacqueline', 'Long'),"
" (15, 'Dylan', 'Shaw')",
{}));
if (!insert) return insert.status();
return spanner::Mutations{};
});
if (!commit_result) {
throw std::runtime_error(commit_result.status().message());
}
std::cout << "Insert was successful [spanner_dml_getting_started_insert]\n";
}
//! [END spanner_dml_getting_started_insert]
//! [START spanner_dml_getting_started_update]
void DmlGettingStartedUpdate(google::cloud::spanner::Client client) {
using ::google::cloud::StatusOr;
namespace spanner = ::google::cloud::spanner;
// A helper to read the budget for the given album and singer.
auto get_budget = [&](spanner::Transaction txn, std::int64_t album_id,
std::int64_t singer_id) -> StatusOr<std::int64_t> {
auto key = spanner::KeySet().AddKey(spanner::MakeKey(album_id, singer_id));
auto rows = client.Read(std::move(txn), "Albums", key, {"MarketingBudget"});
using RowType = std::tuple<google::cloud::optional<std::int64_t>>;
auto row = spanner::GetSingularRow(spanner::StreamOf<RowType>(rows));
if (!row) return row.status();
auto const budget = std::get<0>(*row);
return budget ? *budget : 0;
};
// A helper to update the budget for the given album and singer.
auto update_budget = [&](spanner::Transaction txn, std::int64_t album_id,
std::int64_t singer_id, std::int64_t budget) {
auto sql = spanner::SqlStatement(
"UPDATE Albums SET MarketingBudget = @AlbumBudget "
"WHERE SingerId = @SingerId AND AlbumId = @AlbumId",
{{"AlbumBudget", spanner::Value(budget)},
{"AlbumId", spanner::Value(album_id)},
{"SingerId", spanner::Value(singer_id)}});
return client.ExecuteDml(std::move(txn), std::move(sql));
};
auto const transfer_amount = 20000;
auto commit_result = client.Commit(
[&](spanner::Transaction const& txn) -> StatusOr<spanner::Mutations> {
auto budget1 = get_budget(txn, 1, 1);
if (!budget1) return budget1.status();
if (*budget1 < transfer_amount) {
return google::cloud::Status(
google::cloud::StatusCode::kUnknown,
"cannot transfer " + std::to_string(transfer_amount) +
" from budget of " + std::to_string(*budget1));
}
auto budget2 = get_budget(txn, 2, 2);
if (!budget2) return budget2.status();
auto update = update_budget(txn, 1, 1, *budget1 - transfer_amount);
if (!update) return update.status();
update = update_budget(txn, 2, 2, *budget2 + transfer_amount);
if (!update) return update.status();
return spanner::Mutations{};
});
if (!commit_result) {
throw std::runtime_error(commit_result.status().message());
}
std::cout << "Update was successful [spanner_dml_getting_started_update]\n";
}
//! [END spanner_dml_getting_started_update]
//! [START spanner_query_with_parameter]
void QueryWithParameter(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
spanner::SqlStatement select(
"SELECT SingerId, FirstName, LastName FROM Singers"
" WHERE LastName = @name",
{{"name", spanner::Value("Garcia")}});
using RowType = std::tuple<std::int64_t, std::string, std::string>;
auto rows = client.ExecuteQuery(std::move(select));
for (auto const& row : spanner::StreamOf<RowType>(rows)) {
if (!row) throw std::runtime_error(row.status().message());
std::cout << "SingerId: " << std::get<0>(*row) << "\t";
std::cout << "FirstName: " << std::get<1>(*row) << "\t";
std::cout << "LastName: " << std::get<2>(*row) << "\n";
}
std::cout << "Query completed for [spanner_query_with_parameter]\n";
}
//! [END spanner_query_with_parameter]
//! [START spanner_read_data]
void ReadData(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
auto rows = client.Read("Albums", google::cloud::spanner::KeySet::All(),
{"SingerId", "AlbumId", "AlbumTitle"});
using RowType = std::tuple<std::int64_t, std::int64_t, std::string>;
for (auto const& row : spanner::StreamOf<RowType>(rows)) {
if (!row) throw std::runtime_error(row.status().message());
std::cout << "SingerId: " << std::get<0>(*row) << "\t";
std::cout << "AlbumId: " << std::get<1>(*row) << "\n";
std::cout << "AlbumTitle: " << std::get<2>(*row) << "\n";
}
std::cout << "Read completed for [spanner_read_data]\n";
}
//! [END spanner_read_data]
//! [spanner-query-data-select-star]
void QueryDataSelectStar(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
// With a "SELECT *" query, we don't know the order in which the columns will
// be returned (nor the number of columns). Therefore, we look up each value
// based on the column name rather than its position.
spanner::SqlStatement select_star("SELECT * FROM Singers");
auto rows = client.ExecuteQuery(std::move(select_star));
for (auto const& row : rows) {
if (!row) throw std::runtime_error(row.status().message());
if (auto singer_id = row->get<std::int64_t>("SingerId")) {
std::cout << "SingerId: " << *singer_id << "\t";
} else {
std::cerr << singer_id.status();
}
if (auto last_name = row->get<std::string>("LastName")) {
std::cout << "LastName: " << *last_name;
} else {
std::cerr << last_name.status();
}
std::cout << "\n";
}
// However, if we can avoid "SELECT *" and instead enumerate the exact
// columns we care about in the query, it's more efficient because unwanted
// values aren't returned, and we can use `StreamOf<std::tuple<...>>` to
// automatically parse each row into the specified `std::tuple`, thus
// removing error paths and simplifying the code.
spanner::SqlStatement select("SELECT SingerId, LastName FROM Singers");
using RowType = std::tuple<std::int64_t, std::string>;
rows = client.ExecuteQuery(std::move(select));
for (auto const& row : spanner::StreamOf<RowType>(rows)) {
if (!row) throw std::runtime_error(row.status().message());
std::cout << "SingerId: " << std::get<0>(*row) << "\t";
std::cout << "LastName: " << std::get<1>(*row) << "\n";
}
std::cout << "Query completed for [spanner_query_data_select_star]\n";
}
//! [spanner-query-data-select-star]
//! [START spanner_query_data_with_struct]
void QueryDataWithStruct(google::cloud::spanner::Client client) {
//! [spanner-sql-statement-params] [START spanner_create_struct_with_data]
namespace spanner = ::google::cloud::spanner;
auto singer_info = std::make_tuple("Elena", "Campbell");
//! [END spanner_create_struct_with_data]
auto rows = client.ExecuteQuery(spanner::SqlStatement(
"SELECT SingerId FROM Singers WHERE (FirstName, LastName) = @name",
{{"name", spanner::Value(singer_info)}}));
//! [spanner-sql-statement-params]
for (auto const& row : spanner::StreamOf<std::tuple<std::int64_t>>(rows)) {
if (!row) throw std::runtime_error(row.status().message());
std::cout << "SingerId: " << std::get<0>(*row) << "\n";
}
std::cout << "Query completed for [spanner_query_data_with_struct]\n";
}
//! [END spanner_query_data_with_struct]
//! [START spanner_query_data_with_array_of_struct]
void QueryDataWithArrayOfStruct(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
// [START spanner_create_array_of_struct_with_data]
// Cloud Spanner STRUCT<> types with named fields are represented by
// std::tuple<std::pair<std::string, T>...>, create an alias to make it easier
// to follow this code.
using SingerName = std::tuple<std::pair<std::string, std::string>,
std::pair<std::string, std::string>>;
auto make_name = [](std::string first_name, std::string last_name) {
return std::make_tuple(std::make_pair("FirstName", std::move(first_name)),
std::make_pair("LastName", std::move(last_name)));
};
std::vector<SingerName> singer_info{
make_name("Elena", "Campbell"),
make_name("Gabriel", "Wright"),
make_name("Benjamin", "Martinez"),
};
// [END spanner_create_array_of_struct_with_data]
auto rows = client.ExecuteQuery(spanner::SqlStatement(
"SELECT SingerId FROM Singers"
" WHERE STRUCT<FirstName STRING, LastName STRING>(FirstName, LastName)"
" IN UNNEST(@names)",
{{"names", spanner::Value(singer_info)}}));
for (auto const& row : spanner::StreamOf<std::tuple<std::int64_t>>(rows)) {
if (!row) throw std::runtime_error(row.status().message());
std::cout << "SingerId: " << std::get<0>(*row) << "\n";
}
std::cout << "Query completed for"
<< " [spanner_query_data_with_array_of_struct]\n";
}
//! [END spanner_query_data_with_array_of_struct]
//! [START spanner_field_access_on_struct_parameters]
void FieldAccessOnStructParameters(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
// Cloud Spanner STRUCT<> with named fields is represented as
// tuple<pair<string, T>...>. Create a type alias for this example:
using SingerName = std::tuple<std::pair<std::string, std::string>,
std::pair<std::string, std::string>>;
SingerName name({"FirstName", "Elena"}, {"LastName", "Campbell"});
auto rows = client.ExecuteQuery(spanner::SqlStatement(
"SELECT SingerId FROM Singers WHERE FirstName = @name.FirstName",
{{"name", spanner::Value(name)}}));
for (auto const& row : spanner::StreamOf<std::tuple<std::int64_t>>(rows)) {
if (!row) throw std::runtime_error(row.status().message());
std::cout << "SingerId: " << std::get<0>(*row) << "\n";
}
std::cout << "Query completed for"
<< " [spanner_field_access_on_struct_parameters]\n";
}
//! [END spanner_field_access_on_struct_parameters]
//! [START spanner_field_access_on_nested_struct]
void FieldAccessOnNestedStruct(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
// Cloud Spanner STRUCT<> with named fields is represented as
// tuple<pair<string, T>...>. Create a type alias for this example:
using SingerFullName = std::tuple<std::pair<std::string, std::string>,
std::pair<std::string, std::string>>;
auto make_name = [](std::string fname, std::string lname) {
return SingerFullName({"FirstName", std::move(fname)},
{"LastName", std::move(lname)});
};
using SongInfo =
std::tuple<std::pair<std::string, std::string>,
std::pair<std::string, std::vector<SingerFullName>>>;
auto songinfo = SongInfo(
{"SongName", "Imagination"},
{"ArtistNames",
{make_name("Elena", "Campbell"), make_name("Hannah", "Harris")}});
auto rows = client.ExecuteQuery(spanner::SqlStatement(
"SELECT SingerId, @songinfo.SongName FROM Singers"
" WHERE STRUCT<FirstName STRING, LastName STRING>(FirstName, LastName)"
" IN UNNEST(@songinfo.ArtistNames)",
{{"songinfo", spanner::Value(songinfo)}}));
using RowType = std::tuple<std::int64_t, std::string>;
for (auto const& row : spanner::StreamOf<RowType>(rows)) {
if (!row) throw std::runtime_error(row.status().message());
std::cout << "SingerId: " << std::get<0>(*row)
<< " SongName: " << std::get<1>(*row) << "\n";
}
std::cout << "Query completed for [spanner_field_access_on_nested_struct]\n";
}
//! [END spanner_field_access_on_nested_struct]
void ExampleStatusOr(google::cloud::spanner::Client client) {
//! [example-status-or]
namespace spanner = ::google::cloud::spanner;
[](spanner::Client client) {
auto rows = client.Read("Albums", spanner::KeySet::All(), {"AlbumTitle"});
// The actual type of `row` is google::cloud::StatusOr<spanner::Row>, but
// we expect it'll most often be declared with auto like this.
for (auto const& row : rows) {
// Use `row` like a smart pointer; check it before dereferencing
if (!row) {
// `row` doesn't contain a value, so `.status()` will contain error info
std::cerr << row.status();
break;
}
// The actual type of `song` is google::cloud::StatusOr<std::string>, but
// again we expect it'll be commonly declared with auto as we show here.
auto song = row->get<std::string>("AlbumTitle");
// Instead of checking then dereferencing `song` as we did with `row`
// above, here we demonstrate use of the `.value()` member, which will
// return a reference to the contained `T` if it exists, otherwise it
// will throw an exception (or terminate if compiled without exceptions).
std::cout << "SongName: " << song.value() << "\n";
}
}
//! [example-status-or]
(std::move(client));
}
void CustomRetryPolicy(std::vector<std::string> argv) {
if (argv.size() != 3) {
throw std::runtime_error(
"custom-retry-policy <project-id> <instance-id> <database-id>");
}
//! [custom-retry-policy]
namespace spanner = ::google::cloud::spanner;
[](std::string const& project_id, std::string const& instance_id,
std::string const& database_id) {
auto client = spanner::Client(spanner::MakeConnection(
spanner::Database(project_id, instance_id, database_id),
spanner::ConnectionOptions{}, spanner::SessionPoolOptions{},
// Retry for at most 25 minutes.
spanner::LimitedTimeRetryPolicy(
/*maximum_duration=*/std::chrono::minutes(25))
.clone(),
// Use an truncated exponential backoff with jitter to wait between
// retries:
// https://en.wikipedia.org/wiki/Exponential_backoff
// https://cloud.google.com/storage/docs/exponential-backoff
spanner::ExponentialBackoffPolicy(
/*initial_delay=*/std::chrono::seconds(2),
/*maximum_delay=*/std::chrono::minutes(10),
/*scaling=*/1.5)
.clone()));
auto rows =
client.ExecuteQuery(spanner::SqlStatement("SELECT 'Hello World'"));
for (auto const& row : spanner::StreamOf<std::tuple<std::string>>(rows)) {
if (!row) throw std::runtime_error(row.status().message());
std::cout << std::get<0>(*row) << "\n";
}
}
//! [custom-retry-policy]
(argv[0], argv[1], argv[2]);
}
class RemoteConnectionFake {
public:
void SendBinaryStringData(std::string const& serialized_partition) {
serialized_partition_in_transit_ = serialized_partition;
}
std::string Receive() { return serialized_partition_in_transit_; }
void SendPartitionToRemoteMachine(
google::cloud::spanner::ReadPartition const& partition) {
//! [serialize-read-partition]
namespace spanner = ::google::cloud::spanner;
google::cloud::StatusOr<std::string> serialized_partition =
spanner::SerializeReadPartition(partition);
if (!serialized_partition) {
throw std::runtime_error(serialized_partition.status().message());
}
std::string const& bytes = *serialized_partition;
// `bytes` contains the serialized data, which may contain NULs and other
// non-printable characters.
SendBinaryStringData(bytes);
//! [serialize-read-partition]
}
void SendPartitionToRemoteMachine(
google::cloud::spanner::QueryPartition const& partition) {
//! [serialize-query-partition]
namespace spanner = ::google::cloud::spanner;
google::cloud::StatusOr<std::string> serialized_partition =
spanner::SerializeQueryPartition(partition);
if (!serialized_partition) {
throw std::runtime_error(serialized_partition.status().message());
}
std::string const& bytes = *serialized_partition;
// `bytes` contains the serialized data, which may contain NULs and other
// non-printable characters.
SendBinaryStringData(bytes);
//! [serialize-query-partition]
}
//! [deserialize-read-partition]
google::cloud::StatusOr<google::cloud::spanner::ReadPartition>
ReceiveReadPartitionFromRemoteMachine() {
std::string serialized_partition = Receive();
return google::cloud::spanner::DeserializeReadPartition(
serialized_partition);
}
//! [deserialize-read-partition]
//! [deserialize-query-partition]
google::cloud::StatusOr<google::cloud::spanner::QueryPartition>
ReceiveQueryPartitionFromRemoteMachine() {
std::string serialized_partition = Receive();
return google::cloud::spanner::DeserializeQueryPartition(
serialized_partition);
}
//! [deserialize-query-partition]
private:
std::string serialized_partition_in_transit_;
};
void ProcessRow(google::cloud::spanner::Row const&) {}
void PartitionRead(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
RemoteConnectionFake remote_connection;
//! [key-set-builder]
auto key_set = spanner::KeySet().AddRange(spanner::MakeKeyBoundClosed(1),
spanner::MakeKeyBoundClosed(10));
//! [key-set-builder]
//! [partition-read]
spanner::Transaction ro_transaction = spanner::MakeReadOnlyTransaction();
google::cloud::StatusOr<std::vector<spanner::ReadPartition>> partitions =
client.PartitionRead(ro_transaction, "Singers", key_set,
{"SingerId", "FirstName", "LastName"});
if (!partitions) throw std::runtime_error(partitions.status().message());
for (auto& partition : *partitions) {
remote_connection.SendPartitionToRemoteMachine(partition);
}
//! [partition-read]
//! [read-read-partition]
google::cloud::StatusOr<spanner::ReadPartition> partition =
remote_connection.ReceiveReadPartitionFromRemoteMachine();
if (!partition) throw std::runtime_error(partition.status().message());
auto rows = client.Read(*partition);
for (auto const& row : rows) {
if (!row) throw std::runtime_error(row.status().message());
ProcessRow(*row);
}
//! [read-read-partition]
}
void PartitionQuery(google::cloud::spanner::Client client) {
namespace spanner = ::google::cloud::spanner;
RemoteConnectionFake remote_connection;
//! [partition-query]
spanner::Transaction ro_transaction = spanner::MakeReadOnlyTransaction();
google::cloud::StatusOr<std::vector<spanner::QueryPartition>> partitions =
client.PartitionQuery(
ro_transaction,
spanner::SqlStatement(
"SELECT SingerId, FirstName, LastName FROM Singers"));
if (!partitions) throw std::runtime_error(partitions.status().message());
for (auto& partition : *partitions) {
remote_connection.SendPartitionToRemoteMachine(partition);
}
//! [partition-query]
//! [execute-sql-query-partition]
google::cloud::StatusOr<spanner::QueryPartition> partition =
remote_connection.ReceiveQueryPartitionFromRemoteMachine();
if (!partition) throw std::runtime_error(partition.status().message());
auto rows = client.ExecuteQuery(*partition);
for (auto const& row : rows) {
if (!row) throw std::runtime_error(row.status().message());
ProcessRow(*row);
}
//! [execute-sql-query-partition]
}
int RunOneCommand(std::vector<std::string> argv) {
using CommandType = std::function<void(std::vector<std::string> const&)>;
using SampleFunction = void (*)(google::cloud::spanner::Client);
using CommandMap = std::map<std::string, CommandType>;
auto make_command_entry = [](std::string const& sample_name,
SampleFunction sample) {
auto make_command = [](std::string const& sample_name,
SampleFunction sample) {
return [sample_name, sample](std::vector<std::string> const& argv) {
if (argv.size() != 3) {
throw std::runtime_error(sample_name +
" <project-id> <instance-id> <database-id>");
}
sample(MakeSampleClient(argv[0], argv[1], argv[2]));
};
};
return CommandMap::value_type(sample_name,
make_command(sample_name, sample));
};
using DatabaseAdminSampleFunction =
void (*)(google::cloud::spanner::DatabaseAdminClient, std::string const&,
std::string const&, std::string const&);
auto make_database_command_entry = [](std::string const& sample_name,
DatabaseAdminSampleFunction sample) {
auto make_command = [](std::string const& sample_name,
DatabaseAdminSampleFunction sample) {
return [sample_name, sample](std::vector<std::string> const& argv) {
if (argv.size() != 3) {
throw std::runtime_error(sample_name +
" <project-id> <instance-id> <database-id>");
}
google::cloud::spanner::DatabaseAdminClient client;
sample(client, argv[0], argv[1], argv[2]);
};
};
return CommandMap::value_type(sample_name,
make_command(sample_name, sample));
};
CommandMap commands = {
{"get-instance", &GetInstanceCommand},
{"create-instance", &CreateInstanceCommand},
{"update-instance", &UpdateInstanceCommand},
{"delete-instance", &DeleteInstanceCommand},
{"list-instance-configs", &ListInstanceConfigsCommand},
{"get-instance-config", &GetInstanceConfigCommand},
{"list-instances", &ListInstancesCommand},
{"instance-get-iam-policy", &InstanceGetIamPolicyCommand},
{"add-database-reader", &AddDatabaseReaderCommand},
{"remove-database-reader", &RemoveDatabaseReaderCommand},
{"instance-test-iam-permissions", &InstanceTestIamPermissionsCommand},
make_database_command_entry("create-database", &CreateDatabase),
make_database_command_entry("create-table-with-timestamp",
&CreateTableWithTimestamp),
make_database_command_entry("add-index", &AddIndex),
make_database_command_entry("add-storing-index", &AddStoringIndex),
make_database_command_entry("get-database", &GetDatabase),
make_database_command_entry("get-database-ddl", &GetDatabaseDdl),
make_database_command_entry("add-column", &AddColumn),
make_database_command_entry("add-timestamp-column", &AddTimestampColumn),
{"list-databases", &ListDatabasesCommand},
make_database_command_entry("drop-database", &DropDatabase),
make_database_command_entry("database-get-iam-policy",
&DatabaseGetIamPolicy),
{"add-database-reader-on-database", &AddDatabaseReaderOnDatabaseCommand},
{"database-test-iam-permissions", &DatabaseTestIamPermissionsCommand},
{"quickstart", &QuickstartCommand},
make_command_entry("insert-data", &InsertData),
make_command_entry("update-data", &UpdateData),
make_command_entry("delete-data", &DeleteData),
make_command_entry("read-only-transaction", &ReadOnlyTransaction),
make_command_entry("read-stale-data", &ReadStaleData),
make_command_entry("use-partition-query", &UsePartitionQuery),
make_command_entry("read-data-with-index", &ReadDataWithIndex),
make_command_entry("query-new-column", &QueryNewColumn),
make_command_entry("query-data-with-index", &QueryUsingIndex),
make_command_entry("read-data-with-storing-index",
&ReadDataWithStoringIndex),
make_command_entry("read-write-transaction", &ReadWriteTransaction),
make_command_entry("dml-standard-insert", &DmlStandardInsert),
make_command_entry("dml-standard-update", &DmlStandardUpdate),
make_command_entry("dml-standard-update-with-timestamp",
&DmlStandardUpdateWithTimestamp),
make_command_entry("dml-write-then-read", &DmlWriteThenRead),
make_command_entry("dml-standard-delete", &DmlStandardDelete),
make_command_entry("dml-partitioned-update", &DmlPartitionedUpdate),
make_command_entry("dml-batch-update", &DmlBatchUpdate),
make_command_entry("dml-partitioned-delete", &DmlPartitionedDelete),
make_command_entry("dml-structs", &DmlStructs),
make_command_entry("write-data-for-struct-queries",
&WriteDataForStructQueries),
make_command_entry("query-data", &QueryData),
make_command_entry("getting-started-insert", &DmlGettingStartedInsert),
make_command_entry("getting-started-update", &DmlGettingStartedUpdate),
make_command_entry("query-with-parameter", &QueryWithParameter),
make_command_entry("read-data", &ReadData),
make_command_entry("query-data-select-star", &QueryDataSelectStar),
make_command_entry("query-data-with-struct", &QueryDataWithStruct),
make_command_entry("query-data-with-array-of-struct",
&QueryDataWithArrayOfStruct),
make_command_entry("field-access-struct-parameters",
&FieldAccessOnStructParameters),
make_command_entry("field-access-on-nested-struct",
&FieldAccessOnNestedStruct),
make_command_entry("partition-read", &PartitionRead),
make_command_entry("partition-query", &PartitionQuery),
make_command_entry("example-status-or", &ExampleStatusOr),
{"custom-retry-policy", &CustomRetryPolicy},
};
static std::string usage_msg = [&argv, &commands] {
auto last_slash = std::string(argv[0]).find_last_of("/\\");
auto program = argv[0].substr(last_slash + 1);
std::string usage;
usage += "Usage: ";
usage += program;
usage += " <command> [arguments]\n\n";
usage += "Commands:\n";
for (auto&& kv : commands) {
try {
kv.second({});
} catch (std::exception const& ex) {
usage += " ";
usage += ex.what();
usage += "\n";
}
}
return usage;
}();
if (argv.size() < 2) {
std::cerr << "Missing command argument\n" << usage_msg << "\n";
return 1;
}
std::string command_name = argv[1];
argv.erase(argv.begin()); // remove the program name from the list.
argv.erase(argv.begin()); // remove the command name from the list.
auto command = commands.find(command_name);
if (commands.end() == command) {
std::cerr << "Unknown command " << command_name << "\n"
<< usage_msg << "\n";
return 1;
}
// Run the command.
command->second(argv);
return 0;
}
void RunAll() {
auto run_slow_integration_tests =
google::cloud::internal::GetEnv("RUN_SLOW_INTEGRATION_TESTS")
.value_or("");
auto project_id =
google::cloud::internal::GetEnv("GOOGLE_CLOUD_PROJECT").value_or("");
if (project_id.empty()) {
throw std::runtime_error("GOOGLE_CLOUD_PROJECT is not set or is empty");
}
auto test_iam_service_account =
google::cloud::internal::GetEnv("GOOGLE_CLOUD_CPP_SPANNER_IAM_TEST_SA")
.value_or("");
if (test_iam_service_account.empty()) {
throw std::runtime_error(
"GOOGLE_CLOUD_CPP_SPANNER_IAM_TEST_SA is not set or is empty");
}
auto generator = google::cloud::internal::MakeDefaultPRNG();
auto random_instance =
google::cloud::spanner_testing::PickRandomInstance(generator, project_id);
if (!random_instance) {
throw std::runtime_error("Cannot find an instance to run the examples: " +
random_instance.status().message());
}
std::string instance_id = *std::move(random_instance);
std::cout << "Running instance admin samples on " << instance_id << "\n";
google::cloud::spanner::InstanceAdminClient instance_admin_client(
google::cloud::spanner::MakeInstanceAdminConnection());
std::cout << "\nRunning get-instance sample\n";
GetInstance(instance_admin_client, project_id, instance_id);
std::cout << "\nRunning get-instance-config sample\n";
GetInstanceConfig(instance_admin_client, project_id, "regional-us-central1");
std::cout << "\nRunning list-instance-configs sample\n";
ListInstanceConfigs(instance_admin_client, project_id);
std::cout << "\nRunning list-instances sample\n";
ListInstances(instance_admin_client, project_id);
std::cout << "\nRunning (instance) get-iam-policy sample\n";
InstanceGetIamPolicy(instance_admin_client, project_id, instance_id);
if (run_slow_integration_tests == "yes") {
std::string crud_instance_id =
google::cloud::spanner_testing::RandomInstanceName(generator);
std::cout << "\nRunning create-instance sample\n";
CreateInstance(instance_admin_client, project_id, crud_instance_id,
"Test Instance");
std::cout << "\nRunning update-instance sample\n";
UpdateInstance(instance_admin_client, project_id, crud_instance_id,
"New name");
std::cout << "\nRunning (instance) add-database-reader sample\n";
AddDatabaseReader(instance_admin_client, project_id, crud_instance_id,
"serviceAccount:" + test_iam_service_account);
std::cout << "\nRunning (instance) remove-database-reader sample\n";
RemoveDatabaseReader(instance_admin_client, project_id, crud_instance_id,
"serviceAccount:" + test_iam_service_account);
std::cout << "\nRunning delete-instance sample\n";
DeleteInstance(instance_admin_client, project_id, crud_instance_id);
}
std::cout << "\nRunning (instance) test-iam-permissions sample\n";
InstanceTestIamPermissions(instance_admin_client, project_id, instance_id);
std::string database_id =
google::cloud::spanner_testing::RandomDatabaseName(generator);
std::cout << "Running samples in database " << database_id << "\n";
google::cloud::spanner::DatabaseAdminClient database_admin_client;
std::cout << "\nRunning spanner_create_database sample\n";
CreateDatabase(database_admin_client, project_id, instance_id, database_id);
std::cout << "\nRunning spanner_create_table_with_timestamp_column sample\n";
CreateTableWithTimestamp(database_admin_client, project_id, instance_id,
database_id);
std::cout << "\nRunning spanner_create_index sample\n";
AddIndex(database_admin_client, project_id, instance_id, database_id);
std::cout << "\nRunning spanner get-database sample\n";
GetDatabase(database_admin_client, project_id, instance_id, database_id);
std::cout << "\nRunning spanner get-database-ddl sample\n";
GetDatabaseDdl(database_admin_client, project_id, instance_id, database_id);
std::cout << "\nList all databases\n";
ListDatabases(database_admin_client, project_id, instance_id);
std::cout << "\nRunning spanner_add_column sample\n";
AddColumn(database_admin_client, project_id, instance_id, database_id);
std::cout << "\nRunning spanner_add_timestamp_column sample\n";
AddTimestampColumn(database_admin_client, project_id, instance_id,
database_id);
std::cout << "\nRunning spanner_create_storing_index sample\n";
AddStoringIndex(database_admin_client, project_id, instance_id, database_id);
std::cout << "\nRunning (database) get-iam-policy sample\n";
DatabaseGetIamPolicy(database_admin_client, project_id, instance_id,
database_id);
std::cout << "\nRunning (database) add-database-reader sample\n";
AddDatabaseReaderOnDatabase(database_admin_client, project_id, instance_id,
database_id,
"serviceAccount:" + test_iam_service_account);
std::cout << "\nRunning (database) test-iam-permissions sample\n";
DatabaseTestIamPermissions(database_admin_client, project_id, instance_id,
database_id, "spanner.databases.read");
std::cout << "\nRunning spanner_quickstart sample\n";
Quickstart(project_id, instance_id, database_id);
auto client = MakeSampleClient(project_id, instance_id, database_id);
std::cout << "\nRunning spanner_insert_data sample\n";
InsertData(client);
std::cout << "\nRunning spanner_update_data sample\n";
UpdateData(client);
std::cout << "\nRunning spanner_read_only_transaction sample\n";
ReadOnlyTransaction(client);
std::cout << "\nRunning spanner_stale_data sample\n";
ReadStaleData(client);
std::cout << "\nRunning spanner_batch_client sample\n";
UsePartitionQuery(client);
std::cout << "\nRunning spanner_read_data_with_index sample\n";
ReadDataWithIndex(client);
std::cout << "\nRunning spanner_query_data_with_new_column sample\n";
QueryNewColumn(client);
std::cout << "\nRunning spanner_query_data_with_index sample\n";
QueryUsingIndex(client);
std::cout << "\nRunning spanner_read_data_with_storing_index sample\n";
ReadDataWithStoringIndex(client);
std::cout << "\nRunning spanner_read_write_transaction sample\n";
ReadWriteTransaction(client);
std::cout << "\nRunning spanner_dml_standard_insert sample\n";
DmlStandardInsert(client);
std::cout << "\nRunning spanner_dml_standard_update sample\n";
DmlStandardUpdate(client);
std::cout << "\nRunning spanner_dml_standard_update_with_timestamp sample\n";
DmlStandardUpdateWithTimestamp(client);
std::cout << "\nRunning spanner_dml_write_then_read sample\n";
DmlWriteThenRead(client);
std::cout << "\nRunning spanner_dml_batch_update sample\n";
DmlBatchUpdate(client);
std::cout << "\nRunning spanner_write_data_for_struct_queries sample\n";
WriteDataForStructQueries(client);
std::cout << "\nRunning spanner_query_data sample\n";
QueryData(client);
std::cout << "\nRunning spanner_dml_getting_started_insert sample\n";
DmlGettingStartedInsert(client);
std::cout << "\nRunning spanner_dml_getting_started_update sample\n";
DmlGettingStartedUpdate(client);
std::cout << "\nRunning spanner_query_with_parameter sample\n";
QueryWithParameter(client);
std::cout << "\nRunning spanner_read_data sample\n";
ReadData(client);
std::cout << "\nRunning spanner_query_data_select_star sample\n";
QueryDataSelectStar(client);
std::cout << "\nRunning spanner_query_data_with_struct sample\n";
QueryDataWithStruct(client);
std::cout << "\nRunning spanner_query_data_with_array_of_struct sample\n";
QueryDataWithArrayOfStruct(client);
std::cout << "\nRunning spanner_field_access_on_struct_parameters sample\n";
FieldAccessOnStructParameters(client);
std::cout << "\nRunning spanner_field_access_on_nested_struct sample\n";
FieldAccessOnNestedStruct(client);
std::cout << "\nRunning spanner_partition_read sample\n";
PartitionRead(client);
std::cout << "\nRunning spanner_partition_query sample\n";
PartitionQuery(client);
std::cout << "\nRunning example-status-or sample\n";
ExampleStatusOr(client);
std::cout << "\nRunning custom-retry-policy sample\n";
RunOneCommand(
{"", "custom-retry-policy", project_id, instance_id, database_id});
std::cout << "\nRunning spanner_dml_partitioned_update sample\n";
DmlPartitionedUpdate(client);
std::cout << "\nRunning spanner_dml_partitioned_delete sample\n";
DmlPartitionedDelete(client);
std::cout << "\nRunning spanner_dml_structs sample\n";
DmlStructs(client);
std::cout << "\nRunning spanner_dml_standard_delete sample\n";
DmlStandardDelete(client);
std::cout << "\nRunning spanner_delete_data sample\n";
DeleteData(client);
std::cout << "\nRunning spanner_drop_database sample\n";
DropDatabase(database_admin_client, project_id, instance_id, database_id);
}
bool AutoRun() {
return google::cloud::internal::GetEnv("GOOGLE_CLOUD_CPP_AUTO_RUN_EXAMPLES")
.value_or("") == "yes";
}
} // namespace
int main(int ac, char* av[]) try {
if (AutoRun()) {
RunAll();
return 0;
}
return RunOneCommand({av, av + ac});
} catch (std::exception const& ex) {
std::cerr << ex.what() << "\n";
return 1;
}
| 41.477639
| 80
| 0.646107
|
antfitch
|
fe1b83fab51d806b9ab814bc8789528ee07b855c
| 2,747
|
cpp
|
C++
|
mem/mmap.cpp
|
IGR2014/kernale
|
a8b43cf7d89c3d92b14ffdb88683023048f4bf78
|
[
"MIT"
] | 4
|
2019-08-09T09:20:40.000Z
|
2021-09-10T00:59:30.000Z
|
mem/mmap.cpp
|
IGR2014/kernale
|
a8b43cf7d89c3d92b14ffdb88683023048f4bf78
|
[
"MIT"
] | 12
|
2017-10-24T14:22:46.000Z
|
2020-07-17T16:20:39.000Z
|
mem/mmap.cpp
|
IGR2014/kernale
|
a8b43cf7d89c3d92b14ffdb88683023048f4bf78
|
[
"MIT"
] | 1
|
2019-08-01T07:49:36.000Z
|
2019-08-01T07:49:36.000Z
|
////////////////////////////////////////////////////////////////
//
// Memory map operations definition
//
// File: mmap.cpp
// Date: 15 Jan 2021
//
// Copyright (c) 2017 - 2021, Igor Baklykov
// All rights reserved.
//
//
#include <cstdint>
#include <platform.hpp>
#include <mem/mmap.hpp>
// Memory code zone
namespace igros::mem {
// Free pages pointer
pointer_t phys::freePageList {nullptr};
// Initialize physical memory
void phys::init(const multiboot::memoryMapEntry* map, const std::size_t size) noexcept {
// Memory map entries iterator
auto entry = map;
// Previous entry pointer
auto prevEntry = static_cast<pointer_t>(nullptr);
// Loop through memory map
while (reinterpret_cast<std::size_t>(entry) < size) {
// Check if entry is available
if ( (multiboot::MEMORY_MAP_TYPE::AVAILABLE == entry->type)
&& ((reinterpret_cast<std::size_t>(entry) < reinterpret_cast<std::size_t>(platform::KERNEL_START()))
|| (reinterpret_cast<std::size_t>(entry) > reinterpret_cast<std::size_t>(platform::KERNEL_END())))) {
// Initial entry's memory offset
auto entrySize = 0ULL;
// Loop through entry's memory
while ((entry->address + entrySize) < entry->length) {
// Calculate new entry address
const auto newEntry = pointer_t(entry->address + entrySize);
// Place previous entry's pointer in current entry
*reinterpret_cast<pointer_t*>(newEntry) = prevEntry;
// Save new entry's address ass new oldEntry's address
prevEntry = newEntry;
// Increment size by one page (4KB)
entrySize += DEFAULT_PAGE_SIZE;
}
}
// Move to next memory map entry
entry = reinterpret_cast<multiboot::memoryMapEntry*>(std::size_t(entry) + entry->size + sizeof(entry->size));
}
// Linked list of free pages
phys::freePageList = prevEntry;
}
// Allcoate physical page
[[nodiscard]] pointer_t phys::alloc() noexcept {
// Check if we have free pages
if (nullptr != phys::freePageList) {
// Get page pointer
const auto page = phys::freePageList;
// Remove page from list of free pages
phys::freePageList = reinterpret_cast<pointer_t>(*static_cast<std::size_t*>(phys::freePageList));
// Return page pointer
return page;
}
// No free pages left
return nullptr;
}
// Free physical page
void phys::free(pointer_t &page) noexcept {
// Error check
if (nullptr == page) {
return;
}
// Return page to free pages list
*static_cast<pointer_t*>(page) = phys::freePageList;
phys::freePageList = reinterpret_cast<pointer_t>(*static_cast<std::size_t*>(phys::freePageList));
page = nullptr;
}
} // namespace igros::mem
| 28.915789
| 113
| 0.641427
|
IGR2014
|
fe1eaabfa3825cf2ca70ae9c227787c2dc97c4e3
| 8,823
|
cpp
|
C++
|
sources/samples/air3D/air3D.cpp
|
mdoshi96/beacls
|
860426ed1336d9539dea195987efcdd8a8276a1c
|
[
"BSD-2-Clause",
"BSD-2-Clause-FreeBSD"
] | 30
|
2017-12-17T22:57:50.000Z
|
2022-01-30T17:06:34.000Z
|
sources/samples/air3D/air3D.cpp
|
codingblazes/beacls
|
6c1d685ee00e3b39d8100c4a170a850682679abc
|
[
"BSD-2-Clause",
"BSD-2-Clause-FreeBSD"
] | 2
|
2017-03-24T06:18:16.000Z
|
2017-04-04T16:16:06.000Z
|
sources/samples/air3D/air3D.cpp
|
codingblazes/beacls
|
6c1d685ee00e3b39d8100c4a170a850682679abc
|
[
"BSD-2-Clause",
"BSD-2-Clause-FreeBSD"
] | 8
|
2018-07-06T01:47:21.000Z
|
2021-07-23T15:50:34.000Z
|
#define _USE_MATH_DEFINES
#include <levelset/levelset.hpp>
#include <cmath>
#include <numeric>
#include <functional>
#include <cfloat>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <cstring>
#include "Air3DSchemeData.hpp"
typedef enum ApproximationAccuracy_Type{
ApproximationAccuracy_Invalid,
ApproximationAccuracy_low,
ApproximationAccuracy_medium,
ApproximationAccuracy_high,
ApproximationAccuracy_veryHigh,
}ApproximationAccuracy_Type;
int main(int argc, char *argv[])
{
bool debug_dump_file = false;
// bool debug_dump_file = true;
bool dump_file = false;
if (argc >= 2) {
dump_file = (atoi(argv[1]) == 0) ? false : true;
}
size_t line_length_of_chunk = 1;
if (argc >= 3) {
line_length_of_chunk = atoi(argv[2]);
}
bool useCuda = false;
if (argc >= 4) {
useCuda = (atoi(argv[3]) == 0) ? false : true;
}
int num_of_threads = 0;
if (argc >= 5) {
num_of_threads = atoi(argv[4]);
}
int num_of_gpus = 0;
if (argc >= 6) {
num_of_gpus = atoi(argv[5]);
}
levelset::DelayedDerivMinMax_Type delayedDerivMinMax = levelset::DelayedDerivMinMax_Disable;
if (argc >= 7) {
switch (atoi(argv[6])) {
default:
case 0:
delayedDerivMinMax = levelset::DelayedDerivMinMax_Disable;
break;
case 1:
delayedDerivMinMax = levelset::DelayedDerivMinMax_Always;
break;
case 2:
delayedDerivMinMax = levelset::DelayedDerivMinMax_Adaptive;
break;
}
}
bool enable_user_defined_dynamics_on_gpu = true;
if (argc >= 8) {
enable_user_defined_dynamics_on_gpu = (atoi(argv[7]) == 0) ? false : true;
}
const FLOAT_TYPE tMax = (FLOAT_TYPE) 2.8; //!< End time.
// const FLOAT_TYPE tMax = 0.35; //!< End time.
// const FLOAT_TYPE tMax = 0.1; //!< End time.
const int plotSteps = 9; //!< How many intermediate plots to produce?
// const int plotSteps = 2; //!< How many intermediate plots to produce?
const FLOAT_TYPE t0 = 0.0; //!< Start time.
FLOAT_TYPE tPlot = (tMax - t0) / (plotSteps - 1);
//! How close (relative) do we need to get to tMax to be considered finished?
const FLOAT_TYPE small_ratio = 100.; //!<
const FLOAT_TYPE eps = std::numeric_limits<FLOAT_TYPE>::epsilon(); //!<
FLOAT_TYPE small = small_ratio * eps; //!<
//! Problem Parameters.
//! Radius of target circle(positive).
const FLOAT_TYPE targetRadius = 5;
//! Speed of the evader(positive constant).
const FLOAT_TYPE velocityA = 5;
//! Speed of the pursuer(positive constant).
const FLOAT_TYPE velocityB = 5;
//! Maximum turn rate of the evader(positive).
const FLOAT_TYPE inputA = 1;
//! Maximum turn rate of the pursuer(positive).
const FLOAT_TYPE inputB = 1;
size_t num_of_dimensions = 3;
beacls::FloatVec mins{ -6,-10,0 };
beacls::FloatVec maxs{ +20,+10,(FLOAT_TYPE)(+2*M_PI) };
size_t Nx = 51;
beacls::IntegerVec Ns(num_of_dimensions);
Ns = {Nx, (size_t)std::ceil(Nx * (maxs[1] - mins[1])/(maxs[0]-mins[0])), Nx-1};
maxs[2] = (FLOAT_TYPE)(maxs[2] * (1 - 1. / Ns[2]));
levelset::ShapeCylinder *shape = new levelset::ShapeCylinder(
beacls::IntegerVec{2},
beacls::FloatVec{0.,0.,0},
targetRadius);
levelset::AddGhostExtrapolate *addGhostExtrapolate = new levelset::AddGhostExtrapolate();
levelset::AddGhostPeriodic *addGhostPeriodic = new levelset::AddGhostPeriodic();
std::vector<levelset::BoundaryCondition*> boundaryConditions(3);
boundaryConditions[0] = addGhostExtrapolate;
boundaryConditions[1] = addGhostExtrapolate;
boundaryConditions[2] = addGhostPeriodic;
levelset::HJI_Grid *hJI_Grid = new levelset::HJI_Grid(
num_of_dimensions);
hJI_Grid->set_mins(mins);
hJI_Grid->set_maxs(maxs);
hJI_Grid->set_boundaryConditions(boundaryConditions);
hJI_Grid->set_Ns(Ns);
if (!hJI_Grid->processGrid()) {
return -1;
}
const beacls::UVecType type = useCuda ? beacls::UVecType_Cuda : beacls::UVecType_Vector;
ApproximationAccuracy_Type accuracy = ApproximationAccuracy_medium;
// ApproximationAccuracy_Type accuracy = ApproximationAccuracy_high;
// ApproximationAccuracy_Type accuracy = ApproximationAccuracy_veryHigh;
// Choose spatial derivative approimation at appropriate level of accuracy.
levelset::SpatialDerivative *spatialDerivative = NULL;
switch (accuracy) {
case ApproximationAccuracy_low:
spatialDerivative = new levelset::UpwindFirstFirst(hJI_Grid, type);
break;
case ApproximationAccuracy_medium:
spatialDerivative = new levelset::UpwindFirstENO2(hJI_Grid, type);
break;
case ApproximationAccuracy_high:
spatialDerivative = new levelset::UpwindFirstENO3(hJI_Grid, type);
break;
case ApproximationAccuracy_veryHigh:
spatialDerivative = new levelset::UpwindFirstWENO5(hJI_Grid, type);
break;
default:
printf("Unkown accuracy level %d\n", accuracy);
return -1;
}
levelset::ArtificialDissipationGLF *dissipation = new levelset::ArtificialDissipationGLF();
std::vector<levelset::PostTimestep_Exec_Type*> postTimestep_Execs;
levelset::Integrator *integrator;
FLOAT_TYPE factor_cfl = (FLOAT_TYPE)0.75;
FLOAT_TYPE max_step = (FLOAT_TYPE)8.0e16;
bool single_step = false;
// bool single_step = true;
bool stats = false;
levelset::TerminalEvent_Exec_Type *terminalEvent_Exec_Type = NULL;
Air3DSchemeData *innerData = new Air3DSchemeData();
innerData->set_spatialDerivative(spatialDerivative);
innerData->set_dissipation(dissipation);
innerData->set_grid(hJI_Grid);
// innerData->set_hamiltonJacobiFunction(hamiltonJacobiFunction);
// innerData->set_partialFunction(partialFunction);
innerData->velocityA = velocityA;
innerData->velocityB = velocityB;
innerData->inputA = inputA;
innerData->inputB = inputB;
levelset::TermLaxFriedrichs *innerFunc = new levelset::TermLaxFriedrichs(innerData, type);
levelset::TermRestrictUpdate *schemeFunc = new levelset::TermRestrictUpdate();
Air3DSchemeData *schemeData = new Air3DSchemeData();
schemeData->set_grid(hJI_Grid);
schemeData->set_innerFunc(innerFunc);
schemeData->set_innerData(innerData);
schemeData->set_positive(false);
// Choose integration approimation at appropriate level of accuracy.
switch (accuracy) {
case ApproximationAccuracy_low:
integrator = new levelset::OdeCFL1(schemeFunc, factor_cfl, max_step, postTimestep_Execs, single_step, stats, terminalEvent_Exec_Type);
break;
case ApproximationAccuracy_medium:
integrator = new levelset::OdeCFL2(schemeFunc, factor_cfl, max_step, postTimestep_Execs, single_step, stats, terminalEvent_Exec_Type);
break;
case ApproximationAccuracy_high:
integrator = new levelset::OdeCFL3(schemeFunc, factor_cfl, max_step, postTimestep_Execs, single_step, stats, terminalEvent_Exec_Type);
break;
case ApproximationAccuracy_veryHigh:
integrator = new levelset::OdeCFL3(schemeFunc, factor_cfl, max_step, postTimestep_Execs, single_step, stats, terminalEvent_Exec_Type);
break;
default:
printf("Unkown accuracy level %d\n", accuracy);
return -1;
}
beacls::FloatVec data;
shape->execute(hJI_Grid, data);
if (dump_file) {
beacls::MatFStream* fs = beacls::openMatFStream(std::string("initial.mat"), beacls::MatOpenMode_Write);
save_vector(data, std::string("y0"), Ns, false, fs);
beacls::closeMatFStream(fs);
// beacls::FloatVec reload_data;
// load_vector(std::string("initial.mat"), reload_data);
// HJI_Grid* tmp_grid = new levelset::HJI_Grid();
// tmp_grid->load_grid(std::string("air3D_0_g_v7_3.mat"));
// tmp_grid->save_grid(std::string("air3D_0_g_v7_3_new.mat"),std::string("grid"));
// delete tmp_grid;
}
// Loop until tMax (subject to a little roundoff).
FLOAT_TYPE tNow = t0;
beacls::FloatVec y;
beacls::FloatVec y0;
while ((tMax - tNow) > small * tMax) {
y0 = data;
beacls::FloatVec tspan(2);
tspan[0] = tNow;
tspan[1] = HjiMin(tMax, tNow + tPlot);
if (debug_dump_file) {
std::stringstream ss;
ss << std::setprecision(5) << tNow << std::resetiosflags(std::ios_base::floatfield);
std::string filename = "air3D_" + ss.str() + ".txt";
dump_vector(filename.c_str(), data);
}
tNow = integrator->execute(
y, tspan, y0, schemeData,
line_length_of_chunk, num_of_threads, num_of_gpus,
delayedDerivMinMax, enable_user_defined_dynamics_on_gpu);
data = y;
printf("tNow = %f\n", tNow);
}
if (dump_file) {
dump_vector(std::string("all_loop.csv"),data);
beacls::MatFStream* fs = beacls::openMatFStream(std::string("all_loop.mat"), beacls::MatOpenMode_Write);
save_vector(data, std::string("y0"), Ns, false, fs);
beacls::closeMatFStream(fs);
}
if (innerFunc) delete innerFunc;
if (innerData) delete innerData;
if (schemeFunc) delete schemeFunc;
if (dissipation) delete dissipation;
if (schemeData) delete schemeData;
if (integrator) delete integrator;
if (hJI_Grid) delete hJI_Grid;
if (shape) delete shape;
if (addGhostExtrapolate) delete addGhostExtrapolate;
if (addGhostPeriodic) delete addGhostPeriodic;
if (spatialDerivative) delete spatialDerivative;
return 0;
}
| 33.420455
| 136
| 0.741018
|
mdoshi96
|
fe205c9d407117a6769f62f8e8da89f53df60a59
| 965
|
hpp
|
C++
|
SRC/GLD/VertexArray.hpp
|
GustavoGLD/CLI-Graphics-Library
|
0f5a884f42618ac2a39ec2061a30d1be5a438e9f
|
[
"MIT"
] | 1
|
2021-08-29T01:01:41.000Z
|
2021-08-29T01:01:41.000Z
|
SRC/GLD/VertexArray.hpp
|
GustavoGLD/Fast-CLI-Game-Engine
|
0f5a884f42618ac2a39ec2061a30d1be5a438e9f
|
[
"MIT"
] | null | null | null |
SRC/GLD/VertexArray.hpp
|
GustavoGLD/Fast-CLI-Game-Engine
|
0f5a884f42618ac2a39ec2061a30d1be5a438e9f
|
[
"MIT"
] | null | null | null |
#include <functional>
#include <vector>
#include <map>
#include "Vectors.hpp"
#include "Drawable.hpp"
#include "Impl/VertexArrayImpl.hpp"
namespace gld
{
enum PrimitiveType { POINTS, LINE_STRIP, LINE_LOOP, TRIANGLES, PrTy_SIZE };
std::map<gld::PrimitiveType, DrawFunc> drawFunc = {
{gld::POINTS, drawPoints},
{gld::LINE_STRIP, drawLineStripe},
{gld::LINE_LOOP, drawLineLoop},
{gld::TRIANGLES, drawTriangles}
};
class VertexArray : public gld::Drawable, private std::vector<gld::Vector2f> {
private:
gld::PrimitiveType type = gld::LINE_LOOP;
public:
using vector::vector;
using vector::push_back;
using vector::erase;
using vector::begin;
using vector::end;
using vector::operator[];
inline void draw(std::vector<std::vector<std::string>>& map) {
drawFunc[type](this[0], color, map);
}
inline void setPrimitiveType(const gld::PrimitiveType& type) {
this->type = type;
}
};
}
| 22.44186
| 78
| 0.671503
|
GustavoGLD
|
fe27af1b4420b2c81f0f2406a11e8cbdf05e002f
| 4,549
|
cpp
|
C++
|
ROBIT_master/src/qnode.cpp
|
zang09/turtlebot3_autorace_ROBIT2_src
|
adc7225b7e0e5f822e62746beba16cd5a0b20214
|
[
"Apache-2.0"
] | null | null | null |
ROBIT_master/src/qnode.cpp
|
zang09/turtlebot3_autorace_ROBIT2_src
|
adc7225b7e0e5f822e62746beba16cd5a0b20214
|
[
"Apache-2.0"
] | null | null | null |
ROBIT_master/src/qnode.cpp
|
zang09/turtlebot3_autorace_ROBIT2_src
|
adc7225b7e0e5f822e62746beba16cd5a0b20214
|
[
"Apache-2.0"
] | null | null | null |
/**
* @file /src/qnode.cpp
*
* @brief Ros communication central!
*
* @date February 2011
**/
/*****************************************************************************
** Includes
*****************************************************************************/
#include "../include/ROBIT_master/qnode.hpp"
/*****************************************************************************
** Namespaces
*****************************************************************************/
bool ROBIT_driving::confirm_gatebar = false, ROBIT_driving::state = false;
int ROBIT_driving::sensor_data[3]={0,}, ROBIT_driving::direction_angle = 0, ROBIT_driving::tunnel_escape = 0;
geometry_msgs::Twist ROBIT_driving::motor_value;
namespace ROBIT_master {
bool isRecved = false;
bool button_clicked = false;
using namespace std;
ROBIT_driving Driving;
/*****************************************************************************
** Implementation
*****************************************************************************/
QNode::QNode(int argc, char** argv ) :
init_argc(argc),
init_argv(argv), tunnel_detect(0)
{}
void QNode::TunDataCallback(const std_msgs::UInt32::ConstPtr &tunnel_msg)
{
ROBIT_driving::tunnel_escape = tunnel_msg->data;
}
void QNode::ImgDataCallback(const ROBIT_vision2::vision_msg2::ConstPtr &vision_msg)
{
if(vision_msg != NULL && !isRecved)
{
isRecved = true;
Driving.update_parameter(vision_msg, button_clicked);
Driving.Go();
if(ROBIT_driving::state == 1)
{
//ROS_INFO("2");
Tun_Data_pub.publish(ROBIT_driving::state);
}
else if(ROBIT_driving::state == 0)
{
//ROS_INFO("3");
Mot_Data_pub.publish(ROBIT_driving::motor_value);
}
Q_EMIT Recv_Data();
}
}
void QNode::CdsDataCallback(const std_msgs::UInt32::ConstPtr &cds_msg)
{
ROBIT_driving::sensor_data[cds] = cds_msg->data;
if(ROBIT_driving::sensor_data[cds] >= 800) //tunnel
{
ROS_INFO("%d",ROBIT_driving::tunnel_escape);
ROS_INFO("%d",tunnel_detect);
ROS_INFO("%d",ROBIT_driving::confirm_gatebar);
ROS_INFO("%d",ROBIT_driving::direction_angle);
if(ROBIT_driving::tunnel_escape == 2)
{
ROBIT_driving::tunnel_escape = 0;
ROBIT_driving::state = 0;
}
else
{
if(!tunnel_detect /*&& ROBIT_driving::confirm_gatebar*/ && (ROBIT_driving::direction_angle <= 290 && ROBIT_driving::direction_angle >= 250))
{
ROBIT_driving::state = 1;
tunnel_detect = true;
}
}
}
else
{
if(ROBIT_driving::tunnel_escape == 2)
{
ROBIT_driving::tunnel_escape = 0;
ROBIT_driving::state = 0;
}
}
}
void QNode::SwDataCallback(const std_msgs::Bool::ConstPtr &sw_data)
{
if(ROBIT_driving::state == 1 && sw_data->data == true)
ROBIT_driving::state = 0;
}
void QNode::imuMsgCallback(const sensor_msgs::Imu::ConstPtr &imu)
{
double imu_x = imu->orientation.x;
double imu_y = imu->orientation.y;
double imu_z = imu->orientation.z;
double imu_w = imu->orientation.w;
double yaw = atan2(2*imu_x*imu_y + 2*imu_w*imu_z, imu_w*imu_w + imu_x*imu_x - imu_y*imu_y - imu_z*imu_z);
double yaw_angle = yaw * RAD2DEG;
if(yaw_angle > 0.0 && yaw_angle <= 180.0)
ROBIT_driving::direction_angle = yaw_angle;
else if(yaw_angle <= 0.0 && yaw_angle > -180.0)
ROBIT_driving::direction_angle = yaw_angle + 360.0;
}
bool QNode::init()
{
ros::init(init_argc,init_argv,"ROBIT_master");
if ( ! ros::master::check() )
return false;
ros::start();
ros::NodeHandle nh;
Img_Data_sub = nh.subscribe("turtle_vision",1,&QNode::ImgDataCallback,this);
Cds_Data_sub = nh.subscribe("cds_data",1,&QNode::CdsDataCallback,this);
Tun_Data_sub = nh.subscribe("tunnel_escape",1,&QNode::TunDataCallback,this);
Tun_Data_pub = nh.advertise<std_msgs::Bool>("tunnel_state",1);
Mot_Data_pub = nh.advertise<geometry_msgs::Twist>("cmd_vel",1);
Imu_Data_sub = nh.subscribe("/imu",10,&QNode::imuMsgCallback,this);
Sw_Data_sub = nh.subscribe("switch_data1",1,&QNode::SwDataCallback,this);
start();
return true;
}
void QNode::run()
{
ros::Rate loop_rate(100);
while(ros::ok())
{
ros::spinOnce();
loop_rate.sleep();
}
Q_EMIT rosShutdown(); // used to signal the gui for a shutdown (useful to roslaunch)
}
}
| 30.945578
| 152
| 0.570015
|
zang09
|
fe28cea5519b5f70868dccf8c8aa6ddcf37a6ff4
| 2,212
|
cpp
|
C++
|
LeetCode/1046.cpp
|
jnvshubham7/CPP_Programming
|
a17c4a42209556495302ca305b7c3026df064041
|
[
"Apache-2.0"
] | 1
|
2021-12-22T12:37:36.000Z
|
2021-12-22T12:37:36.000Z
|
LeetCode/1046.cpp
|
jnvshubham7/CPP_Programming
|
a17c4a42209556495302ca305b7c3026df064041
|
[
"Apache-2.0"
] | null | null | null |
LeetCode/1046.cpp
|
jnvshubham7/CPP_Programming
|
a17c4a42209556495302ca305b7c3026df064041
|
[
"Apache-2.0"
] | null | null | null |
class Solution {
public:
int lastStoneWeight(vector<int>& stones) {
priority_queue<int> pq;
for(int i=0;i<stones.size();i++)
{
pq.push(stones[i]);
}
int m1,m2;
while(!pq.empty())
{
if(pq.size()==1)
return pq.top();
m1=pq.top();
pq.pop();
m2=pq.top();
pq.pop();
if(m1!=m2)
pq.push(m1-m2);
}
return 0;
//return all the elements in the priority queue
// vector<int> v;
// while(!pq.empty())
// {
// v.push_back(pq.top());
// pq.pop();
// }
// //return v
// return v;
// return pq.top();
//sort the stones in descending order
// sort(stones.begin(), stones.end(), greater<int>());
// vector<int> new_stones;
// //if stone[i] == stone[i+1] then we can remove both of them
// //if stone[i] != stone[i+1] then stone[i] - stone[i+1] is the new stone isnpush in vector
// for (int i = 0; i < stones.size() - 1; i++) {
// if (stones[i] == stones[i + 1]) {
// i++;
// }
// else {
// new_stones.push_back(stones[i] - stones[i + 1]);
// }
// }
// //sort the new_stones in descending order
// sort(new_stones.begin(), new_stones.end(), greater<int>());
// vector<int> new_new_stones;
// //if new_stones[i] != new_stones[i+1] then push in new_new_stones
// for (int i = 0; i < new_stones.size() - 1; i++) {
// if (new_stones[i] == new_stones[i + 1]) {
// i++;
// }
// else {
// new_new_stones.push_back(new_stones[i]);
// }
// }
// //if new_new_stones is empty then return 0
// if (new_new_stones.empty()) {
// return 0;
// }
// else {
// //return all element of new_new_stones vector
// return accumulate(new_new_stones.begin(), new_new_stones.end(), 0);
// }
}
};
| 23.531915
| 100
| 0.429024
|
jnvshubham7
|
fe2f1d65cad7caeb819d4f7732fb572c6473d5a2
| 3,441
|
cpp
|
C++
|
VC2010Samples/Fusion/traceman/XMLReader.cpp
|
alonmm/VCSamples
|
6aff0b4902f5027164d593540fcaa6601a0407c3
|
[
"MIT"
] | 300
|
2019-05-09T05:32:33.000Z
|
2022-03-31T20:23:24.000Z
|
VC2010Samples/Fusion/traceman/XMLReader.cpp
|
JaydenChou/VCSamples
|
9e1d4475555b76a17a3568369867f1d7b6cc6126
|
[
"MIT"
] | 9
|
2016-09-19T18:44:26.000Z
|
2018-10-26T10:20:05.000Z
|
VC2010Samples/Fusion/traceman/XMLReader.cpp
|
JaydenChou/VCSamples
|
9e1d4475555b76a17a3568369867f1d7b6cc6126
|
[
"MIT"
] | 633
|
2019-05-08T07:34:12.000Z
|
2022-03-30T04:38:28.000Z
|
#include "StdAfx.h"
#include <atlbase.h>
#include <strsafe.h>
#include <cassert>
#include <shlwapi.h>
#include "XMLReader.h"
XMLReader::XMLReader(void)
{
typedef HRESULT (STDAPICALLTYPE *XMLReaderFunc)(__in REFIID riid, __out void ** ppvObject, __in_opt IMalloc * pMalloc);
HINSTANCE hInst = ::GetModuleHandleA("XMLLITE.DLL");
if (NULL == hInst) {
m_nError = S_FALSE;
}
XMLReaderFunc pfReader = reinterpret_cast<XMLReaderFunc>(GetProcAddress(hInst, "CreateXmlReader"));
if (NULL == pfReader) {
m_nError = S_FALSE;
}
m_nError = pfReader(__uuidof(IXmlReader), (void**) &m_pReader, NULL);
}
XMLReader::~XMLReader(void)
{
}
HRESULT XMLReader::GetLastError(void)
{
return m_nError;
}
HRESULT XMLReader::SetProperty(UINT nPropety, LONG_PTR pValue)
{
m_nError = m_pReader->SetProperty(nPropety, pValue);
return m_nError;
}
HRESULT XMLReader::SetInput(IUnknown *pInput)
{
assert(pInput != NULL);
m_nError = m_pReader->SetInput(pInput);
return m_nError;
}
HRESULT XMLReader::Read(NodeType *nNodeType)
{
m_nError = m_pReader->Read((XmlNodeType *)nNodeType);
return m_nError;
}
std::wstring XMLReader::GetValue()
{
const WCHAR *pwszTmp;
m_nError = m_pReader->GetValue(&pwszTmp, NULL);
return std::wstring(pwszTmp);
}
std::wstring XMLReader::GetLocalName()
{
const WCHAR *pwszTmp;
m_nError = m_pReader->GetLocalName(&pwszTmp, NULL);
return std::wstring(pwszTmp);
}
std::wstring XMLReader::GetPrefix()
{
const WCHAR *pwszTmp;
m_nError = m_pReader->GetPrefix(&pwszTmp, NULL);
return std::wstring(pwszTmp);
}
UINT XMLReader::GetDepth()
{
UINT nDepth = 0;
m_nError = m_pReader->GetDepth(&nDepth);
return nDepth;
}
UINT XMLReader::GetAttributeCount(void)
{
UINT nCount = 0;
m_nError = m_pReader->GetAttributeCount(&nCount);
return nCount;
}
bool XMLReader::IsEmptyElement(void)
{
return (m_pReader->IsEmptyElement() ? true : false);
}
HRESULT XMLReader::MoveToFirstAttribute(void)
{
m_nError = m_pReader->MoveToFirstAttribute();
return m_nError;
}
HRESULT XMLReader::MoveToNextAttribute(void)
{
m_nError = m_pReader->MoveToNextAttribute();
return m_nError;
}
HRESULT XMLReader::MoveToAttributeByName(const std::wstring& sName)
{
m_nError = m_pReader->MoveToAttributeByName(sName.c_str(), NULL);
return m_nError;
}
HRESULT XMLReader::LoadFromFile(const std::wstring& sFileName)
{
CComPtr<IStream> pFileStream;
m_nError = S_OK;
if (!FAILED(m_nError = SHCreateStreamOnFile(sFileName.c_str(), STGM_READ, &pFileStream)))
{
SetInput(pFileStream);
}
return m_nError;
}
HRESULT XMLReader::LoadFromBuffer(const BYTE* pBuffer, UINT nLen)
{
CComPtr<IStream> pFileStream;
m_nError = S_OK;
//on ia64 there is no definiton of SHCreateMemStream therfore
//we load it dynamicly from dll file
typedef struct IStream *(STDAPICALLTYPE *CreateMemStream)(__in_bcount_opt(cbInit) const BYTE *pInit, UINT cbInit);
HINSTANCE hInst = ::GetModuleHandleA("SHLWAPI.DLL");
if (NULL == hInst) {
m_nError = S_FALSE;
return m_nError;
}
//12 it's an ordinal for SHCreateMemStream function
CreateMemStream pfMemStream = reinterpret_cast<CreateMemStream>(GetProcAddress(hInst, reinterpret_cast<LPCSTR>(LOWORD(12))));
if (NULL == pfMemStream) {
m_nError = S_FALSE;
return m_nError;
}
pFileStream = (*pfMemStream)(pBuffer, nLen);
if (NULL == pFileStream) {
m_nError = S_FALSE;
}
else {
SetInput(pFileStream);
}
return m_nError;
}
| 18.906593
| 126
| 0.726533
|
alonmm
|
fe32937d5b521cce517c8f35e5e65bbb5887ba2d
| 41
|
cpp
|
C++
|
examples/ros/main.cpp
|
sanblch/hunter
|
a21edf8a43f567d2ae60ea1acdaab7d4facf3db7
|
[
"BSD-2-Clause"
] | 2,146
|
2015-01-10T07:26:58.000Z
|
2022-03-21T02:28:01.000Z
|
examples/ros/main.cpp
|
koinos/hunter
|
fc17bc391210bf139c55df7f947670c5dff59c57
|
[
"BSD-2-Clause"
] | 1,778
|
2015-01-03T11:50:30.000Z
|
2019-12-26T05:31:20.000Z
|
examples/ros/main.cpp
|
koinos/hunter
|
fc17bc391210bf139c55df7f947670c5dff59c57
|
[
"BSD-2-Clause"
] | 734
|
2015-03-05T19:52:34.000Z
|
2022-02-22T23:18:54.000Z
|
#include <ros/package.h>
int main() {
}
| 8.2
| 24
| 0.609756
|
sanblch
|
fe3481dff9a2b5e774b141fbe28a7a226f922bb5
| 667
|
cpp
|
C++
|
C-plus-plus/cpp_exercise/Chapter8/exercise2.cpp
|
dqhplhzz2008/Study-notes
|
0df739d22add100e0f5976226abce34242fae57b
|
[
"MIT"
] | 11
|
2018-10-09T03:45:27.000Z
|
2020-12-25T11:39:51.000Z
|
C-plus-plus/cpp_exercise/Chapter8/exercise2.cpp
|
dqhplhzz2008/Study-notes
|
0df739d22add100e0f5976226abce34242fae57b
|
[
"MIT"
] | 2
|
2019-03-07T02:45:49.000Z
|
2019-03-07T03:55:08.000Z
|
C-plus-plus/cpp_exercise/Chapter8/exercise2.cpp
|
dqhplhzz2008/Study-notes
|
0df739d22add100e0f5976226abce34242fae57b
|
[
"MIT"
] | 7
|
2019-03-07T02:46:14.000Z
|
2022-03-19T03:30:22.000Z
|
//C++ Primer Plus Edition 5
//Chapter 8 Homework 2
#include<iostream>
#include<string>
using namespace std;
struct CandyBar {
string name;
double weight;
int hot;
};
void set_CandyBar(CandyBar &candy, char* n = "Millennium Munch", double w = 2.85, int h = 360);
void show_CandyBar(const CandyBar &c);
int main() {
CandyBar candy;
set_CandyBar(candy);
show_CandyBar(candy);
system("pause");
return 0;
}
void set_CandyBar(CandyBar &c, char* n, double w, int h)
{
c.name = n;
c.weight = w;
c.hot = h;
}
void show_CandyBar(const CandyBar &c)
{
cout << "Name: " << c.name << endl;
cout << "Weight: " << c.weight << endl;
cout << "Hot: " << c.hot << endl;
}
| 20.212121
| 95
| 0.655172
|
dqhplhzz2008
|
fe3b675d53dcf177886e9ba97e92796fffda964a
| 791
|
hpp
|
C++
|
include/Quasura/ECS.hpp
|
jcoder39/Quasura
|
f6a8b43620aa77f5488327f0cfe4773b7301bae4
|
[
"MIT"
] | null | null | null |
include/Quasura/ECS.hpp
|
jcoder39/Quasura
|
f6a8b43620aa77f5488327f0cfe4773b7301bae4
|
[
"MIT"
] | null | null | null |
include/Quasura/ECS.hpp
|
jcoder39/Quasura
|
f6a8b43620aa77f5488327f0cfe4773b7301bae4
|
[
"MIT"
] | null | null | null |
/*
* ECS.hpp
*
* Created by Viacheslav Borisenko
*
* Copyright (c) 2018 spectrobyte http://spectrobyte.com
*
* This software may be modified and distributed under the terms
* of the MIT license. See the LICENSE file for details.
*
*/
#ifndef QUASURA_ECS_ENGINE_HPP
#define QUASURA_ECS_ENGINE_HPP
#include "Quasura/ECS/System.hpp"
#include "Quasura/ECS/Component.hpp"
#include "Quasura/ECS/Object.hpp"
#include "Quasura/ECS/ECS.hpp"
#include "Quasura/ECS/ComponentCollection.hpp"
#include "Quasura/ECS/ComponentContainer.hpp"
#include "Quasura/ECS/Entity.hpp"
#include "Quasura/ECS/events/RemoveComponentEvent.hpp"
#include "Quasura/ECS/events/AddComponentEvent.hpp"
#include "Quasura/ECS/events/RemoveEntityEvent.hpp"
#endif //QUASURA_ECS_ENGINE_HPP
| 28.25
| 65
| 0.749684
|
jcoder39
|
fe3b77782ee173c4ed6e9be2bebdd84038a1c8b6
| 2,177
|
hpp
|
C++
|
src/include/util.hpp
|
loda-lang/loda-cpp
|
439ff19ea478eb8f1c07c0a808f8f3628c5e47c0
|
[
"Apache-2.0"
] | 8
|
2021-08-22T11:12:45.000Z
|
2022-03-20T16:52:23.000Z
|
src/include/util.hpp
|
lodalang/loda-cpp
|
439ff19ea478eb8f1c07c0a808f8f3628c5e47c0
|
[
"Apache-2.0"
] | 69
|
2021-08-28T10:34:30.000Z
|
2022-03-20T19:16:19.000Z
|
src/include/util.hpp
|
lodalang/loda-cpp
|
439ff19ea478eb8f1c07c0a808f8f3628c5e47c0
|
[
"Apache-2.0"
] | 1
|
2021-08-29T08:36:12.000Z
|
2021-08-29T08:36:12.000Z
|
#pragma once
#include <chrono>
#include <csignal>
#include <map>
#include <random>
#include <string>
#include <vector>
class Version {
public:
static const std::string VERSION;
static const std::string BRANCH;
static const std::string INFO;
static const std::string PLATFORM;
static const bool IS_RELEASE;
};
class Log {
public:
enum Level { DEBUG, INFO, WARN, ERROR, ALERT };
class AlertDetails {
public:
std::string text;
std::string title;
std::string title_link;
std::string color;
};
Log();
static Log &get();
void debug(const std::string &msg);
void info(const std::string &msg);
void warn(const std::string &msg);
void error(const std::string &msg, bool throw_ = false);
void alert(const std::string &msg, AlertDetails details = AlertDetails());
Level level;
bool silent;
bool loaded_alerts_config;
bool slack_alerts;
bool tweet_alerts;
private:
int twitter_client;
void slack(const std::string &msg, AlertDetails details);
void tweet(const std::string &msg);
void log(Level level, const std::string &msg);
};
class Settings {
public:
static constexpr size_t DEFAULT_NUM_TERMS = 10;
static constexpr int64_t DEFAULT_MAX_MEMORY = 100;
static constexpr int64_t DEFAULT_MAX_CYCLES = 5000000;
size_t num_terms;
int64_t max_memory;
int64_t max_cycles;
bool use_steps;
bool parallel_mining;
std::string miner_profile;
// flag and offset for printing evaluation results in b-file format
bool print_as_b_file;
int64_t print_as_b_file_offset;
Settings();
std::vector<std::string> parseArgs(int argc, char *argv[]);
void printArgs(std::vector<std::string> &args);
};
class AdaptiveScheduler {
public:
AdaptiveScheduler(int64_t target_seconds);
bool isTargetReached();
void reset();
private:
const std::chrono::time_point<std::chrono::steady_clock> setup_time;
std::chrono::time_point<std::chrono::steady_clock> start_time;
const int64_t target_milliseconds;
size_t current_checks;
size_t total_checks;
size_t next_check;
};
class Random {
public:
static Random &get();
uint64_t seed;
std::mt19937 gen;
private:
Random();
};
| 20.157407
| 76
| 0.715204
|
loda-lang
|
fe40a27cfeb5081de4f0a9ed5db01b18145a6ddc
| 2,379
|
hpp
|
C++
|
NightFall/borealis/library/include/borealis/i18n.hpp
|
StarDustCFW/NightFall
|
b66be81a6d10cfd71773e74156fcaf5e513ae262
|
[
"MIT"
] | 57
|
2020-09-19T00:16:10.000Z
|
2021-11-30T20:55:18.000Z
|
NightFall/borealis/library/include/borealis/i18n.hpp
|
StarDustCFW/NightFall
|
b66be81a6d10cfd71773e74156fcaf5e513ae262
|
[
"MIT"
] | 23
|
2020-09-17T20:32:59.000Z
|
2021-11-12T18:57:25.000Z
|
NightFall/borealis/library/include/borealis/i18n.hpp
|
StarDustCFW/NightFall
|
b66be81a6d10cfd71773e74156fcaf5e513ae262
|
[
"MIT"
] | 9
|
2020-09-22T01:24:19.000Z
|
2021-09-29T20:42:23.000Z
|
/*
Borealis, a Nintendo Switch UI Library
Copyright (C) 2020 natinusala
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#pragma once
#include <fmt/core.h>
#include <string>
namespace brls::i18n
{
// TODO: add support for string arrays
namespace internal
{
std::string getRawStr(std::string stringName);
} // namespace internal
/**
* Returns the translation for the given string,
* after injecting format parameters (if any)
*/
template <typename... Args>
std::string getStr(std::string stringName, Args&&... args)
{
std::string rawStr = brls::i18n::internal::getRawStr(stringName);
try
{
return fmt::format(rawStr, args...);
}
catch (const std::exception& e)
{
Logger::error("Invalid format \"{}\" from string \"{}\": {}", rawStr, stringName, e.what());
return stringName;
}
}
/**
* Loads all translations of the current system locale + default locale
* Must be called before trying to get a translation!
*/
void loadTranslations();
/**
* Loads all translations of the desired locale + default locale
* Must be called before trying to get a translation!
*/
void loadTranslations(std::string locale);
/**
* Returns the current system locale
* NOT the one that's currently used in the app!
*/
std::string getCurrentLocale();
/**
* Returns the current system locale id
* this id only make sense for libnx
* NOT the one that's currently used in the app!
*/
int nxGetCurrentLocaleID();
inline namespace literals
{
/**
* Returns the translation for the given string, without
* injecting any parameters
* Shortcut to i18n::getStr(stringName)
*/
std::string operator"" _i18n(const char* str, size_t len);
} // namespace literals
} // namespace brls::i18n
| 26.142857
| 100
| 0.694409
|
StarDustCFW
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.