text stringlengths 70 351k | source stringclasses 4
values |
|---|---|
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use std::{
fmt::{Display, Formatter},
hash::Hash,
rc::Rc,
};
use proc_macro2::{Span, TokenStream};
use quote::{format_ident, quote};
fn compile_atom(
&mut self,
atom: &Rc<Atom>,
tok... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use rustc_hash::{FxHashMap, FxHashSet};
fn detect_graph_cycles(&self) -> Result<(), String> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use rustc_hash::{FxHashMap, FxHashSet};
fn cycle_dfs(
&self,
node_id: usize,
explored: &mut FxHashSet<usize>,
visited: &mut FxHashSet<usize>,
order: &mut Vec<usize>,
) -> Re... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use syn::{parse::Parse, Token};
fn parse_rhs_atom(input: syn::parse::ParseStream<'_>) -> syn::Result<Atom> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use std::{
fmt::{Display, Formatter},
hash::Hash,
rc::Rc,
};
use syn::{parse::Parse, Token};
fn parse_atom_type_inner(
input: syn::parse::ParseStream<'_>,
key: syn::Ident,
relation: Relation,
)... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use std::{
fmt::{Display, Formatter},
hash::Hash,
rc::Rc,
};
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
{
Self::Crate => write!(f, "crate"),<|fim_suffix|>
<|fim_middle|>
Self::Extern => wri... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use std::{
fmt::{Display, Formatter},
hash::Hash,
rc::Rc,
};
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
{
Self::LessThan => "< ",<|fim_suffix|>
<|fim_middle|>
Self::GreaterThan => "> ",
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use proc_macro2::{Span, TokenStream};
use syn::{parse::Parse, Token};
pub(crate) fn knowledge_inner(ts: TokenStream) -> syn::Result<TokenStream> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use std::{
fmt::{Display, Formatter},
hash::Hash,
rc::Rc,
};
use proc_macro2::{Span, TokenStream};
use quote::{format_ident, quote};
use rustc_hash::{FxHashMap, FxHashSet};
use syn::{parse::Parse, Token};
... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use proc_macro2::{Span, TokenStream};
use quote::{format_ident, quote};
fn next_node_ident(&mut self) -> (proc_macro2::Ident, usize) {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use std::{
fmt::{Display, Formatter},
hash::Hash,
rc::Rc,
};
fn register_rule(&mut self, rule: &Rule) -> Result<(), String> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
fn register_edge(&mut self, from: usize, to: usize) -> Result<(), String> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use std::{
fmt::{Display, Formatter},
hash::Hash,
rc::Rc,
};
fn register_node(&mut self, atom: Rc<Atom>) -> usize {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use syn::{parse::Parse, Token};
fn parse(input: syn::parse::ParseStream<'_>) -> syn::Result<Self> {
let lookahead = input.lookahead1();
if lookahead.peek(Token![crate]) {
input.parse::<Token![crate]>()?;
... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use std::{
fmt::{Display, Formatter},
hash::Hash,
rc::Rc,
};
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
fn to_string(&self, key: &str) -> String {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/tests/basic.rs | crate: masking
use masking::Secret;
use serde::Serialize;
fn for_string() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
{#[cfg_attr(all(feature = "alloc", feature = "serde"), derive(Serialize))]<|fim_suffix|>
<|fim_middle|>
Ok(())}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/tests/basic.rs | crate: masking
use masking::Secret;
use masking::ZeroizableSecret;
use serde::Serialize;
fn without_serialize() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
{#[cfg_attr(feature = "serde", derive(Serialize))]<|fim_suffix|>
<|fim_middle|>
Ok... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/tests/basic.rs | crate: masking
use masking::Secret;
use masking::SerializableSecret;
use masking::ZeroizableSecret;
use serde::Serialize;
fn basic() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/tests/basic.rs | crate: masking
use masking::Secret;
use masking::SerializableSecret;
use masking::ZeroizableSecret;
use serde::Serialize;
fn basic() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
{#[cfg_attr(feature = "serde", derive(Serialize))]#[derive(Cl... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/tests/basic.rs | crate: masking
fn zeroize(&mut self) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_value<V>(&mut self, value: &V) -> Result<(), Self:... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
fn serialize_struct(
self,
_name: &'static str,
len: usize,
) -> Result<Self::SerializeStruct, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn end(self) -> Result<Value, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_field<V>(&mut self, key: &'static str, value: &V) -> Result<(), S... | ast_fragments |
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn end(self) -> Result<Value, Self::Error> {
self.inner.end()
} | ast_fragments |
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_value<V>(&mut self, value: &V) -> Result<(), Self::Error>
... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
fn serialize_key<V>(&mut self, key: &V) -> Result<(), Self::Error>
where
V: ?Sized + Serialize,
{
<|fi... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn end(self) -> Result<Self::Ok, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_field<V>(&mut self, key: &'static str, value: &V) ... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_field<V>(&mut self, value: &V) -> Result<(), Self:... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_element<V>(&mut self, value: &V) -> Result<(), Sel... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
where
T: ?Sized + Display,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
fn serialize_struct_variant(
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str,
_len: usize,
) -> Result<Self::SerializeStructVariant, Self::Error> {
{... | ast_fragments |
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
fn serialize_struct(
self,
_name: &'static str,
len: usize,
) -> Result<Self::SerializeStruct, Self::Error> {
self.serialize_map(Some(len))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
fn serialize_tuple_variant(
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str,
len: usize,
) -> Result<Self::SerializeTupleVariant, Self::Error> {
{<|f... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
fn serialize_tuple_struct(
self,
_name: &'static str,
len: usize,
) -> Result<Self::SerializeTupleStruct, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_newtype_variant<T>(
self,
... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_newtype_struct<T>(
self,
_... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
fn serialize_unit_variant(
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str,
) -> Result<Self::Ok, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_char(self, value: char) -> Result<Self::Ok, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_f64(self, float: f64) -> Result<Self::Ok, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_f32(self, float: f32) -> Result<Self::Ok, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_u128(self, value: u128) -> Result<Self::Ok, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_u64(self, value: u64) -> Result<Self::Ok, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_u32(self, value: u32) -> Result<Self::Ok, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_u16(self, value: u16) -> Result<Self::Ok, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_u8(self, value: u8) -> Result<Self::Ok, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_i128(self, value: i128) -> Result<Self::Ok, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_i64(self, value: i64) -> Result<Self::Ok, Self::Error> {
self.inner.serialize_i64(value)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_i32(self, value: i32) -> Result<Self::Ok, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_i16(self, value: i16) -> Result<Self::Ok, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_i8(self, value: i8) -> Result<Self::Ok, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_bool(self, value: bool) -> Result<Self::Ok, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn clone(&self) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
use pii_serializer::PIISerializer;
pub(super) fn pii_serialize<... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn masked_serialize(&self) -> Result<Value, serde_json::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
use pii_serializer::PIISerializer;
/// Masked serialization.
//... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use serde::{de, Deserialize, Serialize, Serializer};
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: de::Deserializer<'de>,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/maskable.rs | crate: masking
/// Checks whether the data is normal (not masked).
/// Returns `true` if the data is wrapped in the `Normal` variant,
/// returns `false` otherwise.
pub fn is_normal(&self) -> bool {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/maskable.rs | crate: masking
use crate::{ExposeInterface, Secret};
/// Create a new Masked data
pub fn new_masked(item: Secret<T>) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/maskable.rs | crate: masking
fn from(value: &str) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/maskable.rs | crate: masking
fn into_masked(self) -> Maskable<Self::Output> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/masking/src/maskable.rs | crate: masking
/// Checks whether the data is normal (not masked).
/// Returns `true` if the data is wrapped in the `Normal` variant,
/// returns `false` otherwise.
pub fn is_normal(&self) -> bool {
matches!(self, Self::Normal(_))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/maskable.rs | crate: masking
/// Checks whether the data is masked.
/// Returns `true` if the data is wrapped in the `Masked` variant,
/// returns `false` otherwise.
pub fn is_masked(&self) -> bool {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/maskable.rs | crate: masking
/// Create a new non-masked data
pub fn new_normal(item: T) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/masking/src/maskable.rs | crate: masking
use crate::{ExposeInterface, Secret};
/// Create a new Masked data
pub fn new_masked(item: Secret<T>) -> Self {
Self::Masked(item)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/maskable.rs | crate: masking
/// Get the inner data while consuming self
pub fn into_inner(self) -> T {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/maskable.rs | crate: masking
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
{
Self::Masked(secret_value) => std::fmt::Debug::fmt(secret_value, f),<|fim_suffix|>
<|fim_middle|>
Self::Normal(value) => std::fmt::Debug::fmt(value, f),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/bytes.rs | crate: masking
use core::fmt;
use bytes::BytesMut;
use serde::de::{self, Deserialize};
use super::{PeekInterface, ZeroizableSecret};
fn deserialize<D: de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/bytes.rs | crate: masking
use bytes::BytesMut;
use serde::de::{self, Deserialize};
fn peek(&self) -> &BytesMut {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/bytes.rs | crate: masking
use bytes::BytesMut;
/// Wrap bytes in `SecretBytesMut`
pub fn new(bytes: impl Into<BytesMut>) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/bytes.rs | crate: masking
use core::fmt;
use bytes::BytesMut;
use serde::de::{self, Deserialize};
use super::{PeekInterface, ZeroizableSecret};
fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
where
V: de::SeqAccess<'de... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/bytes.rs | crate: masking
use bytes::BytesMut;
use serde::de::{self, Deserialize};
fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
where
E: de::Error,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/masking/src/bytes.rs | crate: masking
use core::fmt;
use serde::de::{self, Deserialize};
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("byte array")
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/bytes.rs | crate: masking
use bytes::BytesMut;
fn from(bytes: BytesMut) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/bytes.rs | crate: masking
use bytes::BytesMut;
use serde::de::{self, Deserialize};
fn peek_mut(&mut self) -> &mut BytesMut {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/masking/src/bytes.rs | crate: masking
use bytes::BytesMut;
use serde::de::{self, Deserialize};
fn peek(&self) -> &BytesMut {
&self.0
} | ast_fragments |
// file: hyperswitch/crates/masking/src/bytes.rs | crate: masking
use bytes::BytesMut;
/// Wrap bytes in `SecretBytesMut`
pub fn new(bytes: impl Into<BytesMut>) -> Self {
Self(bytes.into())
} | ast_fragments |
// file: hyperswitch/crates/analytics/src/core.rs | crate: analytics
use api_models::analytics::GetInfoResponse;
use crate::{types::AnalyticsDomain, utils};
pub async fn get_domain_info(
domain: AnalyticsDomain,
) -> crate::errors::AnalyticsResult<GetInfoResponse> {
let info = match domain {
AnalyticsDo... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/core.rs | crate: analytics
use api_models::analytics::GetInfoResponse;
use crate::{types::AnalyticsDomain, utils};
pub async fn get_domain_info(
domain: AnalyticsDomain,
) -> crate::errors::AnalyticsResult<GetInfoResponse> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/analytics/src/sqlx.rs | crate: analytics
use common_utils::{
errors::{CustomResult, ParsingError},
DbConnectionParams,
};
use error_stack::ResultExt;
use super::{
health_check::HealthCheck,
query::{Aggregate, ToSql, Window},
types::{
AnalyticsCollection, Analytics... | ast_fragments |
// file: hyperswitch/crates/analytics/src/sqlx.rs | crate: analytics
use common_utils::{
errors::{CustomResult, ParsingError},
DbConnectionParams,
};
use error_stack::ResultExt;
use super::{
health_check::HealthCheck,
query::{Aggregate, ToSql, Window},
types::{
AnalyticsCollection, Analytics... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/sqlx.rs | crate: analytics
use api_models::{
analytics::{frm::FrmTransactionType, refunds::RefundType},
enums::{DisputeStage, DisputeStatus},
};
use diesel_models::enums::{
AttemptStatus, AuthenticationType, Currency, FraudCheckStatus, IntentStatus, P... | ast_fragments |
// file: hyperswitch/crates/analytics/src/sqlx.rs | crate: analytics
use api_models::{
analytics::{frm::FrmTransactionType, refunds::RefundType},
enums::{DisputeStage, DisputeStatus},
};
use diesel_models::enums::{
AttemptStatus, AuthenticationType, Currency, FraudCheckStatus, IntentStatus, PaymentMethod,
... | ast_fragments |
// file: hyperswitch/crates/analytics/src/sqlx.rs | crate: analytics
use common_enums::{
AuthenticationConnectors, AuthenticationStatus, DecoupledAuthenticationType, TransactionStatus,
};
use sqlx::{
postgres::{PgArgumentBuffer, PgPoolOptions, PgRow, PgTypeInfo, PgValueRef},
Decode, Encode,
Error::Colum... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/sqlx.rs | crate: analytics
use common_utils::{
errors::{CustomResult, ParsingError},
DbConnectionParams,
};
use error_stack::ResultExt;
use super::{
health_check::HealthCheck,
query::{Aggregate, ToSql, Window},
types::{
AnalyticsCollec... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/sqlx.rs | crate: analytics
e => Err(e),
})?;
Ok(Self {
dispute_stage,
dispute_status,
connector,
connector_status,
currency,
})
}
}
impl<'a> FromRow<'a, Pg... | ast_fragments |
// file: hyperswitch/crates/analytics/src/sqlx.rs | crate: analytics
use api_models::{
analytics::{frm::FrmTransactionType, refunds::RefundType},
enums::{DisputeStage, DisputeStatus},
};
use diesel_models::enums::{
AttemptStatus, AuthenticationType, Currency, FraudCheckStatus, IntentStatus, PaymentMethod,
... | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/sqlx.rs | crate: analytics
use common_utils::{
errors::{CustomResult, ParsingError},
DbConnectionParams,
};
use sqlx::{
postgres::{PgArgumentBuffer, PgPoolOptions, PgRow, PgTypeInfo, PgValueRef},
Decode, Encode,
Error::ColumnNotFound,
From... | ast_fragments |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.