/src/libetonyek/src/lib/contexts/IWORKNumberConverter.cpp

Source
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/*
 * This file is part of the libetonyek project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */

#include "IWORKNumberConverter.h"

#include "libetonyek_xml.h"

namespace libetonyek
{

using boost::none;
using boost::optional;

optional<bool> IWORKNumberConverter<bool>::convert(const char *const value)
{
  return try_bool_cast(value);
}

optional<bool> IWORKNumberConverter<bool>::convert(const unsigned value)
{
  return bool(value);
}

optional<double> IWORKNumberConverter<double>::convert(const char *const value)
{
  return try_double_cast(value);
}

optional<double> IWORKNumberConverter<double>::convert(const unsigned value)
{
  return double(value);
}

optional<int> IWORKNumberConverter<int>::convert(const char *const value)
{
  return try_int_cast(value);
}

optional<int> IWORKNumberConverter<int>::convert(const unsigned value)
{
  return int(value);
}

optional<IWORKAlignment> IWORKNumberConverter<IWORKAlignment>::convert(const char *const value)
{
  const optional<int> alignment(try_int_cast(value));
  if (alignment)
    return convert(unsigned(get(alignment)));
  return none;
}

optional<IWORKAlignment> IWORKNumberConverter<IWORKAlignment>::convert(const unsigned value)
{
  switch (value)
  {
  case 0 :
    return IWORK_ALIGNMENT_LEFT;
  case 1 :
    return IWORK_ALIGNMENT_RIGHT;
  case 2 :
    return IWORK_ALIGNMENT_CENTER;
  case 3 :
    return IWORK_ALIGNMENT_JUSTIFY;
  case 4 :
    return IWORK_ALIGNMENT_AUTOMATIC;
  default:
    ETONYEK_DEBUG_MSG(("IWORKNumberConverter<IWORKAlignment>::convert: unknown value %d\n", int(value)));
    break;
  }
  return none;
}

optional<IWORKBaseline> IWORKNumberConverter<IWORKBaseline>::convert(const char *const value)
{
  const optional<int> superscript(try_int_cast(value));
  if (superscript)
    return convert(unsigned(get(superscript)));
  return none;
}

optional<IWORKBaseline> IWORKNumberConverter<IWORKBaseline>::convert(const unsigned value)
{
  switch (value)
  {
  case 0:
    return none;
  case 1 :
    return IWORK_BASELINE_SUPER;
  case 2 :
    return IWORK_BASELINE_SUB;
  default:
    ETONYEK_DEBUG_MSG(("IWORKNumberConverter<IWORKBaseline>::convert: unknown value %d\n", int(value)));
  }
  return none;
}

optional<IWORKBorderType> IWORKNumberConverter<IWORKBorderType>::convert(const char *const value)
{
  const optional<int> border(try_int_cast(value));
  if (border)
    return convert(unsigned(get(border)));
  return none;
}

optional<IWORKBorderType> IWORKNumberConverter<IWORKBorderType>::convert(const unsigned value)
{
  switch (value)
  {
  case 0:
    return none;
  case 1 :
    return IWORK_BORDER_TYPE_TOP;
  case 2 :
    return IWORK_BORDER_TYPE_BOTTOM;
  case 3 :
    return IWORK_BORDER_TYPE_TOP_AND_BOTTOM;
  case 4 :
    return IWORK_BORDER_TYPE_ALL;
  default:
    ETONYEK_DEBUG_MSG(("IWORKNumberConverter<IWORKBorderType>::convert: unknown value %d\n", int(value)));
  }
  return none;
}

optional<IWORKCapitalization> IWORKNumberConverter<IWORKCapitalization>::convert(const char *const value)
{
  const optional<int> capitalization(try_int_cast(value));
  if (capitalization)
    return convert(unsigned(get(capitalization)));
  return none;
}

optional<IWORKCapitalization> IWORKNumberConverter<IWORKCapitalization>::convert(const unsigned value)
{
  switch (value)
  {
  case 0 :
    return IWORK_CAPITALIZATION_NONE;
  case 1 :
    return IWORK_CAPITALIZATION_ALL_CAPS;
  case 2 :
    return IWORK_CAPITALIZATION_SMALL_CAPS;
  case 3 :
    return IWORK_CAPITALIZATION_TITLE;
  default:
    ETONYEK_DEBUG_MSG(("IWORKNumberConverter<IWORKCapitalization>::convert: unknown value %d\n", int(value)));
  }
  return none;
}

optional<IWORKCellNumberType> IWORKNumberConverter<IWORKCellNumberType>::convert(const char *const value)
{
  const optional<int> numberFormat(try_int_cast(value));
  if (numberFormat)
    return convert(unsigned(get(numberFormat)));
  return none;
}

optional<IWORKCellNumberType> IWORKNumberConverter<IWORKCellNumberType>::convert(const unsigned value)
{
  switch (value)
  {
  case 1 :
    return IWORK_CELL_NUMBER_TYPE_CURRENCY;
  case 2 :
    return IWORK_CELL_NUMBER_TYPE_PERCENTAGE;
  case 3 :
    return IWORK_CELL_NUMBER_TYPE_SCIENTIFIC;
  case 4 :
  case 5 :
  default :
    return IWORK_CELL_NUMBER_TYPE_DOUBLE;
  }
}

optional<IWORKStrokeType> IWORKNumberConverter<IWORKStrokeType>::convert(const char *const value)
{
  const optional<int> type(try_int_cast(value));
  if (type)
    return convert(unsigned(get(type)));
  return none;
}

optional<IWORKStrokeType> IWORKNumberConverter<IWORKStrokeType>::convert(const unsigned value)
{
  switch (value)
  {
  case 0 :
    return IWORK_STROKE_TYPE_DASHED;
  case 1 :
    return IWORK_STROKE_TYPE_SOLID;
  case 2 :
    return IWORK_STROKE_TYPE_AUTO;
  default:
    ETONYEK_DEBUG_MSG(("IWORKNumberConverter<IWORKStrokeType>::convert: unknown value %d\n", int(value)));
  }
  return none;
}

optional<IWORKVerticalAlignment> IWORKNumberConverter<IWORKVerticalAlignment>::convert(const char *const value)
{
  const optional<int> alignment(try_int_cast(value));
  if (alignment)
    return convert(unsigned(get(alignment)));
  return none;
}

optional<IWORKVerticalAlignment> IWORKNumberConverter<IWORKVerticalAlignment>::convert(const unsigned value)
{
  switch (value)
  {
  case 0 :
    return IWORK_VERTICAL_ALIGNMENT_TOP;
  case 1 :
    return IWORK_VERTICAL_ALIGNMENT_MIDDLE;
  case 2 :
    return IWORK_VERTICAL_ALIGNMENT_BOTTOM;
  default:
    ETONYEK_DEBUG_MSG(("IWORKNumberConverter<IWORKVerticalAlignment>::convert: unknown value %d\n", int(value)));
    break;
  }
  return none;
}

}

/* vim:set shiftwidth=2 softtabstop=2 expandtab: */

Coverage Report

Created: 2026-04-29 07:28

Line	Count	Source
1		/* -- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -- */
2		/*
3		* This file is part of the libetonyek project.
4		*
5		* This Source Code Form is subject to the terms of the Mozilla Public
6		* License, v. 2.0. If a copy of the MPL was not distributed with this
7		* file, You can obtain one at http://mozilla.org/MPL/2.0/.
8		*/
9
10		#include "IWORKNumberConverter.h"
11
12		#include "libetonyek_xml.h"
13
14		namespace libetonyek
15		{
16
17		using boost::none;
18		using boost::optional;
19
20		optional<bool> IWORKNumberConverter<bool>::convert(const char *const value)
21	0	{
22	0	return try_bool_cast(value);
23	0	}
24
25		optional<bool> IWORKNumberConverter<bool>::convert(const unsigned value)
26	0	{
27	0	return bool(value);
28	0	}
29
30		optional<double> IWORKNumberConverter<double>::convert(const char *const value)
31	0	{
32	0	return try_double_cast(value);
33	0	}
34
35		optional<double> IWORKNumberConverter<double>::convert(const unsigned value)
36	0	{
37	0	return double(value);
38	0	}
39
40		optional<int> IWORKNumberConverter<int>::convert(const char *const value)
41	0	{
42	0	return try_int_cast(value);
43	0	}
44
45		optional<int> IWORKNumberConverter<int>::convert(const unsigned value)
46	0	{
47	0	return int(value);
48	0	}
49
50		optional<IWORKAlignment> IWORKNumberConverter<IWORKAlignment>::convert(const char *const value)
51	0	{
52	0	const optional<int> alignment(try_int_cast(value));
53	0	if (alignment)
54	0	return convert(unsigned(get(alignment)));
55	0	return none;
56	0	}
57
58		optional<IWORKAlignment> IWORKNumberConverter<IWORKAlignment>::convert(const unsigned value)
59	1.35k	{
60	1.35k	switch (value)
61	1.35k	{
62	285	case 0 :
63	285	return IWORK_ALIGNMENT_LEFT;
64	2	case 1 :
65	2	return IWORK_ALIGNMENT_RIGHT;
66	851	case 2 :
67	851	return IWORK_ALIGNMENT_CENTER;
68	84	case 3 :
69	84	return IWORK_ALIGNMENT_JUSTIFY;
70	125	case 4 :
71	125	return IWORK_ALIGNMENT_AUTOMATIC;
72	3	default:
73	3	ETONYEK_DEBUG_MSG(("IWORKNumberConverter<IWORKAlignment>::convert: unknown value %d\n", int(value)));
74	3	break;
75	1.35k	}
76	3	return none;
77	1.35k	}
78
79		optional<IWORKBaseline> IWORKNumberConverter<IWORKBaseline>::convert(const char *const value)
80	0	{
81	0	const optional<int> superscript(try_int_cast(value));
82	0	if (superscript)
83	0	return convert(unsigned(get(superscript)));
84	0	return none;
85	0	}
86
87		optional<IWORKBaseline> IWORKNumberConverter<IWORKBaseline>::convert(const unsigned value)
88	1.27k	{
89	1.27k	switch (value)
90	1.27k	{
91	1.27k	case 0:
92	1.27k	return none;
93	0	case 1 :
94	0	return IWORK_BASELINE_SUPER;
95	0	case 2 :
96	0	return IWORK_BASELINE_SUB;
97	0	default:
98	0	ETONYEK_DEBUG_MSG(("IWORKNumberConverter<IWORKBaseline>::convert: unknown value %d\n", int(value)));
99	1.27k	}
100	0	return none;
101	1.27k	}
102
103		optional<IWORKBorderType> IWORKNumberConverter<IWORKBorderType>::convert(const char *const value)
104	0	{
105	0	const optional<int> border(try_int_cast(value));
106	0	if (border)
107	0	return convert(unsigned(get(border)));
108	0	return none;
109	0	}
110
111		optional<IWORKBorderType> IWORKNumberConverter<IWORKBorderType>::convert(const unsigned value)
112	1.27k	{
113	1.27k	switch (value)
114	1.27k	{
115	1.27k	case 0:
116	1.27k	return none;
117	0	case 1 :
118	0	return IWORK_BORDER_TYPE_TOP;
119	0	case 2 :
120	0	return IWORK_BORDER_TYPE_BOTTOM;
121	5	case 3 :
122	5	return IWORK_BORDER_TYPE_TOP_AND_BOTTOM;
123	1	case 4 :
124	1	return IWORK_BORDER_TYPE_ALL;
125	0	default:
126	0	ETONYEK_DEBUG_MSG(("IWORKNumberConverter<IWORKBorderType>::convert: unknown value %d\n", int(value)));
127	1.27k	}
128	0	return none;
129	1.27k	}
130
131		optional<IWORKCapitalization> IWORKNumberConverter<IWORKCapitalization>::convert(const char *const value)
132	0	{
133	0	const optional<int> capitalization(try_int_cast(value));
134	0	if (capitalization)
135	0	return convert(unsigned(get(capitalization)));
136	0	return none;
137	0	}
138
139		optional<IWORKCapitalization> IWORKNumberConverter<IWORKCapitalization>::convert(const unsigned value)
140	1.27k	{
141	1.27k	switch (value)
142	1.27k	{
143	1.25k	case 0 :
144	1.25k	return IWORK_CAPITALIZATION_NONE;
145	0	case 1 :
146	0	return IWORK_CAPITALIZATION_ALL_CAPS;
147	0	case 2 :
148	0	return IWORK_CAPITALIZATION_SMALL_CAPS;
149	4	case 3 :
150	4	return IWORK_CAPITALIZATION_TITLE;
151	18	default:
152	18	ETONYEK_DEBUG_MSG(("IWORKNumberConverter<IWORKCapitalization>::convert: unknown value %d\n", int(value)));
153	1.27k	}
154	18	return none;
155	1.27k	}
156
157		optional<IWORKCellNumberType> IWORKNumberConverter<IWORKCellNumberType>::convert(const char *const value)
158	0	{
159	0	const optional<int> numberFormat(try_int_cast(value));
160	0	if (numberFormat)
161	0	return convert(unsigned(get(numberFormat)));
162	0	return none;
163	0	}
164
165		optional<IWORKCellNumberType> IWORKNumberConverter<IWORKCellNumberType>::convert(const unsigned value)
166	0	{
167	0	switch (value)
168	0	{
169	0	case 1 :
170	0	return IWORK_CELL_NUMBER_TYPE_CURRENCY;
171	0	case 2 :
172	0	return IWORK_CELL_NUMBER_TYPE_PERCENTAGE;
173	0	case 3 :
174	0	return IWORK_CELL_NUMBER_TYPE_SCIENTIFIC;
175	0	case 4 :
176	0	case 5 :
177	0	default :
178	0	return IWORK_CELL_NUMBER_TYPE_DOUBLE;
179	0	}
180	0	}
181
182		optional<IWORKStrokeType> IWORKNumberConverter<IWORKStrokeType>::convert(const char *const value)
183	0	{
184	0	const optional<int> type(try_int_cast(value));
185	0	if (type)
186	0	return convert(unsigned(get(type)));
187	0	return none;
188	0	}
189
190		optional<IWORKStrokeType> IWORKNumberConverter<IWORKStrokeType>::convert(const unsigned value)
191	0	{
192	0	switch (value)
193	0	{
194	0	case 0 :
195	0	return IWORK_STROKE_TYPE_DASHED;
196	0	case 1 :
197	0	return IWORK_STROKE_TYPE_SOLID;
198	0	case 2 :
199	0	return IWORK_STROKE_TYPE_AUTO;
200	0	default:
201	0	ETONYEK_DEBUG_MSG(("IWORKNumberConverter<IWORKStrokeType>::convert: unknown value %d\n", int(value)));
202	0	}
203	0	return none;
204	0	}
205
206		optional<IWORKVerticalAlignment> IWORKNumberConverter<IWORKVerticalAlignment>::convert(const char *const value)
207	0	{
208	0	const optional<int> alignment(try_int_cast(value));
209	0	if (alignment)
210	0	return convert(unsigned(get(alignment)));
211	0	return none;
212	0	}
213
214		optional<IWORKVerticalAlignment> IWORKNumberConverter<IWORKVerticalAlignment>::convert(const unsigned value)
215	0	{
216	0	switch (value)
217	0	{
218	0	case 0 :
219	0	return IWORK_VERTICAL_ALIGNMENT_TOP;
220	0	case 1 :
221	0	return IWORK_VERTICAL_ALIGNMENT_MIDDLE;
222	0	case 2 :
223	0	return IWORK_VERTICAL_ALIGNMENT_BOTTOM;
224	0	default:
225	0	ETONYEK_DEBUG_MSG(("IWORKNumberConverter<IWORKVerticalAlignment>::convert: unknown value %d\n", int(value)));
226	0	break;
227	0	}
228	0	return none;
229	0	}
230
231		}
232
233		/* vim:set shiftwidth=2 softtabstop=2 expandtab: */