#Chrono: Libreria di Data e Ora per Rust

Chrono mira a fornire tutte le funzionalità necessarie per manipolare correttamente date e orari nel calendario gregoriano:

• Il tipo DateTime è consapevole del fuso orario per impostazione predefinita, pur offrendo tipi indipendenti dal fuso.
• Operazioni che potrebbero generare date o orari non validi o ambigui restituiscono Option o MappedLocalTime.
• Parsing e formattazione configurabili, con una sintassi ispirata a strftime.
• Il fuso orario Local funziona con quello attuale del sistema operativo.
• Tipi e operazioni sono implementati con un'attenzione ragionevole all'efficienza.
• Per limitare le dimensioni del binario, Chrono non include dati sui fusi orari per default. Utilizza le crate Chrono-TZ o tzfile per supporto completo.

#Caratteristiche

Chrono supporta vari ambienti runtime e sistemi operativi, con diverse funzionalità attivabili o disattivabili.

#Funzionalità predefinite:

• alloc: Abilita funzioni che richiedono allocazione di memoria (principalmente formattazione di stringhe).
• std: Abilita funzioni dipendenti dalla libreria standard. Sovrainsieme di alloc, aggiunge interoperabilità con tipi e tratti standard.
• clock: Abilita la lettura del fuso orario locale (Local). Sovrainsieme di now.
• now: Abilita la lettura dell'orario di sistema (now).
• wasmbind: Fornisce un'interfaccia con l'API JS Date per target wasm32.

#Funzionalità opzionali:

• serde: Abilita serializzazione/deserializzazione via serde.
• rkyv: Deprecato, usa le funzionalità rkyv-*.
• rkyv-16, rkyv-32, rkyv-64: Abilita serializzazione/deserializzazione via rkyv, con interi a 16, 32 o 64 bit rispettivamente.
• rkyv-validation: Abilita supporto alla validazione rkyv con bytecheck.
• arbitrary: Costruisce istanze arbitrarie di tipi con la crate Arbitrary.
• unstable-locales: Abilita localizzazione. Aggiunge metodi con suffisso _localized.

#Panoramica

#Differenza temporale/Durata

Chrono fornisce il tipo TimeDelta per rappresentare intervalli temporali. È una durata "precisa" in secondi e nanosecondi, senza componenti "nominali" come giorni o mesi.

Precedentemente chiamato Duration (ancora disponibile come alias), si distingue da core::time::Duration per essere con segno anziché senza.

#Date e Orari

Chrono offre il tipo DateTime per rappresentare date e orari con fuso orario.

DateTime è consapevole del fuso e deve essere costruito da un oggetto TimeZone, che definisce la conversione da/verso UTC. Tre implementazioni note:

• Utc: Specifica il fuso UTC. Il più efficiente.
• Local: Specifica il fuso locale del sistema.
• FixedOffset: Specifica un fuso fisso arbitrario, come UTC+09:00 o UTC-10:30.

DateTime con diversi TimeZone sono tipi distinti, ma convertibili tramite DateTime::with_timezone.

Puoi ottenere la data e l'ora corrente in UTC (Utc::now()) o locale (Local::now()).

use chrono::prelude::*;

let utc: DateTime<Utc> = Utc::now(); // Es. `2014-11-28T12:45:59.324310806Z`
let local: DateTime<Local> = Local::now(); // Es. `2014-11-28T21:45:59.324310806+09:00`

Inoltre, puoi creare date e orari personalizzati:

use chrono::offset::MappedLocalTime;
use chrono::prelude::*;

let dt = Utc.with_ymd_and_hms(2014, 7, 8, 9, 10, 11).unwrap(); // `2014-07-08T09:10:11Z`

#Formattazione e Parsing

La formattazione avviene tramite il metodo format, con sintassi simile a strftime.

Anche to_string e {:?} forniscono rappresentazioni leggibili. Chrono include anche to_rfc2822 e to_rfc3339 per formati comuni.

Ora Chrono supporta la formattazione localizzata in quasi tutte le lingue senza librerie C aggiuntive (funzionalità unstable-locales):

use chrono::prelude::*;

let dt = Utc.with_ymd_and_hms(2014, 11, 28, 12, 0, 9).unwrap();
assert_eq!(dt.format("%Y-%m-%d %H:%M:%S").to_string(), "2014-11-28 12:00:09");
assert_eq!(dt.format_localized("%A %e %B %Y, %T", Locale::fr_BE).to_string(), 
           "vendredi 28 novembre 2014, 12:00:09");

Il parsing può avvenire in due modi:

1. Il tratto standard FromStr (e il metodo parse sulle stringhe) può analizzare DateTime<FixedOffset>, DateTime<Utc> e DateTime<Local>.
2. DateTime::parse_from_str analizza data e ora con offset, restituendo DateTime<FixedOffset>.

use chrono::prelude::*;

let dt = "2014-11-28T12:00:09Z".parse::<DateTime<Utc>>().unwrap();
let fixed_dt = DateTime::parse_from_str("2014-11-28 21:00:09 +09:00", "%Y-%m-%d %H:%M:%S %z").unwrap();

#Conversione con timestamp EPOCH

Usa DateTime::from_timestamp(secondi, nanosecondi) per costruire DateTime<Utc> da un timestamp UNIX.

Usa DateTime.timestamp per ottenere il timestamp (in secondi) da un DateTime. Inoltre, DateTime.timestamp_subsec_nanos fornisce i nanosecondi aggiuntivi.

use chrono::{DateTime, Utc};

// Costruisci datetime dall'epoch:
let dt: DateTime<Utc> = DateTime::from_timestamp(1_500_000_000, 0).unwrap();
assert_eq!(dt.to_rfc2822(), "Fri, 14 Jul 2017 02:40:00 +0000");

// Ottieni valore epoch da datetime:
let dt = DateTime::parse_from_rfc2822("Fri, 14 Jul 2017 02:40:00 +0000").unwrap();
assert_eq!(dt.timestamp(), 1_500_000_000);

#Limitazioni

• Supporta solo il calendario gregoriano prolettico (esteso per date precedenti).
• I tipi data sono limitati a circa ±262.000 anni dall'era comune.
• I tipi ora hanno precisione al nanosecondo.
• Supporta i secondi intercalari, ma non completamente.