ws/types.h

Go to the documentation of this file.

/*
 * Copyright 2006-2009 Savarese Software Research Corporation
 *
 * Licensed 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
 *
 *     https://www.savarese.com/software/ApacheLicense-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 __SSRC_WSPR_WS_TYPES_H
#define __SSRC_WSPR_WS_TYPES_H

#include <ssrc/wispers/ws/protocol.h>
#include <boost/regex.hpp>
#include <boost/ptr_container/ptr_vector.hpp>

__BEGIN_NS_SSRC_WSPR_WS

typedef
boost::function<void (const WebServiceCall &,
                      const NS_SSRC_WISP_PROTOCOL::MessageInfo &)>
call_handler_type;

typedef std::unordered_map<string, call_handler_type> call_handler_map;

struct CallParameter {
  /*
    enum ParameterType {
    Nil           = LUA_TNIL,
    Boolean       = LUA_TBOOLEAN,
    LightUserData = LUA_TLIGHTUSERDATA,
    Number        = LUA_TNUMBER,
    String        = LUA_TSTRING,
    Table         = LUA_TTABLE,
    Function      = LUA_TFUNCTION,
    UserData      = LUA_TUSERDATA,
    Thread        = LUA_TTHREAD
    };

    parameter_type type;
  */
  const bool multi_value;
  const bool optional;
  const unsigned int min_size;
  const unsigned int max_size;
  const string name;

  CallParameter(const string & name,
                const unsigned int min_size = 1,
                const unsigned int max_size = 128,
                const bool multi_value = false,
                const bool optional = false) :
    multi_value(multi_value), optional(optional),
    min_size(min_size), max_size(max_size), name(name)
  { }

  inline virtual bool validate(const string & value) const {
    return (value.size() >= min_size && value.size() <= max_size);
  }
};

struct PatternParameter : public CallParameter {
  typedef CallParameter super;
  const boost::regex pattern;

  PatternParameter(const string & name,
                   const string & pattern,
                   const unsigned int min_size = 1,
                   const unsigned int max_size = 128,
                   const bool multi_value = false,
                   const bool optional = false) :
    super(name, min_size, max_size, multi_value, optional),
    pattern(pattern)
  { }

  inline virtual bool validate(const string & value) const {
    return (super::validate(value) && boost::regex_match(value, pattern));
  }
};

typedef boost::ptr_vector<CallParameter> parameter_sequence;

__END_NS_SSRC_WSPR_WS

#endif