Exemple #1
0
void Level::load_file_fail(std::ifstream &file, std::string s){
    debug(s);
    file.close();
}
Exemple #2
0
 void seek_end(int pos)
 {
     in.seekg(pos,std::ios::end);
 }
Exemple #3
0
 operator bool() const	{return in.good();}
int ESMReaderAll::processNextRecord(std::ifstream& in_File)
{
  uint32_t RecordName = 0; //normally should be 4 char, but char is not eligible for switch
  int lastResult = 0;

  //read record name
  in_File.read((char*) &RecordName, 4);
  switch(RecordName)
  {
    case cACTI:
         lastResult = Activators::getSingleton().readNextRecord(in_File);
         break;
    case cALCH:
         lastResult = AlchemyPotions::getSingleton().readNextRecord(in_File);
         break;
    case cAPPA:
         lastResult = Apparatuses::getSingleton().readNextRecord(in_File);
         break;
    case cARMO:
         lastResult = Armours::getSingleton().readNextRecord(in_File);
         break;
    case cBODY:
         lastResult = BodyParts::getSingleton().readNextRecord(in_File);
         break;
    case cBOOK:
         lastResult = Books::getSingleton().readNextRecord(in_File);
         break;
    case cBSGN:
         lastResult = BirthSigns::getSingleton().readNextRecord(in_File);
         break;
    case cCELL:
         lastResult = Cells::getSingleton().readRecordCELL(in_File);
         break;
    case cCLAS:
         lastResult = Classes::getSingleton().readNextRecord(in_File);
         break;
    case cCLOT:
         lastResult = Clothings::getSingleton().readNextRecord(in_File);
         break;
    case cCONT:
         lastResult = Containers::getSingleton().readNextRecord(in_File);
         break;
    case cCREA:
         lastResult = Creatures::getSingleton().readNextRecord(in_File);
         break;
    case cDIAL:
         lastResult = DialogueTopics::getSingleton().readRecordDIAL(in_File);
         break;
    case cDOOR:
         lastResult = Doors::getSingleton().readNextRecord(in_File);
         break;
    case cENCH:
         lastResult = Enchantings::getSingleton().readNextRecord(in_File);
         break;
    case cFACT:
         lastResult = Factions::getSingleton().readNextRecord(in_File);
         break;
    case cGLOB:
         lastResult = Globals::getSingleton().readNextRecord(in_File);
         break;
    case cGMST:
         lastResult = GameSettings::getSingleton().readRecordGMST(in_File);
         break;
    case cINFO:
         lastResult = DialogueInfos::getSingleton().readNextRecord(in_File);
         break;
    case cINGR:
         lastResult = Ingredients::getSingleton().readNextRecord(in_File);
         break;
    case cLAND:
         lastResult = Landscape::getSingleton().readRecordLAND(in_File);
         break;
    case cLEVC:
         lastResult = LeveledCreatures::getSingleton().readNextRecord(in_File);
         break;
    case cLEVI:
         lastResult = LeveledItems::getSingleton().readNextRecord(in_File);
         break;
    case cLIGH:
         lastResult = Lights::getSingleton().readNextRecord(in_File);
         break;
    case cLOCK:
         lastResult = Lockpicks::getSingleton().readNextRecord(in_File);
         break;
    case cLTEX:
         lastResult = LandscapeTextures::getSingleton().readNextRecord(in_File);
         break;
    case cMGEF:
         lastResult = MagicEffects::getSingleton().readRecordMGEF(in_File);
         break;
    case cMISC:
         lastResult = MiscItems::getSingleton().readNextRecord(in_File);
         break;
    case cNPC_:
         lastResult = NPCs::getSingleton().readNextRecord(in_File);
         break;
    case cPGRD:
         lastResult = PathGrids::getSingleton().readRecordPGRD(in_File);
         break;
    case cPROB:
         lastResult = Probes::getSingleton().readNextRecord(in_File);
         break;
    case cRACE:
         lastResult = Races::getSingleton().readNextRecord(in_File);
         break;
    case cREGN:
         lastResult = Regions::getSingleton().readNextRecord(in_File);
         break;
    case cREPA:
         lastResult = RepairItems::getSingleton().readNextRecord(in_File);
         break;
    case cSCPT:
         lastResult = Scripts::getSingleton().readNextRecord(in_File);
         break;
    case cSKIL:
         lastResult = Skills::getSingleton().readRecordSKIL(in_File);
         break;
    case cSNDG:
         lastResult = SoundGenerators::getSingleton().readNextRecord(in_File);
         break;
    case cSOUN:
         lastResult = Sounds::getSingleton().readNextRecord(in_File);
         break;
    case cSPEL:
         lastResult = Spells::getSingleton().readNextRecord(in_File);
         break;
    case cSSCR:
         lastResult = StartScripts::getSingleton().readNextRecord(in_File);
         break;
    case cSTAT:
         lastResult = Statics::getSingleton().readNextRecord(in_File);
         break;
    case cWEAP:
         lastResult = Weapons::getSingleton().readNextRecord(in_File);
         break;
    default:
         std::cout << "processNextRecord: ERROR: unknown record type found: \""
                   <<IntTo4Char(RecordName)<<"\".\n"
                   << "Current file position: "<<in_File.tellg()<< " bytes.\n";
         lastResult = -1;
         break;
  }//swi
  return lastResult;
}//processNextRecord of ESMReaderAll class
Exemple #5
0
 bool read(void* buf,size_t size)
 {
     return in.read((char*)buf,size).good();
 }
Exemple #6
0
void get_line(std::ifstream fin, char *buff, int buff_len, int &read_len) {
    fin.getline(buff, buff_len);
    read_len = fin.gcount();
    buff[INPUT_LINE_SIZE - 1] = '\0';
}
Exemple #7
0
std::unique_ptr<TorchStage> SpatialDropout::loadFromFile(std::ifstream& file) {
  float p;
  file.read((char*)(&p), sizeof(p));
  return std::unique_ptr<TorchStage>(new SpatialDropout(p));
}
bool CameraPathRecord::loadFromStream(std::ifstream& in_File, const bool localized, const StringTable& table)
{
    uint32_t readSize = 0;
    if (!loadSizeAndUnknownValues(in_File, readSize)) return false;
    uint32_t subRecName;
    uint16_t subLength;
    subRecName = subLength = 0;
    uint32_t bytesRead = 0;

    //read EDID
    char buffer[512];
    if (!loadString512FromStream(in_File, editorID, buffer, cEDID, true, bytesRead))
        return false;

    conditions.clear();
    CTDA_CIS1_compound tempCC;
    bool hasCTDA = false;
    bool hasReadANAM = false;
    bool hasReadDATA = false;
    camShotList.clear();
    uint32_t tempUint32;

    while (bytesRead<readSize)
    {
        //read next subrecord's name
        in_File.read((char*) &subRecName, 4);
        bytesRead += 4;
        switch(subRecName)
        {
        case cCTDA:
            if (hasCTDA)
            {
                conditions.push_back(tempCC);
            }
            //load CTDA
            if (!tempCC.unknownCTDA.loadFromStream(in_File, bytesRead)) return false;
            hasCTDA = true;
            tempCC.unknownCISx.clear();
            break;
        case cCIS1:
            if (!hasCTDA)
            {
                std::cout << "Error: CPTH has CIS1 subrecord without prior CTDA!\n";
                return false;
            }
            if (!tempCC.unknownCISx.empty())
            {
                std::cout << "Error: CPTH seems to have more than one CIS1 per CTDA!\n";
                return false;
            }
            //load CIS1
            if (!loadString512FromStream(in_File, tempCC.unknownCISx, buffer, cCIS1, false, bytesRead))
                return false;
            //check content
            if (tempCC.unknownCISx.empty())
            {
                std::cout << "Error: subrecord CIS1 of CPTH is empty!\n";
                return false;
            }
            conditions.push_back(tempCC);
            hasCTDA = false;
            break;
        case cANAM:
            if (hasReadANAM)
            {
                std::cout << "Error: CPTH seems to have more than one ANAM subrecord!\n";
                return false;
            }
            //ANAM's length
            in_File.read((char*) &subLength, 2);
            bytesRead += 2;
            if (subLength!=8)
            {
                std::cout <<"Error: subrecord ANAM of CPTH has invalid length ("
                          <<subLength <<" bytes). Should be eight bytes!\n";
                return false;
            }
            //read ANAM's stuff
            in_File.read((char*) &cameraPathLinks.parentFormID, 4);
            in_File.read((char*) &cameraPathLinks.nextFormID, 4);
            bytesRead += 8;
            if (!in_File.good())
            {
                std::cout << "Error while reading subrecord ANAM of CPTH!\n";
                return false;
            }//if
            hasReadANAM = true;
            break;
        case cDATA:
            if (hasReadDATA)
            {
                std::cout << "Error: CPTH seems to have more than one DATA subrecord!\n";
                return false;
            }
            //DATA's length
            in_File.read((char*) &subLength, 2);
            bytesRead += 2;
            if (subLength!=1)
            {
                std::cout <<"Error: subrecord DATA of CPTH has invalid length ("
                          <<subLength <<" bytes). Should be one byte!\n";
                return false;
            }
            //read DATA's stuff
            in_File.read((char*) &unknownDATA, 1);
            bytesRead += 1;
            if (!in_File.good())
            {
                std::cout << "Error while reading subrecord DATA of CPTH!\n";
                return false;
            }//if
            hasReadDATA = true;
            break;
        case cSNAM:
            //load SNAM
            if (!loadUint32SubRecordFromStream(in_File, cSNAM, tempUint32, false))
                return false;
            bytesRead += 6;
            //check content
            if (tempUint32==0)
            {
                std::cout << "Error: subrecord SNAM of CPTH is zero!\n";
                return false;
            }
            camShotList.push_back(tempUint32);
            break;
        default:
            std::cout << "Error: unexpected record type \""<<IntTo4Char(subRecName)
                      << "\" found, but only CTDA, CIS1, ANAM, DATA or SNAM are allowed here!\n";
            return false;
            break;
        }//swi
    }//while

    //push leftover CTDA/CIS1
    if (hasCTDA)
    {
        conditions.push_back(tempCC);
    }

    //presence checks
    if (!(hasReadANAM and hasReadDATA))
    {
        std::cout << "Error: At least one subrecord of CPTH is missing!\n";
        return false;
    }

    return in_File.good();
}
bool DestructionData::loadFromStream(std::ifstream& in_File, const uint32_t recordType, char * buffer, uint32_t& bytesRead)
{
  //DEST's length
  uint16_t subLength = 0;
  in_File.read((char*) &subLength, 2);
  bytesRead += 2;
  if (subLength!=8)
  {
    std::cout << "Error: subrecord DEST of "<<IntTo4Char(recordType)<<" has invalid length ("
              << subLength << " bytes). Should be eight bytes.\n";
    return false;
  }
  //read DEST
  in_File.read((char*) &health, 4);
  in_File.read((char*) &stageCount, 1);
  in_File.read((char*) &unknownTwo, 1);
  in_File.read((char*) &unknownThreeFour, 2);
  bytesRead += 8;
  if (!in_File.good())
  {
    std::cout << "Error while reading subrecord DEST of "<<IntTo4Char(recordType)<<"!\n";
    return false;
  }

  isPresent = true;
  stages.clear();
  DestructionStage tempStage;

  while (stages.size()<stageCount)
  {
    //read next record
    uint32_t innerRecordName = 0;
    in_File.read((char*) &innerRecordName, 4);
    bytesRead += 4;
    switch (innerRecordName)
    {
      case cDSTD:
           if (tempStage.unknownDSTD.isPresent())
           {
             std::cout << "Error: "<<IntTo4Char(recordType)<<" seems to have more than one DSTD subrecord per stage!\n";
             return false;
           }//if
           //read DSTD
           if (!tempStage.unknownDSTD.loadFromStream(in_File, cDSTD, false)) return false;
           bytesRead += (2+tempStage.unknownDSTD.getSize());
           break;
      case cDMDL:
           if (!tempStage.replacementModel.empty())
           {
             std::cout << "Error: "<<IntTo4Char(recordType)<<" seems to have more than one DMDL subrecord per stage!\n";
             return false;
           }//if
           //DMDL's length
           in_File.read((char*) &subLength, 2);
           bytesRead += 2;
           if (subLength>511)
           {
             std::cout <<"Error: sub record DMDL of "<<IntTo4Char(recordType)<<" is longer than 511 characters!\n";
             return false;
           }
           //read string
           memset(buffer, 0, 512);
           in_File.read(buffer, subLength);
           bytesRead += subLength;
           if (!in_File.good())
           {
             std::cout << "Error while reading subrecord DMDL of "<<IntTo4Char(recordType)<<"!\n";
             return false;
           }
           tempStage.replacementModel = std::string(buffer);
           //check content
           if (tempStage.replacementModel.empty())
           {
             std::cout << "Error: subrecord DMDL of "<<IntTo4Char(recordType)<<" is empty!\n";
             return false;
           }
           break;
      case cDMDT:
           if (tempStage.unknownDMDT.isPresent())
           {
             std::cout << "Error: "<<IntTo4Char(recordType)
                       << " seems to have more than one DMDT subrecord per stage!\n";
             return false;
           }//if
           //read DMDT
           if (!tempStage.unknownDMDT.loadFromStream(in_File, cDMDT, false)) return false;
           bytesRead += (2+tempStage.unknownDMDT.getSize());
           break;
      case cDSTF:
           //DSTF's length
           in_File.read((char*) &subLength, 2);
           bytesRead += 2;
           if (subLength!=0)
           {
             std::cout << "Error: subrecord DSTF of "<<IntTo4Char(recordType)
                       << " has invalid length (" << subLength
                       << " bytes). Should be zero bytes.\n";
             return false;
           }
           //push it, if not empty
           if (tempStage.isReset())
           {
             std::cout << "Error: "<<IntTo4Char(recordType)<<" seems to have an empty destruction stage!\n";
             return false;
           }
           stages.push_back(tempStage);
           tempStage.reset();
           break;
      default:
           std::cout << "Error: found unexpected subrecord \""<<IntTo4Char(innerRecordName)
                     << "\", but only DSTD, DMDL, DMDT or DSTF are allowed here!\n";
           return false;
    }//swi
  }//while

  return in_File.good();
}
Exemple #10
0
void Q3BSPLoad::LoadBSPData(std::ifstream& aFile)
{
  //Load leaves
  //Calculate number of leaves
  int numLeaves=m_header.m_directoryEntries[bspLeaves].m_length/sizeof(BSP_LOAD_LEAF);

  //Create space for this many BSP_LOAD_LEAFS
  m_loadLeaves.resize(numLeaves);

  //Load leaves
  aFile.seekg(m_header.m_directoryEntries[bspLeaves].m_offset,std::ios::beg);
  aFile.read((char*)&m_loadLeaves[0], m_header.m_directoryEntries[bspLeaves].m_length);




  //Load leaf faces array
  int num_leaf_faces=m_header.m_directoryEntries[bspLeafFaces].m_length/sizeof(int);

  //Create space for this many leaf faces
  m_loadLeafFaces.resize(num_leaf_faces);

  //Load leaf faces
  aFile.seekg(m_header.m_directoryEntries[bspLeafFaces].m_offset,std::ios::beg);
  aFile.read((char*)&m_loadLeafFaces[0], m_header.m_directoryEntries[bspLeafFaces].m_length);





  //Load Planes
  int num_planes=m_header.m_directoryEntries[bspPlanes].m_length/sizeof(BSP_LoadPlane);

  //Create space for this many planes
  m_loadPlanes.resize(num_planes);

  aFile.seekg(m_header.m_directoryEntries[bspPlanes].m_offset,std::ios::beg);
  aFile.read((char*)&m_loadPlanes[0], m_header.m_directoryEntries[bspPlanes].m_length);



  //Load nodes
  int num_nodes=m_header.m_directoryEntries[bspNodes].m_length/sizeof(BSP_NODE);

  //Create space for this many nodes
  m_loadNodes.resize(num_nodes);

  aFile.seekg(m_header.m_directoryEntries[bspNodes].m_offset,std::ios::beg);
  aFile.read((char*)&m_loadNodes[0], m_header.m_directoryEntries[bspNodes].m_length);



  //Load visibility data
  //load numClusters and bytesPerCluster
  aFile.seekg(m_header.m_directoryEntries[bspVisData].m_offset,std::ios::beg);
  aFile.read((char*)&m_loadVisibilityData, 2 * sizeof(int));

  //Calculate the size of the bitset
  int bitsetSize=m_loadVisibilityData.m_numClusters*m_loadVisibilityData.m_bytesPerCluster;

  //Create space for bitset
  m_loadVisibilityData.m_bitset.resize(bitsetSize);
  //read bitset
  aFile.read((char*)&m_loadVisibilityData.m_bitset[0], bitsetSize);
}
bool ApparatusRecord::loadFromStream(std::ifstream& in_File)
{
  uint32_t Size;
  in_File.read((char*) &Size, 4);
  in_File.read((char*) &HeaderOne, 4);
  in_File.read((char*) &HeaderFlags, 4);

  /*Alchemy Apparatus:
    NAME = Item ID, required
    MODL = Model Name, required
    FNAM = Item Name, required
    AADT = Alchemy Data (16 bytes), required
        long    Type (0=Mortar and Pestle,1=Albemic,2=Calcinator,3=Retort)
        float	Quality
        float	Weight
        long	Value
    ITEX = Inventory Icon
    SCRI = Script Name (optional) */

  uint32_t SubRecName;
  uint32_t SubLength, BytesRead;
  SubRecName = SubLength = 0;

  //read NAME
  in_File.read((char*) &SubRecName, 4);
  BytesRead = 4;
  if (SubRecName!=cNAME)
  {
    UnexpectedRecord(cNAME, SubRecName);
    return false;
  }
  //NAME's length
  in_File.read((char*) &SubLength, 4);
  BytesRead += 4;
  if (SubLength>255)
  {
    std::cout << "Subrecord NAME of APPA is longer than 255 characters!\n";
    return false;
  }
  char Buffer[256];
  memset(Buffer, '\0', 256);
  //read apparatus ID
  in_File.read(Buffer, SubLength);
  BytesRead += SubLength;
  if (!in_File.good())
  {
    std::cout << "Error while reading subrecord NAME of APPA!\n";
    return false;
  }
  recordID = std::string(Buffer);

  Model.clear();
  ItemName.clear();
  bool hasReadAADT = false;
  InventoryIcon.clear();
  ScriptName.clear();

  while (BytesRead<Size)
  {
    //read sub record's name
    in_File.read((char*) &SubRecName, 4);
    BytesRead += 4;
    switch (SubRecName)
    {
      case cMODL:
           if (!Model.empty())
           {
             std::cout << "Error: APPA seems to have more than one MODL subrecord!\n";
             return false;
           }
           //MODL's length
           in_File.read((char*) &SubLength, 4);
           BytesRead += 4;
           if (SubLength>255)
           {
             std::cout << "Subrecord MODL of APPA is longer than 255 characters!\n";
             return false;
           }
           //read model path
           memset(Buffer, '\0', 256);
           in_File.read(Buffer, SubLength);
           BytesRead += SubLength;
           if (!in_File.good())
           {
             std::cout << "Error while reading subrecord MODL of APPA!\n";
             return false;
           }
           Model = std::string(Buffer);
           if (Model.empty())
           {
             std::cout << "Error: subrecord MODL of APPA is empty!\n";
             return false;
           }
           break;
      case cFNAM:
           if (!ItemName.empty())
           {
             std::cout << "Error: APPA seems to have more than one FNAM subrecord!\n";
             return false;
           }
           //FNAM's length
           in_File.read((char*) &SubLength, 4);
           BytesRead += 4;
           if (SubLength>255)
           {
             std::cout << "Subrecord FNAM of APPA is longer than 255 characters!\n";
             return false;
           }
           //read apparatus name
           memset(Buffer, '\0', 256);
           in_File.read(Buffer, SubLength);
           BytesRead += SubLength;
           if (!in_File.good())
           {
             std::cout << "Error while reading subrecord FNAM of APPA!\n";
             return false;
           }
           ItemName = std::string(Buffer);
           if (ItemName.empty())
           {
             std::cout << "Error: subrecord FNAM of APPA is empty!\n";
             return false;
           }
           break;
      case cAADT:
           if (hasReadAADT)
           {
             std::cout << "Error: APPA seems to have more than one AADT subrecord!\n";
             return false;
           }
           //AADT's length
           in_File.read((char*) &SubLength, 4);
           BytesRead += 4;
           if (SubLength!=16)
           {
             std::cout << "Error: sub record AADT of APPA has invalid length ("
                       << SubLength << " bytes). Should be 16 bytes.\n";
             return false;
           }
           //read apparatus data
           in_File.read((char*) &Type, 4);
           in_File.read((char*) &Quality, 4);
           in_File.read((char*) &Weight, 4);
           in_File.read((char*) &Value, 4);
           BytesRead += 16;
           if (!in_File.good())
           {
             std::cout << "Error while reading subrecord AADT of APPA!\n";
             return false;
           }
           hasReadAADT = true;
           break;
      case cITEX:
           if (!InventoryIcon.empty())
           {
             std::cout << "Error: APPA seems to have more than one ITEX subrecord!\n";
             return false;
           }
           //ITEX's length
           in_File.read((char*) &SubLength, 4);
           BytesRead += 4;
           //read apparatus icon path
           memset(Buffer, '\0', 256);
           in_File.read(Buffer, SubLength);
           BytesRead += SubLength;
           if (!in_File.good())
           {
             std::cout << "Error while reading subrecord ITEX of APPA!\n";
             return false;
           }
           InventoryIcon = std::string(Buffer);
           if (InventoryIcon.empty())
           {
             std::cout << "Error: subrecord ITEX of APPA is empty!\n";
             return false;
           }
           break;
      case cSCRI:
           if (!ScriptName.empty())
           {
             std::cout << "Error: APPA seems to have more than one SCRI subrecord!\n";
             return false;
           }
           //SCRI's length
           in_File.read((char*) &SubLength, 4);
           BytesRead += 4;
           if (SubLength>255)
           {
             std::cout << "Subrecord SCRI of APPA is longer than 255 characters!\n";
             return false;
           }
           //read apparatus script ID
           memset(Buffer, '\0', 256);
           in_File.read(Buffer, SubLength);
           BytesRead += SubLength;
           if (!in_File.good())
           {
             std::cout << "Error while reading subrecord SCRI of APPA!\n";
             return false;
           }
           ScriptName = std::string(Buffer);
           if (ScriptName.empty())
           {
             std::cout << "Error: subrecord SCRI of APPA is empty!\n";
             return false;
           }
           break;
      default:
           std::cout << "Error: unexpected record type \""<<IntTo4Char(SubRecName)
                     << "\" found, but only MODL, FNAM, AADT or ITEX are allowed here!\n";
           return false;
           break;
    }//swi
  }//while

  //presence checks
  if (Model.empty() or ItemName.empty() or !hasReadAADT or InventoryIcon.empty())
  {
    std::cout << "Error: At least one required subrecord of APPA is missing!\n";
    return false;
  }

  return in_File.good();
}
static inline void eat_blankspace(std::ifstream &f)
{
  while (isblank(f.peek())) {
    f.get();
  }  
}
static inline void eat_whitespace(std::ifstream &f)
{
  while (isspace(f.peek())) {
    f.get();
  }  
}
Exemple #14
0
bool PerkRecord::loadFromStream(std::ifstream& in_File, const bool localized, const StringTable& table)
{
  uint32_t readSize = 0;
  if (!loadSizeAndUnknownValues(in_File, readSize)) return false;
  uint32_t subRecName;
  uint16_t subLength;
  subRecName = subLength = 0;
  uint32_t bytesRead;

  //read EDID
  in_File.read((char*) &subRecName, 4);
  bytesRead = 4;
  if (subRecName!=cEDID)
  {
    UnexpectedRecord(cEDID, subRecName);
    return false;
  }
  //EDID's length
  in_File.read((char*) &subLength, 2);
  bytesRead += 2;
  if (subLength>511)
  {
    std::cout <<"Error: sub record EDID of PERK is longer than 511 characters!\n";
    return false;
  }
  //read EDID's stuff
  char buffer[512];
  memset(buffer, 0, 512);
  in_File.read(buffer, subLength);
  bytesRead += subLength;
  if (!in_File.good())
  {
    std::cout << "Error while reading subrecord EDID of PERK!\n";
    return false;
  }
  editorID = std::string(buffer);

  //now read the rest
  unknownVMAD.setPresence(false);
  name.reset();
  description.reset();
  subBlocks.clear();
  SubBlock temp;
  while (bytesRead<readSize)
  {
    //read next subrecord's name
    in_File.read((char*) &subRecName, 4);
    bytesRead += 4;
    switch (subRecName)
    {
      case cVMAD:
           if (unknownVMAD.isPresent())
           {
             std::cout << "Error: record PERK seems to have more than one VMAD subrecord.\n";
             return false;
           }
           if (!unknownVMAD.loadFromStream(in_File, cVMAD, false)) return false;
           bytesRead += (2 +unknownVMAD.getSize());
           break;
      case cFULL:
           if (name.isPresent())
           {
             std::cout << "Error: record PERK seems to have more than one FULL subrecord.\n";
             return false;
           }
           //read FULL
           if (!name.loadFromStream(in_File, cFULL, false, bytesRead, localized, table, buffer))
             return false;
           break;
      case cDESC:
           if (description.isPresent())
           {
             std::cout << "Error: record PERK seems to have more than one DESC subrecord.\n";
             return false;
           }
           //read DESC
           if (!description.loadFromStream(in_File, cDESC, false, bytesRead, localized, table, buffer))
             return false;
           break;
      default:
           temp.subType = subRecName;
           if (!temp.subData.loadFromStream(in_File, subRecName, false))
           {
             std::cout << "Error while reading subrecord "<<IntTo4Char(subRecName)
                       << " of PERK!\n";
             return false;
           }
           bytesRead += (2 +temp.subData.getSize());
           subBlocks.push_back(temp);
           break;
    }//swi
  }//while

  if (!description.isPresent())
  {
    std::cout << "Error: subrecord DESC of PERK is missing!\n";
    return false;
  }

  return in_File.good();
}
void GamessukOut::readOptimisedCoordinates(std::ifstream &ifs)
{

  //std::cout << "readOptimisedCoordinates\n";

  double x,y,z;

  // Nuke the old coordinates
  gukBasis.atomLabels.clear();
  gukBasis.coordinates.clear();

  ifs.getline(buffer, BUFF_SIZE);
  while( ! ifs.eof() )
  {

    // This for some optimize runtypes
    if ( strstr(buffer,"         x              y              z            chg  tag") != NULL )
    {
      //std::cout << "start of opt coord\n";
      // Skip 2 lines - should then be at the coordinates
      ifs.getline(buffer, BUFF_SIZE) && ifs.getline(buffer, BUFF_SIZE);

      while( ! ifs.eof() )
      {
        // End of geometry block
        if ( strstr(buffer, "  ============================================================") != NULL) return;

        tokenize(tokens, buffer, " \t\n");

        from_string<double>(x, tokens.at(0), std::dec);
        from_string<double>(y, tokens.at(1), std::dec);
        from_string<double>(z, tokens.at(2), std::dec);

        gukBasis.coordinates.push_back( Eigen::Vector3d( x, y, z ));
        gukBasis.atomLabels.push_back(tokens.at(4));

        ifs.getline(buffer, BUFF_SIZE);
      } // end while
    }
    else if ( strstr(buffer,"atom     znuc       x             y             z") != NULL )
    {

      // print "start of opt coord 2"

      // Skip 3 lines - should then be at the coordinates
      ifs.getline(buffer, BUFF_SIZE) && ifs.getline(buffer, BUFF_SIZE) &&
          ifs.getline(buffer, BUFF_SIZE);

      while( ! ifs.eof() )
      {
        // End of geometry block
        if ( strstr(buffer, "*************************") != NULL) return;


        tokenize(tokens, buffer, " \t\n");

        gukBasis.atomLabels.push_back(tokens.at(0));
        from_string<double>(x, tokens.at(3), std::dec);
        from_string<double>(y, tokens.at(4), std::dec);
        from_string<double>(z, tokens.at(5), std::dec);

        gukBasis.coordinates.push_back( Eigen::Vector3d( x, y, z ));

        ifs.getline(buffer, BUFF_SIZE);
      } // end of while
    }

    ifs.getline(buffer, BUFF_SIZE);
  } // end of read loop

} // end readOptimisedCoordinates
Exemple #16
0
int main (int argc, char* argv[]) {
    
    
	int start, end;
    std::stringstream buffer;
    
	cout << "start main" << endl;
    
	if(argc < 6){
		cout << "Please enter your input" << endl;
		return -1;
	}
	if (argc >= 6){
		start = atoi(argv[3]);
		end = atoi(argv[4]);
		var = atof(argv[5]);
        
	}
    
    std::string indirname = argv[1];
    
    buffer.str("");
    buffer << indirname << "/simPattern.txt";
    truePatternFile.open( buffer.str().c_str() );
    
    
    buffer.str("");
    buffer << indirname << "/patterns.tsv";
    estimatedPatternFile.open( buffer.str().c_str() );
    
    
    buffer.str("");
    buffer << indirname << "/shortRead.txt";
    shortReadFile.open( buffer.str().c_str() );
    
    
    std::string outdirname = argv[2];
    
    buffer.str("");
    buffer << outdirname << "/eval.txt";
    evalFile.open( buffer.str().c_str() ,std::ios_base::app);
    
    
    buffer.str("");
    buffer << outdirname << "/mcf.txt";
    MCFFile.open( buffer.str().c_str(), std::ios_base::app);
    
    
    buffer.str("");
    buffer << outdirname << "/match.txt";
    matchFile.open( buffer.str().c_str());
    
    buffer.str("");
    buffer << outdirname << "/matchApp.txt";
    matchAppFile.open( buffer.str().c_str(), std::ios_base::app);
    
    
    buffer.str("");
    buffer << outdirname << "/weight.txt";
    weightFile.open( buffer.str().c_str());
    
    
    buffer.str("");
    buffer << indirname << "/match.txt";
    mFile.open( buffer.str().c_str() );
    
    
    
    buffer.str("");
    buffer << outdirname << "/methylPercentageTrue.txt";
    mTruePercentageFile.open( buffer.str().c_str() );
    
    buffer.str("");
    buffer << outdirname << "/methylPercentageEstimated.txt";
    mEstimatedPercentageFile.open( buffer.str().c_str() );
    
    
    buffer.str("");
    buffer << outdirname << "/methylPercentageRead.txt";
    mReadPercentageFile.open( buffer.str().c_str() );
    
    
	//truePatternFile.open(argv[1]);
    //estimatedPatternFile.open(argv[2]);
    //evalFile.open(argv[3],std::ios_base::app);
    //MCFFile.open(argv[4],std::ios_base::app);
    
	
	//################     read the input .tsv data to the "line" number
	cout << "reading true patterns " << start << " " << end << endl;
	readTruePattern(start , end);
    cout << "reading estimated patterns " << start << " " << end << endl;
    readEstimatedPattern(start , end);
    cout << "reading short read " <<  endl;
    readShortRead(start, end);
    cout << "compute methyl Percentage  " << endl;

    computeMethylPercentage();
    cout << "write methyl Percentage  " << endl;
    writeMethylPercentageMatrix();
    
	cout << "build Graph " << start << endl;
    buildGraph();
    
    
    //########### write the weight of edges and corresponding matches for every true pattern ########
    /// the ffirst line is #truePattern , #estimated Pattern
    /// then each line is true Pattern id , abundance of pattern
    /// then each line is estimated pattern id , abundance of pattern
    // then the weight information of edges and matching information is seen in the rest of file
    
    //minCostFlowErr =  computeMinCostFlowError();
    //MCFFile << var << "\t" << minCostFlowErr << endl;
    //cout << "min cost flow error " << minCostFlowErr << endl;
    
    
    writeMatchMatrix();
    
    minCostFlowErr =  computeMinCostFlowError();
    MCFFile << var << "\t" << minCostFlowErr << endl;
    cout << "min cost flow error " << minCostFlowErr << endl;
    
    readMatchMatrix();
    
    
    //// computing Error Metric ////////
    for (double thresh=0.1; thresh<1; thresh +=0.1)
        computeErrorMatrix(thresh);
    
    
    
    
    //}
    
    /*
     cout << "Solve LP " << start << endl;
     
     ////////////LP//////////////////////
     lemon::Lp lp;
     lp.max();
     
     //Graph::ArcMap<lemon::Lp::Col> x;
     std::map<Edge, lemon::Lp::Row> x;
     
     std::map<RedNode, lemon::Lp::Col> alpha;
     //  std::map<Graph::BlueNode, lemon::Lp::Col> beta;
     
     
     lemon::Lp::Expr obj;
     
     for (RedNodeIt r(g); r != INVALID; ++r) {
     alpha[r] = lp.addCol();
     //lp.colLowerBound(alpha[r], 0.0);
     obj += alpha[r];
     }
     
     
     
     for (EdgeIt e(g); e != INVALID; ++e) {
     
     //   x[e] = lp.addRow();
     RedNode r = g.source(e);
     BlueNode b = g.target(e);
     
     x[e] = lp.addRow(alpha[r] + alpha[b] - length[e] <= 0);
     }
     
     
     
     lp.obj(obj);
     lp.solve();
     
     float v = lp.primal();
     //cout << "dual : " << v << endl;
     
     float abndncError = 0;
     float methylCallError = 0;
     
     
     int match = 0;
     for (EdgeIt e(g); e != INVALID; ++e) {
     
     lemon::Lp::Row row = x[e];
     float dual = lp.dual(row);
     
     cout << " X(" << g.id(g.source(e)) <<", " << g.id(g.target(e)) << ") = " << dual<< endl;
     cout << " W(" << g.id(g.source(e)) <<", " << g.id(g.target(e)) << ") = " << length[e]<< endl;
     
     if (dual){
     abndncError += pow(double(abundance_map[g.target(e)] - abundance_map[g.source(e)]),2) / 10000;
     methylCallError += length[e];
     match++;
     }
     else{
     abndncError += pow(double(abundance_map[g.target(e)]),2) /10000 + pow(double(abundance_map[g.source(e)]),2) /10000;
     methylCallError +=1;
     }
     }
     int TP = match;
     int FN = trueMethylData.size() - match;
     int FP = estimatedMethylData.size() - match;
     
     methylCallError = methylCallError/(match + FN +FP);
     
     //evalFile.open("/cbcb/project-scratch/fdorri/Code/methylFlow/testing/eval.txt", std::ios_base::app);
     
     //evalFile << "abndncError " << "\t"  << "methylCall Error " << "\t" << "TP "<< "\t" << "FN " << "\t" << "FP " << endl;
     evalFile << abndncError << "\t" << methylCallError << "\t" << TP << "\t" << FN  << "\t"  << FP << std::endl;
     
     //std:cout << abndncError << "\t" << methylCallError << "\t" << TP << "\t" << FN  << "\t"  << FP << std::endl;
     */
    
    
    
    
    
}
int GamessukOut::readMOVectors(std::ifstream &ifs)
{
  /*
       Loop through a series of columns of printed MO vectors & return the
       number of orbitals read in
    */

  unsigned int norbitals, norbitalsRead;
  double energy;

  ifs.getline(buffer, BUFF_SIZE);
  //std::cout << "HeaderLine " << buffer << std::endl;

  // Check we're not at the end
  if ( strstr(buffer, "end of")!=0 ) return 0;

  tokenize(tokens, buffer, " \t\n");
  // How many orbital columns:
  norbitals = static_cast<unsigned int>(tokens.size());

  for ( unsigned int i=0; i < tokens.size() ; i++ )
  {
    from_string<double>(energy, tokens.at(i), std::dec);
    //std::cout << "adding e " << energy << std::endl;
    gukBasis.moEnergies.push_back(energy);
  }

  // Add the lists to hold this set of coefficients
  // How many were read in previously:
  norbitalsRead = static_cast<unsigned int>(gukBasis.moVectors.size());

  // Create the arrays to hold the coefficients for each orbital
  for ( unsigned int i=0; i < norbitals ; i++ )
    gukBasis.moVectors.push_back( std::vector<double>() );

  //skip 5 lines to just before where first set of orbitals are printed
  ifs.getline(buffer, BUFF_SIZE) &&
      ifs.getline(buffer, BUFF_SIZE) &&
      ifs.getline(buffer, BUFF_SIZE) &&
      ifs.getline(buffer, BUFF_SIZE) &&
      ifs.getline(buffer, BUFF_SIZE);


  // loop nBasisFunctions times to read in up to norbitals coefficients
  for (int i=0; i < gukBasis.nBasisFunctions ; i++ )
  {
    ifs.getline( buffer, BUFF_SIZE );
    //std::cout << "MO line " << buffer << std::endl;

    tokenize(tokens, buffer, " \t\n");

    for (unsigned int j=0; j < norbitals ; j++ )
    {
      // reuse variable energy to hold coefficient
      from_string<double>(energy, tokens.at(j+4), std::dec);
      gukBasis.moVectors.at(norbitalsRead+j).push_back(energy);
      //std::cout << "Adding " << energy << " to vector " << norbitalsRead+j << std::endl;
    }
  }

  // skip 2 lines to where the next set of headers are printed
  ifs.getline(buffer, BUFF_SIZE);
  ifs.getline(buffer, BUFF_SIZE);

  // If we are printed out after an optimisation under the control of "iprint vectors",
  // the next line with be filled with " =================" if we've finished
  if ( strstr(buffer, " ===============================")!=0 ) return 0;

  return norbitals;

} // end readMOVectors
Exemple #18
0
                /**
                 * Parses an .idx file.
                 */
                std::vector<Reference> parse(std::ifstream& fs)
                {
                    uint32_t size;
                    uint32_t hash;

                    fs >> le >> size;
                    fs >> le >> hash;

                    uint32_t headerHash{ 0 };
                    if ((hash != (headerHash = Crypto::lookup3(fs, size, 0))))
                    {
                        throw Exceptions::InvalidHashException(hash, headerHash, "");
                    }

                    uint16_t version;
                    uint16_t bucket;

                    uint8_t lengthFieldSize;
                    uint8_t locationFieldSize;
                    uint8_t keyFieldSize;
                    uint8_t segmentBits;

                    fs >> le >> version;
                    fs >> le >> bucket;
                    fs >> lengthFieldSize;
                    fs >> locationFieldSize;
                    fs >> keyFieldSize;
                    fs >> segmentBits;

                    this->versions_[bucket] = version;
                    this->keySize_[bucket] = keyFieldSize;

                    for (unsigned int i = 0; i < (size - 8); i += 8)
                    {
                        uint32_t dataBeg;
                        uint32_t dataEnd;

                        fs >> be >> dataBeg;
                        fs >> be >> dataEnd;
                    }

                    fs.seekg(16 - ((8 + size) % 16), std::ios_base::cur);

                    fs >> le >> size;
                    fs >> le >> hash;

                    std::pair<uint32_t, uint32_t> dataHash{ 0, 0 };
                    std::vector<char> data(size);

                    fs.read(data.data(), data.size());

                    std::vector<Reference> files(size / 18);
                    files.reserve(size / 18);

                    for (auto i = 0U; i < (size / 18); ++i)
                    {
                        auto begin = data.begin() + 18 * i;
                        auto end = begin + 18;

                        files.emplace_back(begin, end,
                            keyFieldSize,
                            locationFieldSize,
                            lengthFieldSize,
                            segmentBits);

                        dataHash = Crypto::lookup3(begin, end, dataHash);
                    }

                    if (hash != dataHash.first)
                    {
                        throw Exceptions::InvalidHashException(hash, dataHash.first, "");
                    }

                    fs.seekg(0xE000 - ((8 + size) % 0xD000), std::ios_base::cur);

                    return files;
                }
Exemple #19
0
void Toggle::load(std::ifstream& ifs) {
	int data = 0;
	ifs.read((char*)&data, sizeof(int));
	value = (data == 1);
	needsRedraw();
}
Exemple #20
0
		bool XAnimationKey::ParseFromFStream(std::ifstream& in)
		{
			std::streampos pos;
			char separator;

			if (!in.good())
			{
				return false;
			}

			in.clear();
			pos = in.tellg();

			if (!KeyType.ParseFromFStream(in))
			{
				in.clear();
				in.seekg(pos);
				return false;
			}

			in >> separator;
			if (!in.good() || separator != ';')
			{
				in.clear();
				in.seekg(pos);
				return false;
			}

			if (!NKeys.ParseFromFStream(in))
			{
				in.clear();
				in.seekg(pos);
				return false;
			}

			in >> separator;
			if (!in.good() || separator != ';')
			{
				in.clear();
				in.seekg(pos);
				return false;
			}

			if (!Keys.ParseFromFStream(in, NKeys))
			{
				in.clear();
				in.seekg(pos);
				return false;
			}

			in >> separator;
			if (!in.good() || separator != ';')
			{
				in.clear();
				in.seekg(pos);
				return false;
			}

			return true;
		}
Exemple #21
0
void MSG_data::read_from( std::ifstream &in, MSG_header &header )
{
  size_t dsize;
  size_t dpos;
  unsigned char_1 *dbuff = 0;
  unsigned char_1 *dpnt = 0;

  typecode = header.f_typecode;
  switch (typecode)
  {
    case MSG_FILE_IMAGE_DATA:
      image = new MSG_data_image;

      dsize = header.data_field_length / 8;
      dbuff = new unsigned char_1[dsize];
      in.read((char *) dbuff, dsize);
      if (in.fail( ))
      {
        std::cerr << "Read error from HRIT file: Data field." << std::endl;
        throw;
      }

      if (header.image_structure->compression_flag == MSG_NO_COMPRESSION)
      {
        image->len = dsize;
        image->data = (MSG_SAMPLE *) ( new char[dsize] );
        memcpy(image->data, dbuff, dsize);
      }
      else
      {
        MSG_data_image_encoded encoded;
        encoded.data   = dbuff;
        encoded.len    = dsize;
        encoded.bpp    = header.image_structure->number_of_bits_per_pixel;
        encoded.nx     = header.image_structure->number_of_columns;
        encoded.ny     = header.image_structure->number_of_lines;
        encoded.format = header.segment_id->data_field_format;
        encoded.decode( image );
      }
      break;

    case MSG_FILE_GTS_MESSAGE:

      dsize = header.data_field_length / 8;
      dbuff = new unsigned char_1[dsize];
      in.read((char *) dbuff, dsize);
      if (in.fail( ))
      {
        std::cerr << "Read error from HRIT file: Data field." << std::endl;
        throw;
      }
      gts_message = new MSG_data_gts;
      dpos = gts_message->read_from(dbuff, dsize);
      {
        std::string outname;
        outname = header.annotation->annotation;
        outname += ".bin";
        gts_message->dump(outname);
      }

      break;

    case MSG_FILE_ALPHANUMERIC_TEXT:

      dsize = header.data_field_length / 8;
      dbuff = new unsigned char_1[dsize];
      in.read((char *) dbuff, dsize);
      if (in.fail( ))
      {
        std::cerr << "Read error from HRIT file: Data field." << std::endl;
        throw;
      }
      text_message = new MSG_data_text;
      dpos = text_message->read_from(dbuff, dsize);


      break;

    case MSG_FILE_ENCRYPTION_KEY_MESSAGE:

      dsize = header.data_field_length / 8;
      dbuff = new unsigned char_1[dsize];
      in.read((char *) dbuff, dsize);
      if (in.fail( ))
      {
        std::cerr << "Read error from HRIT file: Data field." << std::endl;
        throw;
      }
      key_message = new MSG_data_key;
      dpos = key_message->read_from(dbuff, dsize);

      break;

    case MSG_FILE_REPEAT_CYCLE_PROLOGUE:
      dsize = header.data_field_length / 8;

      dbuff = new unsigned char_1[dsize];
      in.read((char *) dbuff, dsize);
      if (in.fail( ))
      {
        std::cerr << "Read error from HRIT file: Data field." << std::endl;
        throw;
      }

      if (header.annotation->product_id_1.find("MSG") != std::string::npos)
      {

        prologue = new MSG_data_level_15_header;


        dpnt = dbuff;
        dpos = prologue->sat_status.read_from(dpnt);
        dpnt += dpos;
        dpos = prologue->image_acquisition.read_from(dpnt);
        dpnt += dpos;
        dpos = prologue->celestial_events.read_from(dpnt);
        dpnt += dpos;
        dpos = prologue->image_description.read_from(dpnt);
        dpnt += dpos;
        dpos = prologue->radiometric_proc.read_from(dpnt);
        dpnt += dpos;
        dpos = prologue->geometric_proc.read_from(dpnt);
        dpnt += dpos;
      }
      else if (header.annotation->product_id_1.find("GOES")
                      != std::string::npos ||
               header.annotation->product_id_1.find("GMS")
                      != std::string::npos ||
               header.annotation->product_id_1.find("MTSAT")
                      != std::string::npos ||
               header.annotation->product_id_1.find("NOAA")
                      != std::string::npos ||
               header.annotation->product_id_1.find("METOP")
                      != std::string::npos)
      {
        dpnt = dbuff;
        sdsprologue = new MSG_data_SGS_header;
        dpos = sdsprologue->read_from(dpnt);
        dpnt += dpos;
      }
      else if (header.annotation->product_id_1.find("MET5")
                      != std::string::npos)
      {
        dpnt = dbuff;
        std::cout << "I have no info on MET5 file format !!!!" << std::endl;
      }
      else
        std::cout << "Unknown Image prologue file content" << std::endl;
      break;

    case MSG_FILE_REPEAT_CYCLE_EPILOGUE:
      dsize = header.data_field_length / 8;
      dbuff = new unsigned char_1[dsize];
      in.read((char *) dbuff, dsize);
      if (in.fail( ))
      {
        std::cerr << "Read error from HRIT file: Data field." << std::endl;
        throw;
      }

      if (header.annotation->product_id_1.find("MSG") != std::string::npos)
      {

        epilogue = new MSG_data_level_15_trailer;

        dpnt = dbuff+1;
        dpos = 1;

        dpos = epilogue->product_stats.read_from(dpnt);
        dpnt += dpos;
        dpos = epilogue->navig_result.read_from(dpnt);
        dpnt += dpos;
        dpos = epilogue->radiometric_qlty.read_from(dpnt);
        dpnt += dpos;
        dpos = epilogue->geometric_qlty.read_from(dpnt);
        dpnt += dpos;
        dpos = epilogue->timelin_comple.read_from(dpnt);
        dpnt += dpos;
      }
      else
        std::cout << "Unknown Image epilogue file content" << std::endl;
      break;

    case MSG_FILE_DCP_MESSAGE:
      break;

    case MSG_FILE_BINARY_MESSAGE:

      dsize = header.data_field_length / 8;
      dbuff = new unsigned char_1[dsize];
      in.read((char *) dbuff, dsize);
      if (in.fail( ))
      {
        std::cerr << "Read error from HRIT file: Data field." << std::endl;
        throw;
      }
      {
        std::ofstream os;
        std::string outname;
        outname = header.annotation->annotation;
        outname += ".bin";
        os.open(outname.c_str( ));
        if (!os.good())
          throw;
        os.write((char *) dbuff, (size_t) dsize);
        os.close( );
      }
      break;

    default:
      std::cerr << "Unknown MSG file type " << header.f_typecode << std::endl;
      throw;
      break;
  }

  if (dbuff) delete [ ] dbuff;

  return;
}
Exemple #22
0
	void ScriptLoader::_nextToken(std::ifstream &stream)
	{
		//EOF token
		if (!stream.good())
		{
			mToken = TOKEN_EOF;
			return;
		}

		//(Get next character)
		int ch = stream.get();

		while ((ch == ' ' || ch == 9) && !stream.eof())
		{    //Skip leading spaces / tabs
			ch = stream.get();
		}

		if (!stream.good())
		{
			mToken = TOKEN_EOF;
			return;
		}

		//Newline token
		if (ch == '\r' || ch == '\n')
		{
			do
			{
				ch = stream.get();
			} while ((ch == '\r' || ch == '\n') && !stream.eof());

			stream.unget();

			mToken = TOKEN_NewLine;
			return;
		}

		//Open brace token
		else if (ch == '{')
		{
			mToken = TOKEN_OpenBrace;
			return;
		}

		//Close brace token
		else if (ch == '}')
		{
			mToken = TOKEN_CloseBrace;
			return;
		}

		//Text token
		if (ch < 32 || ch > 122)    //Verify valid char
		{
			throw std::runtime_error("Parse Error: Invalid character, ConfigLoader::load()");
		}

		mTokenValue = "";
		mToken = TOKEN_Text;
		do
		{
			//Skip comments
			if (ch == '/')
			{
				int ch2 = stream.peek();

				//C++ style comment (//)
				if (ch2 == '/')
				{
					stream.get();
					do
					{
						ch = stream.get();
					} while (ch != '\r' && ch != '\n' && !stream.eof());

					mToken = TOKEN_NewLine;
					return;
				}
			}

			//Add valid char to tokVal
			mTokenValue += (char)ch;

			//Next char
			ch = stream.get();

		} while (ch > 32 && ch <= 122 && !stream.eof());

		stream.unget();

		return;
	}
//Linearly read chunks
void ReadChunk()
{
	//because 3DS file stores data with a tree topology, so i do have considered 
	//recursive/tree-like reading...but there is some mysterious chunks which might vary
	//from time to time... ehh...linear reading will be clearer???

	const UINT c_chunkHeadByteLength = 6;

	//2 numbers at the head of every chunk
	uint16_t chunkID = 0;
	uint32_t chunkLength = 0;

	BINARY_READ(chunkID);
	BINARY_READ(chunkLength);

	//if chunk length corrupted , length data might be invalid
	if (chunkLength > static_fileSize)
	{
		static_currentChunkFileEndPos = static_fileSize - 1;
		fileIn.seekg(0, std::ios::end);
		DEBUG_MSG1("Load 3ds File : chunk is too long ! 3ds file might be damaged!!!");
		return;
	}

	uint64_t tmpFilePos = fileIn.tellg();
	static_currentChunkFileEndPos = tmpFilePos + chunkLength - c_chunkHeadByteLength;

	//in CURRENT chunk, there can be several sub-chunks to read
	switch (chunkID)
	{
	case NOISE_3DS_CHUNKID_MAIN3D:
		ParseMainChunk();//level1
		break;

	case NOISE_3DS_CHUNKID_3D_EDITOR_CHUNK:
		Parse3DEditorChunk();//level2
		break;

	case NOISE_3DS_CHUNKID_OBJECT_BLOCK:
		ParseObjectBlock();//level3
		break;

	case NOISE_3DS_CHUNKID_TRIANGULAR_MESH:
		ParseTriangularMeshChunk();//level4
		break;

	case NOISE_3DS_CHUNKID_VERTICES_LIST:
		ParseVerticesChunk();//level5
		break;

	case NOISE_3DS_CHUNKID_FACES_DESCRIPTION:
		ParseFaceDescAndIndices();//level5
		break;

	case NOISE_3DS_CHUNKID_FACES_MATERIAL:
		ParseFacesAndMatName();//level 6
		break;

	case NOISE_3DS_CHUNKID_MAPPING_COORDINATES_LIST:
		ParseTextureCoordinate();//level5
		break;

	case NOISE_3DS_CHUNKID_MATERIAL_BLOCK:
		ParseMaterialBlock();//level 3
		break;

	case NOISE_3DS_CHUNKID_MATERIAL_NAME:
		ParseMaterialName();//level 4
		break;

	case NOISE_3DS_CHUNKID_AMBIENT_COLOR:
		ParseAmbientColor();//level 4
		break;

	case NOISE_3DS_CHUNKID_DIFFUSE_COLOR:
		ParseDiffuseColor();//level 4
		break;

	case NOISE_3DS_CHUNKID_SPECULAR_COLOR:
		ParseSpecularColor();//level 4
		break;

	case NOISE_3DS_CHUNKID_TEXTURE_MAP:
		ParseDiffuseMap();//level 4
		break;

	case NOISE_3DS_CHUNKID_BUMP_MAP:
		ParseBumpMap();//level 4
		break;

	case NOISE_3DS_CHUNKID_SPECULAR_MAP:
		ParseSpecularMap();//level 4
		break;

		/*case NOISE_3DS_CHUNKID_REFLECTION_MAP:
		ParseReflectionMap();//4
		break;*/

	default:
		//not interested chunks , skip
		SkipCurrentChunk();
		break;
	}

}
Exemple #24
0
void ParticleComponent::DoDeserialization(std::ifstream &loadStream)
{
	loadStream.read((char*)&isEmittedFromHero, sizeof(isEmittedFromHero));
}
Exemple #25
0
 void seek(size_t pos)
 {
     in.seekg(pos,std::ios::beg);
 }
Exemple #26
0
int CGait::InitGait(Aris::RT_CONTROL::CSysInitParameters& param)
{
    int Line_Num;
    double temp;

    std::cout << "Start Reading File" << std::endl;
    std::cout<<"reading file data..."<<std::endl;

    fin.open("./gait/TL.txt");

    for(int i=0;i<GAIT_TURN_LEN;i++)
    {
        fin>>Line_Num;

        for(int j=0;j<GAIT_WIDTH;j++)
        {
            fin>>temp;
            GaitTurnLeft[i][j]=-(int)temp;
        }
    }

    fin.close();

    fin.open("./gait/TR.txt");

    for(int i=0;i<GAIT_TURN_LEN;i++)
    {
        fin>>Line_Num;

        for(int j=0;j<GAIT_WIDTH;j++)
        {
            fin>>temp;
            GaitTurnRight[i][j]=-(int)temp;
        }
    }

    fin.close();

    fin.open("./gait/start.txt");

    for(int i=0;i<GAIT_HOME2START_LEN;i++)
    {
        fin>>Line_Num;

        for(int j=0;j<GAIT_WIDTH;j++)
        {
            fin>>temp;
            GaitHome2Start[i][j]=-(int)temp;
        }
    }

    fin.close();

    //FOWARD

    fin.open("./gait/acc.txt");

    for(int i=0; i<GAIT_ACC_LEN;i++)
    {
        fin>>Line_Num;

        for(int j=0;j<GAIT_WIDTH;j++)
        {
            fin>>temp;
            GaitMove_Acc[i][j]=-(int)temp;
        }

    }
    fin.close();

    fin.open("./gait/cons.txt");

    for(int i=0+GAIT_ACC_LEN; i<GAIT_ACC_LEN+GAIT_CON_LEN;i++)
    {
        fin>>Line_Num;

        for(int j=0;j<GAIT_WIDTH;j++)
        {
            fin>>temp;
            GaitMove_Cons[i-GAIT_ACC_LEN][j]=-(int)temp;
        }

    }
    fin.close();

    fin.open("./gait/dec.txt");

    for(int i=0+GAIT_ACC_LEN+GAIT_CON_LEN; i<GAIT_ACC_LEN+GAIT_CON_LEN+GAIT_DEC_LEN;i++)
    {
        fin>>Line_Num;

        for(int j=0;j<GAIT_WIDTH;j++)
        {
            fin>>temp;
            GaitMove_Dec[i-GAIT_ACC_LEN-GAIT_CON_LEN][j]=-(int)temp;
        }

    }
    fin.close();

    //BACKWARD

    fin.open("./gait/back_acc.txt");

    for(int i=0; i<GAIT_ACC_LEN;i++)
    {
        fin>>Line_Num;

        for(int j=0;j<GAIT_WIDTH;j++)
        {
            fin>>temp;
            GaitMoveBack_Acc[i][j]=-(int)temp;
        }
    }

    fin.close();

    fin.open("./gait/back_cons.txt");

    for(int i=0+GAIT_ACC_LEN; i<GAIT_ACC_LEN+GAIT_CON_LEN;i++)
    {
        fin>>Line_Num;

        for(int j=0;j<GAIT_WIDTH;j++)
        {
            fin>>temp;
            GaitMoveBack_Cons[i-GAIT_ACC_LEN][j]=-(int)temp;
        }
    }

    fin.close();

    fin.open("./gait/back_dec.txt");

    for(int i=0+GAIT_ACC_LEN+GAIT_CON_LEN; i<GAIT_ACC_LEN+GAIT_CON_LEN+GAIT_DEC_LEN;i++)
    {
        fin>>Line_Num;
        for(int j=0;j<GAIT_WIDTH;j++)
        {
            fin>>temp;
            GaitMoveBack_Dec[i-GAIT_ACC_LEN-GAIT_CON_LEN][j]=-(int)temp;
        }
    }

    fin.close();

    return 0;
}
Exemple #27
0
 size_t cur(void)
 {
     return in.tellg();
 }
void GamessukOut::readBasisSet(std::ifstream &ifs)
{

  //std::cout << "readBasisSet\n";

  bool newAtom=true, gotAtom=false, firstAtom=true;
  std::string atomLabel;
  double exponent,coefficient;
  orbital stype;
  int nshell=-1;
  int lastNshell=-1; // the last shell number - is same as nshell when looping through a shell
  int lastStype=-1; // need to keep track of sp shells as we split into s & p

  // For separating sp-shells
  std::vector<double> s_coeff;
  std::vector<double> p_coeff;
  std::vector<double> sp_exponents;

  // skip 2 lines to be just before the first atom label
  ifs.getline(buffer, BUFF_SIZE) && ifs.getline(buffer, BUFF_SIZE);

  // now loop through the basis sets till we hit the end
  while ( ! ifs.eof() )
  {
    ifs.getline(buffer, BUFF_SIZE);
    line=buffer;

    if ( line.compare(0,10," =========") == 0 )
    {
      // End of  basis - add indicies of where the coffecients and exponents of the GTOs for the last shell end
      gukBasis.gtoIndicies.at(  gukBasis.shellLabels.size()-1 ).push_back(
            static_cast<unsigned int>(gukBasis.gtoExponents.size()));
      break;
    }

    // Remove blank space
    line=Trim(line);

    // skip blank lines
    if ( line.size() == 0 ) continue;

    // Separate into tokens
    if ( ! tokenize(tokens, line.c_str(), " \t\n") || tokens.size() == 0 )
    {
      // If the string couldn't be tokenised, set tokens[0] to the entire string
      tokens.clear();
      tokens.push_back( line );
    }

    if ( tokens.size() == 1 )
    {
      // This means a new atomLabel
      newAtom=true;
      if ( firstAtom )
        firstAtom=false;
      else
      {
        // Check if the last shell was sp - if so add the temp sp data structures
        // to the main ones
        if (lastStype == SP )
        {
          addSpBasis(s_coeff, p_coeff, sp_exponents);

          // Clear the temp data structures for separating out sp into s & p
          s_coeff.clear();
          p_coeff.clear();
          sp_exponents.clear();
          lastStype=-1;
        }
        else
        {
          // Add the index for where the GTO coffecients and exponents for the previous shell start
          gukBasis.gtoIndicies.at( gukBasis.shellLabels.size()-1 ).push_back(
                static_cast<unsigned int>(gukBasis.gtoExponents.size()));
        }

      } // end firstAtom

      // Check if we've already processed an atom of this type
      if ( ! gukBasis.labelIndex( tokens.at(0) ) )
      {
        //std::cout << "Processing atom label: " << tokens.at(0) << std::endl;
        gotAtom=false;// we'll be processing this atom
        gukBasis.shellLabels.push_back( tokens.at(0) );
        gukBasis.shells.push_back( std::vector< orbital >() );
        gukBasis.gtoIndicies.push_back( std::vector< unsigned int>() );
      }
      else
        gotAtom=true;
      continue;

    } // End new atomLabel

    // if we're not processing an atom we can skip this line
    if ( gotAtom ) continue;

    /* Here we are reading in a line of the format:
        shell   type  prim       exponents      contraction coefficients
        1       1s       3        5.533350       1.801737  (    0.700713  )
         or
        2       2sp      4        3.664980      -0.747384  (   -0.395897  )       1.709178  (    0.236460  )
      */

    from_string<int>(nshell, tokens.at(0), std::dec);

    if ( nshell != lastNshell )
    {
      // Reading a new shell

      if (! newAtom )
      {
        // Add the data for the last shell processed

        //First check if last shell was sp & we need to add the data we've gathered to the main structures
        if ( lastStype == SP )
        {

          addSpBasis(s_coeff, p_coeff, sp_exponents);

          // Clear the temp data structures for separating out sp into s & p
          s_coeff.clear();
          p_coeff.clear();
          sp_exponents.clear();
        }
        else
        {
          // Add the index for where the primitives for the last shell finish
          gukBasis.gtoIndicies.at( gukBasis.shellLabels.size()-1 ).push_back(
                static_cast<unsigned int>(gukBasis.gtoExponents.size()));

        } // end sp shell

      } // end newAtom

      // need to determine type
      stype = gukBasis.shellTypeFromString(tokens.at(1));
      //std::cout << "Reading new shell of type " << stype << std::endl;

      if ( stype != SP )
      {
        // Add shell to symmetry list and AtomToShellIndex if not sp shell as we do that separately
        gukBasis.shells.at(  gukBasis.shellLabels.size()-1 ).push_back( stype );
      }

    } // end new shell

    // Now check for coefficients - we take the second lot to match Gaussian
    from_string<double>(exponent, tokens.at(3), std::dec);

    if ( stype == SP)
    {
      if ( tokens.size() != 12 ) std::cerr << "PROBLEM READING SP LINE!\n";
      from_string<double>(coefficient, tokens.at(6), std::dec);
      s_coeff.push_back(coefficient);
      from_string<double>(coefficient, tokens.at(10), std::dec);
      p_coeff.push_back(coefficient);
      sp_exponents.push_back(exponent);
    }
    else
    {
      //std::cout << "Adding exponent " << exponent << std::endl;
      gukBasis.gtoExponents.push_back(exponent);
      from_string<double>(coefficient, tokens.at(6), std::dec);
      gukBasis.gtoCoefficients.push_back(coefficient);
    } // end type ==  SP

    lastNshell = nshell;
    lastStype = stype;
    newAtom=false;

  } // end while

  // Finished reading the basis data - now just collect some data from the summary - mainly for checking

  ifs.getline(buffer, BUFF_SIZE); //blank


  // nShell
  ifs.getline(buffer, BUFF_SIZE);
  if (strstr(buffer," total number of shells")==NULL) std::cerr << "Error reading nShell!: " << line << std::endl;
  // reuse nshell from above as temporary variable
  tokenize(tokens, buffer, " \t\n");
  from_string<int>(nshell, tokens.at(4), std::dec);
  gukBasis.nShell=nshell;


  // nBasisFunctions
  ifs.getline(buffer, BUFF_SIZE);
  if (strstr(buffer," total number of basis")==NULL) std::cerr << "Error reading nBasisFunctions!: " << line << std::endl;
  tokenize(tokens, buffer, " \t\n");
  // reuse nshell from above as temporary variable
  from_string<int>(nshell, tokens.at(5), std::dec);
  gukBasis.nBasisFunctions=nshell;

  // nElectrons
  ifs.getline(buffer, BUFF_SIZE);
  if (strstr(buffer," number of electrons")==NULL) std::cerr << "Error reading nElectrons!: " << line << std::endl;
  tokenize(tokens, buffer, " \t\n");
  // reuse nshell from above as temporary variable
  from_string<int>(nshell, tokens.at(3), std::dec);
  gukBasis.nElectrons=nshell;


} // end readBasisSet
Exemple #29
0
 bool operator!() const	{return !in.good();}
Exemple #30
0
            REQUIRE(test_npc->get_skill_level(skill_id("dodge")) == 4);
            REQUIRE(test_npc->pos() == tripoint(72, 54, 0));
        } else {
            // Unrecognized NPC, fail.
            REQUIRE(false);
        }
    }
}

TEST_CASE("Reading a legacy overmap save.") {

    std::string legacy_save_name = "tests/data/legacy_0.C_overmap.sav";
    std::string new_save_name = "tests/data/jsionized_overmap.sav";

    overmap test_map;
    std::ifstream fin;

    fin.open( legacy_save_name.c_str(), std::ifstream::binary );
    REQUIRE( fin.is_open() );
    test_map.unserialize( fin );
    fin.close();
    check_test_overmap_data( test_map );

    std::ofstream fout;

    fout.open( new_save_name.c_str(), std::ofstream::binary );
    REQUIRE( fout.is_open() );
    test_map.serialize(fout);
    fout.close();

    overmap test_map_2;