InitDatei.cpp 6.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325
  1. #include "InitDatei.h"
  2. #include "Text.h"
  3. #include "Datei.h"
  4. using namespace Framework;
  5. // Inhalt der InitDatei Klasse aus InitDatei.h
  6. // Konstruktor
  7. InitDatei::InitDatei()
  8. : ReferenceCounter(),
  9. pfad( new Text() ),
  10. name( new RCArray< Text >() ),
  11. wert( new RCArray< Text >() )
  12. {}
  13. InitDatei::InitDatei( Text* pfad )
  14. : ReferenceCounter(),
  15. pfad( new Text() ),
  16. name( new RCArray< Text >() ),
  17. wert( new RCArray< Text >() )
  18. {
  19. setPfad( pfad );
  20. }
  21. InitDatei::InitDatei( const char* pfad )
  22. : ReferenceCounter(),
  23. pfad( new Text() ),
  24. name( new RCArray< Text >() ),
  25. wert( new RCArray< Text >() )
  26. {
  27. setPfad( pfad );
  28. }
  29. // Destruktor
  30. InitDatei::~InitDatei()
  31. {
  32. pfad->release();
  33. name->release();
  34. wert->release();
  35. }
  36. // nicht constant
  37. void InitDatei::setPfad( Text* pfad )
  38. {
  39. this->pfad->setText( pfad );
  40. }
  41. void InitDatei::setPfad( const char* pfad )
  42. {
  43. this->pfad->setText( pfad );
  44. }
  45. bool InitDatei::laden()
  46. {
  47. Datei* dat = new Datei();
  48. dat->setDatei( pfad->getText() );
  49. if( !dat->open( Datei::Style::lesen ) )
  50. {
  51. dat->release();
  52. return 0;
  53. }
  54. removeAlle();
  55. Text* zeile = dat->leseZeile();
  56. while( zeile )
  57. {
  58. zeile->remove( "\r\n" );
  59. zeile->remove( "\n" );
  60. Text* n = zeile->getTeilText( 0, zeile->positionVon( '=' ) );
  61. Text* w = zeile->getTeilText( zeile->positionVon( '=' ) + 1 );
  62. name->add( n );
  63. wert->add( w );
  64. zeile->release();
  65. zeile = dat->leseZeile();
  66. }
  67. dat->close();
  68. dat->release();
  69. return 1;
  70. }
  71. bool InitDatei::addWert( Text* name, Text* wert )
  72. {
  73. if( !wertExistiert( name->getText() ) )
  74. {
  75. this->name->add( new Text( name->getText() ) );
  76. this->wert->add( new Text( wert->getText() ) );
  77. name->release();
  78. wert->release();
  79. return 1;
  80. }
  81. name->release();
  82. wert->release();
  83. return 0;
  84. }
  85. bool InitDatei::addWert( const char* name, const char* wert )
  86. {
  87. return addWert( new Text( name ), new Text( wert ) );
  88. }
  89. bool InitDatei::setWert( Text* name, Text* wert )
  90. {
  91. if( !wertExistiert( name->getText() ) )
  92. {
  93. name->release();
  94. wert->release();
  95. return 0;
  96. }
  97. auto n = this->name->begin();
  98. for( auto v = this->wert->begin(); v; v++, n++ )
  99. {
  100. if( n->istGleich( name->getText() ) )
  101. {
  102. v->setText( wert->getText() );
  103. name->release();
  104. wert->release();
  105. return 1;
  106. }
  107. }
  108. name->release();
  109. wert->release();
  110. return 0;
  111. }
  112. bool InitDatei::setWert( const char* name, const char* wert )
  113. {
  114. return setWert( new Text( name ), new Text( wert ) );
  115. }
  116. bool InitDatei::setWert( int num, Text* wert )
  117. {
  118. bool result = setWert( num, wert->getText() );
  119. wert->release();
  120. return result;
  121. }
  122. bool InitDatei::setWert( int num, const char* wert )
  123. {
  124. if( num >= name->getEintragAnzahl() )
  125. return 0;
  126. this->wert->z( num )->setText( wert );
  127. return 1;
  128. }
  129. bool InitDatei::removeWert( Text* name )
  130. {
  131. bool result = removeWert( name->getText() );
  132. name->release();
  133. return result;
  134. }
  135. bool InitDatei::removeWert( const char* name )
  136. {
  137. if( !wertExistiert( name ) )
  138. return 0;
  139. for( int i = 0; i < wert->getEintragAnzahl(); ++i )
  140. {
  141. if( this->name->z( i )->istGleich( name ) )
  142. {
  143. this->name->remove( i );
  144. this->wert->remove( i );
  145. return 1;
  146. }
  147. }
  148. return 0;
  149. }
  150. bool InitDatei::removeWert( int num )
  151. {
  152. if( num >= wert->getEintragAnzahl() )
  153. return 0;
  154. this->name->remove( num );
  155. this->wert->remove( num );
  156. return 1;
  157. }
  158. void InitDatei::removeAlle()
  159. {
  160. while( wert->getEintragAnzahl() > 0 )
  161. {
  162. this->name->remove( 0 );
  163. this->wert->remove( 0 );
  164. }
  165. }
  166. bool InitDatei::speichern()
  167. {
  168. Datei* dat = new Datei();
  169. dat->setDatei( pfad->getText() );
  170. if( !dat->existiert() )
  171. dat->erstellen();
  172. if( !dat->open( Datei::Style::schreiben ) )
  173. {
  174. dat->release();
  175. return 0;
  176. }
  177. auto n = name->begin();
  178. for( auto v = wert->begin(); v; v++, n++ )
  179. {
  180. Text* zeile = new Text( "" );
  181. zeile->append( n->getText() );
  182. zeile->append( "=" );
  183. zeile->append( v->getText() );
  184. zeile->append( "\n" );
  185. dat->schreibe( zeile->getText(), zeile->getLength() );
  186. zeile->release();
  187. }
  188. dat->close();
  189. dat->release();
  190. return 1;
  191. }
  192. // constant
  193. int InitDatei::getWertAnzahl() const
  194. {
  195. return name->getEintragAnzahl();
  196. }
  197. bool InitDatei::wertExistiert( Text* name )
  198. {
  199. bool result = wertExistiert( name->getText() );
  200. name->release();
  201. return result;
  202. }
  203. bool InitDatei::wertExistiert( const char* name )
  204. {
  205. for( Text* n : *this->name )
  206. {
  207. if( n->istGleich( name ) )
  208. return 1;
  209. }
  210. return 0;
  211. }
  212. int InitDatei::getWertNummer( Text* name )
  213. {
  214. int result = getWertNummer( name->getText() );
  215. name->release();
  216. return result;
  217. }
  218. int InitDatei::getWertNummer( const char* name )
  219. {
  220. int i = 0;
  221. for( Text *n : *this->name )
  222. {
  223. if( n->istGleich( name ) )
  224. return i;
  225. }
  226. return -1;
  227. }
  228. Text* InitDatei::getWert( Text* name )
  229. {
  230. Text* result = getWert( name->getText() );
  231. name->release();
  232. return result;
  233. }
  234. Text* InitDatei::getWert( const char* name )
  235. {
  236. auto v = wert->begin();
  237. for( auto n = this->name->begin(); n; n++, v++ )
  238. {
  239. if( n->istGleich( name ) )
  240. return dynamic_cast<Text*>(v->getThis());
  241. }
  242. return 0;
  243. }
  244. Text* InitDatei::getWert( int num )
  245. {
  246. if( num >= name->getEintragAnzahl() )
  247. return 0;
  248. return wert->get( num );
  249. }
  250. Text* InitDatei::zWert( Text* name )
  251. {
  252. Text* result = zWert( name->getText() );
  253. name->release();
  254. return result;
  255. }
  256. Text* InitDatei::zWert( const char* name )
  257. {
  258. auto v = wert->begin();
  259. for( auto n = this->name->begin(); n; n++, v++ )
  260. {
  261. if( n->istGleich( name ) )
  262. return v;
  263. }
  264. return 0;
  265. }
  266. Text* InitDatei::zWert( int num )
  267. {
  268. if( num >= wert->getEintragAnzahl() )
  269. return 0;
  270. return wert->z( num );
  271. }
  272. Text* InitDatei::getName( int num )
  273. {
  274. if( num >= name->getEintragAnzahl() )
  275. return 0;
  276. return name->get( num );
  277. }
  278. Text* InitDatei::zName( int num )
  279. {
  280. if( num >= name->getEintragAnzahl() )
  281. return 0;
  282. return name->z( num );
  283. }
  284. Text* InitDatei::getPfad() const
  285. {
  286. return dynamic_cast<Text*>(pfad->getThis());
  287. }
  288. Text* InitDatei::zPfad() const
  289. {
  290. return pfad;
  291. }