This file is indexed.

/usr/include/OpenDRIM/Transtype.h is in libopendrim0-dev 1.1.3-0ubuntu3.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
/*################################################################################
# Linux Management Providers (LMP), Provider Common Library
# Copyright (C) 2007 Frederic Desmons, ETRI <desmons@etri.re.kr, desmons_frederic@yahoo.fr>
# 
# This program is being developed under the "OpenDRIM" project.
# The "OpenDRIM" project web page: http://opendrim.sourceforge.net
# The "OpenDRIM" project mailing list: opendrim@googlegroups.com
# 
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; version 2
# of the License.
# 
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# 
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#################################################################################

#################################################################################
# To contributors, please leave your contact information in this section
# AND comment your changes in the source code.
# 
# Modified by <Author(s)>, <Affiliation>, <Year>
################################################################################*/

#ifndef TRANSTYPE_H_
#define TRANSTYPE_H_

#include "cmpidt.h"
#include "cmpimacs.h"

#include "Objectpath.h"

// Added 2007/10/29 by Frederic Desmons (desmons_frederic@yahoo.fr)
// Gets the string interpretation of a CMPIObjectPath
string CT_CMPIObjectPathToString(const CMPIObjectPath* cop);

// Added 2007/10/29 by Frederic Desmons (desmons_frederic@yahoo.fr)
// Gets the string interpretation of a CMPIArray
string CT_CMPIArrayToString(const CMPIArray* array);

// Added 2007/10/29 by Frederic Desmons (desmons_frederic@yahoo.fr)
// Gets the string interpretation of a CMPIData
string CT_CMPIDataToString(const CMPIData& data);

//uint8
CMPIValue CT_toCMPI(const unsigned char& value);
int CT_ToC(const CMPIData& data, unsigned char& value);

//uint16
CMPIValue CT_toCMPI(const unsigned short& value);
int CT_ToC(const CMPIData& data, unsigned short& value);

//uint32
CMPIValue CT_toCMPI(const unsigned int& value);
int CT_ToC(const CMPIData& data, unsigned int& value);

//uint32 deprecated
CMPIValue CT_toCMPI(const unsigned long& value);
int CT_ToC(const CMPIData& data, unsigned long& value);

//uint64
CMPIValue CT_toCMPI(const unsigned long long& value);
int CT_ToC(const CMPIData& data, unsigned long long& value);

//sint8
CMPIValue CT_toCMPI(const signed char& value);
int CT_ToC(const CMPIData& data, signed char& value);

//sint16
CMPIValue CT_toCMPI(const short& value);
int CT_ToC(const CMPIData& data, short& value);

//sint32
CMPIValue CT_toCMPI(const int& value);
int CT_ToC(const CMPIData& data, int& value);

//sint32 deprecated
CMPIValue CT_toCMPI(const long& value);
int CT_ToC(const CMPIData& data, long& value);

//sint64
CMPIValue CT_toCMPI(const long long& value);
int CT_ToC(const CMPIData& data, long long& value);

//real32
CMPIValue CT_toCMPI(const float& value);
int CT_ToC(const CMPIData& data, float& value);

//real64
CMPIValue CT_toCMPI(const double& value);
int CT_ToC(const CMPIData& data, double& value);

//char16
CMPIValue CT_toCMPIChar16(const unsigned short& value);
int CT_ToCChar16(const CMPIData& data, unsigned short& value);

//boolean
CMPIValue CT_toCMPI(const bool& value);
int CT_ToC(const CMPIData& data, bool& value);

//string
CMPIValue CT_toCMPI(const CMPIBroker* broker, const string& value);
int CT_ToC(const CMPIData& data, string& value);

//datetime
CMPIValue CT_toCMPIDatetime(const CMPIBroker* broker, const string& value);
int CT_ToCDatetime(const CMPIData& data, string& value);

//REF
CMPIValue CT_toCMPI(const Objectpath& value);
int CT_ToC(const CMPIBroker* broker, const CMPIData& data, Objectpath& value);

//uint8[]
CMPIValue CT_toCMPI(const CMPIBroker* broker, const vector<unsigned char>& value);
int CT_ToC(const CMPIData& data, vector<unsigned char>& value);

//uint16[]
CMPIValue CT_toCMPI(const CMPIBroker* broker, const vector<unsigned short>& value);
int CT_ToC(const CMPIData& data, vector<unsigned short>& value);

//uint32[]
CMPIValue CT_toCMPI(const CMPIBroker* broker, const vector<unsigned int>& value);
int CT_ToC(const CMPIData& data, vector<unsigned int>& value);

//uint32[] deprecated
CMPIValue CT_toCMPI(const CMPIBroker* broker, const vector<unsigned long>& value);
int CT_ToC(const CMPIData& data, vector<unsigned long>& value);

//uint64[]
CMPIValue CT_toCMPI(const CMPIBroker* broker, const vector<unsigned long long>& value);
int CT_ToC(const CMPIData& data, vector<unsigned long long>& value);

//sint8[]
CMPIValue CT_toCMPI(const CMPIBroker* broker, const vector<signed char>& value);
int CT_ToC(const CMPIData& data, vector<signed char>& value);

//sint16[]
CMPIValue CT_toCMPI(const CMPIBroker* broker, const vector<short>& value);
int CT_ToC(const CMPIData& data, vector<short>& value);

//sint32[]
CMPIValue CT_toCMPI(const CMPIBroker* broker, const vector<int>& value);
int CT_ToC(const CMPIData& data, vector<int>& value);

//sint32[] deprecated
CMPIValue CT_toCMPI(const CMPIBroker* broker, const vector<long>& value);
int CT_ToC(const CMPIData& data, vector<long>& value);

//sint64[]
CMPIValue CT_toCMPI(const CMPIBroker* broker, const vector<long long>& value);
int CT_ToC(const CMPIData& data, vector<long long>& value);

//real32[]
CMPIValue CT_toCMPI(const CMPIBroker* broker, const vector<float>& value);
int CT_ToC(const CMPIData& data, vector<float>& value);

//real64[]
CMPIValue CT_toCMPI(const CMPIBroker* broker, const vector<double>& value);
int CT_ToC(const CMPIData& data, vector<double>& value);

//char16[]
CMPIValue CT_toCMPIChar16(const CMPIBroker* broker, const vector<unsigned short>& value);
int CT_ToCChar16(const CMPIData& data, vector<unsigned short>& value);

//boolean[]
CMPIValue CT_toCMPI(const CMPIBroker* broker, const vector<bool>& value);
int CT_ToC(const CMPIData& data, vector<bool>& value);

//string[]
CMPIValue CT_toCMPI(const CMPIBroker* broker, const vector<string>& value);
int CT_ToC(const CMPIData& data, vector<string>& value);

//datetime[]
CMPIValue CT_toCMPIDatetime(const CMPIBroker* broker, const vector<string>& value);
int CT_ToCDatetime(const CMPIData& data, vector<string>& value);

//REF[]
CMPIValue CT_toCMPI(const CMPIBroker* broker, const vector<Objectpath>& value);
int CT_ToC(const CMPIBroker* broker, const CMPIData& data, vector<Objectpath>& value);

#endif /*TRANSTYPE_H_*/