Slic3r::AvrDude Class Reference

#include <src/avrdude/avrdude-slic3r.hpp>

Collaboration diagram for Slic3r::AvrDude:

Classes
struct	priv

Public Types
enum	{ EXIT_SUCCEESS = 0 , EXIT_EXCEPTION = -1000 }
typedef std::shared_ptr< AvrDude >	Ptr
typedef std::function< void(Ptr)>	RunFn
typedef std::function< void(const char *, unsigned)>	MessageFn
typedef std::function< void(const char *, unsigned)>	ProgressFn
typedef std::function< void()>	CompleteFn

Public Member Functions
	AvrDude ()
	AvrDude (AvrDude &&)
	AvrDude (const AvrDude &)=delete
AvrDude &	operator= (AvrDude &&)=delete
AvrDude &	operator= (const AvrDude &)=delete
	~AvrDude ()
AvrDude &	push_args (std::vector< std::string > args)
AvrDude &	on_run (RunFn fn)
AvrDude &	on_message (MessageFn fn)
AvrDude &	on_progress (ProgressFn fn)
AvrDude &	on_complete (CompleteFn fn)
int	run_sync ()
Ptr	run ()
void	cancel ()
void	join ()
bool	cancelled ()
int	exit_code ()
size_t	last_args_set ()

Private Attributes
std::unique_ptr< priv >	p

Detailed Description

Member Typedef Documentation

CompleteFn

typedef std::function<void()> Slic3r::AvrDude::CompleteFn

MessageFn

typedef std::function<void(const char * , unsigned )> Slic3r::AvrDude::MessageFn

ProgressFn

typedef std::function<void(const char * , unsigned )> Slic3r::AvrDude::ProgressFn

Ptr

typedef std::shared_ptr<AvrDude> Slic3r::AvrDude::Ptr

RunFn

typedef std::function<void(Ptr )> Slic3r::AvrDude::RunFn

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
EXIT_SUCCEESS
EXIT_EXCEPTION

       {
    EXIT_SUCCEESS   = 0,
    EXIT_EXCEPTION  = -1000,
  };

Constructor & Destructor Documentation

AvrDude() [1/3]

Slic3r::AvrDude::AvrDude

(

)

: p(new priv()) {}

AvrDude() [2/3]

Slic3r::AvrDude::AvrDude

(

AvrDude &&

other

)

: p(std::move(other.p)) {}

AvrDude() [3/3]

Slic3r::AvrDude::AvrDude ( const AvrDude &  )

delete

~AvrDude()

Slic3r::AvrDude::~AvrDude

(

)

{
  if (p && p->avrdude_thread.joinable()) {
    p->avrdude_thread.detach();
  }
}

References p.

Member Function Documentation

cancel()

void Slic3r::AvrDude::cancel

(

)

{
  if (p) {
    p->cancelled = true;
    ::avrdude_cancel();
  }
}

References avrdude_cancel(), and p.

Here is the call graph for this function:

cancelled()

bool Slic3r::AvrDude::cancelled

(

)

{
  return p ? p->cancelled : false;
}

References p.

exit_code()

int Slic3r::AvrDude::exit_code

(

)

{
  return p ? p->exit_code : 0;
}

References p.

join()

void Slic3r::AvrDude::join

(

)

{
  if (p && p->avrdude_thread.joinable()) {
    p->avrdude_thread.join();
  }
}

References p.

last_args_set()

size_t Slic3r::AvrDude::last_args_set

(

)

{
  return p ? p->current_args_set : 0;
}

References p.

on_complete()

AvrDude & Slic3r::AvrDude::on_complete

(

CompleteFn

fn

)

{
  if (p) { p->complete_fn = std::move(fn); }
  return *this;
}

References p.

on_message()

AvrDude & Slic3r::AvrDude::on_message

(

MessageFn

fn

)

{
  if (p) { p->message_fn = std::move(fn); }
  return *this;
}

References p.

on_progress()

AvrDude & Slic3r::AvrDude::on_progress

(

ProgressFn

fn

)

{
  if (p) { p->progress_fn = std::move(fn); }
  return *this;
}

References p.

on_run()

AvrDude & Slic3r::AvrDude::on_run

(

RunFn

fn

)

{
  if (p) { p->run_fn = std::move(fn); }
  return *this;
}

References p.

Referenced by Slic3r::FirmwareDialog::priv::perform_upload().

Here is the caller graph for this function:

operator=() [1/2]

AvrDude & Slic3r::AvrDude::operator= ( AvrDude &&  )

delete

operator=() [2/2]

AvrDude & Slic3r::AvrDude::operator= ( const AvrDude &  )

delete

push_args()

AvrDude & Slic3r::AvrDude::push_args

(

std::vector< std::string >

args

)

{
  if (p) { p->args.push_back(std::move(args)); }
  return *this;
}

References p.

run()

AvrDude::Ptr Slic3r::AvrDude::run

(

)

{
  auto self = std::make_shared<AvrDude>(std::move(*this));
 
  if (self->p) {
    auto avrdude_thread = std::thread([self]() {
      try {
        if (self->p->run_fn) {
          self->p->run_fn(self);
        }
 
        if (! self->p->cancelled) {
          self->p->exit_code = self->p->run();
        }
 
        if (self->p->complete_fn) {
          self->p->complete_fn();
        }
      } catch (const std::exception &ex) {
        self->p->exit_code = EXIT_EXCEPTION;
 
        static const char *msg = "An exception was thrown in the background thread:\n";
 
        const char *what = ex.what();
        auto &message_fn = self->p->message_fn;
        if (message_fn) {
          message_fn(msg, sizeof(msg));
          message_fn(what, (unsigned)std::strlen(what));
          message_fn("\n", 1);
        }
 
        if (self->p->complete_fn) {
          self->p->complete_fn();
        }
      }
    });
 
    self->p->avrdude_thread = std::move(avrdude_thread);
  }
 
  return self;
}

References EXIT_EXCEPTION, and if().

Here is the call graph for this function:

run_sync()

int Slic3r::AvrDude::run_sync

(

)

{
  return p ? p->run() : -1;
}

References p.

Member Data Documentation

p

std::unique_ptr<priv> Slic3r::AvrDude::p

private

Referenced by ~AvrDude(), cancel(), cancelled(), exit_code(), join(), last_args_set(), on_complete(), on_message(), on_progress(), on_run(), push_args(), and run_sync().

---

The documentation for this class was generated from the following files:

• src/avrdude/avrdude-slic3r.hpp
• src/avrdude/avrdude-slic3r.cpp