CompatCodec.hpp

Go to the documentation of this file.

// ANNA - Anna is Not Nothingness Anymore                                                         //
//                                                                                                //
// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
//                                                                                                //
// See project site at http://redmine.teslayout.com/projects/anna-suite                           //
// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //


#ifndef anna_comm_CompatCodec_hpp
#define anna_comm_CompatCodec_hpp

#include <map>

#include <anna/core/DataBlock.hpp>
#include <anna/core/RuntimeException.hpp>
#include <anna/core/util/SortedVector.hpp>

#include <anna/comm/Message.hpp>
#include <anna/comm/Variable.hpp>

namespace anna {

class DataBlock;
class Second;
class Millisecond;
class Microsecond;

namespace comm {

class CompatCodec : public Message {
  struct SortById {
    static short int value(const comm::Variable* variable) {
      return variable->getId();
    }
  };

  class VariableContainer {
  public:
    typedef comm::Variable* type_pointer;

    typedef type_pointer* iterator;
    typedef const type_pointer* const_iterator;

    VariableContainer();

    void clear() ;
    void add(comm::Variable* variable) ;
    comm::Variable* find(const int id) ;
    const comm::Variable* find(const int id) const ;

    int size() const { return a_size; }

    iterator begin() { return a_variables; }
    iterator end() { return a_variables + a_size; }

    const_iterator begin() const { return a_variables; }
    const_iterator end() const { return a_variables + a_size; }

    static comm::Variable* data(iterator ii) { return *ii; }
    static const comm::Variable* data(const_iterator ii) { return *ii; }

  private:
    comm::Variable** a_variables;
    int a_maxSize;
    int a_size;
  };

public:
//   typedef SortedVector <comm::Variable, SortById, short int> container;
  typedef VariableContainer container;
  typedef container::iterator iterator;
  typedef container::const_iterator const_iterator;
  typedef unsigned char Type;

  explicit CompatCodec(const Type type, const bool scramble = true);

  virtual ~CompatCodec();

  // Accesores
  Type getType() const { return a_type; }

// Metodos
  const Variable* attach(const char* name, const short int id, std::string& value) noexcept(false);

  const Variable* attach(const char* name, const short int id, const char*& value) noexcept(false);

  const Variable* attach(const char* name, const short int id, int& value) noexcept(false);

  const Variable* attach(const char* name, const short int id, S64& value) noexcept(false);

  const Variable* attach(const char* name, const short int id, bool& value) noexcept(false);

  const Variable* attach(const char* name, const short int id, DataBlock& value) noexcept(false);

  const Variable* attach(const char* name, const short int id, float& value) noexcept(false);

  const Variable* attach(const char* name, const short int id, double& value) noexcept(false);

  const Variable* attach(const char* name, const short int id, Second& value) noexcept(false);
  const Variable* attach(const char* name, const short int id, Millisecond& value) noexcept(false);
  const Variable* attach(const char* name, const short int id, Microsecond& value) noexcept(false);

  const Variable* attach(const char* name, const short int id, comm::CompatCodec& value) noexcept(false);

  const Variable& find(const short int id) const noexcept(false);

  void setNull(const short int id, const bool isNull = true) noexcept(false);

  void setNull(const Variable* variable, const bool isNull = true) ;

  bool isNull(const short int id) const noexcept(false);

  iterator begin() { return a_variables.begin(); }

  const_iterator begin() const { return a_variables.begin(); }

  iterator end() { return a_variables.end(); }

  const_iterator end() const { return a_variables.end(); }

  int size() const { return a_variables.size(); }

  static Variable* variable(iterator ii) { return container::data(ii); }

  static const Variable* variable(const_iterator ii) { return container::data(ii); }

  virtual const DataBlock& code() noexcept(false);

  virtual void decode(const DataBlock& dataBlock) noexcept(false);

  static Type getType(const DataBlock& dataBlock) noexcept(false);

protected:
  bool a_scramble;

private:
  const Type a_type;
  container a_variables;
  int a_nullCounter;

  static bool st_initScramble;

  CompatCodec(const CompatCodec&);
  CompatCodec& operator = (const CompatCodec&);

  void normalDecode(const char* data, const int size, const int maxdata) noexcept(false);
  bool optimizedDecode(const char* data, const int size) noexcept(false);
};

}
}

#endif