// Generated by gmmproc 2.54.1 -- DO NOT MODIFY!
#ifndef _GIOMM_CONVERTER_H
#define _GIOMM_CONVERTER_H


#include <glibmm/ustring.h>
#include <sigc++/sigc++.h>

/* Copyright (C) 2012 The giomm Development Team
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <glibmm/interface.h>


#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct _GConverterIface GConverterIface;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */

#ifndef DOXYGEN_SHOULD_SKIP_THIS
using GConverter = struct _GConverter;
using GConverterClass = struct _GConverterClass;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Gio
{ class Converter_Class; } // namespace Gio
#endif // DOXYGEN_SHOULD_SKIP_THIS

namespace Gio
{

/** @addtogroup giommEnums giomm Enums and Flags */

/** 
 *  @var ConverterResult CONVERTER_ERROR
 * There was an error during conversion.
 * 
 *  @var ConverterResult CONVERTER_CONVERTED
 * Some data was consumed or produced.
 * 
 *  @var ConverterResult CONVERTER_FINISHED
 * The conversion is finished.
 * 
 *  @var ConverterResult CONVERTER_FLUSHED
 * Flushing is finished.
 * 
 *  @enum ConverterResult
 * 
 * Results returned from g_converter_convert().
 * 
 * @newin{2,24}
 *
 * @ingroup giommEnums
 */
enum ConverterResult
{
  CONVERTER_ERROR,
  CONVERTER_CONVERTED,
  CONVERTER_FINISHED,
  CONVERTER_FLUSHED
};

} // namespace Gio

#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{

template <>
class Value<Gio::ConverterResult> : public Glib::Value_Enum<Gio::ConverterResult>
{
public:
  static GType value_type() G_GNUC_CONST;
};

} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */

namespace Gio
{

/** 
 *  @var ConverterFlags CONVERTER_NO_FLAGS
 * No flags.
 * 
 *  @var ConverterFlags CONVERTER_INPUT_AT_END
 * At end of input data.
 * 
 *  @var ConverterFlags CONVERTER_FLUSH
 * Flush data.
 * 
 *  @enum ConverterFlags
 * 
 * Flags used when calling a g_converter_convert().
 * 
 * @newin{2,24}
 *
 * @ingroup giommEnums
 * @par Bitwise operators:
 * <tt>%ConverterFlags operator|(ConverterFlags, ConverterFlags)</tt><br>
 * <tt>%ConverterFlags operator&(ConverterFlags, ConverterFlags)</tt><br>
 * <tt>%ConverterFlags operator^(ConverterFlags, ConverterFlags)</tt><br>
 * <tt>%ConverterFlags operator~(ConverterFlags)</tt><br>
 * <tt>%ConverterFlags& operator|=(ConverterFlags&, ConverterFlags)</tt><br>
 * <tt>%ConverterFlags& operator&=(ConverterFlags&, ConverterFlags)</tt><br>
 * <tt>%ConverterFlags& operator^=(ConverterFlags&, ConverterFlags)</tt><br>
 */
enum ConverterFlags
{
  CONVERTER_NO_FLAGS = 0x0,
  CONVERTER_INPUT_AT_END = (1 << 0),
  CONVERTER_FLUSH = (1 << 1)
};

/** @ingroup giommEnums */
inline ConverterFlags operator|(ConverterFlags lhs, ConverterFlags rhs)
  { return static_cast<ConverterFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }

/** @ingroup giommEnums */
inline ConverterFlags operator&(ConverterFlags lhs, ConverterFlags rhs)
  { return static_cast<ConverterFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }

/** @ingroup giommEnums */
inline ConverterFlags operator^(ConverterFlags lhs, ConverterFlags rhs)
  { return static_cast<ConverterFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }

/** @ingroup giommEnums */
inline ConverterFlags operator~(ConverterFlags flags)
  { return static_cast<ConverterFlags>(~static_cast<unsigned>(flags)); }

/** @ingroup giommEnums */
inline ConverterFlags& operator|=(ConverterFlags& lhs, ConverterFlags rhs)
  { return (lhs = static_cast<ConverterFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }

/** @ingroup giommEnums */
inline ConverterFlags& operator&=(ConverterFlags& lhs, ConverterFlags rhs)
  { return (lhs = static_cast<ConverterFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }

/** @ingroup giommEnums */
inline ConverterFlags& operator^=(ConverterFlags& lhs, ConverterFlags rhs)
  { return (lhs = static_cast<ConverterFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }

} // namespace Gio

#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{

template <>
class Value<Gio::ConverterFlags> : public Glib::Value_Flags<Gio::ConverterFlags>
{
public:
  static GType value_type() G_GNUC_CONST;
};

} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */

namespace Gio
{


/** Converter - Data conversion interface.
 * Converter is implemented by objects that convert binary data in various
 * ways. The conversion can be stateful and may fail at any place.
 *
 * Some example conversions are: character set conversion, compression,
 * decompression and regular expression replace.
 *
 * @newin{2,34}
 */

class Converter : public Glib::Interface
{
  
#ifndef DOXYGEN_SHOULD_SKIP_THIS

public:
  using CppObjectType = Converter;
  using CppClassType = Converter_Class;
  using BaseObjectType = GConverter;
  using BaseClassType = GConverterIface;

  // noncopyable
  Converter(const Converter&) = delete;
  Converter& operator=(const Converter&) = delete;

private:
  friend class Converter_Class;
  static CppClassType converter_class_;

#endif /* DOXYGEN_SHOULD_SKIP_THIS */
protected:
  /**
   * You should derive from this class to use it.
   */
  Converter();

#ifndef DOXYGEN_SHOULD_SKIP_THIS
  /** Called by constructors of derived classes. Provide the result of
   * the Class init() function to ensure that it is properly
   * initialized.
   *
   * @param interface_class The Class object for the derived type.
   */
  explicit Converter(const Glib::Interface_Class& interface_class);

public:
  // This is public so that C++ wrapper instances can be
  // created for C instances of unwrapped types.
  // For instance, if an unexpected C type implements the C interface.
  explicit Converter(GConverter* castitem);

protected:
#endif /* DOXYGEN_SHOULD_SKIP_THIS */

public:

  Converter(Converter&& src) noexcept;
  Converter& operator=(Converter&& src) noexcept;

  ~Converter() noexcept override;

  static void add_interface(GType gtype_implementer);

  /** Get the GType for this class, for use with the underlying GObject type system.
   */
  static GType get_type()      G_GNUC_CONST;

#ifndef DOXYGEN_SHOULD_SKIP_THIS
  static GType get_base_type() G_GNUC_CONST;
#endif

  ///Provides access to the underlying C GObject.
  GConverter*       gobj()       { return reinterpret_cast<GConverter*>(gobject_); }

  ///Provides access to the underlying C GObject.
  const GConverter* gobj() const { return reinterpret_cast<GConverter*>(gobject_); }

private:


public:
  
  /** This is the main operation used when converting data. It is to be called
   * multiple times in a loop, and each time it will do some work, i.e.
   * producing some output (in @a outbuf) or consuming some input (from @a inbuf) or
   * both. If its not possible to do any work an error is returned.
   * 
   * Note that a single call may not consume all input (or any input at all).
   * Also a call may produce output even if given no input, due to state stored
   * in the converter producing output.
   * 
   * If any data was either produced or consumed, and then an error happens, then
   * only the successful conversion is reported and the error is returned on the
   * next call.
   * 
   * A full conversion loop involves calling this method repeatedly, each time
   * giving it new input and space output space. When there is no more input
   * data after the data in @a inbuf, the flag CONVERTER_INPUT_AT_END must be set.
   * The loop will be (unless some error happens) returning CONVERTER_CONVERTED
   * each time until all data is consumed and all output is produced, then
   * CONVERTER_FINISHED is returned instead. Note, that CONVERTER_FINISHED
   * may be returned even if CONVERTER_INPUT_AT_END is not set, for instance
   * in a decompression converter where the end of data is detectable from the
   * data (and there might even be other data after the end of the compressed data).
   * 
   * When some data has successfully been converted @a bytes_read and is set to
   * the number of bytes read from @a inbuf, and @a bytes_written is set to indicate
   * how many bytes was written to @a outbuf. If there are more data to output
   * or consume (i.e. unless the CONVERTER_INPUT_AT_END is specified) then
   * CONVERTER_CONVERTED is returned, and if no more data is to be output
   * then CONVERTER_FINISHED is returned.
   * 
   * On error CONVERTER_ERROR is returned and @a error is set accordingly.
   * Some errors need special handling:
   * 
   * IO_ERROR_NO_SPACE is returned if there is not enough space
   * to write the resulting converted data, the application should
   * call the function again with a larger @a outbuf to continue.
   * 
   * IO_ERROR_PARTIAL_INPUT is returned if there is not enough
   * input to fully determine what the conversion should produce,
   * and the CONVERTER_INPUT_AT_END flag is not set. This happens for
   * example with an incomplete multibyte sequence when converting text,
   * or when a regexp matches up to the end of the input (and may match
   * further input). It may also happen when @a inbuf_size is zero and
   * there is no more data to produce.
   * 
   * When this happens the application should read more input and then
   * call the function again. If further input shows that there is no
   * more data call the function again with the same data but with
   * the CONVERTER_INPUT_AT_END flag set. This may cause the conversion
   * to finish as e.g. in the regexp match case (or, to fail again with
   * IO_ERROR_PARTIAL_INPUT in e.g. a charset conversion where the
   * input is actually partial).
   * 
   * After g_converter_convert() has returned CONVERTER_FINISHED the
   * converter object is in an invalid state where its not allowed
   * to call g_converter_convert() anymore. At this time you can only
   * free the object or call g_converter_reset() to reset it to the
   * initial state.
   * 
   * If the flag CONVERTER_FLUSH is set then conversion is modified
   * to try to write out all internal state to the output. The application
   * has to call the function multiple times with the flag set, and when
   * the available input has been consumed and all internal state has
   * been produced then CONVERTER_FLUSHED (or CONVERTER_FINISHED if
   * really at the end) is returned instead of CONVERTER_CONVERTED.
   * This is somewhat similar to what happens at the end of the input stream,
   * but done in the middle of the data.
   * 
   * This has different meanings for different conversions. For instance
   * in a compression converter it would mean that we flush all the
   * compression state into output such that if you uncompress the
   * compressed data you get back all the input data. Doing this may
   * make the final file larger due to padding though. Another example
   * is a regexp conversion, where if you at the end of the flushed data
   * have a match, but there is also a potential longer match. In the
   * non-flushed case we would ask for more input, but when flushing we
   * treat this as the end of input and do the match.
   * 
   * Flushing is not always possible (like if a charset converter flushes
   * at a partial multibyte sequence). Converters are supposed to try
   * to produce as much output as possible and then return an error
   * (typically IO_ERROR_PARTIAL_INPUT).
   * 
   * @newin{2,24}
   * 
   * @param inbuf The buffer
   * containing the data to convert.
   * @param inbuf_size The number of bytes in @a inbuf.
   * @param outbuf A buffer to write
   * converted data in.
   * @param outbuf_size The number of bytes in @a outbuf, must be at least one.
   * @param flags A ConverterFlags controlling the conversion details.
   * @param bytes_read Will be set to the number of bytes read from @a inbuf on success.
   * @param bytes_written Will be set to the number of bytes written to @a outbuf on success.
   * @return A ConverterResult, CONVERTER_ERROR on error.
   * 
   * @throws Glib::Error
   */
  ConverterResult convert(const void* inbuf, gsize inbuf_size, void* outbuf, gsize outbuf_size, ConverterFlags flags, gsize& bytes_read, gsize& bytes_written);
  
  /** Resets all internal state in the converter, making it behave
   * as if it was just created. If the converter has any internal
   * state that would produce output then that output is lost.
   * 
   * @newin{2,24}
   */
  void reset();

 
  /// @throws Glib::Error.
  virtual ConverterResult convert_vfunc(const void* inbuf, gsize inbuf_size, void* outbuf, gsize outbuf_size, ConverterFlags flags, gsize& bytes_read, gsize& bytes_written);


    virtual void reset_vfunc();


public:

public:
  //C++ methods used to invoke GTK+ virtual functions:

protected:
  //GTK+ Virtual Functions (override these to change behaviour):

  //Default Signal Handlers::


};

} // namespace Gio


namespace Glib
{
  /** A Glib::wrap() method for this object.
   *
   * @param object The C instance.
   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
   * @result A C++ instance that wraps this C instance.
   *
   * @relates Gio::Converter
   */
  Glib::RefPtr<Gio::Converter> wrap(GConverter* object, bool take_copy = false);

} // namespace Glib


#endif /* _GIOMM_CONVERTER_H */

