text stringlengths 70 351k | source stringclasses 4
values |
|---|---|
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/state_machine.rs | crate: euclid
use super::types::EuclidAnalysable;
use crate::{dssa::types, frontend::dir, types::Metadata};
pub fn advance(&mut self) -> Result<Option<&types::ConjunctiveContext<'a>>, StateMachineError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/state_machine.rs | crate: euclid
use super::types::EuclidAnalysable;
use crate::{dssa::types, frontend::dir, types::Metadata};
pub fn new<O>(
program: &'a dir::DirProgram<O>,
connector_selection_data: &'a [Vec<(dir::DirValue, Metadata)>],
) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/state_machine.rs | crate: euclid
use super::types::EuclidAnalysable;
use crate::{dssa::types, frontend::dir, types::Metadata};
pub fn advance(
&mut self,
context: &mut types::ConjunctiveContext<'a>,
) -> Result<(), StateMachineError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/state_machine.rs | crate: euclid
use super::types::EuclidAnalysable;
use crate::{dssa::types, frontend::dir, types::Metadata};
pub fn init(
&mut self,
context: &mut types::ConjunctiveContext<'a>,
) -> Result<(), StateMachineError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/state_machine.rs | crate: euclid
pub fn is_finished(&self) -> bool {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/euclid/src/dssa/state_machine.rs | crate: euclid
use crate::{dssa::types, frontend::dir, types::Metadata};
pub fn new<O>(
program: &'a dir::DirProgram<O>,
connector_selection_data: &'a [Vec<(dir::DirValue, Metadata)>],
) -> Self {
let mut rule_machines: Vec<RuleStateMachine<'a>> = program
.rules
.iter()
.zip(connector_selection_data.iter())
.rev()
.map(|(rule, connector_selection_data)| {
RuleStateMachine::new(rule, connector_selection_data)
})
.collect();
Self {
current_rule_machine: rule_machines.pop(),
rule_machines,
is_init: false,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/state_machine.rs | crate: euclid
use super::types::EuclidAnalysable;
use crate::{dssa::types, frontend::dir, types::Metadata};
pub fn advance_mut(
&mut self,
) -> Result<Option<&mut types::ConjunctiveContext<'a>>, StateMachineError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/state_machine.rs | crate: euclid
use crate::{dssa::types, frontend::dir, types::Metadata};
pub fn new<O>(
rule: &'a dir::DirRule<O>,
connector_selection_data: &'a [(dir::DirValue, Metadata)],
) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/state_machine.rs | crate: euclid
fn is_finished(&self) -> bool {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/state_machine.rs | crate: euclid
use crate::{dssa::types, frontend::dir, types::Metadata};
fn new<O>(
rule: &'a dir::DirRule<O>,
connector_selection_data: &'a [(dir::DirValue, Metadata)],
) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/state_machine.rs | crate: euclid
fn advance(&mut self) -> Result<Option<Self>, StateMachineError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/state_machine.rs | crate: euclid
use super::types::EuclidAnalysable;
use crate::{dssa::types, frontend::dir, types::Metadata};
fn advance_condition_machine(
&mut self,
context: &mut types::ConjunctiveContext<'a>,
) -> Result<(), StateMachineError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/state_machine.rs | crate: euclid
use super::types::EuclidAnalysable;
use crate::{dssa::types, frontend::dir, types::Metadata};
fn destroy(&self, context: &mut types::ConjunctiveContext<'a>) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/state_machine.rs | crate: euclid
fn is_condition_machine_finished(&self) -> bool {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/state_machine.rs | crate: euclid
use super::types::EuclidAnalysable;
use crate::{dssa::types, frontend::dir, types::Metadata};
fn init(
&self,
context: &mut types::ConjunctiveContext<'a>,
) -> Result<Option<Self>, StateMachineError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/state_machine.rs | crate: euclid
use crate::{dssa::types, frontend::dir, types::Metadata};
fn new(stmt: &'a dir::DirIfStatement, ctx_start_idx: usize) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/state_machine.rs | crate: euclid
fn get_next_ctx_idx(&self) -> usize {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/state_machine.rs | crate: euclid
use super::types::EuclidAnalysable;
use crate::{dssa::types, frontend::dir, types::Metadata};
fn init(&self, context: &mut types::ConjunctiveContext<'a>) -> Result<(), StateMachineError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/state_machine.rs | crate: euclid
use crate::{dssa::types, frontend::dir, types::Metadata};
fn new(condition: &'a [dir::DirComparison], start_idx: usize) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/state_machine.rs | crate: euclid
use super::types::EuclidAnalysable;
use crate::{dssa::types, frontend::dir, types::Metadata};
fn push(&self, context: &mut types::ConjunctiveContext<'a>) -> Result<(), StateMachineError> {
{
dir::DirComparisonLogic::PositiveDisjunction => {
context.push(types::ContextValue::assertion(
self.values
.get(self.count)
.ok_or(StateMachineError::IndexOutOfBounds(
"in ComparisonStateMachine while pushing",
))?,
self.metadata,
));
}<|fim_suffix|>
<|fim_middle|>
dir::DirComparisonLogic::NegativeConjunction => {
context.push(types::ContextValue::negation(self.values, self.metadata));
}
}
} | ast_fragments |
// file: hyperswitch/crates/euclid/src/dssa/state_machine.rs | crate: euclid
use super::types::EuclidAnalysable;
use crate::{dssa::types, frontend::dir, types::Metadata};
fn put(&self, context: &mut types::ConjunctiveContext<'a>) -> Result<(), StateMachineError> {
if let dir::DirComparisonLogic::PositiveDisjunction = self.logic {
*context
.get_mut(self.ctx_idx)
.ok_or(StateMachineError::IndexOutOfBounds(
"in ComparisonStateMachine while indexing into context",
))? = types::ContextValue::assertion(
self.values
.get(self.count)
.ok_or(StateMachineError::IndexOutOfBounds(
"in ComparisonStateMachine while indexing into values",
))?,
self.metadata,
);
}
Ok(())
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/state_machine.rs | crate: euclid
fn reset(&mut self) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/state_machine.rs | crate: euclid
use crate::{dssa::types, frontend::dir, types::Metadata};
fn advance(&mut self) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/state_machine.rs | crate: euclid
use super::types::EuclidAnalysable;
use crate::{dssa::types, frontend::dir, types::Metadata};
fn test_correct_contexts() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use std::{fmt::Debug, sync::Weak};
use hyperswitch_constraint_graph as cgraph;
use crate::{
dssa::types,
frontend::dir,
types::{DataType, Metadata},
};
fn test_cycle_resolution_in_graph1() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use std::{fmt::Debug, sync::Weak};
use hyperswitch_constraint_graph as cgraph;
use crate::{
dssa::types,
frontend::dir,
types::{DataType, Metadata},
};
fn test_cycle_resolution_in_graph() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use hyperswitch_constraint_graph as cgraph;
use crate::{
dssa::types,
frontend::dir,
types::{DataType, Metadata},
};
fn test_memoization_in_kgraph() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use std::{fmt::Debug, sync::Weak};
use hyperswitch_constraint_graph as cgraph;
use crate::{
dssa::types,
frontend::dir,
types::{DataType, Metadata},
};
fn test_in_aggregator_failure_trace() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use hyperswitch_constraint_graph as cgraph;
use crate::{
dssa::types,
frontend::dir,
types::{DataType, Metadata},
};
fn perform_context_analysis(
&self,
ctx: &types::ConjunctiveContext<'_>,
memo: &mut cgraph::Memoization<dir::DirValue>,
domains: Option<&[String]>,
) -> Result<(), AnalysisError<dir::DirValue>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use hyperswitch_constraint_graph as cgraph;
use rustc_hash::{FxHashMap, FxHashSet};
use crate::{
dssa::types,
frontend::dir,
types::{DataType, Metadata},
};
fn negation_analysis(
&self,
negative_ctx: &[(&[dir::DirValue], &Metadata)],
analysis_ctx: &mut AnalysisContext,
memo: &mut cgraph::Memoization<dir::DirValue>,
cycle_map: &mut cgraph::CycleCheck,
domains: Option<&[String]>,
) -> Result<(), AnalysisError<dir::DirValue>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use std::{fmt::Debug, sync::Weak};
use hyperswitch_constraint_graph as cgraph;
use crate::{
dssa::types,
frontend::dir,
types::{DataType, Metadata},
};
fn check_value_validity(
&self,
val: dir::DirValue,
analysis_ctx: &AnalysisContext,
memo: &mut cgraph::Memoization<dir::DirValue>,
cycle_map: &mut cgraph::CycleCheck,
domains: Option<&[String]>,
) -> Result<bool, cgraph::GraphError<dir::DirValue>> {
let maybe_node_id = self.value_map.get(&cgraph::NodeValue::Value(val));
let node_id = if let Some(nid) = maybe_node_id {
nid
} else {
return Ok(false);
};
let result = self.check_node(
analysis_ctx,
*node_id,
cgraph::Relation::Positive,
cgraph::Strength::Weak,
memo,
cycle_map,
domains,
);
match result {
Ok(_) => Ok(true),
Err(e) => {
e.get_analysis_trace()?;
Ok(false)
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use std::{fmt::Debug, sync::Weak};
use hyperswitch_constraint_graph as cgraph;
use crate::{
dssa::types,
frontend::dir,
types::{DataType, Metadata},
};
fn check_presence(
&self,
value: &cgraph::NodeValue<dir::DirValue>,
strength: cgraph::Strength,
) -> bool {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
fn viz(&self) -> String {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use std::{fmt::Debug, sync::Weak};
use hyperswitch_constraint_graph as cgraph;
use crate::{
dssa::types,
frontend::dir,
types::{DataType, Metadata},
};
fn check_value_validity(
&self,
val: dir::DirValue,
analysis_ctx: &AnalysisContext,
memo: &mut cgraph::Memoization<dir::DirValue>,
cycle_map: &mut cgraph::CycleCheck,
domains: Option<&[String]>,
) -> Result<bool, cgraph::GraphError<dir::DirValue>> {
{
Ok(_) => Ok(true),<|fim_suffix|>
<|fim_middle|>
Err(e) => {
e.get_analysis_trace()?;
Ok(false)
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use hyperswitch_constraint_graph as cgraph;
use crate::{
dssa::types,
frontend::dir,
types::{DataType, Metadata},
};
fn assertion_from_graph_error(metadata: &Metadata, graph_error: cgraph::GraphError<V>) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use hyperswitch_constraint_graph as cgraph;
fn test_not_in_aggregator_failure() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use hyperswitch_constraint_graph as cgraph;
fn test_not_in_aggregator_success() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use hyperswitch_constraint_graph as cgraph;
fn test_in_aggregator_failure() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use hyperswitch_constraint_graph as cgraph;
fn test_in_aggregator_success() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use std::{fmt::Debug, sync::Weak};
use hyperswitch_constraint_graph as cgraph;
fn test_all_aggregator_mandatory_failure() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use hyperswitch_constraint_graph as cgraph;
fn test_all_aggregator_failure() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use hyperswitch_constraint_graph as cgraph;
fn test_all_aggregator_success() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use std::{fmt::Debug, sync::Weak};
use hyperswitch_constraint_graph as cgraph;
fn test_normal_one_of_failure() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use hyperswitch_constraint_graph as cgraph;
fn test_strong_negative_relation_failure() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use hyperswitch_constraint_graph as cgraph;
fn test_strong_negative_relation_success() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use hyperswitch_constraint_graph as cgraph;
fn test_strong_positive_relation_failure() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use hyperswitch_constraint_graph as cgraph;
fn test_strong_positive_relation_success() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use hyperswitch_constraint_graph as cgraph;
use crate::{
dssa::types,
frontend::dir,
types::{DataType, Metadata},
};
fn assertion_analysis(
&self,
positive_ctx: &[(&dir::DirValue, &Metadata)],
analysis_ctx: &AnalysisContext,
memo: &mut cgraph::Memoization<dir::DirValue>,
cycle_map: &mut cgraph::CycleCheck,
domains: Option<&[String]>,
) -> Result<(), AnalysisError<dir::DirValue>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use hyperswitch_constraint_graph as cgraph;
use crate::{
dssa::types,
frontend::dir,
types::{DataType, Metadata},
};
fn key_value_analysis(
&self,
val: dir::DirValue,
ctx: &AnalysisContext,
memo: &mut cgraph::Memoization<dir::DirValue>,
cycle_map: &mut cgraph::CycleCheck,
domains: Option<&[String]>,
) -> Result<(), cgraph::GraphError<dir::DirValue>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use hyperswitch_constraint_graph as cgraph;
use crate::{
dssa::types,
frontend::dir,
types::{DataType, Metadata},
};
fn value_analysis(
&self,
val: dir::DirValue,
ctx: &AnalysisContext,
memo: &mut cgraph::Memoization<dir::DirValue>,
cycle_map: &mut cgraph::CycleCheck,
domains: Option<&[String]>,
) -> Result<(), cgraph::GraphError<dir::DirValue>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use hyperswitch_constraint_graph as cgraph;
use crate::{
dssa::types,
frontend::dir,
types::{DataType, Metadata},
};
fn key_analysis(
&self,
key: dir::DirKey,
ctx: &AnalysisContext,
memo: &mut cgraph::Memoization<dir::DirValue>,
cycle_map: &mut cgraph::CycleCheck,
domains: Option<&[String]>,
) -> Result<(), cgraph::GraphError<dir::DirValue>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use hyperswitch_constraint_graph as cgraph;
fn get_values_by_key(
&self,
key: &<Self::Value as cgraph::ValueNode>::Key,
) -> Option<Vec<Self::Value>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use rustc_hash::{FxHashMap, FxHashSet};
use crate::{
dssa::types,
frontend::dir,
types::{DataType, Metadata},
};
fn from_node_values<L>(vals: impl IntoIterator<Item = L>) -> Self
where
L: Into<Self::Value>,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use crate::{
dssa::types,
frontend::dir,
types::{DataType, Metadata},
};
pub fn remove(&mut self, value: dir::DirValue) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use crate::{
dssa::types,
frontend::dir,
types::{DataType, Metadata},
};
pub fn insert(&mut self, value: dir::DirValue) {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use rustc_hash::{FxHashMap, FxHashSet};
use crate::{
dssa::types,
frontend::dir,
types::{DataType, Metadata},
};
pub fn from_dir_values(vals: impl IntoIterator<Item = dir::DirValue>) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use hyperswitch_constraint_graph as cgraph;
use crate::{
dssa::types,
frontend::dir,
types::{DataType, Metadata},
};
fn negation_from_graph_error(
metadata: Vec<&Metadata>,
graph_error: cgraph::GraphError<V>,
) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use hyperswitch_constraint_graph as cgraph;
use crate::{
dssa::types,
frontend::dir,
types::{DataType, Metadata},
};
fn assertion_from_graph_error(metadata: &Metadata, graph_error: cgraph::GraphError<V>) -> Self {
match graph_error {
cgraph::GraphError::AnalysisError(trace) => Self::AssertionTrace {
trace,
metadata: metadata.clone(),
},
other => Self::Graph(other),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
fn get_key(&self) -> Self::Key {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid/src/dssa/graph.rs | crate: euclid
use std::{fmt::Debug, sync::Weak};
use hyperswitch_constraint_graph as cgraph;
use crate::{
dssa::types,
frontend::dir,
types::{DataType, Metadata},
};
fn test_cycle_resolution_in_graph2() {
{let mut builder = cgraph::ConstraintGraphBuilder::new();<|fim_suffix|>
<|fim_middle|>
assert!(_result.is_ok());}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
type PaymentMethodMigrationResponseType = (
Result<PaymentMethodMigrateResponse, String>,
PaymentMethodRecord,
);
fn from((response, record): PaymentMethodMigrationResponseType) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
use serde::de;
use crate::{
admin, enums as api_enums,
payments::{self, BankCodeResponse},
};
type PaymentMethodMigrationResponseType = (
Result<PaymentMethodMigrateResponse, String>,
PaymentMethodRecord,
);
fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
where
A: de::MapAccess<'de>,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
use cards::CardNumber;
use crate::payouts;
pub fn get_payment_method_create_from_payment_method_migrate(
card_number: CardNumber,
payment_method_migrate: &PaymentMethodMigrate,
) -> Self {
let card_details =
payment_method_migrate
.card
.as_ref()
.map(|payment_method_migrate_card| CardDetail {
card_number,
card_exp_month: payment_method_migrate_card.card_exp_month.clone(),
card_exp_year: payment_method_migrate_card.card_exp_year.clone(),
card_holder_name: payment_method_migrate_card.card_holder_name.clone(),
nick_name: payment_method_migrate_card.nick_name.clone(),
card_issuing_country: payment_method_migrate_card.card_issuing_country.clone(),
card_network: payment_method_migrate_card.card_network.clone(),
card_issuer: payment_method_migrate_card.card_issuer.clone(),
card_type: payment_method_migrate_card.card_type.clone(),
});
Self {
customer_id: payment_method_migrate.customer_id.clone(),
payment_method: payment_method_migrate.payment_method,
payment_method_type: payment_method_migrate.payment_method_type,
payment_method_issuer: payment_method_migrate.payment_method_issuer.clone(),
payment_method_issuer_code: payment_method_migrate.payment_method_issuer_code,
metadata: payment_method_migrate.metadata.clone(),
payment_method_data: payment_method_migrate.payment_method_data.clone(),
connector_mandate_details: payment_method_migrate
.connector_mandate_details
.clone()
.map(|common_mandate_reference| {
PaymentsMandateReference::from(common_mandate_reference)
}),
client_secret: None,
billing: payment_method_migrate.billing.clone(),
card: card_details,
card_network: payment_method_migrate.card_network.clone(),
#[cfg(feature = "payouts")]
bank_transfer: payment_method_migrate.bank_transfer.clone(),
#[cfg(feature = "payouts")]
wallet: payment_method_migrate.wallet.clone(),
network_transaction_id: payment_method_migrate.network_transaction_id.clone(),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
use serde::de;
use crate::payouts;
use crate::{
admin, enums as api_enums,
payments::{self, BankCodeResponse},
};
type PaymentMethodMigrationResponseType = (
Result<PaymentMethodMigrateResponse, String>,
PaymentMethodRecord,
);
fn deserialize_connector_mandate_details<'de, D>(
deserializer: D,
) -> Result<Option<CommonMandateReference>, D::Error>
where
D: serde::Deserializer<'de>,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
use serde::de;
use crate::{
admin, enums as api_enums,
payments::{self, BankCodeResponse},
};
type PaymentMethodMigrationResponseType = (
Result<PaymentMethodMigrateResponse, String>,
PaymentMethodRecord,
);
fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
where
A: de::MapAccess<'de>,
{
{
Some(inner) => inner.push(map.next_value()?),<|fim_suffix|>
<|fim_middle|>
None => {
output.accepted_currencies = Some(vec![map.next_value()?]);
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
use serde::de;
use crate::{
admin, enums as api_enums,
payments::{self, BankCodeResponse},
};
type PaymentMethodMigrationResponseType = (
Result<PaymentMethodMigrateResponse, String>,
PaymentMethodRecord,
);
fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
where
A: de::MapAccess<'de>,
{
{
Some(inner) => inner.push(map.next_value()?),<|fim_suffix|>
<|fim_middle|>
None => {
output.accepted_countries = Some(vec![map.next_value()?]);
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
use masking::PeekInterface;
use masking::{ExposeInterface, PeekInterface};
fn from(card: &Card) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
use common_utils::{
consts::SURCHARGE_PERCENTAGE_PRECISION_LENGTH,
crypto::OptionalEncryptableName,
errors,
ext_traits::OptionExt,
id_type, link_utils, pii,
types::{MinorUnit, Percentage, Surcharge},
};
use crate::{
admin, enums as api_enums,
payments::{self, BankCodeResponse},
};
type PaymentMethodMigrationResponseType = (
Result<PaymentMethodMigrateResponse, String>,
PaymentMethodRecord,
);
fn from(value: (PaymentMethodRecord, id_type::MerchantId)) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
use std::str::FromStr;
use serde::de;
type PaymentMethodMigrationResponseType = (
Result<PaymentMethodMigrateResponse, String>,
PaymentMethodRecord,
);
fn set_or_reject_duplicate<T, E: de::Error>(
data: &mut Option<T>,
name: &'static str,
value: T,
) -> Result<(), E> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
use std::collections::{HashMap, HashSet};
use std::str::FromStr;
use crate::{
admin, enums as api_enums,
payments::{self, BankCodeResponse},
};
type PaymentMethodMigrationResponseType = (
Result<PaymentMethodMigrateResponse, String>,
PaymentMethodRecord,
);
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
use crate::{
admin, enums as api_enums,
payments::{self, BankCodeResponse},
};
pub fn get_payment_method_type(&self) -> Option<api_enums::PaymentMethodType> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
use crate::{
admin, enums as api_enums,
payments::{self, BankCodeResponse},
};
type PaymentMethodMigrationResponseType = (
Result<PaymentMethodMigrateResponse, String>,
PaymentMethodRecord,
);
pub fn new(
pm_type: RequestPaymentMethodTypes,
connector: String,
merchant_connector_id: String,
pm: api_enums::PaymentMethod,
) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
use common_utils::{
consts::SURCHARGE_PERCENTAGE_PRECISION_LENGTH,
crypto::OptionalEncryptableName,
errors,
ext_traits::OptionExt,
id_type, link_utils, pii,
types::{MinorUnit, Percentage, Surcharge},
};
fn from(value: Percentage<SURCHARGE_PERCENTAGE_PRECISION_LENGTH>) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
use common_utils::{
consts::SURCHARGE_PERCENTAGE_PRECISION_LENGTH,
crypto::OptionalEncryptableName,
errors,
ext_traits::OptionExt,
id_type, link_utils, pii,
types::{MinorUnit, Percentage, Surcharge},
};
fn from(value: Surcharge) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
fn from(item: CardDetailFromLocker) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
fn from(item: CardDetail) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
use crate::{
admin, enums as api_enums,
payments::{self, BankCodeResponse},
};
fn from(item: CardDetailsPaymentMethod) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
fn from(item: PaymentMethodDataWalletInfo) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
use crate::{
admin, enums as api_enums,
payments::{self, BankCodeResponse},
};
fn from(item: payments::additional_info::WalletAdditionalDataForCard) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
use masking::PeekInterface;
use masking::{ExposeInterface, PeekInterface};
use crate::{
admin, enums as api_enums,
payments::{self, BankCodeResponse},
};
pub fn apply(&self, card_data_from_locker: Card) -> CardDetail {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
use common_utils::{
consts::SURCHARGE_PERCENTAGE_PRECISION_LENGTH,
crypto::OptionalEncryptableName,
errors,
ext_traits::OptionExt,
id_type, link_utils, pii,
types::{MinorUnit, Percentage, Surcharge},
};
use crate::{
admin, enums as api_enums,
payments::{self, BankCodeResponse},
};
type PaymentMethodMigrationResponseType = (
Result<PaymentMethodMigrateResponse, String>,
PaymentMethodRecord,
);
pub fn get_tokenize_connector_id(
&self,
) -> Result<id_type::MerchantConnectorAccountId, error_stack::Report<errors::ValidationError>>
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
use crate::{
admin, enums as api_enums,
payments::{self, BankCodeResponse},
};
pub fn validate_payment_method_data_against_payment_method(
payment_method_type: api_enums::PaymentMethod,
payment_method_data: PaymentMethodCreateData,
) -> bool {
match payment_method_type {
api_enums::PaymentMethod::Card => {
matches!(payment_method_data, PaymentMethodCreateData::Card(_))
}
_ => false,
}
} | ast_fragments |
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
use crate::payouts;
use crate::{
admin, enums as api_enums,
payments::{self, BankCodeResponse},
};
fn from(payments_reference: PaymentsMandateReference) -> Self {
Self {
payments: Some(payments_reference),
payouts: None,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
use crate::{
admin, enums as api_enums,
payments::{self, BankCodeResponse},
};
fn from(common_mandate: CommonMandateReference) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
fn from(item: PaymentMethodIntentConfirmInternal) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
use crate::{
admin, enums as api_enums,
payments::{self, BankCodeResponse},
};
pub fn validate_payment_method_data_against_payment_method(
payment_method_type: api_enums::PaymentMethod,
payment_method_data: PaymentMethodCreateData,
) -> bool {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payment_methods.rs | crate: api_models
use std::collections::{HashMap, HashSet};
use common_utils::{
consts::SURCHARGE_PERCENTAGE_PRECISION_LENGTH,
crypto::OptionalEncryptableName,
errors,
ext_traits::OptionExt,
id_type, link_utils, pii,
types::{MinorUnit, Percentage, Surcharge},
};
use crate::payouts;
use crate::{
admin, enums as api_enums,
payments::{self, BankCodeResponse},
};
type PaymentMethodMigrationResponseType = (
Result<PaymentMethodMigrateResponse, String>,
PaymentMethodRecord,
);
fn try_from(
item: (
PaymentMethodRecord,
id_type::MerchantId,
Option<id_type::MerchantConnectorAccountId>,
),
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/refunds.rs | crate: api_models
fn from(status: RefundStatus) -> Self {
{
RefundStatus::Failed => Self::Failure,<|fim_suffix|>
<|fim_middle|>
RefundStatus::Succeeded => Self::Success,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/refunds.rs | crate: api_models
fn from(status: RefundStatus) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/refunds.rs | crate: api_models
use crate::{
admin::{self, MerchantConnectorInfo},
enums,
};
fn from(status: enums::RefundStatus) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/refunds.rs | crate: api_models
pub use common_utils::types::MinorUnit;
use crate::{
admin::{self, MerchantConnectorInfo},
enums,
};
pub fn get_refund_id_as_string(&self) -> String {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payouts.rs | crate: api_models
use common_utils::{
consts::default_payouts_list_limit,
crypto, id_type, link_utils, payout_method_utils,
pii::{self, Email},
transformers::ForeignFrom,
types::{UnifiedCode, UnifiedMessage},
};
fn from(bank_data: Bank) -> Self {
{
Bank::Ach(AchBankTransfer {
bank_name,
bank_country_code,
bank_city,
bank_account_number,
bank_routing_number,
}) => Self::Ach(Box::new(
payout_method_utils::AchBankTransferAdditionalData {
bank_name,
bank_country_code,
bank_city,
bank_account_number: bank_account_number.into(),
bank_routing_number: bank_routing_number.into(),
},
)),<|fim_suffix|>
<|fim_middle|>
Bank::Pix(PixBankTransfer {
bank_name,
bank_branch,
bank_account_number,
pix_key,
tax_id,
}) => Self::Pix(Box::new(
payout_method_utils::PixBankTransferAdditionalData {
bank_name,
bank_branch,
bank_account_number: bank_account_number.into(),
pix_key: pix_key.into(),
tax_id: tax_id.map(From::from),
},
)),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payouts.rs | crate: api_models
use common_utils::{
consts::default_payouts_list_limit,
crypto, id_type, link_utils, payout_method_utils,
pii::{self, Email},
transformers::ForeignFrom,
types::{UnifiedCode, UnifiedMessage},
};
fn from(additional_data: payout_method_utils::AdditionalPayoutMethodData) -> Self {
{
payout_method_utils::AdditionalPayoutMethodData::Card(card_data) => {
Self::Card(card_data)
}<|fim_suffix|>
<|fim_middle|>
payout_method_utils::AdditionalPayoutMethodData::Wallet(wallet_data) => {
Self::Wallet(wallet_data)
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payouts.rs | crate: api_models
use common_utils::{
consts::default_payouts_list_limit,
crypto, id_type, link_utils, payout_method_utils,
pii::{self, Email},
transformers::ForeignFrom,
types::{UnifiedCode, UnifiedMessage},
};
fn from(bank_data: Bank) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payouts.rs | crate: api_models
use common_utils::{
consts::default_payouts_list_limit,
crypto, id_type, link_utils, payout_method_utils,
pii::{self, Email},
transformers::ForeignFrom,
types::{UnifiedCode, UnifiedMessage},
};
fn from(additional_data: payout_method_utils::AdditionalPayoutMethodData) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payouts.rs | crate: api_models
use common_utils::{
consts::default_payouts_list_limit,
crypto, id_type, link_utils, payout_method_utils,
pii::{self, Email},
transformers::ForeignFrom,
types::{UnifiedCode, UnifiedMessage},
};
fn from(wallet_data: Wallet) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/payouts.rs | crate: api_models
use common_utils::{
consts::default_payouts_list_limit,
crypto, id_type, link_utils, payout_method_utils,
pii::{self, Email},
transformers::ForeignFrom,
types::{UnifiedCode, UnifiedMessage},
};
pub fn get_customer_id(&self) -> Option<&id_type::CustomerId> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/cards_info.rs | crate: api_models
type CardInfoMigrationResponseType = (
Result<CardInfoMigrateResponseRecord, String>,
CardInfoUpdateRequest,
);
fn from((response, record): CardInfoMigrationResponseType) -> Self {
{
Ok(res) => Self {
card_iin: record.card_iin,
line_number: record.line_number,
card_issuer: res.card_issuer,
card_network: res.card_network,
card_type: res.card_type,
card_sub_type: res.card_sub_type,
card_issuing_country: res.card_issuing_country,
migration_status: CardInfoMigrationStatus::Success,
migration_error: None,
},<|fim_suffix|>
<|fim_middle|>
Err(e) => Self {
card_iin: record.card_iin,
migration_status: CardInfoMigrationStatus::Failed,
migration_error: Some(e),
line_number: record.line_number,
..Self::default()
},
}
} | ast_fragments |
// file: hyperswitch/crates/api_models/src/cards_info.rs | crate: api_models
type CardInfoMigrationResponseType = (
Result<CardInfoMigrateResponseRecord, String>,
CardInfoUpdateRequest,
);
fn from((response, record): CardInfoMigrationResponseType) -> Self {
match response {
Ok(res) => Self {
card_iin: record.card_iin,
line_number: record.line_number,
card_issuer: res.card_issuer,
card_network: res.card_network,
card_type: res.card_type,
card_sub_type: res.card_sub_type,
card_issuing_country: res.card_issuing_country,
migration_status: CardInfoMigrationStatus::Success,
migration_error: None,
},
Err(e) => Self {
card_iin: record.card_iin,
migration_status: CardInfoMigrationStatus::Failed,
migration_error: Some(e),
line_number: record.line_number,
..Self::default()
},
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/api_models/src/webhooks.rs | crate: api_models
use common_utils::custom_serde;
use crate::payouts;
use crate::{disputes, enums as api_enums, mandates, payments, refunds};
pub type MerchantWebhookConfig = std::collections::HashSet<IncomingWebhookEvent>;
pub fn get_connector_transaction_id_as_string(
self,
) -> Result<String, common_utils::errors::ValidationError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.