fileDistributor.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2007 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: fileDistributor.h,v $ $Revision: 1.19 $ $State: Exp $
*********************************************************************/


#ifndef DtFileDistributor_H_
#define DtFileDistributor_H_

#include "rtiMsConfig.h"
#include <vlutil/vlFilename.h>
#include <map>
#include <set>
#include <list>
#include "rtiMsg.h"
#include "connectMgr.h"

class DtFomModuleDistributionMsg;
class DtFomModuleRequestMsg;
class DtFedExec;
class DtFileName;
class DtFileDistributor;

typedef enum DtDistributorType_enum 
{
   execFedMgrDistributor,
   rtiExecDistributor
} DtDistributorType;

//DtFileDistributorThread creator callback signature
typedef DtFileDistributor* (*DtFileDistributorCreator)
                                                   (const int fedEx, 
                                                   const MAKRti::DtString& fedExName, 
                                                   DtConnectionMgr* connMgr );



class DtFileInformation
{
public:
   DtFileInformation(MAKRti::DtString fomModFileName,
      unsigned int numBlocks = 0,
      FILE* fp = 0,
      char* buff = 0,
      bool fullyReceived = false,
      unsigned int fileSize = 0,
      bool owned = true ) :
      myFomModFileName(fomModFileName),
      myNumBlocks(numBlocks),
      myFilePointer(fp),
      myBuffer(buff),
      myFullyReceived(fullyReceived),
      myFileSize(fileSize),
      myFileOwned(owned),
      myBlocksReceived(0)
   { 
      if ( !myFullyReceived )
      {
         //We'll need to keep track of the received blocks 
         myBlocksReceived = new bool[myNumBlocks];
         for ( unsigned int iter(0); iter < numBlocks; ++iter)
         {
            myBlocksReceived[iter] = false;
         }
      }
   }

   ~DtFileInformation()
   {
      if ( myFileOwned )
      {
         if (  myFilePointer )
         {
            fclose(myFilePointer);
         }
         if ( myBlocksReceived )
         {
            delete [] myBlocksReceived;
         }
         if ( myBuffer )
         {
            delete [] myBuffer;
         }         
      }
   }

   //The name of the file that I represent
   MAKRti::DtString myFomModFileName;
   const unsigned int myNumBlocks;
   unsigned int myFileSize;
   FILE* myFilePointer;
   bool myFileOwned;
   char* myBuffer;
   bool myFullyReceived;
   bool* myBlocksReceived;
private:

   DtFileInformation();
   DtFileInformation(const DtFileInformation& orig);
   DtFileInformation& operator=(const DtFileInformation& orig);
};




class DT_DLL_LRC DtFileDistributor
{

protected:
   
   DtFileDistributor( const int fedExHandle, 
                      const int federateHandle,
                      const MAKRti::DtString& fedExName );

   virtual ~DtFileDistributor();
  

public:
   

   static void setCreatorFunction( DtFileDistributorCreator fn);

   
   virtual bool sendFedFile(const std::vector<MAKRti::DtString>& modules);

   virtual bool pushFedFile( DtConnectionMgr* connMgr, const MAKRti::DtString& fileName, 
      const unsigned int fileSize, 
      const char* fileBuffer, 
      const DtFederateHandle destination = 0 );  


   virtual void fedFileUploaded(const MAKRti::DtString fileUploaded);

   virtual bool fileReceived(const DtFomModuleDistributionMsg& msg, bool& areAllHere );
   virtual bool fileRequested(const DtFomModuleRequestMsg& msg );

   
   virtual void removeFile( const MAKRti::DtString fileName );

   virtual void removeFiles( const std::vector<MAKRti::DtString>& modules );


   virtual bool fedFileReady(const MAKRti::DtString& fileName) const;

   virtual bool fedFilesReady( const std::vector<MAKRti::DtString>* fileNames ) const;

   const FILE* fedFilePtr(MAKRti::DtString fileName) const;

   const char * fedFileBuff( MAKRti::DtString fileName ) const;

   DtFileInformation* takeFedFile(MAKRti::DtString fileName);

   unsigned int fileSize(MAKRti::DtString fileName) const;

   FILE* getTmpFile();

   void setFedHandle(unsigned int newHandle);

   void setFedexHandle( unsigned int newHandle );

   bool requestsPending() const;

   
   

private:
   DtFileDistributor();
   DtFileDistributor(const DtFileDistributor& orig);
   DtFileDistributor& operator=(const DtFileDistributor& orig);

   
protected:

   
   //Really the string associated with the file when their contents were uploaded.
   //All files stored as tmpFiles.
   std::map<MAKRti::DtString, DtFileInformation*> myFiles;
   std::set<std::pair<DtFederateHandle, MAKRti::DtString> > myPendingRequests;

   MAKRti::DtString          myFedExName;
   int               myFedExHandle;
   int               myFederateHandle;
   std::map<MAKRti::DtString, FILE* >  myOpenFileHandles;


protected:
      typedef std::list< DtRtiMsg* > rtiMsgList;
   
      static DtFileDistributorCreator theCreator;


};

#endif  //! DtFileDistributor_H_