OpendTect  6.6
netreqpacket.h
Go to the documentation of this file.
1 #pragma once
2 
3 /*+
4 ________________________________________________________________________
5 
6  (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
7  Author: K. Tingdahl
8  Date: August 2014
9  RCS: $Id$
10 ________________________________________________________________________
11 
12 -*/
13 
14 #include "networkmod.h"
15 
16 #include "arrayndimpl.h"
17 #include "arrayndinfo.h"
18 #include "bufstringset.h"
19 #include "commontypes.h"
20 #include "odjson.h"
21 #include "pythonaccess.h"
22 #include "refcount.h"
23 #include "uistringset.h"
24 
25 #define mRequestPacketHeaderSize 10
26 
27 class IOPar;
28 template <class T> class ArrayND;
29 
30 
31 namespace Network
32 {
33 
34 class PacketFiller;
35 class PacketInterpreter;
36 
37 /*\brief Standardized packet that can be sent over a Tcp connection
38 
39  The request header contains a unique (int) request ID and a (short) sub-ID.
40  The sub-ID is a flag that can be used to implement your protocol. Negative
41  sub-IDs are special and cannot be freely used.
42 
43  Servers will not send Begin packets as they don't initiate requests. Replies
44  are never Begin packets. Error always implies End.
45 
46  Request IDs are obtained by using setIsNewRequest().
47 
48  At the end of the class there is a public section for expert usage.
49 
50  */
51 
52 mExpClass(Network) RequestPacket : public RefCount::Referenced
53 { mODTextTranslationClass(RequestPacket)
54 public:
55  RequestPacket(od_int32 payloadsize=0);
56  RequestPacket(const RequestPacket&);
57 
58  od_int32 requestID() const;
59  bool isNewRequest() const { return subID()==cBeginSubID(); }
60  bool isRequestEnd() const { return subID()<cMoreSubID(); }
61  bool isError() const { return subID()==cErrorSubID(); }
62  const void* payload() const;
63 
64  void getStringPayload(BufferString&) const;
65  uiRetVal getPayload(OD::JSON::Object&) const;
66  uiRetVal getPayload(IOPar&) const;
67  template <class T> ArrayND<T>* getPayload(uiRetVal&) const;
68  PtrMan<PacketInterpreter> getPayload(ObjectSet<ArrayNDInfo>&,
69  TypeSet<OD::DataRepType>&) const;
70 
71  od_int32 payloadSize() const;
72  od_int32 totalSize() const
73  { return payloadSize() + mRequestPacketHeaderSize; }
74 
75  int setIsNewRequest();
76  void setRequestID(od_int32);
77  void setIsError() { setSubID( cErrorSubID() ); }
78  void setIsLast() { setSubID( cEndSubID() ); }
79 
80  void* allocPayload(od_int32 size);
81  void setPayload(void*,od_int32 size);
82  void setStringPayload(const char*);
83  bool setPayload(const OD::JSON::Object&);
84  bool setPayload(const IOPar&);
85  template <class T> bool setPayload(const ArrayND<T>&);
86  PtrMan<PacketFiller> setPayload(const ObjectSet<ArrayNDInfo>&,
87  const TypeSet<OD::DataRepType>&);
88 
89  void addErrMsg(BufferString&) const;
90 
91  // essentially, there is no limit unless user sets it
92  static od_int32 systemSizeLimit(); //< if < 1 no limit
93  static void setSystemSizeLimit(od_int32); //< no limit set to 0
94 
95 protected:
96  ~RequestPacket();
97 
98  union Header
99  {
100  Header()
101  { int32s_[0] = 0; int32s_[1] = 0; int16s_[4] = 0; }
102 
103  od_int32 int32s_[2];
104  od_int16 int16s_[5];
105  };
106 
107 
108  Header header_;
109  char* payload_ = nullptr;
110 
111  static od_int16 cBeginSubID() { return -1; }
112  static od_int16 cMoreSubID() { return -2; }
113  static od_int16 cEndSubID() { return -4; }
114  static od_int16 cErrorSubID() { return -8; }
115 
116 private:
117 
118  friend class PacketFiller;
119  friend class PacketInterpreter;
120 
121  static OD::JSON::Object getDefaultJsonHeader(bool fortxt,od_int32 sz);
122  PacketFiller* finalize(const OD::JSON::Object&);
123  PacketInterpreter* readJsonHeader(OD::JSON::Object&,uiRetVal&) const;
124 
125 public:
126 
127  bool isOK() const;
129  od_int16 subID() const;
130 
131  void setSubID(od_int16);
132 
133  static od_int32 headerSize() { return mRequestPacketHeaderSize; }
134  static od_int32 getPayloadSize(const void*);
135 
136  void* payload(bool takeover=false);
139  void* getRawHeader() { return header_.int32s_; }
140  const void* getRawHeader() const { return header_.int32s_; }
141 };
142 
143 
144 /*\brief fills a packet's payload.
145 
146  Use the sizeFor() functions to calculate the total payload size.
147 
148 */
149 
150 mExpClass(Network) PacketFiller
151 {
152 public:
153  PacketFiller( RequestPacket& p, int startpos=0 )
154  : pkt_(p)
155  , curpos_(startpos) {}
156 
157 # define mNPFSizeFor(v) Network::PacketFiller::sizeFor(v)
158 # define mNPFSizeForArr(a,s) Network::PacketFiller::sizeFor(a,s)
159  template <class T>
160  static int sizeFor(const T&);
161  template <class T>
162  static int sizeFor(const T*,int nrelems,bool rawmode=false);
163  static int sizeFor(const char*);
164 
165  template <class T> const PacketFiller&
166  put(const T&) const;
167  template <class T> const PacketFiller&
168  put(const T*,int nrelems,bool rawmode=false) const;
169  template <class T> const PacketFiller&
170  put(const ArrayND<T>&,bool rawmode=false) const;
171 
172  const PacketFiller& put(const char*) const;
173  const PacketFiller& putBytes(const void*,int nrbytes) const;
174 
175 protected:
176 
177  RequestPacket& pkt_;
178  mutable int curpos_;
179 
180 };
181 
182 
183 /*\brief interprets what is in a packet.
184 
185  You need to know what should be in there. Arrays/sets are always
186  preceeded by their size.
187 
188 */
189 
190 mExpClass(Network) PacketInterpreter
191 {
192 public:
193  PacketInterpreter( const RequestPacket& p,
194  int startpos=0 )
195  : pkt_(p)
196  , curpos_(startpos) {}
197 
198  template <class T> void get(T&) const;
199  inline bool getBool() const;
200  inline int getInt() const;
201  inline float getFloat() const;
202  inline double getDouble() const;
203  inline BufferString getString() const;
204 
205  template <class T> void getArr(T*,int maxsz,bool rawmode=false) const;
206  template <class T> void getArr(ArrayND<T>&,bool rawmode=false) const;
207  inline void getSet(BufferStringSet&,int maxsz=-1) const;
208  template <class T> void getSet(TypeSet<T>&,int maxsz=-1,
209  bool rawmode=false) const;
210 
211  inline void move( int nrb ) const { curpos_ += nrb; }
212  inline void moveTo( int pos ) const { curpos_ = pos; }
213  template <class T> void peek(T&) const;
214  inline int peekInt() const;
215  void getBytes(void*,int nrbytes) const;
216 
217  inline bool atEndOfPkt() const;
218 
219 protected:
220 
221  const RequestPacket& pkt_;
222  mutable int curpos_;
223 
224 };
225 
226 
227 
228 template <class T> inline
229 bool RequestPacket::setPayload( const ArrayND<T>& arr )
230 {
231  ObjectSet<ArrayNDInfo> infos;
232  TypeSet<OD::DataRepType> types;
233  infos.add( (ArrayNDInfo*)&arr.info() );
234  types += OD::GetDataRepType<T>();
235  PtrMan<PacketFiller> filler = setPayload( infos, types );
236  if ( !filler )
237  return false;
238 
239  filler->put( arr, true );
240  return true;
241 }
242 
243 
244 template <class T> inline
245 ArrayND<T>* RequestPacket::getPayload( uiRetVal& uirv ) const
246 {
247  ObjectSet<ArrayNDInfo> infos;
248  TypeSet<OD::DataRepType> types;
249  PtrMan<PacketInterpreter> interp = getPayload( infos, types );
250  if ( !interp || infos.isEmpty() )
251  { deepErase( infos ); return nullptr; }
252 
253  ArrayND<T>* ret = (ArrayND<T>*)getArrayND( *infos.first(), types[0] );
254  deepErase( infos );
255  if ( !ret || !ret->isOK() )
256  { delete ret; return nullptr; }
257 
258  interp->getArr( *ret, true );
259 
260  return ret;
261 }
262 
263 
264 
265 template <class T>
266 inline int PacketFiller::sizeFor( const T& var )
267 {
268  return sizeof(T);
269 }
270 
271 template <class T>
272 inline int PacketFiller::sizeFor( const T* arr, int nrelems, bool rawmode )
273 {
274  return (rawmode ? 0 : sizeof(int)) + nrelems * sizeof(T);
275 }
276 
277 template <>
278 inline int PacketFiller::sizeFor( const bool& var )
279 {
280  return sizeFor( ((int)var) );
281 }
282 
283 template <>
284 inline int PacketFiller::sizeFor( const OD::String& str )
285 {
286  return sizeof(int) + str.size();
287 }
288 
289 template <>
290 inline int PacketFiller::sizeFor( const BufferString& str )
291 { return sizeFor( (const OD::String&) str ); }
292 
293 template <>
294 inline int PacketFiller::sizeFor( const FixedString& str )
295 { return sizeFor( (const OD::String&) str ); }
296 
297 template <>
298 inline int PacketFiller::sizeFor( const BufferStringSet& bss )
299 {
300  int ret = sizeof(int);
301  for ( int idx=0; idx<bss.size(); idx++ )
302  ret += sizeFor( bss.get(idx) );
303  return ret;
304 }
305 
306 inline int PacketFiller::sizeFor( const char* str )
307 {
308  return sizeFor( FixedString(str) );
309 }
310 
311 
312 template <class T>
313 inline const PacketFiller& PacketFiller::put( const T& var ) const
314 {
315  return putBytes( &var, sizeof(T) );
316 }
317 
318 
319 template <class T>
320 inline const PacketFiller& PacketFiller::put( const T* arr, int nrelems,
321  bool rawmode ) const
322 {
323  if ( !rawmode )
324  put( nrelems );
325  return putBytes( arr, nrelems * sizeof(T) );
326 }
327 
328 template <class T>
329 inline const PacketFiller& PacketFiller::put( const ArrayND<T>& arr,
330  bool rawmode ) const
331 {
332  if ( arr.getData() )
333  return put( arr.getData(), arr.totalSize(), rawmode );
334 
335  if ( !rawmode )
336  put( arr.totalSize() );
337 
338  ArrayNDIter iter( arr.info() );
339  do
340  {
341  const T val = arr.getND( iter.getPos() );
342  put( val );
343  } while( iter.next() );
344 
345  return *this;
346 }
347 
348 
349 template <>
350 inline const PacketFiller& PacketFiller::put( const bool& var ) const
351 {
352  const int toput = var ? 1 : 0;
353  return put( toput );
354 }
355 
356 template <>
357 inline const PacketFiller& PacketFiller::put( const OD::String& str ) const
358 {
359  const int sz = str.size();
360  put( sz );
361  return putBytes( str.str(), sz );
362 }
363 
364 template <>
365 inline const PacketFiller& PacketFiller::put( const BufferString& str ) const
366 { return put( (const OD::String&) str ); }
367 
368 template <>
369 inline const PacketFiller& PacketFiller::put( const FixedString& str ) const
370 { return put( (const OD::String&) str ); }
371 
372 template <>
373 inline const PacketFiller& PacketFiller::put( const BufferStringSet& bss ) const
374 {
375  const int sz = bss.size();
376  put( sz );
377  for ( int idx=0; idx<sz; idx++ )
378  put( bss.get(idx) );
379  return *this;
380 }
381 
382 inline const PacketFiller& PacketFiller::put( const char* str ) const
383 { return put( FixedString(str) ); }
384 
385 inline const PacketFiller& PacketFiller::putBytes( const void* ptr,
386  int sz ) const
387 {
388  if ( sz > 0 )
389  {
390  OD::memCopy( pkt_.payload_+curpos_, ptr, sz );
391  curpos_ += sz;
392  }
393  return *this;
394 }
395 
396 
397 
398 
399 template <class T>
400 inline void PacketInterpreter::peek( T& var ) const
401 {
402  OD::memCopy( &var, pkt_.payload_+curpos_, sizeof(T) );
403 }
404 
405 template <class T>
406 inline void PacketInterpreter::get( T& var ) const
407 {
408  getBytes( &var, sizeof(T) );
409 }
410 
411 template <>
412 inline void PacketInterpreter::get( BufferString& var ) const
413 {
414  int sz; get( sz );
415  if ( sz < 1 )
416  {
417  if ( sz < 0 )
418  { pErrMsg("Invalid string size"); }
419  var.setEmpty();
420  return;
421  }
422  var.setBufSize( sz+1 );
423  char* cstr = var.getCStr();
424  getBytes( cstr, sz );
425  cstr[sz] = '\0';
426 }
427 
428 inline int PacketInterpreter::peekInt() const
429 { int ret = 0; peek(ret); return ret; }
430 inline bool PacketInterpreter::getBool() const
431 { int ret = 0; get(ret); return ret != 0; }
432 inline int PacketInterpreter::getInt() const
433 { int ret = 0; get(ret); return ret; }
434 inline float PacketInterpreter::getFloat() const
435 { float ret = 0.f; get(ret); return ret; }
436 inline double PacketInterpreter::getDouble() const
437 { double ret = 0.; get(ret); return ret; }
438 inline BufferString PacketInterpreter::getString() const
439 { BufferString ret; get(ret); return ret; }
440 
441 template <class T>
442 inline void PacketInterpreter::getArr( T* arr, int maxsz, bool rawmode ) const
443 {
444  int arrsz = maxsz;
445  if ( !rawmode )
446  get( arrsz );
447  int sz = arrsz;
448  if ( sz > maxsz )
449  sz = maxsz;
450  if ( arrsz < 1 )
451  return;
452 
453  getBytes( arr, sz*sizeof(T) );
454 }
455 
456 template <class T>
457 inline void PacketInterpreter::getArr( ArrayND<T>& arr, bool rawmode ) const
458 {
459  if ( arr.getData() )
460  {
461  getArr( arr.getData(), arr.totalSize(), rawmode );
462  return;
463  }
464 
465  int arrsz = mCast(int,arr.totalSize());
466  if ( !rawmode )
467  {
468  get( arrsz );
469  if ( arrsz != arr.totalSize() )
470  return;
471  }
472 
473  ArrayNDIter iter( arr.info() );
474  T val;
475  do
476  {
477  get( val );
478  arr.setND( iter.getPos(), val );
479  } while( iter.next() );
480 }
481 
482 template <class T>
483 inline void PacketInterpreter::getSet( TypeSet<T>& ts, int maxsz,
484  bool rawmode ) const
485 {
486  int arrsz = maxsz;
487  if ( !rawmode )
488  get( arrsz );
489  int sz = arrsz;
490  if ( maxsz >= 0 && sz > maxsz )
491  sz = maxsz;
492  if ( arrsz < 1 )
493  { ts.setEmpty(); return; }
494 
495  ts.setSize( sz );
496  getBytes( ts.arr(), sz*sizeof(T) );
497 }
498 
499 inline void PacketInterpreter::getSet( BufferStringSet& bss,
500  int maxsz ) const
501 {
502  int setsz; get( setsz );
503  int sz = setsz;
504  if ( maxsz >= 0 && sz > maxsz )
505  sz = maxsz;
506  bss.setEmpty();
507  if ( setsz < 1 )
508  return;
509 
510  for ( int idx=0; idx<sz; idx++ )
511  {
512  BufferString* bs = new BufferString;
513  get( *bs );
514  bss += bs;
515  }
516 
517  for ( int idx=sz; idx<setsz; idx++ )
518  getString();
519 }
520 
521 inline void PacketInterpreter::getBytes( void* ptr, int nrbytes ) const
522 {
523  if ( nrbytes > 0 )
524  {
525  OD::memCopy( ptr, pkt_.payload_+curpos_, nrbytes );
526  curpos_ += nrbytes;
527  }
528 }
529 
530 inline bool PacketInterpreter::atEndOfPkt() const
531 { return curpos_ >= pkt_.payloadSize(); }
532 
533 }; //Namespace Network
Network::PacketInterpreter::get
void get(T &) const
Definition: netreqpacket.h:406
Network::PacketInterpreter::PacketInterpreter
PacketInterpreter(const RequestPacket &p, int startpos=0)
Definition: netreqpacket.h:193
Network::RequestPacket
Definition: netreqpacket.h:53
Network::PacketInterpreter::getInt
int getInt() const
Definition: netreqpacket.h:432
uistringset.h
BufferStringSet::get
BufferString & get(idx_type idx)
Definition: bufstringset.h:57
Network::RequestPacket::cErrorSubID
static od_int16 cErrorSubID()
Definition: netreqpacket.h:114
Network::RequestPacket::setPayload
bool setPayload(const OD::JSON::Object &)
Network::RequestPacket::setIsLast
void setIsLast()
Definition: netreqpacket.h:78
ArrayNDInfo
Contains the information about the size of ArrayND, and in what order the data is stored (if accessab...
Definition: arrayndinfo.h:25
ObjectSet
Set of pointers to objects.
Definition: commontypes.h:31
Network::RequestPacket::getPayloadSize
static od_int32 getPayloadSize(const void *)
Network::RequestPacket::cEndSubID
static od_int16 cEndSubID()
Definition: netreqpacket.h:113
ObjectSet::add
ObjectSet & add(T *t)
Definition: objectset.h:69
BufferStringSet
Set of BufferString objects.
Definition: bufstringset.h:26
Network::RequestPacket::cMoreSubID
static od_int16 cMoreSubID()
Definition: netreqpacket.h:112
getArrayND
void * getArrayND(const ArrayNDInfo &, const OD::DataRepType)
Implementation of ArrayND.
Network::RequestPacket::RequestPacket
mODTextTranslationClass(RequestPacket) public RequestPacket(const RequestPacket &)
Network::PacketFiller::put
const PacketFiller & put(const T &) const
Definition: netreqpacket.h:313
Network::RequestPacket::setSubID
void setSubID(od_int16)
Network::PacketInterpreter::peekInt
int peekInt() const
Definition: netreqpacket.h:428
mExpClass
#define mExpClass(module)
Definition: commondefs.h:177
Network::RequestPacket::setIsError
void setIsError()
Definition: netreqpacket.h:77
ObjectSet::first
T * first()
Definition: objectset.h:565
Network::RequestPacket::setSystemSizeLimit
static void setSystemSizeLimit(od_int32)
Network::PacketInterpreter::getBool
bool getBool() const
Definition: netreqpacket.h:430
Network::RequestPacket::Header::Header
Header()
Definition: netreqpacket.h:100
Network::PacketInterpreter::getArr
void getArr(T *, int maxsz, bool rawmode=false) const
Definition: netreqpacket.h:442
Network::PacketInterpreter::peek
void peek(T &) const
Definition: netreqpacket.h:400
Network
Definition: jobcommunic.h:22
Network::RequestPacket::getRawHeader
const void * getRawHeader() const
Definition: netreqpacket.h:140
Network::PacketInterpreter::move
void move(int nrb) const
Definition: netreqpacket.h:211
Network::RequestPacket::subID
od_int16 subID() const
Network::RequestPacket::getRawHeader
void * getRawHeader()
Definition: netreqpacket.h:139
Network::RequestPacket::totalSize
od_int32 totalSize() const
Definition: netreqpacket.h:72
uiRetVal
Definition: uistringset.h:105
Network::RequestPacket::setPayload
PtrMan< PacketFiller > setPayload(const ObjectSet< ArrayNDInfo > &, const TypeSet< OD::DataRepType > &)
Pick::getSet
Pick::Set * getSet(const MultiID &, BufferString &)
Network::PacketFiller::sizeFor
static int sizeFor(const T &)
Definition: netreqpacket.h:266
Network::RequestPacket::isError
bool isError() const
Definition: netreqpacket.h:61
arrayndimpl.h
ArrayND::isOK
virtual bool isOK() const
Definition: arraynd.h:367
Network::RequestPacket::isOK
bool isOK() const
checks whether the header is reasonable
Network::RequestPacket::setPayload
void setPayload(void *, od_int32 size)
buf becomes mine
mODTextTranslationClass
#define mODTextTranslationClass(clss)
Definition: uistring.h:40
ArrayND::setND
virtual void setND(const int *, T)=0
Network::RequestPacket::headerSize
static od_int32 headerSize()
Definition: netreqpacket.h:133
BufferString::getCStr
char * getCStr()
Definition: bufstring.h:77
Network::RequestPacket::getPayload
PtrMan< PacketInterpreter > getPayload(ObjectSet< ArrayNDInfo > &, TypeSet< OD::DataRepType > &) const
arrayndinfo.h
Network::PacketInterpreter::atEndOfPkt
bool atEndOfPkt() const
Definition: netreqpacket.h:530
Network::PacketInterpreter::getString
BufferString getString() const
Definition: netreqpacket.h:438
ArrayND::info
virtual const ArrayNDInfo & info() const =0
BufferStringSet::setEmpty
void setEmpty()
Definition: bufstringset.h:64
mRequestPacketHeaderSize
#define mRequestPacketHeaderSize
Definition: netreqpacket.h:25
Network::PacketFiller::putBytes
const PacketFiller & putBytes(const void *, int nrbytes) const
Definition: netreqpacket.h:385
Network::PacketInterpreter::curpos_
int curpos_
Definition: netreqpacket.h:222
Network::RequestPacket::setStringPayload
void setStringPayload(const char *)
OD::String::str
const char * str() const
Definition: odstring.h:47
Network::RequestPacket::getPayload
uiRetVal getPayload(OD::JSON::Object &) const
od_int16
#define od_int16
Definition: plftypes.h:26
ArrayNDIter::getPos
const int * getPos() const
Definition: arraynd.h:220
ArrayNDIter
Iterates through all samples in an ArrayND.
Definition: arraynd.h:209
PtrMan
Definition: ptrman.h:121
ArrayNDIter::next
bool next()
Network::PacketInterpreter::getSet
void getSet(BufferStringSet &, int maxsz=-1) const
Definition: netreqpacket.h:499
Network::RequestPacket::getDefaultJsonHeader
static OD::JSON::Object getDefaultJsonHeader(bool fortxt, od_int32 sz)
Network::RequestPacket::readJsonHeader
PacketInterpreter * readJsonHeader(OD::JSON::Object &, uiRetVal &) const
BufferString::setBufSize
bool setBufSize(unsigned int)
ArrayND::totalSize
uint64_t totalSize() const
Definition: arraynd.h:87
FixedString
OD::String that holds an existing text string.
Definition: fixedstring.h:29
pErrMsg
#define pErrMsg(msg)
Usual access point for programmer error messages.
Definition: errmsg.h:37
Network::RequestPacket::getStringPayload
void getStringPayload(BufferString &) const
Network::RequestPacket::~RequestPacket
~RequestPacket()
BufferStringSet::size
size_type size() const
Definition: bufstringset.h:43
Network::PacketInterpreter::getDouble
double getDouble() const
Definition: netreqpacket.h:436
Network::RequestPacket::allocPayload
void * allocPayload(od_int32 size)
Network::RequestPacket::isNewRequest
bool isNewRequest() const
Definition: netreqpacket.h:59
Network::PacketInterpreter::pkt_
const RequestPacket & pkt_
Definition: netreqpacket.h:221
ArrayND::getND
virtual T getND(const int *) const =0
mCast
#define mCast(tp, v)
Definition: commondefs.h:137
BufferString
OD::String with its own variable length buffer. The buffer has a guaranteed minimum size.
Definition: bufstring.h:40
Network::RequestPacket::setIsNewRequest
int setIsNewRequest()
conveniently returns reqID()
bufstringset.h
deepErase
void deepErase(BufferStringSet &)
OD::String::size
unsigned int size() const
Network::PacketInterpreter
Definition: netreqpacket.h:191
Network::RequestPacket::getPayload
uiRetVal getPayload(IOPar &) const
pythonaccess.h
Network::RequestPacket::Header
Definition: netreqpacket.h:99
od_int32
#define od_int32
Definition: plftypes.h:30
Network::PacketInterpreter::moveTo
void moveTo(int pos) const
Definition: netreqpacket.h:212
OD::String
encapsulates the read-access-only part of strings in OD.
Definition: odstring.h:31
BufferString::setEmpty
BufferString & setEmpty()
ArrayND
An ArrayND is an array with a given number of dimensions and a size.
Definition: arraynd.h:33
Network::PacketFiller
Definition: netreqpacket.h:151
Network::PacketInterpreter::getFloat
float getFloat() const
Definition: netreqpacket.h:434
Network::RequestPacket::payload
void * payload(bool takeover=false)
Network::PacketFiller::PacketFiller
PacketFiller(RequestPacket &p, int startpos=0)
Definition: netreqpacket.h:153
refcount.h
Network::RequestPacket::isRequestEnd
bool isRequestEnd() const
Definition: netreqpacket.h:60
Network::RequestPacket::header_
Header header_
Definition: netreqpacket.h:108
odjson.h
Network::RequestPacket::systemSizeLimit
static od_int32 systemSizeLimit()
Network::RequestPacket::payload
const void * payload() const
Network::RequestPacket::Header::int32s_
od_int32 int32s_[2]
Definition: netreqpacket.h:103
Network::RequestPacket::finalize
PacketFiller * finalize(const OD::JSON::Object &)
Network::PacketFiller::pkt_
RequestPacket & pkt_
Definition: netreqpacket.h:177
Network::RequestPacket::cBeginSubID
static od_int16 cBeginSubID()
Definition: netreqpacket.h:111
Network::PacketFiller::curpos_
int curpos_
Definition: netreqpacket.h:178
commontypes.h
Network::RequestPacket::payloadSize
od_int32 payloadSize() const
Network::RequestPacket::addErrMsg
void addErrMsg(BufferString &) const
Network::RequestPacket::payload_
char * payload_
Definition: netreqpacket.h:109
Network::PacketInterpreter::getBytes
void getBytes(void *, int nrbytes) const
Definition: netreqpacket.h:521
IOPar
Generalized set of parameters of the keyword-value type.
Definition: iopar.h:55
ArrayND::getData
const T * getData() const
Definition: arraynd.h:54
OD::JSON::Object
ValueSet where the values and subsets have a key.
Definition: odjson.h:283
TypeSet
Sets of (small) copyable elements.
Definition: commontypes.h:29
Network::RequestPacket::setRequestID
void setRequestID(od_int32)
for multi-packet requests
Network::RequestPacket::setPayload
bool setPayload(const IOPar &)
Network::RequestPacket::requestID
od_int32 requestID() const

Generated at for the OpendTect seismic interpretation project. Copyright (C): dGB Beheer B.V. 1995-2021