El libro blanco de EOS dice que quiere construir un sistema distribuido similar a un sistema operativo. Y nuestro contrato es como un software que se ejecuta en el sistema operativo. Entonces, ¿cuál es el
elemento de tiempo más comúnmente utilizado cuando escribimos programas ?
Mire time.hpp en eosiolib.
Consigue tiempo
Necesita mirar el archivo "system.h" antes de mirar time.hpp. En este archivo se definen dos funciones para obtener el tiempo:
uint64_t current_time();
/**
* Returns the time in seconds from 1970 of the block including this action
* @brief Get time (rounded down to the nearest second) of the current block (i.e. the block including this action)
* @return time in seconds from 1970 of the current block
*/
uint32_t now() {
return (uint32_t)( current_time() / 1000000 );
}
Se utiliza para obtener la marca de tiempo actual (el tiempo en el pasado desde la época Unix de 1970 hasta el presente). La unidad del primero es milisegundos y la unidad del segundo es segundos.
Representación de la unidad de tiempo
El tiempo obtenido anteriormente está representado por uint64 y uint32. Si ha leído el artículo sobre el punto flotante y las unidades monetarias discutido anteriormente, naturalmente pensará que se necesita una cantidad unificada para representar el tiempo; de lo contrario
, cambiará al calcular el tiempo. muy complicado. En el sistema EOS, time_point se usa para indicar milisegundos y time_point_sec se usa para indicar segundos.
microsegundos
Primero mira una definición:
class microseconds {
int64_t _count;
EOSLIB_SERIALIZE( microseconds, (_count) )
}
El milisegundo es en realidad un int64. Es solo que este int64 se ha sobrecargado con n operadores para realizar su cálculo de tiempo, no hay diferencia entre el operador sobrecargado y el propio int64. La única adición es la conversión a segundos:
int64_t to_seconds()const { return _count/1000000; }
punto de tiempo
Clase convencional:
class time_point {
microseconds elapsed;
EOSLIB_SERIALIZE( time_point, (elapsed) )
};
Puede considerarse como una redefinición de milisegundos. Si se usan milisegundos en contratos EOS, generalmente se usa esta clase, que es esencialmente un int64. Pero más que microsegundos:
const microseconds& time_since_epoch()const { return elapsed; }
uint32_t sec_since_epoch()const { return uint32_t(elapsed.count() / 1000000); }
Para obtener la unidad de época mencionada anteriormente.
Además, hay una herramienta para convertir el tiempo de cadenas estándar:
operator std::string()const;
static time_point from_iso_string( const std::string& s );
Un formato de cadena de tiempo unificado se especifica en la norma ISO-8601 . similar:
"2009-W01-1"
2007-03-01T13:00:00Z/2008-05-11T15:30:00Z
P1Y2M10DT2H30M/2008-05-11T15:30:00Z
Espere, a menudo vemos "2018-08-21T11: 31: 36.000" en Block. Entonces, si necesita pasar el tiempo en el comando cloes, generalmente se usa este formato.
time_point_sec
También se puede deducir del significado literal: time_point_sec es la estructura de time_point que representa segundos:
class time_point_sec
{
uint32_t utc_seconds;
EOSLIB_SERIALIZE( time_point_sec, (utc_seconds) )
}；
Operación
Además de las definiciones anteriores, estos dos time_points definen principalmente las operaciones aritméticas entre sí. Por lo tanto, no necesitamos ir manualmente a * 1000 o / 1000.
//time_point
time_point& operator += ( const microseconds& m) { elapsed+=m; return *this; }
time_point& operator -= ( const microseconds& m) { elapsed-=m; return *this; }
time_point operator + (const microseconds& m) const { return time_point(elapsed+m); }
time_point operator + (const time_point& m) const { return time_point(elapsed+m.elapsed); }
time_point operator - (const microseconds& m) const { return time_point(elapsed-m); }
microseconds operator - (const time_point& m) const { return microseconds(elapsed.count() - m.elapsed.count()); }
//time_point_sec
friend time_point operator + ( const time_point_sec& t, const microseconds& m ) { return time_point(t) + m; }
friend time_point operator - ( const time_point_sec& t, const microseconds& m ) { return time_point(t) - m; }
friend microseconds operator - ( const time_point_sec& t, const time_point_sec& m ) { return time_point(t) - time_point(m); }
friend microseconds operator - ( const time_point& t, const time_point_sec& m ) { return time_point(t) - time_point(m); }
La conversión entre las dos funciones en el tipo de suma realiza la operación de suma y resta entre los tres tipos de datos.
block_timestamp
Excepto por el tiempo anterior. Sabemos que hay un momento en el que se consulta la información del bloque, porque el bloque se genera en 500ms, por lo que el idx del bloque también representa el tiempo. Por tanto, el tiempo de bloqueo se define:
class block_timestamp {
public:
uint32_t slot;
static constexpr int32_t block_interval_ms = 500;
static constexpr int64_t block_timestamp_epoch = 946684800000ll; // epoch is year 2000
EOSLIB_SERIALIZE( block_timestamp, (slot) )
}
De hecho, es el número actual de bloques basado en el tiempo de época de Unix.
Combate real:
Comparación de tiempo
uint64_t starttime = "unit时间戳";
eosio::time_point_sec(starttime) > eosio::time_point_sec(now();Suma y resta de tiempo
uint64_t starttime = "unit时间戳";
#结果单位为秒
uint64_t t= (eosio::time_point_sec(starttime)-eosio::time_point_sec(now())).to_seconds();