C++ UTIL_THROW函数代码示例

   /* 
   * Read potential parameters from file.
   */
   void LocalLamellarOrderingExternal::readParameters(std::istream &in) 
   {
      if (nAtomType_ == 0) {
         UTIL_THROW("nAtomType must be set before readParam");
      }
      if (!boundaryPtr_) {
         UTIL_THROW("Boundary must be set before readParam");
      }
   
      // Read parameters
      read<int>(in, "perpDirection", perpDirection_);
      if (perpDirection_ < 0 || perpDirection_ >= Dimension) {
         UTIL_THROW("Invalid index for perpendicular direction.");
      }
      read<int>(in, "parallelDirection", parallelDirection_);
      if (parallelDirection_ < 0 || parallelDirection_ >= Dimension) {
         UTIL_THROW("Invalid index for parallel direction.");
      }
      read<double>(in, "fraction", fraction_);
      prefactor_.allocate(nAtomType_);
      readDArray<double>(in, "prefactor", prefactor_, nAtomType_);
      read<double>(in, "externalParameter", externalParameter_);
      read<double>(in, "interfaceWidth", width_);
      read<int>(in, "periodicity", periodicity_);

      isInitialized_ = true;
   }

   /* 
   * Read potential parameters from file.
   */
   void PeriodicExternal::readParameters(std::istream &in) 
   {
      if (nAtomType_ == 0) {
         UTIL_THROW("nAtomType must be set before readParam");
      }
      if (!boundaryPtr_) {
         UTIL_THROW("Boundary must be set before readParam");
      }
  
      // Read parameters
      prefactor_.allocate(nAtomType_);
      readDArray<double>(in, "prefactor", prefactor_, nAtomType_);

      read<double>(in, "externalParameter", externalParameter_);

      read<int>(in, "nWaveVectors", nWaveVectors_);
      read<double>(in, "C", C_);
      waveVectors_.allocate(nWaveVectors_);
      readDArray<Vector>(in, "waveVectors", waveVectors_, nWaveVectors_);

      phases_.allocate(nWaveVectors_);
      readDArray<double>(in, "phases", phases_, nWaveVectors_);
      read<Vector>(in, "shift", shift_);
      read<double>(in, "interfaceWidth", interfaceWidth_);
      read<int>(in, "periodicity", periodicity_);

      isInitialized_ = true;
   }

   void McSimulation::load(const std::string& filename)
   {
      if (isInitialized_) {
         UTIL_THROW("Error: Called load when already initialized");
      }
      if (!isRestarting_) {
         UTIL_THROW("Error: Called load without restart option");
      }

      // Load from archive
      Serializable::IArchive ar;
      std::ios_base::openmode mode = std::ios_base::in | std::ios_base::binary;
      fileMaster().openRestartIFile(filename, ar.file(), mode);
      load(ar);
      ar.file().close();

      #ifdef UTIL_MPI
      #ifdef MCMD_PERTURB
      if (system().hasPerturbation()) {
         // Read one command file, after reading multiple restart files.
         Util::Log::file() << "Set to use a single command file" 
                           << std::endl;
         setIoCommunicator();
      }
      #endif
      #endif

      isInitialized_ = true;
   }

   /*
   * Remove all ghosts.
   */
   void AtomStorage::clearGhosts()
   {
      // Precondition
      if (locked_) 
         UTIL_THROW("AtomStorage is locked");

      // Clear ghosts from the map
      map_.clearGhosts(ghostSet_);

      // Transfer ghosts from the set to the reservoir
      Atom* atomPtr;
      while (ghostSet_.size() > 0) {
         atomPtr = &ghostSet_.pop();
         ghostReservoir_.push(*atomPtr);
      }

      if (ghostSet_.size() != 0) {
         UTIL_THROW("Nonzero ghostSet size at end of clearGhosts");
      }
      if (map_.nGhost() != 0) {
         UTIL_THROW("Nonzero nGhost in map at end of clearGhosts");
      }
      if (map_.nGhostDistinct() != 0) {
         UTIL_THROW("Nonzero nGhostDistinct at end of clearGhosts");
      }
   }

   /*
   * Load state from an archive.
   */
   void ClusterHistogram::loadParameters(Serializable::IArchive& ar)
   {
      // Load interval and outputFileName
      Analyzer::loadParameters(ar);

      loadParameter<int>(ar,"speciesId", speciesId_);
      if (speciesId_ < 0) {
         UTIL_THROW("Negative speciesId");
      }
      if (speciesId_ >= system().simulation().nSpecies()) {
         UTIL_THROW("speciesId > nSpecies");
      }

      loadParameter<int>(ar, "atomTypeId", atomTypeId_);
      if (atomTypeId_ < 0) {
         UTIL_THROW("Negative atomTypeId");
      }

      loadParameter<double>(ar, "cutoff", cutoff_);
      if (cutoff_ < 0) {
         UTIL_THROW("Negative cutoff");
      }

      identifier_.initialize(speciesId_, atomTypeId_, cutoff_);
      loadParameter<int>(ar, "histMin", histMin_);
      loadParameter<int>(ar, "histMax", histMax_);
      ar >> hist_;

      ar >> nSample_;

      isInitialized_ = true;
   }

   /*
   * Load state from an archive.
   */
   void StructureFactor::loadParameters(Serializable::IArchive& ar)
   {
      Analyzer::loadParameters(ar);
      ar & nAtomType_;
      loadParameter<int>(ar, "nMode", nMode_);
      loadDMatrix<double>(ar, "modes", modes_, nMode_, nAtomType_);
      loadParameter<int>(ar, "nWave", nWave_);
      loadDArray<IntVector>(ar, "waveIntVectors", waveIntVectors_, nWave_);
      ar & structureFactors_;
      ar & nSample_;

      // Validate
      if (nAtomType_ != system().simulation().nAtomType()) {
         UTIL_THROW("Inconsistent values of nAtomType_");
      }
      if (modes_.capacity1() != nMode_) {
         UTIL_THROW("Inconsistent capacity1 for modes array");
      }
      if (modes_.capacity2() != nAtomType_) {
         UTIL_THROW("Inconsistent capacity2 for modes array");
      }
      if (waveIntVectors_.capacity() != nWave_) {
         UTIL_THROW("Inconsistent capacity for waveIntVector");
      }

      // Allocate temporary data structures
      waveVectors_.allocate(nWave_);
      fourierModes_.allocate(nWave_, nMode_);

      isInitialized_ = true;
   }

void ScoreFeatureManager::configure(const std::vector<std::string> args)
{
  bool domainAdded = false;
  bool sparseDomainAdded = false;

  for (size_t i = 0; i < args.size(); ++i) {
  	if (args[i] == "--IgnoreSentenceId") {
      m_includeSentenceId = true;
    } else if (args[i].substr(0,8) == "--Domain") {
      string type = args[i].substr(8);
      ++i;
      UTIL_THROW_IF(i == args.size(), ScoreFeatureArgumentException, "Missing domain file");
      string domainFile = args[i];
      UTIL_THROW_IF(domainAdded, ScoreFeatureArgumentException,
                    "Only allowed one domain feature");
      if (type == "Subset") {
        m_features.push_back(ScoreFeaturePtr(new SubsetDomainFeature(domainFile)));
      } else if (type == "Ratio") {
        m_features.push_back(ScoreFeaturePtr(new RatioDomainFeature(domainFile)));
      } else if (type == "Indicator") {
        m_features.push_back(ScoreFeaturePtr(new IndicatorDomainFeature(domainFile)));
      } else {
        UTIL_THROW(ScoreFeatureArgumentException, "Unknown domain feature type " << type);
      }
      domainAdded = true;
      m_includeSentenceId = true;
    } else if (args[i].substr(0,14) == "--SparseDomain") {
      string type = args[i].substr(14);
      ++i;
      UTIL_THROW_IF(i == args.size(), ScoreFeatureArgumentException, "Missing domain file");
      string domainFile = args[i];
      UTIL_THROW_IF(sparseDomainAdded, ScoreFeatureArgumentException,
                    "Only allowed one sparse domain feature");
      if (type == "Subset") {
        m_features.push_back(ScoreFeaturePtr(new SparseSubsetDomainFeature(domainFile)));
      } else if (type == "Ratio") {
        m_features.push_back(ScoreFeaturePtr(new SparseRatioDomainFeature(domainFile)));
      } else if (type == "Indicator") {
        m_features.push_back(ScoreFeaturePtr(new SparseIndicatorDomainFeature(domainFile)));
      } else {
        UTIL_THROW(ScoreFeatureArgumentException, "Unknown domain feature type " << type);
      }
      sparseDomainAdded = true;
      m_includeSentenceId = true;
    } else if(args[i] == "--GHKMFeatureSparse"){
    	//MARIA
    	m_features.push_back(ScoreFeaturePtr(new InternalStructFeatureSparse()));
    } else if(args[i] == "--GHKMFeatureDense"){
    	//MARIA
    	m_features.push_back(ScoreFeaturePtr(new InternalStructFeatureDense()));
    } else {
      UTIL_THROW(ScoreFeatureArgumentException,"Unknown score argument " << args[i]);
    	}

  }

}

 /* 
 * Set nAtomType
 */
 void OrthoBoxExternal::setNAtomType(int nAtomType) 
 {  
    if (nAtomType <= 0) {
       UTIL_THROW("nAtomType <= 0");
    }
    if (nAtomType > MaxAtomType) {
       UTIL_THROW("nAtomType > OrthoBoxExternal::MaxAtomType");
    }
    nAtomType_ = nAtomType;
 }

 /* 
 * Set nAtomType
 */
 void NucleationExternal::setNAtomType(int nAtomType) 
 {  
    if (nAtomType <= 0) {
       UTIL_THROW("nAtomType <= 0");
    }
    if (nAtomType > MaxAtomType) {
       UTIL_THROW("nAtomType > NucleationExternal::MaxAtomType");
    }
    nAtomType_ = nAtomType;
 }

 /*
 * Clear memory block (reset to empty state).
 */
 void MemoryIArchive::clear()
 {
    if (!isAllocated()) {
       UTIL_THROW("Archive is not allocated");
    }
    if (!ownsData_) {  
       UTIL_THROW("Archive does not own data");
    }
    cursor_ = begin(); 
    end_ = begin();
 }

void OnDiskWrapper::BeginLoad(const std::string &filePath)
{
  if (!OpenForLoad(filePath)) {
    UTIL_THROW(util::FileOpenException, "Couldn't open for loading: " << filePath);
  }

  if (!m_vocab.Load(*this))
    UTIL_THROW(util::FileOpenException, "Couldn't load vocab");

  UINT64 rootFilePos = GetMisc("RootNodeOffset");
  m_rootSourceNode = new PhraseNode(rootFilePos, *this);
}

 /*
 * Finalize receiving block, check consistency.
 */
 void Buffer::endRecvBlock()
 {
    if (recvSize_ != 0) {
       UTIL_THROW("Error: Recv counter != 0 at end of block");
    }
    if (recvPtr_ != recvBlockEnd_) {
       UTIL_THROW("Error: Inconsistent recv cursor at end of block");
    }
    recvBlockBegin_ = 0;
    recvBlockEnd_ = 0;
    recvSize_ = 0;
    recvType_ = NONE;
 }

 /*
 * Clear accumulators.
 */
 void McMuExchange::setup()
 {
    nMolecule_ = system().nMolecule(speciesId_);
    if (nMolecule_ > accumulators_.capacity()) {
       UTIL_THROW("nMolecule > capacity");
    }
    if (nMolecule_ <= 0) {
       UTIL_THROW("nMolecule <= 0");
    }
    for (int iMol = 0; iMol < nMolecule_; ++iMol) {
       accumulators_[iMol].clear();
    }
 }

 /*
 * Read saveInterval and saveFileName.
 */
 void Integrator::readParameters(std::istream& in)
 {
    read<int>(in, "saveInterval", saveInterval_);
    if (saveInterval_ > 0) {
       if (Analyzer::baseInterval > 0) {
          if (saveInterval_ % Analyzer::baseInterval != 0) {
             UTIL_THROW("saveInterval is not a multiple of baseInterval");
          }
       } else {
          UTIL_THROW("Analyzer::baseInterval is not positive");
       }
       read<std::string>(in, "saveFileName", saveFileName_);
    }
 }

GlobalLexicalModelUnlimited::GlobalLexicalModelUnlimited(const std::string &line)
  :StatelessFeatureFunction(0, line)
{
  UTIL_THROW(util::Exception,
             "GlobalLexicalModelUnlimited hasn't been refactored for new feature function framework yet"); // TODO need to update arguments to key=value

  const vector<string> modelSpec = Tokenize(line);

  for (size_t i = 0; i < modelSpec.size(); i++ ) {
    bool ignorePunctuation = true, biasFeature = false, restricted = false;
    size_t context = 0;
    string filenameSource, filenameTarget;
    vector< string > factors;
    vector< string > spec = Tokenize(modelSpec[i]," ");

    // read optional punctuation and bias specifications
    if (spec.size() > 0) {
      if (spec.size() != 2 && spec.size() != 3 && spec.size() != 4 && spec.size() != 6) {
        std::cerr << "Format of glm feature is <factor-src>-<factor-tgt> [ignore-punct] [use-bias] "
                  <<  "[context-type] [filename-src filename-tgt]";
        //return false;
      }

      factors = Tokenize(spec[0],"-");
      if (spec.size() >= 2)
        ignorePunctuation = Scan<size_t>(spec[1]);
      if (spec.size() >= 3)
        biasFeature = Scan<size_t>(spec[2]);
      if (spec.size() >= 4)
        context = Scan<size_t>(spec[3]);
      if (spec.size() == 6) {
        filenameSource = spec[4];
        filenameTarget = spec[5];
        restricted = true;
      }
    } else
      factors = Tokenize(modelSpec[i],"-");

    if ( factors.size() != 2 ) {
      std::cerr << "Wrong factor definition for global lexical model unlimited: " << modelSpec[i];
      //return false;
    }

    const vector<FactorType> inputFactors = Tokenize<FactorType>(factors[0],",");
    const vector<FactorType> outputFactors = Tokenize<FactorType>(factors[1],",");
    throw runtime_error("GlobalLexicalModelUnlimited should be reimplemented as a stateful feature");
    GlobalLexicalModelUnlimited* glmu = NULL; // new GlobalLexicalModelUnlimited(inputFactors, outputFactors, biasFeature, ignorePunctuation, context);

    if (restricted) {
      cerr << "loading word translation word lists from " << filenameSource << " and " << filenameTarget << endl;
      if (!glmu->Load(filenameSource, filenameTarget)) {
        std::cerr << "Unable to load word lists for word translation feature from files "
                  << filenameSource
                  << " and "
                  << filenameTarget;
        //return false;
      }
    }
  }
}