void MergeStreams(FileInputStream * in1, FileInputStream * in2, char * outfile) {
FileOutputStream * outStream = NULL;
try {
	int nbytes;
	char buffer[1];
    outStream = new FileOutputStream(outfile);
    
	while ((nbytes = (in1->read(buffer, 1)) != -1)) {
		outStream->write(buffer, nbytes);
	    }

	while ((nbytes = (in2->read(buffer, 1)) != -1)) {
		outStream->write(buffer, nbytes);
	    }

	delete outStream;
    }
catch (IOException & err) {
	err.Display();
	cout<<"Deleting dynamic outStream object"<<endl;
	delete outStream;
    throw FileNotFoundException(outfile);
    }
catch (Xception & err) {
	err.Display();
	cout<<"Deleting dynamic FileOutputStream object"<<endl;
	delete outStream;
    throw FileNotFoundException(outfile);
    }
}

int JpegStegoDecoder::Decode(char *infile, char *outfile, bool getMes)
{
	if(!outfile)
		outfile = "nul";

	// test for existing input and output files
	FILE *fp;
	if ((fp = fopen(infile, READ_BINARY)) == NULL) {
		throw FileNotFoundException("File not found\n",infile);
	}
	fclose(fp);
	if ((fp = fopen(outfile, WRITE_BINARY)) == NULL) {
		throw FileNotFoundException("File not found\n",outfile);
	}
	fclose(fp);

	InitJpegStego(true);

	int argc = 3;
	char *argv[3];
	char name[]="djpeg";
	
	argv[0]=name;
	argv[1]=infile;
	argv[2]=outfile;
	

	return main_djpeg(argc, argv, sData);
}

void FileImpl::renameToImpl(const std::string& path)
{
	poco_assert (!_path.empty());

	POCO_DESCRIPTOR_STRING(oldNameDsc, _path);
	POCO_DESCRIPTOR_STRING(newNameDsc, path);

	int res;
	if ((res = lib$rename_file(&oldNameDsc, &newNameDsc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)) != 1)
	{
		switch (res & 0x0FFFFFFF)
		{
		case RMS$_FNF: 
			throw FileNotFoundException(_path);
		case RMS$_DEV:
		case RMS$_DNF:
			throw PathNotFoundException(_path);
		case RMS$_SYN:
			throw PathSyntaxException(path);
		case RMS$_RMV:
			throw FileAccessDeniedException(_path);
		case RMS$_PRV:
			throw FileAccessDeniedException("insufficient privileges", _path);		
		default:
			throw FileException(path);
		}
	}
}

   /// <summary>Get fully resolved copy of the path</summary>
   /// <returns></returns>
   /// <exception cref="Logic::ComException">COM operation failed</exception>
   /// <exception cref="Logic::FileNotFoundException">Path not found</exception>
   /// <exception cref="Logic::IOException">Unable to query properties</exception>
   Path  Path::GetResolved() const
   {
      Path resolved;
      
      // Resolve path
      if (!GetFullPathName(c_str(), MAX_PATH, (wchar*)resolved, nullptr))
         throw IOException(HERE, L"Unable to resolve path: "+SysErrorString());

      // Ensure exists
      if (!resolved.Exists())
         throw FileNotFoundException(HERE, resolved);

      // Get info
      SHFILEINFO info;
      if (!SHGetFileInfo((wchar*)resolved, 0, &info, sizeof(info), SHGFI_ATTRIBUTES))
         throw IOException(HERE, L"Unable to retrieve file info: "+SysErrorString());

      // Ensure is link
      if (info.dwAttributes & SFGAO_LINK)
      {
         IShellLinkPtr   shell(CLSID_ShellLink);
         IPersistFilePtr file(shell);
         HRESULT         hr;
         
         // Load file, resolve link, extract resolved path
         if (FAILED(hr=file->Load(resolved.c_str(), STGM_READ))
          || FAILED(hr=shell->Resolve(nullptr, SLR_NO_UI|SLR_ANY_MATCH))
          || FAILED(hr=shell->GetPath((wchar*)resolved, MAX_PATH, nullptr, 0)))
            throw ComException(HERE, L"Unable to resolve shell link: ", hr);
      }

      // Return resolved path
      return resolved;
   }

std::pair<std::string, std::string> ShaderManager::FindShaderCode(const std::string& name) const {
	std::string keyName = StripShaderName(name);
	std::string fileName = StripShaderName(name, false);

	// try it in direct source cache
	auto codeIt = m_codes.find(keyName);
	if (codeIt != m_codes.end()) {
		return { keyName, codeIt->second };
	}

	// try it in directories
	for (const auto& directory : m_directories) {
		auto filepath = directory / (fileName + ".hlsl");
		std::ifstream fs(filepath.c_str());
		if (fs.is_open()) {
			fs.seekg(0, std::ios::end);
			size_t s = fs.tellg();
			fs.seekg(0, std::ios::beg);
			std::unique_ptr<char[]> content = std::make_unique<char[]>(s + 1);
			fs.read(content.get(), s);
			content[s] = '\0';
			return { filepath.generic_string(), content.get() };
		}
	}

	throw FileNotFoundException("Shader was not found.", keyName + "(" + name + " as requested)");
}

Path TemplateCache::resolvePath(const Path& path) const
{
	if ( path.isAbsolute() )
		return path;

	for(std::vector<Path>::const_iterator it = _includePaths.begin(); it != _includePaths.end(); ++it)
	{
		Path templatePath(*it, path);

		File templateFile(templatePath);
		if ( templateFile.exists() )
		{
			if ( _logger )
			{
				poco_trace_f2(*_logger, "%s template file resolved to %s", path.toString(), templatePath.toString());
			}
			return templatePath;
		}
		if ( _logger )
		{
			poco_trace_f1(*_logger, "%s doesn't exist", templatePath.toString());
		}
	}

	throw FileNotFoundException(path.toString());
}

void CFileContent::load() {
	ifstream is( realPath_m, ifstream::binary );
	if ( !is )
		throw FileNotFoundException( userPath_m.c_str(), "" );

	is.seekg( 0, is.end );
	size_m = (size_t) is.tellg();
	is.seekg( 0, is.beg );

	char * buf = new char[size_m];
	is.read( buf, size_m );

	size_m = (size_t) is.tellg();

	data_m.insert( data_m.begin(), buf, buf + size_m );
	delete[] buf;

	if ( !is.good() )
		throw FileErrorException( userPath_m.c_str() );

	is.close();

	modificationTime();
	creationTime();
}

void SerialChannelImpl::handleError(const std::string& name)
{
	std::string errorText;
	DWORD error = GetLastError();

	switch (error)
	{
	case ERROR_FILE_NOT_FOUND:
		throw FileNotFoundException(name, getErrorText(errorText));
	case ERROR_ACCESS_DENIED:
		throw FileAccessDeniedException(name, getErrorText(errorText));
	case ERROR_ALREADY_EXISTS:
	case ERROR_FILE_EXISTS:
		throw FileExistsException(name, getErrorText(errorText));
	case ERROR_FILE_READ_ONLY:
		throw FileReadOnlyException(name, getErrorText(errorText));
	case ERROR_CANNOT_MAKE:
	case ERROR_INVALID_NAME:
	case ERROR_FILENAME_EXCED_RANGE:
		throw CreateFileException(name, getErrorText(errorText));
	case ERROR_BROKEN_PIPE:
	case ERROR_INVALID_USER_BUFFER:
	case ERROR_INSUFFICIENT_BUFFER:
		throw IOException(name, getErrorText(errorText));
	case ERROR_NOT_ENOUGH_MEMORY:
		throw OutOfMemoryException(name, getErrorText(errorText));
	case ERROR_HANDLE_EOF: break;
	default:
		throw FileException(name, getErrorText(errorText));
	}
}

ArchiveReader::ArchiveReader(const path_t &path, const path_t *encrypted_fso, RsaKeyPair *keypair):
		manifest_offset(-1),
		path(path),
		keypair(keypair){
	if (!boost::filesystem::exists(path) || !boost::filesystem::is_regular_file(path))
		throw FileNotFoundException(path);
}

 FileReader::FileReader(const String& fileName)
 {
     this->file = newInstance<std::ifstream>(StringUtils::toUTF8(fileName).c_str(), std::ios::binary | std::ios::in);
     if (!file->is_open())
         boost::throw_exception(FileNotFoundException(fileName));
     _length = FileUtils::fileLength(fileName);
 }

void ConfigFile::load(
    const std::string fileName, const std::string delimiter,
    const std::string comment, const std::string inc, const std::string sentry )
{
    // Construct a ConfigFile, getting keys and values from given file

    // the old values
    std::string delimiter1 = _delimiter;
    std::string comment1 = _comment;
    std::string inc1 = _include;
    std::string sentry1 = _sentry;

    if (delimiter != "") _delimiter = delimiter;
    if (comment != "") _comment = comment;
    if (inc != "") _include = inc;
    if (sentry != "") _sentry = sentry;

    std::ifstream in( fileName.c_str() );

    if( !in ) {
        throw FileNotFoundException(fileName);
    }

    in >> (*this);

    _delimiter = delimiter1;
    _comment = comment1;
    _include = inc1;
    _sentry = sentry1;
}

void FileImpl::handleLastErrorImpl(const std::string& path)
{
    switch (errno)
    {
    case EIO:
        throw IOException(path);
    case EPERM:
        throw FileAccessDeniedException("insufficient permissions", path);
    case EACCES:
        throw FileAccessDeniedException(path);
    case ENOENT:
        throw FileNotFoundException(path);
    case ENOTDIR:
        throw OpenFileException("not a directory", path);
    case EISDIR:
        throw OpenFileException("not a file", path);
    case EROFS:
        throw FileReadOnlyException(path);
    case EEXIST:
        throw FileExistsException(path);
    case ENOSPC:
        throw FileException("no space left on device", path);
    case ENOTEMPTY:
        throw FileException("directory not empty", path);
    case ENAMETOOLONG:
        throw PathSyntaxException(path);
    case ENFILE:
    case EMFILE:
        throw FileException("too many open files", path);
    default:
        throw FileException(std::strerror(errno), path);
    }
}

//--------
WatchID FileWatcherWin32::addWatch(const String& directory,
                                   FileWatchListener* watcher,
                                   bool recursive)
{
  WatchID watchid = ++mLastWatchID;

  WatchStruct* watch = CreateWatch(
    directory.c_str(),
    FILE_NOTIFY_CHANGE_CREATION | FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_FILE_NAME,
    recursive);

  if(!watch)
    {
    std::ostringstream message;
    message << "In " << __FILE__ << " at line " << __LINE__ << ": ";
    throw FileNotFoundException(directory, message.str());
    }
  watch->mWatchid = watchid;
  watch->mFileWatcher = this;
  watch->mFileWatchListener = watcher;
  watch->mRecursive = recursive;
  watch->mDirName = new char[directory.length()+1];
  strcpy(watch->mDirName, directory.c_str());

  mWatches.insert(std::make_pair(watchid, watch));

  return watchid;
}

    Entity* EntityCreator::CreateFromFile(const string& filepath) {
        std::ifstream fin(filepath, std::ios::in);

        if (fin) {
            Json::Value rootNode;
            Json::Reader reader;
            bool success = reader.parse(fin, rootNode);
            if (success) {
                Model* model = nullptr;
                PhysicsBody* body = nullptr;

                if (CheckExistence(rootNode, "model")) {
                    const Json::Value& modelNode = rootNode["model"];
                    model = ModelCreator::CreateFromJson(modelNode);
                }

                if (CheckExistence(rootNode, "body")) {
                    const Json::Value& bodyNode = rootNode["body"];
                    body = PhysicsCreator::CreateFromJson(bodyNode, model);
                }

                Entity* entity = new Entity(model, body);
                return entity;
            } else {
                throw Exception("SceneCreator: Cannot parse file '" + filepath + "': " + reader.getFormatedErrorMessages());
            }
        } else {
            throw FileNotFoundException(filepath);
        }
    }

		void addAll()
		{
			// add base dir
			int fd = open(mDirName.c_str(), O_RDONLY | O_EVTONLY);
			EV_SET(&mChangeList[0], fd, EVFILT_VNODE,
				   EV_ADD | EV_ENABLE | EV_ONESHOT,
				   NOTE_DELETE | NOTE_EXTEND | NOTE_WRITE | NOTE_ATTRIB,
				   0, 0);
			
			//fprintf(stderr, "ADDED: %s\n", mDirName.c_str());			
			
			// scan directory and call addFile(name, false) on each file
			DIR* dir = opendir(mDirName.c_str());
			if(!dir)
				throw FileNotFoundException(mDirName);
			
			struct dirent* entry;
			struct stat attrib;
			while((entry = readdir(dir)) != NULL)
			{
				String fname = (mDirName + "/" + String(entry->d_name));
				stat(fname.c_str(), &attrib);
				if(S_ISREG(attrib.st_mode))
					addFile(fname, false);
				//else
				//	fprintf(stderr, "NOT ADDED: %s (%d)\n", fname.c_str(), attrib.st_mode);

			}//end while
			
			closedir(dir);
		}

		void addFile(const String& name, bool imitEvents = true)
		{
			//fprintf(stderr, "ADDED: %s\n", name.c_str());
			
			// create entry
			struct stat attrib;
			stat(name.c_str(), &attrib);
			
			int fd = open(name.c_str(), O_RDONLY | O_EVTONLY);

			if(fd == -1)
				throw FileNotFoundException(name);
			
			++mChangeListCount;
			
			char* namecopy = new char[name.length() + 1];
			strncpy(namecopy, name.c_str(), name.length());
			namecopy[name.length()] = 0;
			EntryStruct* entry = new EntryStruct(namecopy, mWatchID, attrib.st_mtime);
			
			// set the event data at the end of the list
			EV_SET(&mChangeList[mChangeListCount], fd, EVFILT_VNODE,
				   EV_ADD | EV_ENABLE | EV_ONESHOT/* | EV_CLEAR*/,
				   NOTE_DELETE | NOTE_EXTEND | NOTE_WRITE | NOTE_ATTRIB | NOTE_RENAME | NOTE_LINK | NOTE_REVOKE,
				   0, (void*)entry);
			
			// qsort
			qsort(mChangeList + 1, mChangeListCount, sizeof(KEvent), comparator);
			
			// handle action
			if(imitEvents)
				handleAction(name, Actions::Add);
		}

std::vector<Task>* Parser::parse_stg(const char *filepath, DirectedAcyclicGraph* &graph)
                    throw(FileNotFoundException) {
  enum section {
    HEADER,
    GRAPH,
    FOOTER
  };
  
  std::vector<Task>* tasks = NULL;
  
  section s = HEADER;
  std::ifstream file(filepath);
  
  if(!file)
    throw FileNotFoundException(filepath);

  unsigned int task_count = 0;
  while(file.good()) {
    if(s == HEADER) {
      file >> task_count;
      if (task_count !=0) {
        // STG format always includes two dummy nodes
        task_count = task_count + 2;
        graph = new DirectedAcyclicGraph(task_count);
        tasks = new std::vector<Task>(task_count);
        s = GRAPH;
      }
    } else if(s == GRAPH) {

		void removeFile(const String& name, bool imitEvents = true)
		{
			// bsearch
			KEvent target;
			EntryStruct tempEntry(name.c_str(), 0);
			target.udata = &tempEntry;
			KEvent* ke = (KEvent*)bsearch(&target, &mChangeList, mChangeListCount + 1, sizeof(KEvent), comparator);
			if(!ke)
				throw FileNotFoundException(name);

			tempEntry.mFilename = 0;
			
			// delete
			close(ke->ident);
			delete((EntryStruct*)ke->udata);
			memset(ke, 0, sizeof(KEvent));
			
			// move end to current
			memcpy(ke, &mChangeList[mChangeListCount], sizeof(KEvent));
			memset(&mChangeList[mChangeListCount], 0, sizeof(KEvent));
			--mChangeListCount;
			
			// qsort
			qsort(mChangeList + 1, mChangeListCount, sizeof(KEvent), comparator);
			
			// handle action
			if(imitEvents)
				handleAction(name, Actions::Delete);
		}

utils::File::File(const zchar* const filename, FileAccess access, FileShare share,
	FileMode mode, FileType type)
{
	hFile = CreateFileW(filename, static_cast<DWORD>(access), static_cast<DWORD>(share), nullptr,
		static_cast<DWORD>(mode), static_cast<DWORD>(type), nullptr);
	if (hFile == INVALID_HANDLE_VALUE)
	{
		OutputDebugStringW(L"Something is wrong:\n");
		auto error = GetLastError();
		switch (error)
		{
		case ERROR_FILE_EXISTS:
			OutputDebugStringW(L"File already exists.\n");
			throw FileAlreadyExistsException();
		case ERROR_FILE_NOT_FOUND:
			OutputDebugStringW(L"File not found.\n");
			throw FileNotFoundException();
		case ERROR_SHARING_VIOLATION:
			OutputDebugStringW(L"File cannot be shared.\n");
			throw FileSharingViolationException();
		default:
			OutputDebugStringW(L"Reason is not defined.\n");
			throw FileException();
		}
	}
}

/**
  * Compute the SHA1 hash for the given file.
  * @param filename The filename (with or without prefixed by a path). If the file
  * is not found the exeption 'FileNotFoundException' is thrown.
  * @param bufferSize The size of the buffer used to give the data to 'QCryptographicHash'.
  * @return The sha1 hash.
  */
QByteArray computeSHA1(const QString& filename, qint32 bufferSize)
      throw (FileNotFoundException)
{
#if not WITH_SHA1_LINUS
   QCryptographicHash crypto(QCryptographicHash::Sha1);
#endif

   QFile file(filename);
   if (!file.open(QIODevice::ReadOnly))
      throw FileNotFoundException();

#if WITH_SHA1_LINUS
   blk_SHA_CTX sha1State;
   blk_SHA1_Init(&sha1State);
   unsigned char bufferHash[20];
#endif

   char buffer[bufferSize];
   qint64 bytesRead = 0;
   while ((bytesRead = file.read(buffer, bufferSize)) > 0)
   {
#if WITH_SHA1_LINUS
      blk_SHA1_Update(&sha1State, buffer, bytesRead);
#else
      crypto.addData(buffer, bytesRead);
#endif
   }

#if WITH_SHA1_LINUS
      blk_SHA1_Final(bufferHash, &sha1State);
      return QByteArray((const char*)bufferHash, 20);
#else
   return crypto.result();
#endif
}