src/Factory.cc

   1 /*
   2  * Factory.cc
   3  *
   4  *  Created on: Dec 11, 2010
   5  *      Author: lamikr
   6  */
   7
   8 #include <string>
   9 #include <sstream>
  10 #include <iostream>
  11
  12 #include <string.h>
  13
  14 #include <plp/log.h>
  15 #include "Factory.hh"
  16 #include "W1TemperatureSensor.hh"
  17 #include "W1CounterDevice.hh"
  18 #include "W1Util.hh"
  19
  20 using namespace w1;
  21 using namespace plp;
  22 using namespace std;
  23
  24 template <class NumberDataType>
  25 bool string_to_number(NumberDataType& result,
  26                  const std::string& string_param,
  27                  std::ios_base& (*format)(std::ios_base&))
  28 {
  29         std::istringstream iss(string_param);
  30         return !(iss >> format >> result).fail();
  31 }
  32
  33 Factory::Factory() {
  34         // TODO Auto-generated constructor stub
  35 }
  36
  37 Factory::~Factory() {
  38         // TODO Auto-generated destructor stub
  39 }
  40
  41 W1Device *Factory::get_device(int family_code,
  42                         string device_id,
  43                         dirent *direntry_param) {
  44         W1Device        *ret_val;
  45         DeviceConfig    *config;
  46         string          type;
  47
  48         ret_val = NULL;
  49         switch(family_code) {
  50                 case    0x10:
  51                 case    0x28:
  52                         ret_val = new W1TemperatureSensor(family_code, device_id, direntry_param);
  53                         break;
  54                 case    0x1d:
  55                         ret_val = new W1CounterDevice(family_code, device_id, direntry_param);
  56                         break;
  57                 case    0x81:
  58                         // 0x81 is the 1-wire USB dongle... No need to create device for it.
  59                         break;
  60                 default:
  61                         log_debug("Unsupported 1-wire-family code: %#x, device not created: %s\n", family_code, device_id.c_str());
  62                         break;
  63         }
  64         if (ret_val != NULL) {
  65                 log_debug("%s: %#x\n", ret_val->get_device_type().c_str(), ret_val->get_w1_family_code());
  66                 // check that device config exist
  67                 config  = get_device_config(device_id);
  68                 if (config != NULL) {
  69                         // if not, create default device config
  70                         type    = config->get_cfg_value(DEVICE_CONFIG_VALUE_KEY__TYPE);
  71                         if (type.empty() == true) {
  72                                 type    = ret_val->get_device_type();
  73                                 config->set_cfg_value(DEVICE_CONFIG_VALUE_KEY__TYPE, type);
  74                                 config->set_cfg_value(DEVICE_CONFIG_VALUE_KEY__ID, ret_val->get_id());
  75                         }
  76                         delete(config);
  77                 }
  78         }
  79         return ret_val;
  80 }
  81
  82 W1Device *Factory::create_device(dirent *direntry_param, int *err_code_param) {
  83         string          folder_name;
  84         string          tmp_str;
  85         string          device_name;
  86         int             pos;
  87         int             family_code;
  88         bool            suc_flg;
  89         W1Device        *ret_val;
  90
  91         ret_val         = NULL;
  92         *err_code_param = 0;
  93         folder_name     = direntry_param->d_name;
  94         pos             = folder_name.find("-");
  95         if (pos > 0) {
  96                 tmp_str = folder_name.substr(0, pos);
  97                 // number in string is in hex format, convert to int
  98                 suc_flg = string_to_number<int>(family_code, tmp_str, hex);
  99                 // if family code = 0x81 (1-wire usb dongle), do not try to create the device
 100                 if (family_code != 0x81) {
 101                         if (suc_flg == true) {
 102                                 log_debug("1-wire device family code: %#x\n", family_code);
 103                                 device_name     = folder_name.substr(pos + 1, folder_name.length() - pos);
 104                                 ret_val         = Factory::get_device(family_code,
 105                                                                 device_name,
 106                                                                 direntry_param);
 107                                 if ((ret_val == NULL) &&
 108                                     (family_code != 0x81)) {
 109                                         *err_code_param = 1;
 110                                 }
 111                         }
 112                 }
 113         }
 114         return ret_val;
 115 }
 116
 117 list<W1Device *> Factory::get_device_list() {
 118         DIR                     *dir;
 119         int                     err_flg;
 120         struct dirent           *direntry;
 121         W1Device                *device;
 122         bool                    is_subdir;
 123         list<W1Device *>        ret_val;
 124
 125         dir     = opendir(W1_SCAN_ROOTDIR);
 126         if (dir != NULL) {
 127                 direntry        = readdir(dir);
 128                 while(direntry != NULL) {
 129                         is_subdir       = W1Util::is_subdirectory(W1_SCAN_ROOTDIR, direntry);
 130                         if (is_subdir == true) {
 131                                 err_flg = 0;
 132                                 device  = create_device(direntry, &err_flg);
 133                                 if (device != NULL) {
 134                                         ret_val.push_back(device);
 135                                 }
 136                                 else {
 137                                         if (err_flg != 0) {
 138                                                 log_info("Unsupported 1-wire device detected: %s\n", direntry->d_name);
 139                                         }
 140                                 }
 141                         }
 142                         direntry        = readdir(dir);
 143                 }
 144                 err_flg = closedir(dir);
 145                 if (err_flg < 0) {
 146                         log_error("Failed to close 1-wire device directory: %s\n", W1_SCAN_ROOTDIR);
 147                 }
 148         }
 149         return ret_val;
 150 }
 151
 152 list<DeviceData *> Factory::get_device_data_list() {
 153         DIR                     *dir;
 154         string                  dr_name;
 155         int                     err_flg;
 156         struct dirent           *direntry;
 157         DeviceData              *dev_dta;
 158         bool                    is_subdir;
 159         list<DeviceData *>      ret_val;
 160
 161         dr_name = DeviceConfig::get_base_dir_name();
 162         dir     = opendir(dr_name.c_str());
 163         if (dir != NULL) {
 164                 direntry        = readdir(dir);
 165                 while(direntry != NULL) {
 166                         if (strcmp(direntry->d_name, "cache") != 0) {
 167                                 is_subdir       = W1Util::is_subdirectory(dr_name.c_str(), direntry);
 168                                 if (is_subdir == true) {
 169                                         dev_dta = new DeviceData(direntry->d_name);
 170                                         ret_val.push_back(dev_dta);
 171                                 }
 172                         }
 173                         direntry        = readdir(dir);
 174                 }
 175                 err_flg = closedir(dir);
 176                 if (err_flg < 0) {
 177                         log_error("Failed to close 1-wire device data directory: %s\n", dr_name.c_str());
 178                 }
 179         }
 180         return ret_val;
 181 }
 182
 183 DeviceConfig *Factory::get_device_config(string device_id) {
 184         DeviceConfig    *ret_val;
 185
 186         ret_val = new DeviceConfig(device_id);
 187         return ret_val;
 188 }