Sei sulla pagina 1di 12

1

VRML 2.0 con Java CAPÍTULO 24

La construcción de un
depurador de VRML en Java

Contenido CAPÍTULO 24
2

VRML 2.0 con Java CAPÍTULO 24

• Conceptos básicos
• Diseño
• Aumento de la depuración
• Uso de VermelTest
• Adición de Capacidad

Conceptos básicos

Depurar una escena de VRML es común, independientemente de si desea


utilizar un script o un applet de mirar la escena a través de su gráfico. Nos
gustaría definir el depurador de ser lo más genérica posible.
3

VRML 2.0 con Java CAPÍTULO 24

A diferencia de los otros proyectos en este libro, la construcción de un


depurador es una tarea relativamente pequeño. Que puede lograrse en una
clase Java con un poco de código. No hay necesidad de que cientos de clases
para cuidar de los tipos.

Lo que quiero hacer es crear un depurador que puede ser conectado en


cualquier lugar de la escena. Debe ser uno de esos nonintrusive trozos de
código que puede agregar a cualquier otra pieza de código y se deja correr sin
interferir. Para adaptarse a este molde, el depurador debe poder ser insertado
en cualquier punto de la scenegraph, y el código debe darle lo que existe como
los hijos de un mismo nodo.
Diseñar

Al igual que los otros proyectos en este libro, que se iniciará a partir de un
diseño muy básico y, a continuación, construir sobre ella. Para empezar, el
depurador se limitará a la impresión de sólo el tipo de nodo.

Vaya, ya he hecho otra hipótesis-que se imprime la salida. Voy a tomar un


enfoque diferente de la biblioteca utilizados en el capítulo anterior. Esta vez
voy a utilizar una cadena recta de salida en el método toString. Este enfoque
es muy útil porque usted puede obtener una copia impresa de la pantalla
utilizando sólo un único println declaración.

Para mantener la cantidad de código tan pequeño como sea posible, voy a
utilizar un sistema recursivo. El constructor se traza un nodo raíz desde el
punto de referencia, pero no hacer nada que no sea un poco de limpieza. Para
generar la salida, el método toString debe ser llamado. Esto se da luego el
nodo raíz y analizar la scenegraph recursiva utilizando llamadas a métodos
privados internos.

En el CD-ROM: El código de este capítulo se pueden encontrar en el CD-


ROM. La última versión también se puede encontrar en mi sitio Web,
http://www.vlc.com.au/VermelTrap/.

La Primera Etapa

La primera etapa del diseño, como ya he mencionado, sólo se imprime la lista


de nodos. Por supuesto, para que sea legible, es necesario que las cosas muy
bien el formato, incluyendo sangrado. Asimismo, como parte de este diseño, un
rápido analizador se pondrá en práctica, ya que nos gustaría ser capaces de
obtener los resultados lo más rápidamente posible.

Sin embargo, incluso esto llevará un poco de trabajo, desde cualquier nodo de
4

VRML 2.0 con Java CAPÍTULO 24

VRML que tenga un SF / MFNode tipo de campo se necesita tener que preguntó
sobre el terreno, utilizando el código específico de la situación (es decir, las
interfaces internas o externas). Por esta razón, no vamos a ser capaces de
crear una clase base genérica y luego extenderla a las secuencias de
comandos y la interfaz externa.

Todos mis ejemplos hasta ahora han utilizado el EAI, por lo que para este
proyecto voy a tomar un rumbo diferente y empezar con uno basado en
secuencias de comandos. Voy a extender a la EAI en una etapa posterior.
La construcción de la depuración

Primeros pasos con las reglas anteriores hace que el código bastante fácil. Es
casi un caso de la conexión de los puntos.
Lo Básico

En primer lugar, tenemos que poner juntos el esquema básico del código.
Después de la obligación de los comentarios en la parte superior del archivo,
luego importar la API de secuencias de comandos de paquetes. Después de
esto, declaramos el único en esta clase de archivos VrmlDebug. Se trata de una
clase pública.

/ / Vrml Depurador
/ / Copyright 1997 Justin Sofá justin@vlc.com.au
/ /
/ / Dado un nodo raíz Esto rastrear todos los hijos e imprimir
/ / Una versión formateada de la lista de nodos.

importación vrml .*;


importación vrml.field .*;
vrml.node.Node de importación;

clase pública VrmlDebug


(
/ / El contenido de clase está aquí.
)

Debido a que será necesario extraer los ganglios de los niños de algunos
sectores de las clases, tenemos que emitir los nodos a un nodo. BaseNode la
clase no nos permite obtener cualquiera de los campos de un nodo.

Tenemos una base que tenga un constructor de Nodo y hace una referencia
interna a la misma.

Nodo _root_node privado = null;


5

VRML 2.0 con Java CAPÍTULO 24

público VrmlDebug (Nodo root_node)


(
_root_node = root_node;
)

Luego tenemos el método ToString, además:

public String toString ()


(
return (parseNode (_root_node, ""));
)

Analizar a los niños

Ahora comienza la diversión cosas. ParseNode El método es lo que hace el


verdadero trabajo en el depurador. Es el responsable de determinar el tipo de
nodo y, a continuación, llamar al método apropiado.

Determinar el tipo de nodo que hemos comienza con una llamada al método de
GetType el nodo dado como parámetro del método. La razón para utilizar el
parámetro de nodo, en lugar de algunos de clase mundial de valor, es que el
método es el parseNode recursiva una. Si tenemos algún nodo mundial,
entonces la recursión recibirían horriblemente fuera de sincronía con gran
rapidez. Usted podría evitar los problemas de reajuste por el valor después de
haber llamado parseNode de nuevo, pero esto es sólo un extra que hay que
hacer que las cosas lentamente.

Analizar el Nombre del Nodo

Una vez que la cadena que representa el nombre del nodo se obtiene,
podemos determinar lo que es el nodo. Para analizar con mayor rapidez, quiero
evitar el mayor número de comparaciones de cadenas como sea posible. El
primer paso es romper el punto de toma de decisiones mirando el primer
carácter del nombre.

Nota: Los caracteres de inicio de índice 0 en la cadena. Recuerde comprobar


que no vas fuera de la final de la cadena. Esto no es un problema aquí, ya que
alguien puede haber declarado un proto nombre que es sólo un carácter de
largo.

Cadena parseNode privado (Nodo nodo, Cadena de guión)


(
6

VRML 2.0 con Java CAPÍTULO 24

Node_type cadena = node.getType ();


char char2;

if (node_type == null)
return (null);

intentar
(
char2 = node_type.charAt (1);
)
de capturas (StringIndexOutOfBoundsException e)
(
return (guión + "PROTO nodo:" + node_type);
)

switch (node_type.charAt (0))


(
caso 'A':
/ / Etc
)
)

Como con todos los nombres de nodo, la primera carta es una sociedad de
capital, dando lugar a un gran cambio que ha estado un caso por cada carta
que se inicia cualquier nombre de nodo.

Este switch ha desglosado la decisión en grupos de un máximo de ocho nodos


(los que comienzan con C). A partir de ese momento, los grupos de más de tres
nodos de control de la segunda carta. Este nivel de pruebas es suficiente para
determinar la real palabra.
Tratar con PROTO Nodos

Si nos dirigimos con esta prueba básica, que pronto en problemas. ¿Qué pasa
con PROTO / EXTERNPROTO tipo nodos? El método GetType devuelve la cadena
que es el nombre PROTO. El prototipo que SimpleShape camino de regreso se
desarrolló en el capítulo 3 tendría la cadena "SimpleShape" ha obtenido como
el tipo. Cuando llegamos a la transformación del nombre, podríamos considerar
erróneamente que este era uno de los incorporados en los nodos. Para evitar
este problema, que hacemos un control final. Si la cadena coincide
exactamente con el nombre de nodo de VRML, entonces el método de la clase
que se llama. Si no es así, entonces una línea que se imprime el nodo que se
declara como un PROTO y su nombre:

return (guión + "PROTO nodo:" + node_type);


7

VRML 2.0 con Java CAPÍTULO 24

No sólo se necesita comprobar en el nombre de nodo a nivel individual, sino


también en los niveles más altos, también. En caso de que sea una
comparación o switch, que incluirá un defecto que imprime el anterior PROTO
declaración.

Nota: char2 es el segundo de la cadena de caracteres que se devuelve. Para


guardar el código, siempre que obtenga el segundo personaje antes de entrar
en el interruptor principal declaración.

Una típica de nivel superior de análisis de rutina que ahora como el siguiente:

caso 'A':
switch (char2)
(
case 'n':
if (node_type.equals ( "Ancla"))
return (Ancla (nodo, guión));

case 'p':
if (node_type.equals ( "Apariencia"))
return (Apariencia (nodo, guión));

case 'u':
if (node_type.equals ( "AudioClip"))
return (AudioClip (nodo, guión));

por defecto:
return (guión + "PROTO nodo:" + node_type);
)

Excepciones a la regla

Por supuesto, si queremos crear un conjunto de normas, siempre debe haber


excepciones a los mismos. En este caso, no es realmente una excepción, sólo
algunas aclaraciones adicionales antes de saltar pulg Estas pueden resumirse
como sigue:

• Se necesitan controles adicionales antes de decidir el nombre de nodo de


los nodos a partir de C. Esto se suma a los tres niveles de anidado
declaraciones antes de hacer cambiar la decisión final.
• Los nodos a partir de P tienen el segundo control, basado en el cuarto
personaje de la cadena. Esto es así que podemos descomponer más
rápidamente el nodo nombres.
8

VRML 2.0 con Java CAPÍTULO 24

• Si bien yo trato de mantener el número de cadena, si se compara en una


escala a otra persona-sólo dos, hay un par de casos en los que esta escalera va
a tres.

Se ocupan de los nodos individuales

Después de haber decidido que el nodo dado es de un tipo particular, que


luego llame al método privado interno del mismo nombre. La mayoría de las
veces esto tiene dos argumentos, el nodo y una cadena que es la cantidad de
guión para añadir el nodo de la impresión. Todos estos métodos devolver una
cadena que representa ese nodo y ninguno de sus hijos.

Cada uno de los nodos de VRML se representa como su propio método. En


muchos casos, esto es un despilfarro, ya que sólo hay una línea de código, y
que la declaración es el regreso de la cadena. En cuanto a los objetivos de la
etapa dos, debe ser capaz de ver que la mayoría de los nodos se han expuesto
a campos de un tipo u otro. Estos deberán tener la información impresa y se
requieren métodos distintos para cada nodo. Para aquellos que todavía no
necesita otro código, podemos esperar que el compilador es bastante agresivo
para el código en línea, eliminando la sobrecarga adicional de la llamada de
método.
Viajando a través de la Scenegraph

Si se analiza sólo este nodo, no sería muy buena, porque no estamos recursing
la scenegraph. ¿Qué hay que hacer es comprobar los nodos que tienen hijos
(de cualquier nodo que tiene un SF / MFNode campo) y, a continuación,
analizar los niños. Esta es una tarea relativamente simple.

Para cada nodo que tiene hijos, recuperar el niño o los niños y, a continuación,
llamar parseNode para cada niño. Obtener el nodo para pasar a parseNode es
un proceso de dos pasos. En primer lugar, usted necesita para obtener el
exposedField en sí mismo, y entonces usted necesita para recuperar el nodo de
referencia para este ámbito:

Cadena str = + guión "ElevationGrid \ n";


Ch_node nodo;
SFNode color = (SFNode) node.getExposedField ( "color");

if (color! = null)
(
ch_node = color.getValue ();
str + = parseNode (ch_node, guión + "");
)
9

VRML 2.0 con Java CAPÍTULO 24

El código anterior sólo funciona para los campos SFNode. Si se trata de MFNode
campos, sólo una pequeña cantidad de trabajo adicional que se necesita:

Ancla de cadenas privadas (Nodo nodo, Cadena de guión)


(
int i;
int size;
Nodo [] child_list = null;
Cadena str = + guión "Ancla \ n";

MFNode niños = (MFNode) node.getExposedField ( "niños");

size = children.getSize ();


child_list = new Nodo [tamaño];

children.getValue (child_list);

for (i = 0; i <size; i + +)
str + = parseNode (child_list [i], guión + "");

return (str);
)

Tenga en cuenta que primero tenemos que antes de asignar el conjunto de


nodos antes de recuperar con una llamada a getValue.

SUGERENCIA: Una trampa que no debe caer en llamar el método es para el


niño directamente. Porque usted puede prototipo nodos, puede crear un nodo
specialiazed Apariencia como un prototipo. Al recuperar la apariencia de un
campo Forma nodo, el nodo devuelto no es un nodo de Apariencia y tal vez ni
siquiera tienen derecho los nombres de campo. Por eso es importante siempre
para llamar parseNode nodo para cada niño que necesita atención.

Limitaciones

Hay algunas limitaciones impuestas por los mismos nodos. El representante de una colisión
nodo tiene acceso sólo campo. Una vez creado, no podemos localizar a los niños de la
delegación de voto, por lo que no podemos imprimir la información.

Protos y scripts también presenta problemas. Ambos pueden contener campos arbitraria y
nombres de campo, que no podemos manejar en un sistema dinámico como este depurador.
VRML actualmente no ofrece ningún medio de obtener una lista de campos que un nodo
pueda contener. Para las secuencias de comandos y protos, esta es una limitación
especialmente frustrante.
10

VRML 2.0 con Java CAPÍTULO 24

Por ahora usted también es probablemente la razón por la que insistió en preguntarse sobre
el uso de mi propia cadena de rutinas que cada nodo tiene un método toString ya. El
problema con toString es que nadie ha decidido exactamente lo que se imprime a partir de
este nodo. RECURSE que se establecen los niños o simplemente imprimir información
acerca de ese nodo? Cada navegador puede producir una cosa diferente, por lo que el
enfoque más seguro es hacer todo nosotros mismos.
Uso de VermelTest

Pruebas y uso de la biblioteca de depuración son casi la misma cosa. Para probar el código,
es necesario utilizar la biblioteca y ver la salida.

Una vez que haya importado la biblioteca en su archivo de comandos de Java, puede
escribir un script muy simple. Todo lo que necesitas hacer es obtener el nodo de un campo
en el guión, crear una instancia de la depuración y, a continuación, imprimir los resultados a
través de System.out. El conjunto de nuestra clase de prueba tiene este aspecto:

/ / Archivo VrmlTest para el depurador


/ / Justin Sofá 1997
//

VrmlDebug de importación;
importación vrml .*;
importación vrml.field .*;
importación vrml.node .*;

clase pública se extiende VrmlTest Guión


(
SFNode raíz;

public void inicializar ()


(
root = (SFNode) getField ( "root");

VrmlDebug tester = new VrmlDebug ((Nodo) root.getValue ());

System.out.println (tester.toString ());


)
)

El archivo de VRML puede ser tan simple o tan complejo como desee. Sólo hay una
restricción: Usted necesidad de mantener toda la información que el niño de la raíz nodo
determinado. Este grupo es como la secuencia de comandos es un nodo del mundo para
rastrear.

# VRML V2.0 utf8

DEF root_node Grupo


11

VRML 2.0 con Java CAPÍTULO 24

(
# Poner su lista de nodos de aquí
)

Script
(
campo SFNode raíz USO root_node
url "VrmlTest.class"
)

El resultado de este código es que cuando empieza la escena, se imprime a la consola de


Java de la lista de nodos con root_node en la parte superior.
Adición de Capacidad

El depurador presentado hasta ahora es limitado en capacidad. Lo único que hace es


imprimir el nodo de jerarquía. Sería bueno tener algunos extras. Si han sobrevivido hasta
ahora en el libro y lo entiende todo, entonces usted debería ser capaz de añadir los extras
con el pequeño problema.

En primer lugar en la lista de los que tienen-está llena nodo impresiones. Todos los
exposedFields deben tener sus valores impresos. Tal vez te gustaría también añadir la actual
eventOut valores, también. Para ello, todo lo que necesita hacer es añadir código en los
métodos apropiados para recuperar el valor del campo y convertirlo en una cadena. La
biblioteca de la JVerge capítulo anterior hace exactamente lo mismo cuando se consulta un
nodo con sus métodos de obtener.

Tras esta acción, tal vez quiera decir que para localizar sólo a una cierta profundidad. Para
ello, es necesario añadir un argumento adicional a todos los métodos de análisis sintáctico,
entre ellos toString. En cualquier lugar que usted llame recursivamente parseNode, usted
pasa por "la profundidad - 1." En la parseNode método, que acaba de hacer un cheque por
este valor y el retorno a fondo si es cero.

Quizás otra característica útil es algún tipo de capacidad de síntesis. Usted podría crear una
lista de contadores para cada nodo como una variable de clase y el incremento adecuadas
para cada nodo que se encuentra en la transversal. Al final, todas las cifras son comparadas
y se convirtió en una cadena.

Por último, la otra cosa buena es tener un puerto de este código a la interfaz externa. Usted,
el lector ya muy experimentado, casi debería ser capaz de convertir entre código script y
código externo con los ojos cerrados! Si no es así, vuelva al sitio Web,
http://www.vlc.com.au/VermelTrap/, por las últimas revisiones.
Resumen

Bueno, nos alegra que haya llegado a la final! El depurador es el último de nuestros
proyectos para ti. Envuelve la mayoría de las características que hemos estado jugando con
todo el libro.

Esperamos que haya aprendido mucho no sólo acerca de VRML, pero también acerca de
12

VRML 2.0 con Java CAPÍTULO 24

Java y la forma de mezclar los dos. El VRML-Java combinación es muy fuerte y dará lugar
a muchos proyectos interesantes, no sólo en las páginas Web sino también en las
aplicaciones. Si decide crear algunos nifty trabajo como resultado de lo que hemos
presentado en el libro, envíanos un e-mail con su dirección URL. Nuestra web y
direcciones de correo electrónico se da en la parte delantera del libro.

Potrebbero piacerti anche