25456501308

Committed 06 May 2026 07:29PM UTC coverage: 55.935% (-0.8%) from 56.7%

Build # 25456501308

Build Type

Pull #2011

github

Committed by

web-flow

Commit Message

Merge 7ad262960 into 7054e405e

Pull Request Pull Request #2011: Single-file CI and code style adoption

Coverage Stats

14612 of 26123 relevant lines covered (55.94%)

462107.16 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

76.92

/include/trick/checkpoint_queue.hh


/*
    PURPOSE: (Helpers to checkpoint STLs)
*/

#ifndef CHECKPOINT_QUEUE_HH
#define CHECKPOINT_QUEUE_HH

#include <queue>
#include <algorithm>
#include <typeinfo>
#include <sstream>
#include <type_traits>

#ifdef __GNUC__
#include <cxxabi.h>
#endif

#include "checkpoint_is_stl_container.hh"
#include "checkpoint_stl_protos.hh"
#include "checkpoint_fwd_declare.hh"
#include "checkpoint_sequence_stl.hh"
#include "trick/memorymanager_c_intf.h"
#include "trick/message_proto.h"

/* =================================================================================================*/


// queue: intrinsic
template <typename ITEM_TYPE, typename _Sequence,
          typename std::enable_if<!is_stl_container<ITEM_TYPE>::value>::type* >
int checkpoint_stl(std::queue<ITEM_TYPE,_Sequence> & in_stl , std::string object_name , std::string var_name ) {

    unsigned int ii ;
    unsigned int cont_size ;
    std::ostringstream var_declare ;
    int status ;
    std::string temp_str ;

    ITEM_TYPE * items = nullptr ;
    std::queue<ITEM_TYPE,_Sequence> temp_queue(in_stl) ;

    cont_size = temp_queue.size() ;
    std::replace_if(object_name.begin(), object_name.end(), static_cast<int (*)(int)>(std::ispunct), '_');

    if ( cont_size > 0 ) {
        std::string type_string;
        try {
            type_string = stl_type_name_convert(abi::__cxa_demangle(typeid(*items).name(), 0, 0, &status )) ;
        } catch (const std::bad_typeid& e) {
            message_publish(1, "Error, having difficulty checkpointing %s.%s\n", object_name.c_str(), var_name.c_str()) ;
            return 0 ;
        }
        var_declare << type_string << " "
         << object_name << "_" << var_name << "[" << cont_size << "]" ;
        temp_str = var_declare.str() ;
        items = (ITEM_TYPE *)TMM_declare_var_s(temp_str.c_str()) ;
        if ( items ) {
            temp_str = std::string(object_name + "_" + var_name) ;
            TMM_add_checkpoint_alloc_dependency(temp_str.c_str()) ;
            //message_publish(1, "CHECKPOINT_STL_STACK with %s\n", var_declare) ;

            for ( ii = 0 ; ii < cont_size ; ii++ ) {
                items[ii] = temp_queue.front() ;
                temp_queue.pop() ;
            }
        }
    }

    return 0 ;
}

// queue: STL
template <typename ITEM_TYPE, typename _Sequence,
          typename std::enable_if< is_stl_container<ITEM_TYPE>::value>::type* >
int checkpoint_stl(std::queue<ITEM_TYPE,_Sequence> & in_stl , std::string object_name , std::string var_name ) {

    unsigned int ii ;
    unsigned int cont_size ;
    std::ostringstream var_declare ;

    std::string temp_str;

    std::string * items = nullptr ;
    std::queue<ITEM_TYPE,_Sequence> temp_queue(in_stl) ;

    cont_size = temp_queue.size() ;
    std::replace_if(object_name.begin(), object_name.end(), static_cast<int (*)(int)>(std::ispunct), '_');

    if ( cont_size > 0 ) {
        var_declare << "std::string "
         << object_name << "_" << var_name << "[" << cont_size << "]" ;
        temp_str = var_declare.str() ;
        items = (std::string *)TMM_declare_var_s(temp_str.c_str()) ;
        if ( items ) {
            temp_str = std::string(object_name + "_" + var_name) ;
            TMM_add_checkpoint_alloc_dependency(temp_str.c_str()) ;
            //message_publish(1, "CHECKPOINT_STL_STACK with %s\n", var_declare) ;

            for ( ii = 0 ; ii < cont_size ; ii++ ) {
                std::ostringstream sub_elements ;
                sub_elements << object_name << "_" << var_name << "_" << ii ;
                items[ii] = sub_elements.str() ;

                std::ostringstream index_string ;
                index_string << ii ;
                checkpoint_stl (temp_queue.front(), object_name + "_" + var_name, index_string.str()) ;
                temp_queue.pop() ;
            }
        }
    }
    return 0 ;
}

// priority queue: intrinsic
template <typename ITEM_TYPE, typename _Container, typename _Compare,
          typename std::enable_if<!is_stl_container<ITEM_TYPE>::value>::type* >
int checkpoint_stl(std::priority_queue<ITEM_TYPE, _Container, _Compare> & in_stl ,
                   std::string object_name , std::string var_name ) {
    unsigned int ii ;
    unsigned int cont_size ;
    std::ostringstream var_declare ;
    int status ;

    std::string temp_str ;

    ITEM_TYPE * items = nullptr ;
    std::priority_queue<ITEM_TYPE,_Container,_Compare> temp_queue(in_stl) ;

    cont_size = temp_queue.size() ;
    std::replace_if(object_name.begin(), object_name.end(), static_cast<int (*)(int)>(std::ispunct), '_');

    if ( cont_size > 0 ) {
        std::string type_string;
        try {
            type_string = stl_type_name_convert(abi::__cxa_demangle(typeid(*items).name(), 0, 0, &status )) ;
        } catch (const std::bad_typeid& e) {
            message_publish(1, "Error, having difficulty checkpointing %s.%s\n", object_name.c_str(), var_name.c_str()) ;
            return 0 ;
        }
        var_declare << type_string << " "
         << object_name << "_" << var_name << "[" << cont_size << "]" ;
        temp_str = var_declare.str() ;
        items = (ITEM_TYPE *)TMM_declare_var_s(temp_str.c_str()) ;
        if ( items ) {
            temp_str = std::string(object_name + "_" + var_name) ;
            TMM_add_checkpoint_alloc_dependency(temp_str.c_str()) ;
            //message_publish(1, "CHECKPOINT_STL_STACK with %s\n", var_declare) ;

            for ( ii = 0 ; ii < cont_size ; ii++ ) {
                items[ii] = temp_queue.top() ;
                temp_queue.pop() ;
            }
        }
    }

    return 0 ;
}

// priority queue: STL
template <typename ITEM_TYPE, typename _Container, typename _Compare,
          typename std::enable_if< is_stl_container<ITEM_TYPE>::value>::type* >
int checkpoint_stl(std::priority_queue<ITEM_TYPE, _Container, _Compare> & in_stl ,
                   std::string object_name , std::string var_name ) {

    unsigned int ii ;
    unsigned int cont_size ;
    std::ostringstream var_declare ;

    std::string temp_str ;

    std::string * items = nullptr ;
    std::priority_queue<ITEM_TYPE,_Container,_Compare> temp_queue(in_stl) ;

    cont_size = temp_queue.size() ;
    std::replace_if(object_name.begin(), object_name.end(), static_cast<int (*)(int)>(std::ispunct), '_');

    if ( cont_size > 0 ) {
        var_declare << "std::string "
         << object_name << "_" << var_name << "[" << cont_size << "]" ;
        temp_str = var_declare.str() ;
        items = (std::string *)TMM_declare_var_s(temp_str.c_str()) ;
        if ( items ) {
            temp_str = std::string(object_name + "_" + var_name) ;
            TMM_add_checkpoint_alloc_dependency(temp_str.c_str()) ;
            //message_publish(1, "CHECKPOINT_STL_STACK with %s\n", var_declare) ;

            for ( ii = 0 ; ii < cont_size ; ii++ ) {
                std::ostringstream sub_elements ;
                sub_elements << object_name << "_" << var_name << "_" << ii ;
                items[ii] = sub_elements.str() ;

                std::ostringstream index_string ;
                index_string << ii ;
                checkpoint_stl (const_cast< ITEM_TYPE &>(temp_queue.top()), object_name + "_" + var_name, index_string.str()) ;
                temp_queue.pop() ;
            }
        }
    }

    return 0 ;
}

/* =================================================================================================*/

// The delete routines use the same method as the sequence types

template <typename ITEM_TYPE, typename _Sequence>
int delete_stl(std::queue<ITEM_TYPE,_Sequence> & in_stl , std::string object_name , std::string var_name ) {
    return delete_sequence_alloc( in_stl , object_name , var_name ) ;
}

template <typename ITEM_TYPE, typename _Container, typename _Compare>
int delete_stl(std::priority_queue<ITEM_TYPE,_Container,_Compare> & in_stl ,
                    std::string object_name , std::string var_name ) {
    return delete_sequence_alloc( in_stl , object_name , var_name ) ;
}

/* =================================================================================================*/

/* Find the arrays the map data was stored in the checkpoint using ref_attributes
   From the address of the resulting ref_attributes, we can figure out the number of
   items that were stored in the checkpoint.  Knowing the size, we can restore
   the map from the 2 arrays.
 */

// queue: intrinsic
template <typename ITEM_TYPE, typename _Sequence,
          typename std::enable_if<!is_stl_container<ITEM_TYPE>::value>::type* >
int restore_stl(std::queue<ITEM_TYPE,_Sequence> & in_stl , std::string object_name , std::string var_name ) {
    unsigned int ii ;
    unsigned int cont_size ;

    std::string temp_str ;

    REF2 * items_ref ;
    ITEM_TYPE * items ;
    std::replace_if(object_name.begin(), object_name.end(), static_cast<int (*)(int)>(std::ispunct), '_');

    //message_publish(1, "RESTORE_STL_queue %s_%s\n", object_name.c_str() , var_name.c_str()) ;
    temp_str = object_name + std::string("_") + var_name ;
    items_ref = ref_attributes((char *)temp_str.c_str()) ;

    if ( items_ref != NULL ) {
        cont_size = in_stl.size() ;
        for ( ii = 0 ; ii < cont_size ; ii++ ) {
            in_stl.pop() ;
        }

        items = (ITEM_TYPE *)items_ref->address ;
        cont_size = get_size((char *)items) ;

        for ( ii = 0 ; ii < cont_size ; ii++ ) {
            in_stl.push( items[ii] ) ;
        }
        delete_stl( in_stl , object_name , var_name ) ;
    }
    return 0 ;
}

// queue: STL
template <typename ITEM_TYPE, typename _Sequence,
          typename std::enable_if< is_stl_container<ITEM_TYPE>::value>::type* >
int restore_stl(std::queue<ITEM_TYPE,_Sequence> & in_stl , std::string object_name , std::string var_name ) {
    unsigned int ii ;
    unsigned int cont_size ;

    std::string temp_str ;

    REF2 * items_ref ;
    std::string * items ;
    std::replace_if(object_name.begin(), object_name.end(), static_cast<int (*)(int)>(std::ispunct), '_');

    //message_publish(1, "RESTORE_STL_queue %s_%s\n", object_name.c_str() , var_name.c_str()) ;
    temp_str = object_name + "_" + var_name ;
    items_ref = ref_attributes((char *)temp_str.c_str()) ;

    if ( items_ref != NULL ) {
        cont_size = in_stl.size() ;
        for ( ii = 0 ; ii < cont_size ; ii++ ) {
            in_stl.pop() ;
        }

        items = (std::string *)items_ref->address ;
        cont_size = get_size((char *)items) ;

        for ( ii = 0 ; ii < cont_size ; ii++ ) {
            ITEM_TYPE vt ;
            std::ostringstream index_string ;
            index_string << ii ;
            restore_stl( vt , object_name + "_" + var_name , index_string.str()) ;
            in_stl.push( vt ) ;
        }
        delete_stl( in_stl , object_name , var_name ) ;
    }
    return 0 ;
}

// priority_queue: intrinsic
template <typename ITEM_TYPE, typename _Container, typename _Compare,
          typename std::enable_if<!is_stl_container<ITEM_TYPE>::value>::type* >
int restore_stl(std::priority_queue<ITEM_TYPE,_Container,_Compare> & in_stl ,
                    std::string object_name , std::string var_name ) {
    unsigned int ii ;
    unsigned int cont_size ;

    std::string temp_str ;

    REF2 * items_ref ;
    ITEM_TYPE * items ;
    std::replace_if(object_name.begin(), object_name.end(), static_cast<int (*)(int)>(std::ispunct), '_');

    //message_publish(1, "RESTORE_STL_queue %s_%s\n", object_name.c_str() , var_name.c_str()) ;
    temp_str = object_name + std::string("_") + var_name ;
    items_ref = ref_attributes((char *)temp_str.c_str()) ;

    if ( items_ref != NULL ) {
        cont_size = in_stl.size() ;
        for ( ii = 0 ; ii < cont_size ; ii++ ) {
            in_stl.pop() ;
        }

        items = (ITEM_TYPE *)items_ref->address ;
        cont_size = get_size((char *)items) ;

        for ( ii = 0 ; ii < cont_size ; ii++ ) {
            in_stl.push( items[ii] ) ;
        }
        delete_stl( in_stl , object_name , var_name ) ;
    }
    return 0 ;
}

// priority_queue: STL
template <typename ITEM_TYPE, typename _Container, typename _Compare,
          typename std::enable_if< is_stl_container<ITEM_TYPE>::value>::type* >
int restore_stl(std::priority_queue<ITEM_TYPE,_Container,_Compare> & in_stl ,
                    std::string object_name , std::string var_name ) {
    unsigned int ii ;
    unsigned int cont_size ;

    std::string temp_str ;

    REF2 * items_ref ;
    std::string * items ;
    std::replace_if(object_name.begin(), object_name.end(), static_cast<int (*)(int)>(std::ispunct), '_');

    //message_publish(1, "RESTORE_STL_queue %s_%s\n", object_name.c_str() , var_name.c_str()) ;
    temp_str = object_name + "_" + var_name ;
    items_ref = ref_attributes((char *)temp_str.c_str()) ;

    if ( items_ref != NULL ) {
        cont_size = in_stl.size() ;
        for ( ii = 0 ; ii < cont_size ; ii++ ) {
            in_stl.pop() ;
        }

        items = (std::string *)items_ref->address ;
        cont_size = get_size((char *)items) ;

        for ( ii = 0 ; ii < cont_size ; ii++ ) {
            ITEM_TYPE vt ;
            std::ostringstream index_string ;
            index_string << ii ;
            restore_stl( vt , object_name + "_" + var_name , index_string.str()) ;
            in_stl.push( vt ) ;
        }
        delete_stl( in_stl , object_name , var_name ) ;
    }
    return 0 ;
}

#endif

1
2	/*
3	PURPOSE: (Helpers to checkpoint STLs)
4	*/
5
6	#ifndef CHECKPOINT_QUEUE_HH
7	#define CHECKPOINT_QUEUE_HH
8
9	#include <queue>
10	#include <algorithm>
11	#include <typeinfo>
12	#include <sstream>
13	#include <type_traits>
14
15	#ifdef __GNUC__
16	#include <cxxabi.h>
17	#endif
18
19	#include "checkpoint_is_stl_container.hh"
20	#include "checkpoint_stl_protos.hh"
21	#include "checkpoint_fwd_declare.hh"
22	#include "checkpoint_sequence_stl.hh"
23	#include "trick/memorymanager_c_intf.h"
24	#include "trick/message_proto.h"
25
26	/* =================================================================================================*/
27
28
29	// queue: intrinsic
30	template <typename ITEM_TYPE, typename _Sequence,
31	typename std::enable_if<!is_stl_container<ITEM_TYPE>::value>::type* >
32	int checkpoint_stl(std::queue<ITEM_TYPE,_Sequence> & in_stl , std::string object_name , std::string var_name ) {	3✔
33
34	unsigned int ii ;
35	unsigned int cont_size ;
36	std::ostringstream var_declare ;	3✔
37	int status ;
38	std::string temp_str ;	3✔
39
40	ITEM_TYPE * items = nullptr ;	3✔
41	std::queue<ITEM_TYPE,_Sequence> temp_queue(in_stl) ;	3✔
42
43	cont_size = temp_queue.size() ;	3✔
44	std::replace_if(object_name.begin(), object_name.end(), static_cast<int (*)(int)>(std::ispunct), '_');	3✔
45
46	if ( cont_size > 0 ) {	3✔
47	std::string type_string;	3✔
48	try {
49	type_string = stl_type_name_convert(abi::__cxa_demangle(typeid(*items).name(), 0, 0, &status )) ;	3✔
50	} catch (const std::bad_typeid& e) {	×
51	message_publish(1, "Error, having difficulty checkpointing %s.%s\n", object_name.c_str(), var_name.c_str()) ;	×
52	return 0 ;	×
53	}
54	var_declare << type_string << " "
55	<< object_name << "_" << var_name << "[" << cont_size << "]" ;	3✔
56	temp_str = var_declare.str() ;	3✔
57	items = (ITEM_TYPE *)TMM_declare_var_s(temp_str.c_str()) ;	3✔
58	if ( items ) {	3✔
59	temp_str = std::string(object_name + "_" + var_name) ;	3✔
60	TMM_add_checkpoint_alloc_dependency(temp_str.c_str()) ;	3✔
61	//message_publish(1, "CHECKPOINT_STL_STACK with %s\n", var_declare) ;
62
63	for ( ii = 0 ; ii < cont_size ; ii++ ) {	53✔
64	items[ii] = temp_queue.front() ;	50✔
65	temp_queue.pop() ;	50✔
66	}
67	}
68	}	3✔
69
70	return 0 ;	3✔
71	}	3✔
72
73	// queue: STL
74	template <typename ITEM_TYPE, typename _Sequence,
75	typename std::enable_if< is_stl_container<ITEM_TYPE>::value>::type* >
76	int checkpoint_stl(std::queue<ITEM_TYPE,_Sequence> & in_stl , std::string object_name , std::string var_name ) {	2✔
77
78	unsigned int ii ;
79	unsigned int cont_size ;
80	std::ostringstream var_declare ;	2✔
81
82	std::string temp_str;	2✔
83
84	std::string * items = nullptr ;	2✔
85	std::queue<ITEM_TYPE,_Sequence> temp_queue(in_stl) ;	2✔
86
87	cont_size = temp_queue.size() ;	2✔
88	std::replace_if(object_name.begin(), object_name.end(), static_cast<int (*)(int)>(std::ispunct), '_');	2✔
89
90	if ( cont_size > 0 ) {	2✔
91	var_declare << "std::string "
92	<< object_name << "_" << var_name << "[" << cont_size << "]" ;	2✔
93	temp_str = var_declare.str() ;	2✔
94	items = (std::string *)TMM_declare_var_s(temp_str.c_str()) ;	2✔
95	if ( items ) {	2✔
96	temp_str = std::string(object_name + "_" + var_name) ;	2✔
97	TMM_add_checkpoint_alloc_dependency(temp_str.c_str()) ;	2✔
98	//message_publish(1, "CHECKPOINT_STL_STACK with %s\n", var_declare) ;
99
100	for ( ii = 0 ; ii < cont_size ; ii++ ) {	15✔
101	std::ostringstream sub_elements ;	13✔
102	sub_elements << object_name << "_" << var_name << "_" << ii ;	13✔
103	items[ii] = sub_elements.str() ;	13✔
104
105	std::ostringstream index_string ;	13✔
106	index_string << ii ;	13✔
107	checkpoint_stl (temp_queue.front(), object_name + "_" + var_name, index_string.str()) ;	13✔
108	temp_queue.pop() ;	13✔
109	}
110	}
111	}
112	return 0 ;	2✔
113	}	2✔
114
115	// priority queue: intrinsic
116	template <typename ITEM_TYPE, typename _Container, typename _Compare,
117	typename std::enable_if<!is_stl_container<ITEM_TYPE>::value>::type* >
118	int checkpoint_stl(std::priority_queue<ITEM_TYPE, _Container, _Compare> & in_stl ,	34✔
119	std::string object_name , std::string var_name ) {
120	unsigned int ii ;
121	unsigned int cont_size ;
122	std::ostringstream var_declare ;	34✔
123	int status ;
124
125	std::string temp_str ;	34✔
126
127	ITEM_TYPE * items = nullptr ;	34✔
128	std::priority_queue<ITEM_TYPE,_Container,_Compare> temp_queue(in_stl) ;	34✔
129
130	cont_size = temp_queue.size() ;	34✔
131	std::replace_if(object_name.begin(), object_name.end(), static_cast<int (*)(int)>(std::ispunct), '_');	34✔
132
133	if ( cont_size > 0 ) {	34✔
134	std::string type_string;	×
135	try {
136	type_string = stl_type_name_convert(abi::__cxa_demangle(typeid(*items).name(), 0, 0, &status )) ;	×
137	} catch (const std::bad_typeid& e) {	×
138	message_publish(1, "Error, having difficulty checkpointing %s.%s\n", object_name.c_str(), var_name.c_str()) ;	×
139	return 0 ;	×
140	}
141	var_declare << type_string << " "
142	<< object_name << "_" << var_name << "[" << cont_size << "]" ;	×
143	temp_str = var_declare.str() ;	×
144	items = (ITEM_TYPE *)TMM_declare_var_s(temp_str.c_str()) ;	×
145	if ( items ) {	×
146	temp_str = std::string(object_name + "_" + var_name) ;	×
147	TMM_add_checkpoint_alloc_dependency(temp_str.c_str()) ;	×
148	//message_publish(1, "CHECKPOINT_STL_STACK with %s\n", var_declare) ;
149
150	for ( ii = 0 ; ii < cont_size ; ii++ ) {	×
151	items[ii] = temp_queue.top() ;	×
152	temp_queue.pop() ;	×
153	}
154	}
155	}	×
156
157	return 0 ;	34✔
158	}	34✔
159
160	// priority queue: STL
161	template <typename ITEM_TYPE, typename _Container, typename _Compare,
162	typename std::enable_if< is_stl_container<ITEM_TYPE>::value>::type* >
163	int checkpoint_stl(std::priority_queue<ITEM_TYPE, _Container, _Compare> & in_stl ,
164	std::string object_name , std::string var_name ) {
165
166	unsigned int ii ;
167	unsigned int cont_size ;
168	std::ostringstream var_declare ;
169
170	std::string temp_str ;
171
172	std::string * items = nullptr ;
173	std::priority_queue<ITEM_TYPE,_Container,_Compare> temp_queue(in_stl) ;
174
175	cont_size = temp_queue.size() ;
176	std::replace_if(object_name.begin(), object_name.end(), static_cast<int (*)(int)>(std::ispunct), '_');
177
178	if ( cont_size > 0 ) {
179	var_declare << "std::string "
180	<< object_name << "_" << var_name << "[" << cont_size << "]" ;
181	temp_str = var_declare.str() ;
182	items = (std::string *)TMM_declare_var_s(temp_str.c_str()) ;
183	if ( items ) {
184	temp_str = std::string(object_name + "_" + var_name) ;
185	TMM_add_checkpoint_alloc_dependency(temp_str.c_str()) ;
186	//message_publish(1, "CHECKPOINT_STL_STACK with %s\n", var_declare) ;
187
188	for ( ii = 0 ; ii < cont_size ; ii++ ) {
189	std::ostringstream sub_elements ;
190	sub_elements << object_name << "_" << var_name << "_" << ii ;
191	items[ii] = sub_elements.str() ;
192
193	std::ostringstream index_string ;
194	index_string << ii ;
195	checkpoint_stl (const_cast< ITEM_TYPE &>(temp_queue.top()), object_name + "_" + var_name, index_string.str()) ;
196	temp_queue.pop() ;
197	}
198	}
199	}
200
201	return 0 ;
202	}
203
204	/* =================================================================================================*/
205
206	// The delete routines use the same method as the sequence types
207
208	template <typename ITEM_TYPE, typename _Sequence>
209	int delete_stl(std::queue<ITEM_TYPE,_Sequence> & in_stl , std::string object_name , std::string var_name ) {	5✔
210	return delete_sequence_alloc( in_stl , object_name , var_name ) ;	5✔
211	}
212
213	template <typename ITEM_TYPE, typename _Container, typename _Compare>
214	int delete_stl(std::priority_queue<ITEM_TYPE,_Container,_Compare> & in_stl ,	×
215	std::string object_name , std::string var_name ) {
216	return delete_sequence_alloc( in_stl , object_name , var_name ) ;	×
217	}
218
219	/* =================================================================================================*/
220
221	/* Find the arrays the map data was stored in the checkpoint using ref_attributes
222	From the address of the resulting ref_attributes, we can figure out the number of
223	items that were stored in the checkpoint. Knowing the size, we can restore
224	the map from the 2 arrays.
225	*/
226
227	// queue: intrinsic
228	template <typename ITEM_TYPE, typename _Sequence,
229	typename std::enable_if<!is_stl_container<ITEM_TYPE>::value>::type* >
230	int restore_stl(std::queue<ITEM_TYPE,_Sequence> & in_stl , std::string object_name , std::string var_name ) {	3✔
231	unsigned int ii ;
232	unsigned int cont_size ;
233
234	std::string temp_str ;	3✔
235
236	REF2 * items_ref ;
237	ITEM_TYPE * items ;
238	std::replace_if(object_name.begin(), object_name.end(), static_cast<int (*)(int)>(std::ispunct), '_');	3✔
239
240	//message_publish(1, "RESTORE_STL_queue %s_%s\n", object_name.c_str() , var_name.c_str()) ;
241	temp_str = object_name + std::string("_") + var_name ;	3✔
242	items_ref = ref_attributes((char *)temp_str.c_str()) ;	3✔
243
244	if ( items_ref != NULL ) {	3✔
245	cont_size = in_stl.size() ;	3✔
246	for ( ii = 0 ; ii < cont_size ; ii++ ) {	3✔
247	in_stl.pop() ;	×
248	}
249
250	items = (ITEM_TYPE *)items_ref->address ;	3✔
251	cont_size = get_size((char *)items) ;	3✔
252
253	for ( ii = 0 ; ii < cont_size ; ii++ ) {	63✔
254	in_stl.push( items[ii] ) ;	60✔
255	}
256	delete_stl( in_stl , object_name , var_name ) ;	3✔
257	}
258	return 0 ;	3✔
259	}	3✔
260
261	// queue: STL
262	template <typename ITEM_TYPE, typename _Sequence,
263	typename std::enable_if< is_stl_container<ITEM_TYPE>::value>::type* >
264	int restore_stl(std::queue<ITEM_TYPE,_Sequence> & in_stl , std::string object_name , std::string var_name ) {	2✔
265	unsigned int ii ;
266	unsigned int cont_size ;
267
268	std::string temp_str ;	2✔
269
270	REF2 * items_ref ;
271	std::string * items ;
272	std::replace_if(object_name.begin(), object_name.end(), static_cast<int (*)(int)>(std::ispunct), '_');	2✔
273
274	//message_publish(1, "RESTORE_STL_queue %s_%s\n", object_name.c_str() , var_name.c_str()) ;
275	temp_str = object_name + "_" + var_name ;	2✔
276	items_ref = ref_attributes((char *)temp_str.c_str()) ;	2✔
277
278	if ( items_ref != NULL ) {	2✔
279	cont_size = in_stl.size() ;	2✔
280	for ( ii = 0 ; ii < cont_size ; ii++ ) {	2✔
281	in_stl.pop() ;	×
282	}
283
284	items = (std::string *)items_ref->address ;	2✔
285	cont_size = get_size((char *)items) ;	2✔
286
287	for ( ii = 0 ; ii < cont_size ; ii++ ) {	28✔
288	ITEM_TYPE vt ;	26✔
289	std::ostringstream index_string ;	26✔
290	index_string << ii ;	26✔
291	restore_stl( vt , object_name + "_" + var_name , index_string.str()) ;	26✔
292	in_stl.push( vt ) ;	26✔
293	}
294	delete_stl( in_stl , object_name , var_name ) ;	2✔
295	}
296	return 0 ;	2✔
297	}	2✔
298
299	// priority_queue: intrinsic
300	template <typename ITEM_TYPE, typename _Container, typename _Compare,
301	typename std::enable_if<!is_stl_container<ITEM_TYPE>::value>::type* >
302	int restore_stl(std::priority_queue<ITEM_TYPE,_Container,_Compare> & in_stl ,	22✔
303	std::string object_name , std::string var_name ) {
304	unsigned int ii ;
305	unsigned int cont_size ;
306
307	std::string temp_str ;	22✔
308
309	REF2 * items_ref ;
310	ITEM_TYPE * items ;
311	std::replace_if(object_name.begin(), object_name.end(), static_cast<int (*)(int)>(std::ispunct), '_');	22✔
312
313	//message_publish(1, "RESTORE_STL_queue %s_%s\n", object_name.c_str() , var_name.c_str()) ;
314	temp_str = object_name + std::string("_") + var_name ;	22✔
315	items_ref = ref_attributes((char *)temp_str.c_str()) ;	22✔
316
317	if ( items_ref != NULL ) {	22✔
318	cont_size = in_stl.size() ;	×
319	for ( ii = 0 ; ii < cont_size ; ii++ ) {	×
320	in_stl.pop() ;	×
321	}
322
323	items = (ITEM_TYPE *)items_ref->address ;	×
324	cont_size = get_size((char *)items) ;	×
325
326	for ( ii = 0 ; ii < cont_size ; ii++ ) {	×
327	in_stl.push( items[ii] ) ;	×
328	}
329	delete_stl( in_stl , object_name , var_name ) ;	×
330	}
331	return 0 ;	22✔
332	}	22✔
333
334	// priority_queue: STL
335	template <typename ITEM_TYPE, typename _Container, typename _Compare,
336	typename std::enable_if< is_stl_container<ITEM_TYPE>::value>::type* >
337	int restore_stl(std::priority_queue<ITEM_TYPE,_Container,_Compare> & in_stl ,
338	std::string object_name , std::string var_name ) {
339	unsigned int ii ;
340	unsigned int cont_size ;
341
342	std::string temp_str ;
343
344	REF2 * items_ref ;
345	std::string * items ;
346	std::replace_if(object_name.begin(), object_name.end(), static_cast<int (*)(int)>(std::ispunct), '_');
347
348	//message_publish(1, "RESTORE_STL_queue %s_%s\n", object_name.c_str() , var_name.c_str()) ;
349	temp_str = object_name + "_" + var_name ;
350	items_ref = ref_attributes((char *)temp_str.c_str()) ;
351
352	if ( items_ref != NULL ) {
353	cont_size = in_stl.size() ;
354	for ( ii = 0 ; ii < cont_size ; ii++ ) {
355	in_stl.pop() ;
356	}
357
358	items = (std::string *)items_ref->address ;
359	cont_size = get_size((char *)items) ;
360
361	for ( ii = 0 ; ii < cont_size ; ii++ ) {
362	ITEM_TYPE vt ;
363	std::ostringstream index_string ;
364	index_string << ii ;
365	restore_stl( vt , object_name + "_" + var_name , index_string.str()) ;
366	in_stl.push( vt ) ;
367	}
368	delete_stl( in_stl , object_name , var_name ) ;
369	}
370	return 0 ;
371	}
372
373	#endif

nasa / trick / 25456501308

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous