blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 3
264
| content_id
stringlengths 40
40
| detected_licenses
sequencelengths 0
85
| license_type
stringclasses 2
values | repo_name
stringlengths 5
140
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 986
values | visit_date
timestamp[us] | revision_date
timestamp[us] | committer_date
timestamp[us] | github_id
int64 3.89k
681M
⌀ | star_events_count
int64 0
209k
| fork_events_count
int64 0
110k
| gha_license_id
stringclasses 23
values | gha_event_created_at
timestamp[us] | gha_created_at
timestamp[us] | gha_language
stringclasses 145
values | src_encoding
stringclasses 34
values | language
stringclasses 1
value | is_vendor
bool 1
class | is_generated
bool 2
classes | length_bytes
int64 3
10.4M
| extension
stringclasses 122
values | content
stringlengths 3
10.4M
| authors
sequencelengths 1
1
| author_id
stringlengths 0
158
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
6f17f3e14039623fb09f71f63a1ddef1aa9f1cbf | efe2b4dedbc6bab31ffe88c271daa5463f8649f6 | /tags/libtorrent-0_15_0/include/libtorrent/web_peer_connection.hpp | 18487dc68ea24a00c49b34921f65ade4f1d58514 | [] | no_license | svn2github/libtorrent | 867c84f0c271cdc255c3e268c17db75d46010dde | 8cfe21e253d8b90086bb0b15c6c881795bf12ea1 | refs/heads/master | 2020-03-30T03:50:32.931129 | 2015-01-07T23:21:54 | 2015-01-07T23:21:54 | 17,344,601 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 5,627 | hpp | /*
Copyright (c) 2003, Arvid Norberg
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the distribution.
* Neither the name of the author nor the names of its
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef TORRENT_WEB_PEER_CONNECTION_HPP_INCLUDED
#define TORRENT_WEB_PEER_CONNECTION_HPP_INCLUDED
#include <ctime>
#include <algorithm>
#include <vector>
#include <deque>
#include <string>
#include "libtorrent/debug.hpp"
#ifdef _MSC_VER
#pragma warning(push, 1)
#endif
#include <boost/smart_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include <boost/noncopyable.hpp>
#include <boost/array.hpp>
#include <boost/optional.hpp>
#include <boost/cstdint.hpp>
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#include "libtorrent/buffer.hpp"
#include "libtorrent/peer_connection.hpp"
#include "libtorrent/socket.hpp"
#include "libtorrent/peer_id.hpp"
#include "libtorrent/storage.hpp"
#include "libtorrent/stat.hpp"
#include "libtorrent/alert.hpp"
#include "libtorrent/torrent_handle.hpp"
#include "libtorrent/torrent.hpp"
#include "libtorrent/peer_request.hpp"
#include "libtorrent/piece_block_progress.hpp"
#include "libtorrent/config.hpp"
// parse_url
#include "libtorrent/tracker_manager.hpp"
#include "libtorrent/http_parser.hpp"
namespace libtorrent
{
class torrent;
namespace detail
{
struct session_impl;
}
class TORRENT_EXPORT web_peer_connection
: public peer_connection
{
friend class invariant_access;
public:
// this is the constructor where the we are the active part.
// The peer_conenction should handshake and verify that the
// other end has the correct id
web_peer_connection(
aux::session_impl& ses
, boost::weak_ptr<torrent> t
, boost::shared_ptr<socket_type> s
, tcp::endpoint const& remote
, std::string const& url
, policy::peer* peerinfo);
void start();
~web_peer_connection();
// called from the main loop when this connection has any
// work to do.
void on_sent(error_code const& error
, std::size_t bytes_transferred);
void on_receive(error_code const& error
, std::size_t bytes_transferred);
std::string const& url() const { return m_original_url; }
virtual void get_specific_peer_info(peer_info& p) const;
virtual bool in_handshake() const;
// the following functions appends messages
// to the send buffer
void write_choke() {}
void write_unchoke() {}
void write_interested() {}
void write_not_interested() {}
void write_request(peer_request const& r);
void write_cancel(peer_request const& r)
{ incoming_reject_request(r); }
void write_have(int index) {}
void write_piece(peer_request const& r, disk_buffer_holder& buffer) { TORRENT_ASSERT(false); }
void write_keepalive() {}
void on_connected();
void write_reject_request(peer_request const&) {}
void write_allow_fast(int) {}
#ifdef TORRENT_DEBUG
void check_invariant() const;
#endif
private:
// returns the block currently being
// downloaded. And the progress of that
// block. If the peer isn't downloading
// a piece for the moment, the boost::optional
// will be invalid.
boost::optional<piece_block_progress> downloading_piece_progress() const;
// this has one entry per bittorrent request
std::deque<peer_request> m_requests;
// this has one entry per http-request
// (might be more than the bt requests)
std::deque<int> m_file_requests;
std::string m_server_string;
http_parser m_parser;
std::string m_auth;
std::string m_host;
int m_port;
std::string m_path;
std::string m_url;
const std::string m_original_url;
// the first request will contain a little bit more data
// than subsequent ones, things that aren't critical are left
// out to save bandwidth.
bool m_first_request;
// this is used for intermediate storage of pieces
// that are received in more than one HTTP response
std::vector<char> m_piece;
// the number of bytes into the receive buffer where
// current read cursor is.
int m_body_start;
// the number of bytes received in the current HTTP
// response. used to know where in the buffer the
// next response starts
int m_received_body;
// position in the current range response
int m_range_pos;
// the position in the current block
int m_block_pos;
};
}
#endif // TORRENT_WEB_PEER_CONNECTION_HPP_INCLUDED
| [
"arvidn@f43f7eb3-cfe1-5f9d-1b5f-e45aa6702bda"
] | arvidn@f43f7eb3-cfe1-5f9d-1b5f-e45aa6702bda |
adf1f621d2426a876b4ecd21f97a23d5729e4b32 | 80ce41145cae41a57ee55ee03c230f110e209c39 | /examples/rvsimple/metron/singlecycle_datapath.h | e7d8ccdc131badac523690075284a65322f0a8b3 | [
"MIT"
] | permissive | fengjixuchui/Metron | 2d2abcfc1b9191d2950116082fd5b04d5476ee1b | 49093c2fa734a856e1ebb78e240d8b6dbae8cc8a | refs/heads/master | 2023-03-16T16:03:18.688900 | 2023-02-01T06:28:59 | 2023-02-01T06:28:59 | 494,727,930 | 0 | 0 | MIT | 2023-02-01T06:29:00 | 2022-05-21T08:43:57 | C++ | UTF-8 | C++ | false | false | 4,727 | h | // RISC-V SiMPLE SV -- single-cycle data path
// BSD 3-Clause License
// (c) 2017-2019, Arthur Matos, Marcus Vinicius Lamar, Universidade de Brasília,
// Marek Materzok, University of Wrocław
#ifndef SINGLECYCLE_DATAPATH_H
#define SINGLECYCLE_DATAPATH_H
#include "adder.h"
#include "alu.h"
#include "config.h"
#include "constants.h"
#include "immediate_generator.h"
#include "instruction_decoder.h"
#include "metron_tools.h"
#include "multiplexer2.h"
#include "multiplexer4.h"
#include "multiplexer8.h"
#include "regfile.h"
#include "register.h"
class singlecycle_datapath {
public:
logic<1> reset;
logic<32> data_mem_read_data;
logic<32> data_mem_address;
logic<32> data_mem_write_data;
logic<32> inst;
logic<32> pc;
logic<7> inst_opcode;
logic<3> inst_funct3;
logic<7> inst_funct7;
logic<1> alu_result_equal_zero;
// control signals
logic<1> pc_write_enable;
logic<1> regfile_write_enable;
logic<1> alu_operand_a_select;
logic<1> alu_operand_b_select;
logic<3> reg_writeback_select;
logic<2> next_pc_select;
logic<5> alu_function;
private:
logic<32> rs1_data;
logic<32> rs2_data;
logic<5> inst_rd;
logic<5> inst_rs1;
logic<5> inst_rs2;
public:
//----------------------------------------
void tock_pc() { pc = program_counter.value; }
//----------------------------------------
void tock_instruction_decoder() {
idec.inst = inst;
idec.tock();
inst_opcode = idec.inst_opcode;
inst_funct3 = idec.inst_funct3;
inst_funct7 = idec.inst_funct7;
inst_rd = idec.inst_rd;
inst_rs1 = idec.inst_rs1;
inst_rs2 = idec.inst_rs2;
}
//----------------------------------------
void tock_immediate_generator() {
igen.inst = inst;
igen.tock();
}
//----------------------------------------
void tock_reg_read() {
regs.rd_address = idec.inst_rd;
regs.rs1_address = idec.inst_rs1;
regs.rs2_address = idec.inst_rs2;
regs.tock1();
rs1_data = regs.rs1_data;
rs2_data = regs.rs2_data;
}
void tock_mux_operand_a() {
mux_operand_a.sel = alu_operand_a_select;
mux_operand_a.in0 = regs.rs1_data;
mux_operand_a.in1 = program_counter.value;
mux_operand_a.tock();
}
void tock_mux_operand_b() {
mux_operand_b.sel = alu_operand_b_select;
mux_operand_b.in0 = regs.rs2_data;
mux_operand_b.in1 = igen.immediate;
mux_operand_b.tock();
}
void tock_alu() {
alu_core.alu_function = alu_function;
alu_core.operand_a = mux_operand_a.out;
alu_core.operand_b = mux_operand_b.out;
alu_core.tock();
alu_result_equal_zero = alu_core.result_equal_zero;
}
void tock_adder_pc_plus_4() {
adder_pc_plus_4.operand_a = b32(0x00000004);
adder_pc_plus_4.operand_b = program_counter.value;
adder_pc_plus_4.tock();
}
void tock_adder_pc_plus_immediate() {
adder_pc_plus_immediate.operand_a = program_counter.value;
adder_pc_plus_immediate.operand_b = igen.immediate;
adder_pc_plus_immediate.tock();
}
void tock_data_mem_write_data() {
data_mem_address = alu_core.result;
data_mem_write_data = regs.rs2_data;
}
void tock_mux_next_pc_select() {
mux_next_pc_select.sel = next_pc_select;
mux_next_pc_select.in0 = adder_pc_plus_4.result;
mux_next_pc_select.in1 = adder_pc_plus_immediate.result;
mux_next_pc_select.in2 = cat(b31(alu_core.result, 1), b1(0b0));
mux_next_pc_select.in3 = b32(0b0);
mux_next_pc_select.tock();
}
void tock_program_counter() {
program_counter.reset = reset;
program_counter.write_enable = pc_write_enable;
program_counter.next = mux_next_pc_select.out;
program_counter.tock();
}
void tock_mux_reg_writeback() {
mux_reg_writeback.sel = reg_writeback_select;
mux_reg_writeback.in0 = alu_core.result;
mux_reg_writeback.in1 = data_mem_read_data;
mux_reg_writeback.in2 = adder_pc_plus_4.result;
mux_reg_writeback.in3 = igen.immediate;
mux_reg_writeback.in4 = b32(0b0);
mux_reg_writeback.in5 = b32(0b0);
mux_reg_writeback.in6 = b32(0b0);
mux_reg_writeback.in7 = b32(0b0);
mux_reg_writeback.tock();
}
void tock_reg_writeback() {
regs.write_enable = regfile_write_enable;
regs.rd_data = mux_reg_writeback.out;
regs.tock();
}
//----------------------------------------
private:
adder<32> adder_pc_plus_4;
adder<32> adder_pc_plus_immediate;
alu alu_core;
multiplexer4<32> mux_next_pc_select;
multiplexer2<32> mux_operand_a;
multiplexer2<32> mux_operand_b;
multiplexer8<32> mux_reg_writeback;
single_register<32, rv_config::INITIAL_PC> program_counter;
regfile regs;
instruction_decoder idec;
immediate_generator igen;
};
#endif // SINGLECYCLE_DATAPATH_H
| [
"[email protected]"
] | |
72019cd51f27300236cef61b86a564ca507f76f7 | b993bb63ccad4cd8dc5dc3ad078eea165e338dc4 | /src/crypto.cpp | 3a662d56035e4e3d1b8d1929a8c92b2ae520e428 | [] | no_license | kwiaczek/BruvChatClient | 099d13fd4cec67bf1dcf1db90fc6ee2e47f6c4de | a75141f05cdf8be556040df0f27513c1a328852f | refs/heads/master | 2021-04-01T10:34:41.696217 | 2020-05-16T15:06:15 | 2020-05-16T15:06:15 | 248,182,602 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 14,194 | cpp | #include "crypto.h"
#include "device.h"
#include <memory>
#include "utils.h"
// todo: choose correct value
#define MAX_SKIP 9999999
void X3DH::initiate(Device *sender, Device *receiver)
{
std::vector<std::unique_ptr<DH>> dhs;
for(int i =0; i < 3; i++)
{
dhs.push_back(std::make_unique<DH>());
}
//DH1 = DH(IKA, SPKB)
dhs[0]->initalize(sender->identity_key.x25519_keypair, receiver->signed_prekey.x25519_keypair);
//DH2 = DH(EKA, IKB)
dhs[1]->initalize(ephemeral, receiver->identity_key.x25519_keypair);
//DH3 = DH(EKA, SPKB)
dhs[2]->initalize(ephemeral, receiver->signed_prekey.x25519_keypair);
//SK = KDF(DH1 || DH2 || DH3
//derive rx
crypto_generichash_state state;
crypto_generichash_init(&state, dhs[0]->rx.data(), dhs[0]->rx.size(), rx.size());
crypto_generichash_init(&state, dhs[1]->rx.data(), dhs[1]->rx.size(), rx.size());
crypto_generichash_init(&state, dhs[2]->rx.data(), dhs[2]->rx.size(), rx.size());
crypto_generichash_final(&state, rx.data(), rx.size());
//derive tx
crypto_generichash_init(&state, dhs[0]->tx.data(), dhs[0]->tx.size(), tx.size());
crypto_generichash_init(&state, dhs[1]->tx.data(), dhs[1]->tx.size(), tx.size());
crypto_generichash_init(&state, dhs[2]->tx.data(), dhs[2]->tx.size(), tx.size());
crypto_generichash_final(&state, tx.data(), tx.size());
}
void X3DH::sync(Device *sender, Device *receiver)
{
std::vector<std::unique_ptr<DH>> dhs;
for(int i =0; i < 3; i++)
{
dhs.push_back(std::make_unique<DH>());
}
//DH1 = DH(IKA, SPKB)
dhs[0]->sync(sender->identity_key.x25519_keypair, receiver->signed_prekey.x25519_keypair);
//DH2 = DH(EKA, IKB)
dhs[1]->sync(ephemeral, receiver->identity_key.x25519_keypair);
//DH3 = DH(EKA, SPKB)
dhs[2]->sync(ephemeral, receiver->signed_prekey.x25519_keypair);
//SK = KDF(DH1 || DH2 || DH3
//derive rx
crypto_generichash_state state;
crypto_generichash_init(&state, dhs[0]->rx.data(), dhs[0]->rx.size(), rx.size());
crypto_generichash_init(&state, dhs[1]->rx.data(), dhs[1]->rx.size(), rx.size());
crypto_generichash_init(&state, dhs[2]->rx.data(), dhs[2]->rx.size(), rx.size());
crypto_generichash_final(&state, rx.data(), rx.size());
//derive tx
crypto_generichash_init(&state, dhs[0]->tx.data(), dhs[0]->tx.size(), tx.size());
crypto_generichash_init(&state, dhs[1]->tx.data(), dhs[1]->tx.size(), tx.size());
crypto_generichash_init(&state, dhs[2]->tx.data(), dhs[2]->tx.size(), tx.size());
crypto_generichash_final(&state, tx.data(), tx.size());
}
QJsonObject X3DH::toJson()
{
QJsonObject obj;
obj.insert("rx", bytesToBase64qstring(rx));
obj.insert("tx", bytesToBase64qstring(tx));
obj.insert("ephemeral", ephemeral.toJson(X25519_PRIVATE));
return obj;
}
void X3DH::parseJson(const QJsonDocument &serialzed_data)
{
rx = base64QStringToBytes(serialzed_data["rx"].toString());
tx = base64QStringToBytes(serialzed_data["tx"].toString());
ephemeral.parseJson(QJsonDocument(serialzed_data["ephemeral"].toObject()));
}
X3DH::X3DH(){
rx.reserve(crypto_kx_SESSIONKEYBYTES);
rx.resize(crypto_kx_SESSIONKEYBYTES);
tx.reserve(crypto_kx_SESSIONKEYBYTES);
tx.resize(crypto_kx_SESSIONKEYBYTES);
ephemeral.public_key.reserve(crypto_box_PUBLICKEYBYTES);
ephemeral.public_key.resize(crypto_box_PUBLICKEYBYTES);
ephemeral.secret_key.reserve(crypto_box_SECRETKEYBYTES);
ephemeral.secret_key.resize(crypto_box_SECRETKEYBYTES);
}
void DH::initalize(const X25519 &sender, const X25519 &receiver)
{
crypto_kx_client_session_keys(rx.data(), tx.data(), sender.public_key.data(), sender.secret_key.data(), receiver.public_key.data());
}
void DH::sync(const X25519 &sender, const X25519 & receiver)
{
crypto_kx_server_session_keys(rx.data(), tx.data(), receiver.public_key.data(), receiver.secret_key.data(), sender.public_key.data());
}
DH::DH()
{
rx.reserve(crypto_kx_SESSIONKEYBYTES);
rx.resize(crypto_kx_SESSIONKEYBYTES);
tx.reserve(crypto_kx_SESSIONKEYBYTES);
tx.resize(crypto_kx_SESSIONKEYBYTES);
}
DoubleRatchet::DoubleRatchet()
{
x3dh = nullptr;
rx_chainkey.reserve(crypto_kx_SESSIONKEYBYTES);
rx_chainkey.resize(crypto_kx_SESSIONKEYBYTES);
tx_chainkey.reserve(crypto_kx_SESSIONKEYBYTES);
tx_chainkey.resize(crypto_kx_SESSIONKEYBYTES);
/*
state.Ns = 0
state.Nr = 0
state.PN = 0
*/
tx_counter = 0;
tx_previous = 0;
rx_counter = 0;
}
void DoubleRatchet::initalize()
{
x3dh = new X3DH();
x3dh->ephemeral.generate();
x3dh->initiate(init_device, sync_device);
//initalize with x3dh
std::copy(x3dh->rx.begin(), x3dh->rx.end(), rx_chainkey.begin());
std::copy(x3dh->tx.begin(), x3dh->tx.end(), tx_chainkey.begin());
//state.DHs = bob_dh_key_pair
self.generate();
}
void DoubleRatchet::sync(MessageHeader header)
{
x3dh = new X3DH();
x3dh->ephemeral = header.ephemeral;
x3dh->sync(init_device, sync_device);
//initalize with x3dh
std::copy(x3dh->rx.begin(), x3dh->rx.end(), rx_chainkey.begin());
std::copy(x3dh->tx.begin(), x3dh->tx.end(), tx_chainkey.begin());
//state.DHs = GENERATE_DH()
self.generate();
//state.DHr = bob_dh_public_key
remote = header.self;
//state.RK, state.CKs = KDF_RK(SK, DH(state.DHs, state.DHr))
std::unique_ptr<DH> dh = std::make_unique<DH>();
dh->initalize(self, remote);
crypto_generichash_state state;
crypto_generichash_init(&state, tx_chainkey.data(), tx_chainkey.size(), tx_chainkey.size());
crypto_generichash_update(&state, dh->tx.data(), dh->tx.size());
crypto_generichash_final(&state, tx_chainkey.data(), tx_chainkey.size());
}
EncryptedMessage DoubleRatchet::encrypt(const std::string &plaintext)
{
if(x3dh == nullptr)
{
initalize();
}
EncryptedMessage encrypted_message;
//message key
std::vector<unsigned char> mk;
mk.reserve(crypto_aead_aes256gcm_KEYBYTES);
mk.resize(crypto_aead_aes256gcm_KEYBYTES);
crypto_kdf_derive_from_key(mk.data(), mk.size(), tx_counter, "RATCHET", tx_chainkey.data());
//nonce
std::vector<unsigned char> nonce;
nonce.reserve(crypto_aead_aes256gcm_NPUBBYTES);
nonce.resize(crypto_aead_aes256gcm_NPUBBYTES);
randombytes_buf(nonce.data(), nonce.size());
//create header
encrypted_message.header = header(nonce);
encrypted_message.ciphertext.reserve(plaintext.size() + crypto_aead_aes256gcm_ABYTES);
encrypted_message.ciphertext.resize(plaintext.size() + crypto_aead_aes256gcm_ABYTES);
crypto_aead_aes256gcm_encrypt(encrypted_message.ciphertext.data(), nullptr, (unsigned char *) plaintext.c_str(), plaintext.size(), encrypted_message.header.toJsonBytes().data(), encrypted_message.header.toJsonBytes().size(), NULL, nonce.data(), mk.data());
tx_counter++;
return encrypted_message;
}
DecryptedMessage DoubleRatchet::decrypt(EncryptedMessage encrypted)
{
if(x3dh == nullptr)
{
sync(encrypted.header);
}
std::vector<unsigned char> mk = get_message_key(encrypted.header);
std::vector<unsigned char> nonce = encrypted.header.nonce;
std::vector<unsigned char> ciphertext =encrypted.ciphertext;
DecryptedMessage decrypted_message;
decrypted_message.plaintext.reserve(ciphertext.size() - crypto_aead_aes256gcm_ABYTES);
decrypted_message.plaintext.resize(ciphertext.size() - crypto_aead_aes256gcm_ABYTES);
if(ciphertext.size() < crypto_aead_aes256gcm_ABYTES || (crypto_aead_aes256gcm_decrypt(decrypted_message.plaintext.data(), nullptr, NULL, ciphertext.data(), ciphertext.size(), encrypted.header.toJsonBytes().data(), encrypted.header.toJsonBytes().size(), nonce.data(), mk.data()) != 0))
{
std::cerr << "error!!" << std::endl;
}
return decrypted_message;
}
QJsonObject DoubleRatchet::toJson()
{
QJsonObject obj;
obj.insert("self", self.toJson(X25519_PRIVATE));
obj.insert("remote", remote.toJson(X25519_PRIVATE_REMOTE));
obj.insert("rx_chainkey", bytesToBase64qstring(rx_chainkey));
obj.insert("tx_chainkey", bytesToBase64qstring(tx_chainkey));
obj.insert("rx_counter", rx_counter);
obj.insert("tx_counter", tx_counter);
obj.insert("tx_previous", tx_previous);
QJsonArray skipped_message_keys_json;
for(auto it = skipped_messages_keys.begin(); it != skipped_messages_keys.end(); it++)
{
QJsonObject skipped_key_json;
QJsonObject index;
std::pair<std::vector<unsigned char>, long long> index_pair = it->first;
index.insert("public_key", bytesToBase64qstring(std::get<0>(index_pair)));
index.insert("n", std::get<1>(index_pair));
skipped_key_json.insert("index", index);
skipped_key_json.insert("key", bytesToBase64qstring(it->second));
skipped_message_keys_json.append(skipped_key_json);
}
obj.insert("skipped_message_keys", skipped_message_keys_json);
obj.insert("x3dh", x3dh->toJson());
return obj;
}
void DoubleRatchet::parseJson(const QJsonDocument &serialized_data)
{
self.parseJson(QJsonDocument(serialized_data["self"].toObject()));
remote.parseJson(QJsonDocument(serialized_data["remote"].toObject()));
rx_chainkey = base64QStringToBytes(serialized_data["rx_chainkey"].toString());
tx_chainkey = base64QStringToBytes(serialized_data["tx_chainkey"].toString());
rx_counter = serialized_data["rx_counter"].toInt();
tx_counter = serialized_data["tx_counter"].toInt();
tx_previous = serialized_data["tx_previous"].toInt();
QJsonArray skipped_key_array_json = serialized_data["skipped_message_keys"].toArray();
for(int i =0 ; i < skipped_key_array_json.size(); i++)
{
QJsonObject skipped_key_json = skipped_key_array_json[i].toObject();
QJsonObject index = skipped_key_json["index"].toObject();
std::pair<std::vector<unsigned char>, long long> index_pair = std::make_pair(base64QStringToBytes(index["public_key"].toString()), index["n"].toInt());
skipped_messages_keys[index_pair] = base64QStringToBytes(skipped_key_json["key"].toString());
}
x3dh = new X3DH();
x3dh->parseJson(QJsonDocument(serialized_data["x3dh"].toObject()));
}
MessageHeader DoubleRatchet::header(const std::vector<unsigned char> &nonce)
{
MessageHeader h;
h.nonce = nonce;
h.self = self;
h.tx_counter = tx_counter;
h.tx_previous = tx_previous;
h.ephemeral = x3dh->ephemeral;
return h;
}
std::vector<unsigned char> DoubleRatchet::get_message_key(MessageHeader h)
{
X25519 send_remote_key = h.self;
long long n = h.tx_counter;
long long pn = h.tx_previous;
auto index = skipped_messages_keys.find(std::make_pair(send_remote_key.public_key, n));
if(index != skipped_messages_keys.end())
{
auto mk = index->second;
skipped_messages_keys.erase(index);
return mk;
}
if(send_remote_key.public_key != remote.public_key)
{
skip_message(pn);
dhratchet(send_remote_key);
}
skip_message(n);
std::vector<unsigned char> mk;
mk.reserve(crypto_aead_aes256gcm_KEYBYTES);
mk.resize(crypto_aead_aes256gcm_KEYBYTES);
crypto_kdf_derive_from_key(mk.data(), mk.size(), rx_counter, "RATCHET", rx_chainkey.data());
rx_counter++;
return mk;
}
void DoubleRatchet::skip_message(long long until)
{
if(rx_counter + MAX_SKIP < until)
{
std::cerr << "TO MANY MESSAGES SKIPPED!" << std::endl;
}
for(rx_counter; rx_counter<until;rx_counter+=1)
{
std::vector<unsigned char> mk;
mk.reserve(crypto_aead_aes256gcm_KEYBYTES);
mk.resize(crypto_aead_aes256gcm_KEYBYTES);
crypto_kdf_derive_from_key(mk.data(), mk.size(), rx_counter, "RATCHET", rx_chainkey.data());
auto index = std::make_pair(remote.public_key, rx_counter);
skipped_messages_keys[index] = mk;
}
}
void DoubleRatchet::dhratchet(const X25519 &new_remote)
{
//state.PN = state.Ns
//state.Ns = 0
//state.Nr = 0
tx_previous = tx_counter;
tx_counter = 0;
rx_counter = 0;
// state.DHr = header.dh
remote = new_remote;
// state.RK, state.CKr = KDF_RK(state.RK, DH(state.DHs, state.DHr))
std::unique_ptr<DH> dh = std::make_unique<DH>();
dh->sync(remote, self);
crypto_generichash_state state;
crypto_generichash_init(&state, rx_chainkey.data(), rx_chainkey.size(), rx_chainkey.size());
crypto_generichash_update(&state, dh->rx.data(), dh->rx.size());
crypto_generichash_final(&state, rx_chainkey.data(), rx_chainkey.size());
// state.DHs = GENERATE_DH()
self.generate();
dh = std::make_unique<DH>();
dh->initalize(self, remote);
crypto_generichash_init(&state, tx_chainkey.data(), tx_chainkey.size(), tx_chainkey.size());
crypto_generichash_update(&state, dh->tx.data(), dh->tx.size());
crypto_generichash_final(&state, tx_chainkey.data(), tx_chainkey.size());
}
QJsonObject IdentityKey::toJson(int serializaion_type)
{
QJsonObject obj;
obj.insert("serialization_type", serializaion_type);
obj.insert("ed25519", ed25519_keypair.toJson(serializaion_type));
return obj;
}
void IdentityKey::parseJson(const QJsonDocument &serialized_data)
{
int serialization_type = serialized_data["serialization_type"].toInt();
ed25519_keypair.parseJson(QJsonDocument(serialized_data["ed25519"].toObject()));
x25519_keypair.derive_from_ed25519(ed25519_keypair);
}
QJsonObject SignedPreKey::toJson(int serializaion_type)
{
QJsonObject obj;
obj.insert("serialization_type", serializaion_type);
obj.insert("ed25519", ed25519_keypair.toJson(serializaion_type));
obj.insert("signature", bytesToBase64qstring(signature));
return obj;
}
void SignedPreKey::parseJson(const QJsonDocument &serialized_data)
{
int serialization_type = serialized_data["serialization_type"].toInt();
ed25519_keypair.parseJson(QJsonDocument(serialized_data["ed25519"].toObject()));
x25519_keypair.derive_from_ed25519(ed25519_keypair);
signature = base64QStringToBytes(serialized_data["signature"].toString());
}
| [
"[email protected]"
] | |
6e1420e79ccd5def31c8037bb1747574a4042e69 | 91a882547e393d4c4946a6c2c99186b5f72122dd | /Source/XPSP1/NT/inetsrv/iis/svcs/nntp/adminsso/server.h | 901ad2b58adc8c93400d7702498843e0c5d1c1b2 | [] | no_license | IAmAnubhavSaini/cryptoAlgorithm-nt5src | 94f9b46f101b983954ac6e453d0cf8d02aa76fc7 | d9e1cdeec650b9d6d3ce63f9f0abe50dabfaf9e2 | refs/heads/master | 2023-09-02T10:14:14.795579 | 2021-11-20T13:47:06 | 2021-11-20T13:47:06 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,692 | h | // server.h : Declaration of the CNntpVirtualServer
/////////////////////////////////////////////////////////////////////////////
// Dependencies:
#include "metafact.h"
#include "binding.h"
#include "vroots.h"
#include "ipaccess.h"
/////////////////////////////////////////////////////////////////////////////
// nntpadm
class CNntpVirtualServer :
public CComDualImpl<INntpVirtualServer, &IID_INntpVirtualServer, &LIBID_NNTPADMLib>,
public ISupportErrorInfo,
public CComObjectRoot,
public CComCoClass<CNntpVirtualServer,&CLSID_CNntpVirtualServer>
{
public:
CNntpVirtualServer();
virtual ~CNntpVirtualServer ();
BEGIN_COM_MAP(CNntpVirtualServer)
COM_INTERFACE_ENTRY(IDispatch)
COM_INTERFACE_ENTRY(INntpVirtualServer)
COM_INTERFACE_ENTRY(ISupportErrorInfo)
END_COM_MAP()
//DECLARE_NOT_AGGREGATABLE(CNntpVirtualServer)
// Remove the comment from the line above if you don't want your object to
// support aggregation. The default is to support it
DECLARE_REGISTRY(CNntpVirtualServer, _T("Nntpadm.VirtualServer.1"), _T("Nntpadm.VirtualServer"), IDS_NNTPADMINSERVICE_DESC, THREADFLAGS_BOTH)
// ISupportsErrorInfo
STDMETHOD(InterfaceSupportsErrorInfo)(REFIID riid);
// INntpVirtualServer
public:
//////////////////////////////////////////////////////////////////////
// Properties:
//////////////////////////////////////////////////////////////////////
// Which service to configure:
STDMETHODIMP get_Server ( BSTR * pstrServer );
STDMETHODIMP put_Server ( BSTR strServer );
STDMETHODIMP get_ServiceInstance ( long * plServiceInstance );
STDMETHODIMP put_ServiceInstance ( long lServiceInstance );
// Other admin interfaces for virtual server:
STDMETHODIMP get_FeedsAdmin ( IDispatch ** ppIDispatch );
STDMETHODIMP get_GroupsAdmin ( IDispatch ** ppIDispatch );
STDMETHODIMP get_SessionsAdmin ( IDispatch ** ppIDispatch );
STDMETHODIMP get_ExpirationAdmin ( IDispatch ** ppIDispatch );
STDMETHODIMP get_RebuildAdmin ( IDispatch ** ppIDispatch );
STDMETHODIMP get_VirtualRoots ( INntpVirtualRoots ** ppVirtualRoots );
STDMETHODIMP get_VirtualRootsDispatch ( IDispatch ** ppVirtualRoots );
STDMETHODIMP get_TcpAccess ( ITcpAccess ** ppTcpAccess );
/*
STDMETHODIMP get_HomeDirectory ( INntpVirtualRoot ** ppVirtualRoot );
STDMETHODIMP put_HomeDirectory ( INntpVirtualRoot * pVirtualRoot );
*/
// Overridable server properties:
STDMETHODIMP get_ArticleTimeLimit ( long * plArticleTimeLimit );
STDMETHODIMP put_ArticleTimeLimit ( long lArticleTimeLimit );
STDMETHODIMP get_HistoryExpiration ( long * plHistoryExpiration );
STDMETHODIMP put_HistoryExpiration ( long lHistoryExpiration );
STDMETHODIMP get_HonorClientMsgIDs ( BOOL * pfHonorClientMsgIDs );
STDMETHODIMP put_HonorClientMsgIDs ( BOOL fHonorClientMsgIDs );
STDMETHODIMP get_SmtpServer ( BSTR * pstrSmtpServer );
STDMETHODIMP put_SmtpServer ( BSTR strSmtpServer );
STDMETHODIMP get_AdminEmail ( BSTR * pstrAdminEmail );
STDMETHODIMP put_AdminEmail ( BSTR strAdminEmail );
STDMETHODIMP get_AllowClientPosts ( BOOL * pfAllowClientPosts );
STDMETHODIMP put_AllowClientPosts ( BOOL fAllowClientPosts );
STDMETHODIMP get_AllowFeedPosts ( BOOL * pfAllowFeedPosts );
STDMETHODIMP put_AllowFeedPosts ( BOOL fAllowFeedPosts );
STDMETHODIMP get_ClientPostHardLimit ( long * plClientPostHardLimit );
STDMETHODIMP put_ClientPostHardLimit ( long lClientPostHardLimit );
STDMETHODIMP get_ClientPostSoftLimit ( long * plClientPostSoftLimit );
STDMETHODIMP put_ClientPostSoftLimit ( long lClientPostSoftLimit );
STDMETHODIMP get_FeedPostHardLimit ( long * plFeedPostHardLimit );
STDMETHODIMP put_FeedPostHardLimit ( long lFeedPostHardLimit );
STDMETHODIMP get_FeedPostSoftLimit ( long * plFeedPostSoftLimit );
STDMETHODIMP put_FeedPostSoftLimit ( long lFeedPostSoftLimit );
STDMETHODIMP get_AllowControlMsgs ( BOOL * pfAllowControlMsgs );
STDMETHODIMP put_AllowControlMsgs ( BOOL fAllowControlMsgs );
STDMETHODIMP get_DefaultModeratorDomain ( BSTR * pstrDefaultModeratorDomain );
STDMETHODIMP put_DefaultModeratorDomain ( BSTR strDefaultModeratorDomain );
STDMETHODIMP get_CommandLogMask ( long * plCommandLogMask );
STDMETHODIMP put_CommandLogMask ( long lCommandLogMask );
STDMETHODIMP get_DisableNewnews ( BOOL * pfDisableNewnews );
STDMETHODIMP put_DisableNewnews ( BOOL fDisableNewnews );
STDMETHODIMP get_ExpireRunFrequency ( long * plExpireRunFrequency );
STDMETHODIMP put_ExpireRunFrequency ( long lExpireRunFrequency );
STDMETHODIMP get_ShutdownLatency ( long * plShutdownLatency );
STDMETHODIMP put_ShutdownLatency ( long lShutdownLatency );
STDMETHODIMP get_EnableLogging ( BOOL * pfEnableLogging );
STDMETHODIMP put_EnableLogging ( BOOL fEnableLogging );
// Service Properties:
STDMETHODIMP get_Organization ( BSTR * pstrOrganization );
STDMETHODIMP put_Organization ( BSTR strOrganization );
STDMETHODIMP get_UucpName ( BSTR * pstrUucpName );
STDMETHODIMP put_UucpName ( BSTR strUucpName );
STDMETHODIMP get_GroupHelpFile ( BSTR * pstrGroupHelpFile );
STDMETHODIMP put_GroupHelpFile ( BSTR strGroupHelpFile );
STDMETHODIMP get_GroupListFile ( BSTR * pstrGroupListFile );
STDMETHODIMP put_GroupListFile ( BSTR strGroupListFile );
STDMETHODIMP get_GroupVarListFile ( BSTR *pstrGroupVarListFile );
STDMETHODIMP put_GroupVarListFile ( BSTR strGroupVarListFile );
STDMETHODIMP get_ArticleTableFile ( BSTR * pstrArticleTableFile );
STDMETHODIMP put_ArticleTableFile ( BSTR strArticleTableFile );
STDMETHODIMP get_HistoryTableFile ( BSTR * pstrHistoryTableFile );
STDMETHODIMP put_HistoryTableFile ( BSTR strHistoryTableFile );
STDMETHODIMP get_ModeratorFile ( BSTR * pstrModeratorFile );
STDMETHODIMP put_ModeratorFile ( BSTR strModeratorFile );
STDMETHODIMP get_XOverTableFile ( BSTR * pstrXOverTableFile );
STDMETHODIMP put_XOverTableFile ( BSTR strXOverTableFile );
STDMETHODIMP get_AutoStart ( BOOL * pfAutoStart );
STDMETHODIMP put_AutoStart ( BOOL fAutoStart );
STDMETHODIMP get_Comment ( BSTR * pstrComment );
STDMETHODIMP put_Comment ( BSTR strComment );
STDMETHODIMP get_Bindings ( INntpServerBindings ** ppBindings );
STDMETHODIMP get_BindingsDispatch ( IDispatch ** ppDispatch );
STDMETHODIMP get_SecurePort ( long * pdwSecurePort );
STDMETHODIMP put_SecurePort ( long dwSecurePort );
STDMETHODIMP get_MaxConnections ( long * pdwMaxConnections );
STDMETHODIMP put_MaxConnections ( long dwMaxConnections );
STDMETHODIMP get_ConnectionTimeout ( long * pdwConnectionTimeout );
STDMETHODIMP put_ConnectionTimeout ( long dwConnectionTimeout );
STDMETHODIMP get_AnonymousUserName ( BSTR * pstrAnonymousUserName );
STDMETHODIMP put_AnonymousUserName ( BSTR strAnonymousUserName );
STDMETHODIMP get_AnonymousUserPass ( BSTR * pstrAnonymousUserPass );
STDMETHODIMP put_AnonymousUserPass ( BSTR strAnonymousUserPass );
STDMETHODIMP get_AutoSyncPassword ( BOOL * pfAutoSyncPassword );
STDMETHODIMP put_AutoSyncPassword ( BOOL fAutoSyncPassword );
STDMETHODIMP get_PickupDirectory ( BSTR * pstrPickupDirectory );
STDMETHODIMP put_PickupDirectory ( BSTR strPickupDirectory );
STDMETHODIMP get_FailedPickupDirectory ( BSTR * pstrFailedPickupDirectory );
STDMETHODIMP put_FailedPickupDirectory ( BSTR strFailedPickupDirectory );
STDMETHODIMP get_AuthAnonymous ( BOOL * pfAuthAnonymous );
STDMETHODIMP put_AuthAnonymous ( BOOL fAuthAnonymous );
STDMETHODIMP get_AuthBasic ( BOOL * pfAuthBasic );
STDMETHODIMP put_AuthBasic ( BOOL fAuthBasic );
STDMETHODIMP get_AuthMCISBasic ( BOOL * pfAuthMCISBasic );
STDMETHODIMP put_AuthMCISBasic ( BOOL fAuthMCISBasic );
STDMETHODIMP get_AuthNT ( BOOL * pfAuthNT );
STDMETHODIMP put_AuthNT ( BOOL fAuthNT );
STDMETHODIMP get_SSLNegotiateCert ( BOOL * pfSSLNegotiateCert );
STDMETHODIMP put_SSLNegotiateCert ( BOOL fSSLNegotiateCert );
STDMETHODIMP get_SSLRequireCert ( BOOL * pfSSLRequireCert );
STDMETHODIMP put_SSLRequireCert ( BOOL fSSLRequireCert );
STDMETHODIMP get_SSLMapCert ( BOOL * pfSSLMapCert );
STDMETHODIMP put_SSLMapCert ( BOOL fSSLMapCert );
/*
STDMETHODIMP get_AuthenticationProviders ( SAFEARRAY ** ppsastrProviders );
STDMETHODIMP put_AuthenticationProviders ( SAFEARRAY * psastrProviders );
STDMETHODIMP get_AuthenticationProvidersVariant ( SAFEARRAY ** ppsastrProviders );
STDMETHODIMP put_AuthenticationProvidersVariant ( SAFEARRAY * psastrProviders );
*/
/*
STDMETHODIMP get_NewsgroupsVariant ( SAFEARRAY ** ppsastrNewsgroups );
STDMETHODIMP put_NewsgroupsVariant ( SAFEARRAY * psastrNewsgroups );
*/
STDMETHODIMP get_Administrators ( SAFEARRAY ** ppsastrAdmins );
STDMETHODIMP put_Administrators ( SAFEARRAY * psastrAdmins );
STDMETHODIMP get_AdministratorsVariant ( SAFEARRAY ** ppsastrAdmins );
STDMETHODIMP put_AdministratorsVariant ( SAFEARRAY * psastrAdmins );
STDMETHODIMP get_ClusterEnabled ( BOOL *pfClusterEnabled );
STDMETHODIMP put_ClusterEnabled ( BOOL fClusterEnabled );
//
// Service State Properties:
//
STDMETHODIMP get_State ( NNTP_SERVER_STATE * pState );
STDMETHODIMP get_Win32ErrorCode ( long * plWin32ErrorCode );
/*
STDMETHODIMP get_EncryptionCapabilitiesMask ( long * plEncryptionCapabilitiesMask );
STDMETHODIMP put_EncryptionCapabilitiesMask ( long lEncryptionCapabilitiesMask );
STDMETHODIMP get_DisplayName ( BSTR * pstrDisplayName );
STDMETHODIMP put_DisplayName ( BSTR strDisplayName );
STDMETHODIMP get_ErrorControl ( BOOL * pfErrorControl );
STDMETHODIMP put_ErrorControl ( BOOL fErrorControl );
STDMETHODIMP get_CleanBoot ( BOOL * pfCleanBoot );
STDMETHODIMP put_CleanBoot ( BOOL fCleanBoot );
*/
//////////////////////////////////////////////////////////////////////
// Methods:
//////////////////////////////////////////////////////////////////////
STDMETHODIMP Get ( );
STDMETHODIMP Set ( BOOL fFailIfChanged);
STDMETHODIMP Start ( );
STDMETHODIMP Pause ( );
STDMETHODIMP Continue ( );
STDMETHODIMP Stop ( );
//////////////////////////////////////////////////////////////////////
// Data:
//////////////////////////////////////////////////////////////////////
private:
// Properties:
CComBSTR m_strServer;
DWORD m_dwServiceInstance;
DWORD m_dwArticleTimeLimit;
DWORD m_dwHistoryExpiration;
BOOL m_fHonorClientMsgIDs;
CComBSTR m_strSmtpServer;
CComBSTR m_strAdminEmail;
BOOL m_fAllowClientPosts;
BOOL m_fAllowFeedPosts;
BOOL m_fAllowControlMsgs;
CComBSTR m_strDefaultModeratorDomain;
DWORD m_dwCommandLogMask;
BOOL m_fDisableNewnews;
DWORD m_dwExpireRunFrequency;
DWORD m_dwShutdownLatency;
DWORD m_dwClientPostHardLimit;
DWORD m_dwClientPostSoftLimit;
DWORD m_dwFeedPostHardLimit;
DWORD m_dwFeedPostSoftLimit;
BOOL m_fEnableLogging;
CComBSTR m_strGroupHelpFile;
CComBSTR m_strGroupListFile;
CComBSTR m_strGroupVarListFile;
CComBSTR m_strArticleTableFile;
CComBSTR m_strHistoryTableFile;
CComBSTR m_strModeratorFile;
CComBSTR m_strXOverTableFile;
CComBSTR m_strUucpName;
CComBSTR m_strOrganization;
BOOL m_fAutoStart;
CComBSTR m_strComment;
DWORD m_dwSecurePort;
DWORD m_dwMaxConnections;
DWORD m_dwConnectionTimeout;
CComBSTR m_strAnonymousUserName;
CComBSTR m_strAnonymousUserPass;
BOOL m_fAutoSyncPassword;
CComBSTR m_strPickupDirectory;
CComBSTR m_strFailedPickupDirectory;
DWORD m_bvAuthorization;
DWORD m_bvSslAccess;
BOOL m_fClusterEnabled;
// CMultiSz m_mszProviders;
SAFEARRAY * m_psaAdmins;
// Service State:
NNTP_SERVER_STATE m_State;
DWORD m_dwWin32ErrorCode;
// Tcp restrictions:
CComPtr<ITcpAccess> m_pIpAccess;
CTcpAccess * m_pPrivateIpAccess;
// Bindings:
CComPtr<INntpServerBindings> m_pBindings;
CNntpServerBindings * m_pPrivateBindings;
/*
CComPtr<INntpVirtualRoot> m_pHomeDirectory;
CNntpVirtualRoot * m_pPrivateHomeDirectory;
*/
// Unused so far:
DWORD m_dwEncryptionCapabilities;
CComBSTR m_strDisplayName;
BOOL m_fErrorControl;
BOOL m_fCleanBoot;
// Status:
BOOL m_fGotProperties;
DWORD m_bvChangedFields;
DWORD m_bvChangedFields2;
FILETIME m_ftLastChanged;
// Metabase:
CMetabaseFactory m_mbFactory;
HRESULT GetPropertiesFromMetabase ( IMSAdminBase * pMetabase);
HRESULT SendPropertiesToMetabase ( BOOL fFailIfChanged, IMSAdminBase * pMetabase);
// State:
HRESULT ControlService (
IMSAdminBase * pMetabase,
DWORD ControlCode,
DWORD dwDesiredState,
DWORD dwPendingState
);
HRESULT WriteStateCommand ( IMSAdminBase * pMetabase, DWORD dwCommand );
HRESULT CheckServiceState ( IMSAdminBase * pMetabase, DWORD * pdwState );
NNTP_SERVER_STATE TranslateServerState ( DWORD dwState );
// Validation:
BOOL ValidateStrings ( ) const;
BOOL ValidateProperties ( ) const;
void CorrectProperties ( );
};
| [
"[email protected]"
] | |
ea434884bedc09f922b6c3622193947968cd9e87 | cb03501a58fdfd38bb32c3c6655f30294c026a0f | /Analyser/Static/Acorn/StaticAnalyser.cpp | d5a34167b4ea255c7152f3e11a54843f23d283d7 | [
"MIT"
] | permissive | TomHarte/CLK | 6f19e56cccb05bf8680bb875d8df161e92bad6cb | 3e666a08ae547fd9c8787af07b08b3afb53eff61 | refs/heads/master | 2023-09-01T04:26:12.421586 | 2023-08-30T01:24:04 | 2023-08-30T01:24:04 | 39,225,788 | 850 | 51 | MIT | 2023-09-10T22:08:12 | 2015-07-16T23:46:52 | C++ | UTF-8 | C++ | false | false | 5,928 | cpp | //
// AcornAnalyser.cpp
// Clock Signal
//
// Created by Thomas Harte on 29/08/2016.
// Copyright 2016 Thomas Harte. All rights reserved.
//
#include "StaticAnalyser.hpp"
#include "Disk.hpp"
#include "Tape.hpp"
#include "Target.hpp"
#include <algorithm>
using namespace Analyser::Static::Acorn;
static std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>>
AcornCartridgesFrom(const std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>> &cartridges) {
std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>> acorn_cartridges;
for(const auto &cartridge : cartridges) {
const auto &segments = cartridge->get_segments();
// only one mapped item is allowed
if(segments.size() != 1) continue;
// which must be 8 or 16 kb in size
const Storage::Cartridge::Cartridge::Segment &segment = segments.front();
if(segment.data.size() != 0x4000 && segment.data.size() != 0x2000) continue;
// is a copyright string present?
const uint8_t copyright_offset = segment.data[7];
if(
segment.data[copyright_offset] != 0x00 ||
segment.data[copyright_offset+1] != 0x28 ||
segment.data[copyright_offset+2] != 0x43 ||
segment.data[copyright_offset+3] != 0x29
) continue;
// is the language entry point valid?
if(!(
(segment.data[0] == 0x00 && segment.data[1] == 0x00 && segment.data[2] == 0x00) ||
(segment.data[0] != 0x00 && segment.data[2] >= 0x80 && segment.data[2] < 0xc0)
)) continue;
// is the service entry point valid?
if(!(segment.data[5] >= 0x80 && segment.data[5] < 0xc0)) continue;
// probability of a random binary blob that isn't an Acorn ROM proceeding to here:
// 1/(2^32) *
// ( ((2^24)-1)/(2^24)*(1/4) + 1/(2^24) ) *
// 1/4
// = something very improbable, around 1/16th of 1 in 2^32, but not exactly.
acorn_cartridges.push_back(cartridge);
}
return acorn_cartridges;
}
Analyser::Static::TargetList Analyser::Static::Acorn::GetTargets(const Media &media, const std::string &, TargetPlatform::IntType) {
auto target = std::make_unique<Target>();
// strip out inappropriate cartridges
target->media.cartridges = AcornCartridgesFrom(media.cartridges);
// if there are any tapes, attempt to get data from the first
if(!media.tapes.empty()) {
std::shared_ptr<Storage::Tape::Tape> tape = media.tapes.front();
std::vector<File> files = GetFiles(tape);
tape->reset();
// continue if there are any files
if(!files.empty()) {
bool is_basic = true;
// If a file is execute-only, that means *RUN.
if(files.front().flags & File::Flags::ExecuteOnly) is_basic = false;
// check also for a continuous threading of BASIC lines; if none then this probably isn't BASIC code,
// so that's also justification to *RUN
std::size_t pointer = 0;
uint8_t *const data = &files.front().data[0];
const std::size_t data_size = files.front().data.size();
while(1) {
if(pointer >= data_size-1 || data[pointer] != 13) {
is_basic = false;
break;
}
if((data[pointer+1]&0x7f) == 0x7f) break;
pointer += data[pointer+3];
}
// Inspect first file. If it's protected or doesn't look like BASIC
// then the loading command is *RUN. Otherwise it's CHAIN"".
target->loading_command = is_basic ? "CHAIN\"\"\n" : "*RUN\n";
target->media.tapes = media.tapes;
}
}
if(!media.disks.empty()) {
std::shared_ptr<Storage::Disk::Disk> disk = media.disks.front();
std::unique_ptr<Catalogue> dfs_catalogue, adfs_catalogue;
dfs_catalogue = GetDFSCatalogue(disk);
if(dfs_catalogue == nullptr) adfs_catalogue = GetADFSCatalogue(disk);
if(dfs_catalogue || adfs_catalogue) {
// Accept the disk and determine whether DFS or ADFS ROMs are implied.
// Use the Pres ADFS if using an ADFS, as it leaves Page at &EOO.
target->media.disks = media.disks;
target->has_dfs = bool(dfs_catalogue);
target->has_pres_adfs = bool(adfs_catalogue);
// Check whether a simple shift+break will do for loading this disk.
Catalogue::BootOption bootOption = (dfs_catalogue ?: adfs_catalogue)->bootOption;
if(bootOption != Catalogue::BootOption::None) {
target->should_shift_restart = true;
} else {
target->loading_command = "*CAT\n";
}
// Check whether adding the AP6 ROM is justified.
// For now this is an incredibly dense text search;
// if any of the commands that aren't usually present
// on a stock Electron are here, add the AP6 ROM and
// some sideways RAM such that the SR commands are useful.
for(const auto &file: dfs_catalogue ? dfs_catalogue->files : adfs_catalogue->files) {
for(const auto &command: {
"AQRPAGE", "BUILD", "DUMP", "FORMAT", "INSERT", "LANG", "LIST", "LOADROM",
"LOCK", "LROMS", "RLOAD", "ROMS", "RSAVE", "SAVEROM", "SRLOAD", "SRPAGE",
"SRUNLOCK", "SRWIPE", "TUBE", "TYPE", "UNLOCK", "UNPLUG", "UROMS",
"VERIFY", "ZERO"
}) {
if(std::search(file.data.begin(), file.data.end(), command, command+strlen(command)) != file.data.end()) {
target->has_ap6_rom = true;
target->has_sideways_ram = true;
}
}
}
}
}
// Enable the Acorn ADFS if a mass-storage device is attached;
// unlike the Pres ADFS it retains SCSI logic.
if(!media.mass_storage_devices.empty()) {
target->has_pres_adfs = false; // To override a floppy selection, if one was made.
target->has_acorn_adfs = true;
// Assume some sort of later-era Acorn work is likely to happen;
// so ensure *TYPE, etc are present.
target->has_ap6_rom = true;
target->has_sideways_ram = true;
target->media.mass_storage_devices = media.mass_storage_devices;
// Check for a boot option.
const auto sector = target->media.mass_storage_devices.front()->get_block(1);
if(sector[0xfd]) {
target->should_shift_restart = true;
} else {
target->loading_command = "*CAT\n";
}
}
TargetList targets;
if(!target->media.empty()) {
targets.push_back(std::move(target));
}
return targets;
}
| [
"[email protected]"
] | |
3cd1201bb32fe86ceac31164b29556b9ad66726f | bd9fefe678cefb25636392d543c6f95cde3314e0 | /test_programs/strings_in_cpp.cpp | c8d67ff736ab9121dbc55e569c5899a6b67d1579 | [] | no_license | amp89/trying-c-plus-plus | 1b922e9289bf744df3625c3080c1cd65088f4891 | 6e511998a3a2ebd73e40a4ea049b92ab096588d9 | refs/heads/master | 2021-07-17T19:08:27.467865 | 2017-10-24T03:14:04 | 2017-10-24T03:14:04 | 107,350,514 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 606 | cpp | //testing strings
#include <iostream>
#include <string>
using namespace std;
int main()
{
// do endl instead: string stringHey = "\nHello!\n";
string stringHey = "Hello!";
//do endl instead: string stringHey = "\nHello!\n";
string stringBye = "Bye!";
cout << stringHey << endl;
cout << stringBye << endl;
cout << stringHey << stringBye <<endl;
cout << "\a"; //this makes it BEEP wow.. no idea why that's so exciting to me
return 0;// I was messing with this... i guess main has to return int,
//even if you change the type (ex: string main())
}
| [
"[email protected]"
] | |
936f9e45d2955eaa271a64aba3c5fd052b2ea155 | 9df4609c84fb665ed9e59211ce61eee469a7d324 | /src/path_finder/sipp_astar.h | 74dea53809556bc7607986b812344760bc6fbdc8 | [] | no_license | Forrest-Z/kiva_simulation | b41b0faff0f5cdb428e6a0ac2b3617460a128b46 | 1415140d245e42cd48102f93bbf26f6791b1e2c0 | refs/heads/master | 2022-04-08T23:32:49.959789 | 2019-12-23T10:05:46 | 2019-12-23T10:05:46 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,470 | h | #ifndef KIVA_SIMULATION_SRC_PATH_FINDER_SIPP_ASTAR_H_
#define KIVA_SIMULATION_SRC_PATH_FINDER_SIPP_ASTAR_H_
#include <queue>
#include <utility>
#include "ks_scheduler_common.h"
#include "ks_map.h"
#include "sipp_common.h"
#include "sipp_solver.h"
#include "utilities.h"
namespace ks {
namespace sipp_astar {
struct SpatioTemporalPoint {
Position pos;
// Milliseconds since the start of scheduling.
int time_ms;
int safe_interval_index;
SpatioTemporalPoint() = default;
SpatioTemporalPoint(Position pos, int time_ms, int safe_interval_index)
: pos(std::move(pos)),
time_ms(time_ms),
safe_interval_index(safe_interval_index) {};
SpatioTemporalPoint &operator=(const SpatioTemporalPoint &o) = default;
bool operator<(const SpatioTemporalPoint &o) const {
if (pos != o.pos) {
return pos < o.pos;
}
return safe_interval_index < o.safe_interval_index;
}
// Intentionally avoids overload the "==" and "!=" operator.
// Because operator< does not consider consider time_ms while
// here it is considered. TODO: think of if time_ms can be
// ignored here.
[[nodiscard]] bool EqualsTo(const SpatioTemporalPoint &o) const {
return pos == o.pos
&& time_ms == o.time_ms
&& safe_interval_index == o.safe_interval_index;
}
[[nodiscard]] bool NotEqualsTo(const SpatioTemporalPoint &o) const {
return !EqualsTo(o);
}
std::string to_string() {
return pos.to_string() + " " + std::to_string(time_ms) + " " + std::to_string(safe_interval_index);
}
};
struct PrevState {
ActionWithTime action_with_time;
SpatioTemporalPoint stp;
PrevState() = default;
PrevState(ActionWithTime awt, SpatioTemporalPoint stp) : action_with_time(std::move(awt)), stp(stp) {};
};
struct State {
SpatioTemporalPoint stp;
// Past cost and heuristic are both in milliseconds.
int past_cost;
int heuristic;
State() = default;
State(Position pos, int time_ms, int safe_interval_index, int past_cost, int heuristic)
: stp(pos, time_ms, safe_interval_index),
past_cost(past_cost),
heuristic(heuristic) {};
bool operator<(const State &o) const {
if (past_cost + heuristic != o.past_cost + o.heuristic) {
return past_cost + heuristic > o.past_cost + o.heuristic;
}
return heuristic > o.heuristic;
}
};
class SippAstar {
public:
SippAstar(const KsMap &ks_map,
const std::map<Location, IntervalSeq> &safe_intervals,
const ShelfManager *shelf_manager_p)
: map_(ks_map), safe_intervals_(safe_intervals), shelf_manager_p_(shelf_manager_p) {
};
// Return a sequence of actions to move the robot from src to dest.
ActionWithTimeSeq GetActions(int start_time_ms, bool has_shelf, Position pos, Location dest);
private:
// Return the heuristic(in milliseconds) from source to destination.
int GetHeuristicMs(Location a, Location b);
std::vector<std::pair<State, ActionWithTime>> GenSuccessors(const State &cur_state);
ActionWithTimeSeq GenActionSeq(State cur_state);
Interval GetSafeInterval(SpatioTemporalPoint stp);
const KsMap &map_;
const std::map<Location, IntervalSeq> &safe_intervals_;
const ShelfManager *shelf_manager_p_;
std::set<SpatioTemporalPoint> closed_;
std::priority_queue<State> open_;
std::map<SpatioTemporalPoint, int> g_value_;
std::map<SpatioTemporalPoint, PrevState> prev_;
SpatioTemporalPoint src_;
Location dest_;
bool has_shelf_;
};
}
}
#endif | [
"[email protected]"
] | |
6912c90093b05390622d52a5aeba6e32ddd43af2 | bbd54c2bc2fc923868c6f7701443a798a0e79ad2 | /leetcode/926.cpp | d84ab1f11637247ea6b0ae053867e23de59116d8 | [] | no_license | Rearcher/OJcodes | 7e07316397b4fb957e2ff2a9ecbf5ec95d6c63a0 | 634d459ee586712bf89e404324a22534099e66a9 | refs/heads/master | 2021-06-07T18:39:23.058122 | 2019-12-10T07:25:13 | 2019-12-10T07:25:13 | 36,869,609 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 416 | cpp | // #medium
// #array #O(n)
class Solution {
public:
int minFlipsMonoIncr(string S) {
int total = count(S.begin(), S.end(), '1');
int len = S.size(), cur = 0, res = S.size();
for (int i = 0; i < len; ++i) {
res = min(res, cur + (len - i - total + cur));
if (S[i] == '1') cur++;
}
res = min(res, total);
return res;
}
}; | [
"[email protected]"
] | |
dc99a560673d8ee5e0a1f241450b26f29aaade43 | 6f926b265e4d4bc7df7d608847db2bbb37aebb1f | /src/state.h | 61c709de594285c4cf8c4641465fe2bb7cb1e0b5 | [
"MIT"
] | permissive | ZirkCoin/ZirkCoin | f415e4baa392bf2b98740546c5a3feeb9f061550 | 043b355298a1711092fbdb1295122c49c2d37ec0 | refs/heads/master | 2021-01-01T18:42:29.592342 | 2015-03-25T00:02:52 | 2015-03-25T00:02:52 | 32,436,291 | 0 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 2,262 | h | // Copyright (c) 2014 The ZirkCoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file license.txt or http://www.opensource.org/licenses/mit-license.php.
#ifndef COIN_STATE_H
#define COIN_STATE_H
#include <string>
#include "sync.h"
enum eNodeType
{
NT_FULL = 1,
NT_THIN,
NT_UNKNOWN // end marker
};
enum eNodeState
{
NS_STARTUP = 1,
NS_GET_HEADERS,
NS_GET_FILTERED_BLOCKS,
NS_READY,
NS_UNKNOWN // end marker
};
enum eBlockFlags
{
BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
BLOCK_STAKE_ENTROPY = (1 << 1), // entropy bit for stake modifier
BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
};
/* nServices flags
top 32 bits of CNode::nServices are used to mark services required
*/
enum
{
NODE_NETWORK = (1 << 0),
THIN_SUPPORT = (1 << 1),
THIN_STAKE = (1 << 2),
THIN_STEALTH = (1 << 3),
SMSG_RELAY = (1 << 4),
};
const int64_t GENESIS_BLOCK_TIME = 1426363040;
static const int64_t COIN = 100000000;
static const int64_t CENT = 1000000;
extern int nNodeMode;
extern int nNodeState;
extern int nMaxThinPeers;
extern int nBloomFilterElements;
extern int nMinStakeInterval;
extern int nThinStakeDelay;
extern int nThinIndexWindow;
extern int nLastTryThinStake;
static const int nTryStakeMempoolTimeout = 5 * 60; // seconds
static const int nTryStakeMempoolMaxAsk = 16;
extern uint32_t nMaxThinStakeCandidates;
extern uint64_t nLocalServices;
extern uint32_t nLocalRequirements;
extern bool fTestNet;
extern bool fDebug;
extern bool fDebugNet;
extern bool fDebugSmsg;
extern bool fDebugChain;
extern bool fDebugRingSig;
extern bool fNoSmsg;
extern bool fPrintToConsole;
extern bool fPrintToDebugger;
extern bool fRequestShutdown;
extern bool fShutdown;
extern bool fDaemon;
extern bool fServer;
extern bool fCommandLine;
extern std::string strMiscWarning;
extern bool fNoListen;
extern bool fLogTimestamps;
extern bool fReopenDebugLog;
extern bool fThinFullIndex;
extern bool fReindexing;
extern CCriticalSection cs_threadCount;
extern int nThreadCount;
extern unsigned int nStakeSplitAge;
extern int64_t nStakeCombineThreshold;
#endif /* COIN_STATE_H */
| [
"[email protected]"
] | |
24da9a6e941effdec7e4d8f46c44c48a57193b17 | 4ce0e532a8af27e99e554aa135fd0cc5e74a7aea | /auth/src/desktop/rpcs/verify_password_response.h | 7cbb6758382b19e4ee4f7aab1b229b8957a4fb94 | [
"Apache-2.0",
"LicenseRef-scancode-proprietary-license"
] | permissive | NetsoftHoldings/firebase-cpp-sdk | 40c0e8195832e685ddd78aa496638a5f5b14b913 | 356c63bddde5ed76483cbfc5f3ff5b228c5cbe1f | refs/heads/master | 2023-08-11T08:53:53.671567 | 2021-09-13T11:33:03 | 2021-09-13T11:33:03 | 257,321,343 | 0 | 0 | Apache-2.0 | 2021-09-13T11:33:04 | 2020-04-20T15:19:10 | null | UTF-8 | C++ | false | false | 1,840 | h | /*
* Copyright 2017 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.
*/
#ifndef FIREBASE_AUTH_CLIENT_CPP_SRC_DESKTOP_RPCS_VERIFY_PASSWORD_RESPONSE_H_
#define FIREBASE_AUTH_CLIENT_CPP_SRC_DESKTOP_RPCS_VERIFY_PASSWORD_RESPONSE_H_
#include "auth/src/desktop/rpcs/auth_response.h"
#include "auth/src/desktop/visual_studio_compatibility.h"
namespace firebase {
namespace auth {
class VerifyPasswordResponse : public AuthResponse {
public:
DEFAULT_AND_MOVE_CTRS_NO_CLASS_MEMBERS(VerifyPasswordResponse, AuthResponse)
std::string local_id() const { return application_data_->localId; }
std::string email() const { return application_data_->email; }
std::string display_name() const { return application_data_->displayName; }
std::string id_token() const { return application_data_->idToken; }
std::string refresh_token() const { return application_data_->refreshToken; }
std::string photo_url() const { return application_data_->photoUrl; }
// The number of seconds til the access token expires.
int expires_in() const {
if (application_data_->expiresIn.empty()) {
return 0;
} else {
return std::stoi(application_data_->expiresIn);
}
}
};
} // namespace auth
} // namespace firebase
#endif // FIREBASE_AUTH_CLIENT_CPP_SRC_DESKTOP_RPCS_VERIFY_PASSWORD_RESPONSE_H_
| [
"[email protected]"
] | |
def0ca1a0553214470d3f88a124ad438059d6b82 | ca13b19679add6020a9b456bbd1b31bd58156f4f | /include/lua-bindings/detail/LuaDelayedPop.hh | 7733d06da8afc511499cf075772dfd1eee82870e | [] | no_license | Lunderberg/lua-bindings | 08f6527ce48b15315977c3ebfb3a0c732f1f86af | 59de6723ccbab999724f097a6cdf020fdaacdc94 | refs/heads/master | 2021-07-06T08:14:22.043729 | 2021-04-10T03:02:31 | 2021-04-10T14:12:26 | 31,801,329 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 685 | hh | #ifndef _LUADELAYEDPOP_H_
#define _LUADELAYEDPOP_H_
#include <lua.hpp>
namespace Lua {
//! Utility class for popping values.
/*! Utility class, for internal use.
Pops values from the lua stack in the destructor,
ensuring that the value is popped in an exception-safe manner.
*/
class LuaDelayedPop{
public:
LuaDelayedPop(lua_State* L, int num_to_pop) :
L(L), num_to_pop(num_to_pop) { }
~LuaDelayedPop(){
if(num_to_pop){
lua_pop(L, num_to_pop);
}
}
void SetNumPop(int num) { num_to_pop = num; }
int GetNumPop() const { return num_to_pop; }
private:
lua_State* L;
int num_to_pop;
};
}
#endif /* _LUADELAYEDPOP_H_ */
| [
"[email protected]"
] | |
c2a782a2f90dcb6dc09b41001072afa1ccf9904c | b2fe4d0185212abfb4140074691c89d337495f0a | /hello2/main.cpp | c4a08f71ac5328e2048629a5e5bfbb07ba103613 | [] | no_license | wangyun123/LearnOSG | 65174d69e57cac1e2c3d9445153f224fbc0d7f6e | 928498e69ab5f9c2f9f5837cdacac0aaf1f4fb31 | refs/heads/master | 2020-07-13T04:13:01.589514 | 2017-09-21T08:17:39 | 2017-09-21T08:17:39 | 73,893,964 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,459 | cpp | #include <osgViewer/Viewer>
#include <osgDB/ReadFile>
#include <osgViewer/ViewerEventHandlers>
#include <osg/ShapeDrawable>
#include <osgUtil/LineSegmentIntersector>
#include <osgUtil/IntersectionVisitor>
#include <iostream>
#include <windows.h>
#ifdef _DEBUG
#pragma comment(lib, "osgd.lib")
#pragma comment(lib, "osgDBd.lib")
#pragma comment(lib, "osgViewerd.lib")
#pragma comment(lib, "OpenThreadsd.lib")
#pragma comment(lib, "osgGAd.lib")
#pragma comment(lib, "osgUtild.lib")
#else
#pragma comment(lib, "osg.lib")
#pragma comment(lib, "osgDB.lib")
#pragma comment(lib, "osgViewer.lib")
#pragma comment(lib, "OpenThreads.lib")
#pragma comment(lib, "osgGA.lib")
#pragma comment(lib, "osgUtil.lib")
#endif
int ticket=10;
class MyThreads : public OpenThreads::Thread
{
public:
MyThreads(std::string name) {this->name=name;}
void run()
{
while(--ticket>0)
{
std::cout << name << ":" << ticket << std::endl;
}
}
private:
std::string name;
};
osg::ref_ptr<osg::Geode> createBox()
{
osg::ref_ptr<osg::Geode> gode = new osg::Geode;
gode->addDrawable(new osg::ShapeDrawable(new osg::Box(osg::Vec3(0.0,0.0,0.0),10.0,10.0,10.0)));
//gode->addDrawable(new osg::shape)
return gode;
}
int main()
{
#if 0
osg::ref_ptr<osgViewer::Viewer> viewer = new osgViewer::Viewer;
osg::Timer* timer = new osg::Timer;
std::cout << timer->getSecondsPerTick() << std::endl;
// intersection
osg::ref_ptr<osgUtil::LineSegmentIntersector> line =
new osgUtil::LineSegmentIntersector(osg::Vec3(0.0,0.0,15.0), osg::Vec3(0.0,0.0,-15.0));
osg::ref_ptr<osgUtil::IntersectionVisitor> nv =
new osgUtil::IntersectionVisitor(line);
osg::ref_ptr<osg::Group> group = new osg::Group;
group->addChild(createBox());
group->accept(*nv);
osgUtil::LineSegmentIntersector::Intersections inter;
if (line->containsIntersections())
{
inter = line->getIntersections();
for (osgUtil::LineSegmentIntersector::Intersections::iterator it=inter.begin(); it!=inter.end(); ++it)
{
std::cout<<it->getLocalIntersectPoint().x()<<","
<<it->getLocalIntersectPoint().y()<<","
<<it->getLocalIntersectPoint().z()<<std::endl;
}
}
viewer->setSceneData(group);
viewer->addEventHandler(new osgViewer::HelpHandler);
viewer->addEventHandler(new osgViewer::StatsHandler);
viewer->addEventHandler(new osgViewer::WindowSizeHandler);
return viewer->run();
#else
MyThreads t1("A");
MyThreads t2("B");
t1.start();
t2.start();
Sleep(30000);
return 1;
#endif
} | [
"[email protected]"
] | |
312066d173dfceaeff9bf65596a7bc36ec7ef0a2 | eadc7699ff95849027e3628b01e6fd7bb57b4f7f | /projeto2_ultrasonic/projeto2_ultrasonic.ino | c854a9cd9db7358330cd71acb0cc63c6dda7d79b | [] | no_license | ThiagoStos/Projeto_2_Smart_Parking | 7a35a103d2b51f2c7dd305660bae17e56bbc9281 | 45b5585dccc3989df0ed6969878003a7a46dcb86 | refs/heads/master | 2021-07-23T20:07:29.209459 | 2017-11-01T23:49:44 | 2017-11-01T23:49:44 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,503 | ino | #include <SPI.h>
/*//Se for usar a placa de rede normal*/
//#include <UIPEthernet.h>
//#include <utility/logging.h>
/*Se for usar a placa Shield*/
#include <Ethernet.h>
/*Para o MQTT*/
#include <PubSubClient.h>
#include <Ultrasonic.h>
//Define o pino do Arduino a ser utilizado com o pino Trigger do sensor
#define PINO_TRIGGER 9
//Define o pino do Arduino a ser utilizado com o pino Echo do sensor
#define PINO_ECHO 8
//Inicializa o sensor ultrasonico
Ultrasonic ultrasonic(PINO_TRIGGER, PINO_ECHO);
//const int ledVermelho = 5;
//const int ledVerde = 6;
//const int ledAzul = 3;
//char* leitura;
int distancia;
char* payloadAsChar;
String hexstring;
String EstadoVaga = "vazia";
/*Atualizar ultimo valor para ID do seu Kit para evitar duplicatas*/
byte mac[] = { 0xDE, 0xED, 0xBA, 0xFE, 0xF1, 0x55 };
//byte ip[] = { 192,168,3,155 };
/*Endereço do Cloud MQTT*/
char* server = "m10.cloudmqtt.com";
/*Valor da porta do servidor MQTT*/
int port = 13038 ;
EthernetClient ethClient;
/* FUNÇÃO que irá receber o retorno do servidor*/
void whenMessageReceived(char* topic, byte* payload, unsigned int length) {
/*Converter pointer do tipo `byte` para typo `char`*/
char* payloadAsChar = payload;
Serial.flush();
//int msgComoNumero = msg.toInt();
//
// Serial.flush();
}
/*Dados do MQTT Cloud*/
PubSubClient client(server, port, whenMessageReceived, ethClient);
long lastReconnectAttempt = 0;
void setup() {
Serial.begin(9600);
// pinMode(ledVermelho, OUTPUT);
// pinMode(ledVerde, OUTPUT);
// pinMode(ledAzul, OUTPUT);
Serial.begin(9600);
Serial.println("Connecting...");
while (!Serial) {}
if (!Ethernet.begin(mac)) {
Serial.println("DHCP Failed");
} else {
Serial.println(Ethernet.localIP());
}
lastReconnectAttempt = 0;
}
void loop() {
/*Faz a conexão no cloud com nome do dispositivo, usuário e senha respectivamente*/
if (!client.connected()) {
long now = millis();
if (now - lastReconnectAttempt > 5000) {
lastReconnectAttempt = now;
if (reconnect()) {
lastReconnectAttempt = 0;
}
}
} else {
/*A biblioteca PubSubClient precisa que este método seja chamado em cada iteração de `loop()`
para manter a conexão MQTT e processar mensagens recebidas (via a função callback)*/
client.loop();
int distancia = ultrasonic.distanceRead();
delay (1000);
Serial.print("valor lido: "); Serial.println(distancia);
if (distancia <= 10 && EstadoVaga == "vazia") {
delay (500);
vagaOcupada();
EstadoVaga = "ocupada";
}
if (distancia >= 10 && EstadoVaga == "ocupada") {
delay (500);
vagaLivre();
EstadoVaga = "vazia";
}
}
}
//////////////////////////////////////////////
//FUNÇÕES
//////////////////////////////////////////////
// Função para (re)conectar no mqtt
boolean reconnect() {
if (client.connect("vagas", "rodolfo", "rodolfo")) {
Serial.println("Connected");
/*Envia uma mensagem para o cloud no topic portao2*/
client.publish("vaga/1", "Online");
Serial.println("LED sent");
/*Conecta no topic para receber mensagens*/
client.subscribe("vaga/1");
Serial.println("conectado A LED");
} else {
Serial.println("Failed to connect to MQTT server");
}
}
void vagaOcupada() {
client.publish("vaga/1", "1");
}
void vagaLivre() {
client.publish("vaga/1", "0");
}
| [
"[email protected]"
] | |
489ae7d8077f5d6733d24cff649f8880773e6feb | dcc5c513758d8b15db1e79d4d21e3bdbacd33b06 | /Source/Watchtower/Chunk.cpp | 6940fa8fce15e24f247637f6c949619730bc5701 | [
"MIT"
] | permissive | killowatt/Watchtower | d0ce00b339ff82d2e1fb26a62e5086e82acd4053 | c4c5b39aca9656ab47d79b506f4be0ccf12ca7ed | refs/heads/master | 2021-01-13T01:29:59.750461 | 2017-05-19T21:28:36 | 2017-05-19T21:28:36 | 34,185,793 | 7 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,083 | cpp | // Copyright 2017 William Yates
#include "Watchtower.h"
#include "Chunk.h"
#include "ChunkGenerator.h"
FBlock& AChunk::GetBlockLocal(const FIntVector& Coordinates)
{
return MapData->GetBlock(MapCoordinates + Coordinates);
}
FBlock& AChunk::GetBlockLocal(int32 X, int32 Y, int32 Z)
{
return GetBlockLocal(FIntVector(X, Y, Z));
}
const FIntVector& AChunk::GetVolumeSize() const
{
return VolumeSize;
}
void AChunk::SetRelativeMapData(UVoxelMapData* MapData,
const FIntVector& MapCoordinates, const FIntVector& VolumeSize)
{
this->MapData = MapData;
this->MapCoordinates = MapCoordinates;
this->VolumeSize = VolumeSize;
}
void AChunk::Generate()
{
FChunkGenerator Generator(this, RuntimeMesh);
Generator.Generate();
}
void AChunk::Tick(float DeltaTime)
{
Super::Tick(DeltaTime); // Call parent class tick function
if (PleaseUpdate)
{
if (GEngine->GetNetMode(GetWorld()) == NM_DedicatedServer)
{
Generate(); // do simple collision instead of genning a collision from mesh
PleaseUpdate = false;
}
else if (GEngine->GetNetMode(GetWorld()) == NM_Client)
{
Generate();
PleaseUpdate = false;
}
else
{
UE_LOG(WTVoxel, Error, TEXT("Unknown end-user type in chunk update."));
PleaseUpdate = false;
}
}
}
// Sets default values
AChunk::AChunk()
{
// Set this actor to call Tick() every frame. You can turn this off to improve performance if you don't need it.
PrimaryActorTick.bCanEverTick = true;
RuntimeMesh = CreateDefaultSubobject<URuntimeMeshComponent>(TEXT("Runtime Mesh"));
RootComponent = RuntimeMesh;
static ConstructorHelpers::FObjectFinder<UMaterial> Material(TEXT("/Game/ChunkMaterial"));
if (Material.Object)
{
RuntimeMesh->SetMaterial(0, (UMaterial*)Material.Object);
}
PleaseUpdate = false;
}
// Called when the game starts or when spawned
void AChunk::BeginPlay()
{
Super::BeginPlay();
RuntimeMesh->SetCollisionResponseToChannel(COLLISION_VOXELPLAYER, ECR_Block);
//RuntimeMesh->SetCollisionResponseToChannel(COLLISION_VOXEL, ECR_Block);
}
void AChunk::OnConstruction(const FTransform& Transform)
{
}
| [
"[email protected]"
] | |
d36816b9b11f432844c1eeb119ee602e3d58f3e4 | 7771130ea6eb1f076a7d18e672d3d82d5996e957 | /src/netbase.h | f01c1c8411179f1186dfafadf31a1b6c50b4e9b4 | [
"MIT"
] | permissive | gdrcoin/gdrcoin | 49707508dfc1b14ace3817854416355a925539df | f9f2137b3d9069bfc8e3c69c90a684a061dfb6aa | refs/heads/master | 2020-03-10T18:01:49.563615 | 2018-04-14T12:36:52 | 2018-04-14T12:36:52 | 129,511,260 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,641 | h | // Copyright (c) 2009-2016 The Gdrcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef GDRCOIN_NETBASE_H
#define GDRCOIN_NETBASE_H
#if defined(HAVE_CONFIG_H)
#include "config/gdrcoin-config.h"
#endif
#include "compat.h"
#include "netaddress.h"
#include "serialize.h"
#include <stdint.h>
#include <string>
#include <vector>
extern int nConnectTimeout;
extern bool fNameLookup;
//! -timeout default
static const int DEFAULT_CONNECT_TIMEOUT = 5000;
//! -dns default
static const int DEFAULT_NAME_LOOKUP = true;
class proxyType
{
public:
proxyType(): randomize_credentials(false) {}
proxyType(const CService &_proxy, bool _randomize_credentials=false): proxy(_proxy), randomize_credentials(_randomize_credentials) {}
bool IsValid() const { return proxy.IsValid(); }
CService proxy;
bool randomize_credentials;
};
enum Network ParseNetwork(std::string net);
std::string GetNetworkName(enum Network net);
bool SetProxy(enum Network net, const proxyType &addrProxy);
bool GetProxy(enum Network net, proxyType &proxyInfoOut);
bool IsProxy(const CNetAddr &addr);
bool SetNameProxy(const proxyType &addrProxy);
bool HaveNameProxy();
bool LookupHost(const char *pszName, std::vector<CNetAddr>& vIP, unsigned int nMaxSolutions, bool fAllowLookup);
bool LookupHost(const char *pszName, CNetAddr& addr, bool fAllowLookup);
bool Lookup(const char *pszName, CService& addr, int portDefault, bool fAllowLookup);
bool Lookup(const char *pszName, std::vector<CService>& vAddr, int portDefault, bool fAllowLookup, unsigned int nMaxSolutions);
CService LookupNumeric(const char *pszName, int portDefault = 0);
bool LookupSubNet(const char *pszName, CSubNet& subnet);
bool ConnectSocket(const CService &addr, SOCKET& hSocketRet, int nTimeout, bool *outProxyConnectionFailed = 0);
bool ConnectSocketByName(CService &addr, SOCKET& hSocketRet, const char *pszDest, int portDefault, int nTimeout, bool *outProxyConnectionFailed = 0);
/** Return readable error string for a network error code */
std::string NetworkErrorString(int err);
/** Close socket and set hSocket to INVALID_SOCKET */
bool CloseSocket(SOCKET& hSocket);
/** Disable or enable blocking-mode for a socket */
bool SetSocketNonBlocking(const SOCKET& hSocket, bool fNonBlocking);
/** Set the TCP_NODELAY flag on a socket */
bool SetSocketNoDelay(const SOCKET& hSocket);
/**
* Convert milliseconds to a struct timeval for e.g. select.
*/
struct timeval MillisToTimeval(int64_t nTimeout);
void InterruptSocks5(bool interrupt);
#endif // GDRCOIN_NETBASE_H
| [
"[email protected]"
] | |
26aa7fcc6e77158d8fd433ede3bc670d5c3c1126 | 8dd428eee55e44bc9d0932bf59f71ae51c99f7ae | /ddraw/Versions/IDirectDraw4.h | 139d290e8af86096aaf92f7d1c88fbdd3c50105d | [
"Zlib"
] | permissive | protocultor/DirectX-Wrappers | 638c522f333245dab450053cb594da3860f674ff | adf36b6a0a9290f4fe02b044d235dba5487da694 | refs/heads/master | 2021-01-01T10:19:59.754620 | 2020-02-09T03:59:43 | 2020-02-09T03:59:43 | 239,235,903 | 0 | 0 | NOASSERTION | 2020-02-09T02:37:51 | 2020-02-09T02:37:50 | null | UTF-8 | C++ | false | false | 2,537 | h | #pragma once
class m_IDirectDraw4 : public IDirectDraw4, public AddressLookupTableObject
{
private:
std::unique_ptr<m_IDirectDrawX> ProxyInterface;
IDirectDraw4 *RealInterface;
REFIID WrapperID = IID_IDirectDraw4;
public:
m_IDirectDraw4(IDirectDraw4 *aOriginal) : RealInterface(aOriginal)
{
ProxyInterface = std::make_unique<m_IDirectDrawX>((IDirectDraw7*)RealInterface, 4, (m_IDirectDraw7*)this);
ProxyAddressLookupTable.SaveAddress(this, RealInterface);
}
~m_IDirectDraw4()
{
ProxyAddressLookupTable.DeleteAddress(this);
}
DWORD GetDirectXVersion() { return 4; }
REFIID GetWrapperType() { return WrapperID; }
IDirectDraw4 *GetProxyInterface() { return RealInterface; }
m_IDirectDrawX *GetWrapperInterface() { return ProxyInterface.get(); }
/*** IUnknown methods ***/
STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj);
STDMETHOD_(ULONG, AddRef) (THIS);
STDMETHOD_(ULONG, Release) (THIS);
/*** IDirectDraw methods ***/
STDMETHOD(Compact)(THIS);
STDMETHOD(CreateClipper)(THIS_ DWORD, LPDIRECTDRAWCLIPPER FAR*, IUnknown FAR *);
STDMETHOD(CreatePalette)(THIS_ DWORD, LPPALETTEENTRY, LPDIRECTDRAWPALETTE FAR*, IUnknown FAR *);
STDMETHOD(CreateSurface)(THIS_ LPDDSURFACEDESC2, LPDIRECTDRAWSURFACE4 FAR *, IUnknown FAR *);
STDMETHOD(DuplicateSurface)(THIS_ LPDIRECTDRAWSURFACE4, LPDIRECTDRAWSURFACE4 FAR *);
STDMETHOD(EnumDisplayModes)(THIS_ DWORD, LPDDSURFACEDESC2, LPVOID, LPDDENUMMODESCALLBACK2);
STDMETHOD(EnumSurfaces)(THIS_ DWORD, LPDDSURFACEDESC2, LPVOID, LPDDENUMSURFACESCALLBACK2);
STDMETHOD(FlipToGDISurface)(THIS);
STDMETHOD(GetCaps)(THIS_ LPDDCAPS, LPDDCAPS);
STDMETHOD(GetDisplayMode)(THIS_ LPDDSURFACEDESC2);
STDMETHOD(GetFourCCCodes)(THIS_ LPDWORD, LPDWORD);
STDMETHOD(GetGDISurface)(THIS_ LPDIRECTDRAWSURFACE4 FAR *);
STDMETHOD(GetMonitorFrequency)(THIS_ LPDWORD);
STDMETHOD(GetScanLine)(THIS_ LPDWORD);
STDMETHOD(GetVerticalBlankStatus)(THIS_ LPBOOL);
STDMETHOD(Initialize)(THIS_ GUID FAR *);
STDMETHOD(RestoreDisplayMode)(THIS);
STDMETHOD(SetCooperativeLevel)(THIS_ HWND, DWORD);
STDMETHOD(SetDisplayMode)(THIS_ DWORD, DWORD, DWORD, DWORD, DWORD);
STDMETHOD(WaitForVerticalBlank)(THIS_ DWORD, HANDLE);
/*** Added in the v2 interface ***/
STDMETHOD(GetAvailableVidMem)(THIS_ LPDDSCAPS2, LPDWORD, LPDWORD);
/*** Added in the V4 Interface ***/
STDMETHOD(GetSurfaceFromDC) (THIS_ HDC, LPDIRECTDRAWSURFACE4 *);
STDMETHOD(RestoreAllSurfaces)(THIS);
STDMETHOD(TestCooperativeLevel)(THIS);
STDMETHOD(GetDeviceIdentifier)(THIS_ LPDDDEVICEIDENTIFIER, DWORD);
};
| [
"[email protected]"
] | |
148b608979e628a6e52da90cf90512a6f6cb85de | db78b28717e04a2d825935f88c019c694d98d7c3 | /src/ripple/peerfinder/impl/Config.cpp | d3e5b6e732b112f51f70e911c52fa32cead61f79 | [
"MIT",
"MIT-Wu",
"ISC",
"BSL-1.0"
] | permissive | bloob/rippled | e156257eea131bc4af43471759359514746c49f0 | 15ef43505473225af21bb7b575fb0b628d5e7f73 | refs/heads/master | 2021-01-17T22:06:18.800766 | 2013-10-02T19:06:54 | 2013-10-02T19:06:54 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,217 | cpp | //------------------------------------------------------------------------------
/*
This file is part of rippled: https://github.com/ripple/rippled
Copyright (c) 2012, 2013 Ripple Labs Inc.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
#include "../api/Config.h"
namespace ripple {
namespace PeerFinder {
Config::Config ()
: maxPeerCount (20)
, wantIncoming (false)
, listeningPort (0)
{
}
}
}
| [
"[email protected]"
] | |
6c4b3071b765e7896f5bff9562494af217a648ae | 546535b806e069d75f8a7d52eee25d5228d77774 | /week1_decomposition1/2_connected_components/connected-class.cpp | 9b145b1868c8eb547d694d1f99a7333e378d786e | [] | no_license | nyck33/coursera_datastructures_algos | c41069cfabe9d3bd361267008a4ff4d971a481dd | 5b7f87776d3f4e8377cc8058716a9809c39529b4 | refs/heads/master | 2020-06-29T22:27:44.641342 | 2019-08-05T11:43:40 | 2019-08-05T11:43:40 | 200,643,195 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,531 | cpp | #include <iostream>
#include <vector>
#include <algorithm>
using std::vector;
using std::pair;
class Graph
{
//private
int V;
int cnum;
vector<vector<int> > *adj;
vector<int> *compnum;
vector<bool> *vis;
void explore(int v);
public:
Graph(int V);
void addEdge(int start, int end);
void DFSconnect();
void printAns();
};
void Graph::printAns()
{
std::cout<<"There are "<< cnum<< " components in the graph."<<std::endl;
}
void Graph::DFSconnect()
{
cnum = 0; //component number
for(int v=0; v<V; v++)
{
if(vis->at(v)==false)
{
explore(v);
cnum++;
}
}
}
void Graph::explore(int v)
{
vis->at(v)=true;
for(unsigned int i=0; i < (*adj)[v].size(); i++)
{
if(vis->at((*adj)[v][i])==false)
{
explore((*adj)[v][i]);
}
}
}
Graph::Graph(int vertices)
{
this->V = vertices;
adj = new vector<vector<int> >(vertices, vector<int>());
compnum = new vector<int>(vertices, 0);
vis = new vector<bool>(vertices, false);
}
void Graph::addEdge(int u, int v)
{
(*adj)[u].push_back(v);
(*adj)[v].push_back(u);
}
int main()
{
int vertices, edges;
std::cout<<"Enter number of vertices and edges"<<std::endl;
std::cin >> vertices >> edges;
Graph g(vertices);
for (int i = 0; i < edges; i++) {
std::cout<<"Enter vertices incident to edge from 0 to n-1"<<std::endl;
int start, end;
std::cin >> start >> end;
g.addEdge(start, end);
}
//ans1 = number_of_components(adj, v, e);
g.DFSconnect();
g.printAns();
}
| [
"[email protected]"
] | |
e90959ce8bf86caa6ad9778f23357b65f33bb3d7 | a08cbd5e9b4e4a037deaaae1749ed4dc55c79661 | /include/IECore/LinearToPanalogDataConversion.h | 169a59ba9428a127506b96f2fd78aa62ba31c595 | [] | no_license | victorvfx/cortex | 46385788b12dae375c1a5ade26d8f403d2dbccff | deb23599c8c69eac5671e59fe1a8ca0d5e943a36 | refs/heads/master | 2021-01-16T23:11:39.139147 | 2017-06-23T12:39:41 | 2017-06-23T12:39:41 | 95,709,763 | 1 | 0 | null | 2017-06-28T20:40:12 | 2017-06-28T20:40:12 | null | UTF-8 | C++ | false | false | 3,169 | h | //////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2008-2009, Image Engine Design Inc. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// * Neither the name of Image Engine Design nor the names of any
// other contributors to this software may be used to endorse or
// promote products derived from this software without specific prior
// written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////
#ifndef IE_CORE_LINEARTOPANALOGDATACONVERSION_H
#define IE_CORE_LINEARTOPANALOGDATACONVERSION_H
#include "boost/static_assert.hpp"
#include "boost/type_traits/is_floating_point.hpp"
#include "IECore/HalfTypeTraits.h"
#include "IECore/DataConversion.h"
namespace IECore
{
/// Forward declaration
template<typename, typename> class PanalogToLinearDataConversion;
/// A class to perform data conversion from linear values to Panalog
template<typename F, typename T>
struct LinearToPanalogDataConversion : public DataConversion< F, T >
{
public:
/// "To" data type should be at least 10-bits!
BOOST_STATIC_ASSERT( sizeof(T) >= 2 );
BOOST_STATIC_ASSERT( boost::is_floating_point< F >::value );
typedef PanalogToLinearDataConversion<T, F> InverseType;
/// Make a default converter with constant values
LinearToPanalogDataConversion();
/// Make a converter with specified constant values
LinearToPanalogDataConversion( float c1, float c2, float c3, float c4 );
/// Perform the conversion
T operator()( F f ) const;
/// Returns an instance of a class able to perform the inverse conversion
InverseType inverse() const;
private:
float m_c1;
float m_c2;
float m_c3;
float m_c4;
};
} // namespace IECore
#include "IECore/LinearToPanalogDataConversion.inl"
#endif // IE_CORE_LINEARTOPANALOGDATACONVERSION_H
| [
"[email protected]"
] | |
21b709ae847c627fb11f8d54e3b33708a2cec272 | 618ce60db6dd3dac8fb0f00a5a75128509a8a2be | /cpp/01_Avg/simulated_annealing.h | 7a44467de34b7704d96c41d1ddf9cbf224c85422 | [] | no_license | jybai/learning2read | 77439a6e0b083c3ab07214d9b718e16fa5d75ab9 | b16560418b67d58d7d653b52b7b22734f36808c0 | refs/heads/master | 2021-10-07T08:43:35.893519 | 2018-12-04T02:57:13 | 2018-12-04T02:57:13 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,402 | h | #ifndef SIMULATED_ANNEALING_H_
#define SIMULATED_ANNEALING_H_
#include <cmath>
#include <random>
#include <functional>
template <class T, class Gen = std::mt19937_64, class ResType = double> class SimulatedAnnealing {
private:
typedef std::function<ResType(const T&)> EvalFuncType_;
typedef std::function<T(const T&)> NeighborFuncType_;
std::uniform_real_distribution<double> rand_ = std::uniform_real_distribution<double>(0., 1.);
T now_, best_;
double nowres_, bestres_;
EvalFuncType_ eval_;
NeighborFuncType_ next_;
Gen gen_;
public:
SimulatedAnnealing(EvalFuncType_ eval, NeighborFuncType_ nxt, const T& start = T(), Gen g = Gen())
: now_(start), best_(start), eval_(eval), next_(nxt), gen_(g) {
nowres_ = bestres_ = eval_(now_);
}
double DoIter(double temp) {
T next = next_(now_);
double res = eval_(next);
if (res < nowres_ || std::exp((nowres_ - res) / temp) > rand_(gen_)) {
now_ = next;
nowres_ = res;
if (res < bestres_) best_ = now_, bestres_ = nowres_;
}
return nowres_;
}
const T& GetNow() const { return now_; }
const T& GetBest() const { return best_; }
double GetNowVal() const { return nowres_; }
double GetBestVal() const { return bestres_; }
void Anneal(double start, double end, int iter) {
for (int i = 0; i < iter; i++)
DoIter((start * (iter - i) + end * i) / iter);
}
};
#endif
| [
"[email protected]"
] | |
5e22cef52000af849366f168cebc4bd53c3bdbf4 | fb9c29e852a96327781e571217b7a34d687f9170 | /Smart Agriculture/src/Agriculture_Bot.ino | b82ba98377c776ba46f02ea19a68ff0f8991d0dd | [] | no_license | devesh-khanzode/Projects | b0fe479af49b78d21af273b657e866aa3aa45117 | 59c8cc710e4ca2a4cc672fd7324a2019fe642f64 | refs/heads/master | 2020-07-16T22:57:52.059428 | 2019-09-13T15:47:09 | 2019-09-13T15:47:09 | 205,885,837 | 0 | 0 | null | 2019-09-13T15:37:21 | 2019-09-02T15:28:19 | C++ | UTF-8 | C++ | false | false | 5,839 | ino |
#define ENA 10 ////left wheel
#define IN1 5
#define IN2 6
#define IN3 7
#define IN4 8
#define ENB 11 //////right wheel
#define ENC A2
#define IN5 A0
#define IN6 A1
#define WAT 9
#define SOE 12
char f,g,up=1,w=1,s=1;
int IR1,IR2,IR3;
void setup() {
pinMode(4,INPUT);
pinMode(3,INPUT);
pinMode(2,INPUT);
pinMode(5,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);
pinMode(8,OUTPUT);
pinMode(10,OUTPUT);
pinMode(11,OUTPUT);
pinMode(A2,OUTPUT);
pinMode(A0,OUTPUT);
pinMode(A1,OUTPUT);
pinMode(9,OUTPUT);
pinMode(12,OUTPUT);
Serial.begin(9600);
}
void loop() {
while(g=='A')
{
// Serial.println("abc=");
//Serial.print(g);
digitalWrite(5,HIGH);
digitalWrite(6,LOW);
digitalWrite(7,HIGH);
digitalWrite(8,LOW);
IR1=digitalRead(4);
IR2=digitalRead(3);
IR3=digitalRead(2);
if(IR1==0 && IR2==0 && IR3==0)
{
drillup();
wateroff();
soeoff();
analogWrite(10,0);
analogWrite(11,0);
}
if(IR1==0 && IR2==0 && IR3==1)
{
drillup();
wateroff();
soeoff();
analogWrite(10,0);
analogWrite(11,230);
}
if(IR1==0 && IR2==1 && IR3==0)
{
drillup();
wateroff();
soeoff();
analogWrite(10,0);
analogWrite(11,0);
}
if(IR1==0 && IR2==1 && IR3==1)
{
drillup();
wateroff();
soeoff();
analogWrite(10,0);
analogWrite(11,230);
}
if(IR1==1 && IR2==0 && IR3==0)
{
drillup();
wateroff();
soeoff();
analogWrite(10,230);
analogWrite(11,0);
}
if(IR1==1 && IR2==0 && IR3==1)
{
drilldw();
wateron();
soeon();
analogWrite(10,130);
analogWrite(11,130);
}
if(IR1==1 && IR2==1 && IR3==0)
{
drillup();
wateroff();
soeoff();
analogWrite(10,230);
analogWrite(11,0);
}
if(IR1==1 && IR2==1 && IR3==1)
{
drillup();
wateroff();
soeoff();
analogWrite(10,0);
analogWrite(11,0);
}
if(Serial.available())
{
f=Serial.read();
if(f=='M'||'F'||'S'||'R'||'L'||'B'||'T'||'D'||'W'||'O'||'E'||'I')
{
g='a';
}}
}
if(Serial.available())
{
f=Serial.read();
if(f=='M'||'F'||'S'||'R'||'L'||'B'||'T'||'D'||'W'||'O'||'E'||'I')
{
g='a';
}
//Serial.println("blue=");
//Serial.print(f);
switch(f)
{
case 'F':
digitalWrite(5,HIGH);
digitalWrite(6,LOW);
digitalWrite(7,HIGH);
digitalWrite(8,LOW);
analogWrite(10,130);
analogWrite(11,130);
break;
case 'B':
digitalWrite(5,LOW);
digitalWrite(6,HIGH);
digitalWrite(7,LOW);
digitalWrite(8,HIGH);
analogWrite(10,130);
analogWrite(11,130);
break;
case 'R':
digitalWrite(5,HIGH);
digitalWrite(6,LOW);
digitalWrite(7,HIGH);
digitalWrite(8,LOW);
analogWrite(10,200);
analogWrite(11,0);
break;
case 'L' :
digitalWrite(5,HIGH);
digitalWrite(6,LOW);
digitalWrite(7,HIGH);
digitalWrite(8,LOW);
analogWrite(10,0);
analogWrite(11,200);
break;
case 'S':
digitalWrite(5,HIGH);
digitalWrite(6,LOW);
digitalWrite(7,HIGH);
digitalWrite(8,LOW);
analogWrite(10,0);
analogWrite(11,0);
break;
case 'D':
drilldw();
break;
case 'I':
drillup();
break;
case 'T':
wateron();
break;
case 'E':
wateroff();
break;
case 'O':
soeon();
break;
case 'W':
soeoff();
break;
case 'A':
digitalWrite(5,HIGH);
digitalWrite(6,LOW);
digitalWrite(7,HIGH);
digitalWrite(8,LOW);
IR1=digitalRead(4);
IR2=digitalRead(3);
IR3=digitalRead(2);
if(IR1==0 && IR2==0 && IR3==0)
{
drillup();
wateroff();
soeoff();
analogWrite(10,0);
analogWrite(11,0);
}
if(IR1==0 && IR2==0 && IR3==1)
{
drillup();
wateroff();
soeoff();
analogWrite(10,0);
analogWrite(11,230);
}
if(IR1==0 && IR2==1 && IR3==0)
{
drillup();
wateroff();
soeoff();
analogWrite(10,0);
analogWrite(11,0);
}
if(IR1==0 && IR2==1 && IR3==1)
{
drillup();
wateroff();
soeoff();
analogWrite(10,0);
analogWrite(11,230);
}
if(IR1==1 && IR2==0 && IR3==0)
{
drillup();
wateroff();
soeoff();
analogWrite(10,230);
analogWrite(11,0);
}
if(IR1==1 && IR2==0 && IR3==1)
{
drilldw();
wateron();
soeon();
analogWrite(10,130);
analogWrite(11,130);
}
if(IR1==1 && IR2==1 && IR3==0)
{
drillup();
wateroff();
soeoff();
analogWrite(10,230);
analogWrite(11,0);
}
if(IR1==1 && IR2==1 && IR3==1)
{
drillup();
wateroff();
soeoff();
analogWrite(10,0);
analogWrite(11,0);
}
g='A';
break;
default:
drillup();
wateroff();
soeoff();
analogWrite(10,0);
analogWrite(11,0);
break;
}}
}
void drillup()
{
if(up==0)
{
analogWrite(IN5,0);
analogWrite(IN6,255);
analogWrite(ENC,150);
delay(100);
analogWrite(ENC,0);
}
up=1;
}
void drilldw()
{
if(up==1)
{
analogWrite(IN5,255);
analogWrite(IN6,0);
analogWrite(ENC,150);
delay(30);
analogWrite(IN5,0);
analogWrite(IN6,255);
analogWrite(ENC,50);
}
up=0;
}
void wateron()
{
int pos = 0;
if(w==1)
{
for (pos = 0; pos <= 90; pos += 1) { // goes from 0 degrees to 180 degrees
// in steps of 1 degree
analogWrite(WAT,pos); // tell servo to go to position in variable 'pos'
delay(15); // waits 15ms for the servo to reach the position
}
}
w=0;
}
void wateroff()
{
int pos = 0;
if(w==0)
{
for (pos = 90; pos >= 0; pos -= 1) { // goes from 180 degrees to 0 degrees
analogWrite(WAT,pos); // tell servo to go to position in variable 'pos'
delay(15);
}
}
w=1;
}
void soeon()
{
int pos = 0;
if(s==1)
{
digitalWrite(SOE,HIGH);
}
s=0;
}
void soeoff()
{
int pos = 0;
if(s==0)
{
digitalWrite(SOE,LOW);
}
s=1;
}
| [
"[email protected]"
] | |
a5cac46a4c21967ac6fd3ad6354dc6c67575b583 | 49b05e95d9003b7f1f4f66620c3e051a27648d91 | /LibCore/CDirIterator.h | 1d3395ef135efb8212aea290455ef870bedef1db | [
"BSD-2-Clause"
] | permissive | ygorko/serenity | 8f1d25b8d48465c9353c585b64e4e089c3434bbf | ccc6e69a294edacf7bec77cb2c2640ada7fe1f77 | refs/heads/master | 2020-05-31T03:40:53.063797 | 2019-06-03T17:52:31 | 2019-06-03T19:17:58 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 581 | h | #pragma once
#include <AK/AKString.h>
#include <dirent.h>
class CDirIterator {
public:
enum Flags
{
NoFlags = 0x0,
SkipDots = 0x1,
};
CDirIterator(const StringView& path, Flags = Flags::NoFlags);
~CDirIterator();
bool has_error() const { return m_error != 0; }
int error() const { return m_error; }
const char* error_string() const { return strerror(m_error); }
bool has_next();
String next_path();
private:
DIR* m_dir = nullptr;
int m_error = 0;
String m_next;
int m_flags;
bool advance_next();
};
| [
"[email protected]"
] | |
7fa0550fb1e1cbf603fc25ad3943ab664d6cc64d | 72cfed90103e76116518df289dc4d8b139672dee | /HelloSDL/AimingStrut.h | 2e802124e399a43c18e168efb85cdb905d85343f | [
"LicenseRef-scancode-warranty-disclaimer",
"LicenseRef-scancode-public-domain"
] | permissive | gentlecolts/trippy-procedurally-generated-star-fox-clone-for-school | 8ad8ea51f09e79775b60c65ee3d5b0855e83b5c9 | a98df82d54fdd9a2d8c6ed4945bd14102067b1a0 | refs/heads/master | 2021-01-22T05:24:03.642376 | 2013-06-24T14:17:45 | 2013-06-24T14:17:55 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 509 | h | //
// AimingStrut.h
// HelloSDL
//
// Created by Jonah Chazan on 5/3/13.
// Copyright (c) 2013 Student. All rights reserved.
//
#ifndef __HelloSDL__AimingStrut__
#define __HelloSDL__AimingStrut__
#include <iostream>
#include "BasicStrut.h"
class AimingStrut : public BasicStrut {
public:
AimingStrut();
AimingStrut(GameObject *p, double speed, Model *m);
void init(GameObject *p, double speed, Model *m);
void update(double dt);
double speed;
};
#endif /* defined(__HelloSDL__AimingStrut__) */
| [
"[email protected]"
] | |
f947455ecc9349bf3401bd45cbd1b6cbfa30a8fd | af1f72ae61b844a03140f3546ffc56ba47fb60df | /src/swagger/v1/model/TrafficLoad_rate.cpp | 985e8a92042ac6b54b0441d507abd2f1f45efe9f | [
"Apache-2.0"
] | permissive | Spirent/openperf | 23dac28e2e2e1279de5dc44f98f5b6fbced41a71 | d89da082e00bec781d0c251f72736602a4af9b18 | refs/heads/master | 2023-08-31T23:33:38.177916 | 2023-08-22T03:23:25 | 2023-08-22T07:13:15 | 143,898,378 | 23 | 16 | Apache-2.0 | 2023-08-22T07:13:16 | 2018-08-07T16:13:07 | C++ | UTF-8 | C++ | false | false | 1,207 | cpp | /**
* OpenPerf API
* REST API interface for OpenPerf
*
* OpenAPI spec version: 1
* Contact: [email protected]
*
* NOTE: This class is auto generated by the swagger code generator program.
* https://github.com/swagger-api/swagger-codegen.git
* Do not edit the class manually.
*/
#include "TrafficLoad_rate.h"
namespace swagger {
namespace v1 {
namespace model {
TrafficLoad_rate::TrafficLoad_rate()
{
m_Period = "";
m_Value = 0L;
}
TrafficLoad_rate::~TrafficLoad_rate()
{
}
void TrafficLoad_rate::validate()
{
// TODO: implement validation
}
nlohmann::json TrafficLoad_rate::toJson() const
{
nlohmann::json val = nlohmann::json::object();
val["period"] = ModelBase::toJson(m_Period);
val["value"] = m_Value;
return val;
}
void TrafficLoad_rate::fromJson(nlohmann::json& val)
{
setPeriod(val.at("period"));
setValue(val.at("value"));
}
std::string TrafficLoad_rate::getPeriod() const
{
return m_Period;
}
void TrafficLoad_rate::setPeriod(std::string value)
{
m_Period = value;
}
int64_t TrafficLoad_rate::getValue() const
{
return m_Value;
}
void TrafficLoad_rate::setValue(int64_t value)
{
m_Value = value;
}
}
}
}
| [
"[email protected]"
] | |
2b10d2ead502de4c4f831aa068ac8a7fbea2491c | d2727504338d2d705b16c9a3499ceeaaccb864af | /COP 3331 - Object Oriented Programming/Flex Project/src/Entrance.cpp | 4d0a7a28a8965daca40fc35d070652d0ace33f22 | [] | no_license | David-Hatcher/CS-Classes | fca3ff783ad923c5fde2c517e52d981c114c6f6c | 96e856f7f5699b9104f6d40e336c64a83c816497 | refs/heads/master | 2022-01-01T00:02:01.231869 | 2021-11-01T00:33:27 | 2021-11-01T00:33:27 | 186,830,580 | 0 | 0 | null | 2021-04-14T18:07:26 | 2019-05-15T13:20:04 | Java | UTF-8 | C++ | false | false | 2,471 | cpp | #include "Entrance.h"
Entrance::Entrance() : Room(){}
Entrance::Entrance(std::string file_path,Player& player): Room(file_path){
readDescription();
Interactive door("Door","Door");
Interactive drawers("Entrance Drawers","Entrance Drawers");
addInteractive("drawer",drawers);
addInteractive("door",door);
items.push_back(Game::buildItem("Jewelry Box Key"));
}
void Entrance::setDescription(Player& player){
updateDescription(player);
}
void Entrance::addInteractive(std::string name,Interactive interactive){
this->interactives.insert(std::pair<std::string,Interactive>(name,interactive));
}
std::string Entrance::interactWith(std::string action,std::string name,Player& player){
auto i = this->interactives.begin();
for(; i != this->interactives.end(); ++i){
if((*i).first == name){
break;
}
}
if(i == this->interactives.end()){ return "You can't do anything with that item.";}
if(action == "check" && (*i).first == "drawer"){
return checkDrawer(player);
}else if(action == "open" && (*i).first == "door"){
return openDoor(player);
}
return "Huh?";
}
void Entrance::readDescription(){
this->no_beast_description = Game::readFile("Rooms/" + file_path + "/" + file_path + "nobeastdesc.txt");
this->beast_description = Game::readFile("Rooms/" + file_path + "/" + file_path + "beastdesc.txt");
}
std::string Entrance::openDoor(Player& player){
if(player.checkFlags("Mirror_broken")){
player.setFlag("Beaten_game",true);
return "As you turn the door nob you feel the warmth from the sun outside move into the doorway. With a smile on her face, Emily thanks you for helping her escape and see the light of day again. \n\n Congratulations on completing the Disappearance of Emily Jane!";
}
else{
return "You cannot do that, the beast is in the way.";
}
}
std::string Entrance::checkDrawer(Player& player){
if(!player.checkInventory(items.at(0))){
player.addToInventory(items.at(0));
return "You find a key that looks like it could fit a jewelry box.";
}else{
return "There is nothing of interest in this drawer";
}
}
void Entrance::updateDescription(Player& player){
if(player.checkFlags("Has_released_emily") && !player.checkFlags("Mirror_broken")){
this->description = this->beast_description;
}else{
this->description = this->no_beast_description;
}
}
| [
"[email protected]"
] | |
310e1fce3310337c4d474bbf60d5e8297d169fad | 99cc10f54747ab929930dd37a49adc6dd6ecd6cf | /FUNCTIONS/TIMER.cpp | 0c0f547c1c0e93c1987a4fbad64a3cd3fa87e443 | [] | no_license | rdelos747/SDL_Game_Library | c10ac87a14ce07cca38a4d1e343104c63ac15302 | b220681f65bbb3eecfb24311f927a8ffa20d45e4 | refs/heads/master | 2021-05-05T15:28:59.537001 | 2019-11-08T05:31:34 | 2019-11-08T05:31:34 | 117,283,500 | 0 | 0 | null | 2019-05-27T22:38:40 | 2018-01-12T20:10:53 | C++ | UTF-8 | C++ | false | false | 1,034 | cpp | // /////////////////////////////////
// T I M E R
// ////////////////////////////////////////////////////////////////
#include "TIMER.h"
Timer::Timer() {
startTicks = 0;
pausedTicks = 0;
paused = false;
started = false;
}
Timer::~Timer() {}
void Timer::start() {
started = true;
paused = false;
startTicks = SDL_GetTicks();
pausedTicks = 0;
}
void Timer::stop() {
started = false;
paused = false;
startTicks = 0;
pausedTicks = 0;
}
void Timer::pause() {
if (started && !paused) {
paused = true;
pausedTicks = SDL_GetTicks() - startTicks;
startTicks = 0;
}
}
void Timer::resume() {
if (started && paused) {
paused = false;
startTicks = SDL_GetTicks() - pausedTicks;
pausedTicks = 0;
}
}
Uint32 Timer::getTicks() {
Uint32 time = 0;
if (started) {
if (paused) {
time = pausedTicks;
}
else {
time = SDL_GetTicks() - startTicks;
}
}
return time;
}
bool Timer::isStarted() {
return started;
}
bool Timer::isPaused() {
return paused;
} | [
"[email protected]"
] | |
ddda1f7ef15df3d6381039f1a4cc93dfcbe61763 | e763b855be527d69fb2e824dfb693d09e59cdacb | /aws-cpp-sdk-AWSMigrationHub/include/aws/AWSMigrationHub/model/PutResourceAttributesRequest.h | a0de9589f164dd0dbb56989eaa02231e2111a55d | [
"MIT",
"Apache-2.0",
"JSON"
] | permissive | 34234344543255455465/aws-sdk-cpp | 47de2d7bde504273a43c99188b544e497f743850 | 1d04ff6389a0ca24361523c58671ad0b2cde56f5 | refs/heads/master | 2023-06-10T16:15:54.618966 | 2018-05-07T23:32:08 | 2018-05-07T23:32:08 | 132,632,360 | 1 | 0 | Apache-2.0 | 2023-06-01T23:20:47 | 2018-05-08T15:56:35 | C++ | UTF-8 | C++ | false | false | 14,760 | h | /*
* Copyright 2010-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#pragma once
#include <aws/AWSMigrationHub/MigrationHub_EXPORTS.h>
#include <aws/AWSMigrationHub/MigrationHubRequest.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/AWSMigrationHub/model/ResourceAttribute.h>
#include <utility>
namespace Aws
{
namespace MigrationHub
{
namespace Model
{
/**
*/
class AWS_MIGRATIONHUB_API PutResourceAttributesRequest : public MigrationHubRequest
{
public:
PutResourceAttributesRequest();
// Service request name is the Operation name which will send this request out,
// each operation should has unique request name, so that we can get operation's name from this request.
// Note: this is not true for response, multiple operations may have the same response name,
// so we can not get operation's name from response.
inline virtual const char* GetServiceRequestName() const override { return "PutResourceAttributes"; }
Aws::String SerializePayload() const override;
Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
/**
* <p>The name of the ProgressUpdateStream. </p>
*/
inline const Aws::String& GetProgressUpdateStream() const{ return m_progressUpdateStream; }
/**
* <p>The name of the ProgressUpdateStream. </p>
*/
inline void SetProgressUpdateStream(const Aws::String& value) { m_progressUpdateStreamHasBeenSet = true; m_progressUpdateStream = value; }
/**
* <p>The name of the ProgressUpdateStream. </p>
*/
inline void SetProgressUpdateStream(Aws::String&& value) { m_progressUpdateStreamHasBeenSet = true; m_progressUpdateStream = std::move(value); }
/**
* <p>The name of the ProgressUpdateStream. </p>
*/
inline void SetProgressUpdateStream(const char* value) { m_progressUpdateStreamHasBeenSet = true; m_progressUpdateStream.assign(value); }
/**
* <p>The name of the ProgressUpdateStream. </p>
*/
inline PutResourceAttributesRequest& WithProgressUpdateStream(const Aws::String& value) { SetProgressUpdateStream(value); return *this;}
/**
* <p>The name of the ProgressUpdateStream. </p>
*/
inline PutResourceAttributesRequest& WithProgressUpdateStream(Aws::String&& value) { SetProgressUpdateStream(std::move(value)); return *this;}
/**
* <p>The name of the ProgressUpdateStream. </p>
*/
inline PutResourceAttributesRequest& WithProgressUpdateStream(const char* value) { SetProgressUpdateStream(value); return *this;}
/**
* <p>Unique identifier that references the migration task.</p>
*/
inline const Aws::String& GetMigrationTaskName() const{ return m_migrationTaskName; }
/**
* <p>Unique identifier that references the migration task.</p>
*/
inline void SetMigrationTaskName(const Aws::String& value) { m_migrationTaskNameHasBeenSet = true; m_migrationTaskName = value; }
/**
* <p>Unique identifier that references the migration task.</p>
*/
inline void SetMigrationTaskName(Aws::String&& value) { m_migrationTaskNameHasBeenSet = true; m_migrationTaskName = std::move(value); }
/**
* <p>Unique identifier that references the migration task.</p>
*/
inline void SetMigrationTaskName(const char* value) { m_migrationTaskNameHasBeenSet = true; m_migrationTaskName.assign(value); }
/**
* <p>Unique identifier that references the migration task.</p>
*/
inline PutResourceAttributesRequest& WithMigrationTaskName(const Aws::String& value) { SetMigrationTaskName(value); return *this;}
/**
* <p>Unique identifier that references the migration task.</p>
*/
inline PutResourceAttributesRequest& WithMigrationTaskName(Aws::String&& value) { SetMigrationTaskName(std::move(value)); return *this;}
/**
* <p>Unique identifier that references the migration task.</p>
*/
inline PutResourceAttributesRequest& WithMigrationTaskName(const char* value) { SetMigrationTaskName(value); return *this;}
/**
* <p>Information about the resource that is being migrated. This data will be used
* to map the task to a resource in the Application Discovery Service (ADS)'s
* repository.</p> <note> <p>In the <code>ResourceAttribute</code> object array,
* the <code>Type</code> field is reserved for the following values:
* <code>IPV4_ADDRESS | IPV6_ADDRESS | MAC_ADDRESS | FQDN | VM_MANAGER_ID |
* VM_MANAGED_OBJECT_REFERENCE | VM_NAME | VM_PATH | BIOS_ID |
* MOTHERBOARD_SERIAL_NUMBER</code>, and the identifying value can be a string up
* to 256 characters.</p> </note> <important> <p>If any "VM" related value is used
* for a <code>ResourceAttribute</code> object, it is required that
* <code>VM_MANAGER_ID</code>, as a minimum, is always used. If it is not used, the
* server will not be associated in the Application Discovery Service (ADS)'s
* repository using any of the other "VM" related values, and you will experience
* data loss. See the Example section below for a use case of specifying "VM"
* related values.</p> </important>
*/
inline const Aws::Vector<ResourceAttribute>& GetResourceAttributeList() const{ return m_resourceAttributeList; }
/**
* <p>Information about the resource that is being migrated. This data will be used
* to map the task to a resource in the Application Discovery Service (ADS)'s
* repository.</p> <note> <p>In the <code>ResourceAttribute</code> object array,
* the <code>Type</code> field is reserved for the following values:
* <code>IPV4_ADDRESS | IPV6_ADDRESS | MAC_ADDRESS | FQDN | VM_MANAGER_ID |
* VM_MANAGED_OBJECT_REFERENCE | VM_NAME | VM_PATH | BIOS_ID |
* MOTHERBOARD_SERIAL_NUMBER</code>, and the identifying value can be a string up
* to 256 characters.</p> </note> <important> <p>If any "VM" related value is used
* for a <code>ResourceAttribute</code> object, it is required that
* <code>VM_MANAGER_ID</code>, as a minimum, is always used. If it is not used, the
* server will not be associated in the Application Discovery Service (ADS)'s
* repository using any of the other "VM" related values, and you will experience
* data loss. See the Example section below for a use case of specifying "VM"
* related values.</p> </important>
*/
inline void SetResourceAttributeList(const Aws::Vector<ResourceAttribute>& value) { m_resourceAttributeListHasBeenSet = true; m_resourceAttributeList = value; }
/**
* <p>Information about the resource that is being migrated. This data will be used
* to map the task to a resource in the Application Discovery Service (ADS)'s
* repository.</p> <note> <p>In the <code>ResourceAttribute</code> object array,
* the <code>Type</code> field is reserved for the following values:
* <code>IPV4_ADDRESS | IPV6_ADDRESS | MAC_ADDRESS | FQDN | VM_MANAGER_ID |
* VM_MANAGED_OBJECT_REFERENCE | VM_NAME | VM_PATH | BIOS_ID |
* MOTHERBOARD_SERIAL_NUMBER</code>, and the identifying value can be a string up
* to 256 characters.</p> </note> <important> <p>If any "VM" related value is used
* for a <code>ResourceAttribute</code> object, it is required that
* <code>VM_MANAGER_ID</code>, as a minimum, is always used. If it is not used, the
* server will not be associated in the Application Discovery Service (ADS)'s
* repository using any of the other "VM" related values, and you will experience
* data loss. See the Example section below for a use case of specifying "VM"
* related values.</p> </important>
*/
inline void SetResourceAttributeList(Aws::Vector<ResourceAttribute>&& value) { m_resourceAttributeListHasBeenSet = true; m_resourceAttributeList = std::move(value); }
/**
* <p>Information about the resource that is being migrated. This data will be used
* to map the task to a resource in the Application Discovery Service (ADS)'s
* repository.</p> <note> <p>In the <code>ResourceAttribute</code> object array,
* the <code>Type</code> field is reserved for the following values:
* <code>IPV4_ADDRESS | IPV6_ADDRESS | MAC_ADDRESS | FQDN | VM_MANAGER_ID |
* VM_MANAGED_OBJECT_REFERENCE | VM_NAME | VM_PATH | BIOS_ID |
* MOTHERBOARD_SERIAL_NUMBER</code>, and the identifying value can be a string up
* to 256 characters.</p> </note> <important> <p>If any "VM" related value is used
* for a <code>ResourceAttribute</code> object, it is required that
* <code>VM_MANAGER_ID</code>, as a minimum, is always used. If it is not used, the
* server will not be associated in the Application Discovery Service (ADS)'s
* repository using any of the other "VM" related values, and you will experience
* data loss. See the Example section below for a use case of specifying "VM"
* related values.</p> </important>
*/
inline PutResourceAttributesRequest& WithResourceAttributeList(const Aws::Vector<ResourceAttribute>& value) { SetResourceAttributeList(value); return *this;}
/**
* <p>Information about the resource that is being migrated. This data will be used
* to map the task to a resource in the Application Discovery Service (ADS)'s
* repository.</p> <note> <p>In the <code>ResourceAttribute</code> object array,
* the <code>Type</code> field is reserved for the following values:
* <code>IPV4_ADDRESS | IPV6_ADDRESS | MAC_ADDRESS | FQDN | VM_MANAGER_ID |
* VM_MANAGED_OBJECT_REFERENCE | VM_NAME | VM_PATH | BIOS_ID |
* MOTHERBOARD_SERIAL_NUMBER</code>, and the identifying value can be a string up
* to 256 characters.</p> </note> <important> <p>If any "VM" related value is used
* for a <code>ResourceAttribute</code> object, it is required that
* <code>VM_MANAGER_ID</code>, as a minimum, is always used. If it is not used, the
* server will not be associated in the Application Discovery Service (ADS)'s
* repository using any of the other "VM" related values, and you will experience
* data loss. See the Example section below for a use case of specifying "VM"
* related values.</p> </important>
*/
inline PutResourceAttributesRequest& WithResourceAttributeList(Aws::Vector<ResourceAttribute>&& value) { SetResourceAttributeList(std::move(value)); return *this;}
/**
* <p>Information about the resource that is being migrated. This data will be used
* to map the task to a resource in the Application Discovery Service (ADS)'s
* repository.</p> <note> <p>In the <code>ResourceAttribute</code> object array,
* the <code>Type</code> field is reserved for the following values:
* <code>IPV4_ADDRESS | IPV6_ADDRESS | MAC_ADDRESS | FQDN | VM_MANAGER_ID |
* VM_MANAGED_OBJECT_REFERENCE | VM_NAME | VM_PATH | BIOS_ID |
* MOTHERBOARD_SERIAL_NUMBER</code>, and the identifying value can be a string up
* to 256 characters.</p> </note> <important> <p>If any "VM" related value is used
* for a <code>ResourceAttribute</code> object, it is required that
* <code>VM_MANAGER_ID</code>, as a minimum, is always used. If it is not used, the
* server will not be associated in the Application Discovery Service (ADS)'s
* repository using any of the other "VM" related values, and you will experience
* data loss. See the Example section below for a use case of specifying "VM"
* related values.</p> </important>
*/
inline PutResourceAttributesRequest& AddResourceAttributeList(const ResourceAttribute& value) { m_resourceAttributeListHasBeenSet = true; m_resourceAttributeList.push_back(value); return *this; }
/**
* <p>Information about the resource that is being migrated. This data will be used
* to map the task to a resource in the Application Discovery Service (ADS)'s
* repository.</p> <note> <p>In the <code>ResourceAttribute</code> object array,
* the <code>Type</code> field is reserved for the following values:
* <code>IPV4_ADDRESS | IPV6_ADDRESS | MAC_ADDRESS | FQDN | VM_MANAGER_ID |
* VM_MANAGED_OBJECT_REFERENCE | VM_NAME | VM_PATH | BIOS_ID |
* MOTHERBOARD_SERIAL_NUMBER</code>, and the identifying value can be a string up
* to 256 characters.</p> </note> <important> <p>If any "VM" related value is used
* for a <code>ResourceAttribute</code> object, it is required that
* <code>VM_MANAGER_ID</code>, as a minimum, is always used. If it is not used, the
* server will not be associated in the Application Discovery Service (ADS)'s
* repository using any of the other "VM" related values, and you will experience
* data loss. See the Example section below for a use case of specifying "VM"
* related values.</p> </important>
*/
inline PutResourceAttributesRequest& AddResourceAttributeList(ResourceAttribute&& value) { m_resourceAttributeListHasBeenSet = true; m_resourceAttributeList.push_back(std::move(value)); return *this; }
/**
* <p>Optional boolean flag to indicate whether any effect should take place. Used
* to test if the caller has permission to make the call.</p>
*/
inline bool GetDryRun() const{ return m_dryRun; }
/**
* <p>Optional boolean flag to indicate whether any effect should take place. Used
* to test if the caller has permission to make the call.</p>
*/
inline void SetDryRun(bool value) { m_dryRunHasBeenSet = true; m_dryRun = value; }
/**
* <p>Optional boolean flag to indicate whether any effect should take place. Used
* to test if the caller has permission to make the call.</p>
*/
inline PutResourceAttributesRequest& WithDryRun(bool value) { SetDryRun(value); return *this;}
private:
Aws::String m_progressUpdateStream;
bool m_progressUpdateStreamHasBeenSet;
Aws::String m_migrationTaskName;
bool m_migrationTaskNameHasBeenSet;
Aws::Vector<ResourceAttribute> m_resourceAttributeList;
bool m_resourceAttributeListHasBeenSet;
bool m_dryRun;
bool m_dryRunHasBeenSet;
};
} // namespace Model
} // namespace MigrationHub
} // namespace Aws
| [
"[email protected]"
] | |
d9593ed772334106e485d8434ac2f793feb581a7 | f3eddc585420e1b4a45505b8217b15951a22ac93 | /include/galaxy.h | cbc10a4edad2234e2c5399cf4667461c3818c2bf | [] | no_license | aronarts/space_gen | 63041db86b42bb532e08467dcbf8bfd37798f9ae | 0d17fa5798ea3098bcd220b483c56086d26f8f18 | refs/heads/master | 2020-05-27T21:18:45.005041 | 2014-10-21T13:16:00 | 2014-10-21T13:16:00 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 330 | h | #ifndef GALAXY_H
#define GALAXY_H
#include <vector>
#include "ssystem.h"
typedef std::vector<Ssystem> v_galaxy;
class Galaxy{
private:
int ssNum;
v_galaxy ssystems;
Galaxy() { };
v_galaxy generateGalaxy( int num );
public:
v_galaxy getGalaxy();
void printGalaxy();
Galaxy( int num );
};
#endif
| [
"[email protected]"
] | |
af20de9e588af8199c4c7081582af4fbf50fdb01 | 160daa0cfc2ac47dddf4003d1173bc42ef5008c9 | /src/WakeLock.cpp | d2498ce26859405b015b1a07b492aa344315baa9 | [] | no_license | KevinZu/lowpower | 7d2f2e08057faff8f141e96709c3ee99176f98b1 | fe5e65c2cdae6dbd5bc6119979c41b81d10c7ecb | refs/heads/master | 2021-04-23T02:05:10.343250 | 2020-04-03T03:34:52 | 2020-04-03T03:34:52 | 249,888,783 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,155 | cpp | #include <iostream>
#include "WakeLock.h"
#include <fcntl.h>
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <pthread.h>
using namespace nebula;
using namespace std;
//////////////////////////////////////////////////////////
const char * const NEW_PATHS[] = {
"/sys/power/wake_lock",
"/sys/power/wake_unlock",
};
#define MY_ID "ag35lock"
int WakeLock::AcquireWakeLock()
{
int fd;
fd = m_fds[ACQUIRE_PARTIAL_WAKE_LOCK];
return write(fd, m_id.c_str(), strlen(m_id.c_str()));
}
int WakeLock::ReleaseWakeLock()
{
ssize_t len = write(m_fds[RELEASE_WAKE_LOCK], m_id.c_str(), strlen(m_id.c_str()));
return len >= 0;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
WakeLock::WakeLock() : m_id(MY_ID),m_lock_count(0)
{
cout << "+ wake lock my_id:" << m_id << endl;
int i;
for (i=0; i<OUR_FD_COUNT; i++) {
int fd = open(NEW_PATHS[i], O_RDWR | O_CLOEXEC);
if (fd < 0) {
printf("fatal error opening \"%s\"\n", NEW_PATHS[i]);
}
m_fds[i] = fd;
}
pthread_mutex_init(&m_mutex, NULL);
}
WakeLock::~WakeLock()
{
cout << "- wake lock\n";
int i;
for (i=0; i<OUR_FD_COUNT; i++) {
if(m_fds[i] > 0)
close(m_fds[i]);
}
pthread_mutex_destroy(&m_mutex);
}
WakeLock& WakeLock::GetInstance()
{
static WakeLock instance_;
return instance_;
}
int WakeLock::Lock()
{
if(m_lock_count < 0) {
cout << "sys lock is failure!" << endl;
return -1;
}
if(m_lock_count == 0) {
AcquireWakeLock();
}
pthread_mutex_lock(&m_mutex);
m_lock_count += 1;
pthread_mutex_unlock(&m_mutex);
return m_lock_count;
}
int WakeLock::UnLock(int lockId)
{
if (m_lock_count <= 0) {
cout << "lock is already releaseWakeLock!" << endl;
return -1;
}
if (m_lock_count == 1) {
ReleaseWakeLock();
}
pthread_mutex_lock(&m_mutex);
m_lock_count -= 1;
pthread_mutex_unlock(&m_mutex);
return m_lock_count;
}
| [
"[email protected]"
] | |
789a0481206b98c5d8bd9af721b8a961271b9c0a | b9de7af9c746e42fb415c2cdb935f47833591300 | /lab_5.5/lab_5.5.cpp | cf2307037a4b6c91a94408ae8322cae4d794c4c6 | [] | no_license | Andr1yK/lab_5.5 | 47e880a519824726f9ba32a2d0d63bdcc7c1033b | 5134ce03a8a708ed5b8541afafda97c70a7f32aa | refs/heads/master | 2023-08-29T17:38:27.235428 | 2021-11-14T16:03:07 | 2021-11-14T16:03:07 | 426,536,127 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 920 | cpp | #include <iostream>
#include <cmath>
using namespace std;
double f(double x);
double findX(double a, double b, double eps, int& deep);
int main()
{
double a, b, eps, x;
int deep = 0;
cout << "a = "; cin >> a;
cout << "b = "; cin >> b;
cout << "eps = "; cin >> eps;
cout << endl;
x = findX(a, b, eps, deep);
cout << "x: " << x << endl;
cout << "Deep: " << deep << endl;
}
double findX(double a, double b, double eps, int& deep)
{
double m, f1, f2;
deep += 1;
f1 = f(a);
m = (a + b) / 2;
f2 = f(m);
if (abs(a - b)/2 >= eps && f2 != 0) {
if (f1 * f2 < 0)
b = m; // відкидаємо праву частину
else
a = m; // відкидаємо ліву частину
return findX(a, b, eps, deep);
}
else
{
return m;
}
}
double f(double x)
{
return sin(x) - cos(x);
} | [
"[email protected]"
] | |
d48316c9ddf8224f94579dd2a073b4f1268740ec | 198b5498a9988b65d52d03cdb9e6cba67f06ed02 | /MAIN.CPP | 8471c7a75a69c4b3705025bf862a8092ffd4cbf8 | [] | no_license | praash47/II-I-Project | 2bd5e8e7ec54bcd0d55da791c01be34447dbb644 | 0f41426bb8dc00c14ae2991e3999d9e46ad9bc08 | refs/heads/Main | 2020-04-10T12:15:43.323195 | 2019-01-29T10:52:00 | 2019-01-29T10:52:00 | 161,016,670 | 0 | 1 | null | 2018-12-09T07:57:10 | 2018-12-09T07:44:00 | null | UTF-8 | C++ | false | false | 1,470 | cpp | #include<iostream.h>
#include<conio.h>
#include<graphics.h>
#include<bios.h>
void welgr(){
clrscr();
int i, a=(getmaxx()-textwidth("<<< >>>"))/2;
setfillstyle(1,GREEN);
bar(0,0,getmaxx(),getmaxy());
setcolor(15);
settextstyle(1, 0, 7);
outtextxy((getmaxx()-textwidth("Student"))/2,1,"Student");
outtextxy((getmaxx()-textwidth("Database"))/2,80,"Database");
outtextxy((getmaxx()-textwidth("Management"))/2,160,"Management");
outtextxy((getmaxx()-textwidth("System"))/2,240,"System");
do{
settextstyle(0, 0, 1);
setcolor(BLUE);
outtextxy(a,getmaxy()-15,"<<< >>>");
setcolor(15);
outtextxy(a,getmaxy()-15," HIT ANY KEY ");
delay(250);if(kbhit()){getch();break;}
setcolor(BLUE);
outtextxy(a,getmaxy()-15,"<<< >>>");
setcolor(15);
outtextxy(a,getmaxy()-15," < HIT ANY KEY > ");
delay(250);if(kbhit()){getch();break;}
setcolor(BLUE);
outtextxy(a,getmaxy()-15,"<<< >>>");
setcolor(15);
outtextxy(a,getmaxy()-15," << HIT ANY KEY >> ");
delay(250);if(kbhit()){getch();break;}
setcolor(BLUE);
outtextxy(a,getmaxy()-15,"<<< >>>");
setcolor(15);
outtextxy(a,getmaxy()-15,"<<< HIT ANY KEY >>>");
delay(250);if(kbhit()){getch();break;}
}while(1);
setcolor(0);
for(i=0;i<getmaxy()/4;i++){
delay(20);
rectangle(midy-i,midy-i,getmaxx()+i-midy,midy+i);
rectangle(i,i,getmaxx()-i,getmaxy()-i);
}
}
void main()
{
welgr();
}
| [
"[email protected]"
] | |
b17d1b9b0c264062708633a47984153527523e80 | 13e46235a820cced8d15f0f1a05610026573aa79 | /src/database/kernels/xgemm/xgemm_32.hpp | a7fb7de96eb23a831b8761ffc1f7a8420df80437 | [
"Apache-2.0"
] | permissive | liuchang5/CLBlast | eb815d27738702ef8e0ca748b56d58f2b056b73b | 48133a0cd1a7b61b87906ec1f4608e766e20a973 | refs/heads/master | 2021-07-12T07:10:01.339320 | 2017-10-14T14:26:35 | 2017-10-14T14:26:35 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,820 | hpp |
// =================================================================================================
// This file is part of the CLBlast project. The project is licensed under Apache Version 2.0. It
// is auto-generated by the 'scripts/database/database.py' Python script.
//
// This file populates the database with best-found tuning parameters for the 'Xgemm32' kernels.
//
// =================================================================================================
namespace clblast {
namespace database {
const DatabaseEntry XgemmSingle = {
"Xgemm", Precision::kSingle, {"KWG", "KWI", "MDIMA", "MDIMC", "MWG", "NDIMB", "NDIMC", "NWG", "SA", "SB", "STRM", "STRN", "VWM", "VWN"}, {
{ // AMD GPUs
kDeviceTypeGPU, "AMD", {
{ "Ellesmere", {
{ Name{"AMD Radeon RX 480 "}, Params{ 32, 2, 8, 8, 16, 16, 16, 64, 1, 1, 0, 0, 1, 2 } },
{ kDeviceNameDefault , Params{ 32, 2, 8, 8, 16, 16, 16, 64, 1, 1, 0, 0, 1, 2 } },
} },
{ "Fiji", {
{ Name{"AMD Radeon R9 Fury X "}, Params{ 32, 2, 16, 16, 64, 16, 16, 64, 1, 1, 0, 0, 4, 4 } },
{ Name{"AMD Radeon R9 M370X Compute Engine "}, Params{ 32, 2, 16, 16, 64, 8, 16, 128, 0, 0, 0, 0, 2, 8 } },
{ kDeviceNameDefault , Params{ 32, 2, 16, 16, 64, 16, 16, 64, 1, 1, 0, 0, 2, 2 } },
} },
{ "Hawaii", {
{ Name{"AMD Radeon R9 290X "}, Params{ 16, 2, 16, 32, 128, 32, 8, 64, 1, 1, 1, 1, 4, 2 } },
{ kDeviceNameDefault , Params{ 16, 2, 16, 32, 128, 32, 8, 64, 1, 1, 1, 1, 4, 2 } },
} },
{ "Oland", {
{ Name{"Oland "}, Params{ 16, 2, 32, 16, 64, 32, 16, 128, 1, 1, 1, 0, 2, 4 } },
{ kDeviceNameDefault , Params{ 16, 2, 32, 16, 64, 32, 16, 128, 1, 1, 1, 0, 2, 4 } },
} },
{ "Pitcairn", {
{ Name{"AMD Radeon R9 270X "}, Params{ 16, 2, 16, 8, 32, 16, 16, 128, 0, 0, 1, 0, 1, 1 } },
{ kDeviceNameDefault , Params{ 16, 2, 16, 8, 32, 16, 16, 128, 0, 0, 1, 0, 1, 1 } },
} },
{ "Tahiti", {
{ Name{"AMD Radeon HD 7970 "}, Params{ 32, 2, 16, 32, 128, 16, 8, 64, 0, 0, 0, 0, 4, 1 } },
{ kDeviceNameDefault , Params{ 32, 2, 16, 32, 128, 16, 8, 64, 0, 0, 0, 0, 4, 1 } },
} },
{ "Tonga", {
{ Name{"AMD Radeon R9 380 "}, Params{ 16, 2, 16, 32, 64, 16, 8, 128, 1, 1, 0, 0, 2, 8 } },
{ kDeviceNameDefault , Params{ 16, 2, 16, 32, 64, 16, 8, 128, 1, 1, 0, 0, 2, 8 } },
} },
{ "Turks", {
{ Name{"AMD Radeon HD 6770M "}, Params{ 32, 2, 8, 8, 64, 8, 8, 64, 0, 0, 0, 0, 4, 4 } },
{ kDeviceNameDefault , Params{ 32, 2, 8, 8, 64, 8, 8, 64, 0, 0, 0, 0, 4, 4 } },
} },
{ "Vancouver", {
{ Name{"ATI Radeon HD 6750M "}, Params{ 32, 2, 8, 16, 128, 8, 8, 128, 0, 0, 1, 1, 8, 8 } },
{ kDeviceNameDefault , Params{ 32, 2, 8, 16, 128, 8, 8, 128, 0, 0, 1, 1, 8, 8 } },
} },
{ "default", {
{ kDeviceNameDefault , Params{ 32, 2, 8, 8, 32, 8, 8, 64, 0, 0, 0, 0, 4, 4 } },
} },
}
},
{ // ARM GPUs
kDeviceTypeGPU, "ARM", {
{ "default", {
{ Name{"Mali-T628 "}, Params{ 16, 2, 8, 8, 64, 8, 16, 16, 0, 0, 1, 1, 8, 1 } },
{ kDeviceNameDefault , Params{ 16, 2, 8, 8, 64, 8, 16, 16, 0, 0, 1, 1, 8, 1 } },
} },
}
},
{ // Intel CPUs
kDeviceTypeCPU, "Intel", {
{ "default", {
{ Name{"Intel(R) Core(TM) i7-2670QM CPU @ 2.20GHz "}, Params{ 16, 2, 8, 8, 128, 16, 8, 128, 0, 1, 1, 1, 1, 8 } },
{ Name{"Intel(R) Core(TM) i5-6200U CPU @ 2.30GHz "}, Params{ 32, 8, 32, 32, 64, 32, 16, 64, 1, 1, 1, 0, 2, 2 } },
{ Name{"Intel(R) Core(TM) i7 CPU 920 @ 2.67GHz "}, Params{ 32, 2, 16, 8, 128, 16, 8, 64, 0, 0, 1, 0, 1, 2 } },
{ Name{"Intel(R) Core(TM) i7-3770 CPU @ 3.40GHz "}, Params{ 32, 2, 32, 8, 128, 8, 8, 128, 1, 1, 1, 1, 2, 8 } },
{ Name{"Intel(R) Core(TM) i7-4790K CPU @ 4.00GHz "}, Params{ 16, 2, 8, 8, 128, 8, 8, 128, 1, 1, 1, 0, 1, 8 } },
{ Name{"Intel(R) Core(TM) i7-5930K CPU @ 3.50GHz "}, Params{ 32, 8, 16, 16, 64, 32, 32, 64, 0, 1, 1, 0, 1, 2 } },
{ Name{"Intel(R) Core(TM) i7-6770HQ CPU @ 2.60GHz "}, Params{ 32, 2, 16, 32, 32, 8, 8, 64, 0, 1, 0, 0, 1, 8 } },
{ kDeviceNameDefault , Params{ 32, 2, 8, 8, 32, 8, 8, 64, 1, 1, 0, 0, 4, 4 } },
} },
}
},
{ // Intel GPUs
kDeviceTypeGPU, "Intel", {
{ "default", {
{ Name{"Intel(R) HD Graphics 530 "}, Params{ 32, 2, 8, 8, 128, 32, 16, 64, 0, 0, 1, 0, 4, 2 } },
{ Name{"Intel(R) HD Graphics 5500 BroadWell U-Processor GT"}, Params{ 32, 8, 8, 8, 64, 32, 16, 64, 1, 1, 1, 1, 4, 2 } },
{ Name{"Intel(R) HD Graphics Haswell Ultrabook GT2 Mobile "}, Params{ 16, 2, 16, 8, 32, 8, 16, 128, 1, 1, 1, 1, 2, 4 } },
{ Name{"Intel(R) HD Graphics IvyBridge M GT2 "}, Params{ 32, 2, 16, 16, 64, 16, 8, 64, 1, 1, 1, 0, 2, 4 } },
{ Name{"Intel(R) HD Graphics Skylake ULT GT2 "}, Params{ 32, 2, 16, 16, 64, 8, 8, 64, 1, 1, 0, 0, 4, 4 } },
{ Name{"Iris "}, Params{ 16, 8, 16, 8, 128, 32, 16, 64, 1, 1, 1, 1, 4, 1 } },
{ Name{"Iris Pro "}, Params{ 16, 2, 16, 8, 64, 32, 32, 128, 1, 1, 1, 0, 4, 4 } },
{ kDeviceNameDefault , Params{ 32, 2, 16, 16, 64, 8, 8, 64, 1, 1, 0, 0, 4, 4 } },
} },
}
},
{ // Intel accelerators
kDeviceTypeAccelerator, "Intel", {
{ "default", {
{ Name{"Intel(R) Many Integrated Core Acceleration Card "}, Params{ 32, 2, 32, 32, 32, 32, 8, 128, 0, 0, 1, 0, 1, 4 } },
{ kDeviceNameDefault , Params{ 32, 2, 32, 32, 32, 32, 8, 128, 0, 0, 1, 0, 1, 4 } },
} },
}
},
{ // NVIDIA GPUs
kDeviceTypeGPU, "NVIDIA", {
{ "SM2.0", {
{ Name{"GeForce GTX 480 "}, Params{ 16, 2, 16, 8, 64, 32, 16, 64, 1, 1, 1, 1, 2, 2 } },
{ kDeviceNameDefault , Params{ 16, 2, 16, 8, 64, 32, 16, 64, 1, 1, 1, 1, 2, 2 } },
} },
{ "SM3.0", {
{ Name{"GRID K520 "}, Params{ 16, 2, 16, 8, 32, 8, 16, 64, 1, 1, 1, 1, 2, 4 } },
{ Name{"GeForce GT 650M "}, Params{ 32, 2, 8, 8, 32, 32, 32, 64, 1, 1, 0, 0, 4, 2 } },
{ Name{"GeForce GTX 670 "}, Params{ 16, 2, 8, 8, 64, 16, 16, 64, 1, 1, 1, 0, 2, 4 } },
{ Name{"GeForce GTX 680 "}, Params{ 32, 8, 8, 16, 64, 32, 16, 128, 1, 1, 0, 0, 4, 2 } },
{ kDeviceNameDefault , Params{ 32, 2, 8, 8, 32, 8, 8, 32, 1, 1, 0, 0, 4, 4 } },
} },
{ "SM3.5", {
{ Name{"GeForce GTX TITAN "}, Params{ 16, 8, 32, 16, 64, 8, 8, 64, 1, 1, 1, 0, 2, 2 } },
{ Name{"GeForce GTX TITAN Black "}, Params{ 16, 2, 16, 8, 64, 16, 16, 64, 1, 1, 1, 0, 4, 1 } },
{ Name{"Tesla K20m "}, Params{ 16, 2, 32, 16, 64, 16, 8, 64, 1, 1, 1, 0, 2, 4 } },
{ Name{"Tesla K40m "}, Params{ 16, 8, 16, 8, 64, 16, 16, 128, 1, 1, 1, 0, 2, 4 } },
{ kDeviceNameDefault , Params{ 16, 8, 32, 16, 64, 32, 16, 64, 1, 0, 1, 0, 2, 2 } },
} },
{ "SM5.0", {
{ Name{"GeForce GTX 750 "}, Params{ 16, 2, 16, 16, 64, 32, 8, 128, 1, 1, 1, 1, 1, 2 } },
{ Name{"GeForce GTX 750 Ti "}, Params{ 16, 2, 16, 16, 128, 32, 8, 64, 1, 1, 0, 1, 8, 2 } },
{ kDeviceNameDefault , Params{ 32, 2, 8, 8, 64, 32, 32, 64, 0, 0, 0, 0, 2, 1 } },
} },
{ "SM5.2", {
{ Name{"GeForce GTX 980 "}, Params{ 16, 2, 16, 16, 64, 16, 8, 128, 1, 1, 1, 0, 4, 8 } },
{ Name{"GeForce GTX TITAN X "}, Params{ 16, 2, 8, 16, 128, 8, 8, 128, 1, 1, 1, 1, 4, 8 } },
{ kDeviceNameDefault , Params{ 16, 2, 16, 16, 128, 16, 8, 128, 1, 1, 1, 0, 4, 8 } },
} },
{ "SM6.1", {
{ Name{"GeForce GTX 1070 "}, Params{ 16, 2, 32, 16, 128, 32, 8, 128, 1, 1, 1, 0, 4, 1 } },
{ Name{"GeForce GTX 1080 "}, Params{ 32, 2, 16, 8, 64, 8, 8, 64, 1, 1, 1, 1, 4, 8 } },
{ Name{"TITAN X (Pascal) "}, Params{ 32, 2, 16, 16, 64, 8, 8, 64, 1, 1, 0, 0, 4, 1 } },
{ kDeviceNameDefault , Params{ 32, 2, 16, 16, 64, 8, 8, 64, 1, 1, 0, 0, 4, 1 } },
} },
{ "default", {
{ kDeviceNameDefault , Params{ 32, 2, 16, 16, 64, 8, 8, 64, 1, 1, 0, 0, 4, 2 } },
} },
}
},
{ // QUALCOMM GPUs
kDeviceTypeGPU, "QUALCOMM", {
{ "default", {
{ Name{"QUALCOMM Adreno(TM) "}, Params{ 32, 2, 8, 8, 32, 8, 8, 32, 1, 1, 0, 0, 4, 1 } },
{ kDeviceNameDefault , Params{ 32, 2, 8, 8, 32, 8, 8, 32, 1, 1, 0, 0, 4, 1 } },
} },
}
},
{ // Default
kDeviceTypeAll, "default", {
{ "default", {
{ kDeviceNameDefault , Params{ 32, 2, 8, 8, 32, 8, 8, 32, 1, 1, 0, 0, 4, 2 } },
} },
}
},
}
};
} // namespace database
} // namespace clblast
| [
"[email protected]"
] | |
08d6329d3d97881a23f4547c07bab6b18f4f8889 | cb1b800db9c2475b1f342fd892af869e1e5ab41d | /robogym_ws/devel/.private/mir_msgs/include/mir_msgs/WebPath.h | 4283dece7ecd1dc6aa1c4fd2f0f73dce28b7c4eb | [] | no_license | klekkala/robogym_moveit | c64cb49f9fe11d5dbd2b10816708e323f772a4f6 | d5cdb3c177b719dd8366e0e1c741c5fd5e97521a | refs/heads/main | 2023-04-23T23:45:52.593518 | 2021-05-17T06:34:57 | 2021-05-17T06:34:57 | 365,917,056 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,189 | h | // Generated by gencpp from file mir_msgs/WebPath.msg
// DO NOT EDIT!
#ifndef MIR_MSGS_MESSAGE_WEBPATH_H
#define MIR_MSGS_MESSAGE_WEBPATH_H
#include <string>
#include <vector>
#include <map>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace mir_msgs
{
template <class ContainerAllocator>
struct WebPath_
{
typedef WebPath_<ContainerAllocator> Type;
WebPath_()
: seq(0)
, x()
, y() {
}
WebPath_(const ContainerAllocator& _alloc)
: seq(0)
, x(_alloc)
, y(_alloc) {
(void)_alloc;
}
typedef int32_t _seq_type;
_seq_type seq;
typedef std::vector<float, typename ContainerAllocator::template rebind<float>::other > _x_type;
_x_type x;
typedef std::vector<float, typename ContainerAllocator::template rebind<float>::other > _y_type;
_y_type y;
typedef boost::shared_ptr< ::mir_msgs::WebPath_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::mir_msgs::WebPath_<ContainerAllocator> const> ConstPtr;
}; // struct WebPath_
typedef ::mir_msgs::WebPath_<std::allocator<void> > WebPath;
typedef boost::shared_ptr< ::mir_msgs::WebPath > WebPathPtr;
typedef boost::shared_ptr< ::mir_msgs::WebPath const> WebPathConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::mir_msgs::WebPath_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::mir_msgs::WebPath_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::mir_msgs::WebPath_<ContainerAllocator1> & lhs, const ::mir_msgs::WebPath_<ContainerAllocator2> & rhs)
{
return lhs.seq == rhs.seq &&
lhs.x == rhs.x &&
lhs.y == rhs.y;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::mir_msgs::WebPath_<ContainerAllocator1> & lhs, const ::mir_msgs::WebPath_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace mir_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsFixedSize< ::mir_msgs::WebPath_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::mir_msgs::WebPath_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct IsMessage< ::mir_msgs::WebPath_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::mir_msgs::WebPath_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::mir_msgs::WebPath_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::mir_msgs::WebPath_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::mir_msgs::WebPath_<ContainerAllocator> >
{
static const char* value()
{
return "ae30a707d92aabd828375025011b8f41";
}
static const char* value(const ::mir_msgs::WebPath_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xae30a707d92aabd8ULL;
static const uint64_t static_value2 = 0x28375025011b8f41ULL;
};
template<class ContainerAllocator>
struct DataType< ::mir_msgs::WebPath_<ContainerAllocator> >
{
static const char* value()
{
return "mir_msgs/WebPath";
}
static const char* value(const ::mir_msgs::WebPath_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::mir_msgs::WebPath_<ContainerAllocator> >
{
static const char* value()
{
return "int32 seq\n"
"float32[] x\n"
"float32[] y\n"
;
}
static const char* value(const ::mir_msgs::WebPath_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::mir_msgs::WebPath_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.seq);
stream.next(m.x);
stream.next(m.y);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct WebPath_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::mir_msgs::WebPath_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::mir_msgs::WebPath_<ContainerAllocator>& v)
{
s << indent << "seq: ";
Printer<int32_t>::stream(s, indent + " ", v.seq);
s << indent << "x[]" << std::endl;
for (size_t i = 0; i < v.x.size(); ++i)
{
s << indent << " x[" << i << "]: ";
Printer<float>::stream(s, indent + " ", v.x[i]);
}
s << indent << "y[]" << std::endl;
for (size_t i = 0; i < v.y.size(); ++i)
{
s << indent << " y[" << i << "]: ";
Printer<float>::stream(s, indent + " ", v.y[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // MIR_MSGS_MESSAGE_WEBPATH_H
| [
"[email protected]"
] | |
b925372fe79681c33c92abab205c240ff01df824 | c67b19ccad5cb4713fa817d06c74a7d8643ee8f2 | /InterviewBit/Two Pointers/sort_by_color.cpp | a0c4186c273f9e418e408922256dce7869faa90a | [] | no_license | JoaoDanielRufino/Online-Judges | afadc08ad52dd4234e90f4c4eefae82c67f0a142 | 44fc4d71fe9db3d624d136b276735c34cf937f84 | refs/heads/master | 2023-07-20T00:04:09.323058 | 2023-07-05T01:03:50 | 2023-07-05T01:03:50 | 177,240,251 | 3 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 445 | cpp | void Solution::sortColors(vector<int> &A) {
int zero = 0;
int one = 0;
int two = 0;
for(int i = 0; i < A.size(); i++) {
if(A[i] == 0)
zero++;
else if(A[i] == 1)
one++;
else
two++;
}
int i;
for(int j = 0; i < zero; j++)
A[i++] = 0;
for(int j = 0; j < one; j++)
A[i++] = 1;
for(int j = 0; j < two; j++)
A[i++] = 2;
}
| [
"[email protected]"
] | |
fb087be463b9a1edb3fc7e6b258d5e34faf68b0e | 9e433eac9403fdd6f3ab13814c9f7144896c1d21 | /src/router.cpp | a0eaecd3cad6d35331b32f4cbd8ce3b6b4cb5952 | [] | no_license | jamesg/apollo | 6165bf8ca7662194730d1a06cd32c990eddd5668 | 8f8a96a9f13473c9e149eb853381a9e26da520f5 | refs/heads/master | 2021-01-23T13:48:32.254473 | 2015-09-05T09:09:02 | 2015-09-05T09:09:02 | 42,105,126 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,831 | cpp | #include "apollo/router.hpp"
#include <boost/bind.hpp>
#include "atlas/http/server/mimetypes.hpp"
#include "atlas/http/server/static_text.hpp"
#include "attachment.hpp"
#include "image_scaled.hpp"
#include "item_image.hpp"
#include "rest.hpp"
#define APOLLO_DECLARE_STATIC_STRING(PREFIX) \
extern "C" { \
extern char apollo_binary_##PREFIX##_start; \
extern char apollo_binary_##PREFIX##_end; \
extern size_t apollo_binary_##PREFIX##_size; \
}
#define APOLLO_STATIC_STD_STRING(PREFIX) \
std::string(&apollo_binary_##PREFIX##_start, &apollo_binary_##PREFIX##_end)
APOLLO_DECLARE_STATIC_STRING(index_html)
APOLLO_DECLARE_STATIC_STRING(manage_html)
APOLLO_DECLARE_STATIC_STRING(index_js)
APOLLO_DECLARE_STATIC_STRING(manage_js)
APOLLO_DECLARE_STATIC_STRING(application_js)
APOLLO_DECLARE_STATIC_STRING(models_js)
APOLLO_DECLARE_STATIC_STRING(style_css)
apollo::router::router(
boost::shared_ptr<boost::asio::io_service> io,
hades::connection& conn
) :
application_router(io)
{
//
// Install static files.
//
install_static_text("/", "html", APOLLO_STATIC_STD_STRING(index_html));
install_static_text("/index.html", APOLLO_STATIC_STD_STRING(index_html));
install_static_text("/manage.html", APOLLO_STATIC_STD_STRING(manage_html));
install_static_text("/index.js", APOLLO_STATIC_STD_STRING(index_js));
install_static_text("/manage.js", APOLLO_STATIC_STD_STRING(manage_js));
install_static_text("/application.js", APOLLO_STATIC_STD_STRING(application_js));
install_static_text("/models.js", APOLLO_STATIC_STD_STRING(models_js));
install_static_text("/style.css", APOLLO_STATIC_STD_STRING(style_css));
boost::shared_ptr<atlas::http::router> rest_router(rest::router(io, conn));
install(
atlas::http::matcher("/api(.*)"),
boost::bind(&atlas::http::router::serve, rest_router, _1, _2, _3, _4)
);
install(
atlas::http::matcher("/item/([0-9]+)/image", "POST"),
[&conn](
mg_connection *mg_conn,
atlas::http::uri_parameters_type args,
atlas::http::uri_callback_type success,
atlas::http::uri_callback_type failure
)
{
const int item_id = boost::lexical_cast<int>(args[1]);
upload_item_image(conn, mg_conn, item_id, success, failure);
}
);
install(
atlas::http::matcher("/attachment", "POST"),
[&conn](
mg_connection *mg_conn,
atlas::http::uri_parameters_type args,
atlas::http::uri_callback_type success,
atlas::http::uri_callback_type failure
)
{
upload_file(
conn,
mg_conn,
"attachment_title",
"attachment_data",
[&conn, mg_conn, success](attachment a) {
insert_attachment(a, conn);
mg_send_status(mg_conn, 200);
mg_send_header(mg_conn, "Content-type", "text/json");
auto r = atlas::http::json_response(a.info);
mg_send_data(mg_conn, r.data.c_str(), r.data.length());
success();
},
failure
);
}
);
install(
atlas::http::matcher("/attachment/([0-9]+)", "GET"),
[this, &conn](
mg_connection *mg_conn,
atlas::http::uri_parameters_type args,
atlas::http::uri_callback_type success,
atlas::http::uri_callback_type failure
)
{
const int attachment_id = boost::lexical_cast<int>(args[1]);
//catch(const boost::bad_lexical_cast& e)
return download_file(
mime_information(),
conn,
mg_conn,
attachment_id,
success,
failure
);
}
);
install(
atlas::http::matcher("/attachment/([0-9]+)/image/([0-9]+)x([0-9]+)", "GET"),
[this, &conn](
mg_connection *mg_conn,
atlas::http::uri_parameters_type args,
atlas::http::uri_callback_type success,
atlas::http::uri_callback_type failure
)
{
const int attachment_id = boost::lexical_cast<int>(args[1]);
const int width = boost::lexical_cast<int>(args[2]);
const int height = boost::lexical_cast<int>(args[3]);
return image_scaled(
mime_information(),
conn,
mg_conn,
attachment_id,
width,
height,
success,
failure
);
}
);
}
| [
"[email protected]"
] | |
6f8347232b1ea50352df3e59254e61f7cd462305 | 01b863b766272b418bf387f0833f6a7f6bdd7fe0 | /src/shaders/static_shader.cpp | 0c4e31327c244fdbd71d5a92831f7dfac3207b8d | [] | no_license | dinokid101/thinmatrix-game-engine | 2d718b6ee2bb1500576210e38ddb6068cad9b7f1 | e0e6173202943433f926c5a3699c007397b67272 | refs/heads/master | 2020-03-27T06:17:06.858278 | 2016-03-16T10:41:38 | 2016-03-16T10:41:38 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,406 | cpp | #include "shaders/static_shader.hpp"
#include "toolbox/math.hpp"
namespace {
constexpr auto VERTEX_SHADER_FILE = "res/shaders/static.v.glsl";
constexpr auto FRAGMENT_SHADER_FILE = "res/shaders/static.f.glsl";
}
StaticShader::StaticShader()
: Shader(VERTEX_SHADER_FILE, FRAGMENT_SHADER_FILE)
{
initialize();
}
void StaticShader::bindAttributes() {
bindAttribute(0, "position");
bindAttribute(1, "textureCoords");
bindAttribute(2, "normal");
}
void StaticShader::getAllUniformLocations() {
transformationMatrixLocation_ = getUniformLocation("transformationMatrix");
viewMatrixLocation_ = getUniformLocation("viewMatrix");
projectionMatrixLocation_ = getUniformLocation("projectionMatrix");
shineDamperLocation_ = getUniformLocation("shineDamper");
reflectivityLocation_ = getUniformLocation("reflectivity");
useFakeLightingLocation_ = getUniformLocation("useFakeLighting");
skyColorLocation_ = getUniformLocation("skyColor");
numberOfRowsLocation_ = getUniformLocation("numberOfRows");
offsetLocation_ = getUniformLocation("offset");
planeLocation_ = getUniformLocation("plane");
for (int i = 0; i < MAX_LIGHTS; i++) {
lightPositionLocation_[i] = getUniformLocation(
std::string("lightPosition[" + std::to_string(i) + "]").c_str());
lightColorLocation_[i] = getUniformLocation(
std::string("lightColor[" + std::to_string(i) + "]").c_str());
attenuationLocation_[i] = getUniformLocation(
std::string("attenuation[" + std::to_string(i) + "]").c_str());
}
}
void StaticShader::loadTransformationMatrix(glm::mat4 const& matrix) const {
loadMatrix(transformationMatrixLocation_, matrix);
}
void StaticShader::loadViewMatrix(Camera const& camera) const {
loadMatrix(viewMatrixLocation_, camera.getViewMatrix());
}
void StaticShader::loadProjectionMatrix(glm::mat4 const& matrix) const {
loadMatrix(projectionMatrixLocation_, matrix);
}
void StaticShader::loadLights(std::vector<Light> const& lights) const {
for (int i = 0; i < MAX_LIGHTS; i++) {
if (i < (int)lights.size()) {
loadVector3(lightPositionLocation_[i], lights[i].getPosition());
loadVector3(lightColorLocation_[i], lights[i].getColor());
loadVector3(attenuationLocation_[i], lights[i].getAttenuation());
} else {
loadVector3(lightPositionLocation_[i], glm::vec3(0, 0, 0));
loadVector3(lightColorLocation_[i], glm::vec3(0, 0, 0));
loadVector3(attenuationLocation_[i], glm::vec3(1, 0, 0));
}
}
}
void StaticShader::loadShineVariables(GLfloat shineDamper, GLfloat reflectivity) const {
loadFloat(shineDamperLocation_, shineDamper);
loadFloat(reflectivityLocation_, reflectivity);
}
void StaticShader::loadFakeLightingVariable(GLboolean useFakeLighting) const {
loadInteger(useFakeLightingLocation_, useFakeLighting);
}
void StaticShader::loadSkyColor(glm::vec3 const& rgbColor) const {
loadVector3(skyColorLocation_, rgbColor);
}
void StaticShader::loadNumberOfRows(int numberOfRows) const {
loadFloat(numberOfRowsLocation_, (GLfloat) numberOfRows);
}
void StaticShader::loadOffset(glm::vec2 const& offset) const {
loadVector2(offsetLocation_, offset);
}
void StaticShader::loadClipPlane(glm::vec4 const& plane) const {
loadVector4(planeLocation_, plane);
}
| [
"[email protected]"
] | |
495d6666950d6d193f3a9308795ad3ff9f05b0d5 | 92bdebea4842b189889ab097c4ad0237dfc2037d | /include/FxParser.h | 625a0a67813a4a2b1ea3d0259c87853c487851c7 | [] | no_license | galek/nvFX | d49f12e62bd3aba69afbb4a12e060a30052c9d43 | 16866af0afb5d425e3c2db1a4829a79a9ee353bf | refs/heads/master | 2021-11-23T04:21:14.269374 | 2019-12-12T22:58:51 | 2019-12-12T22:58:51 | 22,810,673 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,916 | h | #ifndef __FXPARSER_H__
#define __FXPARSER_H__
/*
Copyright (c) 2013, NVIDIA CORPORATION. All rights reserved.
Copyright (c) 2013, Tristan Lorach. 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.
* Neither the name of NVIDIA CORPORATION nor the names of its
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``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.
Please direct any questions to [email protected] (Tristan Lorach)
*/
#include "FxLib.h"
#include "FxLibEx.h"
namespace nvFX
{
bool loadEffectFromFile(IContainer* pCont, const char * filename);
bool loadEffect(IContainer* pCont, const char * str);
typedef void (/*WINAPI?*/*IncludeCb)(const char *incName, FILE *&fp, const char *&buf);
void setIncludeCallback(IncludeCb cbPtr);
} //namespace nvFX
#endif
| [
"[email protected]"
] | |
22e7480362cbbf7b155c5b06b75cc568d3c3caeb | f1c6e41e9f57a291205dbdc2d544caba2b31b967 | /src/graph/matrix/tests/denseMatrixTests.cc | 3992c6f2cfa7838e2a23e54350e7afa4be9fc0e6 | [] | no_license | ipsavitsky/graphs | 681876b41323059335c3dcda993eaef5e83b7bbb | 224b31e444ee804db6c4066f4a68858d41d4983c | refs/heads/master | 2021-12-02T07:10:07.984151 | 2021-07-28T11:12:34 | 2021-07-28T11:12:34 | 389,723,934 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,262 | cc | //
// Created by Ilya Savitsky on 27.07.2021.
//
#include <gtest/gtest.h>
#include "../denseMatrix.hpp"
#include "../exceptions.hpp"
class DenseMatrixTest : public ::testing::Test {
void SetUp() override {
}
void TearDown() override {
}
};
TEST_F(DenseMatrixTest, testMoveSemantics) {
DenseMatrix a(2, 2);
a.set(0, 0, 15);
DenseMatrix b(std::move(a));
ASSERT_DOUBLE_EQ(b.get(0, 0), 15);
b.set(1, 1, 16);
a = std::move(b);
ASSERT_DOUBLE_EQ(a.get(1, 1), 16);
}
TEST_F(DenseMatrixTest, testIterators) {
DenseMatrix matr(3, 4);
/*
3 0 7 0
7 9 0 0
6 9 4 5
*/
matr.set(0, 0, 3);
matr.set(0, 1, 0);
matr.set(0, 2, 7);
matr.set(0, 3, 0);
matr.set(1, 0, 7);
matr.set(1, 1, 9);
matr.set(1, 2, 0);
matr.set(1, 3, 0);
matr.set(2, 0, 6);
matr.set(2, 1, 9);
matr.set(2, 2, 4);
matr.set(2, 3, 5);
Matrix::RowIterator iter = matr.iterate_rows(0);
ASSERT_DOUBLE_EQ(*iter, 3);
iter++;
ASSERT_DOUBLE_EQ(*iter, 7);
++iter;
ASSERT_TRUE(iter == matr.end_rows(0));
Matrix::ColumnIterator it = matr.iterate_columns(2);
ASSERT_DOUBLE_EQ(*it, 7);
++it;
ASSERT_DOUBLE_EQ(*it, 4);
it++;
ASSERT_TRUE(it == matr.end_columns(2));
}
TEST_F(DenseMatrixTest, testExceptions) {
DenseMatrix matr(2, 2);
ASSERT_THROW(matr.get(3, 3), matr_excp::out_of_borders);
DenseMatrix matr2(3, 3);
ASSERT_THROW(matr.set(15, 100, 13), matr_excp::out_of_borders);
ASSERT_THROW(matr + matr2, matr_excp::incompat_sizes);
}
TEST_F(DenseMatrixTest, testGetSet) {
DenseMatrix matrix1(2, 2);
matrix1.set(0, 0, 1.34);
matrix1.set(0, 1, 1023.566);
matrix1.set(1, 0, 4);
matrix1.set(1, 1, 123123);
const DenseMatrix matrix2 = matrix1;
ASSERT_DOUBLE_EQ(matrix1.get(0, 0), 1.34);
ASSERT_DOUBLE_EQ(matrix1.get(0, 1), 1023.566);
ASSERT_DOUBLE_EQ(matrix1.get(1, 0), 4);
ASSERT_DOUBLE_EQ(matrix1.get(1, 1), 123123);
ASSERT_DOUBLE_EQ(matrix2.get(0, 0), 1.34);
ASSERT_DOUBLE_EQ(matrix2.get(0, 1), 1023.566);
ASSERT_DOUBLE_EQ(matrix2.get(1, 0), 4);
ASSERT_DOUBLE_EQ(matrix2.get(1, 1), 123123);
}
TEST_F(DenseMatrixTest, testGetRowsColumnsSize) {
DenseMatrix matrix1(10, 2);
const DenseMatrix matrix2(6, 3);
// std::cout << matrix1 << matrix2;
ASSERT_EQ(matrix1.num_rows(), 10);
ASSERT_EQ(matrix1.num_columns(), 2);
ASSERT_EQ(matrix2.num_rows(), 6);
ASSERT_EQ(matrix2.num_columns(), 3);
}
TEST_F(DenseMatrixTest, testMatrixEqual) {
DenseMatrix matrix1(2, 2);
DenseMatrix matrix2(2, 2);
const DenseMatrix matrix3(2, 2);
const DenseMatrix matrix4(2, 2);
ASSERT_TRUE(matrix1 == matrix2);
ASSERT_TRUE(matrix1 == matrix3);
ASSERT_TRUE(matrix3 == matrix4);
matrix1.set(0, 0, 1.34);
matrix1.set(0, 1, 1023.566);
matrix1.set(1, 0, 4);
matrix1.set(1, 1, 123123);
matrix2.set(0, 0, 1.34);
matrix2.set(0, 1, 1023.566);
matrix2.set(1, 0, 4);
matrix2.set(1, 1, 123123);
ASSERT_TRUE(matrix1 == matrix2);
ASSERT_TRUE(matrix1 != matrix3);
}
TEST_F(DenseMatrixTest, testAddition) {
DenseMatrix matrix1(2, 2);
DenseMatrix matrix2(2, 2);
const DenseMatrix matrix3(2, 2);
const DenseMatrix matrix4(2, 2);
matrix1.set(0, 0, 1.34);
matrix1.set(0, 1, 1023.5);
matrix1.set(1, 0, 4);
matrix1.set(1, 1, 123123);
matrix2.set(0, 0, 1.34);
matrix2.set(0, 1, 1023.5);
matrix2.set(1, 0, 4);
matrix2.set(1, 1, 123123);
DenseMatrix sum1 = matrix1 + matrix2;
DenseMatrix sum2 = matrix2 + matrix3;
DenseMatrix sum3 = matrix3 + matrix4;
ASSERT_DOUBLE_EQ(sum1.get(0, 0), 2.68);
ASSERT_DOUBLE_EQ(sum1.get(0, 1), 2047);
ASSERT_DOUBLE_EQ(sum1.get(1, 0), 8);
ASSERT_DOUBLE_EQ(sum1.get(1, 1), 246246);
ASSERT_DOUBLE_EQ(sum2.get(0, 0), 1.34);
ASSERT_DOUBLE_EQ(sum2.get(0, 1), 1023.5);
ASSERT_DOUBLE_EQ(sum2.get(1, 0), 4);
ASSERT_DOUBLE_EQ(sum2.get(1, 1), 123123);
ASSERT_DOUBLE_EQ(sum3.get(0, 0), 0);
ASSERT_DOUBLE_EQ(sum3.get(0, 1), 0);
ASSERT_DOUBLE_EQ(sum3.get(1, 0), 0);
ASSERT_DOUBLE_EQ(sum3.get(1, 1), 0);
}
TEST_F(DenseMatrixTest, testMultiplication) {
DenseMatrix matrix1(2, 3);
DenseMatrix matrix2(3, 2);
const DenseMatrix matrix3(2, 3);
const DenseMatrix matrix4(3, 2);
matrix1.set(0, 0, 2);
matrix1.set(0, 1, 3);
matrix1.set(0, 2, 4);
matrix1.set(1, 0, 5);
matrix1.set(1, 1, 4);
matrix1.set(1, 2, 5);
matrix2.set(0, 0, 1);
matrix2.set(0, 1, 2);
matrix2.set(1, 0, 1.5);
matrix2.set(1, 1, 3);
matrix2.set(2, 0, 1);
matrix2.set(2, 1, 1);
DenseMatrix mult1 = matrix1 * matrix2;
DenseMatrix mult2 = matrix2 * matrix3;
DenseMatrix mult3 = matrix3 * matrix4;
ASSERT_DOUBLE_EQ(mult1.get(0, 0), 10.5);
ASSERT_DOUBLE_EQ(mult1.get(0, 1), 17);
ASSERT_DOUBLE_EQ(mult1.get(1, 0), 16);
ASSERT_DOUBLE_EQ(mult1.get(1, 1), 27);
ASSERT_DOUBLE_EQ(mult2.get(0, 0), 0);
ASSERT_DOUBLE_EQ(mult2.get(0, 1), 0);
ASSERT_DOUBLE_EQ(mult2.get(1, 0), 0);
ASSERT_DOUBLE_EQ(mult2.get(1, 1), 0);
ASSERT_DOUBLE_EQ(mult3.get(0, 0), 0);
ASSERT_DOUBLE_EQ(mult3.get(0, 1), 0);
ASSERT_DOUBLE_EQ(mult3.get(1, 0), 0);
ASSERT_DOUBLE_EQ(mult3.get(1, 1), 0);
}
TEST_F(DenseMatrixTest, testIndexOperator) {
DenseMatrix matrix1(2, 2);
matrix1[0][0] = 1.34;
matrix1[0][1] = 1023.566;
matrix1[1][0] = 4;
matrix1[1][1] = 123123;
const DenseMatrix matrix2 = matrix1;
ASSERT_DOUBLE_EQ(matrix1[0][0], 1.34);
ASSERT_DOUBLE_EQ(matrix1[0][1], 1023.566);
ASSERT_DOUBLE_EQ(matrix1[1][0], 4);
ASSERT_DOUBLE_EQ(matrix1[1][1], 123123);
ASSERT_DOUBLE_EQ(matrix2[0][0], 1.34);
ASSERT_DOUBLE_EQ(matrix2[0][1], 1023.566);
ASSERT_DOUBLE_EQ(matrix2[1][0], 4);
ASSERT_DOUBLE_EQ(matrix2[1][1], 123123);
}
TEST_F(DenseMatrixTest, testPointer) {
DenseMatrix matrix1(2, 2);
**matrix1 = 1.34;
*(*matrix1 + 1) = 1023.566;
**(matrix1 + 1) = 4;
*(*(matrix1 + 1) + 1) = 123123;
const DenseMatrix matrix2 = matrix1;
ASSERT_DOUBLE_EQ(**matrix1, 1.34);
ASSERT_DOUBLE_EQ(*(*matrix1 + 1), 1023.566);
ASSERT_DOUBLE_EQ(**(matrix1 + 1), 4);
ASSERT_DOUBLE_EQ(*(*(matrix1 + 1) + 1), 123123);
ASSERT_DOUBLE_EQ(**matrix2, 1.34);
ASSERT_DOUBLE_EQ(*(*matrix2 + 1), 1023.566);
ASSERT_DOUBLE_EQ(**(matrix2 + 1), 4);
ASSERT_DOUBLE_EQ(*(*(matrix2 + 1) + 1), 123123);
}
TEST_F(DenseMatrixTest, testZeroObjects) {
DenseMatrix matrix1(2, 2);
const DenseMatrix matrix2 = matrix1;
ASSERT_DOUBLE_EQ(matrix1[0][0], 0.);
ASSERT_DOUBLE_EQ(matrix1[0][1], 0.);
ASSERT_DOUBLE_EQ(matrix1[1][0], 0.);
ASSERT_DOUBLE_EQ(matrix1[1][1], 0.);
ASSERT_DOUBLE_EQ(matrix2[0][0], 0.);
ASSERT_DOUBLE_EQ(matrix2[0][1], 0.);
ASSERT_DOUBLE_EQ(matrix2[1][0], 0.);
ASSERT_DOUBLE_EQ(matrix2[1][1], 0.);
ASSERT_DOUBLE_EQ(**matrix1, 0.);
ASSERT_DOUBLE_EQ(*(*matrix1 + 1), 0.);
ASSERT_DOUBLE_EQ(**(matrix1 + 1), 0.);
ASSERT_DOUBLE_EQ(*(*(matrix1 + 1) + 1), 0.);
ASSERT_DOUBLE_EQ(**matrix2, 0.);
ASSERT_DOUBLE_EQ(*(*matrix2 + 1), 0.);
ASSERT_DOUBLE_EQ(**(matrix2 + 1), 0.);
ASSERT_DOUBLE_EQ(*(*(matrix2 + 1) + 1), 0.);
} | [
"[email protected]"
] | |
cda503a9636dfa9cca6b4ca1d54d62512903be41 | 80024091ffe7089879e3abb16326bd49ad3ea656 | /src/simple_bgra_8888_transformer.h | afc8c503e929233f9d61533dbd101e346d2e0848 | [
"Libpng",
"MIT",
"BSD-3-Clause"
] | permissive | lineCode/skbitmap-transform | 0975f137fc90e36114c63235ecf80956a209cc0b | 4b83b032c3db38c077f6e419fcdc3ba20148d270 | refs/heads/master | 2022-11-18T06:05:39.653130 | 2020-07-21T16:59:03 | 2020-07-21T16:59:03 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 938 | h | #pragma once
#include <memory>
#include <sk_pixmap.h>
#include <sk_stream.h>
#include <sk_encoder.h>
#include <sk_image_encoder_fns.h>
class SimpleBGRA8888Transformer : public SkEncoder {
public:
/**
* Encode the |src| pixels to the |dst| stream.
* |options| may be used to control the encoding behavior.
*
* Returns true on success. Returns false on an invalid or unsupported |src|.
*/
static bool Encode(const SkPixmap& src, SkWStream* dst, const SkImageInfo& info);
static std::unique_ptr<SkEncoder> Make(const SkPixmap& src, SkWStream* dst, const SkImageInfo& info);
void chooseProc(const SkImageInfo& srcInfo);
~SimpleBGRA8888Transformer() override;
protected:
bool onEncodeRows(int numRows) override;
SimpleBGRA8888Transformer(const SkPixmap& src, SkWStream *dst);
typedef SkEncoder INHERITED;
private:
transform_scanline_proc fProc;
SkWStream *fDst;
}; | [
"[email protected]"
] | |
dfc73fddddda931327b56a8575bd0ad09300709a | 0b63ecb77fdf67e9131a73fee50b3d3a67d708bd | /wanheda/SDK/IClientEntity.h | 77216cea3097f54c288e6f6d8721862335e15c79 | [] | no_license | DespiseTheWeak/meme | 460a161cdba6182f56c122e303f27b5c0070e894 | 85800cc33292686e499864355a034c7f157b6faa | refs/heads/master | 2020-06-09T20:47:27.413159 | 2019-06-20T18:19:11 | 2019-06-20T18:19:11 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 538 | h | #pragma once
#include "IClientUnknown.h"
struct SpatializationInfo_t;
class IClientEntity : public IClientUnknown, public IClientRenderable, public IClientNetworkable, public IClientThinkable {
public:
virtual void Release( void ) = 0;
virtual const Vector GetAbsOrigin( void ) const = 0;
virtual const QAngle GetAbsAngles( void ) const = 0;
virtual void* GetMouth( void ) = 0;
virtual bool GetSoundSpatialization( SpatializationInfo_t info ) = 0;
virtual bool IsBlurred( void ) = 0;
}; | [
"[email protected]"
] | |
c8cc8b726621a734444079795acc1da1e2462d32 | 32db093028132c1e85b82ee801dc8f494c3b0b90 | /te33.cpp | 5076b2f148c204cbe3f1c2041f697c24de6ed7cf | [] | no_license | gautam-bits/CompetitiveCoding | b0aa13400655505fec48e4909d48b119b5fa895a | d9fb47c8f6bc94b6587cbdec3271ebd2bdf75b41 | refs/heads/master | 2023-08-16T18:02:07.278849 | 2021-09-24T09:08:13 | 2021-09-24T09:08:13 | 296,126,985 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 19,978 | cpp |
#include <bits/stdc++.h>
using namespace std;
//taken from (https://github.com/williamchanrico/biginteger-cpp/blob/master/BigInt.cpp)
class BigInt {
public:
bool neg = false;
std::string number = "0";
BigInt(){}
BigInt(const BigInt& other){
this -> neg = other.neg;
this -> number = other.number;
}
BigInt(int number){
if(number < 0){
this -> neg = true;
number *= -1;
}
if(number == 0){
this -> number = "0";
return;
}
this -> number = "";
while(number > 0){
this -> number += (number % 10) + '0';
number /= 10;
}
}
BigInt(long long int number){
if(number < 0){
this -> neg = true;
number *= -1;
}
if(number == 0){
this -> number = "0";
return;
}
this -> number = "";
while(number > 0){
this -> number += (number % 10) + '0';
number /= 10;
}
}
BigInt(unsigned long long int number){
if(number < 0){
this -> neg = true;
number *= -1;
}
if(number == 0){
this -> number = "0";
return;
}
this -> number = "";
while(number > 0){
this -> number += (number % 10) + '0';
number /= 10;
}
}
BigInt(const char *number){
std::string number_(number);
*(this) = number_;
}
BigInt(std::string number){
while(number[0] == '-'){
this -> neg = !this -> neg;
number.erase(0, 1);
}
reverse(number.begin(), number.end());
while(number.size() > 1 && number[number.size() - 1] == '0')
number.erase(number.size() - 1, number.size());
if(number == "")
number = "0";
this -> number = number;
if(number == "0")
this -> neg = false;
}
friend bool operator == (BigInt first, BigInt second){
return first.number == second.number && second.neg == first.neg;
}
friend bool operator != (BigInt first, BigInt second){
return !(first == second);
}
friend bool operator < (BigInt first, BigInt second){
if(first.neg && !second.neg) return true;
if(!first.neg && second.neg) return false;
if(first.neg && second.neg){
first.neg = false;
second.neg = false;
return first > second;
}
if((first.number).size() < (second.number).size()) return true;
if((first.number).size() > (second.number).size()) return false;
std::string temp1 = first.number; reverse(temp1.begin(), temp1.end());
std::string temp2 = second.number; reverse(temp2.begin(), temp2.end());
for(unsigned int i = 0; i < temp1.size(); i++)
if(temp1[i] < temp2[i])
return true;
else if(temp1[i] > temp2[i])
return false;
return false;
}
friend bool operator <= (BigInt first, BigInt second){
return (first == second) || (first < second);
}
friend bool operator > (BigInt first, BigInt second){
if(!first.neg && second.neg) return true;
if(first.neg && !second.neg) return false;
if(first.neg && second.neg){
first.neg = false;
second.neg = false;
return first < second;
}
if((first.number).size() > (second.number).size()) return true;
if((first.number).size() < (second.number).size()) return false;
std::string temp1 = first.number; reverse(temp1.begin(), temp1.end());
std::string temp2 = second.number; reverse(temp2.begin(), temp2.end());
for(unsigned int i = 0; i < temp1.size(); i++)
if(temp1[i] > temp2[i])
return true;
else if(temp1[i] < temp2[i])
return false;
return false;
}
friend bool operator >= (BigInt first, BigInt second){
return (first == second) || (first > second);
}
void operator = (unsigned long long int number){
if(number < 0){
this -> neg = true;
number *= -1;
}
this -> number = "";
while(number > 0){
this -> number += (number % 10) + '0';
number /= 10;
}
}
friend std::istream& operator >> (std::istream& in, BigInt &bigint){
std::string number; in >> number;
bigint.neg = false;
while(number[0] == '-'){
bigint.neg = !bigint.neg;
number.erase(0, 1);
}
reverse(number.begin(), number.end());
while(number.size() > 1 && number[number.size() - 1] == '0')
number.erase(number.size() - 1, number.size());
bigint.number = number;
if(number == "0")
bigint.neg = false;
return in;
}
friend std::ostream& operator << (std::ostream& out, const BigInt &bigint){
std::string number = bigint.number;
reverse(number.begin(), number.end());
if(bigint.neg)
number = '-' + number;
out << number;
return out;
}
friend void swap(BigInt &first, BigInt &second){
BigInt temp(first);
first = second;
second = temp;
}
friend BigInt abs(BigInt bigint){
bigint.neg = false;
return bigint;
}
friend BigInt operator + (BigInt first, BigInt second){
bool neg = false;
if(!first.neg && second.neg){
second.neg = false; return first - second;
}
if(first.neg && !second.neg){
first.neg = false; return second - first;
}
if(first.neg && second.neg){
neg = true;
first.neg = second.neg = false;
}
int n = first.number.size();
int m = second.number.size();
int carry = 0;
std::string result;
for(int i = 0; i < std::max(n, m); i++){
int add = carry;
if(i < n) add += first.number[i] - '0';
if(i < m) add += second.number[i] - '0';
carry = add / 10;
result += add % 10 + '0';
}
if(carry != 0)
result += carry + '0';
reverse(result.begin(), result.end());
BigInt result_(result);
result_.neg = neg;
return result_;
}
friend BigInt operator + (BigInt bigint){
return bigint;
}
friend BigInt operator - (BigInt first, BigInt second){
if(second.neg){
second.neg = false;
return first + second;
}
if(first.neg){
second.neg = true;
return first + second;
}
bool neg = false;
if(first < abs(second)){
neg = true;
swap(first, second);
first = abs(first);
}
int n = first.number.size();
int m = second.number.size();
int carry = 0;
std::string result;
for(int i = 0; i < std::max(n, m); i++){
int add = carry;
if(i < n) add += first.number[i] - '0';
if(i < m) add -= second.number[i] - '0';
if(add < 0){
carry = -1;
result += add + 10 + '0';
}
else {
carry = 0;
result += add + '0';
}
}
reverse(result.begin(), result.end());
BigInt result_(result);
result_.neg = neg;
return result_;
}
friend BigInt operator - (BigInt second){
BigInt first("0"); return first - second;
}
friend BigInt operator * (BigInt first, BigInt second){
bool neg = first.neg != second.neg;
first.neg = false;
second.neg = false;
int n = first.number.size();
int m = second.number.size();
BigInt result_;
for(int i = 0; i < n; i++){
int carry = 0;
std::string result;
for(int j = 0; j < i; j++)
result += '0';
for(int j = 0; j < m; j++){
int add = carry + (first.number[i] - '0') * (second.number[j] - '0');
carry = add / 10;
result += add % 10 + '0';
}
if(carry != 0)
result += carry + '0';
reverse(result.begin(), result.end());
BigInt current(result);
result_ += current;
}
result_.neg = neg;
return result_;
}
friend BigInt operator / (BigInt first, BigInt second){
if(second == "0")
throw "Division with 0";
bool neg = first.neg != second.neg;
first.neg = false;
second.neg = false;
BigInt quotient;
int i = first.size() - 1;
BigInt current(first.number[i] - '0');
--i;
while(true){
BigInt result = current;
bool l = false;
while(result < second && i >= 0){
result = result * 10 + (first.number[i--] - '0');
if(l)
quotient *= 10;
l = true;
}
int c = 0;
BigInt result_(result);
while(result_ >= second){
result_ -= second;
c++;
}
quotient = quotient * 10 + c;
current = result_;
if(i < 0)
break;
}
quotient.neg = neg;
return quotient;
}
friend BigInt operator % (BigInt first, BigInt second){
if(second == "0")
throw "Modulo with 0";
first.neg = false;
second.neg = false;
int i = first.size() - 1;
BigInt current(first.number[i] - '0');
--i;
while(true){
BigInt result = current;
while(result < second && i >= 0)
result = result * 10 + (first.number[i--] - '0');
int c = 0;
BigInt result_(result);
while(result_ >= second){
result_ -= second;
c++;
}
current = result_;
if(i < 0)
break;
}
current.neg = second.neg;
return current;
}
friend BigInt pow(BigInt x, BigInt y, BigInt mod = 0){
if(mod != 0)
x %= mod;
BigInt res = 1;
while(y != 0){
if(y % 2 == 1){
res *= x;
if(mod != 0)
res %= mod;
}
x *= x;
if(mod != 0)
x %= mod;
y /= 2;
}
return res;
}
friend BigInt operator & (BigInt first_, BigInt second_){
std::string first = first_.int_to_base(2);
std::string second = second_.int_to_base(2);
unsigned int n = std::min(first.size(), second.size());
reverse(first.begin(), first.end());
reverse(second.begin(), second.end());
std::string result(n, '~');
for(unsigned int i = 0; i < n; i++){
if(first[i] == '1' && second[i] == '1')
result[i] = '1';
else
result[i] = '0';
}
reverse(result.begin(), result.end());
return BigInt().base_to_int(result, 2);
}
friend BigInt operator | (BigInt first_, BigInt second_){
std::string first = first_.int_to_base(2);
std::string second = second_.int_to_base(2);
unsigned int n = std::max(first.size(), second.size());
reverse(first.begin(), first.end());
reverse(second.begin(), second.end());
std::string result(n, '~');
for(unsigned int i = 0; i < n; i++){
if(first.size() <= i || second.size() <= i){
if(first.size() > i) result[i] = first[i];
if(second.size() > i) result[i] = second[i];
continue;
}
if(first[i] == '1' || second[i] == '1')
result[i] = '1';
else
result[i] = '0';
}
reverse(result.begin(), result.end());
return BigInt().base_to_int(result, 2);
}
friend BigInt operator ^ (BigInt first_, BigInt second_){
std::string first = first_.int_to_base(2);
std::string second = second_.int_to_base(2);
unsigned int n = std::max(first.size(), second.size());
reverse(first.begin(), first.end());
reverse(second.begin(), second.end());
std::string result(n, '~');
for(unsigned int i = 0; i < n; i++){
if(first.size() <= i || second.size() <= i){
if(first.size() > i){
if(first[i] == '0')
result[i] = '0';
else
result[i] = '1';
}
if(second.size() > i){
if(second[i] == '0')
result[i] = '0';
else
result[i] = '1';
}
continue;
}
if(first[i] == second[i])
result[i] = '0';
else
result[i] = '1';
}
reverse(result.begin(), result.end());
return BigInt().base_to_int(result, 2);
}
friend BigInt operator << (BigInt first, BigInt second){
BigInt x = pow(2, second);
return first * x;
}
friend BigInt operator >> (BigInt first, BigInt second){
BigInt x = pow(2, second);
return first / x;
}
int to_int(BigInt bigint){
int n = 0;
for(int i = bigint.number.size() - 1; i >= 0; i--)
n = (n * 10) + (bigint.number[i] - '0');
return n;
}
std::string int_to_base(int base){
std::string result;
BigInt bigint(*this);
while(bigint > 0){
BigInt r = bigint % base;
if(r >= 10)
result += (char)(to_int(r / 10) + 'A');
else
result += (char)(to_int(r) + '0');
bigint /= base;
}
reverse(result.begin(), result.end());
return result;
}
BigInt base_to_int(std::string str, int base){
BigInt result;
for(unsigned int i = 0; i < str.size(); i++){
BigInt add;
if('0' <= str[i] && str[i] <= '9')
add += str[i] - '0';
else
add += (str[i] - 'A') + 10;
result = result * base + add;
}
return result;
}
int size(){
return this -> number.size();
}
void operator ++ (){*(this) = *(this) + 1;}
void operator -- (){*(this) = *(this) - 1;}
void operator += (BigInt bigint){*(this) = *(this) + bigint;}
void operator -= (BigInt bigint){*(this) = *(this) - bigint;}
void operator *= (BigInt bigint){*(this) = *(this) * bigint;}
void operator /= (BigInt bigint){*(this) = *(this) / bigint;}
void operator %= (BigInt bigint){*(this) = *(this) % bigint;}
void operator &= (BigInt bigint){*(this) = *(this) & bigint;}
void operator |= (BigInt bigint){*(this) = *(this) | bigint;}
void operator ^= (BigInt bigint){*(this) = *(this) ^ bigint;}
void operator <<= (BigInt bigint){*(this) = *(this) << bigint;}
void operator >>= (BigInt bigint){*(this) = *(this) >> bigint;}
};
map<pair<BigInt,BigInt>,BigInt> mp;
set<BigInt> st;
BigInt precedence(char op){
if(op == '+'||op == '-')
return 1;
if(op == '*'||op == '/' || op == '#' || op == '$')
return 2;
return 0;
}
BigInt applyOp(BigInt a, BigInt b, char op){
BigInt te = 332923839;
BigInt te2 = 50550593;
switch(op){
case '+': return a + b;
case '-': return a - b;
case '*': return a * b;
case '/': return a / b;
case '#': {
if(mp.find({a,b}) != mp.end()) {
return mp[{a,b}];
}
else if(st.empty()) {
st.insert("9323783383373");
mp[{a,b}] = "9323783383373";
return BigInt("9323783383373");
}
else {
BigInt te = *st.rbegin();
te += BigInt(rand());
st.insert(te);
mp[{a,b}] = te;
return te;
}
} ;
case '$': return te*a + b*te + a*b*b + 69*b + b - 22*a;
}
}
BigInt evaluate(string tokens){
int i;
stack <BigInt> values;
stack <char> ops;
for(i = 0; i < tokens.length(); i++){
if(tokens[i] == ' ')
continue;
else if(tokens[i] == '('){
ops.push(tokens[i]);
}
else if(isdigit(tokens[i])){
BigInt val = 0;
while(i < tokens.length() &&
isdigit(tokens[i]))
{
val = (val*10) + (BigInt)(tokens[i]-'0');
i++;
}
values.push(val);
i--;
}
else if(tokens[i] == ')')
{
while(!ops.empty() && ops.top() != '(')
{
BigInt val2 = values.top();
values.pop();
BigInt val1 = values.top();
values.pop();
char op = ops.top();
ops.pop();
values.push(applyOp(val1, val2, op));
}
if(!ops.empty())
ops.pop();
}
else
{
while(!ops.empty() && precedence(ops.top())
>= precedence(tokens[i])){
BigInt val2 = values.top();
values.pop();
BigInt val1 = values.top();
values.pop();
char op = ops.top();
ops.pop();
values.push(applyOp(val1, val2, op));
}
ops.push(tokens[i]);
}
}
while(!ops.empty()){
BigInt val2 = values.top();
values.pop();
BigInt val1 = values.top();
values.pop();
char op = ops.top();
ops.pop();
values.push(applyOp(val1, val2, op));
}
return values.top();
}
int main() {
// cout << evaluate("(9999999999999999999999999999999999999999+1)") << "\n";
// cout << evaluate("(100000000000000000000*100000000000000000000)") << "\n";
// cout << evaluate("(1*(1+2))") << "\n";
// cout << evaluate("100 * ( 2 + 12 ) / 14");
int t;
cin>>t;
for(int tno = 1; tno <= t ; tno++) {
mp.clear();
st.clear();
int n;
cin>>n;
vector<string> arr(n);
vector<int> ans(n);
vector<int> ans2(n);
map<BigInt,int> se;
map<BigInt,int> se2;
int itr = 1;
for(int i = 0 ; i < n ; i++) cin>>arr[i];
for(int i = 0 ; i < n ; i++) {
BigInt temp = evaluate(arr[i]);
if(se.size() != 0 && se.find(temp) != se.end()) {
ans[i] = se[temp];
}
else {
ans[i] = itr;
se[temp] = itr;
itr++;
}
}
// mp.clear();
// st.clear();
// for(int i = 0 ; i < n ; i ++){
// for(int j = 0 ; j < arr[i].size() ; j++){
// if(arr[i][j] == '#') {
// //cout<<"yo";
// arr[i][j] = '$';
// }
// }
// }
// itr = 1;
// for(int i = 0 ; i < n ; i++) {
// BigInt temp = evaluate(arr[i]);
// if(se2.size() != 0 && se2.find(temp) != se2.end()) {
// ans2[i] = se2[temp];
// }
// else {
// ans2[i] = itr;
// se2[temp] = itr;
// itr++;
// }
// }
// if(ans != ans2) assert(0);
// if(se2.size() > se.size()){
// ans = ans2;
// }
cout<<"Case #"<<tno<<": ";
for(int i = 0 ; i < n ; i++) cout<<ans[i]<<" ";
cout<<"\n";
}
return 0;
}
| [
"[email protected]"
] | |
5c2bfad305071935d72653d5a6109d9dcc210374 | c02332272e85c4b5a19d400c319df2f0f18f019b | /First-In-First-Out.cpp | 6d920f6ad55b35e7f9223cfdc897ee7dc918cd5d | [] | no_license | Nandhini1296/CS1035-Operating-Systems | c1301b80e179043f56686387050f85c0e9f04ba4 | 3e8cb95f082d7e5aebad11e4fc6e79c97f49d17e | refs/heads/master | 2020-12-02T23:55:16.278474 | 2017-07-01T12:26:12 | 2017-07-01T12:26:12 | 95,962,755 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 914 | cpp | #include <stdio.h>//fifo
int i,j,nof,nor,flag=0,ref[50],frm[50],pf=0,victim=-1;
int main()
{
printf("\nEnter the no. of frames: ");
scanf("%d",&nof);
printf("\nEnter no. of reference string: ");
scanf("%d",&nor);
printf("\nEnter the reference string: ");
for(i=0;i<nor;i++)
scanf("%d",&ref[i]);
for(i=1;i<nof;i++)
frm[i]=-1;
printf("\n");
for(i=0;i<nor;i++)
{
flag=0;
printf("\nReference: %d\t,ref[i]");
for(j=0;j<nof;j++)
{
if(frm[j]==ref[i])
{
flag=1;
break;
}
}
if(flag==0)
{
pf++;
victim++;
victim=victim%nof;
frm[victim]=ref[i];
for(j=0;j<nof;j++)
printf("%4d",frm[j]);
}
}
printf("\nNo of. Page faults: %d",pf);
return 0;
} | [
"[email protected]"
] | |
5cc992ec978adcc2b0eab78382bf920f967bb5db | 07185d117c2c9bcbbc3b92a88f91eba5f306949e | /chapter09/code9-1.cpp | bd6cd59ad34a6183353d9d78a348bb14936f4b9d | [] | no_license | JohannesMDr/book_algorithm_trials | c910069dc4df7026af9c9f1792c241ac655d6cc8 | 851b86fb41e901fa0c620ff1d52ca96f648c7c74 | refs/heads/main | 2023-02-01T08:36:27.253752 | 2020-12-18T03:19:05 | 2020-12-18T03:19:05 | 302,058,403 | 12 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 897 | cpp | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i, n) for(ll i = 0; i < ll(n); i++)
#define REPD(i, n) for(ll i = n-1; i >= 0; i--)
#define FOR(i, a, b) for(ll i = a; i < ll(b); i++)
#define FORD(i, a, b) for(ll i = a; i > ll(b); i--)
#define ALL(v) v.begin(), v.end()
#define START ios::sync_with_stdio(false);cin.tie(0);
const int MAX = 100000;
int st[MAX];
int top = 0;
void init() {
top = 0;
}
bool isEmpty() {
return (top == 0);
}
bool isFull() {
return (top == MAX);
}
void push(int x) {
if (isFull()) {
cout << "error: stack is full." << endl;
return;
}
st[top] = x;
++top;
}
int pop() {
if (isEmpty()) {
cout << "error: stack is empty." << endl;
return -1;
}
--top;
return st[top];
}
int main() {
START
init();
push(3);
push(5);
push(7);
cout << pop() << endl;
cout << pop() << endl;
push(9);
} | [
"[email protected]"
] | |
8f9edc7e016f8c195773bf3bf075957d2f89fbd5 | e2de85f83de242fc5b066a81eb55205c750ebc29 | /omaha/testing/omaha_unittest_main_small_tests_with_resources.cc | 4c1fc63484f39b456e76b31f4fd337d1ed145329 | [
"Apache-2.0"
] | permissive | google/omaha | 1a1c7f985388c0acedb05e9cee4e208de900f41c | 8fa5322c5c35d0cede28f4c32454cb0285490b6d | refs/heads/main | 2023-08-30T21:01:52.783638 | 2023-05-31T23:48:27 | 2023-05-31T23:48:27 | 38,279,227 | 2,705 | 805 | Apache-2.0 | 2023-09-07T17:36:59 | 2015-06-30T00:49:42 | C++ | UTF-8 | C++ | false | false | 1,454 | cc | // Copyright 2010 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ========================================================================
#include <windows.h>
#include <shellapi.h>
#include "omaha/testing/omaha_unittest.h"
// The entry point for the Omaha unit tests.
// We use main instead of _tmain since _tmain doesn't like being part of a
// static library...
int main(int unused_argc, char** unused_argv) {
UNREFERENCED_PARAMETER(unused_argc);
UNREFERENCED_PARAMETER(unused_argv);
int argc = 0;
WCHAR** argv = ::CommandLineToArgvW(::GetCommandLine(), &argc);
return omaha::RunTests(false, // is_medium_or_large_test.
true, // load_resources.
argc,
argv);
}
namespace omaha {
// The network is not needed for small tests.
int InitializeNetwork() {
return 0;
}
int DeinitializeNetwork() {
return 0;
}
} // namespace omaha
| [
"[email protected]"
] | |
35b5ee7859b5ad17ad01890042c0d117ab58839f | bb6ebff7a7f6140903d37905c350954ff6599091 | /content/public/test/mock_render_thread.cc | 0d1b0bcb6f3f9457f3db202b69475ebcbf1974e6 | [
"BSD-3-Clause"
] | permissive | PDi-Communication-Systems-Inc/lollipop_external_chromium_org | faa6602bd6bfd9b9b6277ce3cd16df0bd26e7f2f | ccadf4e63dd34be157281f53fe213d09a8c66d2c | refs/heads/master | 2022-12-23T18:07:04.568931 | 2016-04-11T16:03:36 | 2016-04-11T16:03:36 | 53,677,925 | 0 | 1 | BSD-3-Clause | 2022-12-09T23:46:46 | 2016-03-11T15:49:07 | C++ | UTF-8 | C++ | false | false | 7,784 | cc | // Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "content/public/test/mock_render_thread.h"
#include "base/message_loop/message_loop_proxy.h"
#include "content/common/frame_messages.h"
#include "content/common/view_messages.h"
#include "content/public/renderer/render_process_observer.h"
#include "content/renderer/render_view_impl.h"
#include "ipc/ipc_message_utils.h"
#include "ipc/ipc_sync_message.h"
#include "ipc/message_filter.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/WebKit/public/web/WebScriptController.h"
namespace content {
MockRenderThread::MockRenderThread()
: routing_id_(0),
surface_id_(0),
opener_id_(0),
new_window_routing_id_(0),
new_window_main_frame_routing_id_(0),
new_frame_routing_id_(0) {
}
MockRenderThread::~MockRenderThread() {
while (!filters_.empty()) {
scoped_refptr<IPC::MessageFilter> filter = filters_.back();
filters_.pop_back();
filter->OnFilterRemoved();
}
}
// Called by the Widget. Used to send messages to the browser.
// We short-circuit the mechanism and handle the messages right here on this
// class.
bool MockRenderThread::Send(IPC::Message* msg) {
// We need to simulate a synchronous channel, thus we are going to receive
// through this function messages, messages with reply and reply messages.
// We can only handle one synchronous message at a time.
if (msg->is_reply()) {
if (reply_deserializer_) {
reply_deserializer_->SerializeOutputParameters(*msg);
reply_deserializer_.reset();
}
} else {
if (msg->is_sync()) {
// We actually need to handle deleting the reply deserializer for sync
// messages.
reply_deserializer_.reset(
static_cast<IPC::SyncMessage*>(msg)->GetReplyDeserializer());
}
if (msg->routing_id() == MSG_ROUTING_CONTROL)
OnControlMessageReceived(*msg);
else
OnMessageReceived(*msg);
}
delete msg;
return true;
}
base::MessageLoop* MockRenderThread::GetMessageLoop() {
return NULL;
}
IPC::SyncChannel* MockRenderThread::GetChannel() {
return NULL;
}
std::string MockRenderThread::GetLocale() {
return "en-US";
}
IPC::SyncMessageFilter* MockRenderThread::GetSyncMessageFilter() {
return NULL;
}
scoped_refptr<base::MessageLoopProxy>
MockRenderThread::GetIOMessageLoopProxy() {
return scoped_refptr<base::MessageLoopProxy>();
}
void MockRenderThread::AddRoute(int32 routing_id, IPC::Listener* listener) {
}
void MockRenderThread::RemoveRoute(int32 routing_id) {
}
int MockRenderThread::GenerateRoutingID() {
NOTREACHED();
return MSG_ROUTING_NONE;
}
void MockRenderThread::AddFilter(IPC::MessageFilter* filter) {
filter->OnFilterAdded(&sink());
// Add this filter to a vector so the MockRenderThread::RemoveFilter function
// can check if this filter is added.
filters_.push_back(make_scoped_refptr(filter));
}
void MockRenderThread::RemoveFilter(IPC::MessageFilter* filter) {
// Emulate the IPC::ChannelProxy::OnRemoveFilter function.
for (size_t i = 0; i < filters_.size(); ++i) {
if (filters_[i].get() == filter) {
filter->OnFilterRemoved();
filters_.erase(filters_.begin() + i);
return;
}
}
NOTREACHED() << "filter to be removed not found";
}
void MockRenderThread::AddObserver(RenderProcessObserver* observer) {
observers_.AddObserver(observer);
}
void MockRenderThread::RemoveObserver(RenderProcessObserver* observer) {
observers_.RemoveObserver(observer);
}
void MockRenderThread::SetResourceDispatcherDelegate(
ResourceDispatcherDelegate* delegate) {
}
void MockRenderThread::EnsureWebKitInitialized() {
}
void MockRenderThread::RecordAction(const base::UserMetricsAction& action) {
}
void MockRenderThread::RecordComputedAction(const std::string& action) {
}
scoped_ptr<base::SharedMemory>
MockRenderThread::HostAllocateSharedMemoryBuffer(
size_t buffer_size) {
scoped_ptr<base::SharedMemory> shared_buf(new base::SharedMemory);
if (!shared_buf->CreateAnonymous(buffer_size)) {
NOTREACHED() << "Cannot map shared memory buffer";
return scoped_ptr<base::SharedMemory>();
}
return scoped_ptr<base::SharedMemory>(shared_buf.release());
}
void MockRenderThread::RegisterExtension(v8::Extension* extension) {
blink::WebScriptController::registerExtension(extension);
}
void MockRenderThread::ScheduleIdleHandler(int64 initial_delay_ms) {
}
void MockRenderThread::IdleHandler() {
}
int64 MockRenderThread::GetIdleNotificationDelayInMs() const {
return 0;
}
void MockRenderThread::SetIdleNotificationDelayInMs(
int64 idle_notification_delay_in_ms) {
}
void MockRenderThread::UpdateHistograms(int sequence_number) {
}
int MockRenderThread::PostTaskToAllWebWorkers(const base::Closure& closure) {
return 0;
}
bool MockRenderThread::ResolveProxy(const GURL& url, std::string* proxy_list) {
return false;
}
base::WaitableEvent* MockRenderThread::GetShutdownEvent() {
return NULL;
}
#if defined(OS_WIN)
void MockRenderThread::PreCacheFont(const LOGFONT& log_font) {
}
void MockRenderThread::ReleaseCachedFonts() {
}
#endif // OS_WIN
void MockRenderThread::SendCloseMessage() {
ViewMsg_Close msg(routing_id_);
RenderViewImpl::FromRoutingID(routing_id_)->OnMessageReceived(msg);
}
// The Widget expects to be returned valid route_id.
void MockRenderThread::OnCreateWidget(int opener_id,
blink::WebPopupType popup_type,
int* route_id,
int* surface_id) {
opener_id_ = opener_id;
*route_id = routing_id_;
*surface_id = surface_id_;
}
// The View expects to be returned a valid route_id different from its own.
void MockRenderThread::OnCreateWindow(
const ViewHostMsg_CreateWindow_Params& params,
int* route_id,
int* main_frame_route_id,
int* surface_id,
int64* cloned_session_storage_namespace_id) {
*route_id = new_window_routing_id_;
*main_frame_route_id = new_window_main_frame_routing_id_;
*surface_id = surface_id_;
*cloned_session_storage_namespace_id = 0;
}
// The Frame expects to be returned a valid route_id different from its own.
void MockRenderThread::OnCreateChildFrame(int new_frame_routing_id,
const std::string& frame_name,
int* new_render_frame_id) {
*new_render_frame_id = new_frame_routing_id_++;
}
bool MockRenderThread::OnControlMessageReceived(const IPC::Message& msg) {
ObserverListBase<RenderProcessObserver>::Iterator it(observers_);
RenderProcessObserver* observer;
while ((observer = it.GetNext()) != NULL) {
if (observer->OnControlMessageReceived(msg))
return true;
}
return OnMessageReceived(msg);
}
bool MockRenderThread::OnMessageReceived(const IPC::Message& msg) {
// Save the message in the sink.
sink_.OnMessageReceived(msg);
bool handled = true;
IPC_BEGIN_MESSAGE_MAP(MockRenderThread, msg)
IPC_MESSAGE_HANDLER(ViewHostMsg_CreateWidget, OnCreateWidget)
IPC_MESSAGE_HANDLER(ViewHostMsg_CreateWindow, OnCreateWindow)
IPC_MESSAGE_HANDLER(FrameHostMsg_CreateChildFrame, OnCreateChildFrame)
IPC_MESSAGE_UNHANDLED(handled = false)
IPC_END_MESSAGE_MAP()
return handled;
}
#if defined(OS_WIN)
void MockRenderThread::OnDuplicateSection(
base::SharedMemoryHandle renderer_handle,
base::SharedMemoryHandle* browser_handle) {
// We don't have to duplicate the input handles since RenderViewTest does not
// separate a browser process from a renderer process.
*browser_handle = renderer_handle;
}
#endif // defined(OS_WIN)
} // namespace content
| [
"[email protected]"
] | |
67feea36e34d85273f431b6452aa84eae2bf5bb1 | ef9f45769704fced7beefb0f20afc1f25f1024d4 | /serviceLane.cpp | ab74e372bd67bb179772d834a74cc66f97698f02 | [] | no_license | YogaVicky/Hackerrank-solutions | 4a517b0272d994807895123e1a5c3a95bd86d7ac | f5d8a3b5cb4ab3bbf7116391aa4c3de17d366bf8 | refs/heads/master | 2020-05-30T08:57:29.006496 | 2019-12-17T19:11:19 | 2019-12-17T19:11:19 | 189,629,279 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 464 | cpp | #include <iostream>
using namespace std;
int main(){
long int n , i , check , c1 , c2;
int t , a[10000] , b[10000][2] , j;
cin>>n>>t;
for(i=0;i<n;i++){
cin>>a[i];
}
for(i=0;i<t;i++){
for(j=0;j<2;j++){
cin>>b[i][j];
}
}
for(i=0;i<t;i++){
c1 = b[i][0];
c2 = b[i][1];
check = a[c1];
for(j=c1+1;j<=c2;j++){
if(check>a[j])
check = a[j];
}
cout<<check<<endl;
}
return 0;
} | [
"[email protected]"
] | |
d1a9ba4ddfae8028c6ee6bf04917282335f65286 | 2d08393b82ad53c6d415dd378a0ba8763dea59ae | /base/l2.cpp | 579f9c503df15ee8dba4c57977cce2eea865c4b8 | [] | no_license | frstrtr/boost_tutorials | 8329017dc5d20f39c9de261b49546c512e0d9f65 | 0ab0fd08704b5723076c7200c6815881aeef9d80 | refs/heads/master | 2022-08-12T09:11:21.312334 | 2020-05-20T02:40:30 | 2020-05-20T02:40:30 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 340 | cpp | #include <iostream>
#include <boost/asio.hpp>
using namespace std;
using namespace boost;
void print(const boost::system::error_code& /*e*/)
{
cout << "Hello, world!" << std::endl;
}
int main()
{
asio::io_context io;
asio::steady_timer t(io, asio::chrono::seconds(5));
t.async_wait(&print);
io.run();
return 0;
} | [
"[email protected]"
] | |
16f9c94a831ea5ba1579c946948b031ee7933932 | 2ba94892764a44d9c07f0f549f79f9f9dc272151 | /Engine/Source/Runtime/Engine/Private/Tests/NetworkAutomationTests.cpp | 37adf214521e5840e5d8352e2293b217e8ec6b14 | [
"BSD-2-Clause",
"LicenseRef-scancode-proprietary-license"
] | permissive | PopCap/GameIdea | 934769eeb91f9637f5bf205d88b13ff1fc9ae8fd | 201e1df50b2bc99afc079ce326aa0a44b178a391 | refs/heads/master | 2021-01-25T00:11:38.709772 | 2018-09-11T03:38:56 | 2018-09-11T03:38:56 | 37,818,708 | 0 | 0 | BSD-2-Clause | 2018-09-11T03:39:05 | 2015-06-21T17:36:44 | null | UTF-8 | C++ | false | false | 2,474 | cpp | // Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
#include "EnginePrivate.h"
#include "AutomationTestCommon.h"
DEFINE_LOG_CATEGORY_STATIC(LogNetworkAutomationTests, Log, All);
//enum for multiplayer test
namespace EMultiplayerAutomationRoles
{
enum Type
{
Host = 0,
Client0,
MaxNumParticipants,
};
};
/**
* 2-Multiplayer session automation test
* Verification for 2 player multiplayer session start up and tear down
*/
IMPLEMENT_NETWORKED_AUTOMATION_TEST( FMultiplayer4PlayerTest, "System.Networking.Multiplayer.TwoPlayerSessionStartupShutdown", EAutomationTestFlags::ATF_Game, EMultiplayerAutomationRoles::MaxNumParticipants )
/**
* Load up a game session, invite players to join, accept invitations, quit
*
* @param Parameters - Unused for this test
* @return TRUE if the test was successful, FALSE otherwise
*/
bool FMultiplayer4PlayerTest::RunTest(const FString& Parameters)
{
// Accessing the game world is only valid for game-only
check((GetTestFlags() & EAutomationTestFlags::ATF_ApplicationMask) == EAutomationTestFlags::ATF_Game);
check(GEngine->GetWorldContexts().Num() == 1);
check(GEngine->GetWorldContexts()[0].WorldType == EWorldType::Game);
START_NETWORK_AUTOMATION_COMMAND(OpenMap)
{
//Load Map
FString MapName = TEXT("AutomationTest");
GEngine->Exec(GEngine->GetWorldContexts()[0].World(), *FString::Printf(TEXT("Open %s"), *MapName));
ADD_LATENT_AUTOMATION_COMMAND(FEngineWaitLatentCommand(2.0));
}
END_NETWORK_AUTOMATION_COMMAND(OpenMap, EMultiplayerAutomationRoles::Host)
// TODO: Ask JB about this....
for (int32 i = 0; i < EMultiplayerAutomationRoles::MaxNumParticipants; ++i)
{
//Invite Players
START_NETWORK_AUTOMATION_COMMAND(InvitePlayers)
{
ADD_LATENT_AUTOMATION_COMMAND(FExecStringLatentCommand(TEXT("stat memory")));
ADD_LATENT_AUTOMATION_COMMAND(FEngineWaitLatentCommand(2.0));
ADD_LATENT_AUTOMATION_COMMAND(FExecStringLatentCommand(TEXT("stat memory")));
}
END_NETWORK_AUTOMATION_COMMAND(InvitePlayers, i)
}
START_NETWORK_AUTOMATION_COMMAND(PerformanceHost)
{
ADD_LATENT_AUTOMATION_COMMAND(FEnqueuePerformanceCaptureCommands());
}
END_NETWORK_AUTOMATION_COMMAND(PerformanceHost, EMultiplayerAutomationRoles::Host)
START_NETWORK_AUTOMATION_COMMAND(PerformanceClient0)
{
ADD_LATENT_AUTOMATION_COMMAND(FEnqueuePerformanceCaptureCommands());
}
END_NETWORK_AUTOMATION_COMMAND(PerformanceClient0, EMultiplayerAutomationRoles::Client0)
return true;
} | [
"[email protected]"
] | |
62c094b18b3f29de1e4e6a3d18589a077fa58119 | acee4b7eef20520061c2023eedd7e3fdbdce71f7 | /CoinFlip/debug/moc_mainwindow.cpp | 8a527d6b5347f8c3919e01d1739d1f80e1e1f45d | [] | no_license | wangxiaochao66/qt_project_CoinFlipGame | 1893bab1404433a97b397a0e376ffd77bc761876 | db70ffb37a2c1f33fd2b1aa054234857e10bdeca | refs/heads/master | 2022-11-22T23:32:24.825080 | 2020-07-23T12:36:37 | 2020-07-23T12:36:37 | 281,947,195 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,687 | cpp | /****************************************************************************
** Meta object code from reading C++ file 'mainwindow.h'
**
** Created by: The Qt Meta Object Compiler version 67 (Qt 5.8.0)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "../mainwindow.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'mainwindow.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.8.0. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif
QT_BEGIN_MOC_NAMESPACE
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
struct qt_meta_stringdata_MainWindow_t {
QByteArrayData data[1];
char stringdata0[11];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
qptrdiff(offsetof(qt_meta_stringdata_MainWindow_t, stringdata0) + ofs \
- idx * sizeof(QByteArrayData)) \
)
static const qt_meta_stringdata_MainWindow_t qt_meta_stringdata_MainWindow = {
{
QT_MOC_LITERAL(0, 0, 10) // "MainWindow"
},
"MainWindow"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_MainWindow[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
0, 0, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
0, // signalCount
0 // eod
};
void MainWindow::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
Q_UNUSED(_o);
Q_UNUSED(_id);
Q_UNUSED(_c);
Q_UNUSED(_a);
}
const QMetaObject MainWindow::staticMetaObject = {
{ &QMainWindow::staticMetaObject, qt_meta_stringdata_MainWindow.data,
qt_meta_data_MainWindow, qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};
const QMetaObject *MainWindow::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *MainWindow::qt_metacast(const char *_clname)
{
if (!_clname) return Q_NULLPTR;
if (!strcmp(_clname, qt_meta_stringdata_MainWindow.stringdata0))
return static_cast<void*>(const_cast< MainWindow*>(this));
return QMainWindow::qt_metacast(_clname);
}
int MainWindow::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QMainWindow::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
return _id;
}
QT_WARNING_POP
QT_END_MOC_NAMESPACE
| [
"[email protected]"
] | |
446436e614cc942e68e30c27c15ddb939e44543f | 98157b3124db71ca0ffe4e77060f25503aa7617f | /codeforces/369_2/b.cpp | 6e8531ca444b002927727e66e077d497dace1234 | [] | no_license | wiwitrifai/competitive-programming | c4130004cd32ae857a7a1e8d670484e236073741 | f4b0044182f1d9280841c01e7eca4ad882875bca | refs/heads/master | 2022-10-24T05:31:46.176752 | 2022-09-02T07:08:05 | 2022-09-02T07:08:35 | 59,357,984 | 37 | 4 | null | null | null | null | UTF-8 | C++ | false | false | 1,096 | cpp | #include <bits/stdc++.h>
using namespace std;
const int N = 505;
long long a[N][N];
int main() {
int n;
scanf("%d", &n);
long long sum = 0, sub = 0;
for (int i = 0; i < n; i++) {
bool ok = true;
long long now = 0;
for (int j = 0; j < n; j++) {
scanf("%I64d", a[i]+j);
now += a[i][j];
if (a[i][j] == 0) {
ok = false;
}
}
if (ok)
sum = now;
else
sub = now;
}
if (n == 1) {
puts("1");
return 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) if (a[i][j] == 0) {
a[i][j] = sum - sub;
}
}
bool ok = (sum - sub) > 0;
long long d1 = 0, d2 = 0;
for (int i = 0; i < n; i++) {
long long now = 0;
for (int j = 0; j < n; j++) {
now += a[i][j];
}
if (now != sum) {
ok = false;
}
now = 0;
for (int j = 0; j < n; j++) {
now += a[j][i];
}
if (now != sum)
ok = false;
d1 += a[i][i];
d2 += a[i][n-i-1];
}
if (d1 != sum || d2 != sum) {
ok = false;
}
printf("%I64d\n", ok ? sum - sub : -1);
return 0;
} | [
"[email protected]"
] | |
273c194ff6c90c641ae2a1511577568c0ea8fa04 | 95ea4179df1833c017260d11ee9362703e866fd6 | /Game_September/common.h | 377908f6c32fd8759d2f95325cd13ca0b77cd7fb | [] | no_license | wem-wem/fromCygwin | 5d2a759a53c3c5413bf88aaff4b78e900050106f | 644f9b5b443805aaa135b89f992bc420403bc523 | refs/heads/master | 2020-12-24T13:44:24.148318 | 2015-09-23T20:28:47 | 2015-09-23T20:28:47 | 29,850,099 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 201 | h | #pragma once
#include "cinder/app/AppNative.h"
#include "cinder/gl/gl.h"
#include "cinder/Rand.h"
#include <list>
#include <chrono>
#include <ctime>
using namespace ci;
using namespace ci::app;
| [
"[email protected]"
] | |
01ade279dd70618625d417afbca5ea8a64f576d2 | f55665c5faa3d79d0d6fe91fcfeb8daa5adf84d0 | /GameSDK/GameUILib/Include/XUI_Dialog.h | 35839f853d54d88dd95b34054f01c3e31ccb8d5e | [] | no_license | lxinhcn/starworld | 79ed06ca49d4064307ae73156574932d6185dbab | 86eb0fb8bd268994454b0cfe6419ffef3fc0fc80 | refs/heads/master | 2021-01-10T07:43:51.858394 | 2010-09-15T02:38:48 | 2010-09-15T02:38:48 | 47,859,019 | 2 | 1 | null | null | null | null | GB18030 | C++ | false | false | 918 | h | #pragma once
#include "XUI_Window.h"
namespace XGC
{
namespace ui
{
//框架控件，不显示任何内容，只是作为容器
class XUI_System;
class XUI_Dialog: public XUI_Window
{
public:
XUI_Dialog( _lpctstr lpszTemplate = NULL, XUI_Window *pParent = NULL );
~XUI_Dialog();
bool Create();
int DoModal();
protected:
XUI_Wnd* PreModal();
void BeginModalLoop();
void PostModal();
void EndModalLoop();
void EndDialog( UINT nResult );
void OnOK();
void OnCancel();
void CenterWindow();
void SetFocus( UINT nCtrlID );
protected:
virtual bool OnInitDialog(){ return true;}
virtual void OnDestroy(){}
virtual bool DefMessageProc( MSG &msg ){ return false; }
private:
bool m_bModal;
bool m_bEnableParent;
int m_nResult;
_string m_strTemplate;
XUI_Window* m_pParent;
};
}
} | [
"albertclass@a94d7126-06ea-11de-b17c-0f1ef23b492c"
] | albertclass@a94d7126-06ea-11de-b17c-0f1ef23b492c |
236b986fb9afa2c20ad79569a4f7f44cba139840 | 5979ad168e6780e5bc24d0ff58701febe8100395 | /Player/VideoPlayer/videoplayer.cpp | d6c25c56964b8150df6b0956532e6d755bb167c2 | [] | no_license | mehome/qt | 2be0bb32079a26d0803371a512d15aea3d82ef5a | ee474abc80edfeedcbd4f102a09b59ffd55db8df | refs/heads/master | 2021-09-22T01:01:06.579673 | 2018-09-04T06:34:27 | 2018-09-04T06:34:27 | null | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 13,358 | cpp | #include "videoplayer.h"
extern "C"{
#include <SDL/SDL.h>
#include <SDL/SDL_audio.h>
#include <SDL/SDL_types.h>
#include <SDL/SDL_name.h>
#include <SDL/SDL_syswm.h>
#include <SDL/SDL_video.h>
#include <SDL/SDL_main.h>
#include <SDL/SDL_config.h>
}
int volume; //音量 0-128
#define READ_PACKET_TIME_OUT 15
struct PacketQueue
{
AVPacketList *first_pkt, *last_pkt;
int nb_packets;
int size;
SDL_mutex *mutex;
};
PacketQueue *audioq;
void packet_queue_init(PacketQueue *q)
{
memset(q, 0, sizeof(PacketQueue));
q->mutex = SDL_CreateMutex();
}
int packet_queue_put(PacketQueue *q, AVPacket *pkt) {
AVPacketList *pkt1;
if(av_dup_packet(pkt) < 0){
return -1;
}
pkt1 = (AVPacketList*)av_malloc(sizeof(AVPacketList));
if (!pkt1)
return -1;
pkt1->pkt = *pkt;
pkt1->next = NULL;
SDL_LockMutex(q->mutex);
if (!q->last_pkt){
q->first_pkt = pkt1;
}else{
q->last_pkt->next = pkt1;
}
q->last_pkt = pkt1;
q->nb_packets++;
q->size += pkt1->pkt.size;
SDL_UnlockMutex(q->mutex);
return 0;
}
static void packet_queue_clear(PacketQueue *q)
{
SDL_LockMutex(q->mutex);
AVPacketList *tmp;
while (1){
tmp = q->first_pkt;
if (tmp == NULL) break;
q->first_pkt = tmp->next;
q->size -= tmp->pkt.size;
av_free(tmp);
}
q->last_pkt = NULL;
SDL_UnlockMutex(q->mutex);
}
static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block)
{
AVPacketList *pkt1;
int ret;
SDL_LockMutex(q->mutex);
pkt1 = q->first_pkt;
if (pkt1){
q->first_pkt = pkt1->next;
if (!q->first_pkt)
q->last_pkt = NULL;
q->nb_packets;
q->size -= pkt1->pkt.size;
*pkt = pkt1->pkt;
av_free(pkt1);
ret = 1;
}else{
ret = -1;
}
SDL_UnlockMutex(q->mutex);
return ret;
}
int audio_decode_frame(AVCodecContext *aCodecCtx, uint8_t *audio_buf, int buf_size)
{
static AVPacket pkt;
static uint8_t *audio_pkt_data = NULL;
static int audio_pkt_size = 0;
int len1, data_size;
for(;;){
if(packet_queue_get(audioq, &pkt, 1) < 0){
return -1;
}
audio_pkt_data = pkt.data;
audio_pkt_size = pkt.size;
while(audio_pkt_size > 0){
data_size = buf_size;
len1 = avcodec_decode_audio2(aCodecCtx, (int16_t *)audio_buf, &data_size,audio_pkt_data, audio_pkt_size);
if(len1 < 0){
audio_pkt_size = 0;
break;
}
audio_pkt_data += len1;
audio_pkt_size -= len1;
if(data_size <= 0){
continue;
}
return data_size;
}
if(pkt.data)
av_free_packet(&pkt);
}
}
void audio_callback(void *userdata, Uint8 *stream, int len)
{
AVCodecContext *aCodecCtx = (AVCodecContext *)userdata;
int len1, audio_size;
static uint8_t audio_buf[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2];
static unsigned int audio_buf_size = 0;
static unsigned int audio_buf_index = 0;
while(len > 0){
if(audio_buf_index >= audio_buf_size){
audio_size = audio_decode_frame(aCodecCtx, audio_buf,sizeof(audio_buf));
if(audio_size < 0){
audio_buf_size = 1024;
memset(audio_buf, 0, audio_buf_size);
}
else{
audio_buf_size = audio_size;
}
audio_buf_index = 0;
}
len1 = audio_buf_size - audio_buf_index;
if(len1 > len)
len1 = len;
SDL_MixAudio(stream, (uint8_t * )audio_buf + audio_buf_index, len1, volume);
len -= len1;
stream += len1;
audio_buf_index += len1;
}
}
/***
***DecodeVideo类的成员
***/
DecodeVideo::DecodeVideo()
{
bufferRGB = NULL;
mutex = NULL;
}
DecodeVideo::~DecodeVideo()
{
}
void DecodeVideo::setAVCodecContext(AVCodecContext*ctx)
{
pCodecCtx = ctx;
width = pCodecCtx->width;
height= pCodecCtx->height;
pix_fmt = pCodecCtx->pix_fmt;
if (bufferRGB != NULL){
av_free(bufferRGB);
bufferRGB = NULL;
}
int numBytes = avpicture_get_size(PIX_FMT_RGB24, pCodecCtx->width,pCodecCtx->height);
bufferRGB = (uint8_t *)av_malloc(numBytes*sizeof(uint8_t));
}
void DecodeVideo::run()
{
av_log(NULL,AV_LOG_INFO,"DecodeVideo::run \n");
int frameFinished = 0;
static AVFrame pFrame ;
SDL_LockMutex(mutex);
avcodec_decode_video(pCodecCtx, &pFrame, &frameFinished,packet.data,packet.size);
SDL_UnlockMutex(mutex);
if(!frameFinished){
return;
}
static AVFrame pFrameRGB;
avpicture_fill((AVPicture *)&pFrameRGB, bufferRGB, PIX_FMT_RGB24,pCodecCtx->width, pCodecCtx->height);
SwsContext *convert_ctx = sws_getContext(width,height,pix_fmt,width,height,PIX_FMT_RGB24,SWS_BICUBIC, NULL,NULL,NULL);
if(!convert_ctx){
return;
}
sws_scale(convert_ctx,(const uint8_t* const*)pFrame.data,pFrame.linesize,0,height,pFrameRGB.data,pFrameRGB.linesize);
QImage tmpImage((uchar *)bufferRGB,width,height,QImage::Format_RGB888);
QImage image = tmpImage.copy();
sws_freeContext(convert_ctx);
emit readOneFrame(image);
av_free_packet(&packet);
}
/***
***VideoPlayer类的成员
***/
VideoPlayer::VideoPlayer(QObject *parent):QThread(parent)
{
initAvcodec();
audioq = new PacketQueue;
packet_queue_init(audioq);
mutex = SDL_CreateMutex();
decodeVideoMutex = SDL_CreateMutex();
aCodecCtx = NULL;
pFormatCtx = NULL;
eventloop = NULL;
curState = StoppedState;
curType = NoneType;
decodeVideoThread = new DecodeVideo;
connect(decodeVideoThread,SIGNAL(readOneFrame(QImage)),this,SIGNAL(readOneFrame(QImage)));
av_log(NULL,AV_LOG_INFO,"Init VideoPlayer \n");
}
VideoPlayer::~VideoPlayer()
{
}
void VideoPlayer::run()
{
eventloop = new QEventLoop;
QTimer playtimer; //控制播放的定时器
connect(&playtimer,SIGNAL(timeout()),this,SLOT(readPacket()),Qt::DirectConnection);
playtimer.start(READ_PACKET_TIME_OUT);
eventloop->exec();
delete eventloop;
eventloop = NULL;
}
void VideoPlayer::soundSlotChanged(int value)
{
setVolume(value);
}
void VideoPlayer::initAvcodec()
{
av_register_all();
avcodec_init();
avcodec_register_all();
avdevice_register_all();
}
bool VideoPlayer::openVideo(char *filename)
{
videoStream = -1;
audioStream = -1;
if(av_open_input_file(&pFormatCtx, filename, NULL, 0, NULL)!=0){
fprintf(stderr, "Couldn't open file\n");
return false; //Couldn't open file
}
if(av_find_stream_info(pFormatCtx)<0){
fprintf(stderr, "Couldn't find stream information\n");
return false ; // Couldn't find stream information
}
//dump_format(pFormatCtx, 0, filename, 0); //输出视频信息到终端
int i;
for(i=0; i<pFormatCtx->nb_streams; i++){
if(pFormatCtx->streams[i]->codec->codec_type==CODEC_TYPE_VIDEO && videoStream < 0){
videoStream=i;
}
if(pFormatCtx->streams[i]->codec->codec_type==CODEC_TYPE_AUDIO && audioStream < 0){
audioStream=i;
}
}
if(audioStream==-1 && videoStream==-1){
closeVideo();
fprintf(stderr, "Didn't find a audio stream\n");
return false; // Didn't find a audio stream
}
if (videoStream != -1){
// Get a pointer to the codec context for the video stream
pCodecCtx=pFormatCtx->streams[videoStream]->codec;
// Find the decoder for the video stream
AVCodec *pCodec=avcodec_find_decoder(pCodecCtx->codec_id);
if(pCodec==NULL){
fprintf(stderr, "Unsupported codec!\n");
return false;
}
// Open codec
if(avcodec_open(pCodecCtx, pCodec)<0){
fprintf(stderr, "Could not open audio codec!\n");
return false;
}
curType = VideoType;
}else{
curType = AudioType;
}
if (audioStream != -1){
aCodecCtx = pFormatCtx->streams[audioStream]->codec;
AVCodec *aCodec = avcodec_find_decoder(aCodecCtx->codec_id);
if(!aCodec){
fprintf(stderr, "Unsupported codec!\n");
return false;
}
if(avcodec_open(aCodecCtx, aCodec)<0){
fprintf(stderr, "Could not open video codec!\n");
return false; // Could not open video codec
}
}
totaltime = pFormatCtx->duration;
return true;
}
void VideoPlayer::closeVideo()
{
if (aCodecCtx != NULL){
avcodec_close(aCodecCtx);
}
if (pFormatCtx != NULL){
av_close_input_file(pFormatCtx);
}
aCodecCtx = NULL;
pFormatCtx = NULL;
curType = NoneType;
}
bool VideoPlayer::openSDL()
{
if (aCodecCtx == NULL){
return false;
}
SDL_LockAudio();
SDL_AudioSpec spec;
SDL_AudioSpec wanted_spec;
wanted_spec.freq = aCodecCtx->sample_rate;
wanted_spec.format = AUDIO_S16SYS;
wanted_spec.channels = aCodecCtx->channels;
wanted_spec.silence = 0;
wanted_spec.samples = 1024;//SDL_AUDIO_BUFFER_SIZE;
wanted_spec.callback = audio_callback;
wanted_spec.userdata = aCodecCtx;
if(SDL_OpenAudio(&wanted_spec, &spec) < 0){
fprintf(stderr, "SDL_OpenAudio: %s\n", SDL_GetError());
SDL_UnlockAudio();
return false;
}
SDL_UnlockAudio();
av_log(NULL,AV_LOG_INFO,"Open SDL \n");
SDL_PauseAudio(0);
return true;
}
bool VideoPlayer::closeSDL()
{
clearQuene();
SDL_LockAudio();
SDL_CloseAudio();
SDL_UnlockAudio();
return true;
}
void VideoPlayer::clearQuene()
{
packet_queue_clear(audioq);
}
void VideoPlayer::readPacket()
{
if (pFormatCtx == NULL) {
return;
}
SDL_LockMutex(mutex);
currenttime+=READ_PACKET_TIME_OUT;
if (currenttime >= nextPacket.dts){
if(nextPacket.stream_index == videoStream){
decodeVideoThread->setPacket(nextPacket);
decodeVideoThread->start();
}else if(nextPacket.stream_index==audioStream){
packet_queue_put(audioq, &nextPacket);
emit updateTime(currenttime);
}
if(av_read_frame(pFormatCtx, &nextPacket) < 0){//整个视频文件读取完毕
stop();
currenttime = totaltime;
emit updateTime(currenttime);
emit finished();
SDL_UnlockMutex(mutex);
return;
}
}
SDL_UnlockMutex(mutex);
}
void VideoPlayer::setSource(QString str)
{
stop();
char ch[1024];
strcpy(ch,(const char*)str.toLocal8Bit());
if (openVideo(ch)){
currenttime = 0;
av_read_frame(pFormatCtx, &nextPacket);
if (curType == VideoType){
decodeVideoThread->setAVCodecContext(pCodecCtx);
decodeVideoThread->setMutex(decodeVideoMutex);
}
} else {
fprintf(stderr,"open %s erro!\n",ch);
}
av_log(NULL,AV_LOG_INFO,"SetSource Succeed %s \n",str.toStdString().c_str());
}
void VideoPlayer::play()
{
if (isRunning()) {
return;
}
if (pFormatCtx != NULL){
openSDL();
start();
curState = PlayingState;
emit stateChanged(curState);
}
}
void VideoPlayer::pause()
{
if (eventloop == NULL) {
return;
}
eventloop->exit();
closeSDL();
curState = PausedState;
emit stateChanged(curState);
}
void VideoPlayer::stop()
{
if (eventloop == NULL) {
return;
}
eventloop->exit();
closeVideo();
closeSDL();
curState = StoppedState;
emit stateChanged(curState);
}
void VideoPlayer::seek(qint64 time)
{
SDL_LockMutex(mutex);
if (pFormatCtx != NULL){
clearQuene();
int stream_index;
if (videoStream >= 0) {
stream_index = videoStream;
}else if(audioStream >= 0) {
stream_index = audioStream;
}
if (time < pFormatCtx->start_time) {
time=pFormatCtx->start_time;
}
if (time > totaltime) {
time = totaltime;
}
int target= av_rescale_q(time, AV_TIME_BASE_Q,pFormatCtx->streams[stream_index]->time_base);
av_seek_frame(pFormatCtx,stream_index,target,8); //AV_TIME_BASE
currenttime = target;
do{
if(av_read_frame(pFormatCtx, &nextPacket)>=0){
if (nextPacket.dts>0){
currenttime = nextPacket.dts;
}else{
currenttime = nextPacket.pts - 10;
}
}
}while(0);
}
SDL_UnlockMutex(mutex);
emit updateTime(currenttime);
}
void VideoPlayer::setVolume(int value)
{
volume = value;
}
| [
"[email protected]"
] | |
01ec9e253d882f56e76cca2a2ba7fa9593976c64 | b1a9302e4b6e4a3e26b1dff4778c3de7fcb2bfaf | /DigitRecognition/src/MNISTDataReader.cpp | 66d39f2f66e4e10946b921aa0f182183b41583e7 | [] | no_license | Daemencer/CNN | 96f33a6aa0d4307a017a1a26ad26a33f0a0d32ee | 1620e670c973c0d54f57e53ae80a2f02ccfbc72e | refs/heads/master | 2021-01-19T11:58:37.319980 | 2017-05-12T14:38:44 | 2017-05-12T14:38:44 | 82,287,620 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,206 | cpp | #include "MNISTDataReader.h"
#include <fstream>
#include <sstream>
MNISTDataReader::MNISTDataReader(const char* filename):
DataReader(filename)
{
}
MNISTDataReader::~MNISTDataReader()
{
}
auto MNISTDataReader::GenerateData() -> void
{
// ignore the first line
std::string line;
std::getline(file, line);
// process the rest of the lines
while (std::getline(file, line))
{
unsigned int index = 0;
std::array<float, PIXEL_PER_IMAGE> image;
std::istringstream iss(line);
std::string token;
// get the value of the drawn number, first digit in the line
std::getline(iss, token, ',');
//unsigned int number = *(reinterpret_cast<const unsigned int *> (token.c_str()));
unsigned int number = std::stoul(token);
// get the 784 pixels values
while (std::getline(iss, token, ','))
{
//image[index] = *(reinterpret_cast<const float *> (token.c_str()));
image[index] = std::stof(token);
++index;
}
MNISTNumber mNumber(number, image);
m_images.push_back(mNumber);
index = 0;
}
}
auto MNISTNumber::_CreateOutput(unsigned int number) -> void
{
for (unsigned int i = 0; i < 10; ++i)
{
if (i == number)
output[i] = 1.0f;
else
output[i] = 0.0f;
}
} | [
"[email protected]"
] | |
be29c3448a68d8821081c1c7186ef8d49d764124 | 8e835b5510bb2756e57e9ea36d0814aed1484fd3 | /zesteDeSavoir/loop/cinErrorCorrection.cpp | fbba166ecb7925ebd7fe9889a6e6dfda837d9611 | [] | no_license | Simon-chevolleau/cppLearning | 14b7e254ac2234dd7d8a22289b2a3e7e261fd1c2 | 6cbe65b867433ed8d16d00e3206a32765d16b92f | refs/heads/master | 2020-12-20T05:23:58.203585 | 2020-02-15T17:41:24 | 2020-02-15T17:41:24 | 235,976,168 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 886 | cpp | #include <iostream>
int main()
{
std::cout << "Quel jour es-tu né ? ";
int jour { 0 };
// Comme std::cin >> jour renvoie false s'il y a eu une erreur, afin de rentrer dans la boucle, on prend la négation de l'expression avec !
while (!(std::cin >> jour))
{
std::cout << "Entrée invalide. Recommence." << std::endl;
std::cin.clear();
std::cin.ignore(255, '\n');
}
std::cout << "Quel mois es-tu né ? ";
int mois { 0 };
// Même version avec un do while.
do
{
if (std::cin.fail())
{
std::cout << "Entrée invalide. Recommence." << std::endl;
std::cin.clear();
std::cin.ignore(255, '\n');
}
} while (!(std::cin >> mois));
std::cout << "Tu es né le " << jour << "/" << mois << "." << std::endl;
return 0;
}
| [
"[email protected]"
] | |
b46ec08d746c430535dfd6d4d9b6b6f5f599f81d | 9f6545ea46538e40f3e062d7305b200d9b3d9079 | /Is_Protect.cpp | ee074fcaf79cd1840d1264de5cebd2685b38e9bb | [] | no_license | fengxs001/GGchessGui | 9fea3b4f56d8b36889fbbfbe27e09c045151d9b1 | 2fb8eab5b81de0c6257a29d5840213ac6ff647eb | refs/heads/master | 2023-03-20T23:33:20.453118 | 2018-05-02T10:46:38 | 2018-05-02T10:46:38 | null | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 13,362 | cpp | #include "stdafx.h"
#include "data.h"
#include "chess.h"
#include "Resource.h"
#include "pregen.h"
BOOL isPretectedd(position_t *pos, int side, int sqDst, int sqExcept){
//走子方是不是有棋子在保护sqDst;
if(side == WHITE){
//1, 是不是受相的保护
if(inBoard(sqDst) & IN_RXIANG){ //可能在红相的保护中
for(int sq = PieceListStart(pos,RXIANG); sq > 0x32; sq = NextPiece(pos,sq)){
if(sq != sqExcept && (GetDir(sq,sqDst) & DirXiang) && (pos->b256[(sq+sqDst)/2] == EMPTY)){
//还要看一下这个棋能不能走 Is_Can_Move_To_Eat(pos,from,to)
if(Is_Can_Move_To_Eat(pos,sq,sqDst)) return TRUE;
}
}
}
//1, 是不是受仕的保护
if(inBoard(sqDst) & IN_RSHI){
for(int sq = PieceListStart(pos,RSHI); sq > 0x32; sq = NextPiece(pos,sq)){
if(sq != sqExcept && (GetDir(sq,sqDst) & DirShi)){
if(Is_Can_Move_To_Eat(pos,sq,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
}
//2, 是不是受马的保护
for(int sq = PieceListStart(pos,RMA); sq > 0x32; sq = NextPiece(pos,sq)){
if(sq != sqExcept){
int m = horseLegTab(sqDst-sq+256);
if(m && !pos->b256[sq+m]){
if(Is_Can_Move_To_Eat(pos,sq,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
}
//3, 是不是受到兵,将,车,炮的保护
int tox = StoX(sqDst);
int toy = StoY(sqDst);
int tof = pos->wBitFiles[tox];
int tor = pos->wBitRanks[toy];
SlideMoveStruct *psmv;
// 上下
psmv = FileMove(toy,tof);
//得到上面第一个---------------------------------------------------
int tmp = psmv->RookCap[DUpLeft] + tox;
if(tmp != sqDst){
if(tmp != sqExcept){
if(pos->b256[tmp] == RCHE){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
else if(pos->b256[tmp] == RKING){
if(tmp+16 == sqDst && toy > 0x9){
//return TRUE;
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
}
//有了第一个才第二个
tmp = psmv->CannonCap[DUpLeft] + tox;
if(tmp != sqDst){
if(tmp != sqExcept){
if(pos->b256[tmp] == RPAO){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
}
}
//得到下面第一个---------------------------------------------------
tmp = psmv->RookCap[DLoRight] + tox;
if(tmp != sqDst){
if(tmp != sqExcept){
if(pos->b256[tmp] == RCHE){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
else if(pos->b256[tmp] == RKING){
if(tmp-16 == sqDst && toy > 0x9){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
else if(pos->b256[tmp] == RPAWN){
if(tmp-16 == sqDst){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
}
//有了第一个才第二个
tmp = psmv->CannonCap[DLoRight] + tox;
if(tmp != sqDst){
if(tmp != sqExcept){
if(pos->b256[tmp] == RPAO){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
}
}
//得到左面第一个---------------------------------------------------
psmv = RankMove(tox,tor);
int nDisp = sqDst & 0xf0;
tmp = psmv->RookCap[DUpLeft] + nDisp;
if(tmp != sqDst){
if(tmp != sqExcept){
if(pos->b256[tmp] == RCHE){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
else if(pos->b256[tmp] == RPAWN){
if(toy < 0x8 && tmp+1 == sqDst){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
else if(pos->b256[tmp] == RKING){
if((inBoard(sqDst) & IN_RKING) && tmp+1 == sqDst){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
}
//有了第一个才第二个
tmp = psmv->CannonCap[DUpLeft] + nDisp;
if(tmp != sqDst){
if(tmp != sqExcept){
if(pos->b256[tmp] == RPAO){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
}
}
//得到右面第一个---------------------------------------------------
tmp = psmv->RookCap[DLoRight] + nDisp;
if(tmp != sqDst){
if(tmp != sqExcept){
if(pos->b256[tmp] == RCHE){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
else if(pos->b256[tmp] == RPAWN){
if(toy < 0x8 && tmp-1 == sqDst){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
else if(pos->b256[tmp] == RKING){
if((inBoard(sqDst) & IN_RKING) && tmp-1 == sqDst){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
}
//有了第一个才第二个
tmp = psmv->CannonCap[DLoRight] + nDisp;
if(tmp != sqDst){
if(tmp != sqExcept){
if(pos->b256[tmp] == RPAO){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
}
}
}
/////////////////////////////////////////////以下是判断黑方有没有保护棋子
else{
//1, 是不是受象的保护
if(inBoard(sqDst) & IN_BXIANG){ //可能在黑象的保护中
for(int sq = PieceListStart(pos,BXIANG); sq > 0x32; sq = NextPiece(pos,sq)){
if(sq != sqExcept && (GetDir(sq,sqDst) & DirXiang) && (pos->b256[(sq+sqDst)/2] == EMPTY)){
if(Is_Can_Move_To_Eat(pos,sq,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
}
//1, 是不是受仕的保护
if(inBoard(sqDst) & IN_BSHI){
for(int sq = PieceListStart(pos,BSHI); sq > 0x32; sq = NextPiece(pos,sq)){
if(sq != sqExcept && (GetDir(sq,sqDst) & DirShi)){
if(Is_Can_Move_To_Eat(pos,sq,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
}
//2, 是不是受马的保护
for(int sq = PieceListStart(pos,BMA); sq > 0x32; sq = NextPiece(pos,sq)){
if(sq != sqExcept){
int m = horseLegTab(sqDst-sq+256);
if(m && !pos->b256[sq+m]){
if(Is_Can_Move_To_Eat(pos,sq,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
}
//3, 是不是受到兵,将,车,炮的保护
int tox = StoX(sqDst);
int toy = StoY(sqDst);
int tof = pos->wBitFiles[tox];
int tor = pos->wBitRanks[toy];
SlideMoveStruct *psmv;
// 上下
psmv = FileMove(toy,tof);
//得到上面第一个---------------------------------------------------
int tmp = psmv->RookCap[DUpLeft] + tox;
if(tmp != sqDst){
if(tmp != sqExcept){
if(pos->b256[tmp] == BCHE){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
else if(pos->b256[tmp] == BKING){
if(tmp+16 == sqDst && toy < 0x6){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
else if(pos->b256[tmp] == BPAWN){
if(tmp+16 == sqDst){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
}
//有了第一个才第二个
tmp = psmv->CannonCap[DUpLeft] + tox;
if(tmp != sqDst){
if(tmp != sqExcept){
if(pos->b256[tmp] == BPAO){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
}
}
//得到下面第一个---------------------------------------------------
tmp = psmv->RookCap[DLoRight] + tox;
if(tmp != sqDst){
if(tmp != sqExcept){
if(pos->b256[tmp] == BCHE){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
else if(pos->b256[tmp] == BKING){
if(tmp-16 == sqDst && toy < 0x6){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
}
//有了第一个才第二个
tmp = psmv->CannonCap[DLoRight] + tox;
if(tmp != sqDst){
if(tmp != sqExcept){
if(pos->b256[tmp] == BPAO){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
}
}
//得到左面第一个---------------------------------------------------
psmv = RankMove(tox,tor);
int nDisp = sqDst & 0xf0;
tmp = psmv->RookCap[DUpLeft] + nDisp;
if(tmp != sqDst){
if(tmp != sqExcept){
if(pos->b256[tmp] == BCHE){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
else if(pos->b256[tmp] == BPAWN){
if(toy > 0x7 && tmp+1 == sqDst){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
else if(pos->b256[tmp] == BKING){
if((inBoard(sqDst) & IN_BKING) && tmp+1 == sqDst){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
}
//有了第一个才第二个
tmp = psmv->CannonCap[DUpLeft] + nDisp;
if(tmp != sqDst){
if(tmp != sqExcept){
if(pos->b256[tmp] == BPAO){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
}
}
//得到右面第一个---------------------------------------------------
tmp = psmv->RookCap[DLoRight] + nDisp;
if(tmp != sqDst){
if(tmp != sqExcept){
if(pos->b256[tmp] == BCHE){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
else if(pos->b256[tmp] == BPAWN){
if(toy > 0x7 && tmp-1 == sqDst){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
else if(pos->b256[tmp] == BKING){
if((inBoard(sqDst) & IN_BKING) && tmp-1 == sqDst){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
}
//有了第一个才第二个
tmp = psmv->CannonCap[DLoRight] + nDisp;
if(tmp != sqDst){
if(tmp != sqExcept){
if(pos->b256[tmp] == BPAO){
if(Is_Can_Move_To_Eat(pos,tmp,sqDst)) return TRUE; //还要看一下这个棋能不能走
}
}
}
}
}
return FALSE;
}
//上次这个子是不是提供了保护.
BOOL isCanProtect_Last_Move(position_t *pos, int side, int from, int to){
//if(side == WHITE){
// int pc = pos->b256[protect];
// if(IsBlack(pc)) return false;
// switch(pc){
// }
//}
//else{
//}
int piece = pos->b256[from];
if(COLOR(piece) != side) return FALSE;
int tmp;
switch(piece){
case RMA:
case BMA:
tmp = horseLegTab(to-from+256);
return tmp != 0 && pos->b256[from + tmp] == 0;
break;
case RXIANG:
case BXIANG:
//return ccLegalMoveTab[nDst256 - nSrc256 + 256] == 3 && board->P256[(nSrc256 + nDst256) / 2] == 0;
return (GetDir(from,to) & DirXiang) && pos->b256[(from+to)/2] == 0;
break;
case BSHI:
case RSHI:
return (GetDir(from,to) & DirShi) != 0;
break;
case RCHE:
case BCHE:
{
int x = StoX(from);
int y = StoY(from);
if(x == StoX(to)){
//if(cap == EMPTY){
// return (FileMask(y,board->wBitFiles[x])->NonCap & yBitMask(to)) != 0;
//}
//else{
return (FileMask(y,pos->wBitFiles[x])->RookCap & yBitMask(to)) != 0;
//}
}
else if(y == StoY(to)){
//if(cap == EMPTY){
// return (RankMask(x,board->wBitRanks[y])->NonCap & xBitMask(to)) != 0;
//}
//else{
return (RankMask(x,pos->wBitRanks[y])->RookCap & xBitMask(to)) != 0;
//}
}
}
break;
case RPAO:
case BPAO:
{
int x = StoX(from);
int y = StoY(from);
if(x == StoX(to)){
//if(cap == EMPTY){
// return (FileMask(y,board->wBitFiles[x])->NonCap & yBitMask(to)) != 0;
//}
//else{
return (FileMask(y,pos->wBitFiles[x])->CannonCap & yBitMask(to)) != 0;
//}
}
else if(y == StoY(to)){
//if(cap == EMPTY){
// return (RankMask(x,board->wBitRanks[y])->NonCap & xBitMask(to)) != 0;
//}
//else{
return (RankMask(x,pos->wBitRanks[y])->CannonCap & xBitMask(to)) != 0;
//}
}
}
break;
case RPAWN:
return to == from - 16 || ((to & 0x80) == 0 && (to == from - 1 || to == from + 1));
break;
case BPAWN:
return to == from + 16 || ((to & 0x80) != 0 && (to == from - 1 || to == from + 1));
break;
case RKING:
case BKING:
return (GetDir(from,to) & DirKing) != 0;
break;
default:
return FALSE;
break;
}
return FALSE;
} | [
"[email protected]"
] | |
6cb9f784d044396bdbe9b7bc2d38a7aa395f9f72 | 1fe2d21b56b90ea6f409f1e0556a52c83cf1ed7a | /Solved/UVA/@UVA 11286 - Conformity/11286 - Conformity.cpp | da5950ac963b2f556586d7b0f7b7daa0d233ffd4 | [] | no_license | gilbertoalexsantos/judgesolutions | 447456736cef55d3c376a552a3341362f5739cef | e99fad49098eeb0ae0ae649068ddea8162705802 | refs/heads/master | 2021-01-17T02:01:21.702416 | 2018-04-19T02:19:34 | 2018-04-19T02:19:34 | 28,620,429 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 853 | cpp | //Author: Gilberto A. dos Santos
//Website: http://uva.onlinejudge.org/index.php?option=onlinejudge&page=show_problem&problem=2261
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <string>
#include <vector>
#include <algorithm>
#include <ios>
#include <map>
using namespace std;
int n;
int main() {
ios::sync_with_stdio(false);
while(cin >> n && n) {
map<string,int> m;
int ans = 0;
int high = 1;
for(int i = 0; i < n; i++) {
vector<string> temp(5);
for(int j = 0; j < 5; j++) cin >> temp[j];
sort(temp.begin(),temp.end());
string conc = "";
for(int j = 0; j < 5; j++) conc += temp[j];
if(m[conc]) {
int r = ++m[conc];
if(r > high) {
high = r;
ans = high;
} else if(r == high) ans += high;
} else {
m[conc] = 1;
if(high == 1) ans++;
}
}
cout << ans << endl;
}
}
| [
"[email protected]"
] | |
9d2f7ecc10d3252010c3e7f6f23e287164f35036 | 8b9cc79ddcc9a7f6448b637802d1d3403cf15481 | /chapter_4/5-structed-CandyBar.cpp | f47d3adc94c03acee01abfadd3dcf0ca6273b1ae | [] | no_license | Carrie2001/c_Primer_Plus_exercise | 1d2172361bf998ac9dd0e9e2f65d24ce745ad16e | 6cd42c3b896e7e42ae4245e562dbf5b8c4429d3b | refs/heads/master | 2021-10-19T20:05:15.637326 | 2019-02-23T10:45:52 | 2019-02-23T10:45:52 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 552 | cpp | // 声明结构体 CandyBar
// 创建于 2019/01/19
#include <iostream>
#include <string>
int main()
{
using namespace std;
struct CandyBar // 声明结构体CandyBar
{
string brand;
float weight;
int calories;
};
CandyBar snack = {"Mocha Munch", 2.3, 350}; // 创建snack的CandyBar变量
cout << "the brand name is "
<< snack.brand
<< endl
<< "the weight is "
<< snack.weight
<< endl
<< "the calories are "
<< snack.calories;
return 0;
} | [
"[email protected]"
] | |
a040093bb4f63d37f2afd0147357e6cbf131c94d | 095f3757910952a4bb9a25de78076c80c51f377c | /soyoung/173. L3_가장 먼 노드.cpp | e2a82ee8f4f11c568e30a698479db23013768d02 | [] | no_license | soyoung47/study_coding_w-LSY | 7a565333dc07db3663fb725a37f338f0a796c005 | d79d0328169db75d2951dfdae1a37a01bc0ea2b4 | refs/heads/master | 2023-04-09T13:37:49.417347 | 2021-04-22T12:36:46 | 2021-04-22T12:36:46 | 263,019,759 | 0 | 0 | null | 2021-01-28T11:32:49 | 2020-05-11T11:13:08 | C++ | UHC | C++ | false | false | 1,258 | cpp | //https://programmers.co.kr/learn/courses/30/lessons/49189
#include <vector>
#include <queue>
#include <unordered_map>
using namespace std;
int solution(int n, vector<vector<int>> edge) {
//간선 저장
vector<vector<int>> map(n + 1, vector<int>(n + 1, 0));
for (int i = 0; i < edge.size(); i++)
{
map[edge[i][0]][edge[i][1]] = 1;
map[edge[i][1]][edge[i][0]] = 1;
}
vector<bool> visit(n + 1, false);
vector<int> dist(n + 1, 0);
queue<int> q;
visit[1] = true;
q.push(1); //1번 노드로부터
while (!q.empty())
{
int start = q.front();
q.pop();
for (int end = 1; end <= n; end++)
{
if (map[start][end] == 1 && (!visit[end] || dist[end] > dist[start] + 1))
{
dist[end] = dist[start] + 1;
visit[end] = true;
q.push(end);
}
}
}
//최대 거리를 가지는 노드의 개수
unordered_map<int, int> m;
int max = 0;
for (int d : dist)
{
m[d]++;
max = max > d ? max : d;
}
return m[max];
}
//vist(bool) 대신 dist(int)를 초기값 -1로 설정해서 사용 가능
//https://blog.naver.com/lhaayyy/221890252574 | [
"[email protected]"
] | |
467c847905f6e3165238b8ba5fa20c455089925b | 11211916f39b9d98027b64d778e52743d0c519a1 | /L3/code/download/musicphotos/assignments/tmp/system/admin/design/bang.cpp | fc8e7a35bbf264cd304b277d8428a051de8e53d2 | [] | no_license | mantasruigys3000/Group-Task | 87baf1bc2747323c0508f6f32ef733c3f4b50978 | 6790d74ae7fa0fe6b13733efcd75a9f4aca70ab0 | refs/heads/master | 2020-04-23T20:54:09.696659 | 2019-02-22T01:29:53 | 2019-02-22T01:29:53 | 171,454,102 | 0 | 0 | null | 2019-02-19T10:31:09 | 2019-02-19T10:31:08 | null | UTF-8 | C++ | false | false | 105 | cpp | Quaerat quiquia dolore quisquam sed eius ut.
Username: Frank
Password: kenzie
Quisquam ut amet adipisci.
| [
"[email protected]"
] | |
fcfe19a8fdae98bc128a0b9f74f42c3b8454543a | 8570179a4523d9deb116936aa647e5d13cfb6b8e | /Plane.cpp | 8d773868cfb12116b29bb8ed0d1b6983014da1ff | [] | no_license | CelAria/RayTraceYourLifeAway- | f49f91d578ba99df245084436493b3554e5927c9 | 50309f35232bf6c04c1072fd74a13765270117ef | refs/heads/master | 2020-03-20T20:30:16.833427 | 2018-06-18T20:06:24 | 2018-06-18T20:06:24 | 137,690,510 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 887 | cpp | #include "stdafx.h"
#include "Ray.h"
#include "Intersection.h"
#include "Plane.h"
Plane::Plane(glm::vec3 normal, glm::vec3 position, glm::vec3 ambient, glm::vec3 diffuse, glm::vec3 specular, float shininess) {
nor = normal;
pos = position;
amb = ambient;
dif = diffuse;
spec = specular;
shi = shininess;
}
//test for intersection with ray
Intersection Plane::testIntersection(Ray myray) {
//normalize value for normal
normalize(nor);
float denom;
//MIGHT BE PROBLEMS HERE with the cast
denom= glm::dot(glm::vec3(nor), glm::vec3(myray.dir));
//if denominator is smaller than a very small value
if (denom > 1e-6) {
//need to find P0 properly
glm::vec3 p0l0 = pos -myray.pos;
float t = glm::dot(p0l0, nor) / denom;
//return point of intersection and normal
return Intersection((myray.pos + t * myray.dir), nor);
}
return Intersection();
}
| [
"[email protected]"
] | |
c376aec70dd565d17bed588991520975fe58b9fb | bf879d259f4e9a46e95b1c86eb7e26dbc4e47c5f | /udpclient.h | 85cb497b4e26bdf890639212e09230d080770493 | [] | no_license | wh230308/RemoteControlAndMonitorSystem | c848f206758624c0deea649d8d382975e7ae3c28 | 2a62ccef315f984bba6737e0848a529c68256760 | refs/heads/master | 2020-04-13T19:00:21.672053 | 2018-12-28T06:16:56 | 2018-12-28T06:16:56 | 163,390,504 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,267 | h | #ifndef UDPCLIENT_H
#define UDPCLIENT_H
#include <QObject>
#include <QUdpSocket>
#include <QHostAddress>
class QNetworkDatagram;
class QTimer;
class UdpClient : public QObject
{
Q_OBJECT
enum
{
HeartBeatTimerInterval = 5000 // 与服务器心跳保活定时器周期
};
public:
explicit UdpClient(QObject *parent = nullptr);
~UdpClient();
public:
bool initSock(const QString &svrIp, ushort port, const QString &localIp, ushort localport);
void uinitSock();
bool sendPacket(const char *data, int size);
bool sendPacket(const QNetworkDatagram &datagram);
void getSvrAddr(QString &svrIp, ushort &svrPort_) const;
bool updateSvrAddr(const QString &svrIp, ushort svrPort_);
signals:
void heartbeatTimeout();
void reportMainCardState(char deviceId, char mpuFlag, char state);
void reportUserCardState(char deviceId, char slotIndex, char type, char state);
void reportCWPState(char seatId, char seatState, const QByteArray &userName,
const QByteArray &leftPhone, const QByteArray &rightPhone,
const QByteArray &userRoles);
void reportDeviceInfo(char deviceId, char deviceType, const QByteArray &deviceName);
void reportEthPortsState(char deviceId, char mpuFlag, char port1State, char port2State);
void reportUserCardPortState(char deviceId, char slotIndex, char portId, char type, char state);
public slots:
void onSendHeartbeat();
void readPendingDatagrams();
private:
void processTheDatagram(const QNetworkDatagram &datagram);
void processHeartbeatPkt(const QByteArray &byteArray);
void processMainCardStatePkt(const QByteArray &byteArray);
void processUserCardStatePkt(const QByteArray &byteArray);
void processCWPIntoPkt(const QByteArray &byteArray);
void processDeviceInfoPkt(const QByteArray &byteArray);
void processEthPortsStatePkt(const QByteArray &byteArray);
void processUserCardPortStatePkt(const QByteArray &byteArray);
void replyPkt(const QNetworkDatagram &datagram);
private:
QUdpSocket localSock_;
QHostAddress svrIp_;
ushort svrPort_ = 0;
QTimer *heartbeatTimer_ = nullptr;
int heartbeatPktCount_ = 0;
bool isFirstHeartbeatPkt_ = true;
};
#endif // UDPCLIENT_H
| [
"[email protected]"
] | |
d33f7a9088ab73939a5ae03df56ba58f71dc7b74 | c0574410257324c87221dddc8e9ae45906f53d8e | /library/src/auxiliary/rocauxiliary_ormql_unmql.hpp | c0b8516e48b6889c51f6fd601616e0beed78f35f | [
"BSD-3-Clause",
"BSD-3-Clause-Open-MPI",
"BSD-2-Clause"
] | permissive | jzuniga-amd/rocSOLVER | 35ddfd2d4352628fe538c8dcec1d0423a31776c8 | 1361711f95270872c4ce55ae4dceaaccafc6c8b6 | refs/heads/develop | 2023-08-31T16:04:47.507044 | 2023-08-02T00:08:51 | 2023-08-02T00:08:51 | 198,918,601 | 0 | 2 | BSD-2-Clause | 2019-08-30T20:05:37 | 2019-07-26T00:27:44 | C++ | UTF-8 | C++ | false | false | 6,520 | hpp | /************************************************************************
* Derived from the BSD3-licensed
* LAPACK routine (version 3.7.0) --
* Univ. of Tennessee, Univ. of California Berkeley,
* Univ. of Colorado Denver and NAG Ltd..
* December 2016
* Copyright (c) 2019-2022 Advanced Micro Devices, Inc.
* ***********************************************************************/
#pragma once
#include "rocauxiliary_larfb.hpp"
#include "rocauxiliary_larft.hpp"
#include "rocauxiliary_orm2l_unm2l.hpp"
#include "rocblas.hpp"
#include "rocsolver/rocsolver.h"
template <bool BATCHED, typename T>
void rocsolver_ormql_unmql_getMemorySize(const rocblas_side side,
const rocblas_int m,
const rocblas_int n,
const rocblas_int k,
const rocblas_int batch_count,
size_t* size_scalars,
size_t* size_AbyxORwork,
size_t* size_diagORtmptr,
size_t* size_trfact,
size_t* size_workArr)
{
// if quick return no workspace needed
if(m == 0 || n == 0 || k == 0 || batch_count == 0)
{
*size_scalars = 0;
*size_AbyxORwork = 0;
*size_diagORtmptr = 0;
*size_trfact = 0;
*size_workArr = 0;
return;
}
size_t unused;
rocsolver_orm2l_unm2l_getMemorySize<BATCHED, T>(side, m, n, k, batch_count, size_scalars,
size_AbyxORwork, size_diagORtmptr, size_workArr);
if(k > xxMQx_BLOCKSIZE)
{
rocblas_int jb = xxMQx_BLOCKSIZE;
// requirements for calling larft
rocsolver_larft_getMemorySize<BATCHED, T>(max(m, n), min(jb, k), batch_count, &unused,
size_AbyxORwork, &unused);
// requirements for calling larfb
rocsolver_larfb_getMemorySize<BATCHED, T>(side, m, n, min(jb, k), batch_count,
size_diagORtmptr, &unused);
// size of temporary array for triangular factor
*size_trfact = sizeof(T) * jb * jb * batch_count;
}
else
*size_trfact = 0;
}
template <bool BATCHED, bool STRIDED, typename T, typename U>
rocblas_status rocsolver_ormql_unmql_template(rocblas_handle handle,
const rocblas_side side,
const rocblas_operation trans,
const rocblas_int m,
const rocblas_int n,
const rocblas_int k,
U A,
const rocblas_int shiftA,
const rocblas_int lda,
const rocblas_stride strideA,
T* ipiv,
const rocblas_stride strideP,
U C,
const rocblas_int shiftC,
const rocblas_int ldc,
const rocblas_stride strideC,
const rocblas_int batch_count,
T* scalars,
T* AbyxORwork,
T* diagORtmptr,
T* trfact,
T** workArr)
{
ROCSOLVER_ENTER("ormql_unmql", "side:", side, "trans:", trans, "m:", m, "n:", n, "k:", k,
"shiftA:", shiftA, "lda:", lda, "shiftC:", shiftC, "ldc:", ldc,
"bc:", batch_count);
// quick return
if(!n || !m || !k || !batch_count)
return rocblas_status_success;
hipStream_t stream;
rocblas_get_stream(handle, &stream);
// if the matrix is small, use the unblocked variant of the algorithm
if(k <= xxMQx_BLOCKSIZE)
return rocsolver_orm2l_unm2l_template<T>(
handle, side, trans, m, n, k, A, shiftA, lda, strideA, ipiv, strideP, C, shiftC, ldc,
strideC, batch_count, scalars, AbyxORwork, diagORtmptr, workArr);
rocblas_int ldw = xxMQx_BLOCKSIZE;
rocblas_stride strideW = rocblas_stride(ldw) * ldw;
// determine limits and indices
bool left = (side == rocblas_side_left);
bool transpose = (trans != rocblas_operation_none);
rocblas_int start, step, nq, ncol, nrow;
if(left)
{
nq = m;
ncol = n;
if(!transpose)
{
start = 0;
step = 1;
}
else
{
start = (k - 1) / ldw * ldw;
step = -1;
}
}
else
{
nq = n;
nrow = m;
if(!transpose)
{
start = (k - 1) / ldw * ldw;
step = -1;
}
else
{
start = 0;
step = 1;
}
}
rocblas_int i, ib;
for(rocblas_int j = 0; j < k; j += ldw)
{
i = start + step * j; // current householder block
ib = min(ldw, k - i);
if(left)
{
nrow = m - k + i + ib;
}
else
{
ncol = n - k + i + ib;
}
// generate triangular factor of current block reflector
rocsolver_larft_template<T>(handle, rocblas_backward_direction, rocblas_column_wise,
nq - k + i + ib, ib, A, shiftA + idx2D(0, i, lda), lda, strideA,
ipiv + i, strideP, trfact, ldw, strideW, batch_count, scalars,
AbyxORwork, workArr);
// apply current block reflector
rocsolver_larfb_template<BATCHED, STRIDED, T>(
handle, side, trans, rocblas_backward_direction, rocblas_column_wise, nrow, ncol, ib, A,
shiftA + idx2D(0, i, lda), lda, strideA, trfact, 0, ldw, strideW, C, shiftC, ldc,
strideC, batch_count, diagORtmptr, workArr);
}
return rocblas_status_success;
}
| [
"[email protected]"
] | |
a12ac18d5bac6788dda7bc4839e46ca9a6214e4f | 184180d341d2928ab7c5a626d94f2a9863726c65 | /issuestests/CGGP/inst/testfiles/rcpp_fastmatclcranddclcr/libFuzzer_rcpp_fastmatclcranddclcr/rcpp_fastmatclcranddclcr_DeepState_TestHarness.cpp | 80458b191f1c469598323334d97282ab89d35cc6 | [] | no_license | akhikolla/RcppDeepStateTest | f102ddf03a22b0fc05e02239d53405c8977cbc2b | 97e73fe4f8cb0f8e5415f52a2474c8bc322bbbe5 | refs/heads/master | 2023-03-03T12:19:31.725234 | 2021-02-12T21:50:12 | 2021-02-12T21:50:12 | 254,214,504 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 4,165 | cpp | // AUTOMATICALLY GENERATED BY RCPPDEEPSTATE PLEASE DO NOT EDIT BY HAND, INSTEAD EDIT
// rcpp_fastmatclcranddclcr_DeepState_TestHarness_generation.cpp and rcpp_fastmatclcranddclcr_DeepState_TestHarness_checks.cpp
#include <fstream>
#include <RInside.h>
#include <iostream>
#include <RcppDeepState.h>
#include <qs.h>
#include <DeepState.hpp>
void rcpp_fastmatclcranddclcr(NumericMatrix I, NumericVector w, NumericMatrix MSEmat, NumericMatrix dMSEmat, NumericVector S, NumericMatrix dS, int maxlevel, int numpara);
TEST(CGGP_deepstate_test,rcpp_fastmatclcranddclcr_test){
static int rinside_flag = 0;
if(rinside_flag == 0)
{
rinside_flag = 1;
RInside R;
} std::time_t current_timestamp = std::time(0);
std::cout << "input starts" << std::endl;
NumericMatrix I = RcppDeepState_NumericMatrix();
std::string I_t = "/home/akhila/fuzzer_packages/fuzzedpackages/CGGP/inst/testfiles/rcpp_fastmatclcranddclcr/libFuzzer_rcpp_fastmatclcranddclcr/libfuzzer_inputs/" + std::to_string(current_timestamp) +
"_I.qs";
qs::c_qsave(I,I_t,
"high", "zstd", 1, 15, true, 1);
std::cout << "I values: "<< I << std::endl;
NumericVector w = RcppDeepState_NumericVector();
std::string w_t = "/home/akhila/fuzzer_packages/fuzzedpackages/CGGP/inst/testfiles/rcpp_fastmatclcranddclcr/libFuzzer_rcpp_fastmatclcranddclcr/libfuzzer_inputs/" + std::to_string(current_timestamp) +
"_w.qs";
qs::c_qsave(w,w_t,
"high", "zstd", 1, 15, true, 1);
std::cout << "w values: "<< w << std::endl;
NumericMatrix MSEmat = RcppDeepState_NumericMatrix();
std::string MSEmat_t = "/home/akhila/fuzzer_packages/fuzzedpackages/CGGP/inst/testfiles/rcpp_fastmatclcranddclcr/libFuzzer_rcpp_fastmatclcranddclcr/libfuzzer_inputs/" + std::to_string(current_timestamp) +
"_MSEmat.qs";
qs::c_qsave(MSEmat,MSEmat_t,
"high", "zstd", 1, 15, true, 1);
std::cout << "MSEmat values: "<< MSEmat << std::endl;
NumericMatrix dMSEmat = RcppDeepState_NumericMatrix();
std::string dMSEmat_t = "/home/akhila/fuzzer_packages/fuzzedpackages/CGGP/inst/testfiles/rcpp_fastmatclcranddclcr/libFuzzer_rcpp_fastmatclcranddclcr/libfuzzer_inputs/" + std::to_string(current_timestamp) +
"_dMSEmat.qs";
qs::c_qsave(dMSEmat,dMSEmat_t,
"high", "zstd", 1, 15, true, 1);
std::cout << "dMSEmat values: "<< dMSEmat << std::endl;
NumericVector S = RcppDeepState_NumericVector();
std::string S_t = "/home/akhila/fuzzer_packages/fuzzedpackages/CGGP/inst/testfiles/rcpp_fastmatclcranddclcr/libFuzzer_rcpp_fastmatclcranddclcr/libfuzzer_inputs/" + std::to_string(current_timestamp) +
"_S.qs";
qs::c_qsave(S,S_t,
"high", "zstd", 1, 15, true, 1);
std::cout << "S values: "<< S << std::endl;
NumericMatrix dS = RcppDeepState_NumericMatrix();
std::string dS_t = "/home/akhila/fuzzer_packages/fuzzedpackages/CGGP/inst/testfiles/rcpp_fastmatclcranddclcr/libFuzzer_rcpp_fastmatclcranddclcr/libfuzzer_inputs/" + std::to_string(current_timestamp) +
"_dS.qs";
qs::c_qsave(dS,dS_t,
"high", "zstd", 1, 15, true, 1);
std::cout << "dS values: "<< dS << std::endl;
IntegerVector maxlevel(1);
maxlevel[0] = RcppDeepState_int();
std::string maxlevel_t = "/home/akhila/fuzzer_packages/fuzzedpackages/CGGP/inst/testfiles/rcpp_fastmatclcranddclcr/libFuzzer_rcpp_fastmatclcranddclcr/libfuzzer_inputs/" + std::to_string(current_timestamp) +
"_maxlevel.qs";
qs::c_qsave(maxlevel,maxlevel_t,
"high", "zstd", 1, 15, true, 1);
std::cout << "maxlevel values: "<< maxlevel << std::endl;
IntegerVector numpara(1);
numpara[0] = RcppDeepState_int();
std::string numpara_t = "/home/akhila/fuzzer_packages/fuzzedpackages/CGGP/inst/testfiles/rcpp_fastmatclcranddclcr/libFuzzer_rcpp_fastmatclcranddclcr/libfuzzer_inputs/" + std::to_string(current_timestamp) +
"_numpara.qs";
qs::c_qsave(numpara,numpara_t,
"high", "zstd", 1, 15, true, 1);
std::cout << "numpara values: "<< numpara << std::endl;
std::cout << "input ends" << std::endl;
try{
rcpp_fastmatclcranddclcr(I,w,MSEmat,dMSEmat,S,dS,maxlevel[0],numpara[0]);
}
catch(Rcpp::exception& e){
std::cout<<"Exception Handled"<<std::endl;
}
}
| [
"[email protected]"
] | |
39eeac610b9ac2d46faf6965e8aca4391be462c8 | d956e1eac80a0b739e650eac4eaded3d06027b26 | /CXLMBG.h | d7875b9117d4b024889c68134501a239f3eebb05 | [] | no_license | Justliangzhu/gitskills | b42457126a945986bad62b84bc9cb21382efb10d | 957e796bcf5cffa1c6171a1acb1393d38930711f | refs/heads/master | 2023-05-30T22:57:30.523134 | 2021-06-22T02:12:50 | 2021-06-22T02:12:50 | 377,092,494 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,679 | h | #if !defined(AFX_CXLMBG_H__3C8F2C04_B128_48BC_809C_9803953776EF__INCLUDED_)
#define AFX_CXLMBG_H__3C8F2C04_B128_48BC_809C_9803953776EF__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// CXLMBG.h : header file
//
#include "XLDataBase.h"
#include "resource.h"
/////////////////////////////////////////////////////////////////////////////
// CCXLMBG dialog
class CCXLMBG : public CDialog
{
// Construction
public:
CCXLMBG(CWnd* pParent = acedGetAcadFrame()); // standard constructor
JD_CENTER *pm1;
JD_CENTER *pm2;
XLDataBase DBS;
CString mdbname,RoadName,HxBh;
// Dialog Data
//{{AFX_DATA(CCXLMBG)
enum { IDD = IDD_DIALOG_CXLMBG };
CString m_lmbgxzb;
CString m_lmbgyzb;
CString m_desh1;
CString m_desh2;
CString m_dist1;
CString m_dist2;
CString m_lmbg1;
CString m_lmbg2;
CString m_lmbgc;
CString m_lmhp1;
CString m_lmhp2;
CString m_prjckml1;
CString m_prjckml2;
CString m_xl1;
CString m_xl2;
//}}AFX_DATA
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CCXLMBG)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
//}}AFX_VIRTUAL
// Implementation
protected:
// Generated message map functions
//{{AFX_MSG(CCXLMBG)
afx_msg void OnBUTTONLMBGPickPT();
afx_msg void OnButtonPickxl1();
afx_msg void OnButtonPickxl2();
virtual BOOL OnInitDialog();
virtual void OnOK();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
public:
afx_msg void OnBnClickedOk();
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_CXLMBG_H__3C8F2C04_B128_48BC_809C_9803953776EF__INCLUDED_)
| [
"[email protected]"
] | |
c7be08994ce936ff984584191119a436cebaac9d | df81135b7711691086abe2832bc97377d905c8e9 | /2016.02.22 TrailGame/DirectX3D_Framework_1.4/cGameObjectManager.cpp | 5c871ded84b01b5ba271a3a36ed66994099e02e1 | [] | no_license | kwansu/3DEngineProgramming_Practice | b52b806e569cec4457701308dd2390ce2670b537 | 26d43c251b7e9f810784dffb19ff0bfd19419d49 | refs/heads/master | 2023-04-21T16:54:10.951063 | 2021-05-17T06:32:15 | 2021-05-17T06:32:15 | 368,079,698 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 3,859 | cpp | #include "stdafx.h"
#include "cGameObjectManager.h"
cGameObjectManager* g_pGameObjects = cGameObjectManager::GetInstance();
cGameObjectManager::cGameObjectManager()
: m_pGrid(NULL)
, m_isDrag(false)
, m_isEdit(false)
, m_pPickObjec(NULL)
, m_pPlayer(NULL)
{
}
cGameObjectManager::~cGameObjectManager()
{
}
void cGameObjectManager::Setup()
{
g_pInput->SetProcessor(this);
g_pCamera->Setup();
m_pGrid = new cGrid;
m_pGrid->Setup();
// 오브젝트 생성
cGameObject* pPlane = new cObj_Plane;
pPlane->Setup();
m_vecpGameObjects.push_back(pPlane);
cObj_Player* pObject = new cObj_Player;
pObject->Setup();
m_pPlayer = pObject;
m_vecpGameObjects.push_back(pObject);
//cObj_Enemy* pObject2 = new cObj_Enemy;
//pObject2->Setup();
//pObject2->SetTarget(pObject);
//m_vecpGameObjects.push_back(pObject2);
// light Setup
ZeroMemory(&m_light, sizeof(D3DLIGHT9));
m_light.Type = D3DLIGHT_DIRECTIONAL;
m_light.Diffuse = m_light.Ambient = D3DXCOLOR(1, 1, 1, 1);
m_light.Direction = D3DXVECTOR3(-0.7, -1, 0.5f);
g_pDevice->SetLight(0, &m_light);
g_pDevice->LightEnable(0, true);
g_pDevice->SetRenderState(D3DRS_LIGHTING, true);
g_pDevice->SetRenderState(D3DRS_NORMALIZENORMALS, true);
//g_pDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);
}
void cGameObjectManager::Release()
{
for each (cGameObject* pObj in m_vecpGameObjects)
{
SafeDelete(pObj);
}
SafeDelete(m_pGrid);
}
void cGameObjectManager::Update()
{
g_pCamera->Update();
if (m_isPlay)
{
for (int i = 0; i < m_vecpGameObjects.size(); ++i)
{
m_vecpGameObjects[i]->Update();
}
}
}
void cGameObjectManager::Render()
{
m_pGrid->Render();
for each (const auto pObj in m_vecpGameObjects)
{
if (pObj->IsActived())
pObj->Render();
}
g_pPathManager->DebugRender();
g_pWallCreator->DebugRender();
}
void cGameObjectManager::InputProcess(iInputProcessor * pGenerator)
{
if (g_pInput->IsKeyPress(VK_CONTROL))
{
if (g_pInput->IsKeyDown('1'))
m_isEdit = false;
if (g_pInput->IsKeyDown('2'))
m_isEdit = true;
if (g_pInput->IsKeyDown('3'))
g_pInput->SetProcessor(g_pWallCreator);
if (g_pInput->IsKeyDown('4'))
g_pInput->SetProcessor(g_pPathManager);
}
if (g_pInput->IsKeyDown(VK_RETURN))
m_isPlay = m_isPlay ? false : true;
if (m_isEdit)
{
EditModeProcess();
}
else if(m_pPlayer)
{
PlayerControl();
}
}
void cGameObjectManager::PlayerControl()
{
if (g_pInput->IsKeyPress(VK_LBUTTON))
{
cRay rayMouse = g_pCamera->GetMouseRay();
D3DXVECTOR3 vPickPos;
rayMouse.IsCollisionAsPlane(&vPickPos, stPlane());
m_pPlayer->FindPath(vPickPos);
}
}
void cGameObjectManager::EditModeProcess()
{
cRay rayMouse = g_pCamera->GetMouseRay();
D3DXVECTOR3 vPickPos;
rayMouse.IsCollisionAsPlane(&vPickPos, stPlane());
if (g_pInput->IsKeyDown(VK_LBUTTON))
{
for each(const auto obj in m_vecpGameObjects)
{
if (obj->IsCollisionAsRay(&rayMouse))
{
m_pPickObjec = obj;
m_vOffset = obj->GetPosition() - vPickPos;
m_isDrag = true;
break;
}
}
}
if (g_pInput->IsKeyUp(VK_LBUTTON))
{
m_fRatio = 1;
m_isDrag = false;
}
if (m_isDrag)
{
if (g_pInput->IsKeyPress(VK_CONTROL))
{
POINT ptDelta = g_pInput->GetMouseInterval();
m_fRatio += (ptDelta.x + ptDelta.y)*0.01f;
m_pPickObjec->SetScale(m_fRatio);
}
else
{
vPickPos += m_vOffset;
m_pPickObjec->SetPosition(&vPickPos);
}
}
}
void cGameObjectManager::MessageHandler(iObjectMessenger * pGenerator, eObj_Message eMessage)
{
switch (eMessage)
{
case eObj_Message::DEAD:
if (pGenerator == m_pPlayer)
{
MessageBox(g_hWnd, "You Lose", NULL, MB_OK);
}
else
{
MessageBox(g_hWnd, "You Victory", NULL, MB_OK);
}
SendMessage(g_hWnd, WM_CLOSE, NULL, NULL);
break;
case eObj_Message::SHOOT:
m_vecpGameObjects.push_back(dynamic_cast<cGameObject*>(pGenerator));
break;
}
}
| [
"[email protected]"
] | |
1bde55496e378bbb2537d78c34debb50f16c6709 | 8adf8d94793e997e401b0b129e43e6644a6ac016 | /week15/dj_pq.cpp | 62acc113be6bb5c89c70b66b63e309f2c61236a0 | [] | no_license | siffi26/cp2_2016 | e9aef215e71abd5f0fbf511768626dab6dc1371d | 6134b23602f1f2906d1e3c55d7735415ae0a6895 | refs/heads/master | 2021-01-20T05:48:25.414299 | 2016-05-24T09:34:34 | 2016-05-24T09:34:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,855 | cpp | #include<cstdio>
#include<algorithm>
#include<queue>
#include<vector>
using namespace std;
struct halfedge{
int v,w; // w(?,v)=w. We don't really care where is it from.
bool operator<(const halfedge &rhs) const{
return this->w>rhs.w; /* priority_queue: max=first. We need min=first */
}
};
void solve()
{
int i,j,u,w,n,m,ans=0;
vector<vector<halfedge> > e; /* adjacency list */
vector<int> d; /* minimum distance */
vector<bool> inS; /* inS[v] == extracted from pq */
priority_queue<halfedge> pq; /* priority queue for relaxed edges */
halfedge source; /* the first domino */
scanf("%d%d",&n,&m); /* V={0,...,n-1}, |E|=m, Directed */
e.resize(n,vector<halfedge>());
d.resize(n,0x3FFFFFFF); /* initially, minimum distance = infinity */
inS.resize(n,false); /* initially, every node is in pq */
for(i=0;i<m;i++) /* read edges */
{
halfedge in;
scanf("%d%d%d",&u,&in.v,&in.w); /* (u,in.v) has weight in.w */
e[u].push_back(in);
}
d[0]=0; /* initialize the minimum distance of source to 0 */
source.v=0; /* prepare a virtual relaxed edge (?,s) */
source.w=0; /* d[s]=0 */
pq.push(source); /* put it into pq */
while(!pq.empty()) /* iterate if pq is not empty */
{
printf("v=%d v.d=%d inS[v]=%s\n",pq.top().v,pq.top().w,inS[pq.top().v]?"true":"false");
u=pq.top().v;
pq.pop();
if(inS[u])continue; /* u is extracted, skip u */
inS[u]=true; /* u is formally extracted */
for(j=0;j<e[u].size();j++) /* relax u's edges */
{
int v=e[u][j].v,w=e[u][j].w;
if(d[u]+w<d[v]) /* check if we need to update d[v] */
{
halfedge h;
h.v=v; /* (u,v) inserts v into pq */
h.w=d[v]=d[u]+w; /* update d[v]. v has weight h.w=d[v] */
pq.push(h); /* put h into pq */
}
}
}
for(i=0;i<n;i++)
printf("%d\n",d[i]);
}
int main()
{
int nCases;
scanf("%d",&nCases);
while(nCases--)
solve();
return 0;
}
| [
"[email protected]"
] | |
4f9cb6e158fd8075b9d9c34ce223d8978704d135 | 6869b4b82cb44408fc7c1ce85f0bc0228503daf9 | /14 Longest Common Prefix.cpp | fb390d37b8dbcdf7c0e7dbde9191c15ce28fab7f | [] | no_license | LisaJing/MyLeetCodeExercise | 82db37bb882321b70d1d0d07a7d394170b469891 | a216be71ed9412bf90da5011e26e0029d1202a9f | refs/heads/master | 2021-01-11T20:26:24.859583 | 2017-04-25T12:04:17 | 2017-04-25T12:04:17 | 79,115,426 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,270 | cpp | #include <iostream>
#include <string>
#include <vector>
using namespace std;
class Solution {
public:
string longestCommonPrefix(vector<string>& strs) {
int size = strs.size();
cout << "size: " << size <<endl;
string res;
if(size <= 0)
return res;
if(size == 1)
return strs[0];
vector<string::iterator> sits(size);
for(int i = 0;i < size;i++)
{
sits[i] = (strs[i]).begin();
}
int resLen = 0;
bool sameChar = true;
while(sameChar)
{
if(*(sits[0]) == '\0')
{
sameChar = false;
break;
}
for(int i = 1;i < size;i++)
{
if(*(sits[i]) != '\0' && *(sits[i]) != *(sits[i - 1]))
{
sameChar = false;
break;
}
else
{
sits[i - 1]++;
}
}
if(sameChar)
{
res += *(sits[size - 1]);
cout << res << endl;
sits[size - 1]++;
resLen++;
}
}
return res;
}
};
| [
"[email protected]"
] | |
67d85e246a197b8f3d8140dea0bab35a921ec92b | 4c3b3961b7b68ca9f36d2616f26120694ed7f08a | /TimeLine/20190218/netlib/v3/Threadpool.cc | 8687e4d170a85f37225457376faf6dc7b9ee20ab | [] | no_license | moyin1004/learning | a459d35871997183d0088a258ac4f3ea9984327a | 29b4e3f28e1e7887fe66e417c5ace55b47ef43ea | refs/heads/master | 2023-08-31T03:54:39.073635 | 2023-08-22T16:15:45 | 2023-08-22T16:15:45 | 169,972,332 | 6 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,395 | cc | /// @file Threadpool.cc
/// @author moyin([email protected])
/// @data 2019-02-10 20:18:25
#include "Thread.h"
#include "Threadpool.h"
#include <unistd.h>
#include <iostream>
#include <functional>
using std::cout;
using std::endl;
using std::unique_ptr;
namespace wd {
Threadpool::Threadpool(size_t threadNum, size_t queSize)
: _threadNum(threadNum)
, _queSize(queSize)
, _threads()
, _taskque(_queSize)
, _isExit(false)
{
_threads.reserve(_threadNum);
}
Threadpool::~Threadpool() {
if (!_isExit)
stop();
}
void Threadpool::start() {
for (size_t i = 0; i != _threadNum; ++i) {
unique_ptr<Thread> up(new Thread(
std::bind(&Threadpool::threadFunc, this)
));
_threads.push_back(std::move(up));
}
for (auto &threadPtr : _threads) threadPtr->start();
}
void Threadpool::addTask(Task &&task) {
_taskque.push(std::move(task));
}
Task Threadpool::getTask() {
return _taskque.pop();
}
void Threadpool::threadFunc() {
while (!_isExit) {
Task task = getTask();
if (task) task();
}
}
void Threadpool::stop() {
if (!_isExit) {
while (!_taskque.empty()) {
usleep(100);
}
_isExit = true;
_taskque.wakeup();
for (auto &threadPtr : _threads) {
threadPtr->join();
}
}
}
} //end of namespce wd
| [
"[email protected]"
] | |
a27c8d0d9c26e37d794accb5e660c581987e93ba | 2bfe2a09762fb6bfdded4201e8353d47b8462ef4 | /include/ast/ast_pointer.hpp | 3774223ebe47bcee6ef011052db001a658f47cef | [] | no_license | TeDand/MIPS-Compiler | 75d4bd0468978e746153de0723e60fca824ec20d | afe399331a539a6249157ca5dae78bb202e6a199 | refs/heads/master | 2022-11-26T19:11:26.646234 | 2020-08-05T12:46:13 | 2020-08-05T12:46:13 | 285,284,135 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 734 | hpp | #ifndef ast_pointer_hpp
#define ast_pointer_hpp
#include <string>
#include <iostream>
#include "ast_expression.hpp"
class PointerDec
: public Expression
{
private:
int points;
ExpressionPtr variable_name;
public:
PointerDec(const int points_id, const ExpressionPtr &variable_id)
: points(points_id), variable_name(variable_id)
{}
virtual void print_python(std::ostream &dst, ContextPtr& context) const override
{
dst << "pointers not implemented for python" << std::endl;
}
virtual void print_MIPS(std::ostream &dst, ContextPtr_MIPS& context) const override
{
variable_name->print_MIPS(dst, context);
}
};
#endif
| [
"[email protected]"
] | |
4ca9d1d5f75faeb28690fb5906ed8a3597a674ce | 1851358be69e2a89bd00936dcdbe9b3ed672cbfe | /Base c++ Project/map.cpp | 21d8999a0d5425a69ad4023f017d715af4143f8c | [] | no_license | cerealal/C-First-Project-Text-RPG- | 095e46a58038e5963555a420b7c0f5ee341a147a | 6524419c39f4779242e83cefdfa92c5dd1a5d541 | refs/heads/master | 2020-12-18T13:33:45.319217 | 2020-02-01T04:37:13 | 2020-02-01T04:37:13 | 235,401,952 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 183 | cpp | #include <iostream>
#include <string>
#include "globalvars.h"
#include "functions.h"
#include "mapstructure.h"
using namespace std;
int mapstructure(){
}
int mapdisplay(){
} | [
"[email protected]"
] | |
31e35ab950fcd1fa3facc191d8b6d1fa1c4690d8 | 8cf32b4cbca07bd39341e1d0a29428e420b492a6 | /contracts/libc++/upstream/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp | 5df1ce8280be36ddd0ffcc7a202a2a275ebd6856 | [
"MIT",
"NCSA"
] | permissive | cubetrain/CubeTrain | e1cd516d5dbca77082258948d3c7fc70ebd50fdc | b930a3e88e941225c2c54219267f743c790e388f | refs/heads/master | 2020-04-11T23:00:50.245442 | 2018-12-17T16:07:16 | 2018-12-17T16:07:16 | 156,970,178 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,065 | cpp | //===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <string>
// basic_string<charT,traits,Allocator>&
// operator+=(const basic_string<charT,traits,Allocator>& str);
#include <string>
#include <cassert>
#include "test_macros.h"
#include "min_allocator.h"
template <class S>
void
test(S s, S str, S expected)
{
s += str;
LIBCPP_ASSERT(s.__invariants());
assert(s == expected);
}
int main()
{
{
typedef std::string S;
test(S(), S(), S());
test(S(), S("12345"), S("12345"));
test(S(), S("1234567890"), S("1234567890"));
test(S(), S("12345678901234567890"), S("12345678901234567890"));
test(S("12345"), S(), S("12345"));
test(S("12345"), S("12345"), S("1234512345"));
test(S("12345"), S("1234567890"), S("123451234567890"));
test(S("12345"), S("12345678901234567890"), S("1234512345678901234567890"));
test(S("1234567890"), S(), S("1234567890"));
test(S("1234567890"), S("12345"), S("123456789012345"));
test(S("1234567890"), S("1234567890"), S("12345678901234567890"));
test(S("1234567890"), S("12345678901234567890"), S("123456789012345678901234567890"));
test(S("12345678901234567890"), S(), S("12345678901234567890"));
test(S("12345678901234567890"), S("12345"), S("1234567890123456789012345"));
test(S("12345678901234567890"), S("1234567890"), S("123456789012345678901234567890"));
test(S("12345678901234567890"), S("12345678901234567890"),
S("1234567890123456789012345678901234567890"));
}
#if TEST_STD_VER >= 11
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
test(S(), S(), S());
test(S(), S("12345"), S("12345"));
test(S(), S("1234567890"), S("1234567890"));
test(S(), S("12345678901234567890"), S("12345678901234567890"));
test(S("12345"), S(), S("12345"));
test(S("12345"), S("12345"), S("1234512345"));
test(S("12345"), S("1234567890"), S("123451234567890"));
test(S("12345"), S("12345678901234567890"), S("1234512345678901234567890"));
test(S("1234567890"), S(), S("1234567890"));
test(S("1234567890"), S("12345"), S("123456789012345"));
test(S("1234567890"), S("1234567890"), S("12345678901234567890"));
test(S("1234567890"), S("12345678901234567890"), S("123456789012345678901234567890"));
test(S("12345678901234567890"), S(), S("12345678901234567890"));
test(S("12345678901234567890"), S("12345"), S("1234567890123456789012345"));
test(S("12345678901234567890"), S("1234567890"), S("123456789012345678901234567890"));
test(S("12345678901234567890"), S("12345678901234567890"),
S("1234567890123456789012345678901234567890"));
}
#endif
}
| [
"[email protected]"
] | |
9fd7c654dd8c9e3df9672d94cd1832400d064708 | 138e198af877de7ae0adccc5207d70c282952ee1 | /LearnJniAndNdk/app/src/main/jni/com_example_asus1_learnjniandndk_JNIUtil.cpp | d51cde807dc8d9c422d1b16879fef20c171378f7 | [] | no_license | brice-liu/PracticeEveryDay | f8967f5881f2ae1a589910911544d84e78b2e255 | 9cab30c08da76585c4fc2c54feb035bd90f4dd91 | refs/heads/master | 2021-10-14T09:44:00.483488 | 2019-02-04T08:07:04 | 2019-02-04T08:07:04 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 269 | cpp | #include "com_example_asus1_learnjniandndk_JNIUtil.h"
JNIEXPORT jstring JNICALL Java_com_example_asus1_learnjniandndk_JNIUtil_getWorld
(JNIEnv *env, jclass) {
// new 一个字符串，返回Hello World
return env -> NewStringUTF("Hello World ZZZZZ");
}
| [
"[email protected]"
] | |
fd4822e57fd63b4e51cdcf6ad644ad1ae9be4d6a | 1ebed5f4026921e6bb7e677e122b6c09297e20ac | /dylib_export.h | 4a42f3fb5c86eb7d7b487bed90b7afa12cb84c64 | [] | no_license | BachelorDegree/ChunkServer | 8f9dab422235b854fbd97973e35d8082ecda5e81 | f8c04a5a6139b4f049e5755c5d50acd5e5686bd9 | refs/heads/master | 2021-04-17T15:30:14.517592 | 2020-04-08T06:33:01 | 2020-04-08T06:33:01 | 249,455,185 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 397 | h | #pragma once
namespace grpc
{
class Service;
class ServerCompletionQueue;
}
class SatelliteClient;
extern "C"
{
const char * EXPORT_Description(void);
void EXPORT_DylibInit(const char *);
grpc::Service * EXPORT_GetGrpcServiceInstance(void);
void EXPORT_OnWorkerThreadStart(grpc::ServerCompletionQueue*);
void EXPORT_OnCoroutineWorkerStart(void);
}
| [
"[email protected]"
] | |
f1c093f38cf4d3168f990859f050b3d2ffd5689e | b0b8e9d356e70d0c14fa9260620780b46854c150 | /qfloat/test1.cc | b8a34d2db3bff1d3dc541e077ab6c33d7c421cca | [] | no_license | emsr/maths_cephes | 5d7251f42d308660956d82e0e2c37de2da4fae2c | 32ea96abe260737ea274b8362e483da3b0b13eca | refs/heads/master | 2022-04-11T09:54:29.231597 | 2020-03-30T22:43:19 | 2020-03-30T22:43:19 | 109,444,229 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,811 | cc | #include <stdio.h>
#include "qfloat.h"
qfloat w, x, y, z;
char str[80];
int
main()
{
int i;
/*
asctoq( "1.4", &x );
asctoq( "1.5", &y );
*/
x = "1.4";
y = "1.5";
z = x + y;
qtoasc( &z, str, 10 );
printf("1.4 + 1.5 = %s\n", str);
/* i = x + y; */
/*
I = z;
i = *(int *) &I;
printf("int value = %d\n", i);
*/
z = x - y;
qtoasc( &z, str, 10 );
printf("1.4 - 1.5 = %s\n", str);
w = -z;
qtoasc( &z, str, 10 );
printf("-(%s) = ", str);
qtoasc( &w, str, 10 );
printf("%s\n", str);
w = fabs (z);
qtoasc( &z, str, 10 );
printf("fabs(%s) = ", str);
qtoasc( &w, str, 10 );
printf("%s\n", str);
z = x * y;
qtoasc( &z, str, 10 );
printf("1.4 * 1.5 = %s\n", str);
z = x / y;
qtoasc( &z, str, 10 );
printf("1.4 / 1.5 = %s\n", str);
z = x;
z += y;
qtoasc( &z, str, 10 );
printf("1.4 += 1.5 = %s\n", str);
z = y;
z -= x;
qtoasc( &z, str, 10 );
printf("1.5 -= 1.4 = %s\n", str);
y = x;
z = x + y;
qtoasc( &z, str, 10 );
printf("1.4 + 1.4 = %s\n", str);
z = 1.9;
x = z;
qtoasc( &z, str, 10 );
printf("double 1.9 = %s\n", str);
if( x == z )
printf("1.9 == 1.9\n");
else
printf("ERROR: 1.9 != 1.9\n");
qtoasc(&y, str, 10);
printf("%s ", str);
if( y != z )
printf("!= ");
else
printf("== ");
qtoasc(&z, str, 10);
printf("%s\n", str);
qtoasc(&y, str, 10);
printf("%s ", str);
if( y < z )
printf("< ");
else
printf("not < ");
qtoasc(&z, str, 10);
printf("%s\n", str);
qtoasc(&z, str, 10);
printf("%s ", str);
if( z > y )
printf("> ");
else
printf("not > ");
qtoasc(&y, str, 10);
printf("%s\n", str);
z = "1.0e-4000";
qtoasc(&z, str, 10);
printf("\"1.0E-4000\" = %s\n", str);
i = sizeof(qfloat);
printf("sizeof qfloat = %d\n", i);
}
int mtherr (char *prog, int code)
{
printf("%s code %d\n", prog, code);
return 0;
}
| [
"[email protected]"
] | |
855fe33fec228eaea3f55e1dcbb43e5a62d8587e | 9af8cbdb48459f0e88b053fba67248a35561aab5 | /httpserver.cc | f73f9038194440cd0083cfcd98761ebb55dac52b | [
"MIT"
] | permissive | wangjiekai/unixtar | 349860127b8b159342103cb27470a18b622af963 | a244dcc0d4e7a990be2e89db0ac6c6ba4a2cd632 | refs/heads/master | 2023-04-21T02:00:15.561478 | 2021-05-12T10:49:39 | 2021-05-12T10:49:39 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,889 | cc | #include "httpserver.h"
#include "log.h"
#include <unistd.h>
HttpServer::HttpServer()
: ServerBase() {
}
HttpServer::~HttpServer() = default;
HttpServer::HttpNetThread::HttpNetThread()
: NetThreadBase() {
}
int HttpServer::HttpNetThread::_OnReadEvent(tcp::ConnectionProfile *_conn) {
assert(_conn);
SOCKET fd = _conn->FD();
uint32_t uid = _conn->Uid();
LogI("fd(%d), uid: %u", fd, uid)
if (_conn->Receive() < 0) {
DelConnection(uid);
return -1;
}
if (_conn->IsParseDone()) {
LogI("fd(%d) http parse succeed", fd)
return HandleHttpPacket(_conn);
}
return 0;
}
bool HttpServer::HttpNetThread::_OnWriteEvent(tcp::SendContext *_send_ctx) {
if (!_send_ctx) {
LogE("!_send_ctx")
return false;
}
AutoBuffer &resp = _send_ctx->buffer;
size_t pos = resp.Pos();
size_t ntotal = resp.Length() - pos;
SOCKET fd = _send_ctx->fd;
if (fd <= 0 || ntotal == 0) {
return false;
}
ssize_t nsend = ::write(fd, resp.Ptr(pos), ntotal);
if (nsend == ntotal) {
LogI("fd(%d), send %zd/%zu B, done", fd, nsend, ntotal)
resp.Seek(AutoBuffer::kEnd);
return true;
}
if (nsend >= 0 || (nsend < 0 && IS_EAGAIN(errno))) {
nsend = nsend > 0 ? nsend : 0;
LogI("fd(%d): send %zd/%zu B", fd, nsend, ntotal)
resp.Seek(AutoBuffer::kCurrent, nsend);
}
if (nsend < 0) {
if (errno == EPIPE) {
// fd probably closed by peer, or cleared because of timeout.
LogI("fd(%d) already closed, send nothing", fd)
return false;
}
LogE("fd(%d) nsend(%zd), errno(%d): %s",
fd, nsend, errno, strerror(errno))
LogPrintStacktrace(5)
}
return false;
}
HttpServer::HttpNetThread::~HttpNetThread() = default;
| [
"[email protected]"
] | |
5542c1344b58729a79c6a151685caf1789a182c5 | 653ebcf6aaacc20319e2770297e850848df2b888 | /src/matrix.cpp | 4ef6a22934a41598b8ef76ca80ae7534c702392a | [
"MIT"
] | permissive | alasher/slab | 72b37bb655e79df0ff709066764fe3a1557ec10b | 2ce39eb71f16c7f92811cfd3a3be883a61d664a3 | refs/heads/master | 2020-06-10T19:45:27.956599 | 2019-03-07T04:06:15 | 2019-03-07T04:33:32 | 75,893,361 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,542 | cpp | #include <slab/matrix.hpp>
namespace slab {
Matrix::Matrix(const size_t na) : n(na) {
m = new float[n * n];
for (int i = 0; i < n * n; i++) {
m[i] = 0.0f;
}
}
Matrix::Matrix(const Matrix &other) : n(other.n) {
m = new float[n * n];
if (n == other.n) copy(other);
}
Matrix::~Matrix() {
delete[] m;
}
void Matrix::load(const float *data[]) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
m[i * n + j] = data[i][j];
}
}
}
void Matrix::load(const float *data) {
for (int i = 0; i < n * n; i++) {
m[i] = data[i];
}
}
float Matrix::get(int i, int j) {
return m[i * n + j];
}
void Matrix::set(int i, int j, float val) {
m[i * n + j] = val;
}
void Matrix::storeIdentity() {
copy(Identity(n));
}
void Matrix::copy(const Matrix &other) {
if (n != other.n) return;
for (int i = 0; i < n * n; i++) {
m[i] = other.m[i];
}
}
Matrix Matrix::Identity(const size_t na) {
Matrix new_mat(na);
for (int i = 0; i < na * na; i += (na + 1)) {
new_mat.m[i] = 1.0f;
}
return new_mat;
}
Matrix &Matrix::operator=(const Matrix &other) {
for (int i = 0; i < n * n; ++i) {
m[i] = other.m[i];
}
return *this;
}
Matrix &Matrix::operator*=(const Matrix &other) {
Matrix tmp;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
tmp.m[i * n + j] = 0.0;
for (int k = 0; k < n; k++) {
tmp.m[i * n + j] += m[i * n + k] * other.m[k * n + j];
}
}
}
copy(tmp);
return *this;
}
Matrix &Matrix::operator+=(const Matrix &other) {
for (int i = 0; i < n * n; ++i) {
m[i] += other.m[i];
}
return *this;
}
Matrix &Matrix::operator-=(const Matrix &other) {
for (int i = 0; i < n * n; ++i) {
m[i] -= other.m[i];
}
return *this;
}
Matrix Matrix::operator*(const Matrix &other) {
return Matrix(*this) *= other;
}
Matrix Matrix::operator+(const Matrix &other) {
return Matrix(*this) += other;
}
Matrix Matrix::operator-(const Matrix &other) {
return Matrix(*this) -= other;
}
} // namespace slab
| [
"[email protected]"
] | |
cda660bafe99864cb5e80c26943debe3c5102d69 | 392589f6442c6931d4e961a32e7753d41ce94ff6 | /CbersApp/pluginmanager.cpp | 5ea1f080c442aca3bb393176210c747a1e56ad77 | [
"Apache-2.0"
] | permissive | luzhoujiang/CbersUI | 303d8953c6341b4fbec8b623ca39660a89cf046b | 85bfe9f16e0ff17361875461818006efc51d8d28 | refs/heads/master | 2021-09-24T14:11:26.740610 | 2018-10-10T06:39:27 | 2018-10-10T06:39:27 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,477 | cpp | #include "pluginmanager.h"
#include "x3py/nonplugin/scanplugins.h"
#include "x3py/manager/x3manager.h"
#include "x3py/manager/iplugins.h"
int CPluginManager::MINID = 3000;
int CPluginManager::MAXID = 3999;
CPluginManager::CPluginManager(void)
{
m_nNextID = MINID;
m_nLastTool = -1;
}
CPluginManager::~CPluginManager(void)
{
UnloadPlugins();
}
bool CPluginManager::Initialize(const char* folder)
{
return x3::loadScanPlugins(folder)>0;
}
bool CPluginManager::UnInitialize()
{
x3::unloadScanPlugins();
return true;
}
bool CPluginManager::LoadPlugins()
{
UnloadPlugins();
x3::Object<x3::IPlugins> spPlugins(x3::clsidManager);
if( !spPlugins.valid() || spPlugins->getPluginCount()<=0 )
return false;
x3::Object<IUICore> spUICore(clsidUICore);
x3::LockRW lockcls(m_mapPlugin.locker, true);
bool ret = false;
if( lockcls.canWrite() )
{
int nCount = spPlugins->getCLSIDCount();
for( int i=0; i<nCount; i++ )
{
const char* clsid = spPlugins->getCLSID(i);
if( clsid==NULL )
continue;
x3::Object<IUIPlugin> spCommon(clsid);
if( !spCommon.valid() )
continue;
if( !spCommon->Initialize() )
continue;
if( spUICore.valid() )
spUICore->Add(spCommon->getClassName(), spCommon.p());
x3::Object<IUIView> spView = spCommon;
if( spView.valid() )
m_mapView.push_back(spView.p());
else
{
int nNextID = GetNextID();
if( nNextID==-1 )
break;
m_mapPlugin[nNextID] = spCommon.p();
}
ret = true;
}
}
return ret;
}
bool CPluginManager::UnloadPlugins()
{
x3::Object<IUICore> spUICore(clsidUICore);
x3::LockRW lockcls(m_mapPlugin.locker, true);
if( lockcls.canWrite() )
{
hash_map<int, x3::AnyObject>::iterator it = m_mapPlugin.begin();
for( ; it!=m_mapPlugin.end(); it++ )
{
if( it->second.valid() )
{
x3::Object<IUIPlugin> spCommond(it->second);
if( spCommond.valid() )
{
if( spUICore.valid() )
spUICore->Remove(spCommond->getClassName());
spCommond->UnInitialize();
}
}
}
m_mapPlugin.clear();
m_nNextID = MINID;
m_nLastTool = -1;
x3::LockRW lockcls2(m_mapIdleID.locker, true);
if( lockcls2.canWrite() )
m_mapIdleID.clear();
}
{
x3::LockRW lockcls(m_mapView.locker, true);
if( lockcls.canWrite() )
{
std::vector<x3::AnyObject>::iterator it = m_mapView.begin();
for( ; it!=m_mapView.end(); it++ )
{
if( (*it).valid() )
{
x3::Object<IUIPlugin> spCommond(*it);
if( spCommond.valid() )
{
if( spUICore.valid() )
spUICore->Remove(spCommond->getClassName());
spCommond->UnInitialize();
}
}
}
m_mapView.clear();
}
}
return true;
}
int CPluginManager::GetNextID()
{
x3::LockRW lockcls(m_mapIdleID.locker, true);
int ret = -1;
if( lockcls.canWrite() )
{
std::vector<int>::iterator it = m_mapIdleID.begin();
if( it!=m_mapIdleID.end() )
{
ret = *it;
m_mapIdleID.erase(it);
}
}
if( ret!=-1 )
return ret;
if( m_nNextID>MAXID )
return ret;
ret = m_nNextID++;
return ret;
}
void CPluginManager::FreeID(int id)
{
if( id==m_nLastTool )
m_nLastTool = -1;
if( id<MINID || id>MAXID || id>=m_nNextID )
return;
x3::LockRW lockcls(m_mapIdleID.locker, true);
if( lockcls.canWrite() )
{
std::vector<int>::iterator it = m_mapIdleID.begin();
for( ; it!=m_mapIdleID.end(); it++ )
{
if( *it==id )
return;
}
m_mapIdleID.push_back(id);
}
}
int CPluginManager::GetViewPluginCount()
{
x3::LockRW lockcls(m_mapView.locker);
int ret = 0;
if( lockcls.canRead() )
ret = m_mapView.size();
return ret;
}
bool CPluginManager::GetViewPlugin(int index, IUIView** ppIView)
{
x3::LockRW lockcls(m_mapView.locker);
IUIView* ret = nullptr;
if( lockcls.canRead() )
{
if( index>=0 && index<m_mapView.size() )
{
std::vector<x3::AnyObject>::iterator it = m_mapView.begin() + index;
if( it!=m_mapView.end() )
{
x3::Object<IUIView> spCommon(*it);
ret = spCommon.p();
}
}
}
return ret;
}
int CPluginManager::GetPluginCount()
{
x3::LockRW lockcls(m_mapPlugin.locker);
int ret = 0;
if( lockcls.canRead() )
ret = m_mapPlugin.size();
return ret;
}
IUIPlugin* CPluginManager::FindPlugin(int id)
{
x3::LockRW lockcls(m_mapPlugin.locker);
IUIPlugin* ret = nullptr;
if( lockcls.canRead() )
{
hash_map<int, x3::AnyObject>::iterator it = m_mapPlugin.find(id);
if( it!=m_mapPlugin.end() )
{
x3::Object<IUIPlugin> spCommon(it->second);
ret = spCommon.p();
}
}
return ret;
}
bool CPluginManager::GetPlugin(int index, int& id, IUIPlugin** ppICommon)
{
if( ppICommon==NULL )
return false;
x3::LockRW lockcls(m_mapPlugin.locker);
bool ret = false;
if( lockcls.canRead() )
{
if( index>=0 && index<m_mapPlugin.size() )
{
hash_map<int, x3::AnyObject>::iterator it = m_mapPlugin.begin();
for( int i=0; i<index; i++ )
it++;
if( it!=m_mapPlugin.end() )
{
id = it->first;
if( *ppICommon!=NULL )
{
(*ppICommon)->releaseObject();
*ppICommon = NULL;
}
x3::Object<IUIPlugin> spCommon(it->second);
*ppICommon = spCommon.p();
if( *ppICommon!=NULL )
ret = true;
}
}
}
return ret;
}
| [
"[email protected]"
] | |
27f30b213531213a837d8279fb93f1095b0dde86 | 92daa19a80d197e591c88a73307f9a651dcc0111 | /TrabajoFinal/FastIterative-BigArraySeq/grilla_FI.hpp | 07da4eb77c64bf45b93aa326735ed42da81a394d | [] | no_license | Alex23013/Parallel-Algorithms | e346bacec7bc923944adc148b5dea797cb89855d | 4e4745ea883721024f09ff2bb1d65b875b47786c | refs/heads/master | 2020-03-07T05:54:26.950742 | 2018-06-29T03:57:47 | 2018-06-29T03:57:47 | 127,308,601 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,272 | hpp | #ifndef GRILLA_FI_H
#define GRILLA_FI_H
#include <stdio.h>
#include <iostream>
#include <vector>
using namespace std;
struct cCell {
//The velocity
float vel;
//The time of arrival of the wave
double t;
//The index of the cell
int i,j;
//A state... just in case
string state;
//The neightbours (4 or 8)
vector <cCell*> neightbours;
//If the cell is an obstacle or not
bool obstacle = false;
};
class cGrid {
public:
//Matrix of cells
vector< vector<cCell> > grid;
//Heigth and with of the grid
int h, w;
//Empty constructor
cGrid (){};
//Constructor with 2 parameters, 2 dimensions only
cGrid (int h, int w){
//Assigning values
this->h = h;
this->w = w;
//Initializing the grid
init();
}
void init(){
//Creating empty rows
grid.resize(h);
for (int i = 0; i < h; i++) {
//Filling a row with empty cells
grid[i].resize(w);
//Initializing cells
for (int j = 0; j < w; j++) {
grid[i][j].vel = 1;
grid[i][j].t = std::numeric_limits<double>::infinity();
grid[i][j].i = i;
grid[i][j].j = j;
grid[i][j].state = "UNKNOWN";
}
}
//Assigning neightbours to each cell only if it is not an obstacle
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (!grid[i][j].obstacle)
fillNeightbours(&grid[i][j]);
}
}
}
void setObstacle(int i, int j){
//Turning a cell into an obstacle
grid[i][j].obstacle=true;
}
//Filling neightbours with the memory direction of the cell's neightbours
//4 direction only
void fillNeightbours (cCell *c){
c->neightbours.clear();
if(c->i-1>=0) c->neightbours.push_back(&grid[c->i-1][c->j]);
if(c->i+1<h) c->neightbours.push_back(&grid[c->i+1][c->j]);
if(c->j-1>=0) c->neightbours.push_back(&grid[c->i][c->j-1]);
if(c->j+1<w) c->neightbours.push_back(&grid[c->i][c->j+1]);
}
//Printing the velocity and the time of each cell
void print(){
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
printf("(%.1f,%.4f)", grid[i][j].vel, grid[i][j].t);
}
printf("\n");
}
}
};
#endif
| [
"[email protected]"
] | |
d7d90647ec420180041bc8cadedb445e167028ff | e0992373232fceadb8b9c0efed93d8d6465e5014 | /src/Vedio_publisher.cpp | 71e2e8ace979c8bd610607ca5211448ffa1c173e | [] | no_license | zisuina/my_image_transport1 | 8f40588b5063837e12cc31d8ac50187d356b2eaa | 799e9d4079fdf82fbab8b939602125a30c5c5ae0 | refs/heads/master | 2020-03-27T10:36:37.629033 | 2018-09-17T04:50:40 | 2018-09-17T04:50:40 | 146,432,327 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,054 | cpp | #include <iostream>
#include <stdio.h>
#include <ros/ros.h>
#include <image_transport/image_transport.h>
#include <cv_bridge/cv_bridge.h>
#include <opencv2/opencv.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include "PubOperations.h"
#include "boost/program_options.hpp"
#include <rosbag/player.h>
#include <linux/input.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
using namespace std;
using namespace cv;
using namespace std;
namespace po = boost::program_options;
vector<string> files;
cv::VideoCapture cap;
bool kbhit()
{
termios term;
tcgetattr(0, &term);
termios term2 = term;
term2.c_lflag &= ~ICANON;
tcsetattr(0, TCSANOW, &term2);
int byteswaiting;
ioctl(0, FIONREAD, &byteswaiting);
tcsetattr(0, TCSANOW, &term);
return byteswaiting > 0;
}
void stop()
{
if( kbhit() ) {
char ch;
scanf("%c", &ch);
switch (ch) {
case 32:
cout << endl;
cout << "Stop publishing successfully!" << endl;
cout << "Press enter key to continue." << endl;
char ss;
while (1)
{
if(kbhit())
{
scanf("%c", &ss);
if(ss == 32)
{
break;
}
}
}
}
}
}
void printPubInfo(datatrans::PubOptions opts)
{
cout<< "The frames number of this video: "<< opts.frames_num << endl;
cout<< "The duration this video: "<<opts.total_duration<<" s" << endl;
cout << "The publish frequency hz: " << opts.pub_frequency << " times/sec " <<endl;
cout << "The publish duration: " << int(opts.pub_duration) << " s " <<endl;
cout << "The place you want to start publishing: "<< int(opts.time)<< " s " <<endl;
if(opts.loop )
{
cout << "Will loop your publish: "<<endl;
} else{
cout << "Only loop once! "<<endl;
}
// cout<<"Image Type: "<<opts.figure_type.c_str()<<endl;
// cout << "The number of frames you want to publish: " << num_image << " frames" <<endl;
}
datatrans::PubOptions parseOptions(int argc, char** argv) {
datatrans::PubOptions opts;
po::options_description desc("Allowed options");
desc.add_options()
("help,h", "produce help message")
("prefix,p", po::value<std::string>()->default_value(""), "prefixes all output topics in replay")
("quiet,q", "suppress console output")
("immediate,i", "play back all messages without waiting")
("pause", "start in paused mode")
("queue", po::value<int>()->default_value(100), "use an outgoing queue of size SIZE")
("clock", "publish the clock time")
("hz", po::value<float>()->default_value(100.0f), "use a frequency of HZ when publishing clock time")
("delay,d", po::value<float>()->default_value(0.2f), "sleep SEC seconds after every advertise call (to allow subscribers to connect)")
("rate,r", po::value<float>()->default_value(20.0f), "multiply the publish rate by FACTOR")
("start,s", po::value<float>()->default_value(0.0f), "start SEC seconds into the bag files")
("duration,u", po::value<float>(), "play only SEC seconds from the bag files")
("skip-empty", po::value<float>(), "skip regions in the bag with no messages for more than SEC seconds")
("loop,l", "loop playback")
("keep-alive,k", "keep alive past end of bag (useful for publishing latched topics)")
("try-future-version", "still try to open a bag file, even if the version is not known to the player")
("topics", po::value< std::vector<std::string> >()->multitoken(), "topics to play back")
("pause-topics", po::value< std::vector<std::string> >()->multitoken(), "topics to pause playback on")
("bags", po::value< std::vector<std::string> >(), "bag files to play back from")
;
po::positional_options_description p;
p.add("bags", -1);
po::variables_map vm;
try
{
po::store(po::command_line_parser(argc, argv).options(desc).positional(p).run(), vm);
} catch (boost::program_options::invalid_command_line_syntax& e)
{
throw ros::Exception(e.what());
} catch (boost::program_options::unknown_option& e)
{
throw ros::Exception(e.what());
}
if (vm.count("help")) {
std::cout << desc << std::endl;
std::cout << "help" << std::endl;
exit(0);
}
cap.open(argv[1]);
opts.frames_num=cap.get(CV_CAP_PROP_FRAME_COUNT);
if(cap.isOpened())
{
std::cout<<"video was open."<<std::endl;
}
double rate = cap.get(CV_CAP_PROP_FPS);
opts.total_duration = ros::Duration(opts.frames_num/rate);
int delay = 1000/rate;
// if (vm.count("prefix"))
// opts.prefix = vm["prefix"].as<std::string>();
if (vm.count("quiet"))
opts.quiet = true;
if (vm.count("immediate"))
opts.at_once = true;
if (vm.count("pause"))
opts.start_paused = true;
if (vm.count("queue"))
opts.queue_size = vm["queue"].as<int>();
if (vm.count("delay"))
opts.advertise_sleep = ros::WallDuration(vm["delay"].as<float>());
if (vm.count("rate"))
opts.pub_frequency = vm["rate"].as<float>();
if (vm.count("start"))
{
opts.time = vm["start"].as<float>();
opts.has_time = true;
}
if (vm.count("duration"))
{
opts.pub_duration = vm["duration"].as<float>();
opts.has_duration = true;
}
if (vm.count("skip-empty"))
opts.skip_empty = ros::Duration(vm["skip-empty"].as<float>());
if (vm.count("loop"))
opts.loop = true;
if (vm.count("keep-alive"))
opts.keep_alive = true;
if (vm.count("topics"))
{
std::vector<std::string> topics = vm["topics"].as< std::vector<std::string> >();
for (std::vector<std::string>::iterator i = topics.begin();
i != topics.end();
i++)
opts.topics.push_back(*i);
}
if (vm.count("pause-topics"))
{
std::vector<std::string> pause_topics = vm["pause-topics"].as< std::vector<std::string> >();
for (std::vector<std::string>::iterator i = pause_topics.begin();
i != pause_topics.end();
i++)
opts.pause_topics.push_back(*i);
}
return opts;
}
int main(int argc, char** argv)
{
// /home/hitcm/Downloads/111.mp4
datatrans::PubOptions opts;
opts = parseOptions(argc, argv);
opts.check();
const int frequency = opts.pub_frequency;
const double dt = 1/float(frequency);
int num_start, num_image;
if (opts.has_time)
{
num_start =int(opts.time /dt ) ;
} else{
num_start = 0;
}
if (opts.has_duration)
{
num_image = int(opts.pub_duration / dt);
} else{
num_image = opts.frames_num - opts.start_frame_id;
opts.pub_duration = num_image/frequency;
}
printPubInfo( opts);
double diff;
unsigned int end_place;
double process_runtime = 0.0;
double real_dt = dt-process_runtime;
ros::init(argc, argv, "video_publisher");
ros::NodeHandle nh;
image_transport::ImageTransport it(nh);
image_transport::Publisher pub = it.advertise("/camera/image", 1);
cv::Mat frame;
ros::Time pre_time = ros::Time::now();
int i = num_start;
int frame_size = opts.frames_num ;
cap.set(CV_CAP_PROP_POS_FRAMES, num_start);
end_place = num_start+num_image;
cout << "The place you want to stop: " << end_place <<endl;
// cout<< "Total frame size: "<< cap.get(CV_CAP_PROP_FRAME_COUNT) << endl;
while(nh.ok() && i <= end_place)
{
stop();
ros::Time time = ros::Time::now();
diff = time.toSec() - pre_time.toSec() ;
if(diff < real_dt)
{
continue;
}
cap.read(frame);
if(!frame.empty())
{
pre_time = time;
imshow("Live", frame);
sensor_msgs::ImagePtr frame_msg = cv_bridge::CvImage(std_msgs::Header(), "bgr8", frame).toImageMsg();
frame_msg->header.stamp = time;
pub.publish(frame_msg);
printf("\r [RUNNING] Frame Time: %13.6f %d \r", time.toSec(), i);
fflush(stdout);
i=i+1;
ros::spinOnce();
ros::Time time2 = ros::Time::now();
process_runtime = time2.toSec() - pre_time.toSec() ;
if(i == end_place+1 && opts.loop)
{
cout<<"\n One More Time! "<<endl;
i = num_start;
cap.open(argv[1]);
}
}
else
{
throw std::out_of_range ("Out of range of this video!");
}
}
destroyWindow("Live");
}
| [
"[email protected]"
] | |
1ed7d32a5ad37e5444f33452af92ff989a4b9c0c | 0d2d3f5722091fc83842b20991864b5b78c85d5e | /FuckLeetCode/n_queensii.cpp | 33d3135d97414a8a1d68528e1c351bc669e852bc | [] | no_license | 0x0all/FuckInterview | 010d586915054a3d82203705d094c1e1c5803de6 | d83cc1dc1583bd32678494feb524e35b70357d91 | refs/heads/master | 2020-12-25T00:50:43.585098 | 2014-03-03T01:32:45 | 2014-03-03T01:32:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 857 | cpp | /*
* Follow up for N-Queens problem.
*
* Now, instead outputting board configurations, return the total number of distinct solutions.
*/
#include <iostream>
void Solve(int n, long long col, long long ld, long long rd, int &count) {
long long bitmask = (1LL << n) - 1;
if (col == bitmask) {
count++;
} else {
long long pos_set = bitmask & ~(col | ld | rd);
while (pos_set) {
long long pos = pos_set & (0 - pos_set);
pos_set &= ~pos;
Solve(n, col | pos, (ld | pos) << 1, (rd | pos) >> 1, count);
}
}
}
int NQueens(int n) {
int count = 0;
if (n > 0) {
Solve(n, 0, 0, 0, count);
}
return count;
}
int main() {
for (int i = 1; i <= 16; i++)
std::cout << i << " queens, there are " << NQueens(i) << " ways" << std::endl;
return 0;
}
| [
"[email protected]"
] | |
670a4e065b504a05ace4907c719e508ee0780609 | 5ed0f107a2a7095ec2e361e8ec102b05a64096c3 | /src/checkpoints.cpp | 62bfd523e78969d7a79a3901aab283c32e21a849 | [
"MIT"
] | permissive | ruevers/lili | 0a9f71286ebf9c3120480cec2d496a034e9bb1f4 | 264d6e6f0e264ecd66109842c18b6bd2b5e5a850 | refs/heads/master | 2021-07-02T06:10:48.101782 | 2020-08-18T22:00:37 | 2020-08-18T22:00:37 | 136,423,237 | 1 | 0 | null | 2018-06-07T04:50:11 | 2018-06-07T04:50:11 | null | UTF-8 | C++ | false | false | 3,477 | cpp | // Copyright (c) 2009-2014 The Bitcoin developers
// Copyright (c) 2014-2015 The Dash developers
// Copyright (c) 2015-2017 The PIVX developers
// Copyright (c) 2015-2017 The LILI developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "checkpoints.h"
#include "chainparams.h"
#include "main.h"
#include "uint256.h"
#include <stdint.h>
#include <boost/foreach.hpp>
namespace Checkpoints
{
/**
* How many times we expect transactions after the last checkpoint to
* be slower. This number is a compromise, as it can't be accurate for
* every system. When reindexing from a fast disk with a slow CPU, it
* can be up to 20, while when downloading from a slow network with a
* fast multicore CPU, it won't be much higher than 1.
*/
static const double SIGCHECK_VERIFICATION_FACTOR = 5.0;
bool fEnabled = true;
bool CheckBlock(int nHeight, const uint256& hash)
{
if (!fEnabled)
return true;
const MapCheckpoints& checkpoints = *Params().Checkpoints().mapCheckpoints;
MapCheckpoints::const_iterator i = checkpoints.find(nHeight);
if (i == checkpoints.end()) return true;
return hash == i->second;
}
//! Guess how far we are in the verification process at the given block index
double GuessVerificationProgress(CBlockIndex* pindex, bool fSigchecks)
{
if (pindex == NULL)
return 0.0;
int64_t nNow = time(NULL);
double fSigcheckVerificationFactor = fSigchecks ? SIGCHECK_VERIFICATION_FACTOR : 1.0;
double fWorkBefore = 0.0; // Amount of work done before pindex
double fWorkAfter = 0.0; // Amount of work left after pindex (estimated)
// Work is defined as: 1.0 per transaction before the last checkpoint, and
// fSigcheckVerificationFactor per transaction after.
const CCheckpointData& data = Params().Checkpoints();
if (pindex->nChainTx <= data.nTransactionsLastCheckpoint) {
double nCheapBefore = pindex->nChainTx;
double nCheapAfter = data.nTransactionsLastCheckpoint - pindex->nChainTx;
double nExpensiveAfter = (nNow - data.nTimeLastCheckpoint) / 71300.0 * data.fTransactionsPerDay;
fWorkBefore = nCheapBefore;
fWorkAfter = nCheapAfter + nExpensiveAfter * fSigcheckVerificationFactor;
} else {
double nCheapBefore = data.nTransactionsLastCheckpoint;
double nExpensiveBefore = pindex->nChainTx - data.nTransactionsLastCheckpoint;
double nExpensiveAfter = (nNow - pindex->GetBlockTime()) / 71300.0 * data.fTransactionsPerDay;
fWorkBefore = nCheapBefore + nExpensiveBefore * fSigcheckVerificationFactor;
fWorkAfter = nExpensiveAfter * fSigcheckVerificationFactor;
}
return fWorkBefore / (fWorkBefore + fWorkAfter);
}
int GetTotalBlocksEstimate()
{
if (!fEnabled)
return 0;
const MapCheckpoints& checkpoints = *Params().Checkpoints().mapCheckpoints;
return checkpoints.rbegin()->first;
}
CBlockIndex* GetLastCheckpoint()
{
if (!fEnabled)
return NULL;
const MapCheckpoints& checkpoints = *Params().Checkpoints().mapCheckpoints;
BOOST_REVERSE_FOREACH (const MapCheckpoints::value_type& i, checkpoints) {
const uint256& hash = i.second;
BlockMap::const_iterator t = mapBlockIndex.find(hash);
if (t != mapBlockIndex.end())
return t->second;
}
return NULL;
}
} // namespace Checkpoints
| [
"[email protected]"
] | |
0ac4235ed58e8333b05385d20fef49250c16cf4a | 56b39e09838edb807f4d11c9e913e87e486eefaa | /projekt/product_extract.cpp | fb44d18dc0f9dc36f074963f4d3c587d4bb16e2b | [] | no_license | Luckays/coffee | 2cfde6683f19b5a747d12d15a772c84ad78c7210 | 93bf8c6de20d75efcd6e15799fffb27b7130c0a4 | refs/heads/master | 2020-08-28T04:29:36.071789 | 2019-12-12T12:36:06 | 2019-12-12T12:36:06 | 217,590,497 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,324 | cpp | #include "product_extract.h"
#include "ui_product_extract.h"
#include <QSqlTableModel>
product_extract::product_extract(int h,QWidget *parent)
: QDialog(parent),
ui(new Ui::product_extract)
{//open favorite, set colour, title and icon
ui->setupUi(this);
this->setStyleSheet("background-color: ;");
setWindowTitle("Výpis produktu");
setWindowIcon(QIcon(":/img/mainIcon"));
//load information from mainwindow
hh = h;
QString H = QString::number(hh);
// select information from database and display it
QString dotazA = "SELECT produkt, zpracovani,chut,prazeni,odrudy.odruda,oblasti.oblast,produkty.intenzita,produkty.kyselost FROM produkty JOIN oblasti ON oblasti.oblast_id = produkty.oblast_id JOIN odrudy ON odrudy.odruda_id = produkty.odruda_id WHERE produkt_id = %1";
QSqlQuery dotaz (dotazA.arg(H));
QString produkt;
QString proc;
QString roast;
QString var;
QString plac;
QString chut;
QString intenzite;
QString kyselost;
while (dotaz.next())
{
produkt = dotaz.value("produkt").toString();
proc = dotaz.value("zpracovani").toString();
roast = dotaz.value("prazeni").toString();
var = dotaz.value("odrudy.odruda").toString();
plac = dotaz.value("oblasti.oblast").toString();
chut = dotaz.value("chut").toString();
intenzite = dotaz.value("intenzita").toString();
kyselost = dotaz.value("kyselost").toString();
}
ui->lineEdit_product->setText(produkt);
ui->lineEdit_proc->setText(proc);
ui->lineEdit_roast->setText(roast);
ui->lineEdit_var->setText(var);
ui->lineEdit_place->setText(plac);
ui->label_kyselost->setText(kyselost);
ui->textEdit->setText(chut);
if(intenzite == '1'){
//display pictures of intenzita
QPixmap image(":/img/inten1");
ui->label_int->setPixmap(image);
}
else if(intenzite == '2'){
QPixmap image(":/img/inten2");
ui->label_int->setPixmap(image);
}
else if(intenzite == '3'){
QPixmap image(":/img/inten3");
ui->label_int->setPixmap(image);
}
else if(intenzite == '4'){
QPixmap image(":/img/inten4");
ui->label_int->setPixmap(image);
}
else if(intenzite == '5'){
QPixmap image(":/img/inten5");
ui->label_int->setPixmap(image);
}
else if(intenzite == '-' or intenzite == NULL){
QPixmap image(":/img/inten0");
ui->label_int->setPixmap(image);
}
//display pictures of kyselost
if(kyselost == '1'){
QPixmap image(":/img/inten1");
ui->label_kyselost->setPixmap(image);
}
else if(kyselost == '2'){
QPixmap image(":/img/inten2");
ui->label_kyselost->setPixmap(image);
}
else if(kyselost == '3'){
QPixmap image(":/img/inten3");
ui->label_kyselost->setPixmap(image);
}
else if(kyselost == '4'){
QPixmap image(":/img/inten4");
ui->label_kyselost->setPixmap(image);
}
else if(kyselost == '5'){
QPixmap image(":/img/inten5");
ui->label_kyselost->setPixmap(image);
}
else if(kyselost == '-' or kyselost == NULL){
QPixmap image(":/img/inten0");
ui->label_kyselost->setPixmap(image);
}
}
product_extract::~product_extract()
{
delete ui;
}
// button close
void product_extract::on_close_clicked()
{
this->close();
}
| [
"[email protected]"
] | |
fe8338b5f859c35e10f70b5bb8d0bfd40e8933b2 | ae94d634b7ba20328886ad18f0615b6d376ac503 | /count_primes.cpp | 56e95cc36d9937fc41f922fe2c5387bdce1ca7fd | [] | no_license | HavinLeung/cpp_leetcode | 9cfa30d57336145d648be68c7eaecd8e4d3bc95c | 3b04de407ceae6ffb669dbe9767254e3c295a18f | refs/heads/master | 2023-02-20T04:52:33.127121 | 2021-01-17T22:50:12 | 2021-01-17T22:50:12 | 322,943,210 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 668 | cpp | #include <vector>
#include <array>
#include <algorithm>
#include <unordered_map>
#include <string>
#include <iostream>
#define ll long long
#define ul unsigned ll
using std::vector;
class Solution {
public:
int countPrimes(int n) {
// todo - more efficient version
if (n <= 2) return 0;
vector<int> primes = {2};
for (int i = 3; i < n; ++i) {
bool is_prime = true;
for (auto& prime : primes) {
if (i % prime == 0){
is_prime = false;
break;
} else if (prime*prime >= i) break;
}
if (is_prime) primes.emplace_back(i);
}
return primes.size();
}
};
| [
"[email protected]"
] | |
284fb3158ed4dc0e8023efe9791ceeef815724e3 | 84c94cb8d791c7ff373ea4f212ea34c8095c8b5d | /Homework_CPP_OOP/Homework_12_realy_this_01/TEST.cpp | d2811a8083eb5e1ce705776ef000ba5e5753a31b | [] | no_license | AlexIvFreeworld/cpp_course_practice | 52584996967bdcb87d74521187c54558319b6859 | 140c56abb539ef7720a714009327d898a9eb2c7e | refs/heads/master | 2020-11-28T05:30:16.869324 | 2019-12-23T09:35:03 | 2019-12-23T09:35:03 | 229,716,600 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,051 | cpp | #include "Header.h"
#include "Header_TEST.h"
bool test_square_positive() {
cout << "test_square_positive : ";
point p1, p2;
p1.set_X(1);
p2.set_X(2);
p1.set_Y(2);
p2.set_Y(4);
int result = 2;
if (result == square(p1, p2)) {
return true;
}
else {
return false;
}
}
bool test_square_positive_p2_to_p1() {
cout << "test_square_positive_p2_to_p1 : ";
point p1, p2;
p1.set_X(2);
p2.set_X(1);
p1.set_Y(4);
p2.set_Y(2);
int result = 2;
if (result == square(p1, p2)) {
return true;
}
else {
return false;
}
}
bool test_square_positive_p2_to_negative_p1() {
cout << "test_square_positive_p2_to_negative_p1 : ";
point p1, p2;
p1.set_X(-2);
p2.set_X(1);
p1.set_Y(-4);
p2.set_Y(2);
int result = 18;
if (result == square(p1, p2)) {
return true;
}
else {
return false;
}
}
bool test_square_positive_p1_to_negative_p2() {
cout << "test_square_positive_p1_to_negative_p2 : ";
point p1, p2;
p1.set_X(2);
p2.set_X(-1);
p1.set_Y(4);
p2.set_Y(-2);
int result = 18;
if (result == square(p1, p2)) {
return true;
}
else {
return false;
}
}
bool test_square_positive_X_negative_Y() {
cout << "test_square_positive_X_negative_Y : ";
point p1, p2;
p1.set_X(2);
p2.set_X(1);
p1.set_Y(-4);
p2.set_Y(-2);
int result = 2;
if (result == square(p1, p2)) {
return true;
}
else {
return false;
}
}
bool test_square_negative_X_positive_Y() {
cout << "test_square_negative_X_positive_Y : ";
point p1, p2;
p1.set_X(-2);
p2.set_X(-1);
p1.set_Y(4);
p2.set_Y(2);
int result = 2;
if (result == square(p1, p2)) {
return true;
}
else {
return false;
}
}
bool test_square_negative() {
cout << "test_square_negative : ";
point p1, p2;
p1.set_X(-1);
p2.set_X(-2);
p1.set_Y(-2);
p2.set_Y(-4);
int result = 2;
if (result == square(p1, p2)) {
return true;
}
else {
return false;
}
}
bool test_square_negative_p2_to_p1() {
cout << "test_square_negative_p2_to_p1 : ";
point p1, p2;
p1.set_X(-2);
p2.set_X(-1);
p1.set_Y(-4);
p2.set_Y(-2);
int result = 2;
if (result == square(p1, p2)) {
return true;
}
else {
return false;
}
}
void true_or_false(bool x) {
x == 1 ? cout << "OK" << endl: cout << "Error" << endl;
}
bool test_lenght_positive() {
cout << "test_lenght_positive : ";
point p1, p2;
p1.set_X(1);
p2.set_X(2);
p1.set_Y(2);
p2.set_Y(4);
char result_ch_true[8] = "223606";
char result_ch_func[100];
itoa(lenght(p1, p2)*100000, result_ch_func,10);
//cout << "result true : " << result_ch_true << endl;
//cout << "result test func : " << result_ch_func << endl;
if (!strcmp(result_ch_true, result_ch_func)) {
return true;
}
else {
return false;
}
}
bool test_lenght_negative() {
cout << "test_lenght_negative : ";
point p1, p2;
p1.set_X(-2);
p2.set_X(-1);
p1.set_Y(-4);
p2.set_Y(-2);
char result_ch_true[8] = "223606";
char result_ch_func[100];
itoa(lenght(p1, p2) * 100000, result_ch_func, 10);
//cout << "result true : " << result_ch_true << endl;
//cout << "result test func : " << result_ch_func << endl;
if (!strcmp(result_ch_true, result_ch_func)) {
return true;
}
else {
return false;
}
}
bool test_lenght_positive_p2_to_p1() {
cout << "test_lenght_positive_p2_to_p1 : ";
point p1, p2;
p1.set_X(2);
p2.set_X(1);
p1.set_Y(4);
p2.set_Y(2);
char result_ch_true[8] = "223606";
char result_ch_func[100];
itoa(lenght(p1, p2) * 100000, result_ch_func, 10);
//cout << "result true : " << result_ch_true << endl;
//cout << "result test func : " << result_ch_func << endl;
if (!strcmp(result_ch_true, result_ch_func)) {
return true;
}
else {
return false;
}
}
bool test_lenght_positive_p1_to_negative_p2() {
cout << "test_lenght_positive_p1_to_negative_p2 : ";
point p1, p2;
p1.set_X(1);
p2.set_X(-2);
p1.set_Y(2);
p2.set_Y(-4);
char result_ch_true[8] = "670820";
char result_ch_func[100];
itoa(lenght(p1, p2) * 100000, result_ch_func, 10);
//cout << "result true : " << result_ch_true << endl;
//cout << "result test func : " << result_ch_func << endl;
if (!strcmp(result_ch_true, result_ch_func)) {
return true;
}
else {
return false;
}
}
bool test_lenght_positive_p2_to_negative_p1() {
cout << "test_lenght_positive_p2_to_negative_p1 : ";
point p1, p2;
p1.set_X(-2);
p2.set_X(1);
p1.set_Y(-4);
p2.set_Y(2);
char result_ch_true[8] = "670820";
char result_ch_func[100];
itoa(lenght(p1, p2) * 100000, result_ch_func, 10);
//cout << "result true : " << result_ch_true << endl;
//cout << "result test func : " << result_ch_func << endl;
if (!strcmp(result_ch_true, result_ch_func)) {
return true;
}
else {
return false;
}
}
bool test_lenght_negative_p2_to_p1() {
cout << "test_lenght_negative_p2_to_p1 : ";
point p1, p2;
p1.set_X(-1);
p2.set_X(-2);
p1.set_Y(-2);
p2.set_Y(-4);
char result_ch_true[8] = "223606";
char result_ch_func[100];
itoa(lenght(p1, p2) * 100000, result_ch_func, 10);
//cout << "result true : " << result_ch_true << endl;
//cout << "result test func : " << result_ch_func << endl;
if (!strcmp(result_ch_true, result_ch_func)) {
return true;
}
else {
return false;
}
}
bool test_lenght_positive_X_negative_Y() {
cout << "test_lenght_positive_X_negative_Y : ";
point p1, p2;
p1.set_X(1);
p2.set_X(2);
p1.set_Y(-2);
p2.set_Y(-4);
char result_ch_true[8] = "223606";
char result_ch_func[100];
itoa(lenght(p1, p2) * 100000, result_ch_func, 10);
//cout << "result true : " << result_ch_true << endl;
//cout << "result test func : " << result_ch_func << endl;
if (!strcmp(result_ch_true, result_ch_func)) {
return true;
}
else {
return false;
}
}
bool test_lenght_negative_X_positive_Y() {
cout << "test_lenght_negative_X_positive_Y : ";
point p1, p2;
p1.set_X(-2);
p2.set_X(-1);
p1.set_Y(4);
p2.set_Y(2);
char result_ch_true[8] = "223606";
char result_ch_func[100];
itoa(lenght(p1, p2) * 100000, result_ch_func, 10);
//cout << "result true : " << result_ch_true << endl;
//cout << "result test func : " << result_ch_func << endl;
if (!strcmp(result_ch_true, result_ch_func)) {
return true;
}
else {
return false;
}
} | [
"[email protected]"
] | |
bd2b710d493df7a2752e0a919c372d7d3a2f8f37 | b10a3a4582f532cc6c2370c24b61b2ddb909d36d | /common/inc/modbus_common.h | e5777fdfd2448384b6f1c48fc00fcae87607315a | [
"CC0-1.0"
] | permissive | lunarpulse/stm32template | b595f08761d09ce8204c2ad34cff7d9a5f931a11 | c7a55661c21a3ea0266b1e3950c6fb5210ccff25 | refs/heads/main | 2023-07-03T04:45:08.170976 | 2021-07-22T18:08:53 | 2021-07-22T18:08:53 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,258 | h | /*
* Common modbus types for inclusion by
* modbus_defs.h and packets.h
*/
#pragma once
#include "basic.h"
#include <stdint.h>
// 21 functions listed in:
// https://modbus.org/docs/Modbus_Application_Protocol_V1_1b.pdf
// But we're only using 3 of them.
enum class FunctionCode : uint8_t
{
ReadMultipleRegisters = 0x03,
WriteSingleRegister = 0x06,
WriteMultipleRegisters = 0x10,
// Error bit
Exception = 0x80,
};
// https://modbus.org/docs/Modbus_Application_Protocol_V1_1b.pdf
enum class ExceptionCode : uint8_t
{
IllegalFunction = 0x01,
IllegalDataAddress = 0x02,
IllegalDataValue = 0x03,
SlaveDeviceFailure = 0x04,
Acknowledge = 0x05,
// We aren't planning on receiving any of the below exceptions.
// SlaveDeviceBusy = 0x06,
// MemoryParityError = 0x08,
// GatewayPathUnavailable = 0x0A,
// GatewayTargetFailedToRespond = 0x0B,
};
constexpr const char* exceptionCodeToString(ExceptionCode exceptionCode)
{
switch (exceptionCode) {
ENUM_STRING(ExceptionCode, IllegalFunction)
ENUM_STRING(ExceptionCode, IllegalDataAddress)
ENUM_STRING(ExceptionCode, IllegalDataValue)
ENUM_STRING(ExceptionCode, SlaveDeviceFailure)
ENUM_STRING(ExceptionCode, Acknowledge)
}
return "InvalidExceptionCode";
} | [
"[email protected]"
] | |
9efffbf7210a40910c2e18d00bbd7635fb6cc396 | 5ee7b59b955ebde297f0dd924382a96a79771681 | /appplnr/PnlPlnrUsgHeadbar.h | e37e762e47b7e1979dbf5273fad93d5dfbe48539 | [] | no_license | epsitech/planar | a3b22468e6718342218143538a93e7af50debee0 | e97374190feaf229dac4ec941e19f6661150e400 | refs/heads/master | 2021-01-21T04:25:32.542626 | 2016-08-07T19:20:49 | 2016-08-07T19:20:49 | 48,572,177 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,765 | h | /**
* \file PnlPlnrUsgHeadbar.h
* app access code for job PnlPlnrUsgHeadbar (declarations)
* \author Alexander Wirthmueller
* \date created: 4 Dec 2015
* \date modified: 4 Dec 2015
*/
#ifndef PNLPLNRUSGHEADBAR_H
#define PNLPLNRUSGHEADBAR_H
#include "AppPlnr_blks.h"
/**
* PnlPlnrUsgHeadbar
*/
namespace PnlPlnrUsgHeadbar {
/**
* StgInf (full: StgInfPlnrUsgHeadbar)
*/
class StgInf : public Block {
public:
static const uint MENAPPCPTWIDTH = 1;
static const uint MENAPPWIDTH = 2;
static const uint MENCRDCPTWIDTH = 3;
static const uint MENCRDWIDTH = 4;
public:
StgInf(const uint MenAppCptwidth = 100, const uint MenAppWidth = 100, const uint MenCrdCptwidth = 100, const uint MenCrdWidth = 100);
public:
uint MenAppCptwidth;
uint MenAppWidth;
uint MenCrdCptwidth;
uint MenCrdWidth;
public:
bool readXML(xmlXPathContext* docctx, string basexpath = "", bool addbasetag = false);
set<uint> comm(const StgInf* comp);
set<uint> diff(const StgInf* comp);
};
/**
* Tag (full: TagPlnrUsgHeadbar)
*/
class Tag : public Block {
public:
static const uint MENAPP = 1;
static const uint MENCRD = 2;
public:
Tag(const string& MenApp = "", const string& MenCrd = "");
public:
string MenApp;
string MenCrd;
public:
bool readXML(xmlXPathContext* docctx, string basexpath = "", bool addbasetag = false);
};
/**
* DpchEngData (full: DpchEngPlnrUsgHeadbarData)
*/
class DpchEngData : public DpchEngPlnr {
public:
static const uint SCRJREF = 1;
static const uint STGINF = 2;
static const uint TAG = 3;
public:
DpchEngData();
public:
StgInf stginf;
Tag tag;
public:
void readXML(xmlXPathContext* docctx, string basexpath = "", bool addbasetag = false);
};
};
#endif
| [
"[email protected]"
] | |
897fa25a536cbeda23f41932ccfd786fa8735eb0 | b2c3c301d23d5acfbc649eb569826816cb740316 | /test/extensions/common/tap/tap_config_base_test.cc | c01f992e43c882a8084671f8d84670992bb7c3a3 | [
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | datuanmac/envoy | 7dc90a9b6bacf2bbec360155b16085bfcded2538 | e8ecf08f92941c4a2a892efc9b7dd672cfbb3fe8 | refs/heads/master | 2020-04-25T15:16:35.020274 | 2019-02-27T05:47:13 | 2019-02-27T05:47:13 | 172,872,851 | 0 | 0 | Apache-2.0 | 2019-02-27T08:14:28 | 2019-02-27T08:14:28 | null | UTF-8 | C++ | false | false | 3,159 | cc | #include "common/buffer/buffer_impl.h"
#include "extensions/common/tap/tap_config_base.h"
#include "gtest/gtest.h"
namespace Envoy {
namespace Extensions {
namespace Common {
namespace Tap {
namespace {
TEST(AddBufferToProtoBytes, All) {
{
Buffer::OwnedImpl data("hello");
envoy::data::tap::v2alpha::Body body;
Utility::addBufferToProtoBytes(body, 5, data, 4, 1);
EXPECT_EQ("o", body.as_bytes());
EXPECT_FALSE(body.truncated());
}
{
Buffer::OwnedImpl data("hello");
envoy::data::tap::v2alpha::Body body;
Utility::addBufferToProtoBytes(body, 3, data, 0, 5);
EXPECT_EQ("hel", body.as_bytes());
EXPECT_TRUE(body.truncated());
}
{
Buffer::OwnedImpl data("hello");
envoy::data::tap::v2alpha::Body body;
Utility::addBufferToProtoBytes(body, 100, data, 0, 5);
EXPECT_EQ("hello", body.as_bytes());
EXPECT_FALSE(body.truncated());
}
}
TEST(TrimSlice, All) {
{
std::vector<Buffer::RawSlice> slices;
Utility::trimSlices(slices, 0, 100);
EXPECT_TRUE(slices.empty());
}
{
std::vector<Buffer::RawSlice> slices = {{0x0, 5}};
Utility::trimSlices(slices, 0, 100);
const std::vector<Buffer::RawSlice> expected{{0x0, 5}};
EXPECT_EQ(expected, slices);
}
{
std::vector<Buffer::RawSlice> slices = {{0x0, 5}};
Utility::trimSlices(slices, 3, 3);
const std::vector<Buffer::RawSlice> expected{{reinterpret_cast<void*>(0x3), 2}};
EXPECT_EQ(expected, slices);
}
{
std::vector<Buffer::RawSlice> slices = {{0x0, 5}, {0x0, 4}};
Utility::trimSlices(slices, 3, 3);
const std::vector<Buffer::RawSlice> expected{{reinterpret_cast<void*>(0x3), 2},
{reinterpret_cast<void*>(0x0), 1}};
EXPECT_EQ(expected, slices);
}
{
std::vector<Buffer::RawSlice> slices = {{0x0, 5}, {0x0, 4}};
Utility::trimSlices(slices, 6, 3);
const std::vector<Buffer::RawSlice> expected{{reinterpret_cast<void*>(0x5), 0},
{reinterpret_cast<void*>(0x1), 3}};
EXPECT_EQ(expected, slices);
}
{
std::vector<Buffer::RawSlice> slices = {{0x0, 5}, {0x0, 4}};
Utility::trimSlices(slices, 0, 0);
const std::vector<Buffer::RawSlice> expected{{reinterpret_cast<void*>(0x0), 0},
{reinterpret_cast<void*>(0x0), 0}};
EXPECT_EQ(expected, slices);
}
{
std::vector<Buffer::RawSlice> slices = {{0x0, 5}, {0x0, 4}};
Utility::trimSlices(slices, 0, 3);
const std::vector<Buffer::RawSlice> expected{{reinterpret_cast<void*>(0x0), 3},
{reinterpret_cast<void*>(0x0), 0}};
EXPECT_EQ(expected, slices);
}
{
std::vector<Buffer::RawSlice> slices = {{0x0, 5}, {0x0, 4}};
Utility::trimSlices(slices, 1, 3);
const std::vector<Buffer::RawSlice> expected{{reinterpret_cast<void*>(0x1), 3},
{reinterpret_cast<void*>(0x0), 0}};
EXPECT_EQ(expected, slices);
}
}
} // namespace
} // namespace Tap
} // namespace Common
} // namespace Extensions
} // namespace Envoy
| [
"[email protected]"
] | |
ffe82f43ef07e884ab0624e405b785b9d52966d2 | cec3337337b428d45efb561339b418d85dd760b4 | /C++/Navio/MB85RC04.h | 386bfa9b568620bb9b46e56c74472418ce5b1e69 | [] | no_license | ernieift/Navio | 49341e4de21dc998627b2805e99c803fb6bc880d | ed34f0e6dbaffa720f4baae1e3b18a417360df9c | refs/heads/master | 2021-01-15T08:42:43.505556 | 2014-10-29T15:00:44 | 2014-10-29T15:00:44 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,098 | h | /*
MB85RC04 driver code is placed under the BSD license.
Written by Egor Fedorov ([email protected])
Copyright (c) 2014, Emlid Limited
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the Emlid Limited nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL EMLID LIMITED BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef MB85RC04_HPP
#define MB85RC04_HPP
#include <stdint.h>
#include <stdlib.h>
#include <unistd.h>
#include "I2Cdev.h"
class MB85RC04
{
uint8_t device_address;
public:
MB85RC04();
uint8_t readByte(uint16_t register_address, uint8_t* data);
uint8_t writeByte(uint16_t register_address, uint8_t data);
uint8_t readBytes(uint16_t register_address, uint8_t length, uint8_t* data);
uint8_t writeBytes(uint16_t register_address, uint8_t length, uint8_t* data);
};
#endif // MB85RC04_HPP
| [
"[email protected]"
] | |
292f52c9b295a5e458a6c646930c23469b13e56f | cfeac52f970e8901871bd02d9acb7de66b9fb6b4 | /generated/src/aws-cpp-sdk-iam/source/model/DetachGroupPolicyRequest.cpp | 4aba85f03eb7cc85a072b9aae28c6b4539d215af | [
"Apache-2.0",
"MIT",
"JSON"
] | permissive | aws/aws-sdk-cpp | aff116ddf9ca2b41e45c47dba1c2b7754935c585 | 9a7606a6c98e13c759032c2e920c7c64a6a35264 | refs/heads/main | 2023-08-25T11:16:55.982089 | 2023-08-24T18:14:53 | 2023-08-24T18:14:53 | 35,440,404 | 1,681 | 1,133 | Apache-2.0 | 2023-09-12T15:59:33 | 2015-05-11T17:57:32 | null | UTF-8 | C++ | false | false | 989 | cpp | /**
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
* SPDX-License-Identifier: Apache-2.0.
*/
#include <aws/iam/model/DetachGroupPolicyRequest.h>
#include <aws/core/utils/StringUtils.h>
#include <aws/core/utils/memory/stl/AWSStringStream.h>
using namespace Aws::IAM::Model;
using namespace Aws::Utils;
DetachGroupPolicyRequest::DetachGroupPolicyRequest() :
m_groupNameHasBeenSet(false),
m_policyArnHasBeenSet(false)
{
}
Aws::String DetachGroupPolicyRequest::SerializePayload() const
{
Aws::StringStream ss;
ss << "Action=DetachGroupPolicy&";
if(m_groupNameHasBeenSet)
{
ss << "GroupName=" << StringUtils::URLEncode(m_groupName.c_str()) << "&";
}
if(m_policyArnHasBeenSet)
{
ss << "PolicyArn=" << StringUtils::URLEncode(m_policyArn.c_str()) << "&";
}
ss << "Version=2010-05-08";
return ss.str();
}
void DetachGroupPolicyRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
{
uri.SetQueryString(SerializePayload());
}
| [
"[email protected]"
] | |
00a51d4c450ddca770db63e2b9f46bd41bbd34bd | 8a45f1803d67e98aa59421981c95a5865d4dbf60 | /appendix/sample_const.cpp | 3a1992441534d0b44e93f880827710edd80a1d56 | [] | no_license | walter-cc/cpp | 1a2e2f01692be15ad1224d6abe76c6b766d08fa4 | 36b5d184d7b4e69753750d5132e87754957f7d2a | refs/heads/master | 2021-12-30T21:40:22.305507 | 2021-08-06T16:11:28 | 2021-08-06T16:13:21 | 162,880,321 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,636 | cpp | /*===============================
執行結果
cc@appendix$g++ sample_const.cpp -o test
sample_const.cpp: In function ‘int main()’:
sample_const.cpp:37:18: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
char *strB = "test";
^
cc@appendix$./test
3
5
4
6
Test
Test
Test
===============================
# 參考文件 :
【C 語言入門】24.2 - const 修飾字
https://youtu.be/R2rhMxtjuv0
【C 語言入門】24.4 - 指標與 const
https://youtu.be/WM4AjsigcPY
【C 語言入門】24.3 - 字串字面常數與 const char *
https://youtu.be/0XlbDK2l1V4
*/
#include <iostream> // 引入標準程式庫中相關的輸入、輸出程式
#include <cstdlib>
using namespace std; // std 為標準程式庫的命名空間
//#define GET_COMPILE_ERROR_LOG
int main(void) {
int a = 3;
const int b = 5; // 要給定初始值
int c[3] = {4, 5, 6};
const int d[3] = {6, 7, 8}; // 要給定初始值
// 一般我們只會使用 strA[] & const char *strC 這種方式。
char strA[] = "test"; // 將字串存成一個字元陣列，大小為5
char *strB = "test";
/* 特例，不能使用。"test"為系統所提供的字元陣列，它是read only，我們不可以修改它的資料。
編譯時會造成的warning。
error log : warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]*/
const char *strC = "test"; // read only，正常我們會使用的方式
cout << a << endl;
cout << b << endl;
cout << c[0] << endl;
cout << d[0] << endl;
a = 4;
#ifdef GET_COMPILE_ERROR_LOG
b = 6; //會出現編譯錯誤
/*
log :
error: assignment of read-only variable ‘b’
b = 6;
*/
#endif
c[0] = 10;
#ifdef GET_COMPILE_ERROR_LOG
d[0] = 11; //會出現編譯錯誤
/*
log :
error: assignment of read-only location ‘d[0]’
d[0] = 11;
*/
#endif
strA[0] = 'T'; // O，因為 strA 是真實存在記憶體中的一個字元陣列，是「我們自己宣告」的。
#ifdef GET_COMPILE_ERROR_LOG
strB[0] = 'T'; // X(未定義行為)，因為 strB 是一個指標，它指向「系統提供」的字元陣列，我們當然無法改變
/* 執行時會造成的core dump
error log : Segmentation fault (core dumped)*/
strC[0] = 'T'; // X(編譯失敗)，因為在前面已經宣告為read only
/* 編譯時會造成的error log :
error: assignment of read-only location ‘* strC’*/
strA = strB; // (char []) = (char *) (X)，陣列無法放在等號左邊
/*error: incompatible types in assignment of ‘char*’ to ‘char [5]’*/
strA = strC; // (char []) = (const char *) (X)，陣列無法放在等號左邊
/*error: incompatible types in assignment of ‘const char*’ to ‘char [5]’*/
#endif
strB = strA; // (char *) = (char []) (O)，strA為其元素[0]的address，可以隱性複製到 strB
#ifdef GET_COMPILE_ERROR_LOG
strB = strC; // (char *) = (const char *)(X)，因為 strC 在前面已經宣告為read only，今天又把 strC 複製給 strB，這樣會造成 strB 可以去修改 strC所指的字串(由系統提供的字串)
/*error: invalid conversion from ‘const char*’ to ‘char*’ [-fpermissive]*/
#endif
strC = strA; // (const char *) = (char []) (O)，原本可讀可寫，轉成唯讀
strC = strB; // (const char *) = (char *) (O)，原本可讀可寫，轉成唯讀
cout << strA << endl;
cout << strB << endl;
cout << strC << endl;
return 0;
}
| [
"[email protected]"
] | |
197038c5161e45f0849d0e6b8a5c633974175049 | 6059ef7bc48ab49c938f075dc5210a19ec08538e | /src/plugins/monocle/pagenumlabel.cpp | 794caab794a0341ed2e6a780b517e29941bc5766 | [
"BSL-1.0"
] | permissive | Laura-lc/leechcraft | 92b40aff06af9667aca9edd0489407ffc22db116 | 8cd066ad6a6ae5ee947919a97b2a4dc96ff00742 | refs/heads/master | 2021-01-13T19:34:09.767365 | 2020-01-11T15:25:31 | 2020-01-11T15:25:31 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,466 | cpp | /**********************************************************************
* LeechCraft - modular cross-platform feature rich internet client.
* Copyright (C) 2006-2014 Georg Rudoy
*
* Boost Software License - Version 1.0 - August 17th, 2003
*
* Permission is hereby granted, free of charge, to any person or organization
* obtaining a copy of the software and accompanying documentation covered by
* this license (the "Software") to use, reproduce, display, distribute,
* execute, and transmit the Software, and to prepare derivative works of the
* Software, and to permit third-parties to whom the Software is furnished to
* do so, all subject to the following:
*
* The copyright notices in the Software and this entire statement, including
* the above license grant, this restriction and the following disclaimer,
* must be included in all copies of the Software, in whole or in part, and
* all derivative works of the Software, unless such copies or derivative
* works are solely in the form of machine-executable object code generated by
* a source language processor.
*
* 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, TITLE AND NON-INFRINGEMENT. IN NO EVENT
* SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
* FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
**********************************************************************/
#include "pagenumlabel.h"
#include "xmlsettingsmanager.h"
namespace LC
{
namespace Monocle
{
PageNumLabel::PageNumLabel (QWidget *parent)
: QSpinBox { parent }
{
setSpecialValueText (" ");
XmlSettingsManager::Instance ().RegisterObject ("InvertedPageNumLabel",
this, [this] (const auto& invertedVar) { Inverted_ = invertedVar.toBool (); });
}
void PageNumLabel::SetTotalPageCount (int count)
{
blockSignals (true);
setSpecialValueText ({});
setSuffix (" / " + QString::number (count));
setRange (1, count);
blockSignals (false);
}
void PageNumLabel::SetCurrentPage (int page)
{
blockSignals (true);
setValue (page + 1);
blockSignals (false);
}
void PageNumLabel::stepBy (int steps)
{
if (Inverted_)
steps = -steps;
QAbstractSpinBox::stepBy (steps);
}
}
}
| [
"[email protected]"
] | |
1f18c4d8601ff8cc22c53508d38e1b71e848fead | ef7129ada2d77e4283ae29ff3cb6a64e43e09154 | /lte/gateway/c/core/oai/tasks/nas5g/src/ies/M5GSRegistrationResult.cpp | 80f3ddd2e21d85847d8ea28af82de362108578e9 | [
"BSD-3-Clause"
] | permissive | saurabhm3hra/magma | 57fcee8209f8aafe95626cea7ab7e4292abda37d | b4fbd71378935a35cabb13ca3762708033e09b88 | refs/heads/master | 2021-12-15T23:48:29.373368 | 2021-12-04T00:30:56 | 2021-12-04T00:30:56 | 188,944,355 | 1 | 0 | NOASSERTION | 2021-06-11T05:58:13 | 2019-05-28T03:05:00 | Go | UTF-8 | C++ | false | false | 2,691 | cpp | /*
Copyright 2020 The Magma Authors.
This source code is licensed under the BSD-style license found in the
LICENSE file in the root directory of this source tree.
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 <iostream>
#include <sstream>
#include <bitset>
#include <cstdint>
#include "lte/gateway/c/core/oai/tasks/nas5g/include/ies/M5GSRegistrationResult.h"
#include "lte/gateway/c/core/oai/tasks/nas5g/include/M5GCommonDefs.h"
namespace magma5g {
M5GSRegistrationResultMsg::M5GSRegistrationResultMsg(){};
M5GSRegistrationResultMsg::~M5GSRegistrationResultMsg(){};
// Decode 5GS Registration Result message and its IEs
int M5GSRegistrationResultMsg::DecodeM5GSRegistrationResultMsg(
M5GSRegistrationResultMsg* m5gs_reg_result, uint8_t iei, uint8_t* buffer,
uint32_t len) {
// Not yet implemented, Will be supported POST MVC
return 0;
};
// Encode 5GS Registration Result message and its IEs
int M5GSRegistrationResultMsg::EncodeM5GSRegistrationResultMsg(
M5GSRegistrationResultMsg* m5gs_reg_result, uint8_t iei, uint8_t* buffer,
uint32_t len) {
uint8_t* lenPtr;
uint32_t encoded = 0;
/*
* Checking IEI and pointer
*/
if (buffer == NULL) {
return TLV_BUFFER_NULL;
}
if (len < REGISTRATION_RESULT_MIN_LENGTH) {
return TLV_BUFFER_TOO_SHORT;
}
if (iei > 0) {
CHECK_IEI_ENCODER(iei, (unsigned char) m5gs_reg_result->iei);
*buffer = iei;
MLOG(MDEBUG) << "In EncodeM5GSRegistrationResultMsg___: iei = " << std::hex
<< int(*buffer);
encoded++;
}
lenPtr = (buffer + encoded);
encoded++;
*(buffer + encoded) = ((m5gs_reg_result->spare & 0xf) << 0x4) |
((m5gs_reg_result->sms_allowed & 0x1) << 3) |
(m5gs_reg_result->reg_result_val & 0x7);
MLOG(MDEBUG) << " EncodeM5GSRegistrationResultMsg : 0x0"
<< int(*(buffer + encoded)) << " ("
<< "spare = " << ((m5gs_reg_result->spare & 0xf) << 0x4)
<< ", sms allowed = "
<< ((m5gs_reg_result->sms_allowed & 0x1) << 3)
<< ", result val = " << std::hex
<< int(m5gs_reg_result->reg_result_val & 0x7) << ")";
encoded++;
*lenPtr = encoded - 1 - ((iei > 0) ? 1 : 0);
MLOG(MDEBUG) << " EncodeM5GSRegistrationResultMsg : length = 0x0" << std::hex
<< int(*lenPtr);
return encoded;
};
} // namespace magma5g
| [
"[email protected]"
] | |
c8241310b0a3649cb18c9ce7d880d53359ac5531 | ef9d89774f6b8eee203a6f3eaa381d5a5bfdf03c | /BaseLib/Socket.h | 5cf1d6fb0439f676c835bf7a1614cdd6dcfdca38 | [] | no_license | GrenderG/dbo-server | 71862f404e61937c9a3905068f7cf027460f76eb | afedcfc9a208a2680d42eb3d34b7f55af072a3c2 | refs/heads/master | 2021-09-04T02:25:49.570079 | 2018-01-14T16:58:22 | 2018-01-14T16:58:22 | 276,384,265 | 1 | 0 | null | 2020-07-01T13:24:57 | 2020-07-01T13:24:56 | null | UTF-8 | C++ | false | false | 5,067 | h | #ifndef _SOCKET
#define _SOCKET
#pragma once
#include "Base.h"
#include "GameString.h"
#include "SocketAddr.h"
enum SOCKET_ERROR_LIST
{
SOCK_OK,
SOCK_ERROR = -1
};
class Socket
{
public:
Socket() {};
~Socket() { Close(); };
static int StartUp();
static int CleanUp();
int Create();
int Close();
int Bind(SocketAddr& rSockAddr);
int Listen(int nBackLog = SOMAXCONN);
int Shutdown(int how);
int GetPeerName(GameString & rAddress, WORD & rPort);
int GetLocalName(GameString & rAddress, WORD & rPort);
int GetPeerAddr(SocketAddr & rAddr);
int GetLocalAddr(SocketAddr & rAddr);
int SetNonBlocking(BOOL bActive);
int SetReuseAddr(BOOL bActive);
int SetLinger(BOOL bActive, WORD wTime);
int SetTCPNoDelay(BOOL bActive);
int SetKeepAlive(BOOL bActive);
int SetKeepAlive(DWORD dwKeepAliveTime, DWORD dwKeepAliveInterval);
int SetConditionalAccept(BOOL bActive);
int GetCurReadSocketBuffer();
int Connect(struct sockaddr_in * sockaddr);
int SendStream(unsigned char *pSendBuffer, int nSendSize, bool bSendOut);
int RecvStream(BYTE * pRecvBuffer, int nRecvSize);
int AcceptEx(Socket &rAcceptSocket, PVOID lpOutputBuffer, DWORD dwReceiveDataLength, DWORD dwLocalAddressLength, DWORD dwRemoteAddressLength, LPDWORD lpdwBytesReceived, LPOVERLAPPED lpOverlapped);
int ConnectEx(const struct sockaddr* name, int namelen, PVOID lpSendBuffer, DWORD dwSendDataLength, LPDWORD lpdwBytesSent, LPOVERLAPPED lpOverlapped);
int DisconnectEx(LPOVERLAPPED lpOverlapped, DWORD dwFlags, DWORD reserved);
void GetAcceptExSockaddrs(PVOID lpOutputBuffer, DWORD dwReceiveDataLength, DWORD dwLocalAddressLength, DWORD dwRemoteAddressLength, LPSOCKADDR* LocalSockaddr, LPINT LocalSockaddrLength, LPSOCKADDR* RemoteSockaddr, LPINT RemoteSockaddrLength);
int RecvEx(LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesRecvd, LPDWORD lpFlags, LPWSAOVERLAPPED lpOverlapped);
int SendEx(LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesSent, DWORD dwFlags, LPWSAOVERLAPPED lpOverlapped);
void Attach(SOCKET socket) { _socket = socket; }
void Detach() { _socket = INVALID_SOCKET; }
bool IsCreated() { return INVALID_SOCKET != _socket; }
SOCKET GetRawSocket() { return _socket; }
operator SOCKET() { return *((SOCKET *)&_socket); }
Socket & operator=(const Socket & rhs);
protected:
static int LoadExAPI();
static int LoadExMethod(GUID functionID, LPVOID *pFunc);
SOCKET _socket;
static LPFN_ACCEPTEX _lpfnAcceptEx;
static LPFN_CONNECTEX _lpfnConnectEx;
static LPFN_DISCONNECTEX _lpfnDisconnectEx;
static LPFN_GETACCEPTEXSOCKADDRS _lpfnGetAcceptExSockAddrs;
static LPFN_TRANSMITFILE _lpfnTransmitFile;
};
inline int Socket::AcceptEx(Socket &rAcceptSocket, PVOID lpOutputBuffer, DWORD dwReceiveDataLength, DWORD dwLocalAddressLength, DWORD dwRemoteAddressLength, LPDWORD lpdwBytesReceived, LPOVERLAPPED lpOverlapped)
{
if (!_lpfnAcceptEx(_socket, rAcceptSocket.GetRawSocket(), lpOutputBuffer, dwReceiveDataLength, dwLocalAddressLength, dwRemoteAddressLength, lpdwBytesReceived, lpOverlapped))
{
int rc = WSAGetLastError();
if (ERROR_IO_PENDING != rc)
{
return rc;
}
}
return SOCK_OK;
}
inline int Socket::ConnectEx(const struct sockaddr* name, int namelen, PVOID lpSendBuffer, DWORD dwSendDataLength, LPDWORD lpdwBytesSent, LPOVERLAPPED lpOverlapped)
{
if (!_lpfnConnectEx(_socket, name, namelen, lpSendBuffer, dwSendDataLength, lpdwBytesSent, lpOverlapped))
{
int rc = WSAGetLastError();
if (ERROR_IO_PENDING != rc)
{
return rc;
}
}
return SOCK_OK;
}
inline int Socket::DisconnectEx(LPOVERLAPPED lpOverlapped, DWORD dwFlags, DWORD reserved)
{
if (!_lpfnDisconnectEx(_socket, lpOverlapped, dwFlags, reserved))
{
int rc = WSAGetLastError();
if (ERROR_IO_PENDING != rc)
{
return rc;
}
}
return SOCK_OK;
}
inline void Socket::GetAcceptExSockaddrs(PVOID lpOutputBuffer, DWORD dwReceiveDataLength, DWORD dwLocalAddressLength, DWORD dwRemoteAddressLength, LPSOCKADDR* LocalSockaddr, LPINT LocalSockaddrLength, LPSOCKADDR* RemoteSockaddr, LPINT RemoteSockaddrLength)
{
_lpfnGetAcceptExSockAddrs(lpOutputBuffer, dwReceiveDataLength, dwLocalAddressLength, dwRemoteAddressLength, LocalSockaddr, LocalSockaddrLength, RemoteSockaddr, RemoteSockaddrLength);
}
inline int Socket::RecvEx(LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesRecvd, LPDWORD lpFlags, LPWSAOVERLAPPED lpOverlapped)
{
if (0 != ::WSARecv(_socket, lpBuffers, dwBufferCount, lpNumberOfBytesRecvd, lpFlags, lpOverlapped, NULL))
{
int rc = WSAGetLastError();
if (ERROR_IO_PENDING != rc)
{
return rc;
}
}
return SOCK_OK;
}
inline int Socket::SendEx(LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesSent, DWORD dwFlags, LPWSAOVERLAPPED lpOverlapped)
{
if (0 != ::WSASend(_socket, lpBuffers, dwBufferCount, lpNumberOfBytesSent, dwFlags, lpOverlapped, NULL))
{
int rc = WSAGetLastError();
if (ERROR_IO_PENDING != rc)
{
return rc;
}
}
return SOCK_OK;
}
inline Socket & Socket::operator=(const Socket & rhs)
{
_socket = rhs._socket;
return *this;
}
#endif | [
"[email protected]"
] | |
ba245c6acb420cd0ea8ade0a6cbc98c1731e6898 | 35eb88ce19d8e94bcf85f7257206eda1cf4f10be | /namespaces.cpp | 9051574e8d4d63ac78bc2c9948ee1fa8d36662c3 | [] | no_license | diwii/helloworld-from-diwiii | 79aabb4407c2fc4a60ed99ec616678148db970d6 | 48b3d3b5632c67f62f633d569e7c97c6275ece2a | refs/heads/master | 2023-01-10T06:59:31.195636 | 2020-11-06T23:00:57 | 2020-11-06T23:00:57 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 817 | cpp | /**
* Vienā blokā nedrīkst vairrākārt definēt mainīgos ar vienādiem nosaukumiem.
*
**/
#include <iostream> // Input/Output plūsmas atbalsts
using namespace std; // Izmantot nosaukumus no C++ standarta bibliotēkas
namespace pirma {
int vertiba = 500; // Mainīgais izveidots iekš namespace
}
/*
* Galvenā programmas funkcija
* int nozīmē ka programma atgriezīs operetājsistēmai veselo skaitli.
*/
int main() // Galvenā programmas funkcija
{
int vertiba = 200; // main() funkcijas bloka lokālais mainīgais.
cout << vertiba << endl
<< pirma::vertiba << endl; // namespace mainīgajiem var piekļūt ārpus namespace, izmantojot operatoru "::"
// system("pause"); Operētājsistēmas specifiska komanda/konstrukcija.
return 0; // Atgriež operētājsistēmai 0
} | [
"[email protected]"
] | |
5aafb272cdf95a822efd4364369313667689741c | de7e771699065ec21a340ada1060a3cf0bec3091 | /sandbox/src/java/org/apache/lucene/codecs/idversion/SingleDocsEnum.cpp | 62ae00f8449516434afb0b7c405b180dd1b69f27 | [] | no_license | sraihan73/Lucene- | 0d7290bacba05c33b8d5762e0a2a30c1ec8cf110 | 1fe2b48428dcbd1feb3e10202ec991a5ca0d54f3 | refs/heads/master | 2020-03-31T07:23:46.505891 | 2018-12-08T14:57:54 | 2018-12-08T14:57:54 | 152,020,180 | 7 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,059 | cpp | using namespace std;
#include "SingleDocsEnum.h"
namespace org::apache::lucene::codecs::idversion
{
using PostingsEnum = org::apache::lucene::index::PostingsEnum;
using BytesRef = org::apache::lucene::util::BytesRef;
void SingleDocsEnum::reset(int singleDocID)
{
doc = -1;
this->singleDocID = singleDocID;
}
int SingleDocsEnum::nextDoc()
{
if (doc == -1) {
doc = singleDocID;
} else {
doc = NO_MORE_DOCS;
}
return doc;
}
int SingleDocsEnum::docID() { return doc; }
int SingleDocsEnum::advance(int target)
{
if (doc == -1 && target <= singleDocID) {
doc = singleDocID;
} else {
doc = NO_MORE_DOCS;
}
return doc;
}
int64_t SingleDocsEnum::cost() { return 1; }
int SingleDocsEnum::freq() { return 1; }
int SingleDocsEnum::nextPosition() { return -1; }
int SingleDocsEnum::startOffset() { return -1; }
int SingleDocsEnum::endOffset() { return -1; }
shared_ptr<BytesRef> SingleDocsEnum::getPayload()
{
throw make_shared<UnsupportedOperationException>();
}
} // namespace org::apache::lucene::codecs::idversion | [
"[email protected]"
] | |
d7655fb23c422bdc7a42c57ef18189aca20175b6 | e3725ef770a4ad2042ce3bdee3f34146bc540d08 | /masssss.cpp | 4dfb04505eb96948b4aff831919537b32a69d975 | [] | no_license | vladdenisov/learning-cpp | 887ff1cc8d29fd4dccc0939023a861548ec540b3 | 828b9706724a6edec66735a838dc2b0256cbd8c7 | refs/heads/master | 2021-07-24T17:59:12.788113 | 2020-04-21T09:36:14 | 2020-04-21T09:36:14 | 149,314,959 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 855 | cpp | #include <iostream>
#include <exception>
#include <string>
using namespace std;
struct element {
int key;
string value;};
class mass {
private:
element m[10];
int k;
public:
mass() {k = -1;}
void inse(int tmp_key, string tmp_str) {
k++;
m[k].key = tmp_key;
m[k].value = tmp_str;
}
int put_all() {
for (int i = 0; i < 10; i++, k++) {
int t;
string t_str;
cout << "Enter " << i << " key: OR You can enter 0 to stop pushing items ";
cin >> t;
if (t == 0) {break;}
cout << "Enter " << i << " value: ";
cin >> t_str;
m[i].key = t;
m[i].value = t_str;
}
return 0;
}
string return_val(int tmp_key) {
for (int i = 0; i < k; i++) {if (tmp_key = m[k].key){return m[k].value;}}
}
};
int main() {
mass x;
x.put_all();
int t;
cin >> t;
cout << x.return_val(t);
system("pause");
return 0;
}
| [
"[email protected]"
] | |
89e18db60058c584c0f4097aad7a3742eb58af99 | 10c0b342ad91be81b455298cf8dead71e0f90eb1 | /inspectwall.cpp | 9b1c9658cfc94a487c58c253a14be76de1c6612f | [] | no_license | oogab/programmers | 247a5bf1018cd9eb915eec7532b025c948324b10 | 716ee3f52bc75cdbc0ab6046fe36bba960191159 | refs/heads/master | 2020-12-20T04:33:58.793855 | 2020-06-12T08:24:42 | 2020-06-12T08:24:42 | 235,963,590 | 0 | 0 | null | 2020-04-03T15:41:32 | 2020-01-24T08:15:15 | Python | UTF-8 | C++ | false | false | 2,946 | cpp | #include <string>
#include <vector>
#include <algorithm>
using namespace std;
int solution(int n, vector<int> weak, vector<int> dist) {
int answer = 10;
sort(dist.begin(), dist.end(), [](int a, int b) { return a > b; }); // 이렇게 사용할 수 있는거 신기하다.
int fr_num; // friend_number 선별할 친구의 숫자.
// 시작점을 바꿔가면서 외벽 점검.
for(int i=0; i<n; i++) {
vector<int> selected;
fr_num = 1;
int dsize = dist.size();
bool cover = false;
// 취약점을 모두 점검하지 못했고 더이상 친구를 투입할 수 없을 때까지
while(fr_num <= dsize && !cover) {
cover = true;
selected.clear();
// 가장 긴 거리를 점검할 수 있는 친구를 선발 가능한 인원만큼 선발
for (int j = 0; j < fr_num; j++)
selected.push_back(dist[j]);
do {
cover = true;
int wi = 0;
int si = 0;
int start = weak[wi];
int end = start + selected[si];
while(1) {
// 선발한 친구들로 모든 취약점이 점검이 가능할 경우.
if (start <= weak[wi] && weak[wi] <= end) {
wi++;
// 마지막 취약 지점이라면
if (weak.size() <= wi) {
cover = true;
break;
}
}
// 선발한 친구들로 취약점을 모두 점검할 수 없을 경우.
else {
si++;
// 선발한 친구중 더이상 투입할 사람들이 남아있지 않을 경우.
if (fr_num <= si) {
cover = false;
break;
}
start = weak[wi];
end = start + selected[si];
}
}
if(cover) // 모든 취약점을 커버했을 경우.
answer = answer < fr_num ? answer : fr_num;
// 선발한 친구의 출발 순서를 변경하면서 외벽 점검.
} while(prev_permutation(selected.begin(), selected.end()));
fr_num++; // 선발할 친구의 숫자를 늘림.
}
weak[0] += n; // 시작점을 다음칸으로 옮김.
sort(weak.begin(), weak.end());
}
if(answer == 10) // 정답이 안바뀌었으면 -1 전달.
answer = -1;
return answer;
}
// https://lameld.github.io/kakao/2020_circular/
// 생각한 방법은 같으나... 구현이 잘 안되어서 보고 거의 외우다시피 공부했습니다. | [
"[email protected]"
] | |
532163508fc2262943c300cee034e2e56103fc69 | 72b35773f4570206f266f7739a701039b7cf9806 | /src/class/Mesh.h | b9728cf209407ac60edbda85a7ba2ca10c908665 | [
"Apache-2.0"
] | permissive | Kaitou345/nd_renderer | d2f7007c50e7eeb042419d17e47c844b51722b4b | b31e9a62384be1dc2272829614cd1e2403c409f4 | refs/heads/main | 2023-08-16T10:55:54.514979 | 2021-09-01T14:05:56 | 2021-09-01T14:05:56 | 402,081,498 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 584 | h | #ifndef MESH
#define MESH
#include <pch.h>
#include "VertexBuffer.h"
#include "IndexBuffer.h"
#include "shader.h"
class Mesh
{
public:
inline Mesh() = default;
Mesh(std::vector<GLfloat>& vertices, std::vector<GLuint>& indices);
void AddData(std::vector<GLfloat>& vertices, std::vector<GLuint>& indices);
inline unsigned int GetIndexCount() { return m_IB.Count(); }
inline void Bind()
{
m_VB.Bind();
m_IB.Bind();
m_VB.EnableLayouts();
}
void RenderMesh(const Shader& shader);
private:
VertexBuffer m_VB;
IndexBuffer m_IB;
};
#endif | [
"[email protected]"
] | |
75692cceb74f51f40bbb36b314a4920d3f052fcd | e0381dddf45192f4c2d4ebf789974f6db87b86c4 | /eBox_STM32F1/common/edriver/WS2812B.cpp | 658b0abd8598ed2470fe77d1a96000671462da8e | [] | no_license | longsky19856/SI4432_TEST | e6fa6164795224970248e97b86bc308f5a1a6187 | 7e6f480cddcf1512a0769d767ca680f165f88e7b | refs/heads/master | 2021-09-01T18:24:11.686442 | 2017-12-28T07:20:56 | 2017-12-28T07:23:45 | 108,821,433 | 0 | 1 | null | null | null | null | GB18030 | C++ | false | false | 14,198 | cpp |
/*===========================================================================
* 程序名称:
* 源文件名: WS2812B.cpp
* 创建日期: 2017.09.14
* 作 者: xzwj
* 网 站：http://www.cnblogs.com/xzwj/
* 版本说明:
*---------------------------------------------------------------------------
* 硬件环境:
*
*---------------------------------------------------------------------------
* 软件环境:
*
*---------------------------------------------------------------------------
* 内容描述: ebox下WS2812B RGBLED驱动，支持TIM1-TIM4对应的PWM输出口
TIM1 PA8 PA9 PA10 PA11(PA8 驱动测试有BUG) DMA5
TIM2 PA0 PA1 PA2 PA3 DMA2
TIM3 PA6 PA7 PB0 PB1 DMA3
TIM4 PB6 PB7 PB8 PB9 DMA7
备注：在使用时注意DMA是否被系统或其他驱动占用，在使用串口1和串口2
时，最好不要使用TIM2（ PA0 PA1 PA2 PA3）及TIM4(PB6 PB7 PB8 PB9)
*
*
*---------------------------------------------------------------------------
* 【版权】 Copyright(C) All Rights Reserved
* 【声明】 此程序用于测试，引用请注明版权和作者信息！
*===========================================================================*/
#include "ebox.h"
#include "WS2812B.h"
/*---------------------------------------------------------
- 函数名称：
- 功能描述：
- 参数列表：
- 返回结果：
- 备 注：
----------------------------------------------------------*/
WS2812B::WS2812B(Gpio *pin)//(Pwm *pwm)//Pwm *pwmw,
{
pwm_pin = pin;
}
void WS2812B::begin()
{
_init_info(pwm_pin);
pwm_pin->mode(AF_PP);
this->oc_polarity = TIM_OCPolarity_High;
_base_init();
_set_duty();
_set_dma();
}
/*---------------------------------------------------------
- 函数名称：
- 功能描述：PWM模式设置
- 参数列表：
- 返回结果：
- 备 注：
----------------------------------------------------------*/
void WS2812B::_set_duty(void)
{
TIM_OCInitTypeDef TIM_OCInitStructure;
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;//TIM_OCMode_Timing;//
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;//TIM_OutputState_Disable;
TIM_OCInitStructure.TIM_Pulse = 0;
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
switch(ch)
{
case TIMxCH1:
TIM_OC1Init(TIMx, &TIM_OCInitStructure);
break;
case TIMxCH2:
TIM_OC2Init(TIMx, &TIM_OCInitStructure);
break;
case TIMxCH3:
TIM_OC3Init(TIMx, &TIM_OCInitStructure);
break;
case TIMxCH4:
TIM_OC4Init(TIMx, &TIM_OCInitStructure);
break;
}
}
/*---------------------------------------------------------
- 函数名称：
- 功能描述：初始化
- 参数列表：
- 返回结果：
- 备 注：
----------------------------------------------------------*/
void WS2812B::initialize(uint8_t length)
{
begin();
bbuffersize = (length * 24) + 43;
}
void WS2812B::_base_init(void)
{
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
if(rcc == RCC_APB2Periph_TIM1 || rcc == RCC_APB2Periph_TIM8 )
{
RCC_APB2PeriphClockCmd(rcc, ENABLE);
TIM_CtrlPWMOutputs(TIMx,ENABLE);
}
else
RCC_APB1PeriphClockCmd(rcc, ENABLE);
TIM_TimeBaseStructure.TIM_Period = 90-1; // 800kHz
TIM_TimeBaseStructure.TIM_Prescaler = 0;
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
// TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);
TIM_TimeBaseInit(TIMx, &TIM_TimeBaseStructure);
// TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;
TIM_ARRPreloadConfig(TIMx, ENABLE);
// TIM_Cmd(TIMx, ENABLE); //
}
/*---------------------------------------------------------
- 函数名称：
- 功能描述：通过设定的GPIO,来确定 TIM RCC CH;
- 参数列表：
- 返回结果：
- 备 注：
----------------------------------------------------------*/
void WS2812B::_init_info(Gpio *pwm_pin)
{
if(pwm_pin->port == GPIOA)
{
switch(pwm_pin->pin)
{
//TIM2
case GPIO_Pin_0:
TIMx = TIM2;
rcc = RCC_APB1Periph_TIM2;
ch = TIMxCH1;//irq = TIM2_IRQn;
break;
case GPIO_Pin_1:
TIMx = TIM2;
rcc = RCC_APB1Periph_TIM2;
ch = TIMxCH2;//irq = TIM2_IRQn;
break;
case GPIO_Pin_2:
TIMx = TIM2;
rcc = RCC_APB1Periph_TIM2;
ch = TIMxCH3;//irq = TIM2_IRQn;
break;
case GPIO_Pin_3:
TIMx = TIM2;
rcc = RCC_APB1Periph_TIM2;
ch = TIMxCH4;//irq = TIM2_IRQn;
break;
//TIM3
case GPIO_Pin_6:
TIMx = TIM3;
rcc = RCC_APB1Periph_TIM3;
ch = TIMxCH1;//irq = TIM3_IRQn;
break;
case GPIO_Pin_7:
TIMx = TIM3;
rcc = RCC_APB1Periph_TIM3;
ch = TIMxCH2;//irq = TIM3_IRQn;
break;
//TIM1
case GPIO_Pin_8:
TIMx = TIM1;
rcc = RCC_APB2Periph_TIM1;
ch = TIMxCH1;//irq = TIM4_IRQn;
break;
case GPIO_Pin_9:
TIMx = TIM1;
rcc = RCC_APB2Periph_TIM1;
ch = TIMxCH2;//irq = TIM4_IRQn;
break;
case GPIO_Pin_10:
TIMx = TIM1;
rcc = RCC_APB2Periph_TIM1;
ch = TIMxCH3;//irq = TIM4_IRQn;
break;
case GPIO_Pin_11:
TIMx = TIM1;
rcc = RCC_APB2Periph_TIM1;
ch = TIMxCH4;//irq = TIM4_IRQn;
break;
}
}
if(pwm_pin->port == GPIOB)
{
switch(pwm_pin->pin)
{
//TIM4
case GPIO_Pin_6:
TIMx = TIM4;
rcc = RCC_APB1Periph_TIM4;
ch = TIMxCH1;//irq = TIM4_IRQn;
break;
case GPIO_Pin_7:
TIMx = TIM4;
rcc = RCC_APB1Periph_TIM4;
ch = TIMxCH2;//irq = TIM4_IRQn;
break;
case GPIO_Pin_8:
TIMx = TIM4;
rcc = RCC_APB1Periph_TIM4;
ch = TIMxCH3;//irq = TIM4_IRQn;
break;
case GPIO_Pin_9:
TIMx = TIM4;
rcc = RCC_APB1Periph_TIM4;
ch = TIMxCH4;//irq = TIM4_IRQn;
break;
//TIM3
case GPIO_Pin_0:
TIMx = TIM3;
rcc = RCC_APB1Periph_TIM3;
ch = TIMxCH3;//irq = TIM3_IRQn;
break;
case GPIO_Pin_1:
TIMx = TIM3;
rcc = RCC_APB1Periph_TIM3;
ch = TIMxCH4;//irq = TIM3_IRQn;
break;
}
}
}
/*---------------------------------------------------------
- 函数名称：
- 功能描述：DMA 设置
- 参数列表：
- 返回结果：
- 备 注：
----------------------------------------------------------*/
char WS2812B::_set_dma()
{
DMA_InitTypeDef DMA_InitStructure;
/* configure DMA */
/* DMA clock enable */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
switch((uint32_t)TIMx)
{
case (uint32_t)TIM1:
{
dma_ch = DMA1_Channel5;
switch(ch)
{
case TIMxCH1:
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&TIM1->CCR1;//(uint32_t)TIM1_CCR1_Address; // physical address of Timer 3 CCR1
break;
case TIMxCH2:
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&TIM1->CCR2;//(uint32_t)TIM1_CCR2_Address; // physical address of Timer 3 CCR1
break;
case TIMxCH3:
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&TIM1->CCR3;//(uint32_t)TIM1_CCR3_Address; // physical address of Timer 3 CCR1
break;
case TIMxCH4:
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&TIM1->CCR4;//(uint32_t)TIM1_CCR4_Address; // physical address of Timer 3 CCR1
break;
}
}
break;
case (uint32_t)TIM2:
{
dma_ch = DMA1_Channel2;
switch(ch)
{
case TIMxCH1:
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&TIM2->CCR1;//TIM2_CCR1_Address; // physical address of Timer 3 CCR1
break;
case TIMxCH2:
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&TIM2->CCR2;//TIM2_CCR2_Address; // physical address of Timer 3 CCR1
break;
case TIMxCH3:
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&TIM2->CCR3;//TIM2_CCR3_Address; // physical address of Timer 3 CCR1
break;
case TIMxCH4:
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&TIM2->CCR4;//TIM2_CCR4_Address; // physical address of Timer 3 CCR1
break;
}
}
break;
case (uint32_t)TIM3:
{
dma_ch = DMA1_Channel3;
switch(ch)
{
case TIMxCH1:
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&TIM3->CCR1;//(uint32_t)TIM3_CCR1_Address; // physical address of Timer 3 CCR1
break;
case TIMxCH2:
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&TIM3->CCR2;//(uint32_t)TIM3_CCR2_Address; // physical address of Timer 3 CCR1
break;
case TIMxCH3:
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&TIM3->CCR3; //(uint32_t)TIM3_CCR3_Address;// physical address of Timer 3 CCR1
break;
case TIMxCH4:
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&TIM3->CCR4;//(uint32_t)TIM3_CCR4_Address; // physical address of Timer 3 CCR1
break;
}
}
break;
case (uint32_t)TIM4:
{
dma_ch = DMA1_Channel7;
switch(ch)
{
case TIMxCH1:
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&TIM4->CCR1;//(uint32_t)TIM4_CCR1_Address; // physical address of Timer 3 CCR1
break;
case TIMxCH2:
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&TIM4->CCR2;//(uint32_t)TIM4_CCR2_Address; // physical address of Timer 3 CCR1
break;
case TIMxCH3:
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&TIM4->CCR3;//(uint32_t)TIM4_CCR3_Address; // physical address of Timer 3 CCR1
break;
case TIMxCH4:
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&TIM4->CCR4;//(uint32_t)TIM4_CCR4_Address; // physical address of Timer 3 CCR1
break;
}
}
break;
}
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)LED_BYTE_Buffer; // this is the buffer memory
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST; // data shifted from memory to peripheral
DMA_InitStructure.DMA_BufferSize = 42;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; // automatically increase buffer index
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; // stop DMA feed after buffer size is reached
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_DeInit(dma_ch);//DMA1_Channel3
DMA_Init(dma_ch, &DMA_InitStructure);//DMA1_Channel3
/* TIMx CCx DMA Request enable */
TIM_DMACmd(TIMx, TIM_DMA_Update, ENABLE);
}
/*---------------------------------------------------------
- 函数名称：
- 功能描述：一次全部显示len个led，颜色全部一样
- 参数列表：
- 返回结果：
- 备 注：
----------------------------------------------------------*/
void WS2812B::send(uint8_t green,uint8_t red,uint8_t bule, uint16_t len)
{
uint8_t i;
uint16_t memaddr;
uint16_t buffersize;
buffersize = (len * 24) + 43; // number of bytes needed is #LEDs * 24 bytes + 42 trailing bytes
memaddr = 0; // reset buffer memory index
// busize = buffersize;
while (len)
{
for(i=0; i<8; i++) // GREEN data
{
LED_BYTE_Buffer[memaddr] = ((green<<i) & 0x0080) ? TIMING_ONE:TIMING_ZERO;
memaddr++;
}
for(i=0; i<8; i++) // RED
{
LED_BYTE_Buffer[memaddr] = ((red<<i) & 0x0080) ? TIMING_ONE:TIMING_ZERO;
memaddr++;
}
for(i=0; i<8; i++) // BLUE
{
LED_BYTE_Buffer[memaddr] = ((bule<<i) & 0x0080) ? TIMING_ONE:TIMING_ZERO;
memaddr++;
}
len--;
}
//===================================================================//
//bug：最后一个周期波形不知道为什么全是高电平，故增加一个波形
LED_BYTE_Buffer[memaddr] = ((bule<<8) & 0x0080) ? TIMING_ONE:TIMING_ZERO;
//===================================================================//
memaddr++;
while(memaddr < buffersize)
{
LED_BYTE_Buffer[memaddr] = 0;
memaddr++;
}
DMA_SetCurrDataCounter(dma_ch, buffersize); //DMA1_Channel3 load number of bytes to be transferred
DMA_Cmd(dma_ch, ENABLE); //DMA1_Channel3 enable DMA channel 6
TIM_Cmd(TIMx, ENABLE); // enable Timer 3
while(!DMA_GetFlagStatus(DMA1_FLAG_TC3)) ; // wait until transfer complete
TIM_Cmd(TIMx, DISABLE); // disable Timer 3
DMA_Cmd(dma_ch, DISABLE); //DMA1_Channel3 disable DMA channel 6
DMA_ClearFlag(DMA1_FLAG_TC3); // clear DMA1 Channel 6 transfer complete flag
}
/*---------------------------------------------------------
- 函数名称：
- 功能描述： 独立设置每一个LED的颜色
- 参数列表： green
red
bule
num 对应的led编号
- 返回结果：
- 备 注：
----------------------------------------------------------*/
void WS2812B::set_color(uint8_t green,uint8_t red,uint8_t bule, uint16_t num)
{
bmemaddr = num * 24; // reset buffer memory index
for(uint8_t i=0; i<8; i++) // GREEN data
{
LED_BYTE_Buffer[bmemaddr] = ((green << i) & 0x0080) ? TIMING_ONE:TIMING_ZERO;
bmemaddr++;
}
for(uint8_t i=0; i<8; i++) // RED
{
LED_BYTE_Buffer[bmemaddr] = ((red << i) & 0x0080) ? TIMING_ONE:TIMING_ZERO;
bmemaddr++;
}
for(uint8_t i=0; i<8; i++) // BLUE
{
LED_BYTE_Buffer[bmemaddr] = ((bule << i) & 0x0080) ? TIMING_ONE:TIMING_ZERO;
bmemaddr++;
}
}
/*---------------------------------------------------------
- 函数名称：
- 功能描述：在配置完led颜色运行，用来点亮led
- 参数列表：
- 返回结果：
- 备 注：
----------------------------------------------------------*/
void WS2812B::enable()
{
bmemaddr++;
while(bmemaddr < bbuffersize)
{
LED_BYTE_Buffer[bmemaddr] = 0;
bmemaddr++;
}
DMA_SetCurrDataCounter(dma_ch, bbuffersize); //DMA1_Channel3 load number of bytes to be transferred
DMA_Cmd(dma_ch, ENABLE); //DMA1_Channel3 enable DMA channel 6
TIM_Cmd(TIMx, ENABLE); // enable Timer 3
while(!DMA_GetFlagStatus(DMA1_FLAG_TC3)) ; // wait until transfer complete
TIM_Cmd(TIMx, DISABLE); // disable Timer 3
DMA_Cmd(dma_ch, DISABLE); //DMA1_Channel3 disable DMA channel 6
DMA_ClearFlag(DMA1_FLAG_TC3); // clear DMA1 Channel 6 transfer complete flag
}
| [
"[email protected]"
] |
Subsets and Splits