% document

%\begin{comment}

\maketitle

\include{./agradecimentos} %% opcional

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% RESUMO %% obrigatório
\begin{resumo} %% insira seu resumo abaixo
\hypertarget{estilo:resumo}{}
 
%Neste relatório, são apresentadas as várias formas em que um identificador global pode vir a ser criado para identificar e prover acesso consistente e perene à diversos tipos de itens de informação (documentos, mapas, imagens, etc.) armazenados em acervos, sejam eles repositórios ou arquivos digitais. A implantação desse identificador global requer, de uma forma indireta, a infra-estrutura já existente da Internet, portanto, sem custo adicional, nesse aspecto. O identificador global pode ser utilizado em associação com o processo de armazenamento de informação em acervos. O que torna simples a criação de cópias em acervos distintos e, também, a própria migração de itens de informação entre os mesmos. As diversas aplicações de um identificador global desta natureza são de particular interesse em sistemas de dados espaciais e de informação.

Este relatório 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 outra entidade de informação. A implantação desse identificador global requer, de uma forma indireta, 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.

%Este relatório apresenta um procedimento que leva à criação de duas versões de um identificador global que se destina, em um longo prazo, de forma consistente e compacta, em identificar e fornecer um acesso conveniente a vários tipos de itens de informação (documentos, mapas, imagens, etc) que são normalmente armazenados em acervos, como os encontrados em repositórios digitais, em arquivos, ou em outro lugar. A implantação prática desse identificador global, convenientemente e essencialmente, apenas exige, sem nenhum custo adicional, a infra-estrutura já amplamente disponível da Internet. Esse identificador global pode ser usado em associação com sistemas de armazenamento de informação que lidam com coleções e que, desta forma, poderá permitir uma simplicidade marcante nos processos dedicados à criação de cópias em acervos diferentes, como também incluindo simplicidade na migração de itens de informações 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.

\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}{}
 
%In this report, are shown the various ways in which a global identifier might be created to identify and provide consistent and enduring access to various kinds of information items (documents, maps, images, etc.) stored in collections, are they digital repositories or archives. The deployment of this global identifier require, in an indirect manner, the existing infrastructure of the Internet, therefore, without no additional cost, in this regard. The global identifier can be used in combination with the process of information storage in collections. What makes it simple to create copies in different collections and also migrate information items between them. The various applications of a global identifier of this nature are of particular interest in space data and information systems.

This report 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}

\section*{Objetivo}

Este relatório contém uma proposta de um sistema de identificação que associa a cada item (de informação) a ser identificado, um rótulo gerado com base na Internet e utilizado como identificador desse item. As regras de construção de duas formas de apresentação do rótulo são estabelecidas.

A duplicação, em servidores distintos, de componentes desse sistema deve permitir que atores independentes participem do processo de identificação global.

Uma vez os items de informação identificados e depositados em servidores interligados na Internet, estes podem ser recuperados por meio de um sistema de resolução de identificação. No entanto, a descrição desse segundo sistema não faz parte deste relatório.

\section*{Justificativa}

Os hipervínculos (\textsl{hyperlinks}) ou simpelsmente vínculos ou ponteiros, elementos essenciais na navegação entre itens de informação (documentos, mapas, imagens, etc.) disponíveis na Internet, devem ter seu funcionamento preservado por longo prazo.

A solução para tornar os ponteiros persistentes passa pelo 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 fique permanente.

Uma vez escolhido um sistema de identificação e por meio dele atribuidos rótulos à itens de informação, o problema da construção de ponteiros persistentes pode ser solucionado por meio do uso de um sistema de resolução (ou resolvedor) de identificação, 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.

O sistema de identificação descrito neste relatório, apresenta-se como uma alternativa simples, quando comparada a outras soluções como aquelas usadas, por exemplo, no PURL \cite{WeibelJulShaf:2010:PeUnRe} ou no Handle System$^\circledR$ \cite{CNRI:2010:HaSyFu}. O sistema apresentado está sendo extensivamente utilizado, desde 1995, na plataforma UR{\slshape Lib}.

A principal diferença, comparado ao PURL ou ao Handle System$^\circledR$, é que, enquanto estes têm um sistema próprio de cadastro de seus usuários, o sistema proposto reaproveita indiretamente o sistema já existente de cadastro dos atores da Internet detendores de nomes de domínio (\textsl{fully qualified domain names}), portanto, sem custo adicional, nesse aspecto.


\chapter{Terminologia}
\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{subsistema 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 (ver detalhes na Definição~\ref{definition:distribuidortemporal} na Seção \ref{chap:repositoriouniforme}).

\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} (ver detalhes na Definição~\ref{definition:sistema2niveis} na Seção \ref{chap:descricao}).

\textbf{Sistema para geração de IBI}: \textbf{sistema de identificação em dois níveis} objeto deste relatório. 

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

\chapter{Descrição do sistema para geração de IBI}
\label{chap:descricao}

Neste relatório, 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 (resp., enumeráveis), e pela propriedade de \textbf{sistema de identificação} ser injetor, os conjuntos dos \textbf{itens} devem ser necessariamente finitos (resp., enumeráveis).

\begin{comment}
Considerando o \textbf{sistema de identificação} como um processo dinámico (i.e., que ocorre ao longo do tempo), a solução geral para montar uma função injetora consiste em atribuir um novo \textbf{rótulo}, obtido a partir de um \textbf{gerador de rótulo}, à cada novo \textbf{item}.

Uma solução particular consiste em utilizar como \textbf{identificador de um item}, a data e hora na qual é feita a atribuição, sendo a granularidade da data suficientemente fina para distinguir entre duas atribuições sucessivas.

As soluções anteriores, no entanto, pressupõem um \textbf{sistema de identificação} com um \textbf{gerador de rótulo} centralizado, sob a responsabilidade de um único ator, para o qual toda solicitação de geração de um novo \textbf{rótulo} deve ser encaminhada, tornando o \textbf{sistema de identificação} relativamente vulnerável.
\end{comment}

O \textbf{sistema de identificação}, objeto deste relatório, 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} como descrito detalhamente por meio da definição a seguir.

\begin{definition}[sistema de identificação em dois níveis]
	\label{definition:sistema2niveis}
	Os conjuntos e funções introduzidos a seguir são os componentes de um \textbf{sistema de identificação em dois níveis}.
	
	\renewcommand{\baselinestretch}{1.0}
	\normalsize
	
	\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}.
		
\vspace{10mm}

		\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ótulos} 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$. \qed	
\end{definition}

\vspace{10mm}

Na Definição \ref{definition:sistema2niveis}, a definição de $g(i)$ como função de $g^*(g(i))$ em $R_2$ se sustenta desde que $|g(I)| = |g^*(g(I))|$ como consequência de $g^*$ ser injetora (Proposição \ref{proposition:geradoradefibras}), ou seja, à dois elementos distintos $s_1$ e $s_2$ de $g(I)$ podem corresponder duas funções, respectivamente, com domínio $g^*(s_1)$ e $g^*(s_2)$ que serão também distintos por $g^*$ ser injetora.

Por definição, o \textbf{sistema de identificação} $f$, os \textbf{subsistemas de identificação} em $g(I)$ e o \textbf{gerador de rótulo} $c$ são funções injetoras. Essa propriedade se extende ao \textbf{sistema de identificação em dois níveis} resultante, como enunciado na proposição seguinte.

\begin{proposition}[propriedade de um sistema de identificação em dois níveis]
	\label{proposition:sistema2niveis}
	A função $s: I \rightarrow R$ da Definição \ref{definition:sistema2niveis} é injetora.
	\qed
\end{proposition}

\begin{proof}[Prova]
Para todo $i$ e $j \in I$, tem-se:

	\begin{align*}
	s(i) = s(j)	&\Leftrightarrow c(h(i)) = c(h(j))	&(\text{Def. \ref{definition:sistema2niveis} e def. de composição}) \\
				&\Rightarrow h(i) = h(j)	&(\text{$c$ é injetora}) \\
				&\Rightarrow (f(g(i)), g(i)(i)) = (f(g(j)), g(j)(j))	&(\text{Def. \ref{definition:sistema2niveis}}) \\
				&\Leftrightarrow \text{$f(g(i)) = f(g(j))$ e $g(i)(i) = g(j)(j)$}	&(\text{igualdade de pares}) \\
				&\Rightarrow \text{$g(i) = g(j)$ e $g(i)(i) = g(j)(j)$}	&(\text{$f$ é injetora}) \\
				&\Rightarrow g(i)(i) = g(i)(j)							&(\text{subsituição}) \\
				&\Rightarrow i = j.										&(\text{$g(i)$ é injetora})
	\end{align*}
	
	Isto é, $h$ é injetora.
 
\end{proof}

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$.

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 Handle System$^\circledR$, por exemplo, possui esses dois níveis de identificação. Os atores no Handle System$^\circledR$ são o \textsl{Corporation for National Research Initiatives} (CNRI) e os \textsl{Resolution Service Providers} (RSP). Na terminologia deste relatório, os RSP são os \textbf{subsistemas de identificação} e o CNRI é o \textbf{sistema de identificação} dos RSP.

No primeiro nível, o CNRI ($f$) registra os RSP e fornece, a cada um, um rótulo denominado ``prefixo''. No segundo nível, um RSP ($g(i)$) fornece, a cada \textbf{item} ($i$) sob sua responsabilidade, um rótulo denomidado ``sufixo''.

Usando a terminologia do Handle System$^\circledR$, o \textbf{identificador de um item} é a concatenação de um ``prefixo'' identificando um \textbf{subsistema de identificação} e de um ``sufixo'' identificando um \textbf{item} no escopo desse subsistema.

O \textbf{sistema para geração de IBI}, objeto deste relatório, é também um \textbf{sistema de identificação em dois níveis} cujos componentes aparecem na Figura~\ref{fig:sistemaidentificacao}.

\begin{comment}
Por esse motivo, uma solução segura deve contar com um conjunto de \textbf{subsistemas de identificação}, uma atribuição\footnote{As regras de atribuição de um \textbf{item} a um determinado \textbf{subsistema de identificação} não fazem parte do escopo do presente relatório.} prévia de cada \textbf{item} a um determinado \textbf{subsistema de identificação}, e um \textbf{sistema de identificação} dos \textbf{subsistemas de identificação}.

Em outros termos, a solução consiste em um \textbf{sistema de identificação em dois níveis}, no qual, o primeiro nível consiste em um único \textbf{sistema de identificação} responsável pela identificação dos \textbf{subsistemas de identificação}, enquanto o segundo nível consiste nesses \textbf{subsistemas de identificação} possívelmente sob a responsabilidade de atores distintos.

Num primeiro momento, cada \textbf{subsistema de identificação} (visto como objeto a ser identificado) recebe, do \textbf{sistema de identificação} do primeiro nível, um \textbf{rótulo}. Num segundo momento, cada \textbf{item} (do conjunto de itens de interesse) recebe, do \textbf{subsistema de identificação} responsável por esse \textbf{item}, um \textbf{rótulo}. A concatenação desses dois \textbf{rótulos} constitue o \textbf{identificador do item} (ver Figura~\ref{fig:sistemaidentificacao} e Definição~\ref{definition:sistema2niveis} no Apêndice~\ref{apendiceA}).
\end{comment}

\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)$.

% google: handle system prefix registration
%Please provide the following information about yourself in order for CNRI to register your request to become an RSP (Resolution Service Providers) and acquire your prefix

% Neste relatório, propostas para o \textbf{sistema de identificação dos subsistemas de identificação} $f$, e para o conjunto $g(I)$ dos \textbf{subsistemas de identificação}, são apresentadas.
 
No \textbf{sistema para geração de IBI}, o primeiro nível $f$ consiste (diferentemente do Handle System$^\circledR$) em reaproveitar a infra-estrutura já existente da Internet para identificar os \textbf{subsistemas de identificação}, portanto, sem custo adicional, nesse aspecto.

%c omputadores ligados à Internet com IP (\textsl{Internet Protocol}) pertencendo ao espaço de endereçamento público/global (isto é, não pertencendo à redes privadas)

Mais precisamente, 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 computador possuindo nome de domínio (\textsl{fully qualified domain names}). 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 espaço de endereçamento público/global sendo amplamente suficiente para o endereçamento dos \textbf{subsistemas de identificação}, as redes privadas são excluidas deste relatório, permitindo assim limitar o tamanho do \textbf{identificador de um item}.

O segundo nível $g(I)$, consiste (diferentemente do Handle System$^\circledR$) em adotar uma regra para geração do sufixo, comum a todos os \textbf{subsistemas de identificação}. Essa regra é construida com base na data e hora da associação do \textbf{item} ao \textbf{rótulo}. Essa escolha facilita o reuso de um \textbf{identificador de subsistema de identificação} quando este passa sob o controle de um novo ator.

%Com essas escolhas, o \textbf{rótulo} $s(i)$ atribuido ao \textbf{item} $i$ pelo \textbf{sistema de identificação em dois níveis} $s$ recebeu o nome de ``Identificator com Base na Internet'' ou \textbf{IBI}, e $s(i)$ é o \textbf{IBI do item} $i$.

Com essas escolhas, qualquer \textbf{rótulo} gerado pelo \textbf{sistema de identificação em dois níveis} $s$ recebeu o nome de ``Identificator com Base na Internet'' ou \textbf{IBI}, e o \textbf{rótulo} $s(i)$ atribuido ao \textbf{item} $i$ por $s$ é o \textbf{IBI do item} $i$.

% Afim de desburocratizar ainda mais o \textbf{sistema de identificação} como um todo, o sufixo, fornecido por um \textbf{subsistema de identificação}, segue (diferentemente do Handle System$^\circledR$) uma regra comum a todos os subsistemas, e é construida com base na data e hora da associação do \textbf{item} ao sufixo. Esta escolha facilita o reuso de um \textbf{identificador de subsistema de identificação} quando este passa sob o controle de um novo ator.

Na solução objeto deste relatório, 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óximas seções.

% 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}
	
	Usando, por exemplo, o resolvedor de identificação \texttt{urlib.net}, o ponteiro (URL) persistente para esse \textbf{item} ficou:
	
	\begin{center}\texttt{\href{http://urlib.net/sid.inpe.br/mtc-m18@80/2009/02.16.17.46}{http://urlib.net/sid.inpe.br/mtc-m18@80/2009/02.16.17.46}}\end{center}
	
	Adicionalemente, o ponteiro (URL) persistente para os metadados desse \textbf{item} ficou:
	
	\begin{center}\texttt{\href{http://urlib.net/sid.inpe.br/mtc-m18@80/2009/02.16.17.46??}{http://urlib.net/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}
	
	Usando, por exemplo, o resolvedor de identificação \texttt{urlib.net}, o ponteiro (URL) persistente para esse \textbf{item} ficou:
	
	\begin{center}\texttt{\href{http://urlib.net/8JMKD3MGP8W/34PGRBS}{http://urlib.net/8JMKD3MGP8W/34PGRBS}}\end{center}
	
	Adicionalemente, o ponteiro (URL) persistente para os metadados desse \textbf{item} ficou:
	
	\begin{center}\texttt{\href{http://urlib.net/8JMKD3MGP8W/34PGRBS??}{http://urlib.net/8JMKD3MGP8W/34PGRBS??}}\end{center}

	\qed
\end{example}

Observa-se que a granularidade do prefixo é extremamente fina já que os \textbf{subsistemas de identificação} são atrelados à números de porta de computador com nomes de domínio (\textsl{fully qualified domain names}). São atualmente mais de 200 milhões de nomes de domínio \cite{VeriSign:2010:InGrNe}.

Quanto a granularidade do sufixo, ela pode ser aumentada, acrescentando, por exemplo, os segundos ou ainda as frações de segundos.

Os dois tipos de \textbf{sistema para geração de IBI} 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 para geração de IBI} apresentado nesta seção, 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 de repositório uniforme}, 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 eventualemente 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 segundos.}, separados por \verb!"."!.

\end{enumerate}

Estas quatro partes são reconhecíveis no Exemplo \ref{example:nomededominio} da seção 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}

O formato do sufixo é uma adaptação da norma ISO 8601 onde os separadores foram trocados de forma a se adequar as normas próprias para caminhos em sistema de arquivos. Por exemplo, a data e hora: 16 de fevereiro de 2009 às 17 horas 46 minutos, na norma ISO 8601 fica:

\begin{center}\texttt{2009-02-16T17:46Z}\end{center}

\noindent ou ainda:

\begin{center}\texttt{20090216T1746Z}\end{center}

\noindent enquanto o sufixo fica:

\begin{center}\texttt{2009/02.16.17.46}\end{center}

No sufixo, os separadores foram escolhidos para melhorar a legibilidade do \textbf{nome do repositório uniforme de um item} e fazer com que o ano corresponde a um diretório e o resto da data a um outro.



Para definir precisamente a sintaxe do \textbf{nome do repositório uniforme de um item}, neste relatório, 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 de um \textbf{nome de repositório uniforme}.

%\clearpage

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

\caption{Regras definindo a formação de um \textbf{nome de repositório uniforme}}
\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. Por esse motivo, em todo rigor, o \textbf{sistema para geração de IBI} não aponta para um \textbf{rótulo} mas sim, para uma classe de equivalência de \textbf{rótulos}. 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}, um \textbf{nome de 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 biunívoca do \textbf{gerador de rótulo}, denotado $a$ na Figura~\ref{fig:sistemaidentificacao}, 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 biunívoca do \textbf{gerador de rótulo}, denotado $b$ na Figura~\ref{fig:sistemaidentificacao}, utilizado por qualquer \textbf{subsistema de identificação}.

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

O \textbf{sistema para geração de IBI} 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 produzido pelo distribuidor temporal e usado na geração do rótulo corrente -- sufixo corrente\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} = 0$ \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{)}.}
\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 segintes 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 dos \textbf{subsistemas de identificação} mesmo em caso de entrada/saída do horário de verão ou de troca de computadores situados em longitudes distintas.
                
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.

%A entrada \texttt{última-data} do Algoritmo \ref{algorithm:montarsufixo} é usada como uma segurança em caso de haver necessidade de um ajuste no relógio do computador. Nesse caso, o laço \textsf{\textbf{Enquanto}} nesse algorithmo, serve para garantir que o próximo \textbf{rótulo} gerado exibe sempre uma data posterior a data exibida pelo último \textbf{rótulo}, mesmo que ocorra um ajuste no relógio do computador.

%O Algoritmo \ref{algorithm:montarsufixo} tenta sempre gerar o \textbf{rótulo} mais curto possível, fazendo, quando possível, a economia da exibição dos dois dígitos representativos dos segundos. Para conseguir esse resultado, a \texttt{data-corrente} é inicialmente gerada com a granularidade do minuto (cf., Linha 1) e somente em caso de necessidade, gera-se a \texttt{data-corrente} com a granularidade do segundo (cf., Linha 5).

%O Algoritmo \ref{algorithm:montarsufixodonomederepositoriodeumitem} tenta gerar o \textbf{rótulo} (sufixo) mais curto possível, fazendo, quando possível, a economia da exibição dos dois dígitos representativos dos segundos. Para conseguir esse resultado, a \texttt{data-em-segundo-arredondada-em-minuto} é calculada (cf., Linha 1) com base no valor da \texttt{data-corrente} (primeiro elemento do par fornecido pelo \textbf{distribuidor temporal}) e caso a \texttt{última-data} (segundo elemento do par fornecido pelo \textbf{distribuidor temporal}) esteja inferior à \texttt{data-em-segundo-arredondada-em-minuto}, esta data, arredondada em minuto, prevalece, e com isto, os dois dígitos representativos dos segundos podem ser omitidos.

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

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.

%Finalmente, nas Linhas 6 a 7 do Algoritmo \ref{algorithm:montarsufixo}, espara-se um segundo antes de gerar novamente a \texttt{data-corrente} com a granularidade do segundo, para evitar o padrão \texttt{\textquotedbl00\textquotedbl} para os segundos, já que optou-se para trabalhar com duas granularidades (minuto e segundo).


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 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 por meio da definição a seguir, onde $I'$ representa o domínio $g^*(g(i))$ de um determinado \textbf{subsistema de identificação} $g(i)$.

\begin{definition}[distribuidor temporal]
	\label{definition:distribuidortemporal}
	Os conjuntos e expressões introduzidos a seguir são os componentes de um \textbf{distribuidor temporal}.
	
	\renewcommand{\baselinestretch}{1.0}
	\normalsize
	
	\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 conjunto de racionais, definindo as possíveis granularidades temporais: minuto, segundo e frações de segundos.
			
%		\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 segundos\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 \text{rótulo} utilizado na identificação do \textbf{item} $i$. Em outros termos, $t'_i$ será considerada a data de geração do \text{rótulo} do \textbf{item} $i$, enquanto $t(i)$ é data utilizada pelo 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 e $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)$.
	\qed
\end{definition}

 A Tabela~\ref{table:exemplodisttribuidortemporal} contém os dados de um exemplo de funcionamento de um \textbf{distribuidor temporal} com granularidade de 1 segundo ($r = 1$).
			
\begin{table}[ht]
	\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 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 de 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)$.

\begin{comment}

proc CreateSuffix {
	currentTimeInFractionOfSecond lastRepTimeInFractionOfSecond temporalResolution
} {
# puts [list $currentTimeInFractionOfSecond $lastRepTimeInFractionOfSecond]
# expr 1304257193.722 + 0.001
# => 1304257193.7229998
# hence, format must be used

	set roundOffCurrentTimeInFractionOfSecond [expr (entier($currentTimeInFractionOfSecond / $temporalResolution)) / (1 / $temporalResolution)]
	set lastRepTimeInFractionOfSecond [expr (entier($lastRepTimeInFractionOfSecond / $temporalResolution)) / (1 / $temporalResolution)]	;# useful because temporalResolution may have changed and its value increased (e.g., from 0.001 to 0.1)
	set numberOfFractionalDigits [expr int(log10(1 / $temporalResolution))]
# MAX
	set newRepTimeInFractionOfSecond [Max [format %.${numberOfFractionalDigits}f [expr $lastRepTimeInFractionOfSecond + $temporalResolution]] $roundOffCurrentTimeInFractionOfSecond]	;# t'
# puts $newRepTimeInFractionOfSecond	;# t'
	set delay [expr $newRepTimeInFractionOfSecond - $currentTimeInFractionOfSecond]
	set delayInMillisecond [expr entier($delay * 1000)]
# AFTER
	if {$delayInMillisecond > 0} {after $delayInMillisecond}	;# guarantees that the newRepTimeInFractionOfSecond will be the time of the IBI creation - unposting will occur after the last newRepTimeInFractionOfSecond
	set shorterNewRepTime $newRepTimeInFractionOfSecond
	set s $temporalResolution
	while {$lastRepTimeInFractionOfSecond < $shorterNewRepTime} {
# puts $s
		set s [expr $s * 10]
		if {$s == 10} {set s 60.}	;# for minute
		set timeInFractionOfSecond $shorterNewRepTime
		if {$s > 60} {break}
		set shorterNewRepTime [expr double(entier($newRepTimeInFractionOfSecond / $s)) / (1 / $s)]
	}
	if ![regexp {^(.*)(\.)(.*)$} $timeInFractionOfSecond m seconds period fractionOfSecond] {
		set seconds $timeInFractionOfSecond; set fractionOfSecond 0
	}
	set suffix [clock format $seconds -format %Y/%m.%d.%H.%M.%S -gmt 1]
	if {$fractionOfSecond == 0} {
# expr double(entier(123.0056 * 100)) / 100 returns 123.0
		regsub {\.00$} $suffix {} suffix
	} else {
		set suffix $suffix.$fractionOfSecond
	}
	
	return [list $timeInFractionOfSecond $suffix]
}

\end{comment}

\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}$}
\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 real 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 para geração de IBI} apresentado nesta seção, o \textbf{identificador de um item} é opaco, construido com base no IP, e chamado \textbf{IBIp daquele item}.

Num \textbf{IBIp}, 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 na seção 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 Seção \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 de um \textbf{IBIp}.

%\clearpage

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

\caption{Regras definindo a formação de um \textbf{IBIp}}
\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 de repositório uniforme} da seção anterior, o \textbf{IBIp} é insensível a maiúscula e minúscula. Assim \texttt{8JMKD3MGP8W/34PGRBS} e \texttt{8jmkd3mgp8w/34pgrbs} são equivalentes. Por esse motivo, em todo rigor, o \textbf{sistema para geração de IBI} não aponta para um \textbf{rótulo} mas sim, para uma classe de equivalência de \textbf{rótulos}. 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 biunívoca do \textbf{gerador de rótulo}, denotado $a$ na Figura~\ref{fig:sistemaidentificacao}, 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 biunívoca do \textbf{gerador de rótulo}, denotado $b$ na Figura~\ref{fig:sistemaidentificacao}, utilizado por qualquer \textbf{subsistema de identificação}.

O Algoritmo \ref{algorithm:montaribipdeumitem} é a descrição biunívoca do \textbf{gerador de rótulo}, denotado $c$ na Figura~\ref{fig:sistemaidentificacao}, 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{comment}
proc ConvertFromRepositorySuffix {repositorySuffix upperCaseOnly} {
	regsub -all {\.|/} $repositorySuffix {} dateTime	;# 2005/12.07.19.19 -> 200512071919
	if ![regsub {^(........)(....)$} $dateTime {\1T\200} ISODateTime] {
		regsub {(........)(......)} $dateTime {\1T\2} ISODateTime
	}
# set ISODateTime
# => 20051207T191900
	set seconds [expr [clock scan $ISODateTime -gmt 1] - [clock scan 19950801T000000 -gmt 1]]
	if {$seconds < 0} {return -code error -errorinfo {ConvertFromRepositorySuffix: repository name syntax error}}
#	set suffix2 [ConvertFromBinary [ConvertDecimalToBinary $seconds] $upperCaseOnly]
	return [ConvertFromDecimal $seconds $upperCaseOnly]	;# added by GJFB in 2010-10-27 - faster
}

proc ConvertFromRepositorySuffix {repositorySuffix upperCaseOnly separator} {
	set year [lindex [file split $repositorySuffix] 0]
	set numberOfYearDigit [string length $year]
	regsub -all {\.|/} $repositorySuffix {} dateTime	;# 2010/10.28.01.04.22 -> 20101028010422
	set fractionOfSecond 0
	if ![regsub "^(.{$numberOfYearDigit}....)(....)$" $dateTime {\1T\200} ISODateTime] {
		if [regsub "^(.{$numberOfYearDigit}....)(......)$" $dateTime {\1T\2} ISODateTime] {
		} else {
			regexp "^(.{$numberOfYearDigit}....)(......)(.+)$" $dateTime m m1 m2 m3
			set ISODateTime ${m1}T$m2
			set fractionOfSecond $m3
		}
	}
# set ISODateTime
# => 20101028T010422
	set seconds [expr [clock scan $ISODateTime -gmt 1] - [clock scan 19950801T000000 -gmt 1]]	;# 807235200 seconds
	if {$seconds < 0} {return -code error -errorinfo {ConvertFromRepositorySuffix: repository name syntax error}}
	if $fractionOfSecond {
# suffix with fraction of second
		return [ConvertFromDecimal $seconds $upperCaseOnly]$separator[ConvertFromDecimal $fractionOfSecond $upperCaseOnly]
	} else {
# suffix without fraction of second
#		set suffix2 [ConvertFromBinary [ConvertDecimalToBinary $seconds] $upperCaseOnly]
		return [ConvertFromDecimal $seconds $upperCaseOnly]	;# added by GJFB in 2010-10-27 - faster
	}
}

\begin{nicealgo}{algorithm:montarsufixodoibipdeumitem}
\naTITLE{\textsc{MontarSufixoDoIBIpDeUmItem}.}
\naPREAMBLE
\naINPUT{\textnormal{\texttt{data-corrente}} \textnormal{(}inteiro decimal representando a data, arredondada em segundo, da geração do rótulo corrente -- sufixo corrente\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{última-data}} \textnormal{(}inteiro decimal representando a data, arredondada em segundo, da geração do último rótulo -- último sufixo\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{data-em-segundo-arredondada-em-minuto}} \textnormal{(}inteiro decimal\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{segundos}} \textnormal{(}inteiro decimal\textnormal{)},}
\naCONTINUE{\textnormal{\texttt{data}} \textnormal{(}inteiro 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{segundos} \mget \texttt{data} - 807235200$}
\na{$\texttt{sufixo} \mget \textsc{ConverterDeDecimal}(\texttt{segundos}, \texttt{decim-para-IBIp})$}
\end{nicealgo}

\end{comment}

\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{)},}
\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{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{)}.}
\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 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 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 da seção 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 proposta para um sistema de identificação, foram utilizados números de porta como 800 e 802, para o acesso à dois servidores 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, na concatenação da Linha 8 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 de um \textbf{IBIp}.

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 (resp., IPv6) para sua representação no sistema IBIp, é feito primeiro a conversão da representação no sistema IPv4 (resp., IPv6) para sua representação no sistema decimal com base na tabela inversa da Tabela~\ref{table:decimalparaipv4} (resp., \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 a presente proposta de identificação. 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}


\begin{comment}
\chapter{Comparação com o Handle System® e o DOI®}

Como no Handle System®, o identificador usado na UR{\slshape Lib} possui
um prefixo e um sufixo separado por uma barra "/". No entanto,
a principal diferença reside no modo de geração do prefixo.

No sistema de identificação usado na UR{\slshape Lib}, o cadastramento dos
provedores de dados junto ao resolvedor de identificação não é
um pre-requisto para os provedores de dados começarem a trocar
dados entre si, por meio de importação de cópias e inclusão
de vínculos relativos.

Isto é possível porque no identificador usado na UR{\slshape Lib}
o cadastramento dos prefixos é herdado do próprio
funcionamento da Internet como meio de comunicação
entre atores já previamente registrados. Com isto, a
geração dos identificadores pode ser feita pelos
próprios provedores de dados, sem necessidade de prévio
cadastramento junto ao resolvedor de identificação.

Por exemplo, considerando um caso real, antes mesmo de se
registrar junto ao resolvedor de identificação, o provedor
com prefixo iconet.com.br/banon pôde importar, sem conflito
de nomes, do provedor com prefixo dpi.inpe.br/banon uma cópia
do documento identificado por dpi.inpe.br/banon/1998/08.02.08.56.

No provedor com prefixo iconet.com.br/banon, foi também possível
incluir no arquivo: iconet.com.br/banon/2003/11.21.21.08/doc/cgi/oai.tcl,
um vínculo relativo para o documento importado mencionado acima e 
contendo o arquivo doc/utilities1.tcl. Esse vínculo apresenta-se da
seguinte forma:
../../../../../../dpi.inpe.br/banon/1998/08.02.08.56/doc/utilities1.tcl.

Nesse exemplo, observa-se que, usando o identificador global usado na UR{\slshape Lib},
foi possível, sem necessidade de recorrer ao sistema de resolução
de nome, estabelecer um vínculo entre dois documentos originalmente
depositados em dois provedores distintos.

O modo de geração do sufixo também é diferente. No caso do Handle
System®, o modo de geração é livre e por conta do ator registrado
nesse sistema. No sistema de identificação usado na UR{\slshape Lib}, o modo de
geração é padrão e o mesmo para todos os atores (ver Seção 3). 
Esse último sistema é interessante, pois prevê inclusive os casos
em que um novo ator se apropria de um prefixo caído em desuso.
Naquele momento, esse novo ator não precisa tomar conhecimento
do sistema de geração dos identificadores utilizado pelo antigo ator,
nem ter o cuidado de continuar a usá-lo, basta utilizar o sistema de
geração padrão.

Finalmente, em comparação com o DOI® 3, observa-se que tanto o
DOI® quanto o identificador usado na UR{\slshape Lib} possuem múltiplos níveis
de resolução. No entanto, este último resolve também a
distinção entre um documento e suas cópias, oferecendo para o usuário
final a garantia que o documento acessado é sempre o mesmo, seja
ele uma cópia ou não.
\end{comment}

\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ÇÕES E PROPRIEDADES}
\label{apendiceA}

\begin{definition}[função]
	\label{definicao:funcao}
	Sejam $X$ e $Y$ dois conjuntos não vazios, e $F$ um subconjunto do produto cartesiano $X \times Y$. Uma \textsl{função $f$ de $X$ em $Y$} é uma tripla $(X, Y, F)$ que satisfaz os seguintes axiomas:
	
	\begin{mathenum}
		\item para todo $x \in X$, existe um $y \in Y$ tal que $(x, y) \in F$;
		\item para todo ($x_1, y_1)$ e $(x_2, y_2)$ $\in F$, $x_1 = x_2 \Rightarrow y_1 = y_2$.
	\end{mathenum}
	
	Uma função $f$ de $X$ em $Y$ é denotada por $f: X \rightarrow Y$.
	
	$X$ e $Y$ são, respectivamente, o \textsl{domínio} e \textsl{contradomínio} de $f$.
	\qed
\end{definition}

Pelo Axioma (i) da Definição \ref{definicao:funcao}, uma função $f$ associa cada elemento $x$ de $X$ à, pelo menos, um elemento $y$ de $Y$. Pelo Axioma (ii), esse elemento é único. O elemento $y$ associado à $x$ é denotado por $f(x)$ e chamado de \textsl{valor de $f$ em $x$}:

\begin{equation}
	\label{equation:valordefuncaoemx}
	f(x) \triangleq y \Leftrightarrow (x, y) \in F, \qquad  \text{para todo $x \in X$ e $y \in Y$}.
\end{equation}	

Com base nesta notação, $f$ satisfaz as seguintes propriedades decorrentes dos axiomas da Definição \ref{definicao:funcao}.

\begin{proposition}[propriedades de função]
	\label{proposition:funcao}
	Seja $f$ uma função de $X$ em $Y$, então:

	\begin{mathenum}
		\item para todo $x \in X$, existe um $y \in Y$ tal que $y = f(x)$;
		\item para todo $x_1$ e $x_2$ $\in X$, $f(x_1) \neq f(x_2) \Rightarrow x_1 \neq x_2$. 	\qed
	\end{mathenum}
	
\end{proposition}

\begin{proof}[Prova]
	Propriedade (i) decorre do Axioma (i) da Definição \ref{definicao:funcao} e da definição de $f(x)$ (Equação \ref{equation:valordefuncaoemx}). Propriedade (ii) decorre do Axioma (ii), pois, para todo $x_1$ e $x_2 \in X$:
	\begin{align*}
	\text{verdadeiro}	&\Leftrightarrow \text{$(x_1, f(x_1))$ e $(x_2, f(x_2))$} \in F	&(\text{Eq. \ref{equation:valordefuncaoemx}}) \\
						&\Rightarrow (x_1 = x_2 \Rightarrow f(x_1) = f(x_2))			&(\text{Axioma (ii) da Def. \ref{definicao:funcao}}) \\
						&\Leftrightarrow (f(x_1) \neq f(x_2) \Rightarrow x_1 \neq x_2).	&(\text{Prop. da implicação/negação})
	\end{align*}
\end{proof}

\vspace{10mm}

\begin{definition}[imagem, imagem inversa]
	\label{definicao:imagem}
	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*}
			
	\qed
\end{definition}

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*}
			
Aqui chama-se de \textsl{geradora de fibras através de $f$}, a função $f^*$ de $f(X)$ em $\mathcal{P}(X)$ (o conjunto de todas partes de $X$), dada por:

\begin{equation}
	\label{equation:geradoradefibras}
	f^* : y \mapsto f^*(y).
\end{equation}

Com base na definição de imagem inversa (Definição \ref{definicao:imagem}) e de geradora de fibras (Equação \ref{equation:geradoradefibras}), tem-se:

\begin{equation}
	\label{equation:geradoradefibras2}
	x \in f^*(y) \Leftrightarrow f(x) = y, \qquad  \text{para todo $x \in X$ e $y \in Y$};
\end{equation}
		
\begin{equation}
	\label{equation:geradoradefibras3}
	y \in f(X) \Leftrightarrow f^*(y) \neq \emptyset, \qquad  \text{para todo $y \in Y$}.
\end{equation}
		
\vspace{10mm}

\begin{proposition}[propriedade da geradora de fibras]
	\label{proposition:geradoradefibras}
	Sejam $X$ e $Y$ dois conjuntos não vazios, e $f$ uma função de $X$ em $Y$, então $f^*$ de $f(X)$ em $\mathcal{P}(X)$ é injetora.
	\qed
\end{proposition}
	
\begin{proof}[Prova]
	A função $f^*: f(X) \rightarrow \mathcal{P}(X)$ é injetora, pois, para todo $y_1$ e $y_2 \in f(X)$:
	\begin{align*}
	y_1 \neq y_2	&\Rightarrow (\text{$\forall x_1 \in f^*(y_1)$ e $\forall x_2 \in f^*(y_2)$, $f(x_1) \neq f(x_2)$})	&(\text{Eq. \ref{equation:geradoradefibras2}}) \\
					&\Rightarrow (\text{$\forall x_1 \in f^*(y_1)$ e $\forall x_2 \in f^*(y_2)$, $x_1 \neq x_2$})	&(\text{Propriedade (ii) da Prop. \ref{proposition:funcao}}) \\
					&\Leftrightarrow f^*(y_1) \cap f^*(y_2)	= \emptyset &(\text{Definição de interseção}) \\
					&\Rightarrow f^*(y_1) \neq f^*(y_2).	&(\text{Eq. \ref{equation:geradoradefibras3}})
	\end{align*}
	
	
\end{proof}