Zobrazit příspěvky
Tato sekce Vám umožňuje zobrazit všechny příspěvky tohoto uživatele. Prosím uvědomte si, že můžete vidět příspěvky pouze z oblastí Vám přístupných.
K tomu navrhu cez Lazy Init, super napad, rovno to pouzijem, uvazoval som ale nic lepsie ma prakticky na momentalne sksuenosti nenapada.Jde to elegantněji přes get_or_insert.
Proč nepoužiješ enum?Este niesom v Ruste spravne "zabehnuty" takze, neviem/netusim ako konkretne by som pouzil Enum ako nahradu za Struct ( tomto konkretnom priklade)
fn push<T:B>(&mut self, data:T)
use MYSQL::Connection;
pub enum DatabaseMembers {
X,
Y,
Z
}
// Various Structs
pub struct X {
pub name: String
}
pub struct Y {
pub text: String
}
pub struct Z {
pub value: u64
}
/* Builder - traits */
trait DatabaseBuilder {
fn push(&self, c: &Option<Connection>);
fn create_table(c: &Option<Connection>);
}
impl DatabaseBuilder for X {
fn push(&self, c: &Option<Connection>){
let query = query = "INSERT INTO x (name) VALUES (?1)"
let query_params = params![&self.name];
match c {
Some(e) => e.execute(query, query_params)?,
None => {},
};
}
fn create_table(c: &Option<Connection>){
let query =
"CREATE TABLE IF NOT EXISTS X (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
);";
match c {
Some(e) => e.execute(query, [])?,
None => {},
}
}
}
impl DatabaseBuilder for Y {
fn push(&self, c: &Option<Connection>){
let query = query = "INSERT INTO y (text) VALUES (?1)"
let query_params = params![&self.value];
match c {
Some(e) => e.execute(query, query_params)?,
None => {},
};
}
fn create_table(c: &Option<Connection>){
let query =
"CREATE TABLE IF NOT EXISTS X (
id INTEGER PRIMARY KEY,
text TEXT NOT NULL,
);";
match c {
Some(e) => e.execute(query, [])?,
None => {},
}
}
}
impl DatabaseBuilder for Z {
fn push(&self, c: &Option<Connection>){
let query = query = "INSERT INTO z (name) VALUES (?1)"
let query_params = params![&self.name];
match c {
Some(e) => e.execute(query, query_params)?,
None => {},
};
}
fn create_table(c: &Option<Connection>){
let query =
"CREATE TABLE IF NOT EXISTS X (
id INTEGER PRIMARY KEY,
name INTEGER,
);";
match c {
Some(e) => e.execute(query, [])?,
None => {},
}
}
}
impl DatabaseBuilder for Database {
fn push(&self, c: &Option<Connection>){};
fn create_table(c: &Option<Connection>){};
}
/* Database */
pub struct Database {
c: Option<Connection>,
}
impl Database {
pub fn new() -> Database {
Database {
c: None,
}
}
pub fn open_temporary(&mut self){
self.c = Some(Connection::open_in_memory());
}
pub fn push<T: DatabaseBuilder>(&mut self, data: &T) {
data.push(&self.conn)
}
pub fn create_table(&mut self, m: DatabaseMembers) {
match m {
DatabaseMembers::X => X::create_table(&self.conn),
DatabaseMembers::Y => Y::create_table(&self.conn),
DatabaseMembers::Z => Z::create_table(&self.conn),
}
}
}
fn main() {
let mut db: Database = Database::new();
db.open_temporary();
// X
db.create_table(DatabaseMembers::X);
let x = X {name: String::from("Ahoj")};
db.push(&x);
// Y
db.create_table(DatabaseMembers::Y);
let y = Y {text: String::from("Ahoj")};
db.push(&y);
}// Various Structs
pub struct X {
name: String
}
pub struct Y {
text: String
}
pub struct Z {
value: u64
}
/* Builder - traits */
trait DatabaseBuilder<T> {
fn add(&self, data: &T);
}
impl DatabaseBuilder<X> for Database {
fn push(&self, data: &X){
/* ... */
let y = data.name;
}
}
impl DatabaseBuilder<Y> for Database {
fn push(&self, data: &Y){
/* ... */
let y = data.text;
}
}
impl DatabaseBuilder<Z> for Database {
fn push(&self, data: &Z){
/* ... */
let y = data.value;
}
}
/* Database */
pub struct Database {
/* ... */
}
impl Database {
pub fn new() -> Databse {
/* ... */
}
pub fn push(&mut self, data: &dyn std::any::Any) {
match data.downcast_ref::<X>() {
Some(p) => DatabaseBuilder::<X>::push(self, p),
None => {}
}
match data.downcast_ref::<Y>() {
Some(p) => DatabaseBuilder::<Y>::push(self, p),
None => {}
}
match data.downcast_ref::<Z>() {
Some(p) => DatabaseBuilder::<Z>::push(self, p),
None => {}
}
}
}Port 22
AddressFamily inet
ListenAddress 0.0.0.0
UsePAM yes
UseDNS no
Subsystem sftp internal-sftp
AllowUsers test
Match User test
X11Forwarding no
AllowTcpForwarding no
PasswordAuthentication yes
ChrootDirectory /home/%u
# /etc/systemd/resolved.conf
[Resolve]
DNS=192.168.1.1
FallbackDNS=192.168.1.1 1.1.1.1 8.8.8.8
## unbound.conf
#
server:
chroot: ""
interface: 0.0.0.0@53
port: 53
interface: 0.0.0.0@853
ssl-port: 853
# log verbosity
verbosity: 1
log-queries: yes
logfile: /var/log/unbound.log
# Enable IPv4, "yes" or "no".
do-ip4: yes
do-ip6: no
do-udp: yes
do-tcp: yes
# Access control
access-control: 127.0.0.0/8 allow
access-control: 192.168.0.0/16 allow
access-control: 172.16.0.0/16 allow
hide-identity: yes
hide-version: yes
harden-glue: yes
harden-dnssec-stripped: yes
unwanted-reply-threshold: 10000
do-not-query-localhost: no
auto-trust-anchor-file: "/usr/local/etc/unbound/root.key"
val-clean-additional: yes
private-address: 192.168.0.0/16
private-address: 172.16.0.0/12
private-domain: "server.lan"
# locally served zones can be configured for the machines on the LAN.
local-zone: "server.lan." static
local-data: "smb.server.lan. IN A 192.168.2.2"
local-data: "ftp.server.lan. IN A 192.168.2.3"
local-data-ptr: "192.168.2.2 smb.server.lan"
local-data-ptr: "192.168.2.3 ftp.server.lan"
forward-zone:
name: "server.lan"
forward-addr: 127.0.0.1 # Internal or private DNS
# Use the following forward-zone to forward all queries to Google DNS,
# OpenDNS.com or your local ISP's dns servers for example. To test resolution
# speeds use "drill calomel.org @8.8.8.8" and look for the "Query time:" in
# milliseconds.
#
forward-zone:
name: "."
forward-addr: 1.1.1.1@53#one.one.one.one
forward-addr: 8.8.8.8@53#dns.google
forward-addr: 9.9.9.9@53#dns.quad9.net
forward-addr: 1.0.0.1@53#one.one.one.one
forward-addr: 8.8.4.4@53#dns.google
forward-addr: 149.112.112.112@53#dns.quad9.net
forward-addr: 1.1.1.1@853#cloudflare-dns.com
forward-addr: 9.9.9.9@853#dns.quad9.net
SUBSYSTEMS=="usb", ATTR{devpath}=="1.3.2", SYMLINK+="usb1-2", GROUP="usb", ATTR{authorized}="0", MODE="0660", GOTO="usb_end"
systemd-udevd[4803]: 1-1.3.2: /etc/udev/rules.d/90-hub-port.rules:4 GROUP 119
systemd-udevd[4803]: 1-1.3.2: /etc/udev/rules.d/90-hub-port.rules:4 MODE 0660
systemd-udevd[4803]: 1-1.3.2: /etc/udev/rules.d/90-hub-port.rules:4 LINK 'usb1-2'
systemd-udevd[4803]: 1-1.3.2: /etc/udev/rules.d/90-hub-port.rules:4 ATTR '/sys/devices/platform/soc/3f980000.usb/usb1/1-1/1-1.3/1-1.3.2/authorized' writing '0'
systemd-udevd[2399]: 1-1.3.2: Creating symlink '/dev/usb1-2' to 'bus/usb/001/009'
..
zatial v poriadku ale...
...
systemd-udevd[2405]: 1-1.3.2: Updating old name, '/dev/usb1-2' no longer belonging to '/devices/platform/soc/3f980000.usb/usb1/1-1/1-1.3/1-1.3.2'
systemd-udevd[2405]: 1-1.3.2: No reference left, removing '/dev/usb1-2'
#include <string>
#include <memory>
#include <type_traits>
using namespace std;
/* 3rd lib defs */
class A {
/* .. */
};
A A_graph(const string & in) {
A ret;
/* ... */
return ret;
};
class B {
/* .. */
};
B B_graph(const string & in) {
B ret;
/* ... */
return ret;
};
class C {
/* .. */
};
C C_graph(const string & in) {
C ret;
/* ... */
return ret;
};
/* Own classes */
class IResult {};
class XResult : IResult {};
class YResult : IResult {};
class ZResult : IResult {};
template <class G>
class Helper {
private:
unique_ptr<G> graph;
/*
unique_ptr<GraphCalculator> calc;
unique_ptr<Contraction> conc;
unique_ptr<Router> rtr;
*/
public:
Helper(const string & in){
if(0){
}else if constexpr (std::is_same<G, A>::value){
graph = make_unique<A>(A_graph(in));
}else if constexpr (std::is_same<G, B>::value){
graph = make_unique<B>(B_graph(in));
}else if constexpr (std::is_same<G, C>::value){
graph = make_unique<C>(C_graph(in));
}
/* Some data - time consuming init and calculations
calc = make_unique<Contraction>(graph);
...
*/
};
};
template <class R, class G>
class Builder {
private:
unique_ptr<Helper<G>> builder;
public:
unique_ptr<R> build(void){
if(!builder)
builder = make_unique<Helper<G>>("path");
R ret;
/* some stuff
...
auto calculate = MySuperCalculateFunction(builder->conc->results());
ret.append(route);
... */
return make_unique<R>(ret);
};
};
using XABuilder = Builder<XResult, A>;
int main(){
XABuilder builder;
auto A = builder.build();
return 0;
};
Pokud chceš filtr, který se bude dynamicky rozhodovat podle více možných typů vstupu, tak můžeš použít třeba std::variant.Super, myslim ze toto by slo, o tej moznosti som ani netusil
, nakoniec som musel cvhilku porozmyslat o navrhu a myslim ze to slo /* abstract rule template */
template <class T>
class TRule {
public:
virtual ~TRule(){};
virtual bool operator()(const T & t) = 0;
};
template <typename T>
using RulePtr = std::unique_ptr<TRule<T>>;
template <typename T, typename Arg>
std::unique_ptr<T> Rule(Arg&& arg){
return std::make_unique<T>(std::forward<Arg>(arg));
};
template <class T>
class TFilter {
private:
std::vector<RulePtr<T>> v_rule;
public:
TFilter(){};
~TFilter(){};
void add(RulePtr<T> rule){
v_rule.push_back(std::move(rule));
}
bool operator()(const T & t){
for(auto & rule : v_rule){
if((*rule)(t) == false){
return false;
}
}
return true;
}
};
/* Class */
struct Item {
int16_t id;
};
namespace ItemRule {
class LessThan: public TRule<Item> {
private:
int16_t id;
public:
~LessThan(){};
LessThan(int16_t iid): id(iid){};
bool operator()(const Item & item) override{
return item.id < id ? true : false;
}
};
class EqualTo: public TRule<Item> {
private:
int16_t id;
public:
~EqualTo(){};
EqualTo(int16_t iid): id(iid){};
bool operator()(const Item & item) override{
return item.id == id ? true : false;
};
};
};
class ItemFilter : public TFilter<Item>{};
int main(void){
/* test A */
Item item_A = {15};
ItemFilter itemfilter;
itemfilter.add(std::make_unique<ItemRule::EqualTo>(15)); // (1)
itemfilter.add(Rule<ItemRule::LessThan>(20)); // (1)
// (1) equivalent
if(itemfilter(item_A) == true){
std::cout << "ok" << std::endl;
}else{
std::cout << "off" << std::endl;
}
return 0;
}
struct Item {
int16_t id;
};
class Rule{
public:
virtual ~Rule(){};
virtual bool operator()(const Item & item) = 0;
};
class RuleLessThan: public Rule {
private:
int16_t id;
public:
RuleLessThan(int16_t iid): id(iid){}
bool operator()(const Item & item){
return item.id < id ? true : false;
}
};
class RuleEqualTo: public Rule {
private:
int16_t id;
public:
RuleEqualTo(int16_t iid): id(iid){};
bool operator()(const Item & item){
return item.id == id ? true : false;
};
};
class Filter {
private:
std::vector<Rule *> v_rule;
public:
Filter(){};
~Filter(){
for(auto & rule : v_rule){
delete rule;
}
};
void add (Rule * rule){
v_rule.push_back(rule);
}
bool apply(const Item & item ){
for(auto & rule : v_rule){
if((*rule)(item) == false){
return false;
}
}
return true;
}
};
int main(void){
Item item_A = {15};
Item item_B = {30};
Item item_C = {40};
Filter filter_A;
Filter filter_B;
filter_A.add(new RuleEqualTo(15));
filter_B.add(new RuleEqualTo(30));
filter_B.add(new RuleLessThan(50));
if(filter_A.apply(item_A) == true){
std::cout << "ok" << std::endl;
}
if(filter_B.apply(item_B) == true){
std::cout << "ok" << std::endl;
}
if(filter_B.apply(item_C) == false){
std::cout << "ok" << std::endl;
}
return 0;
}
struct Type {
std::string type;
};
Ahoj all,
Root.cz (www.root.cz), informace nejen ze světa Linuxu. ISSN 1212-8309
Copyright © 1998 – 2023 Internet Info, s.r.o. Všechna práva vyhrazena. Powered by Linux.