TVirtualTransport.h

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you 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.
 */

#ifndef _SANDESH_TRANSPORT_TVIRTUALTRANSPORT_H_
#define _SANDESH_TRANSPORT_TVIRTUALTRANSPORT_H_ 1

#include <sandesh/transport/TTransport.h>

namespace contrail { namespace sandesh { namespace transport {


class TTransportDefaults : public TTransport {
 public:
  /*
   * TTransport *_virt() methods provide reasonable default implementations.
   * Invoke them non-virtually.
   */
  uint32_t read(uint8_t* buf, uint32_t len) {
    return this->TTransport::read_virt(buf, len);
  }
  uint32_t readAll(uint8_t* buf, uint32_t len) {
    return this->TTransport::readAll_virt(buf, len);
  }
  int write(const uint8_t* buf, uint32_t len) {
    return this->TTransport::write_virt(buf, len);
  }
  const uint8_t* borrow(uint8_t* buf, uint32_t* len) {
    return this->TTransport::borrow_virt(buf, len);
  }
  void consume(uint32_t len) {
    this->TTransport::consume_virt(len);
  }

 protected:
  TTransportDefaults() {}
};

template <class Transport_, class Super_=TTransportDefaults>
class TVirtualTransport : public Super_ {
 public:
  /*
   * Implementations of the *_virt() functions, to call the subclass's
   * non-virtual implementation function.
   */
  virtual int32_t read_virt(uint8_t* buf, uint32_t len) {
    return static_cast<Transport_*>(this)->read(buf, len);
  }

  virtual int32_t readAll_virt(uint8_t* buf, uint32_t len) {
    return static_cast<Transport_*>(this)->readAll(buf, len);
  }

  virtual int write_virt(const uint8_t* buf, uint32_t len) {
    return static_cast<Transport_*>(this)->write(buf, len);
  }

  virtual const uint8_t* borrow_virt(uint8_t* buf, uint32_t* len) {
    return static_cast<Transport_*>(this)->borrow(buf, len);
  }

  virtual void consume_virt(uint32_t len) {
    static_cast<Transport_*>(this)->consume(len);
  }

  /*
   * Provide a default readAll() implementation that invokes
   * read() non-virtually.
   *
   * Note: subclasses that use TVirtualTransport to derive from another
   * transport implementation (i.e., not TTransportDefaults) should beware that
   * this may override any non-default readAll() implementation provided by
   * the parent transport class.  They may need to redefine readAll() to call
   * the correct parent implementation, if desired.
   */
  uint32_t readAll(uint8_t* buf, uint32_t len) {
    Transport_* trans = static_cast<Transport_*>(this);
    return ::contrail::sandesh::transport::readAll(*trans, buf, len);
  }

 protected:
  TVirtualTransport() {}

  /*
   * Templatized constructors, to allow arguments to be passed to the Super_
   * constructor.  Currently we only support 0, 1, or 2 arguments, but
   * additional versions can be added as needed.
   */
  template <typename Arg_>
  TVirtualTransport(Arg_ const& arg) : Super_(arg) { }

  template <typename Arg1_, typename Arg2_>
  TVirtualTransport(Arg1_ const& a1, Arg2_ const& a2) : Super_(a1, a2) { }
};

}}} // contrail::sandesh::transport

#endif // #ifndef _SANDESH_TRANSPORT_TVIRTUALTRANSPORT_H_