Discussion :

[Zec Merquise]

Salut,

Bon, je vais essayer d'être le plus clair possible...

J'ai un InputStream, je lis admettons 512 octets dessus.
Si je reprends cet InputStream dans une méthode, le flux aura 512 octets en moins ?

Exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
		byte[] buffer = new byte[512];
 
		int bytesRead = 0;
 
		while(bytesRead < 512) 
		{
			int bytes = is.read(buffer, bytesRead, 512 - bytesRead);
 
			if(bytes == -1)
			{
				break;
			}
 
			bytesRead+= bytes;
		}

Ensuite:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

truc = new Truc(is);

Donc là je récupère alors le InputStream - 512 octets du début, c'est ça ?

[le y@m's]

Si tu connaît à l'avance le nombre d'octets que tu doit lire, il n'y a aucune raison que tu face une boucle pour récupérer ton flux.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
byte[] data = new byte[512];
is.read(data);

suffit.

Attention quand même, si le nombre d'octets à lire est très grand il vaut mieux récupérer le flux en plusieurs fois.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
int sizeMax = 2048;
byte[] data = new byte[sizeMax];
int nbData;
while((nbData = is.available()) > 0)
{
     is.read(data, 0, ((nbData > sizeMax) ? sizeMax : nbData));
 
     //  traitement des octets reçus
}

[Zec Merquise]

Ouais, mais ça réponds pas à ma question, ou alors j'ai rien compris...

Je vais expliquer l'utilisation de mon programme:

je reçois un InputStream représentant un flux RSS, j'extrait le début du fichier pour le stocker dans une String, ensuite j'analyse le contenu de cette String pour déterminer la version de RSS utilisée.

Ensuite j'appelle un parser en fonction de la version utilisée (par exemple RSS_1_0 pour la version 1.0).

Le problème c'est que là il va me manquer le début du flux, c'est à dire les octets déja lus.

Donc en gros ma question c'est de savoir s'il y a pas un moyen plus propre que de re-récuperer le InputStream avec "new FileInputStream(File(path))", par exemple.

[Zec Merquise]

Bon, je récapitule.
Voilà mon code actuel:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
public static RSSParser getParser(String path)
	throws NullPointerException, FileNotFoundException, IOException, ParsingException
	{
		InputStream is;
		InputStream in;
		RSSParser rss = null;
 
		if(path.startsWith("http://"))
		{
			URL url = new URL(path);
 
			is = url.openStream();	
			// Solution pas trés propre
			in = url.openStream();		
		}
		else
		{
			is = new FileInputStream(new File(path));
			// Solution pas trés propre
			in = new FileInputStream(new File(path));
		}
 
		// Get the beginning of the stream to determine the RSS version used
		byte[] buffer = new byte[512];
 
		int bytesRead = 0;
 
		while(bytesRead < 512) 
		{
			int bytes = in.read(buffer, bytesRead, 512 - bytesRead);
 
			if(bytes == -1)
			{
				break;
			}
 
			bytesRead+= bytes;
		}
 
		String content = new String(buffer);
 
		if(content.contains("xmlns=\"http://purl.org/rss/1.0/\""))
		{
			rss = new RSS_1_0(is);
		}		
		else if(content.contains("version=\"0.90\"") || content.contains("version=\"0.91\"") || content.contains("version=\"0.92\"") || content.contains("version=\"0.93\""))
		{
			rss = new RSS_0_9(is);
		}
		else if(content.contains("rss version=\"2.0\""))
		{
			rss = new RSS_2_0(is);
		}
 
		return rss;
	}

Maintenant j'aimerais savoir s'il y'a moyen de ne pas avoir deux InputStream (is et in) ?
Parce que là si je prends qu'un seul InputStream pour déterminer la version ET pour le constructeur du parser, ben le parser ne recevra pas le début du InputStream.

Une idée ?

PS: j'ai testé avec

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
byte[] buffer = new byte[512];
		is.read(buffer, 0, buffer.length);

et ça marche pas, en revanche avec ma boucle ça marche. Une idée du pourquoi du comment ?

[bouye]

Si tu connaît à l'avance le nombre d'octets que tu doit lire, il n'y a aucune raison que tu face une boucle pour récupérer ton flux.

Tss, il n'y a absolument aucune garantie que le tableau sera completement rempli en une seule fois.

The number of bytes actually read is returned as an integer.
...
An attempt is made to read as many as len bytes, but a smaller number may be read.

Bien sur une raison simple evidente est que le fichier en question contient moins de donnees que prevu... mais la doc est volontairement dans le flou sur les raisons du pourquoi la valeur de retour peut etre plus petite que prevue.

Ex : du au fait que quand tu as des instances concretes/especes de flux qui sont treeeeees lent (et/ou mal foutus), tu peux eventuellement avoir un timout qui se declenche durant la periode d'attente du remplissage. Comme ce n'est pas une erreur (pas de fin de flux, pas d'erreur de lecture et pas de rupture de connexion), il n'y a donc pas d'exception de lancee mais la methode retourne sans avoir lu la taille escomptee.

D'ou l'interet dans les algo generiques de gestion de flux de toujours bien gerer cette valeur de retour.

[le y@m's]

Merci pour la précision