geosite-rs 0.1.4

use std::collections::HashMap;

use prost::Message;

/// parse dat data (which has protobuf format)
pub fn decode_geosite(buf: &[u8]) -> Result<SiteGroupList, prost::DecodeError> {
    SiteGroupList::decode(buf)
}

/// save to the dat format (which has protobuf format)
pub fn encode_geosite(sg: SiteGroupList) -> Vec<u8> {
    sg.encode_to_vec()
}
///
/// parse dat data (which has protobuf format)
pub fn decode_geoip(buf: &[u8]) -> Result<GeoIpList, prost::DecodeError> {
    GeoIpList::decode(buf)
}

/// save to the dat format (which has protobuf format)
pub fn encode_geoip(sg: GeoIpList) -> Vec<u8> {
    sg.encode_to_vec()
}

/// covert to a hashmap that is compatible with the one in crate 'clash_rules'
///
/// key is "DOMAIN-KEYWORD","DOMAIN-SUFFIX","DOMAIN","DOMAIN-REGEX".
pub fn to_hashmap(site_group_list: &SiteGroupList) -> HashMap<String, Vec<Vec<String>>> {
    let mut map: HashMap<String, Vec<Vec<String>>> = HashMap::new();

    for group in &site_group_list.site_group {
        for domain in &group.domain {
            let key = match domain.r#type {
                0 => "DOMAIN-KEYWORD", // Plain
                1 => "DOMAIN-SUFFIX",  // Domain
                2 => "DOMAIN",         // Full
                3 => "DOMAIN-REGEX",   // Regex
                _ => continue,         // 跳过未知类型
            };

            let v = vec![domain.value.clone(), group.tag.clone()];
            map.entry(key.to_string()).or_default().push(v);
        }
    }

    map
}
//include!(concat!(env!("OUT_DIR"), "/_.rs"));
//
// This file is @generated by prost-build.
/// Domain for routing decision.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Domain {
    /// Domain matching type.
    #[prost(enumeration = "domain::Type", tag = "1")]
    pub r#type: i32,
    /// Domain value.
    #[prost(string, tag = "2")]
    pub value: ::prost::alloc::string::String,
    /// Attributes of this domain. May be used for filtering.
    #[prost(message, repeated, tag = "3")]
    pub attribute: ::prost::alloc::vec::Vec<domain::Attribute>,
}
/// Nested message and enum types in `Domain`.
pub mod domain {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Attribute {
        #[prost(string, tag = "1")]
        pub key: ::prost::alloc::string::String,
        #[prost(oneof = "attribute::TypedValue", tags = "2, 3")]
        pub typed_value: ::core::option::Option<attribute::TypedValue>,
    }
    /// Nested message and enum types in `Attribute`.
    pub mod attribute {
        #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
        pub enum TypedValue {
            #[prost(bool, tag = "2")]
            BoolValue(bool),
            #[prost(int64, tag = "3")]
            IntValue(i64),
        }
    }
    /// Type of domain value.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum Type {
        /// The value is used as is.
        Plain = 0,
        /// The value is used as a regular expression.
        Regex = 1,
        /// The value is a root domain.
        Domain = 2,
        /// The value is a domain.
        Full = 3,
    }
    impl Type {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Plain => "Plain",
                Self::Regex => "Regex",
                Self::Domain => "Domain",
                Self::Full => "Full",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "Plain" => Some(Self::Plain),
                "Regex" => Some(Self::Regex),
                "Domain" => Some(Self::Domain),
                "Full" => Some(Self::Full),
                _ => None,
            }
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SiteGroup {
    #[prost(string, tag = "1")]
    pub tag: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "2")]
    pub domain: ::prost::alloc::vec::Vec<Domain>,
}

/// the final dat file has this type
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SiteGroupList {
    #[prost(message, repeated, tag = "1")]
    pub site_group: ::prost::alloc::vec::Vec<SiteGroup>,
}
/// IP for routing decision, in CIDR form.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Cidr {
    /// IP address, should be either 4 or 16 bytes.
    #[prost(bytes = "vec", tag = "1")]
    pub ip: ::prost::alloc::vec::Vec<u8>,
    /// Number of leading ones in the network mask.
    #[prost(uint32, tag = "2")]
    pub prefix: u32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GeoIp {
    #[prost(string, tag = "1")]
    pub country_code: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "2")]
    pub cidr: ::prost::alloc::vec::Vec<Cidr>,
    #[prost(bool, tag = "3")]
    pub reverse_match: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GeoIpList {
    #[prost(message, repeated, tag = "1")]
    pub entry: ::prost::alloc::vec::Vec<GeoIp>,
}