Exemple #1
0
inline
void read_image( const String&    file_name
               , Image&           img
               , const FormatTag& tag
               , typename enable_if< mpl::and_< detail::is_supported_path_spec< String >
                                              , is_format_tag< FormatTag >
                                              , is_read_supported< typename get_pixel_type< typename Image::view_t >::type
                                                                 , FormatTag
                                                                 >
                                              >
                                   >::type* /* ptr */ = 0
               )
{
    typedef typename get_reader< String
                               , FormatTag
                               , detail::read_and_no_convert
                               >::type reader_t;

    reader_t reader = make_reader( file_name
                                 , tag
                                 , detail::read_and_no_convert()
                                 );

    read_image( reader
              , img
              );
}
Exemple #2
0
inline
void read_image( Device&                                 file
               , Image&                                  img
               , const image_read_settings< FormatTag >& settings
               , typename enable_if< mpl::and_< detail::is_read_device< FormatTag
                                                                      , Device
                                                                      >
                                              , is_format_tag< FormatTag >
                                              , is_read_supported< typename get_pixel_type< typename Image::view_t >::type
                                                                 , FormatTag
                                                                 >
                                              >
                                   >::type* /* ptr */ = 0
               )
{
    typedef typename get_reader< Device
                               , FormatTag
                               , detail::read_and_no_convert
                               >::type reader_t;

    reader_t reader = make_reader( file
                                 , settings
                                 , detail::read_and_no_convert()
                                 );

    read_image( reader
              , img
              );
}
Exemple #3
0
inline
void read_view( const String&    file_name
              , const View&      view
              , const FormatTag& tag
              , typename enable_if< typename mpl::and_< typename detail::is_supported_path_spec< String >::type
                                                      , typename is_format_tag< FormatTag >::type
                                                      , typename is_read_supported< typename get_pixel_type< View >::type
                                                                                  , FormatTag
                                                                                  >::type
                                                      >::type
                                  >::type* /* ptr */ = 0
              )
{
    typedef typename get_reader< String
                               , FormatTag
                               , detail::read_and_no_convert
                               >::type reader_t;

    reader_t reader = make_reader( file_name
                                 , tag
                                 , detail::read_and_no_convert()
                                 );

    read_view( reader
             , view
             );
}
Exemple #4
0
inline
void read_view( Device&                                 file
              , const View&                             view
              , const image_read_settings< FormatTag >& settings
              , typename enable_if< typename mpl::and_< detail::is_read_device< FormatTag
                                                                              , Device
                                                                              >
                                                      , typename is_format_tag< FormatTag >::type
                                                      , typename is_read_supported< typename get_pixel_type< View >::type
                                                                                  , FormatTag
                                                                                  >::type
                                                      >::type
                                  >::type* /* ptr */ = 0
              )
{
    typedef typename get_reader< Device
                               , FormatTag
                               , detail::read_and_no_convert
                               >::type reader_t;

    reader_t reader = make_reader( file
                                 , settings
                                 , detail::read_and_no_convert()
                                 );

    read_view( reader
             , view
             );
}
inline
void read_and_convert_view( Device&                                 device
                          , const View&                             view
                          , const image_read_settings< FormatTag >& settings
                          , const ColorConverter&                   cc
                          , typename enable_if< mpl::and_< detail::is_read_device< FormatTag
                                                                                 , Device
                                                                                 >
                                                         , is_format_tag< FormatTag >
                                                         >
                                              >::type* /* ptr */ = 0

                          )
{
    typedef typename get_reader< Device
                               , FormatTag
                               , detail::read_and_convert< ColorConverter >
                               >::type reader_t;

    reader_t reader = make_reader( device
                                 , settings
                                 , detail::read_and_convert< ColorConverter >( cc )
                                 );

    read_and_convert_view( reader
                         , view
                         );
}
Exemple #6
0
 ReaderPtr get(const String& key) const final {
   auto it = this->ref_.find(key);
   if (it != this->ref_.end()) {
     return make_reader(it->second);
   }
   return nullptr;
 }
inline
void read_and_convert_view( Device&          device
                          , const View&      view
                          , const FormatTag& tag
                          , typename enable_if< mpl::and_< detail::is_read_device< FormatTag
                                                                                 , Device
                                                                                 >
                                                         , is_format_tag< FormatTag >
                                                         >
                                               >::type* /* ptr */ = 0
                          )
{
    typedef typename get_reader< Device
                               , FormatTag
                               , detail::read_and_convert< default_color_converter >
                               >::type reader_t;

    reader_t reader = make_reader( device
                                 , tag
                                 , detail::read_and_convert< default_color_converter >()
                                 );

    read_and_convert_view( reader
                         , view
                         );
}
inline
void read_and_convert_view( const String&         file_name
                          , const View&           view
                          , const ColorConverter& cc
                          , const FormatTag&      tag
                          , typename enable_if< mpl::and_< is_format_tag< FormatTag >
                                                         , detail::is_supported_path_spec< String >
                                                         >
                                            >::type* /* ptr */ = 0
                          )
{
    typedef typename get_reader< String
                               , FormatTag
                               , detail::read_and_convert< ColorConverter >
                               >::type reader_t;

    reader_t reader = make_reader( file_name
                                 , tag
                                 , detail::read_and_convert< ColorConverter >( cc )
                                 );

    read_and_convert_view( reader
                         , view
                         );
}
Exemple #9
0
SQInteger ts::script_api::car_model::getCarName(HSQUIRRELVM vm)
{
    Userdata<resources::Car_model> car_model_udata;
    
    Argument_stream argument_stream(vm, "CarModel::getCarName");
    argument_stream(make_reader(car_model_udata));

    if (argument_stream && car_model_udata->model)
    {
        const auto& car_name = car_model_udata->model->car_name;
        sq_pushstring(vm, car_name.data(), car_name.size());
        return 1;
    }

    else
    {
        report_argument_errors(vm, argument_stream);
        return 0;
    }    
}
Exemple #10
0
static void outputv(ErlDrvData handle, ErlIOVec *ev) {
  
  Reader reader;
  
  const uint8_t* command = &redis_invalid_command;
  
  redis_drv_t* driver_data = (redis_drv_t*) handle;
  
  make_reader(ev, &reader);
  
  if (read_uint8(&reader, &command)) {
    switch(*command) {
      case REDIS_SET:
        redis_drv_set(driver_data, &reader);
        break;
      case REDIS_GET:
        redis_drv_get(driver_data, &reader);
        break;
      case REDIS_DEL:
        redis_drv_del(driver_data, &reader);
        break;
      case REDIS_SADD:
        redis_drv_sadd(driver_data, &reader);
        break;
      case REDIS_SREM:
        redis_drv_srem(driver_data, &reader);
        break;
      case REDIS_SMEMBERS:
        redis_drv_smembers(driver_data, &reader);
        break;
      default:
        redis_drv_unknown(driver_data);
    }
  } else{
    redis_drv_unknown(driver_data);
  }
}
inline
void read_and_convert_view( const String&                           file_name
                          , const View&                             view
                          , const image_read_settings< FormatTag >& settings
                          , typename enable_if< mpl::and_< is_format_tag< FormatTag >
                                                         , detail::is_supported_path_spec< String >
                                                         >
                                            >::type* /* ptr */ = 0
                          )
{
    typedef typename get_reader< String
                               , FormatTag
                               , detail::read_and_convert< default_color_converter >
                               >::type reader_t;

    reader_t reader = make_reader( file_name
                                 , settings
                                 , detail::read_and_convert< default_color_converter >()
                                 );

    read_and_convert_view( reader
                         , view
                         );
}
Exemple #12
0
 ReaderPtr at(size_t idx) const {
   if (idx < this->ref_.size()) {
     return make_reader(this->ref_.at(idx), this->options_);
   }
   return nullptr;
 }
Exemple #13
0
 ReaderPtr current_value() const final {
   if (it_ != end_) {
     return make_reader(it_->second, options_);
   }
   return nullptr;
 }