CHSLinearList.hpp

//更新日時
//2013/08/23
//2013/08/24
//2013/08/25

#ifndef _CHSLinearList_HPP_
#define _CHSLinearList_HPP_


#define  HSLinearList_DefaultFirstSerialNumber  1


//HSLinearList_Data構造体
template<typename T> struct HSLinearList_Data{
 	T Data;
	int SerialNumber;
	HSLinearList_Data *lpBack;
	HSLinearList_Data *lpNext;
};

//CHSLinearListクラス
template<typename T = int> class CHSLinearList
{

protected:
	HSLinearList_Data<T> *lpData;
	int NextSerialNumber;
	int FirstSerialNumber;
	HSLinearList_Data<T>* Alloc();
	HSLinearList_Data<T>* Scan(int Idx , bool bIdxIsSerialNumber = false);

public:
	CHSLinearList(int FirstSerialNumber = HSLinearList_DefaultFirstSerialNumber);
	~CHSLinearList();

	int Add(T AddData);
	int GetSerialNumber(int idx);
	int GetIndex(int serialnumber);
	int GetNums(void);
	int GetMinSerialNumber();
	int GetMaxSerialNumber();

	bool SetReAllocSerialNumber(void);
	bool Delete(int Idx ,  T *lpBackup = nullptr,bool bIdxIsSerialNumber = false);
	bool AllDelete();
	bool Get(int Idx , T *lpOutData , bool bIdxIsSerialNumber = false);
	bool Set(int Idx , T InData , bool bIdxIsSerialNumber = false);
	bool IsExistSerialNumber(int serialnumber);


	//演算子のオーバーロード

	//関数呼び出し演算子のオーバーロード
	T operator()(int idx , bool bIdxIsSerialNumber = false);

	//<<演算子のオーバーロード
	CHSLinearList<T>& operator<< (T AddData);

	//>>演算子のオーバーロード
	CHSLinearList<T>& operator>> (T &OutData);

	//型キャスト演算子（int) のオーバーロード
	operator int();

	//代入演算子のオーバーロード
	void operator = (T Data);
};

template<typename T>  CHSLinearList<T>::CHSLinearList(int FirstSerialNumber)
{
	this->NextSerialNumber = this->FirstSerialNumber = FirstSerialNumber;
	this->lpData = nullptr;
}

template<typename T> CHSLinearList<T>::~CHSLinearList()
{
	this->AllDelete();
}

template<typename T> HSLinearList_Data<T>* CHSLinearList<T>::Alloc(){

	HSLinearList_Data<T> *lpNewData = nullptr;
	HSLinearList_Data<T> *lpClassData = this->lpData;
	
	lpNewData = new HSLinearList_Data<T>;
	lpNewData->lpBack = lpNewData->lpNext = nullptr;
	lpNewData->SerialNumber = this->NextSerialNumber;
	this->NextSerialNumber++;
	if(this->lpData == nullptr){
		this->lpData = lpNewData;

	}else{
		while(lpClassData->lpNext != nullptr) lpClassData = lpClassData->lpNext;

		lpClassData->lpNext = lpNewData;
		lpNewData->lpBack = lpClassData;
	}
	return lpNewData;

}



template<typename T> int CHSLinearList<T>::Add(T AddData){
	HSLinearList_Data<T> *lpListData;
	lpListData = this->Alloc();
	lpListData->Data = AddData;
	return lpListData->SerialNumber;
}


template<typename T> HSLinearList_Data<T>* CHSLinearList<T>::Scan(int Idx , bool bIdxIsSerialNumber){
	if((Idx < 0) && (bIdxIsSerialNumber)) return false;
	if(this->lpData == nullptr)return false;
	HSLinearList_Data<T>* lpTargetData = this->lpData;

	if(bIdxIsSerialNumber){
		while(lpTargetData != nullptr){
			if(lpTargetData->SerialNumber == Idx) break;
			lpTargetData = lpTargetData->lpNext;
		}
	}else{

		if(Idx >= 0){
			for (int i = 0; ((i < Idx) && (lpTargetData != nullptr)); i++)
				lpTargetData = lpTargetData->lpNext;
		}else{
			Idx *= -1;
			Idx--;

			while(lpTargetData->lpNext != nullptr) 
				lpTargetData = lpTargetData->lpNext;

			for (int i = 0; ((i < Idx) && (lpTargetData != nullptr)); i++)
				lpTargetData = lpTargetData->lpBack;
		}
	}
	return lpTargetData;
}

template<typename T> bool CHSLinearList<T>::Delete(int Idx ,  T *lpBackup , bool bIdxIsSerialNumber){
	if(this->lpData == nullptr)return false;
	HSLinearList_Data<T>* lpTargetData;

	lpTargetData = this->Scan(Idx , bIdxIsSerialNumber);
	
	if(lpTargetData == nullptr) return false;
	
	if(lpBackup != nullptr) *lpBackup = lpTargetData->Data;
	
	if(lpTargetData->lpBack != nullptr) lpTargetData->lpBack->lpNext = lpTargetData->lpNext;
	
	if(lpTargetData->lpNext != nullptr) lpTargetData->lpNext->lpBack = lpTargetData->lpBack;
	
	if(lpTargetData == this->lpData) this->lpData = this->lpData->lpNext;
	
	delete lpTargetData;
	return true;

}


template<typename T> bool CHSLinearList<T>::AllDelete(){
	if(this->lpData == nullptr)return false;
	HSLinearList_Data<T>* lpClassData = this->lpData;

	while(lpClassData->lpNext) lpClassData = lpClassData->lpNext;

	//前のデータのアドレス
	HSLinearList_Data<T>* oldad = nullptr;
	//破棄しながら前のデータに移動する
	do{
		oldad = lpClassData->lpBack;
		delete lpClassData;
	}while(lpClassData = oldad);
	this->lpData = nullptr;
	this->NextSerialNumber = this->FirstSerialNumber;
	return true;
}

template<typename T> bool CHSLinearList<T>::Get(int Idx , T *lpOutData , bool bIdxIsSerialNumber){
	if(lpOutData == nullptr) return false;
	if(this->lpData == nullptr)return false;
	HSLinearList_Data<T>* lpTargetData;
	lpTargetData = this->Scan(Idx , bIdxIsSerialNumber);
	if(lpTargetData == nullptr) return false;
	*lpOutData = lpTargetData->Data;
	return true;

}




template<typename T> bool CHSLinearList<T>:: Set(int Idx , T InData , bool bIdxIsSerialNumber){
	HSLinearList_Data<T>* lpTargetData;
	lpTargetData = this->Scan(Idx , bIdxIsSerialNumber);
	if(lpTargetData == nullptr) return false;
	lpTargetData->Data = InData;
	return true;

}



template<typename T> int CHSLinearList<T>::GetNums(void){
	if(this->lpData == nullptr)return 0;
	HSLinearList_Data<T>* lpClassData = this->lpData;
	int nums = 0;
	while(lpClassData != nullptr){
		nums++;
		lpClassData = lpClassData->lpNext;
	}
	return nums;
}

template<typename T> bool CHSLinearList<T>::SetReAllocSerialNumber(void){
	if(this->lpData == nullptr)return 0;
	HSLinearList_Data<T>* lpClassData = this->lpData;
	int nums = this->FirstSerialNumber;
	while(lpClassData != nullptr){
		lpClassData->SerialNumber = nums;
		nums++;
		lpClassData = lpClassData->lpNext;
	}
	this->NextSerialNumber = nums;
	return true;
}

template<typename T> int CHSLinearList<T>::GetSerialNumber(int idx){
	if(this->lpData == nullptr)return this->FirstSerialNumber - 1;
	HSLinearList_Data<T>* lpTargetData;
	lpTargetData = this->Scan(idx , false);
	if(lpTargetData == nullptr) return this->FirstSerialNumber - 1;
	return lpTargetData->SerialNumber;

}
template<typename T> int CHSLinearList<T>::GetIndex(int serialnumber){
	if(serialnumber < 0) return -1;
	if(this->lpData == nullptr) return - 1;
	HSLinearList_Data<T>* lpTargetData = this->lpData;

	int idx = 0;
	while(lpTargetData != nullptr){
		if(lpTargetData->SerialNumber == serialnumber) break;
		idx++;
		lpTargetData = lpTargetData->lpNext;
	}
	if(lpTargetData == nullptr) return -1;
	return  idx;
}

template<typename T> int CHSLinearList<T>::GetMinSerialNumber(){
	if(this->lpData == nullptr) return this->FirstSerialNumber - 1;
	HSLinearList_Data<T>* lpTargetData = this->lpData;	
	int fsn = lpTargetData->SerialNumber;
	while(lpTargetData = lpTargetData->lpNext)
		if(fsn > lpTargetData->SerialNumber)
			fsn = lpTargetData->SerialNumber;
	return fsn;
}

template<typename T> int CHSLinearList<T>::GetMaxSerialNumber(){
	if(this->lpData == nullptr) return this->FirstSerialNumber - 1;
	HSLinearList_Data<T>* lpTargetData = this->lpData;	
	int lsn = lpTargetData->SerialNumber;
	while(lpTargetData = lpTargetData->lpNext)
		if(lsn < lpTargetData->SerialNumber)
			lsn = lpTargetData->SerialNumber;
	return lsn;
}

template<typename T> bool CHSLinearList<T>::IsExistSerialNumber(int serialnumber){
	if(this->lpData == nullptr) return false;
	HSLinearList_Data<T>* lpTargetData;
	lpTargetData = this->Scan(serialnumber , true);
	return (lpTargetData == nullptr) ? false : true;
}

//演算子のオーバーロード
template<typename T> T CHSLinearList<T>::operator()(int idx , bool bIdxIsSerialNumber){
	T Data  = { 0 };
	this->Get(idx , &Data , bIdxIsSerialNumber);
	return Data;
}


template<typename T> CHSLinearList<T>& CHSLinearList<T>::operator<< (T AddData){
	this->Add(AddData);
	return *this;
}

template<typename T> CHSLinearList<T>& CHSLinearList<T>::operator>> (T &OutData){
	this->Delete(-1 , &OutData);
	return *this;
}

template<typename T> CHSLinearList<T>::operator int(){
	return this->GetNums();
}

template<typename T> void CHSLinearList<T>::operator=(T Data){
	this->AllDelete();
	this->Add(Data);
}

#endif /* _CHSLinearList_HPP_ */