arg_list.h

//
// Copyright (c) 2014 Limit Point Systems, Inc.
//
// 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
//
//   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.
//

// Interface for class arg_list

#ifndef ARG_LIST_H
#define ARG_LIST_H

#ifndef SHEAF_DLL_SPEC_H
#include "SheafSystem/sheaf_dll_spec.h"
#endif

#ifndef BLOCK_H
#include "SheafSystem/block.h"
#endif

#ifndef PRIMITIVE_VALUE_H
#include "SheafSystem/primitive_value.h"
#endif

namespace sheaf
{

// Forward declarations to enable friend declaration.

class arg_list;
class namespace_poset;
class poset_path;
class schema_poset_member;

SHEAF_DLL_SPEC std::ostream& operator << (std::ostream &os, const arg_list& p);

SHEAF_DLL_SPEC std::istream& operator >> (std::istream &is, arg_list& p);

class SHEAF_DLL_SPEC arg_list
{

  friend SHEAF_DLL_SPEC std::ostream& operator << (std::ostream &os, const arg_list& xf);
  friend SHEAF_DLL_SPEC std::istream& operator >> (std::istream &is, arg_list& xf);

public:

  // The following must be public to support stream insertion operator.

  struct SHEAF_DLL_SPEC arg_type
  {
    std::string name;

    primitive_type type() const
    {
      return value.id();
    };

    void put_type(primitive_type xid)
    {
      value.id() = xid;
    };

    void put_type(int xid);

    primitive_value value;

    arg_type() {} ;

    arg_type(const std::string& xname)
        : name(xname)
    {} ;

    arg_type(const char* xname)
        : name(xname)
    {};

    bool operator==(const arg_type& xother) const
    {
      return (name == xother.name) && (value == xother.value);
    };

    bool empty() const
    {
      return name.empty();
    };


  };

  arg_list();

  arg_list(const arg_list& xinput);

  arg_list(const arg_type& xarg);

  arg_list(const char* xarg_name);

  unsigned int ct() const;

  bool empty() const;

  int index(const std::string& xname) const;

  const std::string& name(int xi) const;

  int type(int xi) const;
  //  const int& type(int xi) const;

  int type(const std::string& xname) const;
  //  const int& type(const string& xname) const;

  primitive_value& value(int xi);

  const primitive_value& value(int xi) const;

  primitive_value& value(const std::string& xname);

  const primitive_value& value(const std::string& xname) const;

//   ///
//   /// Insert another arg_list.
//   ///
//   arg_list& operator<<(const arg_list& xinput);

  arg_list& operator+=(const arg_list& xother);

  arg_list& operator<<(const primitive_value& xinput);

  bool parsing_name() const;

  bool parsing_value() const;

  bool parsing_error() const;

  bool conforms_to(const namespace_poset& xns,
                   const poset_path& xschema_path,
                   bool xuse_table_schema,
                   bool xauto_access) const;
  bool conforms_to(const schema_poset_member& xschema,
                   bool xuse_table_schema,
                   bool xauto_access) const;


  bool conforms_to_extension(const namespace_poset& xns,
                             const poset_path& xschema_path,
                             const poset_path& xstd_schema_path,
                             bool xuse_table_schema,
                             bool xauto_access) const;

  bool conforms_to_extension(const schema_poset_member& xschema,
                             const schema_poset_member& xstd_schema,
                             bool xuse_table_schema,
                             bool xauto_access) const;

  void clear();

  arg_type& arg(int xi);

  const arg_type& arg(int xi) const;

  bool contains_arg(const std::string& xname) const;

  bool contains_args(const arg_list& xother) const;

  arg_type& arg(const std::string& xname);

  const arg_type& arg(const std::string& xname) const;

  arg_type& back();

  const arg_type& back() const;

  //*
  // Put xarg at the back of the list.
  //*/
  void push_back(const arg_type& xarg);


private:

  block<arg_type> _args;

  enum parse_state_type {GET_NAME, GET_VALUE, ERROR};

  parse_state_type _parse_state;

  bool arg_conforms_to(const schema_poset_member& xschema) const;


};

// ===========================================================
// NON-MEMBER FUNCTIONS
// ===========================================================

SHEAF_DLL_SPEC
std::ostream& operator << (std::ostream &os, const arg_list::arg_type& p);

SHEAF_DLL_SPEC
std::istream& operator >> (std::istream &os, arg_list::arg_type& p);

size_t
SHEAF_DLL_SPEC
deep_size(const arg_list::arg_type& xtype, bool xinclude_shallow = true);


} // namespace sheaf

#endif // ifndef ARG_LIST_H