poset_path.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 poset_path

#ifndef POSET_PATH_H
#define POSET_PATH_H

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

#ifndef STD_IOSTREAM_H
#include "SheafSystem/std_iostream.h"
#endif

#ifndef STD_STRING_H
#include "SheafSystem/std_string.h"
#endif


namespace sheaf
{
 
  class namespace_poset;
  class primitive_value;
  
 
class SHEAF_DLL_SPEC poset_path
{

public:

  poset_path();

  poset_path(const poset_path& xposet_path);

  poset_path(const std::string& xposet_name, const std::string& xmember_name);

  ~poset_path();

  poset_path(const std::string& xpath);

  poset_path(const char* xpath);

  poset_path(const primitive_value& xpath);

  operator primitive_value() const;

  poset_path& operator=(const poset_path& xposet_path);

  poset_path& operator=(const std::string& xpath);

  poset_path& operator=(const char* cpath);

  poset_path& operator=(const primitive_value& xpath);

  bool empty() const;

  bool full() const;

  static bool is_valid_name(const std::string& xname);

  static bool is_valid_path(const std::string& xpath);

  bool operator==(const poset_path& xother) const;

  bool operator==(const std::string& xother) const;

  bool operator==(const char* xother) const;

  std::string path() const;

  std::string poset_name() const;

  void put_poset_name(const std::string& xname);

  std::string member_name() const;

  void put_member_name(const std::string& xname);

  static const std::string& name_legal_characters();

  static char delimiter();

  static const std::string& path_legal_characters();

  static std::string poset_name(const std::string& xpath);

  static std::string delimiter(const std::string& xpath);

  static std::string member_name(const std::string& xpath);

  void to_stream(std::ostream& xos = std::cout) const;

  static std::string make_name(const std::string& xprefix, int xindex, const std::string& xsuffix);

  static std::string make_reserved_name(const std::string& xprefix, const size_t& xindex, const std::string& xsuffix);

  static std::string block_name(const size_t& xindex);

  static std::string block_name(const std::string& xneighborhood_name);

  static std::string block_neighborhood_name(const size_t& xindex);

  static std::string block_neighborhood_name(const std::string& xblock_name);

  static size_t block_id(const std::string& xname);

  static std::string reserved_prefix();

  static std::string boundary_prefix();

  static std::string boundary_name(const std::string& xmbr_name);

  static std::string block_prefix();

  static std::string neighborhood_prefix();

  namespace_poset* current_namespace() const;

  bool state_exists(bool xauto_access) const;

  bool poset_exists(bool xauto_access) const;

  bool member_exists(bool xauto_access) const;

  bool state_is_read_accessible(bool xauto_access) const;

  bool state_is_read_write_accessible(bool xauto_access) const;

  bool conforms_to(const poset_path& xother, bool xauto_access) const;

  bool conforms_to(const namespace_poset& xns, const poset_path& xother, bool xauto_access) const;


private:

  std::string _poset_name;

  std::string _member_name;

//   ///
//   /// True if xname contains only path legal characters.
//   ///
//   static bool contains_legal_characters(const std::string& xname, const std::string& xlegal_chars);

  static void parse_path(const std::string& xpath, 
                         std::string& xposet_name, 
                         std::string& xdelimiter, 
                         std::string& xmember_name);


};

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

SHEAF_DLL_SPEC
std::ostream & operator << (std::ostream& os, const poset_path& pp);

SHEAF_DLL_SPEC
bool operator==(const poset_path& xpath, const primitive_value& xprim);

SHEAF_DLL_SPEC
bool operator==(const primitive_value& xprim, const poset_path& xpath);

size_t
SHEAF_DLL_SPEC
deep_size(const poset_path& xpath, bool xinclude_shallow = true);
 
 
} // namespace sheaf

#endif // ifndef POSET_PATH_H