开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
config_set.h
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：10k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

config_set.h：源码内容
  1. /*
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is MPEG4IP.
  13.  * 
  14.  * The Initial Developer of the Original Code is Cisco Systems Inc.
  15.  * Portions created by Cisco Systems Inc. are
  16.  * Copyright (C) Cisco Systems Inc. 2000, 2001.  All Rights Reserved.
  17.  * 
  18.  * Contributor(s): 
  19.  * Dave Mackie dmackie@cisco.com
  20.  * Bill May  wmay@cisco.com
  21.  */
  23. #ifndef __CONFIG_SET_H__
  24. #define __CONFIG_SET_H__
  26. #include <systems.h>
  28. #ifndef MIN
  29. #define MIN(a, b) ((a) < (b) ? (a) : (b))
  30. #endif
  31. #ifndef MAX
  32. #define MAX(a, b) ((a) > (b) ? (a) : (b))
  33. #endif
  35. #ifndef CONFIG_SAFETY
  36. #define CONFIG_SAFETY 1
  37. #endif
  39. typedef u_int32_t config_integer_t;
  41. typedef u_int16_t config_index_t;
  44. enum ConfigException {
  45. CONFIG_ERR_INAME,
  46. CONFIG_ERR_TYPE,
  47. CONFIG_ERR_MEMORY,
  48. };
  50. // TBD type specific exception info and printing utility
  51. class CConfigException {
  52. public:
  53. CConfigException(ConfigException e) {
  54. type = e;
  55. }
  56. ConfigException type;
  57. };
  59. #define CONFIG_MAX_STRLEN 255
  61. // TBD weld this in, and throw exception
  62. inline char* stralloc(const char* src) {
  63. char* dst = (char*)malloc(strlen(src)+1);
  64. if (dst) {
  65. strcpy(dst, src);
  66. }
  67. return dst;
  68. }
  70. enum ConfigType {
  71. CONFIG_TYPE_UNDEFINED,
  72. CONFIG_TYPE_INTEGER,
  73. CONFIG_TYPE_BOOL,
  74. CONFIG_TYPE_STRING,
  75. CONFIG_TYPE_FLOAT
  76. };
  78. union UConfigValue {
  79. UConfigValue(void) {
  80. m_svalue = NULL;
  81. }
  82. UConfigValue(config_integer_t ivalue) {
  83. m_ivalue = ivalue;
  84. }
  85. UConfigValue(bool bvalue) {
  86. m_bvalue = bvalue;
  87. }
  88. UConfigValue(char* svalue) {
  89. m_svalue = svalue;
  90. }
  91. UConfigValue(float fvalue) {
  92. m_fvalue = fvalue;
  93. }
  95. config_integer_t m_ivalue;
  96. bool m_bvalue;
  97. char* m_svalue;
  98. float m_fvalue;
  99. };
  101. struct SConfigVariable {
  102. const config_index_t m_iName;
  103. const char*  m_sName;
  104. ConfigType m_type;
  105. UConfigValue m_defaultValue;
  106. UConfigValue m_value;
  108. const char* ToAscii() {
  109. static char sBuf[CONFIG_MAX_STRLEN+3];
  110. switch (m_type) {
  111. case CONFIG_TYPE_INTEGER:
  112. sprintf(sBuf, "%d", m_value.m_ivalue);
  113. return sBuf;
  114. case CONFIG_TYPE_BOOL:
  115. sprintf(sBuf, "%d", m_value.m_bvalue);
  116. return sBuf;
  117. case CONFIG_TYPE_STRING:
  118. if (strchr(m_value.m_svalue, ' ')) {
  119. sBuf[0] = '"';
  120. strncpy(&sBuf[1], m_value.m_svalue, CONFIG_MAX_STRLEN);
  121. strcpy(&sBuf[
  122. MIN(strlen(m_value.m_svalue), CONFIG_MAX_STRLEN)+1], """);
  123. }
  124. return m_value.m_svalue;
  125. case CONFIG_TYPE_FLOAT:
  126. sprintf(sBuf, "%f", m_value.m_fvalue);
  127. return sBuf;
  128. default:
  129. return "";
  130. }
  131. }
  133. bool FromAscii(const char* s) {
  134. switch (m_type) {
  135. case CONFIG_TYPE_INTEGER:
  136. return (sscanf(s, " %i ", &m_value.m_ivalue) == 1);
  137. case CONFIG_TYPE_BOOL:
  138. // OPTION could add "yes/no", "true/false"
  139. if (sscanf(s, " %u ", &m_value.m_ivalue) != 1) {
  140. return false;
  141. }
  142. m_value.m_bvalue = m_value.m_ivalue ? true : false;
  143. return true;
  144. case CONFIG_TYPE_STRING:
  145. // N.B. assuming m_svalue has been alloc'ed
  146. free(m_value.m_svalue);
  147. m_value.m_svalue = (char*)malloc(strlen(s)+1);
  148. if (m_value.m_svalue == NULL) {
  149. throw new CConfigException(CONFIG_ERR_MEMORY);
  150. }
  151. m_value.m_svalue[0] = '';
  152. if (s[0] == '"') {
  153. char* end = strchr(&s[1], '"');
  154. if (end == NULL) {
  155. return false;
  156. }
  157. size_t len = end - &s[1];
  158. strncpy(m_value.m_svalue, &s[1], len);
  159. m_value.m_svalue[len] = '';
  160. }
  161. return (sscanf(s, "%s", m_value.m_svalue) == 1);
  162. case CONFIG_TYPE_FLOAT:
  163. return (sscanf(s, " %f ", &m_value.m_fvalue) == 1);
  164. default:
  165. return false;
  166. }
  167. }
  169. void SetToDefault(void) {
  170. switch (m_type) {
  171. case CONFIG_TYPE_INTEGER:
  172. m_value.m_ivalue = m_defaultValue.m_ivalue;
  173. break;
  174. case CONFIG_TYPE_BOOL:
  175. m_value.m_bvalue = m_defaultValue.m_bvalue;
  176. break;
  177. case CONFIG_TYPE_STRING:
  178. free(m_value.m_svalue);
  179. m_value.m_svalue = stralloc(m_defaultValue.m_svalue);
  180. if (m_value.m_svalue == NULL) {
  181. throw new CConfigException(CONFIG_ERR_MEMORY);
  182. }
  183. break;
  184. case CONFIG_TYPE_FLOAT:
  185. m_value.m_fvalue = m_defaultValue.m_fvalue;
  186. break;
  187. default:
  188. break;
  189. } 
  190. }
  192. bool IsValueDefault(void) {
  193. switch (m_type) {
  194. case CONFIG_TYPE_INTEGER:
  195. return m_value.m_ivalue == m_defaultValue.m_ivalue;
  196. case CONFIG_TYPE_BOOL:
  197. return m_value.m_bvalue == m_defaultValue.m_bvalue;
  198. case CONFIG_TYPE_STRING:
  199. return (strcmp(m_value.m_svalue, m_defaultValue.m_svalue) == 0);
  200. case CONFIG_TYPE_FLOAT:
  201. return m_value.m_fvalue == m_defaultValue.m_fvalue;
  202. default:
  203. return false;
  204. } 
  205. }
  206. };
  209. class CConfigSet {
  210. public:
  211. CConfigSet(SConfigVariable* variables, 
  212.   config_index_t numVariables, 
  213.   const char* defaultFileName) {
  214. m_fileName = NULL;
  215. m_debug = false;
  216. m_variables = variables;
  217. m_numVariables = numVariables;
  218. m_defaultFileName = defaultFileName;
  219. SetToDefaults();
  220. };
  222. ~CConfigSet() {
  223. free(m_fileName);
  224. }
  226. const char* GetFileName() {
  227. return m_fileName;
  228. }
  230. inline void CheckIName(config_index_t iName) {
  231. if (iName >= m_numVariables) {
  232. throw new CConfigException(CONFIG_ERR_INAME);
  233. }
  234. if (m_variables[iName].m_iName != iName) {
  235. throw new CConfigException(CONFIG_ERR_INAME);
  236. }
  237. }
  239. inline void CheckIntegerType(config_index_t iName) {
  240. if (m_variables[iName].m_type != CONFIG_TYPE_INTEGER) {
  241. throw new CConfigException(CONFIG_ERR_TYPE);
  242. }
  243. }
  245. inline void CheckBoolType(config_index_t iName) {
  246. if (m_variables[iName].m_type != CONFIG_TYPE_BOOL) {
  247. throw new CConfigException(CONFIG_ERR_TYPE);
  248. }
  249. }
  251. inline void CheckStringType(config_index_t iName) {
  252. if (m_variables[iName].m_type != CONFIG_TYPE_STRING) {
  253. throw new CConfigException(CONFIG_ERR_TYPE);
  254. }
  255. }
  257. inline void CheckFloatType(config_index_t iName) {
  258. if (m_variables[iName].m_type != CONFIG_TYPE_FLOAT) {
  259. throw new CConfigException(CONFIG_ERR_TYPE);
  260. }
  261. }
  263. inline config_integer_t GetIntegerValue(const config_index_t iName) {
  264. #if CONFIG_SAFETY
  265. CheckIName(iName);
  266. CheckIntegerType(iName);
  267. #endif
  268. return m_variables[iName].m_value.m_ivalue;
  269. }
  271. inline void SetIntegerValue(const config_index_t iName, 
  272.   config_integer_t ivalue) {
  273. #if CONFIG_SAFETY
  274. CheckIName(iName);
  275. CheckIntegerType(iName);
  276. #endif
  277. m_variables[iName].m_value.m_ivalue = ivalue;
  278. }
  280. inline bool GetBoolValue(const config_index_t iName) {
  281. #if CONFIG_SAFETY
  282. CheckIName(iName);
  283. CheckBoolType(iName);
  284. #endif
  285. return m_variables[iName].m_value.m_bvalue;;
  286. }
  288. inline void SetBoolValue(const config_index_t iName, bool bvalue) {
  289. #if CONFIG_SAFETY
  290. CheckIName(iName);
  291. CheckBoolType(iName);
  292. #endif
  293. m_variables[iName].m_value.m_bvalue = bvalue;
  294. }
  296. inline char* GetStringValue(const config_index_t iName) {
  297. #if CONFIG_SAFETY
  298. CheckIName(iName);
  299. CheckStringType(iName);
  300. #endif
  301. return m_variables[iName].m_value.m_svalue;
  302. }
  304. inline void SetStringValue(const config_index_t iName, char* svalue) {
  305. #if CONFIG_SAFETY
  306. CheckIName(iName);
  307. CheckStringType(iName);
  308. #endif
  309. if (svalue == m_variables[iName].m_value.m_svalue) {
  310. return;
  311. }
  312. free(m_variables[iName].m_value.m_svalue);
  313. m_variables[iName].m_value.m_svalue = stralloc(svalue);
  314. if (m_variables[iName].m_value.m_svalue == NULL) {
  315. throw new CConfigException(CONFIG_ERR_MEMORY);
  316. }
  317. }
  319. inline float GetFloatValue(const config_index_t iName) {
  320. #if CONFIG_SAFETY
  321. CheckIName(iName);
  322. CheckFloatType(iName);
  323. #endif
  324. return m_variables[iName].m_value.m_fvalue;
  325. }
  327. inline void SetFloatValue(const config_index_t iName, float fvalue) {
  328. #if CONFIG_SAFETY
  329. CheckIName(iName);
  330. CheckFloatType(iName);
  331. #endif
  332. m_variables[iName].m_value.m_fvalue = fvalue;
  333. }
  335. void SetToDefaults(void) {
  336. for (config_index_t i = 0; i < m_numVariables; i++) {
  337. m_variables[i].SetToDefault();
  338. }
  339. }
  341. bool ReadFromFile(const char* fileName) {
  342. free(m_fileName);
  343. m_fileName = stralloc(fileName);
  344. FILE* pFile = fopen(fileName, "r");
  345. if (pFile == NULL) {
  346. if (m_debug) {
  347. fprintf(stderr, "couldn't open file %sn", fileName);
  348. }
  349. return false;
  350. }
  351. char line[256];
  352. while (fgets(line, sizeof(line), pFile)) {
  353. // comment
  354. if (line[0] == '#') {
  355. continue;
  356. }
  357. char* s = line;
  358. SConfigVariable* var = FindByName(strsep(&s, "="));
  359. if (var == NULL || s == NULL) {
  360. if (m_debug) {
  361. fprintf(stderr, "bad config line %sn", s);  
  362. }
  363. continue;
  364. }
  365. if (!var->FromAscii(s)) {
  366. if (m_debug) {
  367. fprintf(stderr, "bad config value in line %sn", s);  
  368. }
  369. }
  370. }
  371. fclose(pFile);
  372. return true;
  373. }
  375. bool WriteToFile(const char* fileName, bool allValues = false) {
  376. FILE* pFile = fopen(fileName, "w");
  377. if (pFile == NULL) {
  378. if (m_debug) {
  379. fprintf(stderr, "couldn't open file %sn", fileName);
  380. }
  381. return false;
  382. }
  383. for (config_index_t i = 0; i < m_numVariables; i++) {
  384. SConfigVariable* var = &m_variables[i];
  385. if (allValues || !var->IsValueDefault()) {
  386. fprintf(pFile, "%s=%sn", var->m_sName, var->ToAscii());
  387. }
  388. }
  389. fclose(pFile);
  390. return true;
  391. }
  393. bool ReadDefaultFile(void) {
  394. return ReadFromFile(m_defaultFileName);
  395. }
  396. bool WriteDefaultFile(void) {
  397. return WriteToFile(m_defaultFileName);
  398. }
  400. void SetDebug(bool debug = true) {
  401. m_debug = debug;
  402. }
  404. protected:
  405. SConfigVariable* FindByName(const char* sName) {
  406. for (config_index_t i = 0; i < m_numVariables; i++) {
  407. if (!strcmp(sName, m_variables[i].m_sName)) {
  408. return &m_variables[i];
  409. }
  410. }
  411. return NULL;
  412. };
  414. protected:
  415. SConfigVariable* m_variables;
  416. config_index_t m_numVariables;
  417. const char* m_defaultFileName;
  418. bool  m_debug;
  419. char* m_fileName;
  420. };
  422. #endif /* __CONFIG_SET_H__ */