16#include <zypp-core/zyppng/core/String> 
   20#undef  ZYPP_BASE_LOGGER_LOGGROUP 
   21#define ZYPP_BASE_LOGGER_LOGGROUP "zypp::plugin" 
   38      Impl( 
const std::string & command_r )
 
 
   52      Impl( std::istream & stream_r );
 
   63        if ( command_r.find( 
'\n' ) != std::string::npos )
 
 
   75      { 
_body = std::move(body_r); }
 
 
   77      static std::string 
escapeHeader( std::string_view val, 
bool escapeColon=
true ) {
 
   93        for ( 
auto c = val.begin (); c!= val.end(); c++ ) {
 
   96              escaped.push_back(
'\\');
 
   97              escaped.push_back(
'n');
 
  101              escaped.push_back(
'\\');
 
  102              escaped.push_back(
'r');
 
  106              escaped.push_back(
'\\');
 
  107              escaped.push_back(
'\\');
 
  112                escaped.push_back(
'\\');
 
  113                escaped.push_back(
'c');
 
  119              escaped.push_back (*c);
 
 
  127        std::string unescaped;
 
  128        for ( 
auto c = val.begin (); c!= val.end(); ) {
 
  130            unescaped.push_back (*c);
 
  136          if ( c == val.end() )
 
  141              unescaped.push_back(
'\n');
 
  146              unescaped.push_back(
'\r');
 
  151              unescaped.push_back(
'\\');
 
  156              unescaped.push_back(
':');
 
 
  170      using KeyRange = std::pair<HeaderList::iterator, HeaderList::iterator>;
 
  178      const std::string & 
getHeader( 
const std::string & key_r )
 const 
  181        if ( r.first == r.second )
 
  183        const std::string & ret( r.first->second );
 
  184        if ( ++r.first != r.second )
 
 
  189      const std::string & 
getHeader( 
const std::string & key_r, 
const std::string & default_r )
 const 
  192        if ( r.first == r.second )
 
  194        const std::string & ret( r.first->second );
 
  195        if ( ++r.first != r.second )
 
 
  200      const std::string & 
getHeaderNT( 
const std::string & key_r, 
const std::string & default_r )
 const 
  203        return iter != 
_header.end() ? iter->second : default_r;
 
 
  206      HeaderList::value_type 
mkHeaderPair( 
const std::string & key_r, 
const std::string & value_r )
 
  208        return HeaderList::value_type( key_r, value_r );
 
 
  211      void setHeader( 
const std::string & key_r, 
const std::string & value_r )
 
 
  217      void addHeader( 
const std::string & key_r, 
const std::string & value_r )
 
 
  224        for ( 
const auto & el : contents_r )
 
 
  230        std::string::size_type sep( data.find( 
':') );
 
  231        if ( sep ==  std::string::npos )
 
 
  243      std::ostream & 
writeTo( std::ostream & stream_r ) 
const;
 
  261      { 
return new Impl( *
this ); }
 
 
 
  268    return str << 
"PluginFrame[" << obj.
command() << 
"](" << obj.
headerList().size() << 
"){" << obj.
body().size() << 
"}";
 
 
  289    if ( ! stream_r.good() )
 
  295      if ( ! stream_r.good() )
 
  307    std::optional<uint64_t> cLen;
 
  310      if ( !contentLen.empty() ) {
 
  325      _body.resize ( (*cLen)+1, 
'\0' );
 
  326      stream_r.read ( 
_body.data(), (*cLen)+1 );
 
  328      if ( ! stream_r.good() )
 
  330      if ( 
_body.back() != 
'\0' )
 
  338      if ( ! stream_r.good() )
 
 
  386    static std::string _val( 
"ACK" );
 
 
  392    static std::string _val( 
"ERROR" );
 
 
  398    static std::string _val( 
"_ENOMETHOD" );
 
 
  404    static std::string _val(
"content-length");
 
 
  429    : 
_pimpl( new 
Impl( command_r, 
std::move(body_r), contents_r ) )
 
 
  437  { 
return _pimpl->empty(); }
 
 
  440  { 
return _pimpl->command(); }
 
 
  443  { 
_pimpl->setCommand( command_r ); }
 
 
  446  { 
return _pimpl->body(); }
 
 
  449  { 
return _pimpl->bodyRef(); }
 
 
  458  { 
_pimpl->setBody( std::move(body_r) ); }
 
 
  461  { 
return _pimpl->writeTo( stream_r ); }
 
 
  464  { 
return _pimpl->headerList(); }
 
 
  467  { 
return _pimpl->headerList(); }
 
 
  470  { 
return _pimpl->getHeader( key_r ); }
 
 
  473  { 
return _pimpl->getHeader( key_r, default_r ); }
 
 
  476  { 
return _pimpl->getHeaderNT( key_r, default_r ); }
 
 
  479  { 
_pimpl->setHeader( key_r, value_r ); }
 
 
  482  { 
_pimpl->addHeader( key_r, value_r ); }
 
 
  485  { 
_pimpl->addHeader( contents_r ); }
 
 
  489    _pimpl->addRawHeader( header.asStringView() );
 
 
  493  { 
_pimpl->clearHeader( key_r ); }
 
 
Base class for PluginFrame Exception.
static const std::string & ackCommand()
"ACK" command.
ByteArray & bodyRef()
Return a reference to the frame body.
void setCommand(const std::string &command_r)
Set the frame command.
HeaderList::const_iterator HeaderListIterator
Header list iterator.
void setBody(const std::string &body_r)
Set the frame body.
const std::initializer_list< std::pair< std::string, std::string > > & HeaderInitializerList
PluginFrame()
Default ctor (empty frame)
void clearHeader(const std::string &key_r)
Remove all headers for key_r.
static const std::string & contentLengthHeader()
"content-lenght" header name
bool empty() const
Whether this is an empty frame.
const ByteArray & body() const
Return the frame body.
static const std::string & enomethodCommand()
"_ENOMETHOD" command.
const std::string & command() const
Return the frame command.
void addHeader(const std::string &key_r, const std::string &value_r=std::string())
Add header for key_r leaving already existing headers for key_r unchanged.
RWCOW_pointer< Impl > _pimpl
Pointer to implementation.
static const std::string & errorCommand()
"ERROR" command.
const std::string & getHeader(const std::string &key_r) const
Return header value for key_r.
std::multimap< std::string, std::string > HeaderList
The header list.
HeaderList & headerList()
Modifyalble header list for internal use only.
void addRawHeader(const ByteArray &header)
void setHeader(const std::string &key_r, const std::string &value_r=std::string())
Set header for key_r removing all other occurrences of key_r.
const std::string & getHeaderNT(const std::string &key_r, const std::string &default_r=std::string()) const
Not throwing version returing one of the matching header values or default_r string.
std::ostream & writeTo(std::ostream &stream_r) const
Write frame to stream.
String related utilities and Regular expression matching.
std::string numstring(char n, int w=0)
std::string receiveUpTo(std::istream &str, const char delim_r, bool returnDelim_r)
Return stream content up to the next ocurrence of delim_r or EOF delim_r, if found,...
std::string getline(std::istream &str, const Trim trim_r)
Return stream content up to (but not returning) the next newline.
Easy-to use interface to the ZYPP dependency resolver.
bool operator==(const SetRelation::Enum &lhs, const SetCompare &rhs)
This is an overloaded member function, provided for convenience. It differs from the above function o...
std::ostream & operator<<(std::ostream &str, const SerialNumber &obj)
std::optional< T > safe_strtonum(const std::string_view &val)
PluginFrame implementation.
std::ostream & writeTo(std::ostream &stream_r) const
void setCommand(const std::string &command_r)
Impl(const std::string &command_r, HeaderInitializerList contents_r)
const std::string & getHeader(const std::string &key_r) const
static shared_ptr< Impl > nullimpl()
Offer default Impl.
const std::string & command() const
const std::string & getHeaderNT(const std::string &key_r, const std::string &default_r) const
Impl(const std::string &command_r, ByteArray &&body_r)
HeaderList & headerList()
friend Impl * rwcowClone(const Impl *rhs)
static std::string unescapeHeader(std::string_view val)
Impl(const std::string &command_r)
const HeaderList & headerList() const
std::pair< HeaderListIterator, HeaderListIterator > constKeyRange
const std::string & getHeader(const std::string &key_r, const std::string &default_r) const
void setHeader(const std::string &key_r, const std::string &value_r)
void clearHeader(const std::string &key_r)
void addHeader(const std::string &key_r, const std::string &value_r)
static std::string escapeHeader(std::string_view val, bool escapeColon=true)
std::pair< HeaderList::iterator, HeaderList::iterator > KeyRange
Impl * clone() const
clone for RWCOW_pointer
void addRawHeader(const std::string_view data)
void addHeader(HeaderInitializerList contents_r)
HeaderList::value_type mkHeaderPair(const std::string &key_r, const std::string &value_r)
void setBody(ByteArray &&body_r)
std::ostream & operator<<(std::ostream &str, const PluginFrame::Impl &obj)
Stream output.
Impl(const std::string &command_r, ByteArray &&body_r, HeaderInitializerList contents_r)
const ByteArray & body() const
#define for_(IT, BEG, END)
Convenient for-loops using iterator.
#define ZYPP_THROW(EXCPT)
Drops a logline and throws the Exception.