chessrecord.java

这是一个Java编写的手机象棋游戏

		try
		{
			data=contentSerialize(content);
			contentRecord.addRecord(data,0,data.length);
			//System.out.println("添加一个棋步成功");
		}
		catch (RecordStoreException re)
		{
			//errorDeal.push("ChessRecord#16", "为一条走棋记录添加走棋变化时返回走棋变化时出现存储文件操作错误");
			return false;
		}
		return true;
	}
	
	//****************重命名
	public int	renameChessRecord(String name,String newName)
	{
		int indexId=0;
		//System.out.println("indexNames的长度是:"+recordName.length);
		int	tempRecordNameId = 0;
		for(int i=0;i<recordName.length;i++)
		{
			if(name.equals(recordName[i]))
			{
				indexId=indexIds[i];
				tempRecordNameId=i;
				//System.out.println("循环中得到的indexId是:"+indexId);
				break;
			}
		}
		//System.out.println("得到的indexId是:"+indexId);
		byte[] data=null;
		Index	index = null;
		try
		{
			data=indexRecord.getRecord(indexId);
			index=indexDeserialize(data);
			index.setName(newName);
			data=indexSerialize(index);
			indexRecord.setRecord(indexId,data,0,data.length);
			recordName[tempRecordNameId] = newName;
		}
		catch(RecordStoreNotOpenException e)
		{
			//System.out.println("重命名记录时出现RecordStoreNotOpenException异常"+e);
			//errorDeal.push("ChessRecord#17", "重命名记录时打开存储文件操作错误");
			return 2;
		}
		catch(InvalidRecordIDException e)
		{
			//System.out.println("重命名记录时出现InvalidRecordIDException异常"+e);
			//errorDeal.push("ChessRecord#18", "获取需要重命名的记录时出现存储文件操作错误");
			return 3;
		}
		catch(RecordStoreException e)
		{
			//System.out.println("重命名记录时出现RecordStoreException异常"+e);
			//errorDeal.push("ChessRecord#19", "重命名记录时出现未知存储文件操作错误");
			return 4;
		}
		return 0;
	}

	//****************删除记录方法部分
	public int delAllRecord()
	{
		int flag=closeRecordStore();
		if(flag==0)
		{
			try
			{
				RecordStore.deleteRecordStore("IndexRecord");
				RecordStore.deleteRecordStore("ContentRecord");
				//System.out.println("记录全部删除成功");
			}
			catch(RecordStoreNotFoundException e)
			{
				//errorDeal.push("ChessRecord#20", "为删除所有走棋记录而打开存储文件时出现错误");
				return 3;
			}
			catch(RecordStoreException e)
			{
				//errorDeal.push("ChessRecord#21", "删除所有走棋记录时出现存储文件操作错误");
				return 4;
			}
		}
		else
			return flag;
		return 0;
	}
	public int delRecord(String name)
	{
		int indexId=0,nextId=0;
		//System.out.println("recordName的长度是:"+recordName.length);
		for(int i=0;i<recordName.length;i++)
		{
			if(name.equals(recordName[i]))
			{
				indexId=indexIds[i];
				if(i==0)
				{
					if(i==indexIds.length-1)
					{
						nextId=0;
					}
					else
					{
						if(indexIds[i+1]>indexId)
						nextId=indexIds[i+1];
						else
							nextId=0;
					}
				}
				else if(recordName.length-1==i)
				{
					if(indexIds[i-1]<indexId)
						nextId=0;
					else
						nextId=indexIds[i-1];
				}
				else
				{
					if(indexIds[i+1]>indexId)
						nextId=indexIds[i+1];
					else
						nextId=indexIds[i-1];
				}
				//System.out.println("循环中得到的indexId是:"+indexId);
				//System.out.println("循环中得到的nextId是:"+nextId);
				break;
			}
		}
		//System.out.println("得到的indexId是:"+indexId);
		Index	startIndex=null;
		Index	endIndex=null;
		try
		{
			startIndex=indexDeserialize(indexRecord.getRecord(indexId));
			//System.out.println("获取startIndex成功");
			if(nextId!=0)
				endIndex=indexDeserialize(indexRecord.getRecord(nextId));
		}
		catch(RecordStoreNotOpenException e)
		{
			//System.out.println("获取startIndex和endIndex时出现异常"+e);
			//errorDeal.push("ChessRecord#22", "删除一条走棋记录获取初始和结束ID时打开存储文件出现错误");
			return 2;
		}
		catch(InvalidRecordIDException e)
		{
			//System.out.println("获取startIndex和endIndex时出现异常"+e);
			//errorDeal.push("ChessRecord#23", "删除一条走棋记录获取初始和结束ID时出现非法ID错误");
			return 3;
		}
		catch(RecordStoreException e)
		{
			//System.out.println("获取startIndex和endIndex时出现异常");
			//errorDeal.push("ChessRecord#24", "为删除一条走棋记录获取初始和结束ID时出现未知错误");
			return 1;
		}
		int startContentId=startIndex.getNumber();
		int endContentId=0;
		if(nextId!=0)
			endContentId=endIndex.getNumber();
		try
		{
			//删除与这个index相对应的contentRecord里面的内容
			contentEnum=contentRecord.enumerateRecords(null,null,false);
			int tempRecordId=0;
			if(nextId!=0)
			{
				//System.out.println("根据nextId!=0进行删除");
				while(contentEnum.hasNextElement())
				{
					tempRecordId=contentEnum.nextRecordId();
					if(tempRecordId>=endContentId||tempRecordId<startContentId)
						continue;
					if(tempRecordId>=startContentId&&tempRecordId<endContentId)
					{
						contentRecord.deleteRecord(tempRecordId);
					}
				}
			}
			else
			{
				//System.out.println("根据nextId=0进行删除");
				while(contentEnum.hasNextElement())
				{
					tempRecordId=contentEnum.nextRecordId();
					if(tempRecordId<startContentId)
					{
						//System.out.println("小");
						continue;
					}
					else
					{
						contentRecord.deleteRecord(tempRecordId);
						//System.out.println("大");
					}
				}
			}
			//System.out.println("delRecord中删除content成功");
			//删除这个index
			//System.out.println("indexId是:"+indexId);
			indexRecord.deleteRecord(indexId);
			//System.out.println("delRecord中删除index成功");
		}
		catch(RecordStoreNotOpenException e)
		{
			//System.out.println("根据startContentId和endContentId删除记录时出现RecordStoreNotOpenException异常"+e);
			//errorDeal.push("ChessRecord#25", "根据一条走棋记录的初始和结束ID删除记录时出现打开存储文件错误");
			return 2;
		}
		catch(InvalidRecordIDException e)
		{
			//System.out.println("根据startContentId和endContentId删除记录时出现InvalidRecordIDException异常"+e);
			//errorDeal.push("ChessRecord#26", "根据一条走棋记录的初始和结束ID删除记录时出现非法ID错误");
			return 3;
		}
		catch(RecordStoreException e)
		{
			//System.out.println("根据startContentId和endContentId删除记录时出现RecordStoreException异常"+e);
			//errorDeal.push("ChessRecord#27", "根据一条走棋记录的初始和结束ID删除记录时出现未知存储文件操作错误");
			return 4;
		}
		return 0;
	}
	public int delTail()
	{
		int lastId=0;
		try
		{
			//System.out.println("开始获取最后的Id");
			lastId=contentRecord.getNextRecordID()-1;
			//System.out.println("获取最后的Id是:"+lastId);
			contentRecord.deleteRecord(lastId);
		}
		catch(RecordStoreNotOpenException e)
		{
			//errorDeal.push("ChessRecord#28", "悔棋时删除上一条记录时出现打开存储文件错误");
			return 1;
		}
		catch(InvalidRecordIDException e)
		{
			//errorDeal.push("ChessRecord#29", "悔棋时删除上一条记录时出现非法ID错误");
			return 2;
		}
		catch(RecordStoreException e)
		{
			//errorDeal.push("ChessRecord#30", "悔棋时删除上一条记录时出现未知存储文件错误");
			return 3;
		}
		return 0;
	}

	//****************关闭RecordStore
	public int closeRecordStore()
	{
		try
		{
			indexRecord.closeRecordStore();
			contentRecord.closeRecordStore();
		}
		catch(RecordStoreNotFoundException e)
		{
			//System.out.println("关闭存储文件时出现没有找到文件");
			//errorDeal.push("ChessRecord#31", "关闭存储文件时出现没有找到文件");
			return 1;
		}
		catch(RecordStoreException e)
		{
			//System.out.println("关闭存储文件时出现错误，但可能不影响使用");
			//errorDeal.push("ChessRecord#32", "关闭存储文件时出现错误，但可能不影响使用");
			return 2;
		}
		return 0;
	}
	
	//****************数据存取时的格式转换部分
	private byte[] indexSerialize(Index index)
	{
		DataOutputStream		dos=null;
		ByteArrayOutputStream	baos=null;
		try
		{
		    baos=new ByteArrayOutputStream();
			dos=new DataOutputStream(baos);
			dos.writeUTF(index.getName());
			dos.writeInt(index.getNumber());
			dos.writeUTF(index.getInitString());
			dos.flush();
			baos.flush();
		}
		catch (IOException e)
		{
			//System.out.println("序列化index时出现了异常");
			//errorDeal.push("ChessRecord#33", "序列化走棋记录时出现文件输入输出错误，会影响到正常存储");
			Alert alert=new Alert("Message","序列化走棋记录时出现文件输入输出错误，会影响到正常存储",null,AlertType.WARNING);
			Chess.dis.setCurrent(alert);
			Chess.quitApp();
		}
		return baos.toByteArray();
	}
	private Index indexDeserialize(byte[] data)
	{
		ByteArrayInputStream  bais=null;
		DataInputStream		dis=null;
		Index			index=new Index();
		try
		{
			bais=new ByteArrayInputStream(data);
			dis=new DataInputStream(bais);
			index.setName(dis.readUTF());	
			index.setNumber(dis.readInt());
			index.setInitString(dis.readUTF());
			//System.out.println("反序列化成功一个index:");
			//System.out.println(index);
		}
		catch (IOException e)
		{
			//System.out.println("反序列化index时出现了异常");
			//errorDeal.push("ChessRecord#34", "反序列化走棋记录时出现文件输入输出错误，会影响到正常存储");
			Alert alert=new Alert("Message","反序列化走棋记录时出现文件输入输出错误，会影响到正常存储",null,AlertType.WARNING);
			Chess.dis.setCurrent(alert);
			Chess.quitApp();
		}
		return index;
	}
	private byte[] contentSerialize(int content[])
	{
		DataOutputStream		dos=null;
		ByteArrayOutputStream	baos=null;
		try
		{
			baos=new ByteArrayOutputStream();
			dos=new DataOutputStream(baos);
			for(int i=0;i<4;i++)
			{
				dos.writeInt(content[i]);
			}
			dos.flush();
			baos.flush();
		}	
		catch (IOException e)
		{
			//errorDeal.push("ChessRecord#35", "序列化走棋记录时出现文件输入输出错误，会影响到正常存储");
			Alert alert=new Alert("Message","序列化走棋记录时出现文件输入输出错误，会影响到正常存储",null,AlertType.WARNING);
			Chess.dis.setCurrent(alert);
			Chess.quitApp();
		}
		return baos.toByteArray();
	}
	private int[] contentDeserialize(byte[] data)
	{
		ByteArrayInputStream  bais=null;
		DataInputStream		dis=null;
		int[]					content=new int[4];
		try
		{
			bais=new ByteArrayInputStream(data);
			dis=new DataInputStream(bais);
			for(int i=0;i<4;i++)
			{
				content[i]=dis.readInt();
			}
		}	
		catch (IOException e)
		{
			//errorDeal.push("ChessRecord#36", "反序列化走棋记录时出现文件输入输出错误，会影响到正常存储");
			Alert alert=new Alert("Message","反序列化走棋记录时出现文件输入输出错误，会影响到正常存储",null,AlertType.WARNING);
			Chess.dis.setCurrent(alert);
			Chess.quitApp();
		}
		return content;
	}
};