data_converter.h

//
// Copyright (c) 2014 Limit Point Systems, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

// Interface for class data_converter

#ifndef DATA_CONVERTER_H
#define DATA_CONVERTER_H

#ifndef SHEAF_DLL_SPEC_H
#include "SheafSystem/sheaf_dll_spec.h"
#endif

#ifndef ANY_H
#include "SheafSystem/any.h"
#endif

#ifndef PRIMITIVE_TYPE_H
#include "SheafSystem/primitive_type.h"
#endif

#ifndef STD_HDF5_H
#include "SheafSystem/std_hdf5.h"
#endif

#ifndef STD_STRING_H
#include "SheafSystem/std_string.h"
#endif

namespace sheaf
{
  
class SHEAF_DLL_SPEC data_converter : public any
{

public:

  // CANONICAL MEMBERS

  virtual data_converter* clone() const;

  virtual ~data_converter();

  virtual bool invariant() const;

  virtual bool is_ancestor_of(const any* other) const;

  // DATA_CONVERTER INTERFACE

  data_converter(hid_t xexternal_type,
                 hid_t xinternal_type,
                 //                  const scoped_index& xinternal_index);
                 int xinternal_index);

  
  
  inline bool conversion_required() const
  {
    return _conversion_required;
  } ;

  
  
  inline hid_t external_type() const
  {
    return _external_type;
  } ;

  
  
  inline size_t external_size() const
  {
    return _external_size;
  };

  // INTERFACE FOR SIMPLE TYPES

  void externalize(const void* xint_buf,
                   size_t xint_buf_ub,
                   void* xext_buf,
                   size_t xext_buf_ub,
                   int xitem_ct);

  void externalize(void* xext_buf,
                   size_t xext_buf_ub,
                   int xitem_ct);

  void externalize(const void* xint_buf,
                   size_t xint_buf_ub);

  
  
  inline hid_t internal_type() const
  {
    return _internal_type;
  } ;

  
  
  inline hid_t internal_index() const
  {
    return _internal_index;
  } ;

  
  
  inline size_t internal_size() const
  {
    return _internal_size;
  };

  
  
  inline size_t internal_alignment() const
  {
    return _internal_alignment;
  };

  void internalize(const void* xext_buf,
                   size_t xext_buf_ub,
                   void* xint_buf,
                   size_t xint_buf_ub,
                   int xitem_ct);

  void internalize(void* xbuf, size_t xbuf_ub, int xitem_ct);

  void internalize(void* xbuf, size_t xbuf_ub);

  
  
  inline bool internal_size_greater() const
  {
    return _internal_size > _external_size;
  };

  
  
  inline bool external_size_greater() const
  {
    return _external_size > _internal_size;
  };

  
  
  inline size_t max_size() const
  {
    return _internal_size > _external_size ? _internal_size : _external_size;
  } ;

  
  
  inline void* result() const
  {
    return _result;
  };

  
  
  inline size_t result_size() const
  {
    return _result_size;
  } ;

  
  
  inline bool is_namespace_relative_member_index_type() const
  {
    return _internal_index == NAMESPACE_RELATIVE_MEMBER_INDEX;
  };

  
  
  inline bool is_namespace_relative_subposet_index_type() const
  {
    return _internal_index == NAMESPACE_RELATIVE_SUBPOSET_INDEX;
  };

  
  
  inline bool is_string_type() const
  {
    return _internal_index == C_STRING;
  };

  static size_t string_length(const char* xbuf);

  size_t string_length_total(const void* xbuf, int xitem_ct) const;


private:

  data_converter();

  data_converter(const data_converter& xother);

  hid_t _external_type;

  size_t _external_size;

  hid_t _internal_type;

  size_t _internal_size;


  int _internal_index;

  size_t _internal_alignment;

  void* _result;

  size_t _result_size;

  hid_t _transfer_plist;

  bool _conversion_required;

};

} // namespace sheaf
 
#endif // ifndef DATA_CONVERTER_H