/src/icu/source/i18n/fphdlimp.cpp

Source (jump to first uncovered line)
// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
* Copyright (C) 2009-2015, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*/

#include "unicode/utypes.h"

#if !UCONFIG_NO_FORMATTING

#include "fphdlimp.h"
#include "uvectr32.h"

U_NAMESPACE_BEGIN

// utility FieldPositionHandler
// base class, null implementation

FieldPositionHandler::~FieldPositionHandler() {
}

void FieldPositionHandler::setShift(int32_t delta) {
  fShift = delta;
}


// utility subclass FieldPositionOnlyHandler

FieldPositionOnlyHandler::FieldPositionOnlyHandler(FieldPosition& _pos)
  : pos(_pos) {
}

FieldPositionOnlyHandler::~FieldPositionOnlyHandler() {
}

void
FieldPositionOnlyHandler::addAttribute(int32_t id, int32_t start, int32_t limit) {
  if (pos.getField() == id && (!acceptFirstOnly || !seenFirst)) {
    seenFirst = TRUE;
    pos.setBeginIndex(start + fShift);
    pos.setEndIndex(limit + fShift);
  }
}

void
FieldPositionOnlyHandler::shiftLast(int32_t delta) {
  if (delta != 0 && pos.getField() != FieldPosition::DONT_CARE && pos.getBeginIndex() != -1) {
    pos.setBeginIndex(delta + pos.getBeginIndex());
    pos.setEndIndex(delta + pos.getEndIndex());
  }
}

UBool
FieldPositionOnlyHandler::isRecording(void) const {
  return pos.getField() != FieldPosition::DONT_CARE;
}

void FieldPositionOnlyHandler::setAcceptFirstOnly(UBool acceptFirstOnly) {
  this->acceptFirstOnly = acceptFirstOnly;
}


// utility subclass FieldPositionIteratorHandler

FieldPositionIteratorHandler::FieldPositionIteratorHandler(FieldPositionIterator* posIter,
                                                           UErrorCode& _status)
    : iter(posIter), vec(NULL), status(_status), fCategory(UFIELD_CATEGORY_UNDEFINED) {
  if (iter && U_SUCCESS(status)) {
    vec = new UVector32(status);
  }
}

FieldPositionIteratorHandler::FieldPositionIteratorHandler(
    UVector32* vec,
    UErrorCode& status)
    : iter(nullptr), vec(vec), status(status), fCategory(UFIELD_CATEGORY_UNDEFINED) {
}

FieldPositionIteratorHandler::~FieldPositionIteratorHandler() {
  // setData adopts the vec regardless of status, so it's safe to null it
  if (iter) {
    iter->setData(vec, status);
  }
  // if iter is null, we never allocated vec, so no need to free it
  vec = NULL;
}

void
FieldPositionIteratorHandler::addAttribute(int32_t id, int32_t start, int32_t limit) {
  if (vec && U_SUCCESS(status) && start < limit) {
    int32_t size = vec->size();
    vec->addElement(fCategory, status);
    vec->addElement(id, status);
    vec->addElement(start + fShift, status);
    vec->addElement(limit + fShift, status);
    if (!U_SUCCESS(status)) {
      vec->setSize(size);
    }
  }
}

void
FieldPositionIteratorHandler::shiftLast(int32_t delta) {
  if (U_SUCCESS(status) && delta != 0) {
    int32_t i = vec->size();
    if (i > 0) {
      --i;
      vec->setElementAt(delta + vec->elementAti(i), i);
      --i;
      vec->setElementAt(delta + vec->elementAti(i), i);
    }
  }
}

UBool
FieldPositionIteratorHandler::isRecording(void) const {
  return U_SUCCESS(status);
}

U_NAMESPACE_END

#endif /* !UCONFIG_NO_FORMATTING */

Line	Count	Source (jump to first uncovered line)
1		// © 2016 and later: Unicode, Inc. and others.
2		// License & terms of use: http://www.unicode.org/copyright.html
3		/*
4		*******************************************************************************
5		* Copyright (C) 2009-2015, International Business Machines Corporation and
6		* others. All Rights Reserved.
7		*******************************************************************************
8		*/
9
10		#include "unicode/utypes.h"
11
12		#if !UCONFIG_NO_FORMATTING
13
14		#include "fphdlimp.h"
15		#include "uvectr32.h"
16
17		U_NAMESPACE_BEGIN
18
19		// utility FieldPositionHandler
20		// base class, null implementation
21
22	0	FieldPositionHandler::~FieldPositionHandler() {
23	0	}
24
25	0	void FieldPositionHandler::setShift(int32_t delta) {
26	0	fShift = delta;
27	0	}
28
29
30		// utility subclass FieldPositionOnlyHandler
31
32		FieldPositionOnlyHandler::FieldPositionOnlyHandler(FieldPosition& _pos)
33	0	: pos(_pos) {
34	0	}
35
36		FieldPositionOnlyHandler::~FieldPositionOnlyHandler() {
37		}
38
39		void
40	0	FieldPositionOnlyHandler::addAttribute(int32_t id, int32_t start, int32_t limit) {
41	0	if (pos.getField() == id && (!acceptFirstOnly \|\| !seenFirst)) {
42	0	seenFirst = TRUE;
43	0	pos.setBeginIndex(start + fShift);
44	0	pos.setEndIndex(limit + fShift);
45	0	}
46	0	}
47
48		void
49	0	FieldPositionOnlyHandler::shiftLast(int32_t delta) {
50	0	if (delta != 0 && pos.getField() != FieldPosition::DONT_CARE && pos.getBeginIndex() != -1) {
51	0	pos.setBeginIndex(delta + pos.getBeginIndex());
52	0	pos.setEndIndex(delta + pos.getEndIndex());
53	0	}
54	0	}
55
56		UBool
57	0	FieldPositionOnlyHandler::isRecording(void) const {
58	0	return pos.getField() != FieldPosition::DONT_CARE;
59	0	}
60
61	0	void FieldPositionOnlyHandler::setAcceptFirstOnly(UBool acceptFirstOnly) {
62	0	this->acceptFirstOnly = acceptFirstOnly;
63	0	}
64
65
66		// utility subclass FieldPositionIteratorHandler
67
68		FieldPositionIteratorHandler::FieldPositionIteratorHandler(FieldPositionIterator* posIter,
69		UErrorCode& _status)
70	0	: iter(posIter), vec(NULL), status(_status), fCategory(UFIELD_CATEGORY_UNDEFINED) {
71	0	if (iter && U_SUCCESS(status)) {
72	0	vec = new UVector32(status);
73	0	}
74	0	}
75
76		FieldPositionIteratorHandler::FieldPositionIteratorHandler(
77		UVector32* vec,
78		UErrorCode& status)
79	0	: iter(nullptr), vec(vec), status(status), fCategory(UFIELD_CATEGORY_UNDEFINED) {
80	0	}
81
82	0	FieldPositionIteratorHandler::~FieldPositionIteratorHandler() {
83		// setData adopts the vec regardless of status, so it's safe to null it
84	0	if (iter) {
85	0	iter->setData(vec, status);
86	0	}
87		// if iter is null, we never allocated vec, so no need to free it
88	0	vec = NULL;
89	0	}
90
91		void
92	0	FieldPositionIteratorHandler::addAttribute(int32_t id, int32_t start, int32_t limit) {
93	0	if (vec && U_SUCCESS(status) && start < limit) {
94	0	int32_t size = vec->size();
95	0	vec->addElement(fCategory, status);
96	0	vec->addElement(id, status);
97	0	vec->addElement(start + fShift, status);
98	0	vec->addElement(limit + fShift, status);
99	0	if (!U_SUCCESS(status)) {
100	0	vec->setSize(size);
101	0	}
102	0	}
103	0	}
104
105		void
106	0	FieldPositionIteratorHandler::shiftLast(int32_t delta) {
107	0	if (U_SUCCESS(status) && delta != 0) {
108	0	int32_t i = vec->size();
109	0	if (i > 0) {
110	0	--i;
111	0	vec->setElementAt(delta + vec->elementAti(i), i);
112	0	--i;
113	0	vec->setElementAt(delta + vec->elementAti(i), i);
114	0	}
115	0	}
116	0	}
117
118		UBool
119	0	FieldPositionIteratorHandler::isRecording(void) const {
120	0	return U_SUCCESS(status);
121	0	}
122
123		U_NAMESPACE_END
124
125		#endif /* !UCONFIG_NO_FORMATTING */

Coverage Report

Created: 2025-06-24 06:43