% document

%\begin{comment}

\maketitle

%\include{./agradecimentos} %% opcional

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% RESUMO %% obrigatório
\begin{resumo} %% insira seu resumo abaixo
\hypertarget{estilo:resumo}{}
 
% Nota de autor

Este documento reflete o resultado de um longo processo de amadurecimento de uma proposta de definição de um sistema de identificação de itens de informação.

A idéia original, concebida em 1995, procura aproveitar a própria infra-estrutura já existente, oferecida pela Internet.
 
Desde a sua concepção, a realização dessa idéia foi sendo, aos poucos, aperfeiçoada. Deste processo todo, resultou esta proposta, que já se encontra amplamente testada numa plataforma computacional chamada de UR\textsl{Lib}. A plataforma UR\textsl{Lib} é aquela adotada pelo INPE para hospedar sua Memória Científica.

Vale mencionar que, embora esta idéia tenha sido primariamente concebida para identificar itens de informação, no caso, sob um caráter normalizado, o sistema de identificação a ela associado, tal como definido neste documento, pode vir a ser também utilizado para identificar qualquer outro item ou objeto, portanto, também de forma normalizada, em princípio.

O documento original que deu origem a esta Norma que está sendo recomendada possui o título: ``Identificador com base na Internet (IBI): Sistema de identificação''. Ele foi publicado pelo INPE na forma de relatório de pesquisa, sob o código de identificação: iconet.com.br/banon/2009/09.09.22.01-RPQ. Ele está acessível a partir de apontamento no endereço URL: <http://urlib.net/LK47B6W/362SFKH>.

Essa segunda edição contém pequenas melhorias do texto em relação a primeira edição de 2011 acessível a partir de apontamento no endereço URL: <http://urlib.net/8JMKD3MGP8W/3CLC37B>.
	
\copyright\ CE 08:010.70/ABNT, INPE/MCT, São José dos Campos, SP, Brasil - Agosto de 2011. 

  \end{resumo}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% ABSTRACT %% obrigatório
\begin{abstract} %% insira abaixo seu abstract
\selectlanguage{english}	%% para os documentos em Português com abstract.tex em Inglês
\hypertarget{estilo:abstract}{}
 
This standard presents a procedure that leads to the creation of two versions of a global identifier, which is intended, in a long term, to consistently and compactly identify and to provide a convenient access to various kinds of information items (documents, maps, images, etc.), which are typically stored in collections, as found in digital repositories, in archives, or elsewhere. The practical deployment of this global identifier conveniently and essentially solely requires, at no additional cost, the widely, already available infrastructure of the Internet. This global identifier can be used in combination with information storage systems, which deal with collections and which, in this way, may enable remarkable simplicity in the processes dedicated to the creation of copies in different collections, also including simplicity in the migration of information items among such collections. In particular, a variety of convenient applications of a global identifier of this nature in space data and information systems are envisioned.

\selectlanguage{portuguese}	%% para os documentos em Português com abstract.tex em Inglês
\end{abstract}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\includeListaFiguras %% obrigatório caso haja mais de 3 figuras, gerado automaticamente
\includeListaTabelas %% obrigatório caso haja mais de 3 tabelas, gerado automaticamente

\includeSumario  %% obrigatório, gerado automaticamente

%\include{./docs/abreviaturasesiglas} %% opcional, mas recomendado com mais de três%% para tese ou dissertação atualize o arquivo siglaseabreviaturas.tex e tire o comentário desta linha
%\include{./docs/simbolos} %% opcional, mas recomendado com mais de três%% para tese ou dissertação atualize o arquivo simbolos.tex e tire o comentário desta linha

%\end{comment}

\inicioIntroducao %% não altere este comando

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% O corpo do texto começo aqui
\hypertarget{estilo:capitulo}{} %% uso para este manual

\chapter{Introdução}
\label{chap:introducao}

Esta norma apresenta duas formas em que um identificador global pode ser criado para identificar e prover acesso consistente e perene a diversos tipos de itens de informação (documentos, mapas, imagens, etc.) armazenados em acervos como os encontrados em repositórios digitais, em arquivos, ou em outras entidades de informação.

A implantação desse identificador global requer, de uma forma indireta, a infra-estrutura já existente e facilmente disponível da Internet. Portanto, sem custo adicional, quanto a este aspecto.
 
Esse identificador global pode ser utilizado em associação com o processo de armazenamento de informação em acervos. O que também torna simples a criação de cópias em acervos distintos, incluindo a própria migração de itens de informação entre tais acervos.
 
As diversas aplicações de um identificador global desta natureza são também de particular interesse para uso em sistemas de dados espaciais e de informação.

\chapter{Escopo}

Esta norma descreve e permite criar um sistema de identificação com base na Internet que associa a cada item de informação a ser identificado, um rótulo que pode ser utilizado como identificador desse item. As regras para a construção de duas formas de apresentação do mencionado rótulo são também apresentadas neste documento.

\chapter{Justificativa}

Parte-se do princípio que os hipervínculos (\textsl{hyperlinks}) ou simplesmente vínculos ou ponteiros, elementos essenciais na navegação entre itens de informação (documentos, mapas, imagens, etc.) atualmente disponíveis na Internet devem ter o seu funcionamento preservado e disponível, por longo prazo.

A solução para se poder garantir longa vida na preservação de ponteiros, portanto, com persistência e durabilidade, implica no uso de um sistema de identificação global.

O sistema de endereçamento físico de um item de informação na Web por meio de uma URL (\textsl{Uniform Resource Locator}) não é um sistema de identificação persistente, pois, com o tempo, um determinado item de informação pode mudar de localização, fazendo com que a associação: ``item de informação'' $\mapsto$ URL, não possua caráter de longa durabilidade, portanto que possa vir a não ser essencialmente permanente.

Uma vez escolhido um sistema de identificação, tal que, por meio dele possam ser atribuídos rótulos à itens de informação, a questão da construção de ponteiros persistentes pode vir a ser solucionada com o uso de um sistema de resolução (ou, sistema ``resolvedor''), que deve ter o propósito básico de redirecionar cada URL, agora contendo apenas o identificador de um item de informação, para a URL que, efetivamente, contém o seu endereço físico.

\chapter{Termos e definições}
\label{chap:termimologia}

Para os efeitos deste documento, aplicam-se os seguintes termos e definições.

\textbf{Distribuidor espacial}: função entre um conjunto de \textbf{itens} e um conjunto de \textbf{subsistemas de identificação}, distribuindo cada \textbf{item} à um determinado \textbf{subsistema de identificação}, tornando esse \textbf{subsistema de identificação} responsável pela identificação desse \textbf{item}.

\textbf{Distribuidor temporal}: função entre um conjunto de \textbf{itens} e um conjunto de datas, expressas em fração de segundo, distribuindo cada \textbf{item} num espaço temporal.

\textbf{Gerador de rótulo}: função injetora utilizada por um \textbf{sistema de identificação} para gerar o \textbf{identificador de um item}.

\textbf{IBI}: sigla para ``Identificador com Base na Internet''. Qualquer \textbf{rótulo} gerado pelo \textbf{sistema para geração de IBI}.

\textbf{IBI de um item}: \textbf{rótulo} atribuido à um \textbf{item} pelo \textbf{sistema para geração de IBI} utilizando o endereçamento por nome de domínio ou IP.

% \textbf{IBIp}: qualquer \textbf{rótulo} gerado pelo \textbf{sistema para geração de IBI} utilizando o endereçamento por IP.

\textbf{IBIp de um item}: \textbf{rótulo} atribuido à um \textbf{item} pelo \textbf{sistema para geração de IBI} utilizando o endereçamento por IP.

% \textbf{Identificador com base na Internet}: qualquer \textbf{rótulo} gerado pelo \textbf{sistema de identificação em dois níveis} objeto deste relatório.

\textbf{Identificador de um item}: \textbf{rótulo} atribuido à um \textbf{item} por um \textbf{sistema de identificação}.

\textbf{Instalador}: função entre um conjunto de \textbf{subsistemas de identificação} e um conjunto de pares de cadeia de caracteres informando o nome ou IP do computador, e a porta de acesso, onde foi instalado o \textbf{gerador de rótulo} utilizado por um determinado \textbf{subsistema de identificação}.

\textbf{Item}: qualquer objeto a ser identificado.

\textbf{Item de informação}: qualquer \textbf{item} consistindo exclusivamente em dados digitais, isto é quaisquer dados digitais a serem identificados. Por exemplo: documentos, mapas, imagens, etc. no formato digital.

% \textbf{Nome de repositório uniforme}: qualquer \textbf{rótulo} gerado pelo \textbf{sistema para geração de IBI} utilizando o endereçamento por nome de domínio.

\textbf{Nome do repositório uniforme de um item}: \textbf{Identificador de um item} podendo ser utilizado para armazená-lo digitalmente em um sistema de arquivos, caso este seja um \textbf{Item de informação}. \textbf{Rótulo} atribuido à um \textbf{item} pelo \textbf{sistema para geração de IBI} utilizando o endereçamento por nome de domínio.

\textbf{Rótulo}: qualquer cadeia finita de caracteres escolhidos dentro de um alfabeto finito, utilizada como \textbf{identificador de um item}.

\textbf{Sistema de identificação}: qualquer função injetora entre um conjunto de \textbf{itens} e um conjunto de \textbf{rótulos}, associando a cada \textbf{item} o \textbf{identificador desse item}.

\textbf{Sistema de identificação em dois níveis}: qualquer \textbf{sistema de identificação} associando um \textbf{item} à um \textbf{rótulo} obtido a partir de um par de \textbf{rótulos}, o primeiro identificando o \textbf{subsistema de identificação} responsável pela identificação do \textbf{item}, e o segundo sendo o \textbf{rótulo} atribuido ao \textbf{item} por esse \textbf{subsistema de identificação}.

% \textbf{Sistema de identificação em dois níveis}: o \textbf{sistema de identificação} objeto desta norma.

\textbf{Sistema para geração de IBI}: qualquer dos dois \textbf{sistemas de identificação em dois níveis} objeto desta norma. 

\textbf{Subsistema de identificação}: qualquer \textbf{sistema de identificação} restrito a um subconjunto de \textbf{itens}.

\chapter{Descrição do sistema de identificação em dois níveis}
\label{chap:descricao}

Nesta norma, os \textbf{itens} (objetos a serem identificados) são considerados formando conjuntos. Por exemplo, um conjunto de pastas.

Por sua vez, os \textbf{rótulos} utilizados para identificar os \textbf{itens}, são considerados formando conjuntos finitos ou enumeráveis. Por exemplo, o conjunto das cadeias de no máximo 255 caracteres alfanuméricos, ou ainda o conjunto dos inteiros representando datas expressas em segundo.

Por ser uma função injetora, um \textbf{sistema de identificação} associa, de forma permanente, cada \textbf{item} à um único \textbf{rótulo}, de maneira que, \textbf{itens} distintos sejam associados à \textbf{rótulos} distintos.

Pela restrição dos conjuntos de \textbf{rótulos} serem finitos (respectivamente, enumeráveis), e pela propriedade de \textbf{sistema de identificação} ser injetor, os conjuntos dos \textbf{itens} devem ser necessariamente finitos (respectivamente, enumeráveis).

O \textbf{sistema de identificação}, objeto desta norma, consiste em quatro principais componentes: um conjunto de \textbf{subsistemas de identificação}, um \textbf{distribuidor espacial} de \textbf{itens}, um \textbf{sistema de identificação} dos \textbf{subsistemas de identificação} e um \textbf{gerador de rótulo}. Juntos eles formam um \textbf{sistema de identificação em dois níveis} descrito detalhadamente a seguir.

	\begin{description}
	
		\item[] Seja $I$ o conjunto dos \textbf{itens} a serem identificados.
			
		\item[] Seja $S$ o conjunto dos \textbf{subsistemas de identificação}.
			
		\item[] Seja $R_1$ um conjunto finito de \textbf{rótulos}.
			
		\item[] Seja $R_2$ um conjunto enumerável de \textbf{rótulos}.
			
		\item[] Seja $R$ um conjunto enumerável de \textbf{rótulos}.
			
		\item[] Seja $f: S \rightarrow R_1$ o \textbf{sistema de identificação} dos \textbf{subsistemas de identificação}.
		
		\item[] Seja $g: I \rightarrow S$ o \textbf{distribuidor espacial} definindo qual é o \textbf{subsistema de identificação} responsável pela identificação de cada \textbf{item}. Assim, para todo $s \in S$, o subconjunto dos \textbf{itens} que estão sob a responsabilidade do \textbf{subsistema de identificação} $s$ é $g^*(s)$, a fibra de $s$ através de $g$ (ver definição de fibra no Apêndice \ref{apendiceA}).
			
		\item[] Seja, para todo $i \in I$, $g(i) : g^*(g(i)) \rightarrow  R_2$, o \textbf{subsistema de identificação} responsável pela identificação do \textbf{item} $i$, no escopo desse subsistema.
			
		\item[] Seja $h: I \rightarrow R_1 \times R_2$ a função definida por:
			\begin{equation*}
				h(i) \triangleq (f(g(i)), g(i)(i)), \qquad  \text{para todo $i \in I$}.
			\end{equation*}	
		\item[] Seja $c: R_1 \times R_2 \rightarrow R$ o \textbf{gerador de rótulo} concatenando de forma reversível (i.e., $c$ é injetor) os rotulos provenientes de $R_1$ e $R_2$ 
		%(ver Agorítmos \ref{algorithm:montarnomederepositoriodeumitem} e \ref{algorithm:montaribipdeumitem})
		.
	\end{description}
	
Um \textbf{sistema de identificação em dois níveis} é a função $s: I \rightarrow R$ definida como a composição de $h$ e $c$, i.e., por:  $s \triangleq c \circ h$.	

Dado um \textbf{item} $i$ em $I$, um \textbf{sistema de identificação em dois níveis} atribui à $i$ o \textbf{rótulo} gerado por $c$ a partir do par $(f(g(i)), g(i)(i))$ constituido, de um lado, pelo \textbf{rótulo} $f(g(i))$ atribuido pelo \textbf{sistema de identificação} $f$ ao \textbf{subsistema de identificação} $g(i)$ (reponsável pela identificação de $i$ dentro do escopo $g^*(g(i))$), e, de outro lado, pelo \textbf{rótulo} $g(i)(i)$ atribuido pelo \textbf{subsistema de identificação} $g(i)$ ao \textbf{item} $i$.

% Os componentes do \textbf{sistema de identificação em dois níveis} aparecem na Figura~\ref{fig:sistemaidentificacao}.

Os dois tipos de \textbf{sistema para geração de IBI}, objetos desta norma, são casos particulares de um \textbf{sistema de identificação em dois níveis} cujos componentes aparecem na Figura~\ref{fig:sistemaidentificacao}.

\begin{figure}[ht]
	\centering
	\includegraphics[width=1.0\hsize,trim=0 0 20 20,clip]{sistemaIdentificacao.pdf}
	\caption{Sistema para geração de IBI}
	\label{fig:sistemaidentificacao}
\end{figure}

Na Figura~\ref{fig:sistemaidentificacao}, cada bloco representa uma função, por exemplo $g$ (indicada por uma setinha acima do bloco), com sua entrada (ao lado esquerdo), por exemplo $i$, e sua saída (ao lado direito), por exemplo $g(i)$.

Enquanto $g(i)(i)$, o \textbf{identificador do item} $i$, fornecido pelo \textbf{subsistema de identificação} $g(i)$, tem validade apenas dentro do escopo $g^*(g(i))$ desse subsistema, $s(i)$, o \textbf{identificador desse item}, fornecido pelo \textbf{sistema de identificação em dois níveis} $s$, tem validade dentro do escopo global $I$.

O \textbf{identificador de um item} será obtido como resultado de uma solicitação a um servidor responsável por um determinado \textbf{subsistema de identificação}, hospedado exclusivamente em um computador possuindo nome de domínio (\textsl{fully qualified domain name}). Nesse contexto, cada um dos \textbf{subsistemas de identificação} é identificado globalmente por um nome de dóminio ou um IP (\textsl{Internet Protocol}) na Internet (e uma porta), permitindo assim construir, de forma simples, o prefixo.

O sufixo, fornecido por um \textbf{subsistema de identificação}, segue uma regra comum a todos os subsistemas, e é construído com base na data e hora da associação do \textbf{item} ao \textbf{rótulo}.

O \textbf{rótulo} $s(i)$ atribuido ao \textbf{item} $i$ pelo \textbf{sistema de identificação em dois níveis} $s$ é chamado, nesta norma, de ``Identificador com Base na Internet'' ou \textbf{IBI}, e $s(i)$ é o \textbf{IBI do item} $i$.

Nesta norma, dois tipos de prefixo herdado da Internet são considerados.

O primeiro tipo consiste em construir o \textbf{identificador de um subsistema de identificação}, isto é, o prefixo, com base no nome de domínio do computador\footnote{O nome de domínio pode se referir eventualmente ao nome de domínio de um computador virtual (\textsl{virtual host}).} que hospeda o servidor responsável por esse subsistema, assim como a porta de acesso a esse servidor.

No segundo tipo, o prefixo é obtido com base no IP do computador, no lugar do nome de domínio.

Os exemplos reais a seguir antecipam alguns dos detalhes sobre a formação dos identificadores que serão dados nos dois próximos capítulos.

% Exemplo 1

\begin{example}[identificador com base no nome de domínio]
	\label{example:nomededominio}
		
	A associação de um \textbf{item} com um sufixo, ocorrida em 16 de fevereiro de 2009 às 17 horas 46 minutos\footnote{Data e hora expressas em Tempo Universal Coordenado (em inglês: \textsl{Coordinated Universal Time} (UTC)).}, resultou no sufixo: 
	
	\begin{center}\texttt{2009/02.16.17.46}\end{center}
	
	O servidor emitindo esse sufixo era hospedado em um computador com nome de domínio \texttt{mtc-m18.sid.inpe.br}, e acessível a partir da porta \texttt{80}, levando ao uso do prefixo: 
	
	\begin{center}\texttt{sid.inpe.br/mtc-m18@80}\end{center}
	
	Desta forma, o \textbf{identificador para o item} passou a ser: 
	
	\begin{center}\texttt{sid.inpe.br/mtc-m18@80/2009/02.16.17.46}\end{center}
		
	\qed
\end{example}

Observa-se, que mesmo que o nome de domínio \texttt{mtc-m18.sid.inpe.br} do Exemplo \ref{example:nomededominio} passe a ser abandonado ou muda de dono, isto não inviabiliza o \textbf{identificador criado para esse item}. O importante, apenas, é que esses dados eram pertinente no contexto da Internet na data e hora da associação entre o \textbf{item} e seu \textbf{rótulo}. Esta observação vale também para o segundo exemplo a seguir ilustrando a formação de um identificador com base no IP.

% Exemplo 2

\begin{example}[identificador opaco com base no IP]
	\label{example:IP}
		
	A associação de um \textbf{item} com um sufixo, ocorrida na segunda 1234806360 em \textsl{POSIX time} (correspondendo a data de 16 de fevereiro de 2009 às 17 horas 46 minutos), resultou no sufixo opaco: 
	
	\begin{center}\texttt{34PGRBS}\end{center}
	
	O servidor emitindo esse sufixo era hospedado em um computador com IP \texttt{150.163.34.243}, e  acessível a partir da porta \texttt{800}, levando ao uso do prefixo opaco: 
	
	\begin{center}\texttt{8JMKD3MGP8W}\end{center}
	
	Desta forma, o \textbf{identificador para o item} passou a ser: 
	
	\begin{center}\texttt{8JMKD3MGP8W/34PGRBS}\end{center}
	
	\qed
\end{example}

Os dois tipos de \textbf{sistemas de identificação em dois níveis} são apresentados a seguir em detalhe. No primeiro, o \textbf{identificador de um item}, exibindo o nome de domíno, é chamado de \textbf{nome de repositório uniforme do item}. No segundo tipo, o \textbf{identificador de um item}, construido com base no IP, é chamado de \textbf{IBIp do item}.

%\chapter{Regras de construção do rótulo como nome de repositório uniforme}
\chapter{Regras de construção do rótulo com base no nome de domínio}
\label{chap:repositoriouniforme}

No \textbf{sistema de identificação em dois níveis} apresentado neste capítulo, o \textbf{identificador de um item} é chamado também de \textbf{nome do repositório uniforme do item} porque ele pode ser utilizado para definir uma sequência de quatro diretórios servindo para armazenar, num sistema de arquivos, o \textbf{item} sendo identificado, caso este seja do tipo \textbf{item de informação}.

Os repositórios são chamados de uniforme porque, por meio destes, qualquer \textbf{item de informação} pode ser armazenado em qualquer sistema de arquivos, debaixo de um mesmo diretório, sem conflito de nome quando considerados outros \textbf{itens de informação}, facilitando assim o depósito de cópias em sistema de arquivos distintos e ainda a migração de \textbf{itens de informação} entre os mesmos.

No \textbf{nome do repositório uniforme de um item}, o prefixo e o sufixo são separados por \verb!"/"! e cada um é, por sua vez, subdividida em duas partes separadas também por \verb!"/"!. Assim, os \textbf{rótulos} são constituidos de quatro partes, que podem se tornar uma sequência de quatro diretórios.

Como anunciado, as duas partes do prefixo são construidas a partir de um nome de domínio de computador (\textsl{hostname}) e eventualmente de um número de porta.

Quanto ao sufixo, as duas partes são construidas a partir de uma informação de data e hora expressa em Tempo Universal Coordenado (em inglês \textsl{Coordinated Universal Time} (UTC)).

Assim, as quatro partes do \textbf{nome do repositório uniforme de um item} são formadas por, nesta ordem:

\begin{enumerate}

	\item um nome de subdomínio,
	
	\item uma palavra\footnote{Um nome de domínio é constituido de palavras separadas por pontos.} de domínio, e eventualmente um número de porta, separados por \verb!"."! ou por \verb!"@"!,
	
	\item um ano e
	
	\item um mês, dia, hora, minuto, e eventualmente segundo\footnote{ou fração de segundo.}, separados por \verb!"."!.

\end{enumerate}

Estas quatro partes são reconhecíveis no Exemplo \ref{example:nomededominio} do capítulo anterior, onde o \textbf{nome do repositório uniforme do item} era:

\begin{center}\texttt{sid.inpe.br/mtc-m18@80/2009/02.16.17.46}\end{center}

Para definir precisamente a sintaxe do \textbf{nome do repositório uniforme de um item}, nesta norma, usa-se uma gramática BNF -- \textsl{Backus Normal Form} ou \textsl{Backus-Naur Form} -- (aumentada) \cite{Crocker:1982:StFoAR, CrockerOver:2008:AuBNSy} com a seguinte alteração: \verb!"|"! é utilizado para alternativas no lugar de \verb!"/"!.

A sintaxe da parte relativa ao prefixo incorpora as regras próprias à formação de ``nome de domínio'' (\textsl{domain name}) como definidas na Seção 3.1 intitulada \textsl{Name space specifications and terminology} por \citeonline{Mockapetris:1987:CoFa}, e de ``nome de domínio de um computador'' (\textsl{hostname}) como definidas na Seção 3.2.2 intitulada \textsl{Server-based Naming Authority} por \citeonline{BernersFielIrviMasi:1998:UnReId}.

A Tabela \ref{table:regraspararepositoriouniforme} contém as regras para a formação do \textbf{nome do repositório uniforme de um item}.

%\clearpage

\begin{table}[h]
\renewcommand{\baselinestretch}{0.9}
\small

\caption{Regras definindo a formação do \textbf{nome do repositório uniforme de um item}}
\label{table:regraspararepositoriouniforme}
\begin{tabular}{rcl}

\verb!repositório!		& \verb!=!	& \verb!prefixo "/" sufixo! \\
						&			& \verb!     ; ex: sid.inpe.br/mtc-m19/2010/08.25.12.38! \\
                        
\verb!prefixo!			& \verb!=!	& \verb!subdomínio "/" palavra [("." | "@") porta]! \\
						&			& \verb!     ; ex: sid.inpe.br/mtc-m19! \\
                        
\verb!subdomínio!		& \verb!=!	& \verb!*(palavra ".") última-palavra ["."]; ex: dpi.inpe.br! \\
						
\verb!palavra!			& \verb!=!	& \verb!ALFANUM | (ALFANUM *(ALFANUM | "-") ALFANUM); ex: sid! \\
                        
\verb!ALFANUM!			& \verb!=!	& \verb!ALFA | DÍGITO! \\
                        
\verb!ALFA!				& \verb!=!	& \verb!ALFAMI | ALFAMA! \\
                        
\verb!ALFAMI!			& \verb!=!	& \verb!"a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" |! \\
						&			& \verb!"j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" |! \\
						&			& \verb!"s" | "t" | "u" | "v" | "w" | "x" | "y" | "z"! \\
                        
\verb!ALFAMA!			& \verb!=!	& \verb!"A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" |! \\
						&			& \verb!"J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" |! \\
						&			& \verb!"S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z"! \\
                        
\verb!DÍGITO!			& \verb!=!	& \verb!"0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" |! \\
						&			& \verb!"9"! \\
                        
\verb!última-palavra!	& \verb!=!	& \verb!ALFA | (ALFA *(ALFANUM | "-") ALFANUM); ex: br! \\
                        
\verb!porta!			& \verb!=!	& \verb!1*DÍGITO; ex: 80! \\
                        
\verb!sufixo!			& \verb!=!	& \verb!ano "/" mês "." dia "." hora "." minuto ["." segundo]! \\
						&			& \verb!     ; ex: 2010/08.25.12.38! \\
                        
\verb!ano!				& \verb!=!	& \verb!4*DÍGITO; ex: 2010! \\
                        
\verb!mês!				& \verb!=!	& \verb!2DÍGITO; ex: 08! \\
                        
\verb!dia!				& \verb!=!	& \verb!2DÍGITO; ex: 25! \\
                        
\verb!hora!				& \verb!=!	& \verb!2DÍGITO; ex: 12! \\
                        
\verb!minuto!			& \verb!=!	& \verb!2DÍGITO; ex: 38! \\
                        
%\verb!segundo!			& \verb!=!	& \verb!2DÍGITO! \\
\verb!segundo!			& \verb!=!	& \verb!inteiro ["." fração]! \\
                        
\verb!inteiro!			& \verb!=!	& \verb!2DÍGITO! \\

\verb!fração!			& \verb!=!	& \verb!1*DÍGITO! \\

\end{tabular}

\renewcommand{\baselinestretch}{1}
\normalsize
\end{table}

Ao acrescentar a \texttt{porta} à \texttt{palavra} no \texttt{prefixo}, o separador pode ser o símbolo \verb!"."! ou o símbolo \verb!"@"!. Recomenda-se usar apenas o símbolo \verb!"."!. O uso do símbolo \verb!"@"! era necessário em implementações do \textbf{IBI} anteriores a agosto de 2010. O inconveniente desse símbolo é que ele induza certos aplicativos a interpretar o \textbf{identificador de um item} como um endereço de \textsl{e-mail}.

A regra \verb!subdomínio! é denotada \verb!hostname! em \citeonline{BernersFielIrviMasi:1998:UnReId}.

O nome de domínio de um computador sendo insensível a maiúscula e minúscula, esta propriedade se estende ao \textbf{nome do repositório uniforme de um item}. Assim, \texttt{sid.inpe.br/mtc-m18@80/2009/02.16.17.46} e \texttt{sid.INPE.br/MTC-m18@80/2009/02.16.17.46} são equivalentes. Na prática, recomenda-se utilizar apenas lettras minúsculas na geração do prefixo.

Além das regras sintáticas da Tabela \ref{table:regraspararepositoriouniforme}, o \textbf{nome do repositório uniforme de um item} deve verificar as regras semânticas definidas por meio dos Algoritmos \ref{algorithm:montarprefixodonomederepositoriodeumitem}, \ref{algorithm:montarsufixodonomederepositoriodeumitem} e \ref{algorithm:montarnomederepositoriodeumitem}. Por sua vez, por construção, o Algoritmo \ref{algorithm:montarnomederepositoriodeumitem} gera um \textbf{rótulo} que verifica as regras sintáticas da Tabela \ref{table:regraspararepositoriouniforme}.

O Algoritmo \ref{algorithm:montarprefixodonomederepositoriodeumitem} é a descrição do \textbf{gerador de rótulo} denotado $a$ na Figura~\ref{fig:sistemaidentificacao} e utilizado pelo \textbf{sistema de identificação} $f$ para a identificação dos \textbf{subsistemas de identificação}.

O Algoritmo \ref{algorithm:montarsufixodonomederepositoriodeumitem} é a descrição do \textbf{gerador de rótulo} denotado $b$ na Figura~\ref{fig:sistemaidentificacao} e utilizado por qualquer \textbf{subsistema de identificação}.

O Algoritmo \ref{algorithm:montarnomederepositoriodeumitem} é a descrição do \textbf{gerador de rótulo} denotado $c$ na Figura~\ref{fig:sistemaidentificacao} e utilizado pelo \textbf{sistema de identificação em dois níveis} $s$.

O \textbf{sistema de identificação em dois níveis} funciona de forma distribuída, um servidor para cada \textbf{subsistema de identificação}. Os servidores estão hospedados em computadores possuindo nomes de domínio, e o acesso aos servidores sendo feito via portas.

Ao receber uma solicitação de identificação de um \textbf{item} $i$, o servidor responsável pelo \textbf{subsistema de identificação} $g(i)$ executa os Algoritmos \ref{algorithm:montarprefixodonomederepositoriodeumitem}, \ref{algorithm:montarsufixodonomederepositoriodeumitem} e \ref{algorithm:montarnomederepositoriodeumitem} e retorna o \textbf{identificador do item}.

\clearpage

\begin{nicealgo}{algorithm:montarprefixodonomederepositoriodeumitem}
\naTITLE{\textsc{MontarPrefixoDoNomeDeRepositórioDeUmItem}.}
\naPREAMBLE
\naINPUT{\textnormal{\texttt{computador}} \textnormal{(}cadeia de caracteres representando o nome de domínio (em minúsculo) do computador (eventualmente virtual) que hospeda o servidor responsável pelo subsistema de identificação\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{porta}} \textnormal{(}inteiro decimal representando o número da porta de acesso ao servidor responsável pelo subsistema de identificação\textnormal{)}.}
\naOUTPUT{\textnormal{\texttt{prefixo}} \textnormal{(}cadeia de caracteres\textnormal{)}.}
\naAUX{\textnormal{\texttt{parte}} \textnormal{(}inteiro\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{aux}} \textnormal{(}cadeia de caracteres\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{subdomínio}} \textnormal{(}cadeia de caracteres\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{primeira-palavra}} \textnormal{(}cadeia de caracteres\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{palavra-porta}} \textnormal{(}cadeia de caracteres\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{c}} \textnormal{(}caractere\textnormal{)}.}

\naBODY
\na{$\texttt{aux} \mget \texttt{computador}$}
\na{$\texttt{parte} \mget 2$}
\naBEGIN{\naWHILE $\texttt{aux} \neq \texttt{\textquotedbl\textquotedbl}$, \naDO}
\na{$\texttt{c} \mget \textsc{SairFila}(\texttt{aux})$}
\naBEGIN{\naIF $\texttt{c} = \texttt{\textquotedbl.\textquotedbl}$ \naTHEN}
\naENDN{1}{$\texttt{parte} \mget 1$}
\naBEGIN{\naELSE}
\naBEGIN{\naIF $\texttt{parte} = 1$ \naTHEN}
\naENDN{1}{$\textsc{EntrarFila}(\texttt{subdomínio}, \texttt{c})$}
\naBEGIN{\naELSE}
\naENDN{3}{$\textsc{EntrarFila}(\texttt{primeira-palavra}, \texttt{c})$}
\naBEGIN{\naIF $\texttt{porta} = 80$ \naTHEN}
\naENDN{1}{$\texttt{palavra-porta} \mget \texttt{primeira-palavra}$}
\naBEGIN{\naELSE}
\naENDN{1}{$\texttt{palavra-porta} \mget \textsc{Concatenar}(\texttt{primeira-palavra}, \texttt{\textquotedbl.\textquotedbl}, \texttt{porta})$}
\na{$\texttt{prefixo} \mget \textsc{Concatenar}(\texttt{subdomínio}, \texttt{\textquotedbl/\textquotedbl}, \texttt{palavra-porta})$}
\end{nicealgo}

\clearpage

\begin{comment}
\begin{nicealgo}{algorithm:montarsufixodonomederepositoriodeumitem}
\naTITLE{\textsc{MontarSufixoDoNomeDeRepositórioDeUmItem}.}
\naPREAMBLE
\naINPUT{\textnormal{\texttt{data-corrente}} \textnormal{(}racional decimal representando a data, arredondada em r de segundo, da geração do rótulo corrente -- sufixo corrente\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{última-data}} \textnormal{(}racional decimal representando a data, arredondada em r de segundo, da geração do último rótulo -- último sufixo\textnormal{)}.}
\naOUTPUT{\textnormal{\texttt{sufixo}} \textnormal{(}cadeia de caracteres\textnormal{)}.}
\naAUX{\textnormal{\texttt{data-em-segundo-arredondada-em-minuto}} \textnormal{(}inteiro\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{data}} \textnormal{(}racional\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{ano}} \textnormal{(}inteiro decimal\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{mês}} \textnormal{(}inteiro decimal\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{dia}} \textnormal{(}inteiro decimal\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{hora}} \textnormal{(}inteiro decimal\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{minuto}} \textnormal{(}inteiro decimal\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{segundo}} \textnormal{(}racional decimal\textnormal{)}.}

\naBODY
\na{$\texttt{data-em-segundo-arredondada-em-minuto} \mget 60 * \textsc{Int}(\texttt{data-corrente}/60)$}
\naBEGIN{\naIF $\texttt{última-data} < \texttt{data-em-segundo-arredondada-em-minuto}$ \naTHEN}
\naENDN{1}{$\texttt{data} \mget \texttt{data-em-segundo-arredondada-em-minuto}$}
\naBEGIN{\naELSE}
\naENDN{1}{$\texttt{data} \mget \texttt{data-corrente}$}
\na{$\texttt{ano} \mget \textsc{Extrair}(\texttt{data}, \mathrm{ano})$}
\na{$\texttt{mês} \mget \textsc{Extrair}(\texttt{data}, \text{mês})$}
\na{$\texttt{dia} \mget \textsc{Extrair}(\texttt{data}, \mathrm{dia})$}
\na{$\texttt{hora} \mget \textsc{Extrair}(\texttt{data}, \mathrm{hora})$}
\na{$\texttt{minuto} \mget \textsc{Extrair}(\texttt{data}, \mathrm{minuto})$}
\na{$\texttt{segundo} \mget \textsc{Extrair}(\texttt{data}, \mathrm{segundo})$}
\na{$\texttt{sufixo} \mget \textsc{Concatenar}(\texttt{ano}, \texttt{\textquotedbl/\textquotedbl}, \texttt{mês}, \texttt{\textquotedbl.\textquotedbl}, \texttt{dia}, \texttt{\textquotedbl.\textquotedbl}, \texttt{hora}, \texttt{\textquotedbl.\textquotedbl}, \texttt{minuto})$}
\naBEGIN{\naIF $\texttt{segundo} \neq \texttt{\textquotedbl00\textquotedbl}$ \naTHEN}
\naENDN{1}{$\texttt{sufixo} \mget \textsc{Concatenar}(\texttt{sufixo}, \texttt{\textquotedbl.\textquotedbl}, \texttt{segundo})$}
\end{nicealgo}
\end{comment}

\begin{nicealgo}{algorithm:montarsufixodonomederepositoriodeumitem}
\naTITLE{\textsc{MontarSufixoDoNomeDeRepositórioDeUmItem}.}
\naPREAMBLE
\naINPUT{\textnormal{\texttt{data}} \textnormal{(}racional decimal obtido em saída do Algorítmo~\ref{algorithm:criardataparamontarsufixodoibideumitem}: \textsc{CriarDataParaMontarSufixoDoIBIDeUmItem}\textnormal{)},}
\naOUTPUT{\textnormal{\texttt{sufixo}} \textnormal{(}cadeia de caracteres\textnormal{)}.}
\naAUX{\textnormal{\texttt{ano}} \textnormal{(}inteiro decimal\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{mês}} \textnormal{(}inteiro decimal\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{dia}} \textnormal{(}inteiro decimal\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{hora}} \textnormal{(}inteiro decimal\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{minuto}} \textnormal{(}inteiro decimal\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{segundo}} \textnormal{(}inteiro decimal\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{fração-de-segundo}} \textnormal{(}inteiro decimal\textnormal{)}.}

\naBODY
\na{$\texttt{ano} \mget \textsc{Extrair}(\texttt{data}, \mathrm{ano})$}
\na{$\texttt{mês} \mget \textsc{Extrair}(\texttt{data}, \text{mês})$}
\na{$\texttt{dia} \mget \textsc{Extrair}(\texttt{data}, \mathrm{dia})$}
\na{$\texttt{hora} \mget \textsc{Extrair}(\texttt{data}, \mathrm{hora})$}
\na{$\texttt{minuto} \mget \textsc{Extrair}(\texttt{data}, \mathrm{minuto})$}
\na{$\texttt{segundo} \mget \textsc{Extrair}(\texttt{data}, \mathrm{segundo})$}
\na{$\texttt{fração-de-segundo} \mget \textsc{Extrair}(\texttt{data}, \text{fração de segundo})$}
\na{$\texttt{sufixo} \mget \textsc{Concatenar}(\texttt{ano}, \texttt{\textquotedbl/\textquotedbl}, \texttt{mês}, \texttt{\textquotedbl.\textquotedbl}, \texttt{dia}, \texttt{\textquotedbl.\textquotedbl}, \texttt{hora}, \texttt{\textquotedbl.\textquotedbl}, \texttt{minuto})$}
\naBEGIN{\naIF $\texttt{fração-de-segundo} = \texttt{\textquotedbl0\textquotedbl}$ \naTHEN}
\naBEGIN{\naIF $\texttt{segundo} \neq \texttt{\textquotedbl00\textquotedbl}$ \naTHEN}
\naENDN{2}{$\texttt{sufixo} \mget \textsc{Concatenar}(\texttt{sufixo}, \texttt{\textquotedbl.\textquotedbl}, \texttt{segundo})$}
\na{\naELSE $\texttt{sufixo} \mget \textsc{Concatenar}(\texttt{sufixo}, \texttt{\textquotedbl.\textquotedbl}, \texttt{segundo}, \texttt{\textquotedbl.\textquotedbl}, \texttt{fração-de-segundo})$}
\end{nicealgo}

\clearpage

\begin{nicealgo}{algorithm:montarnomederepositoriodeumitem}
\naTITLE{\textsc{MontarNomeDeRepositórioDeUmItem}.}
\naPREAMBLE
% \naINPUT{\textnormal{\texttt{prefixo}} \textnormal{(}cadeia de caracteres obtida em saída do Algorítmo 1: \textsc{MontarPrefixoDoNomeDeRepositório\-De\-UmItem}\textnormal{)},}
% \naCONTINUE{\textnormal{\texttt{sufixo}} \textnormal{(}cadeia de caracteres  obtida em saída do Algorítmo 2: \textsc{MontarSufixoDoNomeDeRepositório\-De\-UmItem}\textnormal{)}.}
\naINPUT{\textnormal{\texttt{prefixo}} \textnormal{(}cadeia de caracteres obtida em saída do Algorítmo 1: \textsc{MontarPrefixoDoNomeDeRepositórioDeUmItem}\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{sufixo}} \textnormal{(}cadeia de caracteres  obtida em saída do Algorítmo 2: \textsc{MontarSufixoDoNomeDeRepositórioDeUmItem}\textnormal{)}.}
\naOUTPUT{\textnormal{\texttt{repositório}} \textnormal{(}cadeia de caracteres\textnormal{)}.}
\naBODY
\na{$\texttt{repositório} \mget \textsc{Concatenar}(\texttt{prefixo}, \texttt{\textquotedbl/\textquotedbl}, \texttt{sufixo})$}
\end{nicealgo}

Os algoritmos apresentados acima usam as seguintes rotinas.

A rotina \textsc{Concatenar} concatena as cadeias de caracteres informadas no seus argumentos.

A rotina \textsc{EntrarFila} concatena a direita da cadeia de caracteres informada no primeiro argumento, mais o caractere informado no segundo argumento.

A rotina \textsc{SairFila} retira o primeiro caractere da cadeia de caracteres informada no seu argumento, e retorna esse caractere.

%A rotina \textsc{Int} retorna a parte inteira do valor real do argumento.

%A rotina \textsc{GerarData} gera um número de segundos desde uma data prefixada (por exemplo, 1 de janeiro de 1970 às 00:00:00) com a granularidade (\texttt{segundo} ou \texttt{minuto}) informada.

%A rotina \textsc{Esperar} espera pelo tempo indicado.

A rotina \textsc{Extrair} retorna, no formato compatível com as regras da Tabela \ref{table:regraspararepositoriouniforme}, o número decimal referente a unidade informada no segundo argumento, quando a data em segundo ou fração de segundo, informada no primeiro argumento, é convertida para o Tempo Universal Coordenado (em inglês: \textsl{Coordinated Universal Time} (UTC)).

Utiliza-se o padrão UTC de forma a permitir a continuação do funcionamento do \textbf{sistema de identificação em dois níveis} mesmo em caso de entrada/saída do horário de verão ou de troca de computadores situados em longitudes distintas, e referentes a um mesmo \textbf{subsistema de identificação}.
                
O Algoritmo \ref{algorithm:montarprefixodonomederepositoriodeumitem} separa a primeira palavra do nome de domínio\footnote{Um nome de domínio é constituido de palavras separadas por pontos.} do computador (eventualmente virtual) do subdomínio sem esta palavra, dividindo assim o prefixo em duas partes, a primeira parte contendo o subdomínio, e a segunda, a primeira palavra.

Pelo Algoritmo \ref{algorithm:montarprefixodonomederepositoriodeumitem}, verifica-se, que quando o número de porta é 80, este é omitido na segunda parte do prefixo. Como a porta 80 é a porta geralmente utilizada pelos servidores HTTP que rodam os scripts CGI que implementam os Algoritmos \ref{algorithm:montarprefixodonomederepositoriodeumitem}, \ref{algorithm:montarsufixodonomederepositoriodeumitem} e \ref{algorithm:montarnomederepositoriodeumitem}, o prefixo dos \textbf{nomes de repositório uniforme de um item} fica assim geralmente mais curto.

O Algoritmo \ref{algorithm:montarsufixodonomederepositoriodeumitem} gera um \textbf{rótulo} (sufixo) com base no valor da \texttt{data} fornecido pelo \textbf{distribuidor temporal} (ver saída \texttt{data-para-sufixo} do Algoritmo \ref{algorithm:criardataparamontarsufixodoibideumitem}).

No caso de necessitar de uma resposta mais rápida do \textbf{subsistema de identificação}, basta escolher uma granularidade $r$ menor. No entanto, a possibilidade de atender as solicitações de identificação por meio de um grande número de \textbf{subsistemas de identificação} (lembrando que a granularidade do prefixo é extremamente fina) constitui uma outra solução para minimizar o problema de uma alta frequência de solicitações.

O Algoritmo \ref{algorithm:montarnomederepositoriodeumitem} concatena o prefixo e o sufixo e interpõe entre estes o símbolo \verb!"/"!. A presença, nesta posição, de um símbolo que não pertence aos alfabetos usados na geração do prefixo e do sufixo, torna a concatenação reversível, pois com sua presença é possível reconhecer, sem ambiguidade, o prefixo do sufixo após a concatenação.

Para o correto funcionamento, as entradas do Algoritmo \ref{algorithm:montarprefixodonomederepositoriodeumitem} devem ser: o nome de domínio do computador (\textsl{hostname}) ou do computador virtual (\textsl{virtual host}) que hospeda o servidor responsável pelo \textbf{subsistema de identificação}, e a porta que dá acesso a esse servidor.

O par formado pelo nome de domínio (em minúsculo) do computador e a porta de acesso referentes ao \textbf{subsistema de identificação} $g(i)$ é interpretado, na Figura~\ref{fig:sistemaidentificacao} como a saída, em $C^2$, do chamado \textbf{instalador} $e$, recebendo como entrada, em $S$, o \textbf{subsistema de identificação} $g(i)$.

O nome de domínio do computador (\textsl{hostname}) pode ser obtido, por exemplo, por meio do comando \texttt{nslookup}.

Quanto ao Algoritmo \ref{algorithm:montarsufixodonomederepositoriodeumitem}, a entrada deve ser a data $t(i)$, interpretada, na Figura~\ref{fig:sistemaidentificacao} como a saída, em $T_r$, de um \textbf{distribuidor temporal}, recebendo como entrada, em $g^*(g(i))$, o próprio \textbf{item} $i$.

Para todo $i \in I$, o papel do \textbf{distribuidor temporal} utilizado pelo \textbf{subsistema de identificação} $g(i)$ é distribuir numa grade $T_r$, com granularidade de $r$ segundos, as solicitações de identificações referentes aos \textbf{itens} do conjunto $g^*(g(i))$.

O \textbf{distribuidor temporal} é descrito detalhadamente a seguir, onde $I'$ representa o domínio $g^*(g(i))$ de um determinado \textbf{subsistema de identificação} $g(i)$.

	\begin{description}
	
		\item[] Seja $I'$ um conjunto de \textbf{itens}.
			
		\item[] Seja $\mathbb{Q}^+$ o conjunto dos racionais positivos.
		
		\item[] Seja $\mathbb{R}^+$ o conjunto dos reais positivos.
		
		\item[] Seja $G \triangleq \{60, 1, 1/10, 1/100, ...\}$ o subconjunto de racionais, definindo as possíveis granularidades temporais: minuto, segundo e frações de segundo.
			
%		\item[] Seja $r \in G$ um número racional, definindo a granularidade temporal em uso por um \textbf{subsistema de identificação}.
		
%		\item[] Seja $G_r \triangleq \{60, 1, 1/10, ..., r\}$ o conjunto das granularidades entre 60 e $r$, sendo $r \in G$.
			
		\item[] Seja $t_i \in \mathbb{R}^+$ a data, expressa em fração de segundo\footnote{Mais precisamente em \textsl{Unix time} ou \textsl{POSIX time}.}, da solicitação de identificação do \textbf{item} $i \in I'$ (supõe-se que $i \mapsto t_i$ é injetora).

		\item[] Seja $[i] \in \{1, 2, ..., |I'|\}$ o valor indicando que o \textbf{item} $i \in I'$ foi o $[i]^\text{ésimo}$ \textbf{item} a solicitar uma identificação, i.e., $[i]$ é dado por:
			\begin{equation*}
				[i] \triangleq \sum\limits_{j \in I'} \left\{ \hspace{-1mm}\begin{array}{l}
						1 \quad\text{se}\quad t_j \le t_i,\\ 
						0 \quad\text{caso contrário},
					\end{array}
				\right.
				\qquad \text{para todo $i \in I'$.}
			\end{equation*}	
		\item[] Seja $]k[ \in I'$ o valor indicando que o $k^\text{ésimo}$ \textbf{item} a solicitar uma identificação é o \textbf{item} $]k[$, i.e., $]k[$ é dado por:
			\begin{equation*}
				]k[ \: \triangleq i \; \Leftrightarrow \; k = [i], \qquad \text{para todo $k \in \{1, 2, ..., |I'|\}$ e $i \in I'$.}
			\end{equation*}	
		\item[] Seja $t^{(r)} \in \mathbb{Q}^+$ a data $t$ arredondada em $r$ segundos, i.e, $t^{(r)}$  é dado por:
			\begin{equation*}
				t^{(r)} \triangleq r\mathrm{int}(t/r), \qquad \text{para todo $t \in \mathbb{R}^+$ e $r \in G$.}		
			\end{equation*}
		\item[] Seja $T_r = \{t^{(r)} : t \in \mathbb{R}^+\}$ o conjunto das datas arredondadas em $r$ segundos, sendo $r \in G$.
		
		\item[] Seja $t'_i \in T_r$, com $r \in G$ e $i \in I'$, a data, arredondada em $r$ segundos, dada por:
			\[
				t'_i \triangleq \left\{ \hspace{-1mm}
				  \begin{array}{l l}
				    {t_i}^{(r)} & \quad \text{se $[i] = 1$},\\
				    \max(t(][i] - 1[) + r, {t_i}^{(r)}) & \quad \text{se $[i] = 2, ..., |I'|$.}\\
				  \end{array} \right.
			\]
			Na expressão acima, $t(][i] - 1[)$ é a data fornecida pelo \textbf{distribuidor temporal} referente ao \textbf{item} $][i] - 1[$ imediatamente anterior ao \textbf{item} $i$, considerando as datas de solicitação de identificação.  A data $t'_i$ será considerada a data na qual o \textbf{distribuidor temporal} fornece sua resposta $t(i)$ usada na geração do \textbf{rótulo} utilizado na identificação do \textbf{item} $i$. Em outros termos, $t'_i$ será considerada a data de geração do \textbf{rótulo} do \textbf{item} $i$, enquanto $t(i)$ é a data utilizada pelo \textbf{gerador de rótulo} $b$ para montar o sufixo do identificador de $i$. 
			
		\item[] Seja $t'(i) \in {T_r}^2$, com $r \in G$ e $i \in I'$, o par de datas, arredondadas em $r$ segundos, dado por:
		\[
		t'(i) \triangleq \left\{ \hspace{-1mm}
		  \begin{array}{l l}
		    (t'_i, t'_i - r) & \quad \text{se $[i] = 1$},\\
		    (t'_i, t(][i] - 1[)) & \quad \text{se $[i] = 2, ..., |I'|$.}\\
		  \end{array} \right.
		\]
			O mapeamento $i \mapsto t'(i)$ define uma função $t'$ de $I'$ em ${T_r}^2$.
		
		\item[] Seja $r_{(t, s)} \in G$, com $t > s$, a maior granularidade $r$ tal que a data $t$ arredondada em $r$ segundos, seja maior do que a data $s$, i.e., $r_{(t,s)}$ é dado por:
			\begin{equation*}
				r_{(t, s)} \: \triangleq \max(\{r \in G : t^{(r)} > s\}), \qquad \text{para todo $t$ e $s \in \mathbb{R}^+$ tal que $t > s$.}
			\end{equation*}	
			Nota-se que $r_{(t, t - r)} = r$ para todo $t \in \mathbb{R}^+$ e $r \in G$.
							
		\item[] Seja $t(i) \in T_{r_{t(i)}} \subset T_r$, com $r \in G$, a data $t'_i$ arredondada em $r_{t'(i)}$ segundos:
			\begin{equation*}
				t(i) \triangleq {t'_i}^{(r_{t'(i)})}, \qquad \text{para todo $i \in I'$.}		
			\end{equation*}
			Nota-se que, para todo $r \in G$, $t(]1[) = {t'_{]1[}}^{(r)}$, e que $r_{t(i)} \leq r$, $T_{r_{t(i)}} \subset T_r$ e $t(][i] - 1[) < t(i) \leq t'_i$, para todo $i \in I'$ tal que $[i] > 1$.

\begin{comment}			
			\[
				t''_i \triangleq \left\{ \hspace{-1mm}
				  \begin{array}{l l}
				    t'_i & \quad \text{se $[i] = 1$},\\
				    {t'_i}^{(r_{t(i)})} & \quad \text{se $[i] = 2, ..., |I'|$.}\\
				  \end{array} \right.
			\]
		\item[] Seja $t'(i) \in {T_{r_{t(i)}}}^2$ o par de datas, arredondadas em $r_{t(i)}$ de segundo, dado por:
			\begin{equation*}
				t'(i) \triangleq (t''_i, t''_{][i] - 1[}), \qquad \text{para todo $i \in I'$.}		
			\end{equation*}
\end{comment}			
			
	\end{description}
	
	Um \textbf{distribuidor temporal}, com granularidade $r \in G$, é a função $t: I' \rightarrow T_r$ tal que $i \mapsto t(i)$.

 A Tabela~\ref{table:exemplodisttribuidortemporal} contém os dados de um exemplo de funcionamento de um \textbf{distribuidor temporal} com granularidade de um segundo ($r = 1$).
			
\begin{table}[H]
	\renewcommand{\baselinestretch}{1.3}
%	\footnotesize
	\scriptsize
	\centering
	\caption{Exemplificação do funcionamento de um \textbf{distribuidor temporal} com granularidade de um segundo.}
	\label{table:exemplodisttribuidortemporal}
	\begin{tabular}{cr@{,}lclrcl}
		\footnotesize $i$	& \multicolumn{2}{c}{\footnotesize $t_i$ (segundos)}	& \footnotesize $[i]$	& \multicolumn{1}{c}{\footnotesize $t'(i)$} & \footnotesize $r_{t'(i)}$ & \footnotesize $t(i)$ & \multicolumn{1}{c}{\footnotesize sufixo}\\
		\hline
		\texttt{d}	& 1287587646&394023		& 1		& (1287587646, 1287587645)	&	1	&	1287587646	&	2010/10.20.15.14.06	\\
		\texttt{b}	& 1287588012&2930		& 2		& (1287588012, 1287587646)	&	60	&	1287588000	&	2010/10.20.15.20	\\
		\texttt{a}	& 1287588115&186234		& 3		& (1287588115, 1287588000)	&	60	&	1287588060	&	2010/10.20.15.21	\\
		\texttt{c}	& 1287588115&3462		& 4		& (1287588115, 1287588060)	&	1	&	1287588115	&	2010/10.20.15.21.55	\\
		\texttt{g}	& 1287588115&99623		& 5		& (1287588116, 1287588115)	&	1	&	1287588116	&	2010/10.20.15.21.56	\\
		\texttt{f}	& 1287588116&72			& 6		& (1287588117, 1287588116)	&	1	&	1287588117	&	2010/10.20.15.21.57	\\
		\texttt{e}	& 1287588539&788342		& 7		& (1287588539, 1287588117)	&	60	&	1287588480	&	2010/10.20.15.28	\\
		\hline
	\end{tabular}
\end{table}

Na Tabela~\ref{table:exemplodisttribuidortemporal}, as linhas foram ordenadas por datas crescentes de solicitação de identificação (coluna $t_i$). Os valores de $[i]$ indicam a ordem das solicitações. Observa-se, por exemplo, que o \textbf{item} \texttt{g}, apesar de ter solicitado sua identificação numa data anterior à 1287588116 segundos, recebeu como data $t(i)$, a ser usada na geração do \textbf{rótulo}, o valor de 1287588116 segundos. Isto ocorreu porque os \textbf{itens} \texttt{a}, \texttt{c} e \texttt{g} fizeram, os três, a solicitação de identificação dentro do periodo de um segundo. Consequentemente, o \textbf{item} \texttt{g} terá que aguardar que os \textbf{itens} \texttt{a} e \texttt{c} recebam primeiro suas identificações para receber a sua. Esse ``atraso'' está se repercutindo para o próximo \textbf{item} \texttt{f} que fez sua solicitação de identificação apenas no segundo seguinte (1287588116) ao do \textbf{item} \texttt{g} (1287588115).

Na prática, o \textbf{distribuidor temporal} poderá ser implementado usando, por exemplo, os conceitos de sala de espera e de temporizador, de forma a associar a cada \textbf{item} $i$ uma data de solicitação de identificação $t_i$ (data do começo do atendimento após o aguardo na sala de espera) e transformar esta na data $t(i)$, numa grade temporal com granularidade $r$, para geração do \textbf{rótulo}.

Nesse caso, os \textbf{itens} a serem identificados por um determinado \textbf{subsistema de identificação} entram numa sala de espera. Quando o servidor responsável pelo \textbf{subsistema de identificação} está pronto para identificar um novo \textbf{item}, um dos \textbf{itens} na sala de espera é sorteado. O instante do sorteio torna-se a data de solicitação de identificação do item sorteado.

O Algoritmo \ref{algorithm:criardataparamontarsufixodoibideumitem} mostra como criar, na prática, a data $t(i)$ utilizada, pelo \textbf{gerador de rótulo} $b$, para montar o sufixo do identificador de um \textbf{item} $i \in I'$.

Para criar a data $t(i)$, esse algoritmo tem que ser executado na data $t_i$ (data da solicitação de identificação), e receber essa data $t_i$ como entrada.

No Algoritmo \ref{algorithm:criardataparamontarsufixodoibideumitem} a entrada, denotada \texttt{data-corrente}, corresponde à data $t_i$, e a saída, denotada \texttt{data-para-sufixo}, corresponde à data $t(i)$.

\clearpage

\begin{nicealgo}{algorithm:criardataparamontarsufixodoibideumitem}
\naTITLE{\textsc{CriarDataParaMontarSufixoDoIBIDeUmItem}.}
\naPREAMBLE
\naINPUT{\textnormal{\texttt{data-corrente}} \textnormal{(}racional decimal representando a data de solicitação de uma identificação, i.e., a data de execução do próprio algoritmo\textnormal{)}.}
\naOUTPUT{\textnormal{\texttt{data-para-sufixo}} \textnormal{(}racional decimal\textnormal{)}.}
\naGLOBAL{\textnormal{\texttt{última-data-para-sufixo}} \textnormal{(}racional decimal representando a data criada para o sufixo na execução anterior do próprio algoritmo\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{r}} \textnormal{(}racional decimal representando a granularidade temporal\textnormal{)}.}
\naAUX{\textnormal{\texttt{data-arredondada}} \textnormal{(}racional decimal\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{data-de-criação}} \textnormal{(}racional decimal\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{atraso}} \textnormal{(}racional decimal\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{s}} \textnormal{(}racional decimal\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{t}} \textnormal{(}racional decimal\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{data-curta}} \textnormal{(}racional decimal\textnormal{)}.}

\naBODY
\na{$\texttt{data-arredondada} \mget \texttt{r} * \textsc{Int}(\texttt{data-corrente}/\texttt{r})$}
\naBEGIN{\naIF $\texttt{última-data-para-sufixo} \textnormal{ não existe }$ \naTHEN}
% \naENDN{1}{$\texttt{última-data-para-sufixo} \mget \texttt{data-corrente-arredondada} - \texttt{r}$}
\naENDN{1}{$\texttt{última-data-para-sufixo} \mget \texttt{data-arredondada} - \texttt{r}$}
\na{$\texttt{última-data-para-sufixo} \mget \texttt{r} * \textsc{Int}(\texttt{última-data-para-sufixo}/\texttt{r})$}
\na{$\texttt{data-de-criação} \mget \textsc{Max}(\texttt{última-data-para-sufixo} + \texttt{r}, \texttt{data-arredondada})$}
\na{$\texttt{atraso} \mget \texttt{data-de-criação} - \texttt{data-corrente}$}
\na{\naIF $\texttt{atraso} > 0$ \naTHEN $\textsc{Esperar}(\texttt{atraso})$}
\na{$\texttt{data-curta} \mget \texttt{data-de-criação}$}
\na{$\texttt{s} \mget \texttt{r}$}
\naBEGIN{\naWHILE $\texttt{última-data-para-sufixo} < \texttt{data-curta}$ \naDO}
\na{$\texttt{s} \mget 10 * \texttt{s}$}
\na{\naIF $\texttt{s} = 10$ \naTHEN $\texttt{s} \mget 60$}
\na{$\texttt{t} \mget \texttt{data-curta}$}
\na{\naIF $\texttt{s} > 60$ \naTHEN \naBREAK}
\naENDN{1}{$\texttt{data-curta} \mget \texttt{s} * \textsc{Int}(\texttt{data-de-criação}/\texttt{s})$}
\na{$\texttt{data-para-sufixo} \mget \texttt{t}$}
\na{$\texttt{última-data-para-sufixo} \mget \texttt{t}$}
\end{nicealgo}

A variável global \texttt{última-data-para-sufixo} tem o papel de uma memória que preserva o último valor de \texttt{data-para-sufixo} a ser reaproveitado na criação do próximo sufixo. Caso a variável \texttt{última-data-para-sufixo} não exista (por exemplo, na primeira solicitação de identificação), seu valor será escolhido igual à data corrente arredondada em $r$ segundos (\texttt{data-arredondada}), menos a granularidade corrente $r$ (Linhas 2 e 3).

A variável global \texttt{r} define a granularidade temporal a ser usada na criação do sufixo. Seu valor pode ser $60$ (para a granularidade de um minuto), $1$ (para segundo) ou $0,1$ (para décimo de segundos), $0,01$(para centésimo de segundos), $0,001$ (para milésimo de segundos), ...

O valor de \texttt{r} pode ser alterado externamente ao algoritmo, de forma a atender novas condições de uso do \textbf{subsistema de identificação}.

Na Linha 1, a \texttt{data-corrente} é arredondada em $r$ segundos por meio da rotina \textsc{Int} que retorna a parte inteira do valor racional do seu argumento.

A Linha 4 serve para reformatar o valor da variável \texttt{última-data-para-sufixo}, caso tenha havido uma mudança no valor da granularidade $r$ entre duas criações sucessivas de sufixo.

Na Linha 5, a \texttt{data-de-criação} é calculada por meio da rotina \textsc{Max} que retorna o maior do seus dois argumentos. Essa variável auxiliar corresponde à data $t'_i$. Para essa data ser a data de criação do sufixo, uma temporização é introduzida na Linha 7, por meio da rotina \textsc{Esperar} que espera pelo tempo especificado na variável \texttt{atraso}, toda vez que a \texttt{data-de-criação} calculada for maior que a \texttt{data-corrente}.

As Linhas 8 a 16 servem para o cálculo da saída \texttt{data-para-sufixo} que pode ser uma data menor que a \texttt{data-de-criação} caso uma versão mais ``curta'' dessa data seja compatível com a \texttt{última-data-para-sufixo}.

\chapter{Regras de construção do rótulo com base no IP}

No \textbf{sistema de identificação em dois níveis} apresentado neste capítulo, o \textbf{identificador de um item} é opaco, construido com base no IP, e chamado \textbf{IBIp daquele item}.

No \textbf{IBIp de um item}, o prefixo e o sufixo são também separados por \verb!"/"!.

Como anunciado, o prefixo é construido a partir da informação de um IP de computador e eventualmente de um número de porta. Quanto ao sufixo, este é construido a partir de uma informação de data e hora como no capítulo anterior. A opacidade é obtida codificando estas informações.

A concatenação do prefixo e do sufixo são reconhecível no Exemplo \ref{example:IP} do Capítulo \ref{chap:descricao}, onde o \textbf{IBIp do item} era:

	\begin{center}\texttt{8JMKD3MGP8W/34PGRBS}\end{center}

A Tabela \ref{table:regrasparaibip} contém as regras para a formação do \textbf{IBIp de um item}.

%\clearpage

\begin{table}[h]
\renewcommand{\baselinestretch}{0.9}
\small

\caption{Regras definindo a formação do \textbf{IBIp de um item}}
\label{table:regrasparaibip}
\begin{tabular}{rcl}

% 0 1 I O V Y Z are not used

\verb!IBIp!		& \verb!=!	& \verb!palavra "/" palavra! \\
						&			& \verb!     ; ex: 8JMKD3MGP7W/385N5PE! \\

\verb!palavra!			& \verb!=!	& \verb!1*ALFANUM; ex: 385N5PE! \\

\verb!ALFANUM!			& \verb!=!	& \verb!ALFA | DÍGITO! \\

\verb!ALFA!				& \verb!=!	& \verb!ALFAMI | ALFAMA! \\

\verb!ALFAMI!			& \verb!=!	& \verb!"a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" |! \\
						&			& \verb!"j" | "k" | "l" | "m" | "n" | "p" | "q" | "r" |! \\
						&			& \verb!"s" | "t" | "u" | "w" | "x"! \\

\verb!ALFAMA!			& \verb!=!	& \verb!"A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" |! \\
						&			& \verb!"J" | "K" | "L" | "M" | "N" | "P" | "Q" | "R" |! \\
						&			& \verb!"S" | "T" | "U" | "W" | "X"! \\
                 
\verb!DÍGITO!			& \verb!=!	& \verb!"2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"! \\

\end{tabular}

\renewcommand{\baselinestretch}{1}
\normalsize
\end{table}

Pela Tabela \ref{table:regrasparaibip}, observa-se que os caracteres \verb!"0"!, \verb!"O"!, \verb!"1"!, \verb!"I"!, \verb!"V"!, \verb!"Y"! e \verb!"Z"! foram excluidos. Os cinco primeiros para eliminar possíveis dúvidas na leitura desses caracteres quando se faz uso de certos fontes. Os dois últimos foram reservados caso se faz necessário definir no futuro um sistema de identificação sensível a maiúscula e minúscula.

Como no caso do \textbf{nome do repositório uniforme de um item} do capítulo anterior, o \textbf{IBIp de um item} é insensível a maiúscula e minúscula. Assim \texttt{8JMKD3MGP8W/34PGRBS} e \texttt{8jmkd3mgp8w/34pgrbs} são equivalentes. Na prática, recomenda-se utilizar apenas lettras maiúsculas na geração do \textbf{rótulo}.

Além das regras sintáticas da Tabela \ref{table:regrasparaibip}, um \textbf{IBIp de um item} deve verificar as regras semânticas definidas por meio dos Algoritmos \ref{algorithm:montarprefixodoibipdeumitem}, \ref{algorithm:montarsufixodoibipdeumitem} e \ref{algorithm:montaribipdeumitem}. Por sua vez, por construção, o Algoritmo \ref{algorithm:montaribipdeumitem} gera um \textbf{rótulo} que verifica as regras sintáticas da Tabela \ref{table:regrasparaibip}.

O Algoritmo \ref{algorithm:montarprefixodoibipdeumitem}, é a descrição do \textbf{gerador de rótulo} denotado $a$ na Figura~\ref{fig:sistemaidentificacao} e utilizado pelo \textbf{sistema de identificação} $f$ para a identificação dos \textbf{subsistemas de identificação}.

O Algoritmo \ref{algorithm:montarsufixodoibipdeumitem}, é a descrição do \textbf{gerador de rótulo} denotado $b$ na Figura~\ref{fig:sistemaidentificacao} e utilizado por qualquer \textbf{subsistema de identificação}.

O Algoritmo \ref{algorithm:montaribipdeumitem} é a descrição do \textbf{gerador de rótulo} denotado $c$ na Figura~\ref{fig:sistemaidentificacao} e utilizado pelo \textbf{sistema para geração de IBI} $s$.

	
\clearpage

\begin{nicealgo}{algorithm:montarprefixodoibipdeumitem}
\naTITLE{\textsc{MontarPrefixoDoIBIpDeUmItem}.}
\naPREAMBLE
\naINPUT{\textnormal{\texttt{IP}} \textnormal{(}cadeia de caracteres representando o IP do computador que hospeda o servidor responsável pelo subsistema de identificação\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{porta}} \textnormal{(}inteiro decimal representando o número da porta de acesso ao o servidor responsável pelo subsistema de identificação\textnormal{)}.}
\naOUTPUT{\textnormal{\texttt{prefixo}} \textnormal{(}cadeia de caracteres\textnormal{)}.}
\naGLOBAL{\textnormal{\texttt{decim-para-IBIp}} \textnormal{(}Tabela \ref{table:decimalparaibip} de conversão de decimal para IBIp\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{decim-para-IPv4}} \textnormal{(}Tabela \ref{table:decimalparaipv4} de conversão de decimal para IPv4\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{decim-para-IPv6}} \textnormal{(}Tabela \ref{table:decimalparaipv6} de conversão de decimal para IPv6\textnormal{)}.}
\naAUX{\textnormal{\texttt{IP-codif-decim}} \textnormal{(}inteiro decimal\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{IP-codif}} \textnormal{(}cadeia de caracteres\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{porta-codificada}} \textnormal{(}cadeia de caracteres\textnormal{)}.}

\naBODY
\naBEGIN{\naIF $\texttt{porta} = 800$ \naTHEN}
\naENDN{1}{$\texttt{porta-codificada} \mget \texttt{\textquotedbl\textquotedbl}$}
\naBEGIN{\naELSE}
\naENDN{1}{$\texttt{porta-codificada} \mget \textsc{ConverterDeDecimal}(\texttt{porta}, \texttt{decim-para-IBIp})$}
\naBEGIN{\naIF $\texttt{\textquotedbl.\textquotedbl} \in \texttt{IP}$ \naTHEN}
\na{$\texttt{IP-codif-decim} \mget \textsc{ConverterParaDecimal}(\texttt{IP}, \texttt{decim-para-IPv4})$}
\na{$\texttt{IP-codif} \mget \textsc{ConverterDeDecimal}(\texttt{IP-codif-decim}, \texttt{decim-para-IBIp})$}
\naENDN{1}{$\texttt{prefixo} \mget \textsc{Concatenar}(\texttt{IP-codif}, \texttt{\textquotedbl W\textquotedbl}, \texttt{porta-codificada})$}
\naBEGIN{\naELSE}
\na{$\texttt{IP-codif-decim} \mget \textsc{ConverterParaDecimal}(\texttt{IP}, \texttt{decim-para-IPv6})$}
\na{$\texttt{IP-codif} \mget \textsc{ConverterDeDecimal}(\texttt{IP-codif-decim}, \texttt{decim-para-IBIp})$}
\naENDN{1}{$\texttt{prefixo} \mget \textsc{Concatenar}(\texttt{IP-codif}, \texttt{\textquotedbl X\textquotedbl}, \texttt{porta-codificada})$}
\end{nicealgo}

\clearpage

\begin{nicealgo}{algorithm:montarsufixodoibipdeumitem}
\naTITLE{\textsc{MontarSufixoDoIBIpDeUmItem}.}
\naPREAMBLE
% \naINPUT{\textnormal{\texttt{data-para-sufixo}} \textnormal{(}racional decimal produzido pelo distribuidor temporal e usado na geração do rótulo corrente -- sufixo corrente\textnormal{)},}
% \naINPUT{\textnormal{\texttt{data}} \textnormal{(}racional decimal produzido pelo distribuidor temporal e usado na geração do rótulo corrente -- sufixo corrente\textnormal{)},}
\naINPUT{\textnormal{\texttt{data}} \textnormal{(}racional decimal obtido em saída do Algorítmo~\ref{algorithm:criardataparamontarsufixodoibideumitem}: \textsc{CriarDataParaMontarSufixoDoIBIDeUmItem}\textnormal{)},}
\naOUTPUT{\textnormal{\texttt{sufixo}} \textnormal{(}cadeia de caracteres\textnormal{)}.}
\naGLOBAL{\textnormal{\texttt{decim-para-IBIp}} \textnormal{(}Tabela \ref{table:decimalparaibip} de conversão de decimal para IBIp\textnormal{)}.}
\naAUX{\textnormal{\texttt{parte-inteira}} \textnormal{(}inteiro decimal\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{segundo}} \textnormal{(}inteiro decimal\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{fração}} \textnormal{(}inteiro decimal\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{fração-codificada}} \textnormal{(}cadeia de caracteres\textnormal{)}.}

\naBODY
% \na{$\texttt{parte-inteira} \mget \textsc{Int}(\texttt{data-para-sufixo})$}
\na{$\texttt{parte-inteira} \mget \textsc{Int}(\texttt{data})$}
\na{$\texttt{segundo} \mget \texttt{parte-inteira} - 807235200$}
\na{$\texttt{fração} \mget \texttt{data} - \texttt{parte-inteira}$}
\na{$\texttt{sufixo} \mget \textsc{ConverterDeDecimal}(\texttt{segundo}, \texttt{decim-para-IBIp})$}
\naBEGIN{\naIF $\texttt{fração} \neq 0$ \naTHEN}
\na{$\texttt{fração-codificada} \mget \textsc{ConverterDeDecimal}(\texttt{fração}, \texttt{decim-para-IBIp})$}
\naENDN{1}{$\texttt{sufixo} \mget \textsc{Concatenar}(\texttt{sufixo}, \texttt{\textquotedbl W\textquotedbl}, \texttt{fração-codificada})$}
\end{nicealgo}

\begin{nicealgo}{algorithm:montaribipdeumitem}
\naTITLE{\textsc{MontarIBIpDeUmItem}.}
\naPREAMBLE
% \naINPUT{\textnormal{\texttt{prefixo}} \textnormal{(}cadeia de caracteres obtida em saída do Algorítmo~\ref{algorithm:montarprefixodoibipdeumitem}: \textsc{MontarPrefixoDoIBIp\-De\-UmItem}\textnormal{)},}
% \naCONTINUE{\textnormal{\texttt{sufixo}} \textnormal{(}cadeia de caracteres obtida em saída do Algorítmo~\ref{algorithm:montarsufixodoibipdeumitem}: \textsc{MontarSufixoDoIBIp\-De\-UmItem}\textnormal{)}.}
\naINPUT{\textnormal{\texttt{prefixo}} \textnormal{(}cadeia de caracteres obtida em saída do Algorítmo~\ref{algorithm:montarprefixodoibipdeumitem}: \textsc{MontarPrefixoDoIBIpDeUmItem}\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{sufixo}} \textnormal{(}cadeia de caracteres obtida em saída do Algorítmo~\ref{algorithm:montarsufixodoibipdeumitem}: \textsc{MontarSufixoDoIBIpDeUmItem}\textnormal{)}.}
\naOUTPUT{\textnormal{\texttt{IBIp}} \textnormal{(}IBIp de um item\textnormal{)}.}
\naBODY
\na{$\texttt{IBIp} \mget \textsc{Concatenar}(\texttt{prefixo}, \texttt{\textquotedbl/\textquotedbl}, \texttt{sufixo})$}
\end{nicealgo}

Os algoritmos apresentados acima usam as segintes rotinas.

A rotina \textsc{ConverterParaDecimal} converte, de um determinado sistema de numeração para o sistema de numeração decimal, a cadeia de caracteres, informada no primeiro argumento, em um número inteiro decimal, conforme à tabela informada no segundo argumento. Esta conversão utiliza a tabela inversa da tabela informada.

Alguns exemplos de utilização da rotina \textsc{ConverterParaDecimal} são apresentados na Tabela~\ref{table:exemplosconverterparadecimal}.

\begin{table}
	\renewcommand{\baselinestretch}{1.2}
	\small
	\centering
	\caption{Exemplos de conversão utilizando a rotina \textsc{ConverterParaDecimal}}
	\label{table:exemplosconverterparadecimal}
	\begin{tabular}{ccc}
		\multicolumn{1}{c}{IP}	& \multicolumn{1}{c}{tabela} & \multicolumn{1}{c}{saída} \\
		\hline
%		150.163.2.14 & \texttt{decim-para-IPv4} & 417173132413 \\
		150.163.2.174 & \texttt{decim-para-IPv4} & 4588904456580 \\
		2001:252:0:1::2008:6 & \texttt{decim-para-IPv6} & 478239719325051908572237 \\
		\hline
	\end{tabular}
\end{table}

A rotina \textsc{ConverterDeDecimal} converte, do sistema de numeração decimal para um outro sistema de numeração, o número inteiro decimal, informado no primeiro argumento, em uma cadeia de caracteres, conforme à tabela informada no segundo argumento.

Alguns exemplos de utilização da rotina \textsc{ConverterDeDecimal} são apresentados na Tabela~\ref{table:exemplosconverterdedecimal}

\begin{table}[h]
	\renewcommand{\baselinestretch}{1.2}
	\small
	\centering
	\caption{Exemplos de conversão utilizando a rotina \textsc{ConverterDeDecimal}}
	\label{table:exemplosconverterdedecimal}
	\begin{tabular}{ccc}
		\multicolumn{1}{c}{decimal}	& \multicolumn{1}{c}{tabela} & \multicolumn{1}{c}{saída} \\
		\hline
		1 & \texttt{decim-para-IBIp} & 3 \\
		19050 & \texttt{decim-para-IBIp} & U5H \\
		480992662 & \texttt{decim-para-IBIp} & 38G3TS3 \\
		4588904456580 & \texttt{decim-para-IBIp} & J8LNKAN8P \\
		478239719325051908572237 & \texttt{decim-para-IBIp} & 7URMDHLL9SSN2D89M \\
%		3336097639895921915123445883928058 & \texttt{decim-para-IBIp} & 5UTMTS6QTGBR4DEK58HSPAQ8 \\
		\hline
	\end{tabular}
\end{table}

A entrada do Algoritmo \ref{algorithm:montarprefixodoibipdeumitem} é a mesma que do Algoritmo \ref{algorithm:montarprefixodonomederepositoriodeumitem}.

Nas Linhas 1 a 4 do Algoritmo~\ref{algorithm:montarprefixodoibipdeumitem}, testa-se se o número de porta é 800, nesse caso não há conversão desse número e usa-se uma cadeia vazia, caso contrário o número de porta é codificado usando a Tabela \ref{table:decimalparaibip}.

Diferentemente do capítulo anterior, não se considera o número de porta 80, porque pode existir mais de um computador virtual (\textsl{virtual host}) usando a mesma porta 80. Em testes desta norma para um sistema de identificação, foram utilizados números de porta como 800 e 802, para o acesso aos scripts que implementam os \textbf{geradores de rótulo} utilizados pelos \textbf{sistemas de identificação em dois níveis} hospedados em computadores virtuais distintos, mas dentro um mesmo computador real, portanto, associado ao mesmo IP. Para o caso em que existe apenas um único computador virtual, foi adotado o número de porta 800. Desta forma, toda vez que se utiliza o número de porta 800, o prefixo do \textbf{IBIp de um item} torna-se mais curto.

Na Linha 5 do Algoritmo~\ref{algorithm:montarprefixodoibipdeumitem} testa-se o tipo de IP. Caso o IP for do tipo IPv4, Linha 8, na concatenação utiliza-se o caractere \texttt{\textquotedbl W\textquotedbl} para separar o IP codificado, do número de porta codificado. Caso o IP for do tipo IPv6, na Linha 12 utiliza-se o caractere \texttt{\textquotedbl X\textquotedbl} para esse propósito.

Como os caracteres \texttt{\textquotedbl W\textquotedbl} e \texttt{\textquotedbl X\textquotedbl} não fazem parte dos grafemas da Tabela~\ref{table:decimalparaibip} é possível, caso seja necessário, decodificar o prefixo do \textbf{IBIp de um item}.

Para codificar um IP, considera-se que seu valor representa um número dentro de um determinado sistema de numeração. A codificação, consiste então em converter a representação no sistema original para uma nova representação num outro sistema de numeração, denotado aqui IBIp. Como existem dois tipos de IP: IPv4 e IPv6, considera-se dois sistemas de numeração originais, denotados, respectivamente, IPv4 e IPv6.

A conversão de um IP de um desse dois sistemas de numeração para o sistema IBIp, é feita no Algoritmo~\ref{algorithm:montarprefixodoibipdeumitem}, recorrendo a sua representação no sistema decimal.

Assim, para converter uma representação no sistema IPv4 (respectivamente, IPv6) para sua representação no sistema IBIp, é feito primeiro a conversão da representação no sistema IPv4 (respectivamente, IPv6) para sua representação no sistema decimal com base na tabela inversa da Tabela~\ref{table:decimalparaipv4} (respectivamente, \ref{table:decimalparaipv6}) e em seguida a conversão da sua representação no sistema decimal para sua representação no sistema IBIp com base na Tabela~\ref{table:decimalparaibip}.

A entrada do Algoritmo \ref{algorithm:montarsufixodoibipdeumitem} é a mesma que do Algoritmo \ref{algorithm:montarsufixodonomederepositoriodeumitem}.

Na Linha 2, o Algoritmo \ref{algorithm:montarsufixodoibipdeumitem} calcula a diferença em segundos entre a variável \texttt{parte-inteira} e a constante: 807235200. Esta constante é o número de segundos (em \textsl{Unix time}) corresponde à data 19950801T000000Z (data no formato ISO 8601) de início do mês durante o qual ocorreu a geração do primeiro \textbf{rótulo}, seguindo esta norma. Esse modo operante, permite gerar \textbf{rótulos} mais curtos, desde que obtidos como resultado da conversão de números menores.

Na linha 7, utiliza-se o caractere \texttt{\textquotedbl W\textquotedbl} para separar a parte inteira codificada da parte fracionária codificada. Como o caractere \texttt{\textquotedbl W\textquotedbl} não faz parte dos grafemas da Tabela~\ref{table:decimalparaibip} é possível, caso seja necessário, decodificar o sufixo do \textbf{IBIp de um item}.


\begin{table}
	\renewcommand{\baselinestretch}{1.2}
	\small
	\centering
	\caption{Tabela de conversão de decimal para IPv4}
	\label{table:decimalparaipv4}
	\begin{tabular}{rc}
		\multicolumn{1}{c}{decimal}	& \multicolumn{1}{c}{IPv4} \\
		\hline
		 0\hspace{5mm}	&	0	\\
		 1\hspace{5mm} 	&	1   \\
		 2\hspace{5mm}	&	2	\\
		 3\hspace{5mm} 	&	3   \\
		 4\hspace{5mm}	& 	4   \\
		 5\hspace{5mm} 	&	5   \\
		 6\hspace{5mm}	& 	6   \\
		 7\hspace{5mm}	& 	7   \\
		 8\hspace{5mm}	& 	8   \\
		 9\hspace{5mm}	& 	9   \\
		10\hspace{5mm}	& 	.   \\
		\hline
	\end{tabular}
\end{table}

\begin{table}
	\renewcommand{\baselinestretch}{1.2}
	\small
	\centering
	\caption{Tabela de conversão de decimal para IPv6}
	\label{table:decimalparaipv6}
	\begin{tabular}{rc}
		\multicolumn{1}{c}{decimal}	& \multicolumn{1}{c}{IPv6} \\
		\hline
		 0\hspace{5mm}	&	0  \\
		 1\hspace{5mm}	& 	1  \\
		 2\hspace{5mm}	&	2  \\
		 3\hspace{5mm}	& 	3  \\
		 4\hspace{5mm}	&	4  \\
		 5\hspace{5mm}	&	5  \\
		 6\hspace{5mm}	&	6  \\
		 7\hspace{5mm}	&	7  \\
		 8\hspace{5mm}	&	8  \\
		 9\hspace{5mm}	&	9  \\
		10\hspace{5mm}	&	a  \\
		11\hspace{5mm}	&	b  \\
		12\hspace{5mm}	&	c  \\
		13\hspace{5mm}	&	d  \\
		14\hspace{5mm}	&	e  \\
		15\hspace{5mm}	&	f  \\
		16\hspace{5mm}	&	:  \\
		\hline
	\end{tabular}
\end{table}

\begin{table}
	\renewcommand{\baselinestretch}{1.2}
	\small
	\centering
	\caption{Tabela de conversão de decimal para IBIp}
	\label{table:decimalparaibip}
	\begin{tabular}{rc}
		\multicolumn{1}{c}{decimal}	& \multicolumn{1}{c}{IBIp} \\
		\hline
		 0\hspace{5mm}	&	2  \\
		 1\hspace{5mm}	& 	3  \\
		 2\hspace{5mm}	&	4  \\
		 3\hspace{5mm}	& 	5  \\
		 4\hspace{5mm}	&   6  \\
		 5\hspace{5mm}	&   7  \\
		 6\hspace{5mm}	&   8  \\
		 7\hspace{5mm}	&   9  \\
		 8\hspace{5mm}	& 	A  \\
		 9\hspace{5mm}	&	B  \\
		10\hspace{5mm}	&   C  \\
		11\hspace{5mm}	&   D  \\
		12\hspace{5mm}	&   E  \\
		13\hspace{5mm}	&   F  \\
		14\hspace{5mm}	&   G  \\
		15\hspace{5mm}	&   H  \\
		16\hspace{5mm}	&  	J  \\
		17\hspace{5mm}	&  	K  \\
		18\hspace{5mm}	&  	L  \\
		19\hspace{5mm}	&  	M  \\
		20\hspace{5mm}	&  	N  \\
		21\hspace{5mm}	&  	P  \\
		22\hspace{5mm}	&  	Q  \\
		23\hspace{5mm}	&  	R  \\
		24\hspace{5mm}	&  	S  \\
		25\hspace{5mm}	&  	T  \\
		26\hspace{5mm}	&  	U  \\
		\hline
	\end{tabular}
\end{table}

\clearpage

\bibliography{./reference}
\hypertarget{references}{}
    
\inicioApendice
%\include{./docs/apendice1} %% insira apendices tal qual capítulos acima

%\hypertarget{estilo:apendice1}{} %% uso para este Guia
%Este apêndice foi criado apenas para indicar como construir um apêndice no estilo, não existia no original da tese.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{APÊNDICE A - DEFINIÇÃO DE FIBRA}
\label{apendiceA}

Sejam $X$ e $Y$ dois conjuntos não vazios, e $f$ uma função de $X$ em $Y$.

A \textsl{imagem de um subconjunto $A$ de $X$ através de $f$}, é o subconjunto de $Y$ denotado por $f(A)$ e dado por:
	\begin{equation*}
		f(A) \triangleq \{f(x): x \in A\}, \qquad  \text{para todo $A \subset X$}.
	\end{equation*}	
A \textsl{imagem inversa de um subconjunto $B$ de $Y$ através de $f$}, é o subconjunto de $X$ denotado por $f^{-1}(B)$ e dado por:
	\begin{equation*}
		f^{-1}(B) \triangleq \{x \in X : f(x) \in B\}, \qquad  \text{para todo $B \subset Y$}.
	\end{equation*}
A \textsl{fibra de $y$ através de $f$} é o subconjunto de $X$ denotado por $f^*(y)$ e dado por:
	\begin{equation*}
		f^*(y) \triangleq f^{-1}(\{y\}), \qquad  \text{para todo $y \in f(X)$}.
	\end{equation*}
