Пример #1
0
void TripodClient::getMissedKeys(const DataMap& res, const KeySeq& keys, KeySeq& missedKeys) {
    for(KeySeq::const_iterator it = keys.begin(); it != keys.end(); ++it) {
        if(res.find(*it) == res.end()) {
            missedKeys.push_back(*it);
        }
    }
}
Пример #2
0
TicketData TicketAdapter::queryTicket(const string& ticket) {
  TicketData data;
  if(TicketUtil::isSTicketLegal(ticket)) {
    KeySeq keys, missedKeys;
    keys.push_back(ticket);
    DataMap dataMap = _tripodClient->get(keys, missedKeys);
    DataMap::const_iterator it = dataMap.find(ticket);
    if(it != dataMap.end()) {
      string value(it->second.begin(), it->second.end());
      istringstream in(value);
      data.ParseFromIstream(&in);
    }
  }
  return data;
}
Пример #3
0
void
FreezeScript::AssignVisitor::visitDictionary(const DictionaryDataPtr& dest)
{
    Slice::TypePtr type = dest->getType();
    DictionaryDataPtr d = DictionaryDataPtr::dynamicCast(_src);
    if(d && isCompatible(type, _src->getType()))
    {
        DataMap& srcMap = d->getElements();
        DataMap destMap;
        Slice::DictionaryPtr dictType = Slice::DictionaryPtr::dynamicCast(type);
        assert(dictType);
        Slice::TypePtr keyType = dictType->keyType();
        Slice::TypePtr valueType = dictType->valueType();
        string typeName = typeToString(type);
        for(DataMap::const_iterator p = srcMap.begin(); p != srcMap.end(); ++p)
        {
            DataPtr key = _factory->create(keyType, false);
            Destroyer<DataPtr> keyDestroyer(key);
            DataPtr value = _factory->create(valueType, false);
            Destroyer<DataPtr> valueDestroyer(value);

            AssignVisitor keyVisitor(p->first, _factory, _errorReporter, _convert, typeName + " key");
            key->visit(keyVisitor);

            AssignVisitor valueVisitor(p->second, _factory, _errorReporter, _convert, typeName + " value");
            value->visit(valueVisitor);

            DataMap::const_iterator q = destMap.find(key);
            if(q != destMap.end())
            {
                error("duplicate dictionary key in " + typeToString(dictType));
            }
            else
            {
                destMap.insert(DataMap::value_type(key, value));
                keyDestroyer.release();
                valueDestroyer.release();
            }
        }
        DataMap& m = dest->getElements();
        m.swap(destMap);
    }
    else
    {
        typeMismatchError(type, _src->getType());
    }
}
Пример #4
0
long TicketAdapter::verifyTicket(const string& ticket, const IntSeq& types) {
  long result = -1;
  if(TicketUtil::isSTicketLegal(ticket)) {
    KeySeq keys, missedKeys;
    keys.push_back(ticket);
    DataMap dataMap = _tripodClient->get(keys, missedKeys);
    DataMap::const_iterator itm = dataMap.find(ticket);
    if(itm != dataMap.end()) {
      TicketData data;
      string value(itm->second.begin(), itm->second.end());
      istringstream in(value);
      data.ParseFromIstream(&in);
      int type = data.type();
      for(IntSeq::const_iterator it = types.begin(); it != types.end(); ++it) {
        if(type == *it) {
          result = data.id();
          break;
        }
      }
    }
  }
  return result;
}
Пример #5
0
  void writeECLData(const UnstructuredGrid& grid,
                    const DataMap& data,
                    const int current_step,
                    const double current_time,
                    const boost::posix_time::ptime& current_date_time,
                    const std::string& output_dir,
                    const std::string& base_name) {
    
    ecl_file_enum file_type = ECL_UNIFIED_RESTART_FILE;  // Alternatively ECL_RESTART_FILE for multiple restart files.
    bool fmt_file           = true; 
    
    char * filename         = ecl_util_alloc_filename(output_dir.c_str() , base_name.c_str() , file_type , fmt_file , current_step );
    int phases              = ECL_OIL_PHASE + ECL_WATER_PHASE;
    double days             = Opm::unit::convert::to(current_time, Opm::unit::day);
    time_t date             = 0;
    int nx                  = grid.cartdims[0];
    int ny                  = grid.cartdims[1];
    int nz                  = grid.cartdims[2];
    int nactive             = grid.number_of_cells;
    ecl_rst_file_type * rst_file;
    
    {
      using namespace boost::posix_time;
      ptime t0( boost::gregorian::date(1970 , 1 ,1) );
      time_duration::sec_type seconds = (current_date_time - t0).total_seconds();
      
      date = time_t( seconds );
    }
    
    if (current_step > 0 && file_type == ECL_UNIFIED_RESTART_FILE)
      rst_file = ecl_rst_file_open_append( filename );
    else
      rst_file = ecl_rst_file_open_write( filename );
    
    ecl_rst_file_fwrite_header( rst_file , current_step , date , days , nx , ny , nz , nactive , phases );
    ecl_rst_file_start_solution( rst_file );

    {
      DataMap::const_iterator i = data.find("pressure");
      if (i != data.end()) {
        ecl_kw_type * pressure_kw = ecl_kw_wrapper( grid , "PRESSURE" , i->second , 0 , 1);
        ecl_rst_file_add_kw( rst_file , pressure_kw );
        ecl_kw_free( pressure_kw );
      }
    }
    
    {
      DataMap::const_iterator i = data.find("saturation");
      if (i != data.end()) {
        if (int(i->second->size()) != 2 * grid.number_of_cells) {
          THROW("writeECLData() requires saturation field to have two phases.");
        }
        ecl_kw_type * swat_kw = ecl_kw_wrapper( grid , "SWAT" , i->second , 0 , 2);
        ecl_rst_file_add_kw( rst_file , swat_kw );
        ecl_kw_free( swat_kw );
      }
    }

    ecl_rst_file_end_solution( rst_file );
    ecl_rst_file_close( rst_file );
    free(filename);
  } 
Пример #6
0
void
FreezeScript::TransformVisitor::visitDictionary(const DictionaryDataPtr& dest)
{
    Slice::TypePtr type = dest->getType();
    if(_info->doDefaultTransform(type))
    {
        DictionaryDataPtr d = DictionaryDataPtr::dynamicCast(_src);
        if(d && isCompatible(type, _src->getType()))
        {
            DataMap& srcMap = d->getElements();
            DataMap destMap;
            Slice::DictionaryPtr dictType = Slice::DictionaryPtr::dynamicCast(type);
            assert(dictType);
            Slice::TypePtr keyType = dictType->keyType();
            Slice::TypePtr valueType = dictType->valueType();
            string typeName = typeToString(type);
            for(DataMap::const_iterator p = srcMap.begin(); p != srcMap.end(); ++p)
            {
                DataPtr key = _info->getDataFactory()->create(keyType, false);
                Destroyer<DataPtr> keyDestroyer(key);
                DataPtr value = _info->getDataFactory()->create(valueType, false);
                Destroyer<DataPtr> valueDestroyer(value);

                TransformVisitor keyVisitor(p->first, _info, typeName + " key");
                key->visit(keyVisitor);

                try
                {
                    TransformVisitor valueVisitor(p->second, _info, typeName + " value");
                    value->visit(valueVisitor);
                }
                catch(const ClassNotFoundException& ex)
                {
                    //
                    // If transformation of the dictionary value fails because a class
                    // could not be found, then we invoke purgeObjects() to determine
                    // whether we should ignore the situation (and remove the element
                    // from the dictionary) or raise the exception again.
                    //
                    if(!_info->purgeObjects())
                    {
                        throw;
                    }
                    warning("purging element of dictionary " + typeToString(dictType) + " due to missing class type " +
                            ex.id);
                    continue;
                }

                DataMap::const_iterator q = destMap.find(key);
                if(q != destMap.end())
                {
                    warning("duplicate dictionary key in " + typeToString(dictType));
                }
                else
                {
                    destMap.insert(DataMap::value_type(key, value));
                    keyDestroyer.release();
                    valueDestroyer.release();
                }
            }
            DataMap& m = dest->getElements();
            m.swap(destMap);
        }
        else
        {
            typeMismatchError(type, _src->getType());
        }
    }
    _info->executeCustomTransform(dest, _src);
}
Пример #7
0
void writeVtkData(const UnstructuredGrid& grid,
                  const DataMap& data,
                  std::ostream& os)
{
    if (grid.dimensions != 3) {
        OPM_THROW(std::runtime_error, "Vtk output for 3d grids only");
    }
    os.precision(12);
    os << "<?xml version=\"1.0\"?>\n";
    PMap pm;
    pm["type"] = "UnstructuredGrid";
    Tag vtkfiletag("VTKFile", pm, os);
    Tag ugtag("UnstructuredGrid", os);
    int num_pts = grid.number_of_nodes;
    int num_cells = grid.number_of_cells;
    pm.clear();
    pm["NumberOfPoints"] = boost::lexical_cast<std::string>(num_pts);
    pm["NumberOfCells"] = boost::lexical_cast<std::string>(num_cells);
    Tag piecetag("Piece", pm, os);
    {
        Tag pointstag("Points", os);
        pm.clear();
        pm["type"] = "Float64";
        pm["Name"] = "Coordinates";
        pm["NumberOfComponents"] = "3";
        pm["format"] = "ascii";
        Tag datag("DataArray", pm, os);
        for (int i = 0; i < num_pts; ++i) {
            Tag::indent(os);
            os << grid.node_coordinates[3*i + 0] << ' '
               << grid.node_coordinates[3*i + 1] << ' '
               << grid.node_coordinates[3*i + 2] << '\n';
        }
    }
    {
        Tag cellstag("Cells", os);
        pm.clear();
        pm["type"] = "Int32";
        pm["NumberOfComponents"] = "1";
        pm["format"] = "ascii";
        std::vector<int> cell_numpts;
        cell_numpts.reserve(num_cells);
        {
            pm["Name"] = "connectivity";
            Tag t("DataArray", pm, os);
            int hf = 0;
            for (int c = 0; c < num_cells; ++c) {
                std::set<int> cell_pts;
                for (; hf < grid.cell_facepos[c+1]; ++hf) {
                    int f = grid.cell_faces[hf];
                    const int* fnbeg = grid.face_nodes + grid.face_nodepos[f];
                    const int* fnend = grid.face_nodes + grid.face_nodepos[f+1];
                    cell_pts.insert(fnbeg, fnend);
                }
                cell_numpts.push_back(cell_pts.size());
                Tag::indent(os);
                std::copy(cell_pts.begin(), cell_pts.end(),
                          std::ostream_iterator<int>(os, " "));
                os << '\n';
            }
        }
        {
            pm["Name"] = "offsets";
            Tag t("DataArray", pm, os);
            int offset = 0;
            const int num_per_line = 10;
            for (int c = 0; c < num_cells; ++c) {
                if (c % num_per_line == 0) {
                    Tag::indent(os);
                }
                offset += cell_numpts[c];
                os << offset << ' ';
                if (c % num_per_line == num_per_line - 1
                        || c == num_cells - 1) {
                    os << '\n';
                }
            }
        }
        std::vector<int> cell_foffsets;
        cell_foffsets.reserve(num_cells);
        {
            pm["Name"] = "faces";
            Tag t("DataArray", pm, os);
            const int* fp = grid.cell_facepos;
            int offset = 0;
            for (int c = 0; c < num_cells; ++c) {
                Tag::indent(os);
                os << fp[c+1] - fp[c] << '\n';
                ++offset;
                for (int hf = fp[c]; hf < fp[c+1]; ++hf) {
                    int f = grid.cell_faces[hf];
                    const int* np = grid.face_nodepos;
                    int f_num_pts = np[f+1] - np[f];
                    Tag::indent(os);
                    os << f_num_pts << ' ';
                    ++offset;
                    std::copy(grid.face_nodes + np[f],
                              grid.face_nodes + np[f+1],
                              std::ostream_iterator<int>(os, " "));
                    os << '\n';
                    offset += f_num_pts;
                }
                cell_foffsets.push_back(offset);
            }
        }
        {
            pm["Name"] = "faceoffsets";
            Tag t("DataArray", pm, os);
            const int num_per_line = 10;
            for (int c = 0; c < num_cells; ++c) {
                if (c % num_per_line == 0) {
                    Tag::indent(os);
                }
                os << cell_foffsets[c] << ' ';
                if (c % num_per_line == num_per_line - 1
                        || c == num_cells - 1) {
                    os << '\n';
                }
            }
        }
        {
            pm["type"] = "UInt8";
            pm["Name"] = "types";
            Tag t("DataArray", pm, os);
            const int num_per_line = 10;
            for (int c = 0; c < num_cells; ++c) {
                if (c % num_per_line == 0) {
                    Tag::indent(os);
                }
                os << "42 ";
                if (c % num_per_line == num_per_line - 1
                        || c == num_cells - 1) {
                    os << '\n';
                }
            }
        }
    }
    {
        pm.clear();
        if (data.find("saturation") != data.end()) {
            pm["Scalars"] = "saturation";
        } else if (data.find("pressure") != data.end()) {
            pm["Scalars"] = "pressure";
        }
        Tag celldatatag("CellData", pm, os);
        pm.clear();
        pm["NumberOfComponents"] = "1";
        pm["format"] = "ascii";
        pm["type"] = "Float64";
        for (DataMap::const_iterator dit = data.begin(); dit != data.end(); ++dit) {
            pm["Name"] = dit->first;
            const std::vector<double>& field = *(dit->second);
            const int num_comps = field.size()/grid.number_of_cells;
            pm["NumberOfComponents"] = boost::lexical_cast<std::string>(num_comps);
            Tag ptag("DataArray", pm, os);
            const int num_per_line = num_comps == 1 ? 5 : num_comps;
            for (int item = 0; item < num_cells*num_comps; ++item) {
                if (item % num_per_line == 0) {
                    Tag::indent(os);
                }
                double value = field[item];
                if (std::fabs(value) < std::numeric_limits<double>::min()) {
                    // Avoiding denormal numbers to work around
                    // bug in Paraview.
                    value = 0.0;
                }
                os << value << ' ';
                if (item % num_per_line == num_per_line - 1
                        || item == num_cells - 1) {
                    os << '\n';
                }
            }
        }
    }
}
Пример #8
0
    void CsvFile::read(HeaderList& header, DataMap& data) const  throw (FileException, CustomException)
    {
        std::ifstream file(filename.c_str()); 
        if (!file)  throw FileException("Cannot open file", filename, __FUNCTION_NAME__);
	
	
        // a buffer to store the line read
        std::string line;
	
        if ( ! std::getline(file, line))
            throw FileException("Cannot get the first line of file", filename, __FUNCTION_NAME__);
	

        unsigned int pointer = 0;
        unsigned int rawnb = 0;
        std::string word ="";
        int localHostColNumber = -1, tmp=0;
        bool uselocalhost=false;
        bool useotherthanlocalhost=false;
	
        // Parse the first line (header line)
        while(pointer < line.size())
            {
                while( pointer < line.size() && line[pointer] != separator)
                    {
                        //remove white spaces
                        if (line[pointer] != ' ')
                            {
                                word.push_back(line[pointer]);
                            }
                        pointer++;
                    }
                if( !word.empty())
                    {
                        // warning      if id    already in
                        if (std::find(header.begin(), header.end(), word) != header.end() )  
                            {
                                // Was error before, now just a warning: may be convenient  to have several time the same name in a header
                                Msg::warning("Duplicate header element '"+ word+"' in file "+filename, __FUNCTION_NAME__);
                                // throw FileException("Duplicate header elements'"+ word+"'",filename, __FUNCTION_NAME__);
                            }
                        header.push_back(word);
                        tmp++;
                     }
                // if we have "localhost" in csv file, note the column number.
                if(word == "localhost" || word == "Localhost" || word == "127.0.0.1")
                	localHostColNumber = tmp;

                 pointer++;
                word.clear();
            }
	  
        // Parse the lines
        while (std::getline(file, line))
            {
                rawnb++;
                pointer = 0;
                bool firstWord = true; // Are we parsing the first column
                unsigned int column = 0; // Which column is being scanned?
                std::string id;
                while(line.size() > pointer)
                    {	
                        // get word
                        word.clear();
                        while(line.size() > pointer && line[pointer] != separator)
                            {
                                if (line[pointer] != ' ')
                                    word.push_back(line[pointer]);
                                pointer++;
                            }
                        pointer++;
		  

                        if (firstWord)
                            {
                                // it's the map  id 
                                if ( word.empty() )  break; // forget about this line and go to parse next line
                                id = word;

                                if(data.find(id) != data.end())
                                	throw CustomException("Component : " + id + " is specified twice in CSV file.", __FUNCTION_NAME__ );

                                // init the raw of this id with zeros.
                                data[id].insert(data[id].begin(), header.size(),0);
                                firstWord = false;
                            }
                        else
                            {
                                if (!word.empty())
                                    {
                                	// store data
                                	try{
                                		data[id].at(column) = convertTo<int>(word);

                                		if (data[id].at(column) > 0)// one component instance at least mapped
                                		{
                                			if(column == localHostColNumber-1)   // we are reading in a locahost column
                                			{
                                				// Remember that we have one component mapped on a localHost.
                                				uselocalhost=true;
                                			}
                                			else
                                			{
                                				// Remember that we have one component mapped on an host different  from  localHost.
                                				useotherthanlocalhost=true;
                                			}
                                			if(uselocalhost && useotherthanlocalhost)
                                				throw FileException("Host name 'localhost' is used in CSV file in conjunction with other host names or IP address. Replace 'localhost' by IP address or machine name to avoid problems", filename,  __FUNCTION_NAME__);
                                		}
                                	}//end try
                                       catch(const BadConversion& e)
                                            {
                                                throw FileException("Raw="+toString<unsigned int>(rawnb+1)+", col="+toString<unsigned int>(column+2)+") contains non integer value="+word,filename, __FUNCTION_NAME__);
                                                //			      std::cerr << "ERROR: Csv File "<<fileName<<", element (raw="<<rawnb+1<<", col="<<column+2<<") contains non integer value="<<word<< std::endl;
                                            }
                                        catch(const std::out_of_range& e)
                                            {
                                                throw FileException("Element (raw="+toString<unsigned int>(rawnb+1)+", col="+toString<unsigned int>(column+2)+")  out of column  (value="+word+", ignored)",filename, __FUNCTION_NAME__);
                                                //			      std::cerr << "WARNING : Csv File "<<fileName<<", element (raw="<<rawnb+1<<", col="<<column+2<<")  out of column  (value="<<word<<", ignored)"<< std::endl;
                                            }

                                    }
                                column++;
                            }
                    }
            }
    };
Пример #9
0
/** sqlite3_exec的回调。
*
*  向控制台打印查询的结果。
*
*  @param in data 传递给回调函数的数据。
*  @param in n_columns sqlite3_exec执行结果集中列的数量。
*  @param in col_values sqlite3_exec执行结果集中每一列的数据。
*  @param in col_names sqlite3_exec执行结果集中每一列的名称。
*  @return 状态码。
*/
int sqlite3_exec_callback(void *data, int n_columns, char **col_values, char **col_names)
{
	s_trade trade;
	long time_peroid = 0;
    /*
	for (int i = 0; i < n_columns; i++)
    {
	printf("%s:%s\t", col_names[i], col_values[i]);
    }
	*/
	trade.timestamp = atol(col_values[0]);
	trade.price = atof(col_values[1]);
	trade.amount = atof(col_values[2]);
	
    if(0 == strcmp((const char *)data, "5m")){
		time_peroid = 5*60;
	} else if(0 == strcmp((const char *)data, "15m")){
		time_peroid = 15*60;
	} else if(0 == strcmp((const char *)data, "30m")){
		time_peroid = 30*60;
	} else if(0 == strcmp((const char *)data, "1h")){
		time_peroid = 60*60;
	} else if(0 == strcmp((const char *)data, "4h")){
		time_peroid = 60*60;
	} else if(0 == strcmp((const char *)data, "1d")){
		time_peroid = 60*60*24;
	}
	
	if(0 != time_peroid){
		long time = ((long)(trade.timestamp/time_peroid))*time_peroid;
		DataMap::iterator it = dataMap.find(time);
		if(it==dataMap.end())
		{
			s_history history;
			history.amount = trade.amount;
			history.open = trade.price;
			history.close = trade.price;
			history.high = trade.price;
			history.low = trade.price;
			history.timestamp = time;
			history.open_timestamp = trade.timestamp;
			history.close_timestamp = trade.timestamp;
			dataMap.insert(std::make_pair(time, history));
		} else {
			it->second.amount += trade.amount;
			if(trade.price > it->second.high){
				it->second.high = trade.price;
			}
			if(trade.price < it->second.low){
				it->second.low = trade.price;
			}
			if(trade.timestamp < it->second.open_timestamp){
				it->second.open = trade.price;
				it->second.open_timestamp = trade.timestamp;
			}
			if(trade.timestamp > it->second.close_timestamp){
				it->second.close = trade.price;
				it->second.close_timestamp = trade.timestamp;
			}
		}
	}
	
    return 0;
}