#ifndef _IMAGE_IMAGETHUNKNAME_HPP_
#define _IMAGE_IMAGETHUNKNAME_HPP_
#ifndef _COMMON_WINDOWS_HPP_
#include <common/windows.hpp>
#endif
#ifndef _COMMON_PUREVIEWOFFILE_HPP_
#include <common/pview.hpp>
#endif
#ifndef _COMMON_STRING_HPP_
#include <common/string.hpp>
#endif

class ImageThunkNameExpand
{
public:
	ImageThunkNameExpand(void);
	ImageThunkNameExpand(const ImageThunkNameExpand &someImageThunkNameExpand);
	ImageThunkNameExpand(const String &importName);
	~ImageThunkNameExpand();
	ImageThunkNameExpand &operator=(const ImageThunkNameExpand &someImageThunkNameExpand);
	WORD operator==(const ImageThunkNameExpand &someImageThunkNameExpand)const;
	String importName(void)const;
	void importName(const String &importName);
private:
	String mImportName;
};

inline
ImageThunkNameExpand::ImageThunkNameExpand(void)
{
}

inline
ImageThunkNameExpand::ImageThunkNameExpand(const ImageThunkNameExpand &someImageThunkNameExpand)
{
	*this=someImageThunkNameExpand;
}

inline
ImageThunkNameExpand::ImageThunkNameExpand(const String &importName)
: mImportName(importName)
{
}

inline
ImageThunkNameExpand::~ImageThunkNameExpand()
{
}

inline
ImageThunkNameExpand &ImageThunkNameExpand::operator=(const ImageThunkNameExpand &someImageThunkNameExpand)
{
	importName(someImageThunkNameExpand.importName());
	return *this;
}

inline
WORD ImageThunkNameExpand::operator==(const ImageThunkNameExpand &someImageThunkNameExpand)const
{
	return importName()==someImageThunkNameExpand.importName();
}

inline
String ImageThunkNameExpand::importName(void)const
{
	return mImportName;
}

inline
void ImageThunkNameExpand::importName(const String &importName)
{
	mImportName=importName;
}

// ******************************************

class ImageThunkName : public ImageThunkNameExpand, private IMAGE_IMPORT_BY_NAME
{
public:
	ImageThunkName(void);
	ImageThunkName(const ImageThunkName &someImageThunkName);
	~ImageThunkName();
	ImageThunkName &operator=(const ImageThunkName &someImageThunName);
	WORD operator==(const ImageThunkName &someImageThunkName)const;
	ImageThunkName &operator<<(PureViewOfFile &pureView);
  operator IMAGE_IMPORT_BY_NAME &(void);
	WORD hint(void)const;
	void hint(WORD hint);
	BYTE name(void)const;
  void name(BYTE name);
private:
  void setZero(void);
};

inline
ImageThunkName::ImageThunkName(void)
{
  setZero();
}

inline
ImageThunkName::ImageThunkName(const ImageThunkName &someImageThunkName)
{
	*this=someImageThunkName;
}

inline
ImageThunkName::~ImageThunkName()
{
}

inline
ImageThunkName &ImageThunkName::operator=(const ImageThunkName &someImageThunkName)
{
	hint(someImageThunkName.hint());
	name(someImageThunkName.name());
	(ImageThunkNameExpand&)*this=(ImageThunkNameExpand&)someImageThunkName;
	return *this;
}

inline
WORD ImageThunkName::operator==(const ImageThunkName &someImageThunkName)const
{
	return (hint()==someImageThunkName.hint()&&
					name()==someImageThunkName.name());
}

inline
ImageThunkName &ImageThunkName::operator<<(PureViewOfFile &pureView)
{
	String moduleImportName;
	pureView.read(IMAGE_IMPORT_BY_NAME::Hint);
	pureView.getLine(moduleImportName);
	importName(moduleImportName);
	return *this;
}

inline
ImageThunkName::operator IMAGE_IMPORT_BY_NAME &(void)
{
	return *this;
}

inline
WORD ImageThunkName::hint(void)const
{
	return IMAGE_IMPORT_BY_NAME::Hint;
}

inline
void ImageThunkName::hint(WORD hint)
{
	IMAGE_IMPORT_BY_NAME::Hint=hint;
}

inline
BYTE ImageThunkName::name(void)const
{
	return IMAGE_IMPORT_BY_NAME::Name[0];
}

inline
void ImageThunkName::name(BYTE name)
{
	IMAGE_IMPORT_BY_NAME::Name[0]=name;
}

inline
void ImageThunkName::setZero(void)
{
	IMAGE_IMPORT_BY_NAME::Hint=0;
	IMAGE_IMPORT_BY_NAME::Name[0]=0;
}
#endif