NCBI C++ ToolKit
molinfo_fieldtype.cpp
Go to the documentation of this file.

Go to the SVN repository for this file.

1 /* $Id: molinfo_fieldtype.cpp 42116 2018-12-21 18:26:17Z asztalos $
2  * ===========================================================================
3  *
4  * PUBLIC DOMAIN NOTICE
5  * National Center for Biotechnology Information
6  *
7  * This software/database is a "United States Government Work" under the
8  * terms of the United States Copyright Act. It was written as part of
9  * the author's official duties as a United States Government employee and
10  * thus cannot be copyrighted. This software/database is freely available
11  * to the public for use. The National Library of Medicine and the U.S.
12  * Government have not placed any restriction on its use or reproduction.
13  *
14  * Although all reasonable efforts have been taken to ensure the accuracy
15  * and reliability of the software and data, the NLM and the U.S.
16  * Government do not and cannot warrant the performance or results that
17  * may be obtained by using this software or data. The NLM and the U.S.
18  * Government disclaim all warranties, express or implied, including
19  * warranties of performance, merchantability or fitness for any particular
20  * purpose.
21  *
22  * Please cite the author in any work or product based on this material.
23  *
24  * ===========================================================================
25  *
26  * Authors: Andrea Asztalos
27  */
28 
29 
30 #include <ncbi_pch.hpp>
31 #include <util/static_set.hpp>
32 #include <util/static_map.hpp>
35 
36 
39 
41 {
42  vector<string> rval;
43  for (int i = e_MoleculeType; i < e_Repr; i++) {
44  rval.push_back(GetFieldName((EMolInfoFieldType)i));
45  }
46  return rval;
47 }
48 
50 {
51  vector<string> rval;
52  for (int i = e_MoleculeType; i < e_Repr; i++) {
53  rval.push_back(GetMacroFieldName((EMolInfoFieldType)i));
54  }
55  return rval;
56 }
57 
58 
60 {
61  string rval = "";
62  switch (field_type) {
63  case e_MoleculeType:
64  rval = "molecule";
65  break;
66  case e_Technique:
67  rval = "technique";
68  break;
69  case e_Completedness:
70  rval = "completedness";
71  break;
72  case e_Class:
73  rval = "class";
74  break;
75  case e_Topology:
76  rval = "topology";
77  break;
78  case e_Strand:
79  rval = "strand";
80  break;
81  case e_Repr:
82  rval = "representation";
83  default:
84  break;
85  }
86  return rval;
87 }
88 
90 {
91  string rval;
92  switch (field_type) {
93  case e_MoleculeType:
94  rval = "\"descr..molinfo.biomol\"";
95  break;
96  case e_Technique:
97  rval = "\"descr..molinfo.tech\"";
98  break;
99  case e_Completedness:
100  rval = "\"descr..molinfo.completeness\"";
101  break;
102  case e_Class:
103  rval = "\"inst.mol\"";
104  break;
105  case e_Topology:
106  rval = "\"inst.topology\"";
107  break;
108  case e_Strand:
109  rval = "\"inst.strand\"";
110  break;
111  case e_Repr:
112  rval = "\"inst.repr\"";
113  break;
114  default:
115  break;
116  }
117  return rval;
118 }
119 
121 {
122  for (int i = e_MoleculeType; i < e_Unknown; i++) {
124  if (NStr::EqualNocase(field_name, match)) {
125  return (EMolInfoFieldType)i;
126  }
127  }
128  return e_Unknown;
129 }
130 
131 // For MolInfo editing
133 {
134  { " ", CMolInfo::eBiomol_unknown },
135  { "cRNA", CMolInfo::eBiomol_cRNA },
136  { "genomic", CMolInfo::eBiomol_genomic },
137  { "genomic mRNA", CMolInfo::eBiomol_genomic_mRNA },
138  { "mRNA", CMolInfo::eBiomol_mRNA },
139  { "ncRNA", CMolInfo::eBiomol_ncRNA },
140  { "other", CMolInfo::eBiomol_other },
141  { "other-genetic", CMolInfo::eBiomol_other_genetic },
142  { "peptide", CMolInfo::eBiomol_peptide },
143  { "precursor RNA", CMolInfo::eBiomol_pre_RNA },
144  { "rRNA", CMolInfo::eBiomol_rRNA },
145  { "scRNA", CMolInfo::eBiomol_scRNA },
146  { "snRNA", CMolInfo::eBiomol_snRNA },
147  { "snoRNA", CMolInfo::eBiomol_snoRNA },
148  { "tRNA", CMolInfo::eBiomol_tRNA },
149  { "tmRNA", CMolInfo::eBiomol_tmRNA },
150  { "transcribed_RNA", CMolInfo::eBiomol_transcribed_RNA }
151 };
152 
155 
157 {
158  string rval = "";
159  ITERATE(TCStringBiomolPairsMap, it, k_biomol_names) {
160  if (it->second == biomol) {
161  rval = it->first;
162  break;
163  }
164  }
165  return rval;
166 }
167 
168 
170 {
172  ITERATE(TCStringBiomolPairsMap, it, k_biomol_names) {
174  biomol = it->second;
175  break;
176  }
177  }
178  return biomol;
179 }
180 
181 
183 {
184  { " ", CMolInfo::eTech_unknown },
185  { "EST", CMolInfo::eTech_est },
186  { "FLI_cDNA", CMolInfo::eTech_fli_cdna },
187  { "HTC", CMolInfo::eTech_htc },
188  { "HTGS 0", CMolInfo::eTech_htgs_0 },
189  { "HTGS 1", CMolInfo::eTech_htgs_1 },
190  { "HTGS 2", CMolInfo::eTech_htgs_2 },
191  { "HTGS 3", CMolInfo::eTech_htgs_3 },
192  { "STS", CMolInfo::eTech_sts },
193  { "TSA", CMolInfo::eTech_tsa },
194  { "WGS", CMolInfo::eTech_wgs },
195  { "both", CMolInfo::eTech_both },
196  { "composite-WGS-HTGS", CMolInfo::eTech_composite_wgs_htgs },
197  { "concept-trans", CMolInfo::eTech_concept_trans },
198  { "concept-trans-A", CMolInfo::eTech_concept_trans_a },
199  { "derived", CMolInfo::eTech_derived },
200  { "genetic map", CMolInfo::eTech_genemap },
201  { "physical map", CMolInfo::eTech_physmap },
202  { "seq-pept", CMolInfo::eTech_seq_pept },
203  { "seq-pept-homol", CMolInfo::eTech_seq_pept_homol },
204  { "seq-pept-overlap", CMolInfo::eTech_seq_pept_overlap },
205  { "standard", CMolInfo::eTech_standard },
206  { "survey", CMolInfo::eTech_survey }
207 };
208 
211 
212 
214 {
215  string rval = "";
216  ITERATE(TCStringTechPairsMap, it, k_tech_names) {
217  if (it->second == tech) {
218  rval = it->first;
219  break;
220  }
221  }
222  return rval;
223 }
224 
225 
227 {
229  ITERATE(TCStringTechPairsMap, it, k_tech_names) {
231  tech = it->second;
232  break;
233  }
234  }
235  if (tech == CMolInfo::eTech_unknown && !NStr::IsBlank(val)) {
236  tech = CMolInfo::eTech_other;
237  }
238  return tech;
239 }
240 
241 
243 {
245  { "complete", CMolInfo::eCompleteness_complete },
246  { "has left", CMolInfo::eCompleteness_has_left },
247  { "has right", CMolInfo::eCompleteness_has_right },
248  { "no ends", CMolInfo::eCompleteness_no_ends },
249  { "no left", CMolInfo::eCompleteness_no_left },
250  { "no right", CMolInfo::eCompleteness_no_right },
251  { "other", CMolInfo::eCompleteness_other },
252  { "partial", CMolInfo::eCompleteness_partial }
253 };
254 
255 
258 
259 
261 {
262  string rval = "";
263  ITERATE(TCStringCompletenessPairsMap, it, k_completeness_names) {
264  if (it->second == val) {
265  rval = it->first;
266  break;
267  }
268  }
269  return rval;
270 }
271 
272 
274 {
276  ITERATE(TCStringCompletenessPairsMap, it, k_completeness_names) {
278  rval = it->second;
279  break;
280  }
281  }
282 
283  return rval;
284 }
285 
286 
288 {
289  { " ", CSeq_inst::eMol_not_set },
290  { "DNA", CSeq_inst::eMol_dna },
291  { "RNA", CSeq_inst::eMol_rna },
292  { "nucleotide", CSeq_inst::eMol_na },
293  { "other", CSeq_inst::eMol_other },
294  { "protein", CSeq_inst::eMol_aa }
295 };
296 
297 
300 
301 
303 {
304  string rval = "";
305  ITERATE(TCStringMolPairsMap, it, k_mol_names) {
306  if (it->second == val) {
307  rval = it->first;
308  break;
309  }
310  }
311  return rval;
312 }
313 
314 
316 {
318  ITERATE(TCStringMolPairsMap, it, k_mol_names) {
320  rval = it->second;
321  break;
322  }
323  }
324 
325  return rval;
326 }
327 
328 
330 {
332  { "circular", CSeq_inst::eTopology_circular },
333  { "linear", CSeq_inst::eTopology_linear },
334  { "other", CSeq_inst::eTopology_other },
335  { "tandem", CSeq_inst::eTopology_tandem }
336 };
337 
338 
341 
342 
344 {
345  string rval = "";
346  ITERATE(TCStringTopologyPairsMap, it, k_topology_names) {
347  if (it->second == val) {
348  rval = it->first;
349  break;
350  }
351  }
352  return rval;
353 }
354 
355 
357 {
359  ITERATE(TCStringTopologyPairsMap, it, k_topology_names) {
361  rval = it->second;
362  break;
363  }
364  }
365 
366  return rval;
367 }
368 
369 
371 {
373  { "double", CSeq_inst::eStrand_ds },
374  { "mixed", CSeq_inst::eStrand_mixed },
375  { "other", CSeq_inst::eStrand_other },
376  { "single", CSeq_inst::eStrand_ss }
377 };
378 
379 
382 
383 
385 {
386  string rval = "";
387  ITERATE(TCStringStrandPairsMap, it, k_strand_names) {
388  if (it->second == val) {
389  rval = it->first;
390  break;
391  }
392  }
393  return rval;
394 }
395 
396 
398 {
400  ITERATE(TCStringStrandPairsMap, it, k_strand_names) {
402  rval = it->second;
403  break;
404  }
405  }
406 
407  return rval;
408 }
409 
411 {
412  { " ", CSeq_inst::eRepr_not_set },
413  { "consensus", CSeq_inst::eRepr_consen },
414  { "constructed", CSeq_inst::eRepr_const },
415  { "delta", CSeq_inst::eRepr_delta },
416  { "ordered map", CSeq_inst::eRepr_map },
417  { "other", CSeq_inst::eRepr_other },
418  { "raw", CSeq_inst::eRepr_raw },
419  { "reference to another", CSeq_inst::eRepr_ref },
420  { "segmented", CSeq_inst::eRepr_seg },
421  { "virtual", CSeq_inst::eRepr_virtual }
422 };
423 
426 
428 {
429  string rval;
430  for (auto& it: k_repr_names) {
431  if (it.second == repr) {
432  rval = it.first;
433  break;
434  }
435  }
436  return rval;
437 }
438 
439 
441 {
443  for (auto& it : k_repr_names) {
445  repr = it.second;
446  break;
447  }
448  }
449  return repr;
450 }
451 
452 
453 vector<string> CMolInfoFieldType::GetChoicesForField(EMolInfoFieldType field_type, bool& allow_other)
454 {
455  vector<string> choices;
456 
457  switch (field_type) {
459  ITERATE(TCStringBiomolPairsMap, it, k_biomol_names) {
460  choices.push_back(it->first);
461  }
462  allow_other = false;
463  break;
465  ITERATE(TCStringTechPairsMap, it, k_tech_names) {
466  choices.push_back(it->first);
467  }
468  allow_other = true;
469  break;
471  ITERATE(TCStringCompletenessPairsMap, it, k_completeness_names) {
472  choices.push_back(it->first);
473  }
474  allow_other = false;
475  break;
477  ITERATE(TCStringMolPairsMap, it, k_mol_names) {
478  choices.push_back(it->first);
479  }
480  allow_other = false;
481  break;
483  ITERATE(TCStringTopologyPairsMap, it, k_topology_names) {
484  choices.push_back(it->first);
485  }
486  break;
488  ITERATE(TCStringStrandPairsMap, it, k_strand_names) {
489  choices.push_back(it->first);
490  }
491  allow_other = false;
492  break;
494  for (auto& it : k_repr_names) {
495  choices.push_back(it.first);
496  }
497  allow_other = false;
498  break;
499  default:
500  break;
501  }
502  return choices;
503 }
504 
506 {
507  vector<string> values;
508  switch (field_type) {
510  {
511  values.push_back("unknown");
512  values.push_back("cRNA");
513  values.push_back("genomic");
514  values.push_back("genomic-mRNA");
515  values.push_back("mRNA");
516  values.push_back("ncRNA");
517  values.push_back("other");
518  values.push_back("other-genetic");
519  values.push_back("peptide");
520  values.push_back("pre-RNA");
521  values.push_back("rRNA");
522  values.push_back("scRNA");
523  values.push_back("snRNA");
524  values.push_back("snoRNA");
525  values.push_back("tRNA");
526  values.push_back("tmRNA");
527  values.push_back("transcribed-RNA");
528  }
529  break;
531  {
532  values.push_back("unknown");
533  values.push_back("est");
534  values.push_back("fli-cdna");
535  values.push_back("htc");
536  values.push_back("htgs-0");
537  values.push_back("htgs-1");
538  values.push_back("htgs-2");
539  values.push_back("htgs-3");
540  values.push_back("sts");
541  values.push_back("tsa");
542  values.push_back("wgs");
543  values.push_back("both");
544  values.push_back("composite-wgs-htgs");
545  values.push_back("concept-trans");
546  values.push_back("concept-trans-a");
547  values.push_back("derived");
548  values.push_back("genemap");
549  values.push_back("physmap");
550  values.push_back("seq-pept");
551  values.push_back("seq-pept-homol");
552  values.push_back("seq-pept-overlap");
553  values.push_back("standard");
554  values.push_back("survey");
555  }
556  break;
558  {
559  values.push_back("unknown");
560  values.push_back("complete");
561  values.push_back("has-left");
562  values.push_back("has-right");
563  values.push_back("no-ends");
564  values.push_back("no-left");
565  values.push_back("no-right");
566  values.push_back("other");
567  values.push_back("partial");
568  }
569  break;
571  {
572  values.push_back("not-set");
573  values.push_back("dna");
574  values.push_back("rna");
575  values.push_back("na");
576  values.push_back("other");
577  values.push_back("aa");
578  }
579  break;
581  {
582  values.push_back("not-set");
583  values.push_back("circular");
584  values.push_back("linear");
585  values.push_back("other");
586  values.push_back("tandem");
587  }
588  break;
590  {
591  values.push_back("not-set");
592  values.push_back("ds");
593  values.push_back("mixed");
594  values.push_back("other");
595  values.push_back("ss");
596  }
597  break;
599  {
600  values.push_back("not-set");
601  values.push_back("virtual");
602  values.push_back("raw");
603  values.push_back("seg");
604  values.push_back("const");
605  values.push_back("ref");
606  values.push_back("consen");
607  values.push_back("map");
608  values.push_back("delta");
609  values.push_back("other");
610  }
611  break;
612  default:
613  break;
614  }
615 
616  return values;
617 }
618 
620 
static string GetBiomolLabel(objects::CMolInfo::TBiomol biomol)
static objects::CSeq_inst::TStrand GetStrandFromLabel(const string &val)
static objects::CSeq_inst::TMol GetMolFromLabel(const string &val)
static vector< string > GetFieldNames()
static vector< string > GetMacroFieldNames()
static string GetTechLabel(objects::CMolInfo::TTech tech)
static objects::CSeq_inst::TTopology GetTopologyFromLabel(const string &val)
static objects::CSeq_inst::TRepr GetReprFromLabel(const string &val)
static EMolInfoFieldType GetFieldType(const string &field_name)
static string GetReprLabel(objects::CSeq_inst::TRepr val)
static objects::CMolInfo::TTech GetTechFromLabel(const string &val)
static string GetStrandLabel(objects::CSeq_inst::TStrand val)
static string GetMolLabel(objects::CSeq_inst::TMol val)
static string GetTopologyLabel(objects::CSeq_inst::TTopology tech)
static objects::CMolInfo::TCompleteness GetCompletenessFromLabel(const string &val)
static string GetMacroFieldName(EMolInfoFieldType field_type)
static objects::CMolInfo::TBiomol GetBiomolFromLabel(const string &val)
static string GetFieldName(EMolInfoFieldType field_type)
static vector< string > GetChoicesForField(CMolInfoFieldType::EMolInfoFieldType field_type, bool &allow_other)
static string GetCompletenessLabel(objects::CMolInfo::TCompleteness tech)
static vector< string > GetValuesForField(EMolInfoFieldType field_type)
class CStaticArrayMap<> is an array adaptor that provides an STLish interface to statically-defined a...
Definition: static_map.hpp:105
#define ITERATE(Type, Var, Cont)
ITERATE macro to sequence through container elements.
Definition: ncbimisc.hpp:815
#define END_NCBI_SCOPE
End previously defined NCBI scope.
Definition: ncbistl.hpp:103
#define BEGIN_NCBI_SCOPE
Define ncbi namespace.
Definition: ncbistl.hpp:100
static bool IsBlank(const CTempString str, SIZE_TYPE pos=0)
Check if a string is blank (has no text).
Definition: ncbistr.cpp:106
static bool EqualNocase(const CTempString s1, SIZE_TYPE pos, SIZE_TYPE n, const char *s2)
Case-insensitive equality of a substring with another string.
Definition: ncbistr.hpp:5353
ERepr
representation class
Definition: Seq_inst_.hpp:91
ETopology
topology of molecule
Definition: Seq_inst_.hpp:121
EMol
molecule class in living organism
Definition: Seq_inst_.hpp:108
EStrand
strandedness in living organism
Definition: Seq_inst_.hpp:133
@ eRepr_const
constructed sequence
Definition: Seq_inst_.hpp:96
@ eRepr_ref
reference to another sequence
Definition: Seq_inst_.hpp:97
@ eRepr_seg
segmented sequence
Definition: Seq_inst_.hpp:95
@ eRepr_delta
sequence made by changes (delta) to others
Definition: Seq_inst_.hpp:100
@ eRepr_map
ordered map of any kind
Definition: Seq_inst_.hpp:99
@ eRepr_consen
consensus sequence or pattern
Definition: Seq_inst_.hpp:98
@ eRepr_raw
continuous sequence
Definition: Seq_inst_.hpp:94
@ eRepr_virtual
no seq data
Definition: Seq_inst_.hpp:93
@ eRepr_not_set
empty
Definition: Seq_inst_.hpp:92
@ eCompleteness_unknown
Definition: MolInfo_.hpp:155
@ eCompleteness_has_left
5' or NH3 end present
Definition: MolInfo_.hpp:161
@ eCompleteness_complete
complete biological entity
Definition: MolInfo_.hpp:156
@ eCompleteness_has_right
3' or COOH end present
Definition: MolInfo_.hpp:162
@ eCompleteness_no_left
missing 5' or NH3 end
Definition: MolInfo_.hpp:158
@ eCompleteness_partial
partial but no details given
Definition: MolInfo_.hpp:157
@ eCompleteness_no_right
missing 3' or COOH end
Definition: MolInfo_.hpp:159
@ eCompleteness_no_ends
missing both ends
Definition: MolInfo_.hpp:160
@ eTech_htgs_2
ordered High Throughput sequence contig
Definition: MolInfo_.hpp:138
@ eTech_physmap
from physical mapping techniques
Definition: MolInfo_.hpp:129
@ eTech_other
use Source.techexp
Definition: MolInfo_.hpp:148
@ eTech_htc
high throughput cDNA
Definition: MolInfo_.hpp:142
@ eTech_both
concept transl. w/ partial pept. seq.
Definition: MolInfo_.hpp:133
@ eTech_seq_pept_homol
sequenced peptide, ordered by homology
Definition: MolInfo_.hpp:135
@ eTech_composite_wgs_htgs
composite of WGS and HTGS
Definition: MolInfo_.hpp:145
@ eTech_sts
Sequence Tagged Site.
Definition: MolInfo_.hpp:126
@ eTech_htgs_3
finished High Throughput sequence
Definition: MolInfo_.hpp:139
@ eTech_seq_pept_overlap
sequenced peptide, ordered by overlap
Definition: MolInfo_.hpp:134
@ eTech_htgs_1
unordered High Throughput sequence contig
Definition: MolInfo_.hpp:137
@ eTech_concept_trans
conceptual translation
Definition: MolInfo_.hpp:131
@ eTech_tsa
transcriptome shotgun assembly
Definition: MolInfo_.hpp:146
@ eTech_standard
standard sequencing
Definition: MolInfo_.hpp:124
@ eTech_wgs
whole genome shotgun sequencing
Definition: MolInfo_.hpp:143
@ eTech_seq_pept
peptide was sequenced
Definition: MolInfo_.hpp:132
@ eTech_survey
one-pass genomic sequence
Definition: MolInfo_.hpp:127
@ eTech_htgs_0
single genomic reads for coordination
Definition: MolInfo_.hpp:141
@ eTech_derived
derived from other data, not a primary entity
Definition: MolInfo_.hpp:130
@ eTech_fli_cdna
full length insert cDNA
Definition: MolInfo_.hpp:140
@ eTech_est
Expressed Sequence Tag.
Definition: MolInfo_.hpp:125
@ eTech_concept_trans_a
conceptual transl. supplied by author
Definition: MolInfo_.hpp:136
@ eTech_genemap
from genetic mapping techniques
Definition: MolInfo_.hpp:128
@ eBiomol_pre_RNA
precursor RNA of any sort really
Definition: MolInfo_.hpp:102
@ eBiomol_cRNA
viral RNA genome copy intermediate
Definition: MolInfo_.hpp:111
@ eBiomol_snoRNA
small nucleolar RNA
Definition: MolInfo_.hpp:112
@ eBiomol_genomic_mRNA
reported a mix of genomic and cdna sequence
Definition: MolInfo_.hpp:110
@ eBiomol_transcribed_RNA
transcribed RNA other than existing classes
Definition: MolInfo_.hpp:113
@ eBiomol_other_genetic
other genetic material
Definition: MolInfo_.hpp:109
@ eTopology_tandem
some part of tandem repeat
Definition: Seq_inst_.hpp:125
@ eMol_not_set
> cdna = rna
Definition: Seq_inst_.hpp:109
@ eMol_na
just a nucleic acid
Definition: Seq_inst_.hpp:113
@ eStrand_other
default ds for DNA, ss for RNA, pept
Definition: Seq_inst_.hpp:138
@ eStrand_ds
double strand
Definition: Seq_inst_.hpp:136
@ eStrand_ss
single strand
Definition: Seq_inst_.hpp:135
int i
USING_SCOPE(objects)
CStaticPairArrayMap< const char *, CSeq_inst::TRepr, PCase_CStr > TCStringReprPairsMap
CStaticPairArrayMap< const char *, CSeq_inst::TMol, PCase_CStr > TCStringMolPairsMap
static const SStaticPair< const char *, CMolInfo::TCompleteness > s_map_completeness_names[]
CStaticPairArrayMap< const char *, CSeq_inst::TTopology, PCase_CStr > TCStringTopologyPairsMap
static const SStaticPair< const char *, CSeq_inst::TTopology > s_map_topology_names[]
DEFINE_STATIC_ARRAY_MAP(TCStringBiomolPairsMap, k_biomol_names, s_map_biomol_names)
static const SStaticPair< const char *, CSeq_inst::TRepr > s_map_repr_names[]
CStaticPairArrayMap< const char *, CMolInfo::TCompleteness, PCase_CStr > TCStringCompletenessPairsMap
static const SStaticPair< const char *, CSeq_inst::TMol > s_map_mol_names[]
CStaticPairArrayMap< const char *, CSeq_inst::TStrand, PCase_CStr > TCStringStrandPairsMap
CStaticPairArrayMap< const char *, CMolInfo::TBiomol, PCase_CStr > TCStringBiomolPairsMap
static const SStaticPair< const char *, CMolInfo::TBiomol > s_map_biomol_names[]
static const SStaticPair< const char *, CMolInfo::TTech > s_map_tech_names[]
static const SStaticPair< const char *, CSeq_inst::TStrand > s_map_strand_names[]
CStaticPairArrayMap< const char *, CMolInfo::TBiomol, PCase_CStr > TCStringTechPairsMap
static int match(register const pcre_uchar *eptr, register const pcre_uchar *ecode, const pcre_uchar *mstart, int offset_top, match_data *md, eptrblock *eptrb, unsigned int rdepth)
Definition: pcre_exec.c:513
bool QualifierNamesAreEquivalent(string name1, string name2)
Template structure SStaticPair is simlified replacement of STL pair<> Main reason of introducing this...
Definition: static_set.hpp:60
Modified on Wed Apr 17 13:10:03 2024 by modify_doxy.py rev. 669887