Перечисление Ipv6MulticastScope

#![allow(unused)]
fn main() {
#[non_exhaustive]
pub enum Ipv6MulticastScope {
    InterfaceLocal,
    LinkLocal,
    RealmLocal,
    AdminLocal,
    SiteLocal,
    OrganizationLocal,
    Global,
}
}

🔬 Это экспериментальное API, доступное только в ночных сборках. (ip #27709)

Область действия IPv6 многоадресного адреса, как определено в IETF RFC 7346, раздел 2.

Гарантии стабильности

Не все возможные значения для многоадресной области были назначены. Будущие RFC могут вводить новые области, которые будут добавлены как варианты в это перечисление; из-за этого перечисление помечено как #[non_exhaustive].

Примеры

#![allow(unused)]
#![feature(ip)]

fn main() {
use std::net::Ipv6Addr;
use std::net::Ipv6MulticastScope::*;

// IPv6 многоадресный адрес с глобальной областью действия (`ff0e::`).
let address = Ipv6Addr::new(0xff0e, 0, 0, 0, 0, 0, 0, 0);

// Напечатает "Global scope".
match address.multicast_scope() {
    Some(InterfaceLocal) => println!("Interface-Local scope"),
    Some(LinkLocal) => println!("Link-Local scope"),
    Some(RealmLocal) => println!("Realm-Local scope"),
    Some(AdminLocal) => println!("Admin-Local scope"),
    Some(SiteLocal) => println!("Site-Local scope"),
    Some(OrganizationLocal) => println!("Organization-Local scope"),
    Some(Global) => println!("Global scope"),
    Some(_) => println!("Unknown scope"),
    None => println!("Not a multicast address!")
}
}

Варианты (Не исчерпывающие)

Это перечисление помечено как не исчерпывающее

InterfaceLocal

#![allow(unused)]
fn main() {
InterfaceLocal
}

🔬 Это экспериментальное API, доступное только в ночных сборках. (ip #27709)

Область действия в пределах интерфейса.

LinkLocal

#![allow(unused)]
fn main() {
LinkLocal
}

🔬 Это экспериментальное API, доступное только в ночных сборках. (ip #27709)

Область действия в пределах канала (link).

RealmLocal

#![allow(unused)]
fn main() {
RealmLocal
}

🔬 Это экспериментальное API, доступное только в ночных сборках. (ip #27709)

Область действия в пределах REALM.

AdminLocal

#![allow(unused)]
fn main() {
AdminLocal
}

🔬 Это экспериментальное API, доступное только в ночных сборках. (ip #27709)

Административно-локальная область действия.

SiteLocal

#![allow(unused)]
fn main() {
SiteLocal
}

🔬 Это экспериментальное API, доступное только в ночных сборках. (ip #27709)

Область действия в пределах сайта.

OrganizationLocal

#![allow(unused)]
fn main() {
OrganizationLocal
}

🔬 Это экспериментальное API, доступное только в ночных сборках. (ip #27709)

Область действия в пределах организации.

Global

#![allow(unused)]
fn main() {
Global
}

🔬 Это экспериментальное API, доступное только в ночных сборках. (ip #27709)

Глобальная область действия.

Трайт-реализации

Clone для Ipv6MulticastScope

#![allow(unused)]
fn main() {
impl Clone for Ipv6MulticastScope
}

clone

#![allow(unused)]
fn main() {
fn clone(&self) -> Ipv6MulticastScope
}

Возвращает дубликат значения. Подробнее

clone_from

#![allow(unused)]
fn main() {
fn clone_from(&mut self, source: &Self)
}

Выполняет присваивание копированием из источника. Подробнее

Debug для Ipv6MulticastScope

#![allow(unused)]
fn main() {
impl Debug for Ipv6MulticastScope
}

fmt

#![allow(unused)]
fn main() {
fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
}

Форматирует значение с помощью заданного форматировщика. Подробнее

Hash для Ipv6MulticastScope

#![allow(unused)]
fn main() {
impl Hash for Ipv6MulticastScope
}

hash

#![allow(unused)]
fn main() {
fn hash<__H>(&self, state: &mut __H)
where
    __H: Hasher,
}

Подает это значение в заданный Hasher. Подробнее

hash_slice

#![allow(unused)]
fn main() {
fn hash_slice<H>(data: &[Self], state: &mut H)
where
    H: Hasher,
    Self: Sized,
}

Подает срез этого типа в заданный Hasher. Подробнее

PartialEq для Ipv6MulticastScope

#![allow(unused)]
fn main() {
impl PartialEq for Ipv6MulticastScope
}

eq

#![allow(unused)]
fn main() {
fn eq(&self, other: &Ipv6MulticastScope) -> bool
}

Проверяет равенство значений self и other, используется оператором ==.

ne

#![allow(unused)]
fn main() {
fn ne(&self, other: &Rhs) -> bool
}

Проверяет неравенство (!=). Реализация по умолчанию почти всегда достаточна и не должна переопределяться без очень веской причины.

Copy для Ipv6MulticastScope

#![allow(unused)]
fn main() {
impl Copy for Ipv6MulticastScope
}

Eq для Ipv6MulticastScope

#![allow(unused)]
fn main() {
impl Eq for Ipv6MulticastScope
}

StructuralPartialEq для Ipv6MulticastScope

#![allow(unused)]
fn main() {
impl StructuralPartialEq for Ipv6MulticastScope
}

Автоматические реализации трейтов

#![allow(unused)]
fn main() {
impl Freeze for Ipv6MulticastScope
impl RefUnwindSafe for Ipv6MulticastScope
impl Send for Ipv6MulticastScope
impl Sync for Ipv6MulticastScope
impl Unpin for Ipv6MulticastScope
impl UnwindSafe for Ipv6MulticastScope
}

Стандартные реализации

#![allow(unused)]
fn main() {
impl<T> Any for T
where
    T: 'static + ?Sized,

impl<T> Borrow<T> for T
where
    T: ?Sized,

impl<T> BorrowMut<T> for T
where
    T: ?Sized,

impl<T> CloneToUninit for T
where
    T: Clone,

impl<T> From<T> for T

impl<T, U> Into<U> for T
where
    U: From<T>,

impl<T> ToOwned for T
where
    T: Clone,

impl<T, U> TryFrom<U> for T
where
    U: Into<T>,

impl<T, U> TryInto<U> for T
where
    U: TryFrom<T>,
}

Примеры использования

Анализ многоадресных областей IPv6

#![feature(ip)]

use std::net::{Ipv6Addr, Ipv6MulticastScope};

fn analyze_multicast_addresses() {
    let multicast_addresses = [
        // Различные многоадресные адреса с разными областями
        Ipv6Addr::new(0xff01, 0, 0, 0, 0, 0, 0, 0x1),  // Interface-Local
        Ipv6Addr::new(0xff02, 0, 0, 0, 0, 0, 0, 0x1),  // Link-Local
        Ipv6Addr::new(0xff03, 0, 0, 0, 0, 0, 0, 0x1),  // Realm-Local
        Ipv6Addr::new(0xff04, 0, 0, 0, 0, 0, 0, 0x1),  // Admin-Local
        Ipv6Addr::new(0xff05, 0, 0, 0, 0, 0, 0, 0x1),  // Site-Local
        Ipv6Addr::new(0xff08, 0, 0, 0, 0, 0, 0, 0x1),  // Organization-Local
        Ipv6Addr::new(0xff0e, 0, 0, 0, 0, 0, 0, 0x1),  // Global
    ];
    
    println!("Анализ IPv6 многоадресных областей:");
    
    for addr in &multicast_addresses {
        print!("Адрес: {:39} -> ", addr);
        
        match addr.multicast_scope() {
            Some(Ipv6MulticastScope::InterfaceLocal) => {
                println!("Interface-Local (в пределах интерфейса)");
            }
            Some(Ipv6MulticastScope::LinkLocal) => {
                println!("Link-Local (в пределах канала)");
            }
            Some(Ipv6MulticastScope::RealmLocal) => {
                println!("Realm-Local (в пределах REALM)");
            }
            Some(Ipv6MulticastScope::AdminLocal) => {
                println!("Admin-Local (административно-локальная)");
            }
            Some(Ipv6MulticastScope::SiteLocal) => {
                println!("Site-Local (в пределах сайта)");
            }
            Some(Ipv6MulticastScope::OrganizationLocal) => {
                println!("Organization-Local (в пределах организации)");
            }
            Some(Ipv6MulticastScope::Global) => {
                println!("Global (глобальная)");
            }
            Some(_) => {
                println!("Неизвестная область");
            }
            None => {
                println!("Не многоадресный адрес");
            }
        }
    }
}

fn main() {
    analyze_multicast_addresses();
}

Использование в сетевых приложениях

#![feature(ip)]

use std::net::{Ipv6Addr, Ipv6MulticastScope};
use std::collections::HashMap;

struct MulticastManager {
    scopes: HashMap<Ipv6MulticastScope, Vec<Ipv6Addr>>,
}

impl MulticastManager {
    fn new() -> Self {
        Self {
            scopes: HashMap::new(),
        }
    }
    
    fn add_multicast_address(&mut self, addr: Ipv6Addr) {
        if let Some(scope) = addr.multicast_scope() {
            self.scopes.entry(scope).or_insert_with(Vec::new).push(addr);
        }
    }
    
    fn print_scopes(&self) {
        println!("Многоадресные адреса по областям:");
        
        for (scope, addresses) in &self.scopes {
            let scope_name = match scope {
                Ipv6MulticastScope::InterfaceLocal => "Interface-Local",
                Ipv6MulticastScope::LinkLocal => "Link-Local",
                Ipv6MulticastScope::RealmLocal => "Realm-Local",
                Ipv6MulticastScope::AdminLocal => "Admin-Local",
                Ipv6MulticastScope::SiteLocal => "Site-Local",
                Ipv6MulticastScope::OrganizationLocal => "Organization-Local",
                Ipv6MulticastScope::Global => "Global",
            };
            
            println!("  {} ({} адресов):", scope_name, addresses.len());
            for addr in addresses {
                println!("    - {}", addr);
            }
        }
    }
    
    fn get_addresses_by_scope(&self, scope: Ipv6MulticastScope) -> &[Ipv6Addr] {
        self.scopes.get(&scope).map(|v| v.as_slice()).unwrap_or(&[])
    }
}

fn main() {
    let mut manager = MulticastManager::new();
    
    // Добавляем различные многоадресные адреса
    let multicast_addrs = [
        Ipv6Addr::new(0xff01, 0, 0, 0, 0, 0, 0, 0x1),  // all-nodes interface-local
        Ipv6Addr::new(0xff02, 0, 0, 0, 0, 0, 0, 0x1),  // all-nodes link-local
        Ipv6Addr::new(0xff02, 0, 0, 0, 0, 0, 0, 0x2),  // all-routers link-local
        Ipv6Addr::new(0xff05, 0, 0, 0, 0, 0, 0, 0x1),  // all-nodes site-local
        Ipv6Addr::new(0xff0e, 0, 0, 0, 0, 0, 0, 0x1),  // global multicast
    ];
    
    for addr in &multicast_addrs {
        manager.add_multicast_address(*addr);
    }
    
    manager.print_scopes();
    
    // Получаем адреса для конкретной области
    println!("\nLink-Local адреса:");
    for addr in manager.get_addresses_by_scope(Ipv6MulticastScope::LinkLocal) {
        println!("  - {}", addr);
    }
}

Сравнение и хеширование областей

#![feature(ip)]

use std::net::Ipv6MulticastScope;
use std::collections::HashSet;

fn demonstrate_comparison_and_hashing() {
    let scopes = [
        Ipv6MulticastScope::InterfaceLocal,
        Ipv6MulticastScope::LinkLocal,
        Ipv6MulticastScope::RealmLocal,
        Ipv6MulticastScope::AdminLocal,
        Ipv6MulticastScope::SiteLocal,
        Ipv6MulticastScope::OrganizationLocal,
        Ipv6MulticastScope::Global,
        Ipv6MulticastScope::LinkLocal, // Дубликат
    ];
    
    println!("Демонстрация сравнения и хеширования:");
    
    // Использование в HashSet (автоматически удаляет дубликаты)
    let unique_scopes: HashSet<_> = scopes.iter().collect();
    println!("Уникальные области в HashSet: {}", unique_scopes.len());
    
    for scope in &unique_scopes {
        println!("  - {:?}", scope);
    }
    
    // Сравнение областей
    println!("\nСравнение областей:");
    let scope1 = Ipv6MulticastScope::LinkLocal;
    let scope2 = Ipv6MulticastScope::LinkLocal;
    let scope3 = Ipv6MulticastScope::Global;
    
    println!("  scope1 == scope2: {}", scope1 == scope2);
    println!("  scope1 == scope3: {}", scope1 == scope3);
    println!("  scope1 != scope3: {}", scope1 != scope3);
    
    // Клонирование и копирование
    println!("\nКлонирование и копирование:");
    let original = Ipv6MulticastScope::SiteLocal;
    let cloned = original.clone();
    let copied = original;
    
    println!("  original: {:?}", original);
    println!("  cloned: {:?}", cloned);
    println!("  copied: {:?}", copied);
    println!("  original == cloned: {}", original == cloned);
    println!("  original == copied: {}", original == copied);
}

fn main() {
    demonstrate_comparison_and_hashing();
}

Области многоадресной рассылки IPv6

Области многоадресной рассылки определяют, как далеко могут распространяться многоадресные пакеты:

• Interface-Local: В пределах одного сетевого интерфейса
• Link-Local: В пределах одного сетевого сегмента (link)
• Realm-Local: В пределах REALM (определяется спецификацией)
• Admin-Local: Административно ограниченная область
• Site-Local: В пределах одного сайта или здания
• Organization-Local: В пределах одной организации
• Global: Глобальная область действия (вся сеть Интернет)

Особенности использования

Не исчерпывающее перечисление

Перечисление помечено как #[non_exhaustive], что означает, что в будущем могут быть добавлены новые варианты. Это требует от пользователей обрабатывать возможные неизвестные варианты при использовании сопоставления с образцом.

Экспериментальный статус

Это API является экспериментальным и доступно только в ночных сборках Rust. Для использования необходимо включить функцию #![feature(ip)].