text stringlengths 70 351k | source stringclasses 4
values |
|---|---|
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums.rs | crate: common_enums
pub use accounts::MerchantProductType;
pub use payments::ProductType;
pub use ui::*;
pub use super::connector_enums::RoutableConnectors;
pub type ApplicationResult<T> = Result<T, ApplicationError>;
pub fn as_bool(self) -> bool {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums.rs | crate: common_enums
fn from(relay_status: RelayStatus) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums.rs | crate: common_enums
fn from(refund_status: RefundStatus) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums.rs | crate: common_enums
fn from(connector_type: ConnectorType) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums.rs | crate: common_enums
fn from(role_scope: RoleScope) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums.rs | crate: common_enums
pub use accounts::MerchantProductType;
pub use payments::ProductType;
pub use ui::*;
pub use super::connector_enums::RoutableConnectors;
pub type ApplicationResult<T> = Result<T, ApplicationError>;
pub fn is_failed(self) -> bool {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums.rs | crate: common_enums
pub use accounts::MerchantProductType;
pub use payments::ProductType;
pub use ui::*;
pub use super::connector_enums::RoutableConnectors;
pub type ApplicationResult<T> = Result<T, ApplicationError>;
pub fn is_terminal_status(self) -> bool {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums.rs | crate: common_enums
pub use accounts::MerchantProductType;
pub use payments::ProductType;
pub use ui::*;
pub use super::connector_enums::RoutableConnectors;
pub type ApplicationResult<T> = Result<T, ApplicationError>;
pub fn is_separate_version_call_required(self) -> bool {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums.rs | crate: common_enums
pub use accounts::MerchantProductType;
pub use payments::ProductType;
pub use ui::*;
pub use super::connector_enums::RoutableConnectors;
pub type ApplicationResult<T> = Result<T, ApplicationError>;
pub fn is_for_internal_use_only(self) -> bool {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums.rs | crate: common_enums
pub use accounts::MerchantProductType;
pub use payments::ProductType;
pub use ui::*;
pub use super::connector_enums::RoutableConnectors;
pub type ApplicationResult<T> = Result<T, ApplicationError>;
pub fn should_check_for_customer_saved_payment_method_type(self) -> bool {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums.rs | crate: common_enums
pub use accounts::MerchantProductType;
pub use payments::ProductType;
pub use ui::*;
pub use super::connector_enums::RoutableConnectors;
pub type ApplicationResult<T> = Result<T, ApplicationError>;
/// Indicates whether the syncing with the connector should be allowed or not
pub fn should_force_sync_with_connector(self) -> bool {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums.rs | crate: common_enums
pub use accounts::MerchantProductType;
pub use payments::ProductType;
pub use ui::*;
pub use super::connector_enums::RoutableConnectors;
pub type ApplicationResult<T> = Result<T, ApplicationError>;
/// Indicates whether the payment intent is in terminal state or not
pub fn is_in_terminal_state(self) -> bool {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums.rs | crate: common_enums
pub use accounts::MerchantProductType;
pub use payments::ProductType;
pub use ui::*;
pub use super::connector_enums::RoutableConnectors;
pub type ApplicationResult<T> = Result<T, ApplicationError>;
pub fn number_of_digits_after_decimal_point(self) -> u8 {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/common_enums/src/enums.rs | crate: common_enums
use std::num::{ParseFloatError, TryFromIntError};
pub use accounts::MerchantProductType;
pub use payments::ProductType;
pub use ui::*;
pub use super::connector_enums::RoutableConnectors;
pub type ApplicationResult<T> = Result<T, ApplicationError>;
/// Convert the amount to its base denomination based on Currency and check for zero decimal currency and return String
/// Paypal Connector accepts Zero and Two decimal currency but not three decimal and it should be updated as required for 3 decimal currencies.
/// Paypal Ref - https://developer.paypal.com/docs/reports/reference/paypal-supported-currencies/
pub fn to_currency_base_unit_with_zero_decimal_check(
self,
amount: i64,
) -> Result<String, TryFromIntError> {
let amount_f64 = self.to_currency_base_unit_asf64(amount)?;
if self.is_zero_decimal_currency() {
Ok(amount_f64.to_string())
} else {
Ok(format!("{amount_f64:.2}"))
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums.rs | crate: common_enums
use std::num::{ParseFloatError, TryFromIntError};
pub use accounts::MerchantProductType;
pub use payments::ProductType;
pub use ui::*;
pub use super::connector_enums::RoutableConnectors;
pub type ApplicationResult<T> = Result<T, ApplicationError>;
///Convert the higher decimal amount to its base absolute units
pub fn to_currency_lower_unit(self, amount: String) -> Result<String, ParseFloatError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums.rs | crate: common_enums
use std::num::{ParseFloatError, TryFromIntError};
pub use accounts::MerchantProductType;
pub use payments::ProductType;
pub use ui::*;
pub use super::connector_enums::RoutableConnectors;
pub type ApplicationResult<T> = Result<T, ApplicationError>;
/// Convert the amount to its base denomination based on Currency and return f64
pub fn to_currency_base_unit_asf64(self, amount: i64) -> Result<f64, TryFromIntError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums.rs | crate: common_enums
use std::num::{ParseFloatError, TryFromIntError};
pub use accounts::MerchantProductType;
pub use payments::ProductType;
pub use ui::*;
pub use super::connector_enums::RoutableConnectors;
pub type ApplicationResult<T> = Result<T, ApplicationError>;
/// Convert the amount to its base denomination based on Currency and return String
pub fn to_currency_base_unit(self, amount: i64) -> Result<String, TryFromIntError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums.rs | crate: common_enums
use std::num::{ParseFloatError, TryFromIntError};
fn from(err: std::io::Error) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums.rs | crate: common_enums
pub use accounts::MerchantProductType;
pub use payments::ProductType;
pub use ui::*;
pub use super::connector_enums::RoutableConnectors;
pub type ApplicationResult<T> = Result<T, ApplicationError>;
pub fn is_connection_closed_before_message_could_complete(&self) -> bool {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums.rs | crate: common_enums
pub use accounts::MerchantProductType;
pub use payments::ProductType;
pub use ui::*;
pub use super::connector_enums::RoutableConnectors;
pub type ApplicationResult<T> = Result<T, ApplicationError>;
pub fn is_upstream_timeout(&self) -> bool {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums.rs | crate: common_enums
pub use accounts::MerchantProductType;
pub use payments::ProductType;
pub use ui::*;
pub use super::connector_enums::RoutableConnectors;
pub type ApplicationResult<T> = Result<T, ApplicationError>;
pub fn to_display_name(&self) -> String {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums.rs | crate: common_enums
pub use accounts::MerchantProductType;
pub use payments::ProductType;
pub use ui::*;
pub use super::connector_enums::RoutableConnectors;
pub type ApplicationResult<T> = Result<T, ApplicationError>;
pub fn is_three_decimal_currency(self) -> bool {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums.rs | crate: common_enums
pub use accounts::MerchantProductType;
pub use payments::ProductType;
pub use ui::*;
pub use super::connector_enums::RoutableConnectors;
pub type ApplicationResult<T> = Result<T, ApplicationError>;
pub fn is_four_decimal_currency(self) -> bool {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums.rs | crate: common_enums
pub use accounts::MerchantProductType;
pub use payments::ProductType;
pub use ui::*;
pub use super::connector_enums::RoutableConnectors;
pub type ApplicationResult<T> = Result<T, ApplicationError>;
pub fn is_zero_decimal_currency(self) -> bool {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/common_enums/src/enums.rs | crate: common_enums
pub use accounts::MerchantProductType;
pub use payments::ProductType;
pub use ui::*;
pub use super::connector_enums::RoutableConnectors;
pub type ApplicationResult<T> = Result<T, ApplicationError>;
pub fn iso_4217(self) -> &'static str {
match self {
Self::AED => "784",
Self::AFN => "971",
Self::ALL => "008",
Self::AMD => "051",
Self::ANG => "532",
Self::AOA => "973",
Self::ARS => "032",
Self::AUD => "036",
Self::AWG => "533",
Self::AZN => "944",
Self::BAM => "977",
Self::BBD => "052",
Self::BDT => "050",
Self::BGN => "975",
Self::BHD => "048",
Self::BIF => "108",
Self::BMD => "060",
Self::BND => "096",
Self::BOB => "068",
Self::BRL => "986",
Self::BSD => "044",
Self::BTN => "064",
Self::BWP => "072",
Self::BYN => "933",
Self::BZD => "084",
Self::CAD => "124",
Self::CDF => "976",
Self::CHF => "756",
Self::CLF => "990",
Self::CLP => "152",
Self::COP => "170",
Self::CRC => "188",
Self::CUC => "931",
Self::CUP => "192",
Self::CVE => "132",
Self::CZK => "203",
Self::DJF => "262",
Self::DKK => "208",
Self::DOP => "214",
Self::DZD => "012",
Self::EGP => "818",
Self::ERN => "232",
Self::ETB => "230",
Self::EUR => "978",
Self::FJD => "242",
Self::FKP => "238",
Self::GBP => "826",
Self::GEL => "981",
Self::GHS => "936",
Self::GIP => "292",
Self::GMD => "270",
Self::GNF => "324",
Self::GTQ => "320",
Self::GYD => "328",
Self::HKD => "344",
Self::HNL => "340",
Self::HTG => "332",
Self::HUF => "348",
Self::HRK => "191",
Self::IDR => "360",
Self::ILS => "376",
Self::INR => "356",
Self::IQD => "368",
Self::IRR => "364",
Self::ISK => "352",
Self::JMD => "388",
Self::JOD => "400",
Self::JPY => "392",
Self::KES => "404",
Self::KGS => "417",
Self::KHR => "116",
Self::KMF => "174",
Self::KPW => "408",
Self::KRW => "410",
Self::KWD => "414",
Self::KYD => "136",
Self::KZT => "398",
Self::LAK => "418",
Self::LBP => "422",
Self::LKR => "144",
Self::LRD => "430",
Self::LSL => "426",
Self::LYD => "434",
Self::MAD => "504",
Self::MDL => "498",
Self::MGA => "969",
Self::MKD => "807",
Self::MMK => "104",
Self::MNT => "496",
Self::MOP => "446",
Self::MRU => "929",
Self::MUR => "480",
Self::MVR => "462",
Self::MWK => "454",
Self::MXN => "484",
Self::MYR => "458",
Self::MZN => "943",
Self::NAD => "516",
Self::NGN => "566",
Self::NIO => "558",
Self::NOK => "578",
Self::NPR => "524",
Self::NZD => "554",
Self::OMR => "512",
Self::PAB => "590",
Self::PEN => "604",
Self::PGK => "598",
Self::PHP => "608",
Self::PKR => "586",
Self::PLN => "985",
Self::PYG => "600",
Self::QAR => "634",
Self::RON => "946",
Self::CNY => "156",
Self::RSD => "941",
Self::RUB => "643",
Self::RWF => "646",
Self::SAR => "682",
Self::SBD => "090",
Self::SCR => "690",
Self::SDG => "938",
Self::SEK => "752",
Self::SGD => "702",
Self::SHP => "654",
Self::SLE => "925",
Self::SLL => "694",
Self::SOS => "706",
Self::SRD => "968",
Self::SSP => "728",
Self::STD => "678",
Self::STN => "930",
Self::SVC => "222",
Self::SYP => "760",
Self::SZL => "748",
Self::THB => "764",
Self::TJS => "972",
Self::TMT => "934",
Self::TND => "788",
Self::TOP => "776",
Self::TRY => "949",
Self::TTD => "780",
Self::TWD => "901",
Self::TZS => "834",
Self::UAH => "980",
Self::UGX => "800",
Self::USD => "840",
Self::UYU => "858",
Self::UZS => "860",
Self::VES => "928",
Self::VND => "704",
Self::VUV => "548",
Self::WST => "882",
Self::XAF => "950",
Self::XCD => "951",
Self::XOF => "952",
Self::XPF => "953",
Self::YER => "886",
Self::ZAR => "710",
Self::ZMW => "967",
Self::ZWL => "932",
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums/ui.rs | crate: common_enums
use serde::{de::Visitor, Deserialize, Deserializer, Serialize};
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
{
Self::Variants(variant) => serializer.serialize_str(variant.to_string().as_str()),<|fim_suffix|>
<|fim_middle|>
Self::Percentage(pixel_count) => {
serializer.serialize_str(format!("{}%", pixel_count).as_str())
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums/ui.rs | crate: common_enums
use serde::{de::Visitor, Deserialize, Deserializer, Serialize};
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_enums/src/enums/ui.rs | crate: common_enums
use serde::{de::Visitor, Deserialize, Deserializer, Serialize};
fn visit_str<E>(self, value: &str) -> Result<ElementSize, E>
where
E: serde::de::Error,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/types.rs | crate: hyperswitch_constraint_graph
fn from(value: Relation) -> Self {
{
Relation::Positive => Self::Positive,<|fim_suffix|>
<|fim_middle|>
Relation::Negative => Self::Negative,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/types.rs | crate: hyperswitch_constraint_graph
use rustc_hash::{FxHashMap, FxHashSet};
pub fn new() -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/types.rs | crate: hyperswitch_constraint_graph
pub fn new(identifier: String) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/types.rs | crate: hyperswitch_constraint_graph
pub fn get_resolved_relation(prev_relation: Self, curr_relation: Self) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/types.rs | crate: hyperswitch_constraint_graph
fn from(value: Relation) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/types.rs | crate: hyperswitch_constraint_graph
use std::{
any::Any,
fmt, hash,
ops::{Deref, DerefMut},
sync::Arc,
};
pub fn get_resolved_strength(prev_strength: Self, curr_strength: Self) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/types.rs | crate: hyperswitch_constraint_graph
fn from(value: V) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/types.rs | crate: hyperswitch_constraint_graph
use crate::{dense_map::impl_entity, error::AnalysisTrace};
pub(crate) fn new(node_type: NodeType<V>) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs | crate: hyperswitch_constraint_graph
use std::sync::{Arc, Weak};
use crate::{
builder,
dense_map::DenseMap,
error::{self, AnalysisTrace, GraphError},
types::{
CheckingContext, CycleCheck, DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId,
Memoization, Metadata, Node, NodeId, NodeType, NodeValue, Relation, RelationResolution,
Strength, ValueNode,
},
};
fn context_analysis<C>(
&self,
node_id: NodeId,
relation: Relation,
strength: Strength,
ctx: &C,
val: &NodeValue<V>,
memo: &mut Memoization<V>,
) -> Result<(), GraphError<V>>
where
C: CheckingContext<Value = V>,
{
let in_context = ctx.check_presence(val, strength);
let relation_bool: bool = relation.into();
if in_context != relation_bool {
let err = Arc::new(AnalysisTrace::Value {
value: val.clone(),
relation,
predecessors: None,
info: self.node_info.get(node_id).copied().flatten(),
metadata: self.node_metadata.get(node_id).cloned().flatten(),
});
memo.insert((node_id, relation, strength), Err(Arc::clone(&err)));
Err(GraphError::AnalysisError(Arc::downgrade(&err)))?;
}
if !relation_bool {
memo.insert((node_id, relation, strength), Ok(()));
return Ok(());
}
Ok(())
} | ast_fragments |
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs | crate: hyperswitch_constraint_graph
use std::sync::{Arc, Weak};
use rustc_hash::{FxHashMap, FxHashSet};
use crate::{
builder,
dense_map::DenseMap,
error::{self, AnalysisTrace, GraphError},
types::{
CheckingContext, CycleCheck, DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId,
Memoization, Metadata, Node, NodeId, NodeType, NodeValue, Relation, RelationResolution,
Strength, ValueNode,
},
};
fn validate_in_aggregator<C>(
&self,
vald: CheckNodeContext<'_, V, C>,
expected: &FxHashSet<V>,
) -> Result<(), GraphError<V>>
where
C: CheckingContext<Value = V>,
{
let the_key = expected
.iter()
.next()
.ok_or_else(|| GraphError::MalformedGraph {
reason: "An OnlyIn aggregator node must have at least one expected value"
.to_string(),
})?
.get_key();
let ctx_vals = if let Some(vals) = vald.ctx.get_values_by_key(&the_key) {
vals
} else {
return if let Strength::Weak = vald.strength {
vald.memo
.insert((vald.node_id, vald.relation, vald.strength), Ok(()));
Ok(())
} else {
let err = Arc::new(AnalysisTrace::InAggregation {
expected: expected.iter().cloned().collect(),
found: None,
relation: vald.relation,
info: self.node_info.get(vald.node_id).copied().flatten(),
metadata: self.node_metadata.get(vald.node_id).cloned().flatten(),
});
vald.memo.insert(
(vald.node_id, vald.relation, vald.strength),
Err(Arc::clone(&err)),
);
Err(GraphError::AnalysisError(Arc::downgrade(&err)))
};
};
let relation_bool: bool = vald.relation.into();
for ctx_value in ctx_vals {
if expected.contains(&ctx_value) != relation_bool {
let err = Arc::new(AnalysisTrace::InAggregation {
expected: expected.iter().cloned().collect(),
found: Some(ctx_value.clone()),
relation: vald.relation,
info: self.node_info.get(vald.node_id).copied().flatten(),
metadata: self.node_metadata.get(vald.node_id).cloned().flatten(),
});
vald.memo.insert(
(vald.node_id, vald.relation, vald.strength),
Err(Arc::clone(&err)),
);
Err(GraphError::AnalysisError(Arc::downgrade(&err)))?;
}
}
vald.memo
.insert((vald.node_id, vald.relation, vald.strength), Ok(()));
Ok(())
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs | crate: hyperswitch_constraint_graph
use std::sync::{Arc, Weak};
use crate::{
builder,
dense_map::DenseMap,
error::{self, AnalysisTrace, GraphError},
types::{
CheckingContext, CycleCheck, DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId,
Memoization, Metadata, Node, NodeId, NodeType, NodeValue, Relation, RelationResolution,
Strength, ValueNode,
},
};
fn validate_any_aggregator<C>(
&self,
vald: CheckNodeContext<'_, V, C>,
) -> Result<(), GraphError<V>>
where
C: CheckingContext<Value = V>,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs | crate: hyperswitch_constraint_graph
use std::sync::{Arc, Weak};
use crate::{
builder,
dense_map::DenseMap,
error::{self, AnalysisTrace, GraphError},
types::{
CheckingContext, CycleCheck, DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId,
Memoization, Metadata, Node, NodeId, NodeType, NodeValue, Relation, RelationResolution,
Strength, ValueNode,
},
};
fn validate_all_aggregator<C>(
&self,
vald: CheckNodeContext<'_, V, C>,
) -> Result<(), GraphError<V>>
where
C: CheckingContext<Value = V>,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs | crate: hyperswitch_constraint_graph
use std::sync::{Arc, Weak};
use crate::{
builder,
dense_map::DenseMap,
error::{self, AnalysisTrace, GraphError},
types::{
CheckingContext, CycleCheck, DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId,
Memoization, Metadata, Node, NodeId, NodeType, NodeValue, Relation, RelationResolution,
Strength, ValueNode,
},
};
pub fn check_node_inner<C>(
&self,
ctx: &C,
node_id: NodeId,
relation: Relation,
strength: Strength,
memo: &mut Memoization<V>,
cycle_map: &mut CycleCheck,
domains: Option<&[DomainId]>,
) -> Result<(), GraphError<V>>
where
C: CheckingContext<Value = V>,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs | crate: hyperswitch_constraint_graph
use crate::{
builder,
dense_map::DenseMap,
error::{self, AnalysisTrace, GraphError},
types::{
CheckingContext, CycleCheck, DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId,
Memoization, Metadata, Node, NodeId, NodeType, NodeValue, Relation, RelationResolution,
Strength, ValueNode,
},
};
pub fn check_node<C>(
&self,
ctx: &C,
node_id: NodeId,
relation: Relation,
strength: Strength,
memo: &mut Memoization<V>,
cycle_map: &mut CycleCheck,
domains: Option<&[String]>,
) -> Result<(), GraphError<V>>
where
C: CheckingContext<Value = V>,
{
let domains = domains
.map(|domain_idents| {
domain_idents
.iter()
.map(|domain_ident| {
self.domain_identifier_map
.get(&DomainIdentifier::new(domain_ident.to_string()))
.copied()
.ok_or(GraphError::DomainNotFound)
})
.collect::<Result<Vec<_>, _>>()
})
.transpose()?;
self.check_node_inner(
ctx,
node_id,
relation,
strength,
memo,
cycle_map,
domains.as_deref(),
)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs | crate: hyperswitch_constraint_graph
use crate::{
builder,
dense_map::DenseMap,
error::{self, AnalysisTrace, GraphError},
types::{
CheckingContext, CycleCheck, DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId,
Memoization, Metadata, Node, NodeId, NodeType, NodeValue, Relation, RelationResolution,
Strength, ValueNode,
},
};
pub fn get_viz_digraph_string(&self) -> String {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs | crate: hyperswitch_constraint_graph
use std::sync::{Arc, Weak};
use crate::{
builder,
dense_map::DenseMap,
error::{self, AnalysisTrace, GraphError},
types::{
CheckingContext, CycleCheck, DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId,
Memoization, Metadata, Node, NodeId, NodeType, NodeValue, Relation, RelationResolution,
Strength, ValueNode,
},
};
fn build_edge(cg_edge: &types::Edge) -> Edge {
{
types::Relation::Positive => "blue",<|fim_suffix|>
<|fim_middle|>
types::Relation::Negative => "red",
}
} | ast_fragments |
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs | crate: hyperswitch_constraint_graph
use crate::{
builder,
dense_map::DenseMap,
error::{self, AnalysisTrace, GraphError},
types::{
CheckingContext, CycleCheck, DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId,
Memoization, Metadata, Node, NodeId, NodeType, NodeValue, Relation, RelationResolution,
Strength, ValueNode,
},
};
pub fn get_viz_digraph_string(&self) -> String {
let mut ctx = PrinterContext::default();
let digraph = self.get_viz_digraph();
digraph.print(&mut ctx)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs | crate: hyperswitch_constraint_graph
use crate::{
builder,
dense_map::DenseMap,
error::{self, AnalysisTrace, GraphError},
types::{
CheckingContext, CycleCheck, DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId,
Memoization, Metadata, Node, NodeId, NodeType, NodeValue, Relation, RelationResolution,
Strength, ValueNode,
},
};
pub fn get_viz_digraph(&self) -> Graph {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs | crate: hyperswitch_constraint_graph
use std::sync::{Arc, Weak};
use crate::{
builder,
dense_map::DenseMap,
error::{self, AnalysisTrace, GraphError},
types::{
CheckingContext, CycleCheck, DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId,
Memoization, Metadata, Node, NodeId, NodeType, NodeValue, Relation, RelationResolution,
Strength, ValueNode,
},
};
fn build_edge(cg_edge: &types::Edge) -> Edge {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs | crate: hyperswitch_constraint_graph
use crate::{
builder,
dense_map::DenseMap,
error::{self, AnalysisTrace, GraphError},
types::{
CheckingContext, CycleCheck, DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId,
Memoization, Metadata, Node, NodeId, NodeType, NodeValue, Relation, RelationResolution,
Strength, ValueNode,
},
};
fn build_node(cg_node_id: types::NodeId, cg_node: &types::Node<V>) -> Node {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs | crate: hyperswitch_constraint_graph
use crate::{
builder,
dense_map::DenseMap,
error::{self, AnalysisTrace, GraphError},
types::{
CheckingContext, CycleCheck, DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId,
Memoization, Metadata, Node, NodeId, NodeType, NodeValue, Relation, RelationResolution,
Strength, ValueNode,
},
};
fn get_node_label(node: &types::Node<V>) -> String {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs | crate: hyperswitch_constraint_graph
use crate::{
builder,
dense_map::DenseMap,
error::{self, AnalysisTrace, GraphError},
types::{
CheckingContext, CycleCheck, DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId,
Memoization, Metadata, Node, NodeId, NodeType, NodeValue, Relation, RelationResolution,
Strength, ValueNode,
},
};
fn get_node_id(node_id: types::NodeId) -> String {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs | crate: hyperswitch_constraint_graph
use crate::{
builder,
dense_map::DenseMap,
error::{self, AnalysisTrace, GraphError},
types::{
CheckingContext, CycleCheck, DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId,
Memoization, Metadata, Node, NodeId, NodeType, NodeValue, Relation, RelationResolution,
Strength, ValueNode,
},
};
fn get_predecessor_edges_by_domain(
&self,
node_id: NodeId,
domains: Option<&[DomainId]>,
) -> Result<Vec<&Edge>, GraphError<V>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs | crate: hyperswitch_constraint_graph
use crate::{
builder,
dense_map::DenseMap,
error::{self, AnalysisTrace, GraphError},
types::{
CheckingContext, CycleCheck, DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId,
Memoization, Metadata, Node, NodeId, NodeType, NodeValue, Relation, RelationResolution,
Strength, ValueNode,
},
};
pub fn combine(g1: &Self, g2: &Self) -> Result<Self, GraphError<V>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs | crate: hyperswitch_constraint_graph
use std::sync::{Arc, Weak};
use crate::{
builder,
dense_map::DenseMap,
error::{self, AnalysisTrace, GraphError},
types::{
CheckingContext, CycleCheck, DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId,
Memoization, Metadata, Node, NodeId, NodeType, NodeValue, Relation, RelationResolution,
Strength, ValueNode,
},
};
fn validate_value_node<C>(
&self,
vald: CheckNodeContext<'_, V, C>,
val: &NodeValue<V>,
) -> Result<(), GraphError<V>>
where
C: CheckingContext<Value = V>,
{
{
(Strength::Strong, Err(trace)) => {
let err = Arc::new(AnalysisTrace::Value {
value: val.clone(),
relation: vald.relation,
info: self.node_info.get(vald.node_id).copied().flatten(),
metadata: self.node_metadata.get(vald.node_id).cloned().flatten(),
predecessors: Some(error::ValueTracePredecessor::Mandatory(Box::new(
trace.get_analysis_trace()?,
))),
});
vald.memo.insert(
(vald.node_id, vald.relation, vald.strength),
Err(Arc::clone(&err)),
);
Err(GraphError::AnalysisError(Arc::downgrade(&err)))?;
}<|fim_suffix|>
<|fim_middle|>
(Strength::Normal | Strength::Weak, Ok(_)) => {
matched_one = true;
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/error.rs | crate: hyperswitch_constraint_graph
use std::sync::{Arc, Weak};
pub fn get_analysis_trace(self) -> Result<Weak<AnalysisTrace<V>>, Self> {
{
Self::AnalysisError(trace) => Ok(trace),<|fim_suffix|>
<|fim_middle|>
_ => Err(self),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/error.rs | crate: hyperswitch_constraint_graph
use std::sync::{Arc, Weak};
pub fn get_analysis_trace(self) -> Result<Weak<AnalysisTrace<V>>, Self> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs | crate: hyperswitch_constraint_graph
pub(crate) use impl_entity;
pub fn contains_key(&self, key: K) -> bool {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs | crate: hyperswitch_constraint_graph
pub(crate) use impl_entity;
pub fn push(&mut self, elem: V) -> K {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs | crate: hyperswitch_constraint_graph
use std::{fmt, iter, marker::PhantomData, ops, slice, vec};
fn from_iter<T>(iter: T) -> Self
where
T: IntoIterator<Item = V>,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs | crate: hyperswitch_constraint_graph
fn into_iter(self) -> Self::IntoIter {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs | crate: hyperswitch_constraint_graph
fn next(&mut self) -> Option<Self::Item> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs | crate: hyperswitch_constraint_graph
use std::{fmt, iter, marker::PhantomData, ops, slice, vec};
fn new(iter: vec::IntoIter<V>) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs | crate: hyperswitch_constraint_graph
fn next(&mut self) -> Option<Self::Item> {
self.inner.next().map(|(id, val)| (K::with_id(id), val))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs | crate: hyperswitch_constraint_graph
use std::{fmt, iter, marker::PhantomData, ops, slice, vec};
fn new(iter: slice::IterMut<'a, V>) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs | crate: hyperswitch_constraint_graph
use std::{fmt, iter, marker::PhantomData, ops, slice, vec};
fn new(iter: slice::Iter<'a, V>) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs | crate: hyperswitch_constraint_graph
use std::{fmt, iter, marker::PhantomData, ops, slice, vec};
fn new(range: ops::Range<usize>) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs | crate: hyperswitch_constraint_graph
use std::{fmt, iter, marker::PhantomData, ops, slice, vec};
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_map().entries(self.iter()).finish()
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs | crate: hyperswitch_constraint_graph
pub(crate) use impl_entity;
pub fn iter_mut(&mut self) -> IterMut<'_, K, V> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs | crate: hyperswitch_constraint_graph
use std::{fmt, iter, marker::PhantomData, ops, slice, vec};
pub(crate) use impl_entity;
pub fn iter(&self) -> Iter<'_, K, V> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs | crate: hyperswitch_constraint_graph
use std::{fmt, iter, marker::PhantomData, ops, slice, vec};
pub(crate) use impl_entity;
pub fn into_values(self) -> vec::IntoIter<V> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs | crate: hyperswitch_constraint_graph
use std::{fmt, iter, marker::PhantomData, ops, slice, vec};
pub(crate) use impl_entity;
pub fn values_mut(&mut self) -> slice::IterMut<'_, V> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs | crate: hyperswitch_constraint_graph
use std::{fmt, iter, marker::PhantomData, ops, slice, vec};
pub(crate) use impl_entity;
pub fn values(&self) -> slice::Iter<'_, V> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs | crate: hyperswitch_constraint_graph
pub(crate) use impl_entity;
pub fn into_keys(self) -> Keys<K> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs | crate: hyperswitch_constraint_graph
pub(crate) use impl_entity;
pub fn keys(&self) -> Keys<K> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs | crate: hyperswitch_constraint_graph
pub(crate) use impl_entity;
pub fn contains_key(&self, key: K) -> bool {
key.get_id() < self.data.len()
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs | crate: hyperswitch_constraint_graph
pub(crate) use impl_entity;
pub fn get_mut(&mut self, idx: K) -> Option<&mut V> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs | crate: hyperswitch_constraint_graph
pub(crate) use impl_entity;
pub fn get(&self, idx: K) -> Option<&V> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs | crate: hyperswitch_constraint_graph
pub(crate) use impl_entity;
pub fn push(&mut self, elem: V) -> K {
let curr_len = self.data.len();
self.data.push(elem);
K::with_id(curr_len)
} | ast_fragments |
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs | crate: hyperswitch_constraint_graph
use std::{fmt, iter, marker::PhantomData, ops, slice, vec};
pub(crate) use impl_entity;
pub fn new() -> Self {
Self {
data: Vec::new(),
_marker: PhantomData,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/builder.rs | crate: hyperswitch_constraint_graph
use std::sync::Arc;
use rustc_hash::{FxHashMap, FxHashSet};
use crate::{
dense_map::DenseMap,
error::GraphError,
graph::ConstraintGraph,
types::{
DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId, Metadata, Node, NodeId, NodeType,
NodeValue, Relation, Strength, ValueNode,
},
};
pub fn make_in_aggregator<M: Metadata>(
&mut self,
values: Vec<V>,
info: Option<&'static str>,
metadata: Option<M>,
) -> Result<NodeId, GraphError<V>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/builder.rs | crate: hyperswitch_constraint_graph
use crate::{
dense_map::DenseMap,
error::GraphError,
graph::ConstraintGraph,
types::{
DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId, Metadata, Node, NodeId, NodeType,
NodeValue, Relation, Strength, ValueNode,
},
};
pub fn make_edge<T: Into<DomainIdOrIdentifier>>(
&mut self,
pred_id: NodeId,
succ_id: NodeId,
strength: Strength,
relation: Relation,
domain: Option<T>,
) -> Result<EdgeId, GraphError<V>> {
{
DomainIdOrIdentifier::DomainIdentifier(ident) => {
self.retrieve_domain_from_identifier(ident)
}<|fim_suffix|>
<|fim_middle|>
DomainIdOrIdentifier::DomainId(domain_id) => {
self.ensure_domain_exists(domain_id).map(|_| domain_id)
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/builder.rs | crate: hyperswitch_constraint_graph
use crate::{
dense_map::DenseMap,
error::GraphError,
graph::ConstraintGraph,
types::{
DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId, Metadata, Node, NodeId, NodeType,
NodeValue, Relation, Strength, ValueNode,
},
};
pub fn make_edge<T: Into<DomainIdOrIdentifier>>(
&mut self,
pred_id: NodeId,
succ_id: NodeId,
strength: Strength,
relation: Relation,
domain: Option<T>,
) -> Result<EdgeId, GraphError<V>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/builder.rs | crate: hyperswitch_constraint_graph
use crate::{
dense_map::DenseMap,
error::GraphError,
graph::ConstraintGraph,
types::{
DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId, Metadata, Node, NodeId, NodeType,
NodeValue, Relation, Strength, ValueNode,
},
};
fn ensure_domain_exists(&self, id: DomainId) -> Result<(), GraphError<V>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/builder.rs | crate: hyperswitch_constraint_graph
use crate::{
dense_map::DenseMap,
error::GraphError,
graph::ConstraintGraph,
types::{
DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId, Metadata, Node, NodeId, NodeType,
NodeValue, Relation, Strength, ValueNode,
},
};
fn ensure_node_exists(&self, id: NodeId) -> Result<(), GraphError<V>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/builder.rs | crate: hyperswitch_constraint_graph
use std::sync::Arc;
use crate::{
dense_map::DenseMap,
error::GraphError,
graph::ConstraintGraph,
types::{
DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId, Metadata, Node, NodeId, NodeType,
NodeValue, Relation, Strength, ValueNode,
},
};
pub fn make_any_aggregator<M: Metadata>(
&mut self,
nodes: &[(NodeId, Relation, Strength)],
info: Option<&'static str>,
metadata: Option<M>,
domain_id: Option<DomainId>,
) -> Result<NodeId, GraphError<V>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/builder.rs | crate: hyperswitch_constraint_graph
use std::sync::Arc;
use crate::{
dense_map::DenseMap,
error::GraphError,
graph::ConstraintGraph,
types::{
DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId, Metadata, Node, NodeId, NodeType,
NodeValue, Relation, Strength, ValueNode,
},
};
pub fn make_all_aggregator<M: Metadata>(
&mut self,
nodes: &[(NodeId, Relation, Strength)],
info: Option<&'static str>,
metadata: Option<M>,
domain_id: Option<DomainId>,
) -> Result<NodeId, GraphError<V>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/builder.rs | crate: hyperswitch_constraint_graph
use std::sync::Arc;
use crate::{
dense_map::DenseMap,
error::GraphError,
graph::ConstraintGraph,
types::{
DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId, Metadata, Node, NodeId, NodeType,
NodeValue, Relation, Strength, ValueNode,
},
};
pub fn make_value_node<M: Metadata>(
&mut self,
value: NodeValue<V>,
info: Option<&'static str>,
metadata: Option<M>,
) -> NodeId {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/builder.rs | crate: hyperswitch_constraint_graph
use crate::{
dense_map::DenseMap,
error::GraphError,
graph::ConstraintGraph,
types::{
DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId, Metadata, Node, NodeId, NodeType,
NodeValue, Relation, Strength, ValueNode,
},
};
pub fn make_domain(
&mut self,
domain_identifier: String,
domain_description: &str,
) -> Result<DomainId, GraphError<V>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/builder.rs | crate: hyperswitch_constraint_graph
use crate::{
dense_map::DenseMap,
error::GraphError,
graph::ConstraintGraph,
types::{
DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId, Metadata, Node, NodeId, NodeType,
NodeValue, Relation, Strength, ValueNode,
},
};
fn retrieve_domain_from_identifier(
&self,
domain_ident: DomainIdentifier,
) -> Result<DomainId, GraphError<V>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/builder.rs | crate: hyperswitch_constraint_graph
use crate::{
dense_map::DenseMap,
error::GraphError,
graph::ConstraintGraph,
types::{
DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId, Metadata, Node, NodeId, NodeType,
NodeValue, Relation, Strength, ValueNode,
},
};
pub fn build(self) -> ConstraintGraph<V> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/builder.rs | crate: hyperswitch_constraint_graph
use crate::{
dense_map::DenseMap,
error::GraphError,
graph::ConstraintGraph,
types::{
DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId, Metadata, Node, NodeId, NodeType,
NodeValue, Relation, Strength, ValueNode,
},
};
fn from(value: DomainId) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/builder.rs | crate: hyperswitch_constraint_graph
use crate::{
dense_map::DenseMap,
error::GraphError,
graph::ConstraintGraph,
types::{
DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId, Metadata, Node, NodeId, NodeType,
NodeValue, Relation, Strength, ValueNode,
},
};
fn from(value: DomainIdentifier) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_constraint_graph/src/builder.rs | crate: hyperswitch_constraint_graph
use crate::{
dense_map::DenseMap,
error::GraphError,
graph::ConstraintGraph,
types::{
DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId, Metadata, Node, NodeId, NodeType,
NodeValue, Relation, Strength, ValueNode,
},
};
fn from(value: String) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/connector_configs/src/response_modifier.rs | crate: connector_configs
use crate::common_config::{
CardProvider, ConnectorApiIntegrationPayload, DashboardPaymentMethodPayload,
DashboardRequestPayload, Provider,
};
pub fn get_transformed_response_payload(response: Self) -> DashboardRequestPayload {
{
api_models::enums::PaymentMethodType::Credit => {
if let Some(card_networks) = method_type.card_networks {
for card in card_networks {
credit_details.push(CardProvider {
payment_method_type: card,
accepted_currencies: method_type
.accepted_currencies
.clone(),
accepted_countries: method_type
.accepted_countries
.clone(),
})
}
}
}<|fim_suffix|>
<|fim_middle|>
_ => (),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/connector_configs/src/response_modifier.rs | crate: connector_configs
use crate::common_config::{
CardProvider, ConnectorApiIntegrationPayload, DashboardPaymentMethodPayload,
DashboardRequestPayload, Provider,
};
pub fn get_transformed_response_payload(response: Self) -> DashboardRequestPayload {
{let mut wallet_details: Vec<Provider> = Vec::new();let mut bank_redirect_details: Vec<Provider> = Vec::new();<|fim_suffix|>
<|fim_middle|>
let credit_details = DashboardPaymentMethodPayload {
payment_method: api_models::enums::PaymentMethod::Card,
payment_method_type: api_models::enums::PaymentMethodType::Credit.to_string(),
provider: None,
card_provider: Some(credit_details),
};DashboardRequestPayload {
connector: response.connector_name,
payment_methods_enabled: Some(vec![
open_banking,
upi,
voucher,
reward,
real_time_payment,
wallet,
bank_redirect,
bank_debit,
bank_transfer,
crypto,
card_redirect,
pay_later,
debit_details,
credit_details,
gift_card,
]),
metadata: response.metadata,
}}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/connector_configs/src/connector.rs | crate: connector_configs
use api_models::{
enums::{AuthenticationConnectors, Connector, PmAuthConnectors, TaxConnectors},
payments,
};
pub fn get_authentication_connector_config(
connector: AuthenticationConnectors,
) -> Result<Option<ConnectorTomlConfig>, String> {
{
AuthenticationConnectors::Threedsecureio => Ok(connector_data.threedsecureio),<|fim_suffix|>
<|fim_middle|>
AuthenticationConnectors::Juspaythreedsserver => Ok(connector_data.juspaythreedsserver),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/connector_configs/src/connector.rs | crate: connector_configs
use api_models::enums::PayoutConnectors;
pub fn get_payout_connector_config(
connector: PayoutConnectors,
) -> Result<Option<ConnectorTomlConfig>, String> {
{
PayoutConnectors::Adyen => Ok(connector_data.adyen_payout),<|fim_suffix|>
<|fim_middle|>
PayoutConnectors::Wise => Ok(connector_data.wise_payout),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/connector_configs/src/connector.rs | crate: connector_configs
use api_models::{
enums::{AuthenticationConnectors, Connector, PmAuthConnectors, TaxConnectors},
payments,
};
pub fn get_pm_authentication_processor_config(
connector: PmAuthConnectors,
) -> Result<Option<ConnectorTomlConfig>, String> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/connector_configs/src/connector.rs | crate: connector_configs
use api_models::{
enums::{AuthenticationConnectors, Connector, PmAuthConnectors, TaxConnectors},
payments,
};
pub fn get_tax_processor_config(
connector: TaxConnectors,
) -> Result<Option<ConnectorTomlConfig>, String> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/connector_configs/src/connector.rs | crate: connector_configs
use api_models::{
enums::{AuthenticationConnectors, Connector, PmAuthConnectors, TaxConnectors},
payments,
};
pub fn get_authentication_connector_config(
connector: AuthenticationConnectors,
) -> Result<Option<ConnectorTomlConfig>, String> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/connector_configs/src/connector.rs | crate: connector_configs
use api_models::enums::PayoutConnectors;
pub fn get_payout_connector_config(
connector: PayoutConnectors,
) -> Result<Option<ConnectorTomlConfig>, String> {
let connector_data = Self::new()?;
match connector {
PayoutConnectors::Adyen => Ok(connector_data.adyen_payout),
PayoutConnectors::Adyenplatform => Ok(connector_data.adyenplatform_payout),
PayoutConnectors::Cybersource => Ok(connector_data.cybersource_payout),
PayoutConnectors::Ebanx => Ok(connector_data.ebanx_payout),
PayoutConnectors::Nomupay => Ok(connector_data.nomupay_payout),
PayoutConnectors::Payone => Ok(connector_data.payone_payout),
PayoutConnectors::Paypal => Ok(connector_data.paypal_payout),
PayoutConnectors::Stripe => Ok(connector_data.stripe_payout),
PayoutConnectors::Wise => Ok(connector_data.wise_payout),
}
} | ast_fragments |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.