LPDIRECTSOUNDBUFFER TSoundsManager::GetFromName(char *Name, bool Dynamic,
                                                           float *fSamplingRate)
{ // wyszukanie dŸwiêku w pamiêci albo wczytanie z pliku
    AnsiString file;
    if (Dynamic)
    { // próba wczytania z katalogu pojazdu
        file = Global::asCurrentDynamicPath + AnsiString(Name);
        if (FileExists(file))
            Name = file.c_str(); // nowa nazwa
        else
            Dynamic = false; // wczytanie z "sounds/"
    }
    TSoundContainer *Next = First;
    DWORD dwStatus;
    for (int i = 0; i < Count; i++)
    {
        if (strcmp(Name, Next->Name) == 0)
        {
            if (fSamplingRate)
                *fSamplingRate = Next->fSamplingRate; // czêstotliwoœæ
            return (Next->GetUnique(pDS));
            //      DSBuffers.
            /*
                Next->pDSBuffer[Next->Oldest]->Stop();
                Next->pDSBuffer[Next->Oldest]->SetCurrentPosition(0);
                if (Next->Oldest<Next->Concurrent-1)
                {
                    Next->Oldest++;
                    return (Next->pDSBuffer[Next->Oldest-1]);
                }
                else
                {
                    Next->Oldest= 0;
                    return (Next->pDSBuffer[Next->Concurrent-1]);
                };

       /*         for (int j=0; j<Next->Concurrent; j++)
                {

                    Next->pDSBuffer[j]->GetStatus(&dwStatus);
                    if ((dwStatus & DSBSTATUS_PLAYING) != DSBSTATUS_PLAYING)
                        return (Next->pDSBuffer[j]);
                }                                   */
        }
        else
            Next = Next->Next;
    };
    if (Dynamic) // wczytanie z katalogu pojazdu
        Next = LoadFromFile("", Name, 1);
    else
        Next = LoadFromFile(Directory, Name, 1);
    if (Next)
    { //
        if (fSamplingRate)
            *fSamplingRate = Next->fSamplingRate; // czêstotliwoœæ
        return Next->GetUnique(pDS);
    }
    ErrorLog("Missed sound: " + AnsiString(Name));
    return (NULL);
};

Shader::Shader(std::string vertexFile, std::string fragmentFile) : Shader()
{
	mVertex =glCreateShader(GL_VERTEX_SHADER);
	mFragment =glCreateShader(GL_FRAGMENT_SHADER);
	mProgram =glCreateProgram();
	
	LoadFromFile(FragmentShader, fragmentFile);
	LoadFromFile(VertexShader, vertexFile);
}

CMapzoneData::CMapzoneData(const char *szMapName)
{
    if (!LoadFromFile(szMapName))
    {
        Log("Unable to find map zones! Trying to create them...\n");
        saveZonFile(szMapName);//try making the zon file if the map has the entities
        LoadFromFile(szMapName);
    }
}

/*!
 Loads a shader program from a file and creates the related program
 @param vertex_file -  the file which stores the vertex shader code
 @param fragment_file -  the file which stores the fragment shader code
 @return - Gluint of the shader program
 */
GLuint LoadAndCreateShaderProgram(string vertex_file, string fragment_file)
{

    string vertex_source = LoadFromFile(vertex_file);
    string fragment_source= LoadFromFile(fragment_file);


    // create and return the pgoram.
    return CreateShaderProgram(vertex_source, fragment_source);

}

CFavouritesService::CFavouritesService(std::string userDataFolder) : m_userDataFolder(std::move(userDataFolder))
{
  CFileItemList items;
  std::string favourites = "special://xbmc/system/favourites.xml";
  if(XFILE::CFile::Exists(favourites))
    LoadFromFile(favourites, m_favourites);
  else
    CLog::Log(LOGDEBUG, "CFavourites::Load - no system favourites found, skipping");

  favourites = URIUtils::AddFileToFolder(m_userDataFolder, "favourites.xml");
  if(XFILE::CFile::Exists(favourites))
    LoadFromFile(favourites, m_favourites);
  else
    CLog::Log(LOGDEBUG, "CFavourites::Load - no userdata favourites found, skipping");
}

bool cPlayer::LoadFromDisk(cWorldPtr & a_World)
{
	LoadRank();

	// Load from the UUID file:
	if (LoadFromFile(GetUUIDFileName(m_UUID), a_World))
	{
		return true;
	}
	
	// Load from the offline UUID file, if allowed:
	AString OfflineUUID = cClientHandle::GenerateOfflineUUID(GetName());
	const char * OfflineUsage = " (unused)";
	if (cRoot::Get()->GetServer()->ShouldLoadOfflinePlayerData())
	{
		OfflineUsage = "";
		if (LoadFromFile(GetUUIDFileName(OfflineUUID), a_World))
		{
			return true;
		}
	}
	
	// Load from the old-style name-based file, if allowed:
	if (cRoot::Get()->GetServer()->ShouldLoadNamedPlayerData())
	{
		AString OldStyleFileName = Printf("players/%s.json", GetName().c_str());
		if (LoadFromFile(OldStyleFileName, a_World))
		{
			// Save in new format and remove the old file
			if (SaveToDisk())
			{
				cFile::Delete(OldStyleFileName);
			}
			return true;
		}
	}
	
	// None of the files loaded successfully
	LOG("Player data file not found for %s (%s, offline %s%s), will be reset to defaults.",
		GetName().c_str(), m_UUID.c_str(), OfflineUUID.c_str(), OfflineUsage
	);

	if (a_World == NULL)
	{
		a_World = cRoot::Get()->GetDefaultWorld();
	}
	return false;
}

NameGenerator::NameGenerator()
{
    //ctor
    LoadFromFile("data/letter_chances.txt");
    std::string key, value;
    for(auto it = m_values.begin(); it != m_values.end(); it++)
    {
        key = it->first;
        value = it->second;
        try
        {
            if(key.size() == 1)
            {
                m_first[key.at(0)] = std::stof(value);
            }
            if(key.size() == 2)
            {
                m_second[key.at(0)][key.at(1)] = std::stof(value);
            }
            if(key.size() == 3)
            {
                m_third[key.at(0)][key.at(1)][key.at(2)] = std::stof(value);
            }
        }
        catch(...)
        {
            std::cout << "Could not convert " << value << std::endl;
        }
    }
}

void Ide::LoadLastMain()
{
	bool editor = IsEditorMode();
	LoadFromFile(THISBACK(SerializeLastMain), ConfigFile("lastmain.cfg"));
	if(editor)
		main <<= Null;
}

int main() {
	MyTree<int>* root = CreateEmptyTree<int>();
	LoadFromFile(root, "C:\\input.txt");
	Square(root);
	SaveToFile(root, "C:\\out.txt");
	DeleteTree(root);
}

bool pawsConfigPopup::Initialize()
{
    if (!LoadFromFile("configpopup.xml"))
        return false;

    return true;
}

/*
    constructor
    -----------

    if "szPath" is NULL then we create an untitled document and default object
    
    the type is "doctypeNew" if "lhDoc" is NULL and "doctypeEmbedded" if
    "lhDoc" is non NULL
    
    if "szPath" is non NULL we create a document of type "doctypeFromFile"
    and initialize it from file "szPath"
    
    if "lhDoc" is NULL then we call OleRegisterServerDoc() otherwise we
    just use "lhDoc" as our registration handle
*/
TOLEDocument::TOLEDocument (TOLEServer &server,
                            LHSERVERDOC lhDoc,
                            LPSTR       szPath,
                            BOOL        dirty)
{
  szName = 0;
  lpvtbl = &_vtbl;
  fRelease = FALSE;
  fDirty = dirty;

  server.pDocument = this;

  //
  // since we only have one object we can create it now...
  //
  pObject = new TOLEObject;

  if (szPath)
    LoadFromFile (szPath);

  else {
    SetDocumentName (UNNAMED_DOC);

    type = lhDoc ? doctypeEmbedded : doctypeNew;
  }

  if (lhDoc != 0)
    this->lhDoc = lhDoc;  // use registration handle we were given

  else
  	OleRegisterServerDoc (server.lhServer, szName, this, (LHSERVERDOC FAR *) &this->lhDoc);
}

Bitmap::Bitmap(const WCHAR *path) {
	data = NULL;
	xOffsets = NULL;
	yOffsets = NULL;
	
	LoadFromFile(path);
}

bool pawsConfigChatFilter::Initialize()
{
    if (!LoadFromFile("configchatfilter.xml"))
        return false;

    return true;
}

//-----------------------------------------------------------------------------------------------
ResourceStream::ResourceStream( const std::string& fileToOpenForReading, bool failSilently )
: m_jazzPath( fileToOpenForReading )
, m_startOfData( NULL )
, m_currentReadOffset( 0 )
, m_dataBytesAvailable( 0 )
, m_capacity( 0 )
, m_internalFormat( RESOURCE_STREAM_FORMAT_INVALID )
, m_currentIndentationDepth( 0 )
, m_consecutiveNewLineCount( 1 )
, m_justWroteBlockBegin( false )
, m_justWroteBlockEnd( false )
, m_integrity( RESOURCE_STREAM_INTEGRITY_VALID )
{
	// DEBUGGING - { int q = 5; } //ConsolePrintf( "ResourceStream is being constructed from JazzPath...\n" );
//	{ int q = 5; } //ConsolePrintf( "ResourceSteam being contructed from JazzPath, relative \"%s\" to marker #%d, resolved \"%s\".\n", fileToOpenForReading.GetRelativePathAsString().c_str(), fileToOpenForReading.GetFileFolderID(), fileToOpenForReading..c_str() );
	LoadFromFile( fileToOpenForReading );
//	{ int q = 5; } //ConsolePrintf( "Finished loading ResourceStream from file \"%s\"; resource stream contains %d bytes (capacity=%d).\n", m_jazzPath..c_str(), m_dataBytesAvailable, m_capacity );
	if( IsValid() )
	{
		{ int q = 5; } //ConsolePrintf( Rgba::GREY, "Loaded ResourceStream from file \"%s\"; resource stream contains %d bytes (capacity=%d).\n", m_jazzPath.c_str(), m_dataBytesAvailable, m_capacity );
	}
	else if( !failSilently )
	{
		{ int q = 5; } //ConsolePrintf( Rgba::RED, "FAILED TO LOAD ResourceStream from file \"%s\".\n", m_jazzPath..c_str() );
	}
}

bool pawsConfigSound::Initialize()
{
    if ( ! LoadFromFile("configsound.xml"))
        return false;

    return true;
}

INT CLcMdl2D::Create(void* p1, void* p2, void* p3, void* p4)
{
	char*	sFile = (char*)p1;

	if(FAILED(LoadFromFile(sFile)))
		return -1;


	char fname[128]={0};
	char fext [ 32]={0};
	LcStr_SplitPath(sFile, NULL, NULL, fname, fext);
	sprintf(m_sName, "%s%s", fname, fext);


	D3DXVECTOR3 vcMin;
	D3DXVECTOR3 vcMax;

	// Set Max and Min vertex Position
	D3DXComputeBoundingBox(	(D3DXVECTOR3*)m_pVtx
							, 4
							, D3DXGetFVFVertexSize(VtxDUV1::FVF)
							, &vcMin
							, &vcMax);

	m_BndInf.Set(vcMin, vcMax);

	return 0;
}

bool SysConf::Reload()
{
	std::string& filename = m_Filename.empty() ? m_FilenameDefault : m_Filename;

	LoadFromFile(filename);
	return m_IsValid;
}

 int SImgX_STB::LoadFromFile( LPCSTR pszFileName )
 {
     wchar_t wszFileName[MAX_PATH+1];
     MultiByteToWideChar(CP_ACP,0,pszFileName,-1,wszFileName,MAX_PATH);
     if(GetLastError()==ERROR_INSUFFICIENT_BUFFER) return 0;
     return LoadFromFile(wszFileName);
 }

bool CEpgDataLoader::Load(LPCTSTR pszFolder,HANDLE hAbortEvent)
{
	if (pszFolder==NULL)
		return false;

	FILETIME ftCurrent;
	TCHAR szFileMask[MAX_PATH];
	HANDLE hFind;
	WIN32_FIND_DATA fd;

	::GetSystemTimeAsFileTime(&ftCurrent);
	::PathCombine(szFileMask,pszFolder,TEXT("*_epg.dat"));
	hFind=::FindFirstFile(szFileMask,&fd);
	if (hFind==INVALID_HANDLE_VALUE)
		return false;
	do {
		if ((fd.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)==0
				&& ftCurrent-fd.ftLastWriteTime<FILETIME_HOUR*24*14
				&& ::lstrlen(pszFolder)+1+::lstrlen(fd.cFileName)<MAX_PATH) {
			TCHAR szFilePath[MAX_PATH];

			::PathCombine(szFilePath,pszFolder,fd.cFileName);
			LoadFromFile(szFilePath);
			if (hAbortEvent!=NULL
					&& ::WaitForSingleObject(hAbortEvent,0)==WAIT_OBJECT_0)
				break;
		}
	} while (::FindNextFile(hFind,&fd));
	::FindClose(hFind);
	return true;
}

int main(int argc, char* argv[])
{
    LoadFromFile();
    printf("\n\n");
    LoadFromMemory();
    return 0;
}