#include "tensorflow/cc/experimental/libtf/impl/string.h"

#include <unordered_set>

// It is important for the container below to not invalidate pointers to
// elements when elements are inserted, because the String class stores such
// pointers. This rules out, for example, absl::flat_hash_set.
using StringTable = std::unordered_set<std::string>;

namespace tf {
namespace libtf {
namespace impl {

package org.gradle.kotlin.dsl.fixtures


fun <T> Iterable<T>.joinLines(transform: (T) -> String) =

	if err != nil {
		return nil, fmt.Errorf("fail to read string table: %v", err)
	}
	return StringTable(buf), nil
}

// TODO(brainman): decide if start parameter should be int instead of uint32

// String extracts string from COFF string table st at offset start.
func (st StringTable) String(start uint32) (string, error) {
	// start includes 4 bytes of string table length
	if start < 4 {

	case v == "*":
		return StringMatcherRegex(".+")
	case strings.HasPrefix(v, "*"):
		if prefix == "" {
			return StringMatcherSuffix(strings.TrimPrefix(v, "*"), false)
		}
		return StringMatcherRegex(prefix + ".*" + strings.TrimPrefix(v, "*"))
	case strings.HasSuffix(v, "*"):
		return StringMatcherPrefix(prefix+strings.TrimSuffix(v, "*"), false)
	default:
		return StringMatcherExact(prefix+v, false)
	}

	Run:      run,
}

// describe returns a string describing the type typ contained within the type
// set of inType. If non-empty, inName is used as the name of inType (this is
// necessary so that we can use alias type names that may not be reachable from
// inType itself).
func describe(typ, inType types.Type, inName string) string {
	name := inName
	if typ != inType {
		name = typeName(typ)
	}

   */
  explicit String(const char* s);

  String() : String("") {}
  String(const String& s) : value_(s.value_) {}

  // This is the same as the default equality operator, which works because
  // we're interning all strings. It is specified here so we are explicit about
  // it. We're not saying "= default;" because we can't use C++20 features yet.
  bool operator==(const String& other) const { return value_ == other.value_; }

// addStrings takes a batch whose first byte is an EvStrings event
// (indicating that the batch contains only strings) and adds each
// string contained therein to the provided strings map.
func addStrings(stringTable *dataTable[stringID, string], b batch) error {
	if !b.isStringsBatch() {
		return fmt.Errorf("internal error: addStrings called on non-string batch")
	}
	r := bytes.NewReader(b.data)
	hdr, err := r.ReadByte() // Consume the EvStrings byte.

	v := 'x'
	c = string(v)
	if c != "x" {
		panic("create int " + c)
	}

	/* create string with byte array */
	var z1 [3]byte
	z1[0] = 'a'
	z1[1] = 'b'
	z1[2] = 'c'
	c = string(z1[0:])
	if c != "abc" {
		panic("create byte array " + c)
	}

	/* create string with int array */
	var z2 [3]rune
	z2[0] = 'a'
	z2[1] = '\u1234'
	z2[2] = 'c'
	c = string(z2[0:])
	if c != "a\u1234c" {

*/

package sets

// String is a set of strings, implemented via map[string]struct{} for minimal memory consumption.
//
// Deprecated: use generic Set instead.
// new ways:
// s1 := Set[string]{}
// s2 := New[string]()
type String map[string]Empty

// NewString creates a String from a list of values.
func NewString(items ...string) String {
	return String(New[string](items...))
}

#endif

  // Compares two C strings.  Returns true iff they have the same content.
  //
  // Unlike strcmp(), this function can handle NULL argument(s).  A
  // NULL C string is considered different to any non-NULL C string,
  // including the empty string.
  static bool CStringEquals(const char* lhs, const char* rhs);

  // Converts a wide C string to a String using the UTF-8 encoding.